BaseCluster.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef BaseCluster_H
#define BaseCluster_H
 
#endif //BaseCluster_H
 
#include <Mercury3D.h>
#include "Species/LinearPlasticViscoelasticFrictionSpecies.h"
 
 
#ifdef MERCURYDPM_USE_MPI
#include <mpi.h>
#include <MpiDataClass.h>
#include <MpiContainer.h>
#endif
 
#ifndef BaseCluster_h
#define BaseCluster_h
class BaseCluster : public Mercury3D
{
public:
 
/*
 * ----------------------------------------------------------------------
 *               FUNCTIONS: setters and getters
 * ----------------------------------------------------------------------
 */
 
    BaseCluster();
 
    ~BaseCluster() final;
 
    Vec3D getPosition() const;
 
    void setPosition(Vec3D p);
 
    Mdouble getCollisionTimeOverTimeStep() const;
 
    void setCollisionTimeOverTimeStep(Mdouble cTOTS);
 
    Mdouble getRadiusParticle() const;
 
    void setRadiusParticle(Mdouble rP);
 
    Mdouble getSizeDispersityParticle() const;
 
    void setSizeDispersityParticle(Mdouble sDP);
 
    int getNumberOfParticles() const;
 
    void setNumberOfParticles(int nP);
 
    void setRadiusCluster(Mdouble rCR);
 
    Mdouble getFinalMassFraction();
 
    unsigned int getClusterId() const;
 
    void setClusterId(unsigned int iC);
 
    Mdouble getVelocityDampingModulus() const;
 
    void setVelocityDampingModulus(Mdouble vDM);
 
    int getNumberOfInternalStructurePoints() const;
 
    void setNumberOfInternalStructurePoints(int gL);
 
    Mdouble getEnergyRatioTolerance() const;
 
    void setEnergyRatioTolerance(Mdouble eRT);
 
    LinearPlasticViscoelasticFrictionSpecies *getParticleSpecies() const;
 
    void setParticleSpecies(LinearPlasticViscoelasticFrictionSpecies *particleSpecies);
 
    Vec3D getVelocity();
    
    void setVelocity(Vec3D v);
 
    bool isCdatOutputOn() const;
 
    void doCdatOutput(bool iCOO);
 
    bool isOverlOutputOn() const;
 
    void doOverlOutput(bool iOOO);
 
    bool isAmatOutputOn() const;
 
    void doAmatOutput(bool iAOO);
 
    bool isIntStrucOutputOn() const;
 
    void doIntStrucOutput(bool iISOO);
 
    bool isVtkOutputOn() const;
 
    void doVtkOutput(bool iVOO);
 
    bool isRestartOutputOn() const;
 
    void doRestartOutput(bool isRestartOutputOn);
 
    bool isFStatOutputOn() const;
 
    void doFStatOutput(bool isfStatOutputOn);
 
    bool isEneOutputOn() const;
 
    void doEneOutput(bool isEneOutputOn);
 
    Mdouble getMeanClusterRadius();
 
    Mdouble getAverageOverlap();
 
/*
 * ----------------------------------------------------------------------
 *               FUNCTIONS: overridden mercury3D functions
 * ----------------------------------------------------------------------
 */
 
 
    void setupInitialConditions() override;
 
    void actionsAfterTimeStep() override;
 
    void actionsAfterSolve() override;
 
    void write(std::ostream& os, bool writeAllParticles) const override;
 
    void read(std::istream& is, ReadOptions opt = ReadOptions::ReadAll) override;
 
    void actionsOnRestart() override;
 
    void printTime() const override;
    
private:
    /*
     * ----------------------------------------------------------------------
     *           FUNCTIONS: functions inside setupInitialConditions
     * ----------------------------------------------------------------------
     */
 
    void setRadii();
 
    void setSpecies();
 
    void setDomainLimits();
 
    void calculateTimeStep();
 
    void insertParticles();
 
    void makeCdatFile();
 
    void makeOverlFile();
 
    bool particleInsertionSuccessful(int n);
 
 
 
    /*
     * ----------------------------------------------------------------------
     *        FUNCTIONS: functions inside actionsAfterTimeStep
     * ----------------------------------------------------------------------
     */
 
    void makeDataAnalysis();
 
    void writeToCdatFile();
 
    void writeToOverlFile();
 
    void applyCentralForce();
 
    void increaseForce();
 
    void dampVelocities();
 
    void decreaseForce();
 
    void dampForce();
 
    void createAdjacencyMatrix();
 
    void makeAmatFile();
 
    void writeAmatFile();
 
    void computeInternalStructure();
 
    void makeGnuplotFile();
 
    void makeIntenalStructureFile();
 
 
 
    /*
     * ----------------------------------------------------------------------
     *       VARIABLES: accessed by the user with setters and getters
     * ----------------------------------------------------------------------
     */
 
    //POSITION
    //\brief Position where the cluster is inserted after creation.
    Vec3D position_;
 
    // TIME
    //\brief Ratio between collision time and time step: should be at least 50.
    Mdouble collisionTimeOverTimeStep_;
    // \brief Energy ratio threshold under wich the simulation can be considered static and so can be stopped.
    Mdouble energyRatioTolerance_;
 
