/* Copyright 2019 David Grote, Luca Fedeli, Remi Lehe
 * Yinjian Zhao
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
#ifndef UTILS_WARPXALGORITHMSELECTION_H_
#define UTILS_WARPXALGORITHMSELECTION_H_

#include <AMReX_BaseFwd.H>

#include <string>

/**
  * \brief struct to determine the computational medium, i.e., vacuum or material/macroscopic
           default is vacuum.
  */
struct MediumForEM {
    enum {
        Vacuum = 0,
        Macroscopic = 1
    };
};

/**
  * \brief struct to select algorithm for macroscopic Maxwell solver
           LaxWendroff (semi-implicit) represents sigma*E = sigma*0.5*(E^(n) + E^(n+1))
           Backward Euler (fully-implicit) represents sigma*E = sigma*E^(n+1)
           default is Backward Euler as it is more robust.
  */
struct MacroscopicSolverAlgo {
    enum {
        BackwardEuler = 0,
        LaxWendroff = 1
    };
};

struct ElectromagneticSolverAlgo {
    enum {
        None = 0,
        Yee = 1,
        CKC = 2,
        PSATD = 3,
        ECT = 4
    };
};

struct ElectrostaticSolverAlgo {
    enum {
        None = 0,
        Relativistic = 1,
        LabFrameElectroMagnetostatic = 2,
        LabFrame = 3  // Non relativistic
    };
};

struct ParticlePusherAlgo {
    enum {
        Boris = 0,
        Vay = 1,
        HigueraCary = 2
    };
};

struct CurrentDepositionAlgo {
    enum {
         Esirkepov = 0,
         Direct = 1,
         Vay = 2
    };
};

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
    };
};

/** Strategy to compute weights for use in load balance.
 */
struct LoadBalanceCostsUpdateAlgo {
    enum {
        Timers    = 0, //!< load balance according to in-code timer-based weights (i.e., with  `costs`)
        Heuristic = 1, /**< load balance according to weights computed from number of cells
                             and number of particles per box (i.e., with `costs_heuristic`)*/
        GpuClock  = 2
    };
};

/** Field boundary conditions at the domain boundary
 */
struct FieldBoundaryType {
    enum {
        PML = 0,
        Periodic = 1,
        PEC = 2,     //!< perfect electric conductor (PEC) with E_tangential=0
        PMC = 3,      //!< perfect magnetic conductor (PMC) with B_tangential=0
        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.
    };
};

/** Particle boundary conditions at the domain boundary
 */
enum struct ParticleBoundaryType {
        Absorbing = 0,     //!< particles crossing domain boundary are removed
        Open = 1,          //!< particles cross domain boundary leave with damped j
        Reflecting = 2,     //!< particles are reflected
        Periodic = 3
};

/** MPI reductions
 */
struct ReductionType {
    enum {
        Maximum = 0,
        Minimum = 1,
        Sum = 2
    };
};

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

/** Select BC Type for fields, if field=true
 *  else select BCType for particles.
 */
int
GetFieldBCTypeInteger( std::string BCType );

/** Select BC Type for particles.
 */
ParticleBoundaryType
GetParticleBCTypeInteger( std::string BCType );

#endif // UTILS_WARPXALGORITHMSELECTION_H_