Domain.h

 
#ifndef DOMAIN_H_
#define DOMAIN_H_
 
#include <string>
#include <map>
#include <array>
#include <cstdint>
 
#include "molecules/Comp2Param.h"
#include "molecules/Component.h"
#include "ensemble/EnsembleBase.h"
#include "Simulation.h"
#include "utils/CommVar.h"
/* 
 * TODO add comments for variables 
 */
#define CHECKPOINT_FILE_VERSION 20160512  
#define MIN_BETA 0.9  
#define KINLIMIT_PER_T 10.0
 
#include "molecules/MoleculeForwardDeclaration.h"
class ParticleContainer;
class DomainDecompBase;
class XMLfileUnits;
 
class Domain {
 
private:
    Domain();
    Domain(Domain &domain);
 
    Domain& operator=(Domain &domain);
    
public:
    Domain(int rank);
 
    void readXML(XMLfileUnits& xmlconfig);
    void writeCheckpoint( std::string filename, ParticleContainer* particleContainer,
            DomainDecompBase* domainDecomp, double currentTime, bool useBinaryFormat = false);
 
    void writeCheckpointHeader(std::string filename,
            ParticleContainer* particleContainer,
            const DomainDecompBase* domainDecomp, double currentTime);
 
    void writeCheckpointHeaderXML(std::string filename,
            ParticleContainer* particleContainer,
            const DomainDecompBase* domainDecomp, double currentTime);
 
//  void initFarFieldCorr(double cutoffRadius, double cutoffRadiusLJ);
 
    void initParameterStreams(double cutoffRadius, double cutoffRadiusLJ);
 
    void setLocalUpot(double Upot);
 
    double getLocalUpot() const;
    
    void setLocalUpotCompSpecific(double UpotCspec);
 
    void setNumFluidComponents(unsigned nc);
    
    unsigned getNumFluidComponents();
    
    double getLocalUpotCompSpecific();
 
    void setLocalVirial(double Virial);
 
    double getLocalVirial() const;
    
    double getGlobalBetaTrans();
    double getGlobalBetaTrans(int thermostat);
 
    double getGlobalBetaRot();
    double getGlobalBetaRot(int thermostat);
 
    double getGlobalLength(int d) const { return _globalLength[d]; }
 
    void setGlobalLength(int index, double length);
 
    double getGlobalCurrentTemperature() { return getCurrentTemperature(0); }
    double getCurrentTemperature(int thermostatID) { return _globalTemperatureMap[thermostatID]; }
    double getTargetTemperature(int thermostatID) { return _universalTargetTemperature[thermostatID]; }
 
    void setGlobalTemperature(double T) { setTargetTemperature(0, T); }
    void setTargetTemperature(int thermostatID, double T);
 
    std::vector<double> & getmixcoeff();
 
    double getepsilonRF() const;
 
    void setepsilonRF(double erf);
 
    unsigned long getglobalNumMolecules() const;
 
    void setglobalNumMolecules(unsigned long glnummol);
    
    void updateglobalNumMolecules(ParticleContainer* particleContainer, DomainDecompBase* domainDecomp);
 
    CommVar<uint64_t> getMaxMoleculeID() const;
 
    void updateMaxMoleculeID(ParticleContainer* particleContainer, DomainDecompBase* domainDecomp);
 
    double getGlobalPressure();
 
    double getAverageGlobalUpot() const;
        double getGlobalUpot() const;
 
    double getAverageGlobalUpotCSpec();
 
    unsigned long getNumFluidMolecules();
 
    double getAverageGlobalVirial() const;
 
    void setLocalSummv2(double summv2, int thermostat);
 
    void setLocalSumIw2(double sumIw2, int thermostat);
 
    void setLocalNrotDOF(int thermostat, unsigned long N, unsigned long rotDOF) {
        this->_localThermostatN[thermostat] = N;
        this->_localRotationalDOF[thermostat] = rotDOF;
    }
    
    double getglobalRho();
 
    void setglobalRho(double grho);
 
    unsigned long getglobalRotDOF();
 
    void setglobalRotDOF(unsigned long grotdof);
 
    Comp2Param& getComp2Params();
 
    void calculateGlobalValues(
            DomainDecompBase* domainDecomp, ParticleContainer* particleContainer,
            bool collectThermostatVelocities, double Tfactor
    );
 
    /* FIXME: alternatively: default values for function parameters */
    void calculateGlobalValues(DomainDecompBase* domainDecomp, ParticleContainer* particleContainer) {
        this->calculateGlobalValues(domainDecomp, particleContainer, false, 1.0);
    }
 
    void calculateVelocitySums(ParticleContainer* partCont);
 
    void calculateThermostatDirectedVelocity(ParticleContainer* partCont);
    bool thermostatIsUndirected(int thermostat) { return this->_universalUndirectedThermostat[thermostat]; }
    double getThermostatDirectedVelocity(int thermostat, int d) { return this->_universalThermostatDirectedVelocity[thermostat][d]; }
 
