interspeciescollisions.h

Go to the documentation of this file.

#ifndef DECLARATION_INTERSPECIES_FP_H
#define DECLARATION_INTERSPECIES_FP_H


//-------------------------------------------------------------------
        class interspecies_f00_explicit_step {
//--------------------------------------------------------------            
        public:
            interspecies_f00_explicit_step(const DistFunc1D& DF1, const DistFunc1D& DF2, const double& deltat);//, int tout_start) //DistFunc1D& DFin,

            valarray<double>  takestep(const valarray<double>& f1in, const valarray<double>& f2in);


        private:
        //  Variables

            // SHarmonic1D&        f1, f2;
            valarray<double>    fslope;

            double              dt;
            Formulary           formulary;
            void                calculateintegrals(const valarray<double>& f1in, const valarray<double>& f2in);            
            // vector<double>      f1;
            void                remapintegrals();

            double              m1, m2, z1, z2, n1, n2, T1, T2, Gamma12, kpre;
            
            valarray<double>            pgrid_s1, pgrid_s2;
            valarray<double>            df0;
            valarray<double>            U4, U4m1, U2, U2m1, U1, U1m1, U3, Qn, Pn;

            valarray<double>            J1_s2, I2_s2, I4_s2;

            valarray<double>            J1_s1, I2_s1, I4_s1;

            int                         Nbc; 
            int                         szx; 

        };
//--------------------------------------------------------------
//  Functor to be used in the Runge-Kutta methods 
    class interspecies_f00_RKfunctor : public Algorithms::AbstFunctor<valarray<double>> {
//--------------------------------------------------------------        
        public:
//          Constructor
            interspecies_f00_RKfunctor(const DistFunc1D& DF1,const DistFunc1D& DF2,const double& smalldt);
            ~interspecies_f00_RKfunctor(){ };

//          Collect all the operators and apply on Yin
            void operator()(const valarray<double>& fin1, valarray<double>& fslope);
            void operator()(const valarray<double>& fin1, const valarray<double>& fin2, valarray<double>& fslope);
            void operator()(const valarray<double>& fin1, valarray<double>& fslope, size_t dir);

        private:
            //          Variables
            interspecies_f00_explicit_step collide;
             
    };
//--------------------------------------------------------------    

//-------------------------------------------------------------------
        class interspecies_f00_explicit_collisions {
//--------------------------------------------------------------            
        public:
            interspecies_f00_explicit_collisions(const DistFunc1D& DF1,const DistFunc1D& DF2, const double& deltat);//, int tout_start) //DistFunc1D& DFin,

            void rkloop(SHarmonic1D& SH1, const SHarmonic1D& SH2);

        private:
        //  Variables
            interspecies_f00_RKfunctor              rkf00;
            valarray<double>                        fin1,fin2;
            Algorithms::RK4<valarray<double>>            RK4;
            

            size_t                                  num_h;
            double                                  h;

            int Nbc; 
            int szx; 

        };
//-------------------------------------------------------------------

//--------------------------------------------------------------
//--------------------------------------------------------------
        class interspecies_flm_implicit_step {
//-------------------------------------------------------------------
        private:

//          Define the powers of the velocity
            valarray<double>  vr;

//          Parameters
            valarray<double>  U4, U4m1, U2, U2m1, U1, U1m1;

//          Define the integrals
            valarray<double>  J1m, I0, I2;

//          Define the derivatives of f0
            valarray<double>  df0, ddf0;

//          Variables for the matrix A, such that A*x = b
            valarray<double> Scattering_Term;
            Array2D<double> Alpha_Tri;
            bool if_tridiagonal;

//          Constant
            double I0_density, I2_temperature;
            double _ZLOGei, _LOGee, kpre, Dt;
            Formulary formulas;

        public:
//          Constructors/Destructors
            interspecies_flm_implicit_step(double pmax, size_t nump); 
         
//          Calculate the coefficients
            void reset_coeff(const valarray<double>& f00, const double Delta_t);    

//          Explicit Advance
            void advance(valarray<complex<double> >& fin, const int el);    
        };
//-------------------------------------------------------------------
//-------------------------------------------------------------------
        class interspecies_flm_implicit_collisions {
        public:
            interspecies_flm_implicit_collisions(const DistFunc1D &DFin, const double& deltat); 

            void advancef1(DistFunc1D& DF); 

            void advanceflm(DistFunc1D& DF);

        private:
            // State1D& Y;
            double Dt;

            int Nbc; 
            int szx; 

            size_t l0; 
            size_t m0; 

            valarray<complex<double> >  fc;   
            valarray<double> f00;   

            interspecies_flm_implicit_step  implicit_step;  

        };
//--------------------------------------------------------------
//-------------------------------------------------------------------
        class interspecies_collisions {
//--------------------------------------------------------------            
        public:
            interspecies_collisions(const State1D& Yin, const size_t& sind, const double& deltat); 

            void advancef00(State1D& Y, const size_t& sind);
            // void advancef1(State1D& Y, const size_t sin);
            // void advanceflm(State1D& Y, const size_t sin);

        private:
        //  Variables
            vector<interspecies_f00_explicit_collisions> interspecies_f00_collisions;
            // vector<implicit_flm_interspecies> flm_collisions;

            // double              t, tout;
            // int Nbc; ///< Number of boundary cells in each direction
            // int szx; ///< Total cells including boundary cells in x-direction


        };


#endif