CoulombInterference.h

/********************************************************************************

    Copyright 2013 Jan Kašpar

    This file is part of Elegent (http://elegent.hepforge.org/).

    Elegent is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Elegent is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Elegent.  If not, see <http://www.gnu.org/licenses/>.
 
********************************************************************************/

#ifndef _elegent_coulomb_
#define _elegent_coulomb_

#include "Model.h"
#include "Math.h"


namespace Elegent
{

class CoulombInterference
{
    public:
        enum CIMode
        {
            mPC,                
            mPH,                
            mWY,                
            mSWY,               
            mKL                 
        } mode;

        std::string GetModeString() const;

        enum FFType
        {
            ffNone,             
            ffDipole,           
            ffHofstadter,       
            ffBorkowski,        
            ffKelly,            
            ffArrington,        
            ffPuckett,          
            ffPuckettEl         
        } ffType;

        CoulombInterference();

        ~CoulombInterference();

        double GetT()
            { return T; }

        double tau;
        
        double T;

        double precision;

        unsigned long integ_workspace_size;
        gsl_integration_workspace *integ_workspace, *integ_workspace2;

        void Print() const;

    protected:
        static double A_integrand(double tt, double *par, const void *vobj);

        static double I_integrand(double phi, double *par, const void *vobj);

        static TComplex B_integrand(double tp, double *par, const void *vobj);
        
    public:
        double A_term(double t) const;

        double I_integral(double t, double tp) const;
        
        TComplex B_term(double t) const;

        double C_term(double t) const;

        //-------------------- form factors --------------------
        
    public:
        std::string GetFFName() const;

        double FF_dipole(double t) const;
    
        double FF_e(double t) const;

        double FF_m(double t) const;
        
        double FF_sq(double t) const;

        double FF_sq_prime(double t) const
        {
            double ep = 1E-5;
            return (FF_sq(t + ep) - FF_sq(t)) / ep;
        }

        //-------------------- interference phases --------------------

        TComplex Phi_WY(double t) const;
        
        TComplex Phi_SWY(double t) const;

        TComplex Psi_KL(double t) const;

        TComplex Phase(double t) const;

        //-------------------- amplitudes --------------------

        TComplex Amp_pure(double t) const;  
        
        TComplex Amp_WY(double t) const;    
        TComplex Amp_SWY(double t) const;   
        TComplex Amp_KL(double t) const;    

        TComplex Amp(double t) const;

        //-------------------- standard quantities --------------------

        TComplex R(double t) const;
        
        TComplex R_with_cutoff(double t, double cutoff) const;

        TComplex Z(double t) const;
        
        TComplex C(double t) const;
};

extern CoulombInterference *coulomb;

} // namespace

#endif