xlifepp – Functions – H#

hankelH1#

inline complex_t xlifepp::hankelH1(const complex_t &z, real_t N)#: Hankel function of the first kind and order N: H1_N(z) = J_N(z) + i Y_N(z) (complex case)

template<> inline complex_t xlifepp::hankelH1(real_t x, real_t N)#: Hankel function of the first kind and real order N: H1_N(x) = J_N(x) + i Y_N(x)

template<class T_> complex_t xlifepp::hankelH1(real_t x, T_ N)#

hankelH10#

inline complex_t xlifepp::hankelH10(const complex_t &z)#: Hankel function of the first kind and order 0 : H1_0(z) = J_0(z) + i Y_0(z) (complex case)

complex_t xlifepp::hankelH10(real_t x)#: Hankel function of the first kind and order 0 : H1_0(x) = J_0(x) + i Y_0(x)

hankelH10N#

std::vector<complex_t> xlifepp::hankelH10N(real_t x, number_t N)#: Hankel functions of the first kind and order 0 … N: H1_k(x) = J_k(x) + i Y_k(x)

hankelH11#

inline complex_t xlifepp::hankelH11(const complex_t &z)#: Hankel function of the first kind and order 1 : H1_1(z) = J_1(z) + i Y_1(z) (complex case)

complex_t xlifepp::hankelH11(real_t x)#: Hankel function of the first kind and order 1 : H1_1(x) = J_1(x) + i Y_1(x)

hankelH2#

inline complex_t xlifepp::hankelH2(const complex_t &z, real_t N)#: Hankel function of the second kind and order N: H2_N(z) = J_N(z) - i Y_N(z) (complex case)

template<> inline complex_t xlifepp::hankelH2(real_t x, real_t N)#: Hankel function of the second kind and real order N: H2_N(x) = J_N(x) - i Y_N(x)

template<class T_> complex_t xlifepp::hankelH2(real_t x, T_ N)#

hankelH20#

inline complex_t xlifepp::hankelH20(const complex_t &z)#: Hankel function of the second kind and order 0 : H2_0(z) = J_0(z) + i Y_0(z) (complex case)

inline complex_t xlifepp::hankelH20(real_t x)#: Hankel function of the second kind and order 0 : H2_0(x) = J_0(x) - i Y_0(x)

hankelH20N#

std::vector<complex_t> xlifepp::hankelH20N(real_t x, number_t N)#: Hankel functions of the second kind and order 0 … N: H2_k(x) = J_k(x) - i Y_k(x)

hankelH21#

inline complex_t xlifepp::hankelH21(const complex_t &z)#: Hankel function of the second kind and order 1 : H2_1(z) = J_1(z) - i Y_1(z) (complex case)

inline complex_t xlifepp::hankelH21(real_t x)#: Hankel function of the second kind and order 1 : H2_1(x) = J_1(x) - i Y_1(x)

hasAnalyticGeodesic#

bool xlifepp::hasAnalyticGeodesic(const Geometry &geo)#

hasCommonElts#

template<typename T> bool xlifepp::hasCommonElts(const ClusterNode<T> &cn1, const ClusterNode<T> &cn2)#

hasGeometricGeodesic#

bool xlifepp::hasGeometricGeodesic(const Geometry &geo)#

height#

inline real_t xlifepp::height(const Point &A, const Point &B, const Point &C)#

Helmholtz2d#