    bool severalThermostats() { return this->_componentwiseThermostat; }
    int getThermostat(int cid) { return this->_componentToThermostatIdMap[cid]; }
    void disableComponentwiseThermostat() { this->_componentwiseThermostat = false; }
    void enableComponentwiseThermostat();
    unsigned maxThermostat() {
        return (_componentwiseThermostat)? (_universalThermostatN.size() - 2): 0;
    }
    void setComponentThermostat(int cid, int thermostat) {
        if((0 > cid) || (0 >= thermostat)) Simulation::exit(787);
        this->_componentToThermostatIdMap[cid] = thermostat;
        this->_universalThermostatN[thermostat] = 0;
    }
    void enableUndirectedThermostat(int thermostat);
 
    unsigned long N() {return _globalNumMolecules;}
 
    void Nadd(unsigned cid, int N, int localN);
 
    double getGlobalVolume() const { return (_globalLength[0] *  _globalLength[1] *  _globalLength[2]); }
 
    void thermostatOff() { this->_universalNVE = true; }
    void thermostatOn() { this->_universalNVE = false; }
    bool NVE() { return this->_universalNVE; }
    bool thermostatWarning() { return (this->_universalSelectiveThermostatWarning > 0); }
 
    void evaluateRho(unsigned long localN, DomainDecompBase* comm);
    void submitDU(unsigned cid, double DU, double* r);
    void setLambda(double lambda) { this->_universalLambda = lambda; }
        void setDensityCoefficient(float coeff) { _globalDecisiveDensity = coeff; }
        void setProfiledComponentMass(double m) { _universalProfiledComponentMass = m; }
 
    void init_cv(unsigned N, double U, double UU) {
        this->_globalUSteps = N;
        this->_globalSigmaU = U;
        this->_globalSigmaUU = UU;
    }
    void record_cv();
    double cv();
 
    // by Stefan Becker <stefan.becker@mv.uni-kl.de>
    /* method returning the sigma parameter of a component 
    => needed in the output of the MmspdWriter (specifying the particles' radii in a movie) */
    double getSigma(unsigned cid, unsigned nthSigma);
    // needed for the MmspdWriter (MegaMol)
    unsigned getNumberOfComponents();
    
    void setUpotCorr(double upotcorr){ _UpotCorr = upotcorr; }
    void setVirialCorr(double virialcorr){ _VirialCorr = virialcorr; }
 
    // explosion heuristics, NOTE: turn off when using slab thermostat
    void SetExplosionHeuristics(bool bVal) { _bDoExplosionHeuristics = bVal; }
 
private:
 
    int _localRank;
 
    double _localUpot;
    double _localUpotCspecif;
    unsigned _numFluidComponent;
 
    double _localVirial;
    double _globalUpot;
    double _globalUpotCspecif;
    double _globalVirial;
    double _globalRho;
    unsigned long _globalNumMolecules;
    CommVar<uint64_t> _maxMoleculeID;
    double _globalLength[3];
 
    bool _componentwiseThermostat;
    std::map<int, int> _componentToThermostatIdMap;
 
    std::map<int, unsigned long> _localThermostatN;
    std::map<int, unsigned long> _universalThermostatN;
    std::map<int, unsigned long> _localRotationalDOF;
    std::map<int, unsigned long> _universalRotationalDOF;
    std::map<int, double> _globalTemperatureMap;
    std::map<int, double> _universalTargetTemperature;
    std::map<int, double> _universalBTrans;
    std::map<int, double> _universalBRot;
    std::map<int, bool> _universalUndirectedThermostat;
    std::map<int, std::array<double, 3> > _universalThermostatDirectedVelocity;
    std::map<int, std::array<double, 3> > _localThermostatDirectedVelocity;
 
    /* FIXME: This info should go into an ensemble class */
    bool _universalNVE;
 
    unsigned _globalUSteps;
    double _globalSigmaU;
    double _globalSigmaUU;
    std::map<unsigned, bool> _universalProfiledComponents;
        double _universalProfiledComponentMass;  // set from outside
        double _universalLambda;  // set from outside
        float _globalDecisiveDensity;  // set from outside
 
    int _universalSelectiveThermostatCounter;
    int _universalSelectiveThermostatWarning;
    int _universalSelectiveThermostatError;
 
    std::map<int, double> _local2KETrans;
    std::map<int, double> _local2KERot; 
    
    double _epsilonRF;
 
    double _UpotCorr;
    double _VirialCorr;
 
 
    Comp2Param _comp2params;
    std::vector<double> _mixcoeff;
 
    // explosion heuristics, NOTE: turn off when using slab thermostat
    bool _bDoExplosionHeuristics;
};
 
 
#endif /*DOMAIN_H_*/