amplitudes.h

Go to the documentation of this file.

//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //
//                                                                                   //
//                       / /   / /    __    \ \  / /                                 //
//                      / /__ / /   / _ \    \ \/ /                                  //
//                     /  ___  /   | |/_/    / /\ \                                  //
//                    / /   / /    \_\      / /  \ \                                 //
//                                                                                   //
//                                                                                   //
//  Copyright (c) 2016, Jakub Benda, Charles University in Prague                    //
//                                                                                   //
// MIT License:                                                                      //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a          //
// copy of this software and associated documentation files (the "Software"),        //
// to deal in the Software without restriction, including without limitation         //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,          //
// and/or sell copies of the Software, and to permit persons to whom the             //
// Software is furnished to do so, subject to the following conditions:              //
//                                                                                   //
//  The above copyright notice and this permission notice shall be included          //
// in all copies or substantial portions of the Software.                            //
//                                                                                   //
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS          //
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE       //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, //
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF         //
// OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  //
//                                                                                   //
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //

#ifndef HEX_AMPLITUDES
#define HEX_AMPLITUDES

#include <vector>

#include "hex-arrays.h"
#include "hex-chebyshev.h"

#include "bspline.h"
#include "io.h"
#include "parallel.h"
#include "radial.h"

class Amplitudes
{
    public:
        
        Amplitudes
        (
            Bspline const & bspline_inner,
            Bspline const & bspline_full,
            InputFile const & inp,
            Parallel const & par,
            CommandLine const & cmd,
            std::vector<std::pair<int,int>> const & ang
        );
        
        void extract (std::string directory = ".");
        
        void writeSQL_files (std::string directory = ".");
        
        void writeICS_files (std::string directory = ".");
        
        void verbose (bool b) { verbose_ = b; }
        
    private:
        
        typedef struct tTransition
        {
            // initial state
            int ni, li, mi;
            
            // final state
            int nf, lf, mf;
            
            // necessary ordering operator so that we can use this structure as an index in std::map
            bool operator < (tTransition const & t) const
            {
                #define Compare(x) if (x < t.x) return true; if (x > t.x) return false;
                
                // perform standard lexicographic comparison (by components)
                Compare(ni); Compare(li); Compare(mi);
                Compare(nf); Compare(lf); Compare(mf);
                
                // they are equal
                return false;
            }
        }
        Transition;
        
        // Λ[ie] for both spins indexed by (ni,li,mi,nf,lf,mf) and l'
        std::map<Transition,std::vector<std::pair<cArray,cArray>>> Lambda_Slp;
        
        // T[ie] for both spins indexed by (ni,li,mi,nf,lf,mf) and l'
        std::map<Transition,std::vector<std::pair<cArray,cArray>>> Tmat_Slp;
        
        // σ[ie] for both spins indexed by (ni,li,mi,nf,lf,mf)
        std::map<Transition,std::pair<rArray,rArray>> sigma_S;
        
        // Ξ[ie] (lists of Chebyshev coefficients) indexed by (ni,li,mi) and (l1,l2)
        std::map<Transition,std::vector<std::pair<cArray,cArray>>> Xi_Sl1l2;
        
        void computeLambda_ (Transition T, BlockArray<Complex> & solution, int ie, int Spin);
        
        void computeTmat_ (Transition T);
        
        void computeXi_ (Transition T, BlockArray<Complex> & solution, int ie, int Spin);
        
        void computeSigma_ (Transition T);
        
        Chebyshev<double,Complex> fcheb (cArrayView const & PsiSc, Real kmax, int l1, int l2);
        void computeSigmaIon_ (Transition T);
        
        cArray readAtomPseudoState (int lf, int ichan) const;
        
        // B-spline environment
        Bspline const & bspline_inner_;
        Bspline const & bspline_full_;
        
        // radial integrals
        RadialIntegrals rad_;
        
        // input data
        InputFile const & inp_;
        
        // parallel environment
        Parallel const & par_;
        
        // command line switches
        CommandLine const & cmd_;
        
        // angular basis
        std::vector<std::pair<int,int>> const & ang_;
        
        // solution reader
        SolutionIO reader_;
        
        // standard output verbosity
        bool verbose_;
};

#endif