WarpXAlgorithmSelection.cpp File Reference

#include "WarpX.H"
#include "WarpXAlgorithmSelection.H"
#include "Utils/TextMsg.H"
#include <ablastr/utils/Enums.H>
#include <AMReX.H>
#include <AMReX_ParmParse.H>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <map>
#include <utility>

Functions
int	GetAlgorithmInteger (const amrex::ParmParse &pp, const char *pp_search_key)
FieldBoundaryType	GetFieldBCTypeInteger (std::string BCType)
ParticleBoundaryType	GetParticleBCTypeInteger (std::string BCType)
std::string	GetFieldBCTypeString (FieldBoundaryType fb_type)

Variables
const std::map< std::string, int >	evolve_scheme_to_int
const std::map< std::string, int >	grid_to_int
const std::map< std::string, int >	electromagnetic_solver_algo_to_int
const std::map< std::string, int >	electrostatic_solver_algo_to_int
const std::map< std::string, int >	poisson_solver_algo_to_int
const std::map< std::string, int >	particle_pusher_algo_to_int
const std::map< std::string, int >	current_deposition_algo_to_int
const std::map< std::string, int >	charge_deposition_algo_to_int
const std::map< std::string, int >	gathering_algo_to_int
const std::map< std::string, int >	psatd_solution_type_to_int
const std::map< std::string, int >	J_in_time_to_int
const std::map< std::string, int >	rho_in_time_to_int
const std::map< std::string, int >	load_balance_costs_update_algo_to_int
const std::map< std::string, int >	MaxwellSolver_medium_algo_to_int
const std::map< std::string, int >	MacroscopicSolver_algo_to_int
const std::map< std::string, FieldBoundaryType >	FieldBCType_algo_to_enum
const std::map< std::string, ParticleBoundaryType >	ParticleBCType_algo_to_enum
const std::map< std::string, int >	ReductionType_algo_to_int

Function Documentation

GetAlgorithmInteger()

int GetAlgorithmInteger	(	const amrex::ParmParse &	pp,
		const char *	pp_search_key
	)

GetFieldBCTypeInteger()

FieldBoundaryType GetFieldBCTypeInteger

(

std::string

BCType

)

Select BC Type for fields, if field=true else select BCType for particles.

GetFieldBCTypeString()

std::string GetFieldBCTypeString

(

FieldBoundaryType

fb_type

)

Find the name associated with a BC type

GetParticleBCTypeInteger()

ParticleBoundaryType GetParticleBCTypeInteger

(

std::string

BCType

)

Select BC Type for particles.

Variable Documentation

charge_deposition_algo_to_int

const std::map<std::string, int> charge_deposition_algo_to_int

Initial value:

= {
    {"standard",   ChargeDepositionAlgo::Standard },
    {"default",    ChargeDepositionAlgo::Standard }
}

current_deposition_algo_to_int

const std::map<std::string, int> current_deposition_algo_to_int

Initial value:

= {
    {"esirkepov",  CurrentDepositionAlgo::Esirkepov },
    {"direct",     CurrentDepositionAlgo::Direct },
    {"vay",        CurrentDepositionAlgo::Vay },
    {"villasenor", CurrentDepositionAlgo::Villasenor },
    {"default",    CurrentDepositionAlgo::Esirkepov } 
}

electromagnetic_solver_algo_to_int

const std::map<std::string, int> electromagnetic_solver_algo_to_int

Initial value:

= {
    {"none",    ElectromagneticSolverAlgo::None },
    {"yee",     ElectromagneticSolverAlgo::Yee },
    {"ckc",     ElectromagneticSolverAlgo::CKC },
    {"psatd",   ElectromagneticSolverAlgo::PSATD },
    {"ect",     ElectromagneticSolverAlgo::ECT },
    {"hybrid",  ElectromagneticSolverAlgo::HybridPIC },
    {"default", ElectromagneticSolverAlgo::Yee }
}

electrostatic_solver_algo_to_int

const std::map<std::string, int> electrostatic_solver_algo_to_int

Initial value:

= {
    {"none", ElectrostaticSolverAlgo::None },
    {"relativistic", ElectrostaticSolverAlgo::Relativistic},
    {"labframe-electromagnetostatic", ElectrostaticSolverAlgo::LabFrameElectroMagnetostatic},
    {"labframe", ElectrostaticSolverAlgo::LabFrame},
    {"default", ElectrostaticSolverAlgo::None }
}

evolve_scheme_to_int

const std::map<std::string, int> evolve_scheme_to_int

Initial value:

= {
    {"explicit",       EvolveScheme::Explicit },
    {"theta_implicit_em", EvolveScheme::ThetaImplicitEM },
    {"semi_implicit_em",  EvolveScheme::SemiImplicitEM },
    {"default",        EvolveScheme::Explicit }
}

FieldBCType_algo_to_enum

