datatypes.h

#ifndef IPPL_DATATYPES_H
#define IPPL_DATATYPES_H
 
#include "PoissonSolvers/FFTOpenPoissonSolver.h"
#include "PoissonSolvers/FFTPeriodicPoissonSolver.h"
#include "PoissonSolvers/FFTTruncatedGreenPeriodicPoissonSolver.h"
#include "PoissonSolvers/NullSolver.h"
#include "PoissonSolvers/PoissonCG.h"
#include "PoissonSolvers/FEMPoissonSolver.h"
#include "PoissonSolvers/PreconditionedFEMPoissonSolver.h"
 
// some typedefs
template <unsigned Dim>
using Mesh_t = ippl::UniformCartesian<double, Dim>;
 
template <typename T, unsigned Dim>
using PLayout_t = typename ippl::ParticleSpatialLayout<T, Dim, Mesh_t<Dim>>;
 
template <unsigned Dim>
using Centering_t = typename Mesh_t<Dim>::DefaultCentering;
 
template <unsigned Dim>
using FieldLayout_t = ippl::FieldLayout<Dim>;
 
using size_type = ippl::detail::size_type;
 
template <typename T, unsigned Dim>
using Vector = ippl::Vector<T, Dim>;
 
template <typename T, unsigned Dim = 3, class... ViewArgs>
using Field = ippl::Field<T, Dim, Mesh_t<Dim>, Centering_t<Dim>, ViewArgs...>;
 
template <typename T = double, unsigned Dim = 3>
using ORB = ippl::OrthogonalRecursiveBisection<Field<double, Dim>, T>;
 
template <typename T>
using ParticleAttrib = ippl::ParticleAttrib<T>;
 
template <typename T, unsigned Dim>
using Vector_t = ippl::Vector<T, Dim>;
 
template <unsigned Dim, class... ViewArgs>
using Field_t = Field<double, Dim, ViewArgs...>;
 
template <typename T = double, unsigned Dim = 3, class... ViewArgs>
using VField_t = Field<Vector_t<T, Dim>, Dim, ViewArgs...>;
 
template <typename T = double, unsigned Dim = 3>
using CGSolver_t = ippl::PoissonCG<Field<T, Dim>, Field_t<Dim>>;
 
template <typename T = double, unsigned Dim = 3>
using NullSolver_t = ippl::NullSolver<VField_t<T, Dim>, Field_t<Dim>>;
 
using ippl::detail::ConditionalType, ippl::detail::VariantFromConditionalTypes;
 
template <typename T = double, unsigned Dim = 3>
using FFTSolver_t = ConditionalType<Dim == 2 || Dim == 3,
                                    ippl::FFTPeriodicPoissonSolver<VField_t<T, Dim>, Field_t<Dim>>>;
 
template <typename T = double, unsigned Dim = 3>
using FFTTruncatedGreenSolver_t =
    ConditionalType<Dim == 3,
                    ippl::FFTTruncatedGreenPeriodicPoissonSolver<VField_t<T, Dim>, Field_t<Dim>>>;
 
template <typename T = double, unsigned Dim = 3>
using OpenSolver_t =
    ConditionalType<Dim == 3, ippl::FFTOpenPoissonSolver<VField_t<T, Dim>, Field_t<Dim>>>;
 
template <typename T = double, unsigned Dim = 3>
using FEMSolver_t = ippl::FEMPoissonSolver<Field<T, Dim>, Field<T, Dim>>; 
 
template <typename T = double, unsigned Dim = 3>
using FEMPreconSolver_t = ippl::PreconditionedFEMPoissonSolver<Field<T, Dim>, Field<T, Dim>>; 
 
template <typename T = double, unsigned Dim = 3>
using Solver_t = VariantFromConditionalTypes<CGSolver_t<T, Dim>, FFTSolver_t<T, Dim>,
                                             FFTTruncatedGreenSolver_t<T, Dim>,
                                             OpenSolver_t<T, Dim>, NullSolver_t<T, Dim>,
                                             FEMSolver_t<T, Dim>, FEMPreconSolver_t<T, Dim>>;
 
extern const char* TestName;
 
#endif