WarpXAlgorithmSelection.H

Go to the documentation of this file.

/* Copyright 2019 David Grote, Luca Fedeli, Remi Lehe
 * Yinjian Zhao
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef WARPX_UTILS_WARPXALGORITHMSELECTION_H_
#define WARPX_UTILS_WARPXALGORITHMSELECTION_H_
 
#include <AMReX_BaseFwd.H>
#include <ablastr/utils/Enums.H>
 
#include <string>
 
using namespace ablastr::utils::enums;  // NOLINT(google-global-names-in-headers)
 
 
struct MediumForEM {
    enum {
        Vacuum = 0,
        Macroscopic = 1
    };
};
 
struct EvolveScheme {
    enum {
        Explicit = 0,
        ThetaImplicitEM = 1,
        SemiImplicitEM = 2
    };
};
 
struct MacroscopicSolverAlgo {
    enum {
        BackwardEuler = 0,
        LaxWendroff = 1
    };
};
 
struct ElectromagneticSolverAlgo {
    enum {
        None = 0,
        Yee = 1,
        CKC = 2,
        PSATD = 3,
        ECT = 4,
        HybridPIC = 5
    };
};
 
struct ElectrostaticSolverAlgo {
    enum {
        None = 0,
        Relativistic = 1,
        LabFrameElectroMagnetostatic = 2,
        LabFrame = 3  // Non relativistic
    };
};
 
struct PoissonSolverAlgo {
    enum {
        Multigrid = 1,
        IntegratedGreenFunction = 2,
    };
};
 
struct ParticlePusherAlgo {
    enum {
        Boris = 0,
        Vay = 1,
        HigueraCary = 2
    };
};
 
struct CurrentDepositionAlgo {
    enum {
        Esirkepov = 0,
        Direct = 1,
        Vay = 2,
        Villasenor = 3
    };
};
 
struct ChargeDepositionAlgo {
    // Only the Standard algorithm is implemented
    enum {
        Standard = 0
    };
};
 
struct GatheringAlgo {
    enum {
        EnergyConserving = 0,
        MomentumConserving
    };
};
 
struct PSATDSolutionType {
    enum {
        FirstOrder = 0,
        SecondOrder = 1
    };
};
 
struct JInTime {
    enum {
        Constant = 0,
        Linear = 1
    };
};
 
struct RhoInTime {
    enum {
        Constant = 0,
        Linear = 1
    };
};
 
struct LoadBalanceCostsUpdateAlgo {
    enum {
        Timers    = 0, 
        Heuristic = 1  
    };
};
 
enum struct FieldBoundaryType {
        PML = 0,
        Periodic = 1,
        PEC = 2,      
        PMC = 3,      
        Damped = 4,   // Fields in the guard cells are damped for PSATD
                      //in the moving window direction
        Absorbing_SilverMueller = 5, // Silver-Mueller boundary condition
        Neumann = 6, // For electrostatic, the normal E is set to zero
        None = 7,    // The fields values at the boundary are not updated. This is
                     // useful for RZ simulations, at r=0.
        Open = 8     // Used in the Integrated Green Function Poisson solver
                     // Note that the solver implicitely assumes open BCs:
                     // no need to enforce them separately
};
 
enum struct ParticleBoundaryType {
        Absorbing = 0,     
        Open = 1,          
        Reflecting = 2,     
        Periodic = 3,      
        Thermal = 4,
        None = 5           
};
 
struct ReductionType {
    enum {
        Maximum = 0,
        Minimum = 1,
        Sum = 2
    };
};
 
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 );
 
#endif // WARPX_UTILS_WARPXALGORITHMSELECTION_H_