DPMBase.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef MD_H
#define MD_H

#include <string>
//This is the class that defines the std_save routines
#include "FilesAndRunNumber.h"
//The vector class contains a 3D vector class.
#include "Math/Vector.h"
//This class defines the particle handler
#include "ParticleHandler.h"
//This class defines the wall handler
#include "WallHandler.h"
//This class defines the boundary handler
#include "BoundaryHandler.h"
//This class defines the interaction handler
#include "InteractionHandler.h"
//This class defines the Species handler
#include "SpeciesHandler.h"
//#include "Species/Species.h"
//This class defines the posibleContact lists
#ifdef CONTACT_LIST_HGRID
    #include "PossibleContactList.h"
#endif
//This class defines the random number generator
#include "Math/RNG.h"


class DPMBase : public FilesAndRunNumber
{
public:
    void constructor();

    DPMBase();
    
    DPMBase(const FilesAndRunNumber& other);

    DPMBase(const DPMBase& other);
    
    virtual ~DPMBase();

    void solve();
    
    void checkSettings();

    virtual void writeOutputFiles();

    void solve(int argc, char* argv[]);

    virtual void setupInitialConditions();

    virtual void writeXBallsScript() const;

    virtual double getInfo(const BaseParticle& P) const;

    virtual void writeRestartFile();

    int readRestartFile();

    int readRestartFile(std::string fileName);

//    /*!
//     * \brief Loads all MD data and plots statistics for all timesteps in the .data file
//     */
//    void statisticsFromRestartData(const char *name);

    virtual void write(std::ostream& os, bool writeAllParticles=true) const;

    virtual void read(std::istream& is);

    virtual void readOld(std::istream &is);

    bool readDataFile(const std::string fileName, unsigned int format = 0);

    bool readParAndIniFiles(const std::string fileName);

    bool readNextDataFile(unsigned int format = 0);

    bool findNextExistingDataFile(Mdouble tMin, bool verbose = true);

    friend inline std::ostream& operator<<(std::ostream& os, const DPMBase &md);

    bool readArguments(int argc, char *argv[]);

    virtual bool readNextArgument(int& i, int argc, char *argv[]);

    virtual bool checkParticleForInteraction(const BaseParticle& P);

    //getters and setters

    Mdouble getTime() const;

    unsigned int getNtimeSteps() const;

    void setTime(Mdouble time);

    void setTimeMax(Mdouble newTMax);

    Mdouble getTimeMax() const;

    #ifdef CONTACT_LIST_HGRID
        PossibleContactList& getPossibleContactList();
    #endif

    void setDoCGAlways(bool newDoCGFlag);

    void setRotation(bool newRotFlag);

    bool getRotation() const;

    bool getDoCGAlways() const;
    
    Mdouble getXMin() const;

    Mdouble getXMax() const;

    Mdouble getYMin() const;

    Mdouble getYMax() const;

    Mdouble getZMin() const;

    Mdouble getZMax() const;
    
    void setXMin(Mdouble newXMin);

    void setYMin(Mdouble newYMin);
    
    void setZMin(Mdouble newZMin);
    
    void setXMax(Mdouble newXMax);
    
    void setYMax(Mdouble newYMax);
    
    void setZMax(Mdouble newZMax);
    
    void setTimeStep(Mdouble newDt);

    Mdouble getTimeStep() const;
    
    void setXBallsColourMode(int newCMode);

    int getXBallsColourMode() const;
    
    void setXBallsVectorScale(double newVScale);

    double getXBallsVectorScale() const;

    void setXBallsAdditionalArguments(std::string newXBArgs);

    std::string getXBallsAdditionalArguments() const;
    
    void setXBallsScale(Mdouble newScale);

    double getXBallsScale() const;

    void setGravity(Vec3D newGravity);

    Vec3D getGravity() const;

    void setDimension(unsigned int newDim);

    void setSystemDimensions(unsigned int newDim);

    unsigned int getSystemDimensions() const;

    void setParticleDimensions(unsigned int particleDimensions);

    unsigned int getParticleDimensions() const;

    std::string getRestartVersion() const;

    void setRestartVersion(std::string newRV);

    bool getRestarted() const;
    
    void setRestarted(bool newRestartedFlag);