    // PARTiCleS
    //\brief Radius basing on which all radii will be computed.
    Mdouble radiusParticle_;
    // \brief Bool that saves whether or not the user has set the radius of the single particle composing the cluster.
    bool setRadiusParticle_ = false;
    //\brief Size dispersity of particles: must be between >= than 1.
    Mdouble sizeDispersityParticle_;
    //\brief Total number of particles.
    int nParticles_;
    // \brief Bool that saves whether or not the user has set the number of particles
    bool setNumberOfParticles_ = false;
 
    // CLUSTER
    //\brief Total number of particles.
    unsigned int idCluster_;
    //\brief Desired radius of the cluster.
    Mdouble radiusCluster_;
    // \brief Bool that saves whether or not the user has set the cluster radius
    bool setRadiusCluster_ = false;
    //\brief Velocity of the cluster after creation
    Vec3D clusterVelocity_;
    //\brief mean cluster radius after creation.
    Mdouble meanClusterRadius_;
 
    // CENTRAL FORCE
    //\brief Value of damping modulus for velocity.
    Mdouble velocityDampingModulus_;
 
    //  DATA ANALYSIS
    // \brief Number of points used for computing internal structure.
    int nInternalStructurePoints_;
 
    // SPECIES
    //\brief particle species.
    LinearPlasticViscoelasticFrictionSpecies* particleSpecies_;
 
 
    // File
    //\brief bool used to define whether or not cluster data output must be created.
    bool isCdatOutputOn_;
    //\brief bool used to define whether or not overlap data output must be created.
    bool isOverlOutputOn_;
    //\brief bool used to define whether or not adjacency matrix output must be created.
    bool isAmatOutputOn_;
    //\brief bool used to define whether or not cluster internal structure output must be created.
    bool isIntStrucOutputOn_;
    //\brief bool used to define whether or not vtk output must be created.
    bool isVtkOutputOn_;
    //\brief bool used to define whether or not vtk output must be created.
    bool isRestartOutputOn_;
    //\brief bool used to define whether or not vtk output must be created.
    bool isFStatOutputOn_;
    //\brief bool used to define whether or not vtk output must be created.
    bool isEneOutputOn_;
 
 
    /*
     * ----------------------------------------------------------------------
     *                VARIABLES: never accessed by the user
     * ----------------------------------------------------------------------
     */
 
 
    // PARTICLES
    //\brief vector in which all radii will be stored after calculation.
    std::vector<Mdouble> radii_;
    //smallest radius
    Mdouble smallestRadius_;
    //\brief mass of the particle which has radius radiusParticle.
    Mdouble massParticle_;
    //\brief total volume of all particles.
    Mdouble totalParticleVolume_;
 
    // GEOMETRY
    //\brief size of the cubic domain.
    Mdouble boxSize_;
    //\brief center of mass.
    Vec3D centerOfMass_;
 
    // CONTACT RELATED
    //\brief adjacency matrix.
    std::vector< std::vector<int> > adjacencyMatrix_;
    //\brief mean coordination number.
    Mdouble meanCoordinationNumber_;
    //\brief maximum relative overlap.
    Mdouble maxRelativeOverlap_;
    //\brief mean relative overlap.
    Mdouble meanRelativeOverlap_;
    //\brief minimum relative overlap.
    Mdouble minRelativeOverlap_;
    //\brief number of total intra-cluster bonds.
    int nIntraClusterBonds_;
 
    // OUTPUT
    //\brief cluster data file.
    std::ofstream cdatFile_;
    //\brief cluster overlap file.
    std::ofstream overlFile_;
    //\brief gnuplot file.
    std::ofstream gnuplotFile_;
    //\brief adjacency matrix file.
    std::ofstream amatFile_;
    //\brief internal structure file.
    std::ofstream intStructFile_;
    //\brief output time of files and print time.
    Mdouble fileOutputTimeInterval_;
 
    // DATA ANALYSIS
    //\brief radius with which solid fraction is computed
    Mdouble radiusForSolidFraction_;
    //\brief solid fraction computed with the total particle volume and radiusForSolidFraction_.
    Mdouble solidFraction_;
    //\brief solid fraction computed with internal structure analysis.
    Mdouble solidFractionIntStruct_;
 
    // TIME
    // stage of the simulation: 1 compression, 2 decompression, 3 relaxation, 4 simulation ended.
    int stage_;
    //\brief time flag used for the stages duration.
    Mdouble t0_;
    //\brief final time.
    Mdouble clusterTimeMax_;
 
    // CENTRAL FORCE
    //\brief maximum force modulus applied on particles (this value is then multiplied by distance from force center).
    Mdouble maximumForceModulus_;
    //\brief force modulus applied on particles at a certain simulation time.
    Mdouble forceModulus_;
    //\brief time interval on which force is tuned (increased or decreased).
    Mdouble forceTuningInterval_;
    //\brief time interval on which velocity is tuned (increased or decreased).
    Mdouble velocityDampingInterval_;
    //\brief time duration of force tuning (i.e. duration of compression and decompression stages).
    Mdouble forceTuningDuration_;
    //\brief maximum possible time duration of dissipation (i.e. duration of dissipation if energy ratio
    //          tollerance not reached).
    Mdouble dissipationDuration_;
    //\brief Value of damping modulus for forceFactor.
    Mdouble forceDampingModulus_;
 
};
#endif