BCHandler.hpp

Go to the documentation of this file.

#ifndef OPALX_SRC_PARTBUNCH_BCHANDLER_HPP
#define OPALX_SRC_PARTBUNCH_BCHANDLER_HPP
 
#include <array>
#include <ostream>
 
#include "Ippl.h"
#include "Utilities/OpalException.h"
 
template <unsigned Dim>
class BCHandler {
public:
    enum BCType { OPEN, PERIODIC, DIRICHLET };
 
    static BCType strToBCType(const std::string& str) {
        if (str == "OPEN") {
            return OPEN;
        } else if (str == "PERIODIC") {
            return PERIODIC;
        } else if (str == "DIRICHLET") {
            return DIRICHLET;
        } else {
            throw OpalException(
                    "BCHandler::strToBCType", "Unknown boundary condition type: " + str);
        }
    }
 
    BCHandler(const BCHandler& other) = default;
 
    template <typename... Bcs>
    BCHandler(Bcs... bcs) : bcs_m{{static_cast<BCType>(bcs)...}} {
        if (sizeof...(bcs) != Dim) {
            throw OpalException(
                    "BCHandler::BCHandler", "Number of passed BCs does not match dimensionality!");
        }
    }
 
    bool isAll(BCType bc_type) const {
        for (unsigned int d = 0; d < Dim; ++d) {
            if (bcs_m[d] != bc_type) return false;
        }
        return true;
    }
 
    bool isAllEqual() const {
        int base_case = bcs_m[0];
        for (unsigned int d = 1; d < Dim; ++d) {
            if (bcs_m[d] != base_case) return false;
        }
        return true;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const BCHandler& h) {
        os << "* BCHandler<" << Dim << ">: [";
        for (unsigned int d = 0; d < Dim; ++d) {
            switch (h.bcs_m[d]) {
                case OPEN:
                    os << "OPEN";
                    break;
                case PERIODIC:
                    os << "PERIODIC";
                    break;
                case DIRICHLET:
                    os << "DIRICHLET";
                    break;
                default:
                    os << "UNKNOWN";
                    break;
            }
            if (d + 1 < Dim) os << ", ";
        }
        os << "]";
        return os;
    }
 
    template <typename Field>
    ippl::BConds<Field, Dim> toIPPLBConds() const {
        typedef ippl::BConds<Field, Dim> bc_type;
        bc_type bc_container;
 
        for (unsigned int face = 0; face < 2 * Dim; ++face) {
            unsigned int d = face / 2;  // Dimension associated with this face
 
            if (bcs_m[d] == PERIODIC) {
                bc_container[face] = std::make_shared<ippl::PeriodicFace<Field>>(face);
            } else if (bcs_m[d] == DIRICHLET) {
                bc_container[face] = std::make_shared<ippl::ZeroFace<Field>>(face);
            } else if (bcs_m[d] == OPEN) {
                bc_container[face] = std::make_shared<ippl::NoBcFace<Field>>(face);
            } else {
                throw OpalException("BCHandler::toIPPLBConds", "Unsupported BCType encountered.");
            }
        }
 
        return bc_container;
    }
 
private:
    std::array<BCType, Dim> bcs_m;
};
 
#endif  // OPALX_SRC_PARTBUNCH_BCHANDLER_HPP