ParticleContainer.h

/***************************************************************************
 *   Copyright (C) 2010 by Martin Bernreuther <bernreuther@hlrs.de> et al. *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef PARTICLECONTAINER_H_
#define PARTICLECONTAINER_H_
 
#include <list>
#include <variant>
#include <vector>
#include "ParticleCell.h"
#include "ParticleIterator.h"
#include "RegionParticleIterator.h"
#include "io/MemoryProfiler.h"
#include "molecules/MoleculeForwardDeclaration.h"
 
class CellProcessor;
class ParticlePairsHandler;
class XMLfileUnits;
 
class ParticleContainer: public MemoryProfilable {
private:
    /* Copy operator private */
    ParticleContainer& operator=(const ParticleContainer&);
 
public:
    ParticleContainer(double bBoxMin[3], double bBoxMax[3]);
 
    ParticleContainer() {}
    virtual ~ParticleContainer() {}
 
    virtual void readXML(XMLfileUnits& xmlconfig) = 0;
 
    virtual bool rebuild(double bBoxMin[3], double bBoxMax[3]);
 
    virtual void update() = 0;
 
    virtual bool addParticle(Molecule& particle, bool inBoxCheckedAlready = false, bool checkWhetherDuplicate = false, const bool& rebuildCaches=false) = 0;
 
    virtual bool addHaloParticle(Molecule& particle, bool inBoxCheckedAlready = false, bool checkWhetherDuplicate = false,
            const bool& rebuildCaches = false);
 
    virtual void addParticles(std::vector<Molecule>& particles, bool checkWhetherDuplicate=false) = 0;
 
//  virtual void traversePairs(ParticlePairsHandler* particlePairsHandler) = 0;
 
    virtual void traverseCells(CellProcessor& cellProcessor) = 0;
 
    virtual void traverseNonInnermostCells(CellProcessor& cellProcessor) = 0;
 
    virtual void traversePartialInnermostCells(CellProcessor& cellProcessor, unsigned int stage, int stageCount) = 0;
 
    virtual ParticleIterator iterator (ParticleIterator::Type t) = 0;
    virtual RegionParticleIterator regionIterator (const double startCorner[3], const double endCorner[3], ParticleIterator::Type t) = 0;
 
    virtual unsigned long getNumberOfParticles() = 0;
 
    virtual double getBoundingBoxMin(int dimension) const;
 
    virtual bool isInBoundingBox(double r[3]) const;
 
    virtual int getHaloWidthNumCells();
    virtual double getBoundingBoxMax(int dimension) const;
 
    virtual void clear() = 0;
 
    /* TODO can we combine this with the update method? */
    virtual void deleteOuterParticles() = 0;
 
    virtual double get_halo_L(int index) const = 0;
 
 
    virtual double getCutoff() const = 0;
 
    virtual double getSkin() const {return 0.;}
 
    /* TODO: Have a look on this */
    virtual void deleteMolecule(ParticleIterator& moleculeIter, const bool& rebuildCaches) = 0;
 
    /* TODO goes into grand canonical ensemble */
    virtual double getEnergy(ParticlePairsHandler* particlePairsHandler, Molecule* m1, CellProcessor& cellProcessor) = 0;
 
    virtual void updateInnerMoleculeCaches() = 0;
 
    virtual void updateBoundaryAndHaloMoleculeCaches() = 0;
 
    virtual void updateMoleculeCaches() = 0;
 
    virtual std::variant<ParticleIterator, SingleCellIterator<ParticleCell>> getMoleculeAtPosition(const double pos[3]) = 0;
 
    // @brief Should the domain decomposition exchange calculated forces at the boundaries,
    // or does this particle container calculate all forces.
    virtual bool requiresForceExchange() const {return false;}
        
    virtual unsigned long initCubicGrid(std::array<unsigned long, 3> numMoleculesPerDimension, std::array<double, 3> simBoxLength, size_t seed_offset) = 0;
 
    virtual double* getCellLength() = 0;
 
    virtual double* getHaloSize() {
        return getCellLength();
    };
 
    virtual std::vector<unsigned long> getParticleCellStatistics() {return std::vector<unsigned long>();}
 
    virtual void setCutoff(double rc){};
 
    virtual std::vector<Molecule> getInvalidParticles() { return {}; }
 
    virtual bool isInvalidParticleReturner() { return false; }
 
    virtual std::string getConfigurationAsString() = 0;
 
protected:
 
    double _boundingBoxMin[3];
    double _boundingBoxMax[3];
 
};
 
#endif /* PARTICLECONTAINER_H_ */