EnsembleBase.h

#pragma once
 
#include "molecules/Component.h"
 
#include <string>
#include <vector>
#include <map>
 
#include "DomainBase.h"
#include "molecules/MoleculeForwardDeclaration.h"
 
class ParticleContainer;
 
class MixingRuleBase;
 
class ChemicalPotential;
 
class DomainDecompBase;
 
class CellProcessor;
 
class Domain;
 
enum GlobalVariable {
    NUM_PARTICLES = 1 << 0,
    ENERGY = 1 << 1,
    VOLUME = 1 << 2,
    CHEMICAL_POTENTIAL = 1 << 3,
    TEMPERATURE = 1 << 4,
    PRESSURE = 1 << 5
};
 
enum Type {
    undefined,
    NVT,
    muVT
};
 
class XMLfileUnits;
 
class Ensemble {
public:
    Ensemble() :
            _domain(nullptr) {
    }
 
    virtual ~~Ensemble();
 
    virtual void readXML(XMLfileUnits& xmlconfig);
 
    virtual unsigned long N() = 0;
 
    virtual double V() = 0;
 
    virtual double E() = 0;
 
    virtual double mu() = 0;
 
    virtual double p() = 0;
 
    virtual double T() = 0;
 
    virtual void updateGlobalVariable(ParticleContainer* particleContainer, GlobalVariable variable) = 0;
 
    DomainBase*& domain() { return _domain; }
 
    Component* getComponent(int cid) {
        mardyn_assert(cid < static_cast<int>(_components.size()));
        return &_components.at(cid);
    }
 
    Component* getComponent(std::string name) { return getComponent(_componentnamesToIds[name]); }
 
    std::vector<Component>* getComponents() { return &_components; }
 
    void addComponent(Component& component) { _components.push_back(component); }
 
    void setComponentLookUpIDs();
 
    int getType() { return _type; }
 
    virtual std::list<ChemicalPotential>* getLmu() { return nullptr; }
 
    virtual void initConfigXML(ParticleContainer* moleculeContainer) {};
 
    virtual void prepare_start() {};
 
    virtual void
    beforeEventNewTimestep(ParticleContainer* moleculeContainer, DomainDecompBase* domainDecomposition,
                           unsigned long simstep) {};
 
    virtual void
    afterForces(ParticleContainer* moleculeContainer, DomainDecompBase* domainDecomposition,
                CellProcessor* cellProcessor,
                unsigned long simstep) {};
 
    virtual void beforeThermostat(unsigned long simstep, unsigned long initStatistics) {};
 
    virtual void storeSample(Molecule* m, uint32_t componentid) {};
 
protected:
 
 
    std::vector<Component> _components;
    std::map<std::string, int> _componentnamesToIds;
    std::vector<MixingRuleBase*> _mixingrules;
    DomainBase* _domain;
    Type _type = undefined;
 
    /* EnsembleBase has a DomainBase pointer _domain, however this is not compatible
     * with the needed Domain* for the ChemicalPotential/radial function
     * and for whatever reason, Domain does not inherit from DomainBase.
    */
    Domain* _simulationDomain;
};