PicManager.h

#ifndef IPPL_PIC_MANAGER
#define IPPL_PIC_MANAGER
 
#include <memory>
#include <stdexcept>
#include <vector>
 
#include "Decomposition/OrthogonalRecursiveBisection.h"
#include "Manager/BaseManager.h"
#include "Manager/FieldSolverBase.h"
 
namespace ippl {
 
    template <typename T, unsigned Dim, class pc, class fc, class orb>
    class PicManager : public BaseManager {
    public:
        PicManager()
            : BaseManager()
            , fcontainer_m(nullptr)
            , pcontainer_m(nullptr)
            , loadbalancer_m(nullptr) {}
 
        virtual ~PicManager() = default;
 
        virtual void par2grid() = 0;
 
        virtual void grid2par() = 0;
 
        std::shared_ptr<pc> getParticleContainer() { return pcontainer_m; }
 
 
        std::shared_ptr<pc> getParticleContainer(size_t i) {
            if (i >= pcontainers_m.size()) {
                throw std::out_of_range("PicManager::getParticleContainer: index out of range");
            }
            return pcontainers_m[i];
        }
 
        void setParticleContainer(std::shared_ptr<pc> pcontainer) {
            pcontainer_m = pcontainer;
            if (pcontainers_m.empty()) {
                pcontainers_m.push_back(pcontainer);
            } else {
                pcontainers_m[0] = pcontainer;
            }
        }
 
        size_t addParticleContainer(std::shared_ptr<pc> pcontainer) {
            pcontainers_m.push_back(pcontainer);
            // If this is the first container being added, also set pcontainer_m
            if (pcontainers_m.size() == 1) {
                pcontainer_m = pcontainer;
            }
            return pcontainers_m.size() - 1;
        }
 
        size_t getNumParticleContainers() const { return pcontainers_m.size(); }
 
        const std::vector<std::shared_ptr<pc>>& getParticleContainers() const {
            return pcontainers_m;
        }
 
        std::shared_ptr<fc> getFieldContainer() { return fcontainer_m; }
 
        void setFieldContainer(std::shared_ptr<fc> fcontainer) { fcontainer_m = fcontainer; }
 
        std::shared_ptr<ippl::FieldSolverBase<T, Dim>> getFieldSolver() { return fsolver_m; }
 
        void setFieldSolver(std::shared_ptr<ippl::FieldSolverBase<T, Dim>> fsolver) {
            fsolver_m = fsolver;
        }
 
        std::shared_ptr<orb> getLoadBalancer() { return loadbalancer_m; }
 
        void setLoadBalancer(std::shared_ptr<orb> loadbalancer) { loadbalancer_m = loadbalancer; }
 
    protected:
        std::shared_ptr<fc> fcontainer_m;
 
        std::shared_ptr<pc> pcontainer_m;
 
        std::vector<std::shared_ptr<pc>> pcontainers_m;
 
        std::shared_ptr<orb> loadbalancer_m;
 
        std::shared_ptr<ippl::FieldSolverBase<T, Dim>> fsolver_m;
    };
}  // namespace ippl
 
#endif