const std::map<std::string, FieldBoundaryType> FieldBCType_algo_to_enum

Initial value:

= {
    {"pml",      FieldBoundaryType::PML},
    {"periodic", FieldBoundaryType::Periodic},
    {"pec",      FieldBoundaryType::PEC},
    {"pmc",      FieldBoundaryType::PMC},
    {"damped",   FieldBoundaryType::Damped},
    {"absorbing_silver_mueller", FieldBoundaryType::Absorbing_SilverMueller},
    {"neumann",  FieldBoundaryType::Neumann},
    {"open",     FieldBoundaryType::Open},
    {"none",     FieldBoundaryType::None},
    {"default",  FieldBoundaryType::PML}
}

gathering_algo_to_int

const std::map<std::string, int> gathering_algo_to_int

Initial value:

= {
    {"energy-conserving",   GatheringAlgo::EnergyConserving },
    {"momentum-conserving", GatheringAlgo::MomentumConserving },
    {"default",             GatheringAlgo::EnergyConserving }
}

grid_to_int

const std::map<std::string, int> grid_to_int

Initial value:

= {
    {"collocated", static_cast<int>(ablastr::utils::enums::GridType::Collocated)},
    {"staggered", static_cast<int>(ablastr::utils::enums::GridType::Staggered)},
    {"hybrid", static_cast<int>(ablastr::utils::enums::GridType::Hybrid)},
    {"default", static_cast<int>(ablastr::utils::enums::GridType::Staggered)}
}

J_in_time_to_int

const std::map<std::string, int> J_in_time_to_int

Initial value:

= {
    {"constant", JInTime::Constant},
    {"linear", JInTime::Linear},
    {"default", JInTime::Constant}
}

load_balance_costs_update_algo_to_int

const std::map<std::string, int> load_balance_costs_update_algo_to_int

Initial value:

= {
    {"timers",    LoadBalanceCostsUpdateAlgo::Timers },
    {"heuristic", LoadBalanceCostsUpdateAlgo::Heuristic },
    {"default",   LoadBalanceCostsUpdateAlgo::Timers }
}

MacroscopicSolver_algo_to_int

const std::map<std::string, int> MacroscopicSolver_algo_to_int

Initial value:

= {
    {"backwardeuler", MacroscopicSolverAlgo::BackwardEuler},
    {"laxwendroff", MacroscopicSolverAlgo::LaxWendroff},
    {"default", MacroscopicSolverAlgo::BackwardEuler}
}

MaxwellSolver_medium_algo_to_int

const std::map<std::string, int> MaxwellSolver_medium_algo_to_int

Initial value:

= {
    {"vacuum", MediumForEM::Vacuum},
    {"macroscopic", MediumForEM::Macroscopic},
    {"default", MediumForEM::Vacuum}
}

particle_pusher_algo_to_int

const std::map<std::string, int> particle_pusher_algo_to_int

Initial value:

= {
    {"boris",   ParticlePusherAlgo::Boris },
    {"vay",     ParticlePusherAlgo::Vay },
    {"higuera", ParticlePusherAlgo::HigueraCary },
    {"default", ParticlePusherAlgo::Boris }
}

ParticleBCType_algo_to_enum

const std::map<std::string, ParticleBoundaryType> ParticleBCType_algo_to_enum

Initial value:

= {
    {"absorbing",  ParticleBoundaryType::Absorbing},
    {"open",       ParticleBoundaryType::Open},
    {"reflecting", ParticleBoundaryType::Reflecting},
    {"periodic",   ParticleBoundaryType::Periodic},
    {"thermal",    ParticleBoundaryType::Thermal},
    {"none",       ParticleBoundaryType::None},
    {"default",    ParticleBoundaryType::Absorbing}
}

poisson_solver_algo_to_int

const std::map<std::string, int> poisson_solver_algo_to_int

Initial value:

= {
    {"multigrid", PoissonSolverAlgo::Multigrid},
    {"fft", PoissonSolverAlgo::IntegratedGreenFunction},
    {"default", PoissonSolverAlgo::Multigrid }
}

psatd_solution_type_to_int

const std::map<std::string, int> psatd_solution_type_to_int

Initial value:

= {
    {"first-order", PSATDSolutionType::FirstOrder},
    {"second-order", PSATDSolutionType::SecondOrder},
    {"default", PSATDSolutionType::SecondOrder}
}

ReductionType_algo_to_int

const std::map<std::string, int> ReductionType_algo_to_int

Initial value:

= {
    {"maximum",  ReductionType::Maximum},
    {"minimum",  ReductionType::Minimum},
    {"integral", ReductionType::Sum}
}

rho_in_time_to_int

const std::map<std::string, int> rho_in_time_to_int

Initial value:

= {
    {"constant", RhoInTime::Constant},
    {"linear", RhoInTime::Linear},
    {"default", RhoInTime::Linear}
}