xlifepp – Functions – W#

w1_Ai#

inline complex_t xlifepp::w1_Ai(const complex_t &z, DiffOpType d = _id)#: 2*sqrt(pi)exp(i*pi/6)Ai(t*exp(2i*pi/3))

w2_Ai#

inline complex_t xlifepp::w2_Ai(const complex_t &z, DiffOpType d = _id)#: 2*sqrt(pi)exp(-i*pi/6)Ai(t*exp(-2i*pi/3))

warning#

template<typename T> void xlifepp::warning(const string_t &msgIds, const T &v, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, const T7 &v7, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, const T6 &v6, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4, typename T5> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, const T5 &v5, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3, typename T4> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, const T4 &v4, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2, typename T3> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, const T3 &v3, Messages *msgSrc = theMessages_p)#

template<typename T1, typename T2> void xlifepp::warning(const string_t &msgIds, const T1 &v1, const T2 &v2, Messages *msgSrc = theMessages_p)#

void xlifepp::warning(const string_t &msgIds, MsgData &msgData, Messages *msgSrc)#

shortcut of msg for warning type messages

throw warning messages

wedge_dir#

inline complex_t xlifepp::wedge_dir(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)#

compute wedge diffraction at (kr,phi) using either Somerfeld paths or Steepest Decent paths Phi: wedge angle , phi0 : incidence angle, tau=pi/2Phi,

        1    /                         cos tau.phi0

u_(kr,phi) = –— | exp(-ikr.cos z) ————————–— dz (Dirichlet on both sides) 4i.Phi /path sin tau(phi+z) - sin tau.phi0

1 / cos tau(phi+z) u_(kr,phi) = –— | exp(-ikr.cos z) ————————–— dz (Neumann on both sides) 4i.Phi /path sin tau(phi+z) - sin tau.phi0

           1    /                 PsiP(z+phi)PsiM(z+phi)        cos tau.phi_0

u_(kr,phi) = –— | exp(-ikr.cos z) ——————-— ————————–— dz ( Fourier dn(u) - ik.sin thetaP/M u =0 on SigmaP/M) 4i.Phi /path PsiP(phi0)PsiM(phi0) sin tau(phi+z) - sin tau.phi0

with psiP(z)=psi(Phi+z+thetaP-pi/2)psi(Phi+z-thetaP+pi/2) psiM(z)=psi(-Phi+z-thetaM+pi/2)psi(-Phi+z+thetaM-\pi/2)

important notes:

To deal with Neuman and Dirichlet condition, use Fourier with tethaP=0 and thetaM = -100i for instance
Computation is hazardous for wedge angle Phi < pi/2 (multiple reflexion)
Re(thetaMP)<0 (reactive material) induces exponentially growing solutions
heavy computation when Malyuzhinets function is involved

There are many ways to compute the wedge diffraction depending on

the paths chosen,
the Malyuzineths object is passed or not (Fourier mode)
the number of kr or phi passed (one or few) Note: if Malyuzhinets object is not passed but required, it will be construct internally at each call (additional cost) if more than point given, point loop is parallelized else quadrature loop is parallelized (if OMP available)

wedge_dndirM#

inline complex_t xlifepp::wedge_dndirM(const complex_t &z, real_t Phi, real_t phi0)#

wedge_dndirP#

inline complex_t xlifepp::wedge_dndirP(const complex_t &z, real_t Phi, real_t phi0)#

wedge_fou#

inline complex_t xlifepp::wedge_fou(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)#

wedge_neu#

inline complex_t xlifepp::wedge_neu(const complex_t &z, real_t phi, real_t phi0, const complex_t &thetaP, const complex_t &thetaM, const complex_t &coeffP, const complex_t &coeffM, bool istd, const Malyuzhinets &mal)#

wedgeCurrentSD#

std::vector<complex_t> xlifepp::wedgeCurrentSD(const std::vector<real_t> &krs, real_t Phi, int uplow, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

wedgeCurrentSD_par#

std::vector<complex_t> xlifepp::wedgeCurrentSD_par(const std::vector<real_t> &krs, real_t Phi, int uplow, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

wedgeCurrentSOM#

std::vector<complex_t> xlifepp::wedgeCurrentSOM(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

wedgeDiffractionSD#

std::vector<complex_t> xlifepp::wedgeDiffractionSD(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

inline complex_t xlifepp::wedgeDiffractionSD(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, real_t kra, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)#

wedgeDiffractionSD_par#

std::vector<complex_t> xlifepp::wedgeDiffractionSD_par(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, real_t krasym, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

inline complex_t xlifepp::wedgeDiffractionSD_par(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, real_t kra, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)#

wedgeDiffractionSOM#

std::vector<complex_t> xlifepp::wedgeDiffractionSOM(const std::vector<real_t> &krs, const std::vector<real_t> &phis, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM, complex_t thetaP, complex_t thetaM)#

inline complex_t xlifepp::wedgeDiffractionSOM(real_t kr, real_t phi, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM = _undefEcType, complex_t thetaP = 0, complex_t thetaM = 0)#

wedgeDirCurrentSD#

std::vector<complex_t> xlifepp::wedgeDirCurrentSD(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, int uplow)#

wedgeDirCurrentSOM#

std::vector<complex_t> xlifepp::wedgeDirCurrentSOM(const std::vector<real_t> &krs, real_t Phi, real_t phi0, FieldPart fp, BcType bcP, BcType bcM)#

where#

string_t &xlifepp::where(const string_t &s)#: sets a message to tell where we are in the code (shortcut to when push/pop are not set)

whichSide#

int_t xlifepp::whichSide(const Point &p, const Point &n, const std::vector<Point> &pts)#: determines if a plane splits a set of points

words#

string_t xlifepp::words(const bool b)#: accessor to words with a boolean

string_t xlifepp::words(const char *key)#: accessor to words with a const char* (needed to avoid automatic cast to bool type)

string_t xlifepp::words(const string_t &key)#

accessor to words with a string_t

external function to manage localized strings

string_t xlifepp::words(const string_t &key, const int id)#: accessor to enumWords

writeLigne#

number_t xlifepp::writeLigne(std::ostream &out, const std::string &str, number_t ncar)#

Write the string str on the output stream out, limiting the length of all output lines to 80 characters Nota: the length of str is logically assumed to be < 80 characters.

This is not checked since this is always the case when this function is called by the function melExport; moreover, this would not produce any error: the string str would just be written as is on a new line.

ncar is the number of characters previously written on the current line. If the sum of the length of str and ncar does not exceed 80 characters, then str is written at the end of the current line; otherwise str is written on a new line, which then become the (new) current line. The function returns the updated number of characters written on the current line.