Class xlifepp::Fock#

class Fock#

Public Functions

inline Fock()#: default constructor

Fock(const string_t &filename)#: constructor loading table

Fock(number_t o, number_t nr, number_t vnf, const complex_t &vq = 0., real_t va = -2.55, real_t vb = 2, real_t vc = -15, real_t vd = 5, bool rot = true)#: constructor

void clear()#: clear object

void createTable(real_t x0, real_t xf, number_t nx)#: create tabulated Fock values

complex_t Fock_s_app(real_t x) const#: compute surface Fock function using approximation

complex_t Fock_s_Filon(real_t x) const#: compute “exact” surface Fock function using Filon methods

complex_t Fock_s_interp(real_t x) const#

compute surface Fock function from tabulated values

compute surface Fock using linear interpolation from values in table x0 <= x <= x0+(n-1)*dx (n=table.size()) NO CHECK

complex_t Fock_s_trapz(real_t x, real_t a = -100, real_t b = 10, number_t nt = 2200) const#: compute “exact” surface Fock function using trapeze method

void initFilon(real_t c, real_t d, number_t nf, bool rot = true)#: initialize Filon object fimAP, fimAM used to compute Fock approximation

void initFilonMP(real_t a, real_t b, number_t nfM, number_t nfP, bool rot = true)#: initialize Filon objects fimM, fimP used to compute “exact” Fock function

void initResidue(number_t nbp = 1, bool withNewton = false)#

initialize pole stuff for residue computation

precomputation of poles zk of w2’-q.w2 and values zk.w2(zk)-q.w2’(zk) = (zk-q^2)w2(zk) q = 0 : zk = exp(2ipi/3)ak’ with ak’ the zeros of Ai’ that are tabulated (up to 10) q=inf: zk = exp(2ipi/3)ak with ak the zeros of Ai that are tabulated (up to 10) when q!=0, zk is approximated from zeros of ak’ (q small) or ak (q large) if withNewton is on, Newton’s method is used to get a better approximation

complex_t ippFock_s(real_t x, real_t c, int_t p) const#

compute surface Fock function using ipp (a<x<b)

compute part of Fock_s using integration by parts approximation (two first terms of double ipp), c>0

    / +inf                                 / c                  / +inf

(p=1) : | j_s(x,q,t)dt or (p=-1) : | j_s(x,q,t)dt = | j_s(x,q,-t)dt /c /-inf /-c

 / +inf

or (p=-2) : r | j_s(x,q,r*t)dt with r=exp(-2ipi/3) (rotated integral) /c

void loadTable(const string_t &filename)#

load from file tabulated Fock values

load tabulated Fock values from file

void newton(complex_t &r0, number_t kmax = 10, real_t tol = theTolerance) const#: improve roots of w2’-q.w2 using Newton’s method

inline complex_t operator()(real_t x, CalType ct = _defaultCal) const#: < compute Fock main function

complex_t resFock_s(real_t x) const#: compute surface Fock function using residue (x>b)

void saveTable(const string_t &filename) const#: save to file tabulated Fock values

void saveTable(real_t x0, real_t xf, number_t nx, const string_t &filename)#: create and save to file tabulated Fock values

complex_t spFock_s(real_t x) const#: compute surface Fock function using stationnary phase (x

Public Members

real_t b#: bounds defining methods to be used (default a=-2.55, b=2)

real_t d#: bounds of integral computed by quadrature (default c=-15, d = 5)

FilonIM fimAM#: Filon object to compute approximated Fock function.

FilonIM fimP#: Filon objects to compute Fock function by Filon methods.

number_t nbr#: number of residue used by the residue method

number_t nf#: number of points used by Filon method

number_t ord#: stationary phase order (0 or 1)

Vector<complex_t> poles#: poles zk

complex_t q#: impedance factor, (default q = 0)

bool qis0#: true if q = 0

mutable bool rotate#: use rotation of negative real axe in quadrature methods (default = true)

Tabular<complex_t> *table#: tabulated Fock values

Vector<complex_t> vpoles#: values (zk-q*q)*w2_Ai(zk)