sources.hpp

Go to the documentation of this file.

#ifndef SOURCES_HPP
#define SOURCES_HPP

#include "step_trigger.hpp"
#include "monte_carlo_collisions.hpp"
#include "col_grid.hpp"
#include "diffusion.hpp"

enum class CollisionMode{
    None = 0,
    MonteCarloNonConserving, // monte-carlo non-conserving
    NonLinearFokkerPlanckLandau, // fully non-linear multi-species Fokker-Planck-Landau [Hager JCP 315, 644-660 (2016)]
    PETScLandauAMR // PETSc multi-species Landau with adaptive mesh refinement (ongoing implementation)
};

struct Sources{
    private:

    StepTrigger step_trigger; // Triggers when f_source is called

    public:

    int f_source_period; 

    // List of sources (other collisions-related members will be folded into a child class of Source)
    Source neutrals;
    Diffusion diffusion;
    Source radiation;
    Source heat_and_torque;
    Source collisions;
    Source current_drive;

    CollisionMode col_mode; 
    MonteCarloCollider<DeviceType> col_mc; 
    CollisionGrid<DeviceType> col_grid; 

    Sources(NLReader::NamelistReader& nlr, const MagneticField<DeviceType>& magnetic_field, const VelocityGrid& vgrid, const Plasma& plasma) {
        nlr.use_namelist("sml_param");
        f_source_period = nlr.get<int>("sml_f_source_period", 1);

        step_trigger = StepTrigger(f_source_period);

        // Set up for each source:
        const int CALL_AT_F_SOURCE = 1; // Set these triggers so that these sources are called every time f_source is called
        bool sml_radiation = nlr.get<bool>("sml_radiation",false);
        bool sml_neutral = nlr.get<bool>("sml_neutral",false);
        bool sml_source = nlr.get<bool>("sml_source",false);
        bool sml_current_drive = nlr.get<bool>("sml_current_drive_on",false);
        if (sml_radiation) sml_neutral = true; // radiation overrides neutrals (should throw error instead)

        if(sml_radiation){
            nlr.use_namelist("rad_param");
            int start_time = nlr.get<int>("rad_start_time",1); 
            radiation.step_trigger = StepTrigger(CALL_AT_F_SOURCE, start_time);
        }

        if(sml_neutral){
            nlr.use_namelist("neu_param");
            int start_time = nlr.get<int>("neu_start_time",2); 
            neutrals.step_trigger = StepTrigger(CALL_AT_F_SOURCE, start_time);
        }

        if(sml_source){
            nlr.use_namelist("src_param");
            int start_time = nlr.get<int>("src_start_time",1); 
            heat_and_torque.step_trigger = StepTrigger(CALL_AT_F_SOURCE, start_time);
        }

        if(sml_current_drive){
            nlr.use_namelist("src_param");
            int start_time = nlr.get<int>("src_current_drive_start_time",1);
            current_drive.step_trigger = StepTrigger(CALL_AT_F_SOURCE, start_time);
        }    

        nlr.use_namelist("diff_param");
        bool diff_on = nlr.get<bool>("diff_on", false); 
        if(diff_on){
            // If diffusion is on, call diffusion constructor
            diffusion = Diffusion(nlr, magnetic_field);

            int start_time = nlr.get<int>("diff_start_time", 1); 
            diffusion.step_trigger = StepTrigger(CALL_AT_F_SOURCE, start_time);
        }

        // Collisions
        nlr.use_namelist("col_param");
        int col_mode_in = nlr.get<int>("col_mode", 0);
        if(col_mode_in==0) col_mode = CollisionMode::None;
        else if(col_mode_in==1) col_mode = CollisionMode::MonteCarloNonConserving;
        else if(col_mode_in==4) col_mode = CollisionMode::NonLinearFokkerPlanckLandau;
        else if(col_mode_in==5) col_mode = CollisionMode::PETScLandauAMR;
        else{
            if(col_mode_in==2){
                if(is_rank_zero()) printf("\ncol_mode==2 is currently not supported. If you are reviving it, dont forget to address this potential issue: https://github.com/PrincetonUniversity/XGC-Devel/issues/266");
            }
            exit_XGC("\nInvalid col_mode specified. Acceptable options are 0, 1, 4, or 5.\n");
        }

        if(col_mode==CollisionMode::NonLinearFokkerPlanckLandau){
            col_grid = CollisionGrid<DeviceType>(nlr, magnetic_field);
        }else if(col_mode==CollisionMode::MonteCarloNonConserving){
            col_mc = MonteCarloCollider<DeviceType>(nlr, magnetic_field, plasma.n_nonadiabatic_species);
        }

        if(col_mode!=CollisionMode::None){
            collisions.step_trigger = StepTrigger(CALL_AT_F_SOURCE, 0); // start time is zero
        }
    }

    /* Returns whether the sources should be executed on this step
     * */
    bool is_triggered(int step){
        return step_trigger.is_triggered(step);
    }
};

#endif