complex_t xlifepp::Helmholtz2d(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: value

Helmholtz2dGradx#

Vector<complex_t> xlifepp::Helmholtz2dGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradx

Helmholtz2dGradxReg#

Vector<complex_t> xlifepp::Helmholtz2dGradxReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: reg gradx

Helmholtz2dGradxSing#

Vector<complex_t> xlifepp::Helmholtz2dGradxSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: sing gradx

Helmholtz2dGradxy#

Matrix<complex_t> xlifepp::Helmholtz2dGradxy(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradxy

Helmholtz2dGradxyReg#

Matrix<complex_t> xlifepp::Helmholtz2dGradxyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: reg gradxy

Helmholtz2dGradxySing#

Matrix<complex_t> xlifepp::Helmholtz2dGradxySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: sing gradxy

Helmholtz2dGrady#

Vector<complex_t> xlifepp::Helmholtz2dGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: grady

Helmholtz2dGradyReg#

Vector<complex_t> xlifepp::Helmholtz2dGradyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: reg grady

Helmholtz2dGradySing#

Vector<complex_t> xlifepp::Helmholtz2dGradySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: sing grady

Helmholtz2dHalfPlane#

complex_t xlifepp::Helmholtz2dHalfPlane(const Point &x, const Point &y, Parameters &pa = defaultParameters)#

Helmholtz kernel in a half-plane with either Dirichlet or Neumann boundary condition half plane P is defined by AY.n >0 where A(a1,a2) is a point of a line L, t = (t1,t2) the tangent vector and n=(-t2,t1) kernel is built from source image Ys = 2A - Y +2*(AY.t)t/|t|^2.

 Hd(X,Y) = H(X,Y) - H(X,Ys)   satisfy Hd(X,Y) =0 for Y in L (say Dirichlet condition)
 Hd(X,Y) = H(X,Y) + H(X,Ys)   satisfy grad(Hd(X,Y)).n =0 for Y in L (say Neumann condition)

Note that dy1(Ys1) = -1+2*t1^2/|t|^2 dy2(Ys1) = 2*t1*t2/|t|^2 dy1(Ys2) = 2*t1^2/|t|^2 dy2(Ys2) = -1 + 2*t2^2/|t|^2

This kernel manage the following parameters bc: boundary condition type on line L (_Dirichlet (default),_Neumann) k: wave number a,b: origin of the line (default (0,0)) t1,t2 : tangent vector of the line (default (1,0))

Helmholtz2dHalfPlaneGradx#

Vector<complex_t> xlifepp::Helmholtz2dHalfPlaneGradx(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dHalfPlaneGradxy#

Matrix<complex_t> xlifepp::Helmholtz2dHalfPlaneGradxy(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dHalfPlaneGrady#

Vector<complex_t> xlifepp::Helmholtz2dHalfPlaneGrady(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dHalfPlaneKernel#

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(Parameters& = defaultParameters)#: construct a Helmholtz2dHalfPlane kernel

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(real_t k, const std::vector<real_t> &t = Point(1., 0.), const Point &A = Point(0., 0.), BoundaryConditionType bct = _Dirichlet)#: construct a Helmholtz2dHalfPlane kernel from k, point, vector, bc

Kernel xlifepp::Helmholtz2dHalfPlaneKernel(real_t k, real_t t1 = 1., real_t t2 = 0., real_t a = 0., real_t b = 0., BoundaryConditionType bct = _Dirichlet)#: construct a Helmholtz2dHalfPlane kernel from from k, point, vector, bc

Helmholtz2dHalfPlaneNxdotGradx#

complex_t xlifepp::Helmholtz2dHalfPlaneNxdotGradx(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dHalfPlaneNydotGrady#

complex_t xlifepp::Helmholtz2dHalfPlaneNydotGrady(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dKernel#

Kernel xlifepp::Helmholtz2dKernel(const real_t &k)#: construct a Helmholtz2d kernel from real k

Kernel xlifepp::Helmholtz2dKernel(Parameters& = defaultParameters)#: construct a Helmholtz2d kernel

Helmholtz2dKernelReg#

Kernel xlifepp::Helmholtz2dKernelReg(Parameters& = defaultParameters)#: construct a Helmholtz2d kernel, regular part

Helmholtz2dKernelSing#

Kernel xlifepp::Helmholtz2dKernelSing(Parameters& = defaultParameters)#: construct a Helmholtz2d kernel, singular part

Helmholtz2dNxdotGradx#

complex_t xlifepp::Helmholtz2dNxdotGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: nx.gradx

Helmholtz2dNydotGrady#

complex_t xlifepp::Helmholtz2dNydotGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: ny.grady

Helmholtz2dReg#

complex_t xlifepp::Helmholtz2dReg(const Point &x, const Point &y, Parameters &pa)#

Regular part of Helmholtz2d function i/4 H^{(1)}_0(k*r) - log(k*r)/(2*pi)

reg value

Helmholtz2dSing#

complex_t xlifepp::Helmholtz2dSing(const Point &x, const Point &y, Parameters &pa)#

Singular part of Helmholtz2d function - log(r)/(2*pi)

sing value

Helmholtz2dStrip#

complex_t xlifepp::Helmholtz2dStrip(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dStripDir#

complex_t xlifepp::Helmholtz2dStripDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGradx#

Vector<complex_t> xlifepp::Helmholtz2dStripGradx(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dStripGradxDir#

Vector<complex_t> xlifepp::Helmholtz2dStripGradxDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGradxNeu#

Vector<complex_t> xlifepp::Helmholtz2dStripGradxNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGradxy#

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxy(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dStripGradxyDir#

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxyDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGradxyNeu#

Matrix<complex_t> xlifepp::Helmholtz2dStripGradxyNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGrady#

Vector<complex_t> xlifepp::Helmholtz2dStripGrady(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dStripGradyDir#

Vector<complex_t> xlifepp::Helmholtz2dStripGradyDir(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripGradyNeu#

Vector<complex_t> xlifepp::Helmholtz2dStripGradyNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripKernel#

Kernel xlifepp::Helmholtz2dStripKernel(BoundaryConditionType bct, real_t k, real_t h = 1., number_t n = 1000, real_t l = -1., real_t e = 1.E-6)#: construct a Helmholtz2dStrip kernel from k, h, n, …

Kernel xlifepp::Helmholtz2dStripKernel(Parameters& = defaultParameters)#: construct a Helmholtz2d kernel

Helmholtz2dStripNeu#

complex_t xlifepp::Helmholtz2dStripNeu(const Point &x, const Point &y, real_t k, real_t h, real_t l, number_t N, real_t eps)#

Helmholtz2dStripNxdotGradx#

complex_t xlifepp::Helmholtz2dStripNxdotGradx(const Point &x, const Point &y, Parameters &pa)#

Helmholtz2dStripNydotGrady#

complex_t xlifepp::Helmholtz2dStripNydotGrady(const Point &x, const Point &y, Parameters &pa)#

Helmholtz3d#

complex_t xlifepp::Helmholtz3d(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: value

Helmholtz3dGradx#

Vector<complex_t> xlifepp::Helmholtz3dGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradx

Helmholtz3dGradxReg#

Vector<complex_t> xlifepp::Helmholtz3dGradxReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradx

Helmholtz3dGradxSing#

Vector<complex_t> xlifepp::Helmholtz3dGradxSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradx

Helmholtz3dGradxy#

Matrix<complex_t> xlifepp::Helmholtz3dGradxy(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradxy

Helmholtz3dGradxyReg#

Matrix<complex_t> xlifepp::Helmholtz3dGradxyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradxy

Helmholtz3dGradxySing#

Matrix<complex_t> xlifepp::Helmholtz3dGradxySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: gradxy

Helmholtz3dGrady#

Vector<complex_t> xlifepp::Helmholtz3dGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: grady

Helmholtz3dGradyReg#

Vector<complex_t> xlifepp::Helmholtz3dGradyReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: grady

Helmholtz3dGradySing#

Vector<complex_t> xlifepp::Helmholtz3dGradySing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: grady

Helmholtz3dKernel#

Kernel xlifepp::Helmholtz3dKernel(const complex_t &k)#: construct a Helmholtz3d kernel from complex k

Kernel xlifepp::Helmholtz3dKernel(const real_t &k)#: construct a Helmholtz3d kernel from real k

Kernel xlifepp::Helmholtz3dKernel(Parameters& = defaultParameters)#: construct a Helmholtz3d kernel from parameters

Helmholtz3dKernelReg#

Kernel xlifepp::Helmholtz3dKernelReg(Parameters& = defaultParameters)#: construct a Helmholtz3d kernel from parameters

Helmholtz3dKernelSing#

Kernel xlifepp::Helmholtz3dKernelSing(Parameters& = defaultParameters)#: construct a Helmholtz3d kernel from parameters

Helmholtz3dNxdotGradx#

complex_t xlifepp::Helmholtz3dNxdotGradx(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: nx.gradx

Helmholtz3dNydotGrady#

complex_t xlifepp::Helmholtz3dNydotGrady(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: ny.grady

Helmholtz3dNydotGradyReg#

complex_t xlifepp::Helmholtz3dNydotGradyReg(const Point &x, const Point &y, Parameters &pa)#

Helmholtz3dReg#

complex_t xlifepp::Helmholtz3dReg(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: value

Helmholtz3dSing#

complex_t xlifepp::Helmholtz3dSing(const Point &x, const Point &y, Parameters &pa = defaultParameters)#: value

HelmholtzSingDLP0#

template<class T> T xlifepp::HelmholtzSingDLP0(T k, const Element *elt, const Point &pos)#

HelmholtzSingDLP1#

template<class T> void xlifepp::HelmholtzSingDLP1(T k, const Element *elt, const Point &pos, Vector<T> &res)#

hermitianInnerProductTpl#

template<typename T1_iterator, typename T2_iterator> complex_t xlifepp::hermitianInnerProductTpl(T1_iterator b1, T1_iterator e1, T2_iterator b2)#: hermitian product

hermitianProduct#

template<typename T, typename K> T xlifepp::hermitianProduct(const std::vector<std::pair<number_t, T>> &u, const std::map<number_t, K> &v)#

complex_t xlifepp::hermitianProduct(const SuTermVector&, const SuTermVector&)#: hermitian product

complex_t xlifepp::hermitianProduct(const TermVector &tv1, const TermVector &tv2)#: hermitian product

template<typename K1, typename K2> complex_t xlifepp::hermitianProduct(const Vector<K1> &vecFirst, const Vector<K2> &vecSecond)#

complex_t xlifepp::hermitianProduct(const VectorEntry&, const VectorEntry&)#: hermitian product of two vectorentry’s

hexahedronQuadrature#

Quadrature *xlifepp::hexahedronQuadrature(QuadRule, number_t)#: find or create quadrature rule over the unit hexahedron

homothetize#

template<class Geom> Geom xlifepp::homothetize(const Geom &g, const Parameter &p1)#: apply a homothety on a Geom (1 key) (template external)

template<class Geom> Geom xlifepp::homothetize(const Geom &g, const Parameter &p1, const Parameter &p2)#: apply a homothety on a Geom (2 keys) (template external)

template<class Geom> Geom xlifepp::homothetize(const Geom &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)#: apply a homothety on a Geom (template external)

template<class Geom> Geom xlifepp::homothetize(const Geom &g, real_t factor)#: apply a homothety on a Geom (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Parameter &p1)#: apply a homothety on a Geometry (1 key) (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Parameter &p1, const Parameter &p2)#: apply a homothety on a Geometry (2 keys) (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)#: apply a homothety on a Geometry (template external)

inline Geometry xlifepp::homothetize(const Geometry &g, real_t factor)#: apply a homothety on a Geometry (template external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1)#

apply a homothety on a Mesh (1 key)

apply a homothety on a Mesh (1 key) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2)#

apply a homothety on a Mesh (2 keys)

apply a homothety on a Mesh (2 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3)#

apply a homothety on a Mesh (3 keys)

apply a homothety on a Mesh (3 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Parameter &p1, const Parameter &p2, const Parameter &p3, const Parameter &p4)#

apply a homothety on a Mesh (4 keys)

apply a homothety on a Mesh (4 keys) (external)

Mesh xlifepp::homothetize(const Mesh &m, const Point &c, real_t factor = 1.)#: apply a homothety on a Mesh (external)

Mesh xlifepp::homothetize(const Mesh &m, real_t factor)#: apply a homothety on a Mesh (external)

inline Point xlifepp::homothetize(const Point &g, const Parameter &p1)#: apply a homothety on a Point (1 key) (template external)

inline Point xlifepp::homothetize(const Point &g, const Parameter &p1, const Parameter &p2)#: apply a homothety on a Point (2 keys) (template external)

inline Point xlifepp::homothetize(const Point &g, const Point &c = Point(0., 0., 0.), real_t factor = 0.)#: apply a homothety on a Point (template external)

inline Point xlifepp::homothetize(const Point &g, real_t factor)#: apply a homothety on a Point (template external)

hornerAlgorithmTpl#

template<typename scalar1, typename T1_iterator, typename scalar2> scalar2 xlifepp::hornerAlgorithmTpl(scalar1 x, T1_iterator b, T1_iterator e, scalar2 p0)#: if p0 == 0 this is Horner algorithm: a[n] + x * (a[n-1] + x * (a[n-2] +…+ x * (a[0])…)) else compute a[n] + x * (a[n-1] + x * (a[n-2] +…+ x * (a[0] + x * p0)…))