    bool getAppend() const;

    void setAppend(bool newAppendFlag);
    
    Mdouble getElasticEnergy() const;

    Mdouble getKineticEnergy() const;
    
    bool areInContact(const BaseParticle* pI, const BaseParticle* pJ) const;


    virtual void hGridInsertParticle(BaseParticle *obj UNUSED);

    virtual void hGridUpdateParticle(BaseParticle *obj UNUSED);

    virtual void hGridRemoveParticle(BaseParticle *obj UNUSED);
    
    virtual void hGridUpdateMove(BaseParticle*, Mdouble);

    virtual void gatherContactStatistics(unsigned int index1 UNUSED, int index2 UNUSED, Vec3D Contact UNUSED, Mdouble delta UNUSED, Mdouble ctheta UNUSED, Mdouble fdotn UNUSED, Mdouble fdott UNUSED, Vec3D P1_P2_normal_ UNUSED, Vec3D P1_P2_tangential UNUSED);    

//functions that should only be used in the class definitions 
protected:
    
    virtual void computeAllForces();

    virtual void computeInternalForces(BaseParticle* i);

    virtual void computeInternalForces(BaseParticle* P1, BaseParticle* P2);

    virtual void computeExternalForces(BaseParticle* PI);

    virtual void computeForcesDueToWalls(BaseParticle* PI);
    
    virtual void actionsOnRestart();

    virtual void actionsBeforeTimeLoop();

    virtual void hGridActionsBeforeTimeLoop();

    virtual void hGridActionsBeforeTimeStep();
    
    virtual bool getHGridUpdateEachTimeStep() const;

    virtual void actionsBeforeTimeStep();

    virtual void actionsAfterSolve();

    virtual void actionsAfterTimeStep();

    virtual void outputXBallsData(std::ostream& os) const;
    
    virtual void outputXBallsDataParticle(const unsigned int i,const unsigned int format, std::ostream& os) const;

    virtual void writeEneHeader(std::ostream& os) const;

    virtual void writeFstatHeader(std::ostream& os) const;

    virtual void writeEneTimestep(std::ostream& os) const;
    
     // Functions for statistics
    virtual void initialiseStatistics();

    virtual void outputStatistics();

    void gatherContactStatistics();

    virtual void processStatistics(bool usethese UNUSED);

    virtual void finishStatistics();

    virtual void integrateBeforeForceComputation();

    virtual void integrateAfterForceComputation();

    virtual void checkInteractionWithBoundaries();

    virtual void hGridActionsBeforeIntegration();

    virtual void hGridActionsAfterIntegration();

    virtual void broadPhase(BaseParticle* i);

    void setFixedParticles(unsigned int n);

    void initialiseTangentialSprings();

    virtual void printTime() const;

    virtual bool continueSolve() const;

    void outputInteractionDetails() const;

    bool isTimeEqualTo(Mdouble time) const;

    void removeDuplicatePeriodicParticles();

    void checkAndDuplicatePeriodicParticles();

private:
    
    unsigned int systemDimensions_;

    unsigned int particleDimensions_;

    Vec3D gravity_;

    Mdouble xMin_;
    
    Mdouble xMax_;
    
    Mdouble yMin_;
    
    Mdouble yMax_;
    
    Mdouble zMin_;
    
    Mdouble zMax_;

    Mdouble time_;

    unsigned int ntimeSteps_;

    Mdouble timeStep_;

    Mdouble timeMax_;

    Mdouble elasticEnergy_;

    std::string restartVersion_;

    bool restarted_; 

    bool append_;

    bool rotation_;

    //This is the private data that is only used by the xballs output

    int xBallsColourMode_; 
    
    Mdouble xBallsVectorScale_;

    Mdouble xBallsScale_;

    std::string xBallsAdditionalArguments_; 

    //This belongs to the hGrid
    
    // defines a Macro for creating an instance of class PossibleContactList. See PossbileContactList.h     
    #ifdef CONTACT_LIST_HGRID
        PossibleContactList possibleContactList;
    #endif

public:

    SpeciesHandler speciesHandler;

    RNG random;

    ParticleHandler particleHandler;

    WallHandler wallHandler;

    BoundaryHandler boundaryHandler;

    InteractionHandler interactionHandler;

};
#endif