#include <BaseCluster.h>

Inheritance diagram for BaseCluster:

Public Member Functions
	BaseCluster ()
	Default constructor. More...

	~BaseCluster () final
	Default destructor. More...

Vec3D	getPosition () const
	This returns the value of position_, which is the position in which the cluster will be inserted. More...

void	setPosition (Vec3D p)
	This sets the value of position_, which is the position in which the cluster will be inserted. More...

Mdouble	getCollisionTimeOverTimeStep () const
	This returns the value of the ratio between collision time and time step. More...

void	setCollisionTimeOverTimeStep (Mdouble cTOTS)
	This sets the collisionTimeOverTimeStep number (which is the ratio between collision time and time step). More...

Mdouble	getRadiusParticle () const
	This returns the value of particles' radius if there's no dispersity in size. In case of dispersity != 1, this is the radius from which all radii are computed (as a consequence in this case it is also the pseudo-averaged radius). More...

void	setRadiusParticle (Mdouble rP)
	This sets the value of particles' radius if there's no dispersity in size. More...

Mdouble	getSizeDispersityParticle () const
	This returns the value of particles' dispersity in size. More...

void	setSizeDispersityParticle (Mdouble sDP)
	This sets the value of particles' dispersity in size. More...

int	getNumberOfParticles () const
	This returns the value of the number of particles in the cluster. More...

void	setNumberOfParticles (int nP)
	This sets the value of the number of particles in the cluster. More...

void	setRadiusCluster (Mdouble rCR)
	This sets the desired value of the cluster radius (there is no getter of this value, but there is a getter of the actual mean cluster radius obtained, getMeanClusterRadius) More...

Mdouble	getFinalMassFraction ()
	This gets the final value obtained for the mass fraction;. More...

unsigned int	getClusterId () const
	This returns the value of the cluster ID. More...

void	setClusterId (unsigned int iC)
	This sets the value of the cluster ID. More...

Mdouble	getVelocityDampingModulus () const
	This returns the value of the velocity damping modulus. More...

void	setVelocityDampingModulus (Mdouble vDM)
	This sets the value of the velocity damping modulus. More...

int	getNumberOfInternalStructurePoints () const
	This returns the value of the number of particles used to compute internal structure. More...

void	setNumberOfInternalStructurePoints (int gL)
	This sets the value of the number of particles used to compute the internal structure. More...

Mdouble	getEnergyRatioTolerance () const
	This returns the value of the value of the energy ratio threshold under which the process can be considered static, and so over. More...

void	setEnergyRatioTolerance (Mdouble eRT)
	This sets the value of the value of the energy ratio threshold under which the process can be considered static, and so over. More...

LinearPlasticViscoelasticFrictionSpecies *	getParticleSpecies () const
	This returns the species of the particle. More...

void	setParticleSpecies (LinearPlasticViscoelasticFrictionSpecies *particleSpecies)
	This sets the species of the particle. More...

Vec3D	getVelocity ()
	This gets the value of velocity after creation. More...

void	setVelocity (Vec3D v)
	This sets the value of velocity after creation. More...

bool	isCdatOutputOn () const
	This returns the bool variable that defines whether the cluster data output (which is NOT the mercury data output) is written or not. More...

void	doCdatOutput (bool iCOO)
	This sets the bool variable that defines whether the cluster data output will be written or not. More...

bool	isOverlOutputOn () const
	This returns the bool variable that defines whether the cluster overlap output is written or not. More...

void	doOverlOutput (bool iOOO)
	This sets the bool variable that defines whether the cluster overlap output will be written or not. More...

bool	isAmatOutputOn () const
	This returns the bool variable that defines whether the cluster adjacency matrix output is written or not. More...

void	doAmatOutput (bool iAOO)
	This sets the bool variable that defines whether the cluster adjacency matrix output will be written or not. More...

bool	isIntStrucOutputOn () const
	This returns the bool variable that defines whether the cluster internal structure output is written or not. More...

void	doIntStrucOutput (bool iISOO)
	This sets the bool variable that defines whether the cluster internal structure output will be written or not. More...

bool	isVtkOutputOn () const
	This returns the bool variable that defines whether the cluster vtk output is written or not. More...

void	doVtkOutput (bool iVOO)
	This sets the bool variable that defines whether the cluster vtk output will be written or not. More...

bool	isRestartOutputOn () const
	This returns the bool variable that defines whether the cluster restart output is written or not. More...

void	doRestartOutput (bool isRestartOutputOn)
	This sets the bool variable that defines whether the cluster restart output will be written or not. More...

bool	isFStatOutputOn () const
	This returns the bool variable that defines whether the cluster fStat output is written or not. More...

void	doFStatOutput (bool isfStatOutputOn)
	This sets the bool variable that defines whether the cluster fStat output will be written or not. More...

bool	isEneOutputOn () const
	This returns the bool variable that defines whether the cluster ene output is written or not. More...

void	doEneOutput (bool isEneOutputOn)
	This sets the bool variable that defines whether the cluster ene output will be written or not. More...

Mdouble	getMeanClusterRadius ()
	this returns meanClusterRadius (radius of an ideal perfectly spherical cluster, there's no setter). More...

Mdouble	getAverageOverlap ()
	this returns the average overlap. More...

void	setupInitialConditions () override
	Overrides DPMBase setupInitialConditions(): in this initial conditions for the problem are set. More...

void	actionsAfterTimeStep () override
	Overrides DPMBase actionsAfterTimeStep(): in this compression and decompression are computed, depending on the variable stage_. More...

void	actionsAfterSolve () override
	Overrides DPMBase actionsAfterSolve(): in this cluster data file and cluster overlap file are closed and a few final actions are executed. Details in BaseCluster.cc. More...

void	write (std::ostream &os, bool writeAllParticles) const override
	Overrides DPMBase write(): in this all variables needed by the program for restarting are written. More...

void	read (std::istream &is, ReadOptions opt=ReadOptions::ReadAll) override
	Overrides DPMBase read(): in this all variables needed by the program for restarting are read. More...

void	actionsOnRestart () override
	Overrides DPMBase actionsOnRestart(): in this all variables needed by the program for restarting are initialized. More...

void	printTime () const override
	Overrides DPMBase printTime(): this way variables of interest are shown. More...

Public Member Functions inherited from Mercury3D
	Mercury3D ()
	This is the default constructor. All it does is set sensible defaults. More...

	Mercury3D (const DPMBase &other)
	Copy-constructor for creates an Mercury3D problem from an existing MD problem. More...

	Mercury3D (const Mercury3D &other)
	Copy-constructor. More...

void	constructor ()
	Function that sets the SystemDimension and ParticleDimension to 3. More...

std::vector< BaseParticle * >	hGridFindParticleContacts (const BaseParticle *obj) override
	Returns all particles that have a contact with a given particle. More...

Public Member Functions inherited from MercuryBase
	MercuryBase ()
	This is the default constructor. It sets sensible defaults. More...

	~MercuryBase () override
	This is the default destructor. More...

	MercuryBase (const MercuryBase &mercuryBase)
	Copy-constructor. More...

void	constructor ()
	This is the actual constructor, it is called do both constructors above. More...

void	hGridActionsBeforeTimeLoop () override
	This sets up the broad phase information, has to be done at this stage because it requires the particle size. More...

void	hGridActionsBeforeTimeStep () override
	Performs all necessary actions before a time-step, like updating the particles and resetting all the bucket information, etc. More...

void	read (std::istream &is, ReadOptions opt=ReadOptions::ReadAll) override
	Reads the MercuryBase from an input stream, for example a restart file. More...

void	write (std::ostream &os, bool writeAllParticles=true) const override
	Writes all data into a restart file. More...

Mdouble	getHGridCurrentMaxRelativeDisplacement () const
	Returns hGridCurrentMaxRelativeDisplacement_. More...

Mdouble	getHGridTotalCurrentMaxRelativeDisplacement () const
	Returns hGridTotalCurrentMaxRelativeDisplacement_. More...

void	setHGridUpdateEachTimeStep (bool updateEachTimeStep)
	Sets whether or not the HGrid must be updated every time step. More...

bool	getHGridUpdateEachTimeStep () const final
	Gets whether or not the HGrid is updated every time step. More...

void	setHGridMaxLevels (unsigned int HGridMaxLevels)
	Sets the maximum number of levels of the HGrid in this MercuryBase. More...

unsigned int	getHGridMaxLevels () const
	Gets the maximum number of levels of the HGrid in this MercuryBase. More...

HGridMethod	getHGridMethod () const
	Gets whether the HGrid in this MercuryBase is BOTTOMUP or TOPDOWN. More...

void	setHGridMethod (HGridMethod hGridMethod)
	Sets the HGridMethod to either BOTTOMUP or TOPDOWN. More...

HGridDistribution	getHGridDistribution () const
	Gets how the sizes of the cells of different levels are distributed. More...

void	setHGridDistribution (HGridDistribution hGridDistribution)
	Sets how the sizes of the cells of different levels are distributed. More...

Mdouble	getHGridCellOverSizeRatio () const
	Gets the ratio of the smallest cell over the smallest particle. More...

void	setHGridCellOverSizeRatio (Mdouble cellOverSizeRatio)
	Sets the ratio of the smallest cell over the smallest particle. More...

bool	hGridNeedsRebuilding ()
	Gets if the HGrid needs rebuilding before anything else happens. More...

virtual unsigned int	getHGridTargetNumberOfBuckets () const
	Gets the desired number of buckets, which is the maximum of the number of particles and 10. More...

virtual Mdouble	getHGridTargetMinInteractionRadius () const
	Gets the desired size of the smallest cells of the HGrid. More...

virtual Mdouble	getHGridTargetMaxInteractionRadius () const
	Gets the desired size of the largest cells of the HGrid. More...

bool	checkParticleForInteraction (const BaseParticle &P) final
	Checks if given BaseParticle has an interaction with a BaseWall or other BaseParticle. More...

bool	checkParticleForInteractionLocal (const BaseParticle &P) final
	Checks if the given BaseParticle has an interaction with a BaseWall or other BaseParticles in a local domain. More...

virtual Mdouble	userHGridCellSize (unsigned int level)
	Virtual function that enables inheriting classes to implement a function to let the user set the cell size of the HGrid. More...

void	hGridInfo (std::ostream &os=std::cout) const
	Writes the info of the HGrid to the screen in a nice format. More...

Public Member Functions inherited from DPMBase
void	constructor ()
	A function which initialises the member variables to default values, so that the problem can be solved off the shelf; sets up a basic two dimensional problem which can be solved off the shelf. It is called in the constructor DPMBase(). More...

	DPMBase ()
	Constructor that calls the "void constructor()". More...

	DPMBase (const DPMBase &other)
	Copy constructor type-2. More...

virtual	~DPMBase ()
	virtual destructor More...

void	autoNumber ()
	The autoNumber() function calls three functions: setRunNumber(), readRunNumberFromFile() and incrementRunNumberInFile(). More...

std::vector< int >	get1DParametersFromRunNumber (int size_x) const
	This turns a counter into 1 index, which is a useful feature for performing 1D parameter study. The index run from 1:size_x, while the study number starts at 0 (initially the counter=1 in COUNTER_DONOTDEL) More...

std::vector< int >	get2DParametersFromRunNumber (int size_x, int size_y) const
	This turns a counter into 2 indices which is a very useful feature for performing a 2D study. The indices run from 1:size_x and 1:size_y, while the study number starts at 0 ( initially the counter=1 in COUNTER_DONOTDEL) More...

std::vector< int >	get3DParametersFromRunNumber (int size_x, int size_y, int size_z) const
	This turns a counter into 3 indices, which is a useful feature for performing a 3D parameter study. The indices run from 1:size_x, 1:size_y and 1:size_z, while the study number starts at 0 ( initially the counter=1 in COUNTER_DONOTDEL) More...

int	launchNewRun (const char *name, bool quick=false)
	This launches a code from within this code. Please pass the name of the code to run. More...

void	setRunNumber (int runNumber)
	This sets the counter/Run number, overriding the defaults. More...

int	getRunNumber () const
	This returns the current value of the counter (runNumber_) More...

virtual void	decompose ()
	Sends particles from processorId to the root processor. More...

void	solve ()
	The work horse of the code. More...

virtual void	computeOneTimeStep ()
	Performs everything needed for one time step, used in the time-loop of solve(). More...

void	checkSettings ()
	Checks if the essentials are set properly to go ahead with solving the problem. More...

void	forceWriteOutputFiles ()
	Writes output files immediately, even if the current time step was not meant to be written. Also resets the last saved time step. More...

virtual void	writeOutputFiles ()
	Writes simulation data to all the main Mercury files: .data, .ene, .fstat, .xballs and .restart (see the Mercury website for more details regarding these files). More...

void	solve (int argc, char *argv[])
	The work horse of the code. Can handle flags from the command line. More...

virtual void	writeXBallsScript () const
	This writes a script which can be used to load the xballs problem to display the data just generated. More...

virtual Mdouble	getInfo (const BaseParticle &P) const
	A virtual function that returns some user-specified information about a particle. More...

ParticleVtkWriter *	getVtkWriter () const

virtual void	writeRestartFile ()
	Stores all the particle data for current save time step to a "restart" file, which is a file simply intended to store all the information necessary to "restart" a simulation from a given time step (see also MercuryDPM.org for more information on restart files). More...

void	writeDataFile ()

void	writeEneFile ()

void	writeFStatFile ()

void	fillDomainWithParticles (unsigned N=50)

bool	readRestartFile (ReadOptions opt=ReadOptions::ReadAll)
	Reads all the particle data corresponding to a given, existing . restart file (for more details regarding restart files, refer to the training materials on the MercuryDPM website).Returns true if it is successful, false otherwise. More...

int	readRestartFile (std::string fileName, ReadOptions opt=ReadOptions::ReadAll)
	The same as readRestartFile(bool), but also reads all the particle data corresponding to the current saved time step. More...

virtual BaseWall *	readUserDefinedWall (const std::string &type) const
	Allows you to read in a wall defined in a Driver directory; see USER/Luca/ScrewFiller. More...

virtual void	readOld (std::istream &is)
	Reads all data from a restart file, e.g. domain data and particle data; old version. More...

bool	readDataFile (std::string fileName="", unsigned int format=0)
	This allows particle data to be reloaded from data files. More...

bool	readParAndIniFiles (std::string fileName)
	Allows the user to read par.ini files (useful to read files produced by the MDCLR simulation code - external to MercuryDPM) More...

bool	readNextDataFile (unsigned int format=0)
	Reads the next data file with default format=0. However, one can modify the format based on whether the particle data corresponds to 3D or 2D data- see Visualising data in xballs. More...

void	readNextFStatFile ()
	Reads the next fstat file. More...

bool	findNextExistingDataFile (Mdouble tMin, bool verbose=true)
	Finds and opens the next data file, if such a file exists. More...

bool	readArguments (int argc, char *argv[])
	Can interpret main function input arguments that are passed by the driver codes. More...

bool	checkParticleForInteractionLocalPeriodic (const BaseParticle &P)

void	readSpeciesFromDataFile (bool read=true)

void	importParticlesAs (ParticleHandler &particleHandler, InteractionHandler &interactionHandler, const ParticleSpecies *species)
	Copies particles, interactions assigning species from a local simulation to a global one. Useful for the creation of a cluster. More...

MERCURY_DEPRECATED File &	getDataFile ()
	The non const version. Allows one to edit the File::dataFile. More...

MERCURY_DEPRECATED File &	getEneFile ()
	The non const version. Allows to edit the File::eneFile. More...

MERCURY_DEPRECATED File &	getFStatFile ()
	The non const version. Allows to edit the File::fStatFile. More...

MERCURY_DEPRECATED File &	getRestartFile ()
	The non const version. Allows to edit the File::restartFile. More...

MERCURY_DEPRECATED File &	getStatFile ()
	The non const version. Allows to edit the File::statFile. More...

File &	getInteractionFile ()
	Return a reference to the file InteractionsFile. More...

MERCURY_DEPRECATED const File &	getDataFile () const
	The const version. Does not allow for any editing of the File::dataFile. More...

MERCURY_DEPRECATED const File &	getEneFile () const
	The const version. Does not allow for any editing of the File::eneFile. More...

MERCURY_DEPRECATED const File &	getFStatFile () const
	The const version. Does not allow for any editing of the File::fStatFile. More...

MERCURY_DEPRECATED const File &	getRestartFile () const
	The const version. Does not allow for any editing of the File::restartFile. More...

MERCURY_DEPRECATED const File &	getStatFile () const
	The const version. Does not allow for any editing of the File::statFile. More...

const File &	getInteractionFile () const

const std::string &	getName () const
	Returns the name of the file. Does not allow to change it though. More...

void	setName (const std::string &name)
	Allows to set the name of all the files (ene, data, fstat, restart, stat) More...

void	setName (const char *name)
	Calls setName(std::string) More...

void	setSaveCount (unsigned int saveCount)
	Sets File::saveCount_ for all files (ene, data, fstat, restart, stat) More...

void	setFileType (FileType fileType)
	Sets File::fileType_ for all files (ene, data, fstat, restart, stat) More...

void	setOpenMode (std::fstream::openmode openMode)
	Sets File::openMode_ for all files (ene, data, fstat, restart, stat) More...

void	resetFileCounter ()
	Resets the file counter for each file i.e. for ene, data, fstat, restart, stat) More...

void	closeFiles ()
	Closes all files (ene, data, fstat, restart, stat) that were opened to read or write. More...

void	setLastSavedTimeStep (unsigned int nextSavedTimeStep)
	Sets the next time step for all the files (ene, data, fstat, restart, stat) at which the data is to be written or saved. More...

Mdouble	getTime () const
	Returns the current simulation time. More...

Mdouble	getNextTime () const
	Returns the current simulation time. More...

unsigned int	getNumberOfTimeSteps () const
	Returns the current counter of time-steps, i.e. the number of time-steps that the simulation has undergone so far. More...

void	setTime (Mdouble time)
	Sets a new value for the current simulation time. More...

void	setTimeMax (Mdouble newTMax)
	Sets a new value for the maximum simulation duration. More...

Mdouble	getTimeMax () const
	Returns the maximum simulation duration. More...

void	setLogarithmicSaveCount (Mdouble logarithmicSaveCountBase)
	Sets File::logarithmicSaveCount_ for all files (ene, data, fstat, restart, stat) More...

void	setNToWrite (int nToWrite)
	set the number of elements to write to the screen More...

int	getNToWrite () const
	get the number of elements to write to the More...

void	setRotation (bool rotation)
	Sets whether particle rotation is enabled or disabled. More...

bool	getRotation () const
	Indicates whether particle rotation is enabled or disabled. More...

void	setWallsWriteVTK (FileType writeWallsVTK)
	Sets whether walls are written into a VTK file. More...

void	setWallsWriteVTK (bool)
	Sets whether walls are written into a VTK file. More...

void	setInteractionsWriteVTK (bool)
	Sets whether interactions are written into a VTK file. More...

void	setParticlesWriteVTK (bool writeParticlesVTK)
	Sets whether particles are written in a VTK file. More...

void	setSuperquadricParticlesWriteVTK (bool writeSuperquadricParticlesVTK)

FileType	getWallsWriteVTK () const
	Returns whether walls are written in a VTK file. More...

bool	getParticlesWriteVTK () const
	Returns whether particles are written in a VTK file. More...

bool	getSuperquadricParticlesWriteVTK () const

Mdouble	getXMin () const
	If the length of the problem domain in x-direction is XMax - XMin, then getXMin() returns XMin. More...

Mdouble	getXMax () const
	If the length of the problem domain in x-direction is XMax - XMin, then getXMax() returns XMax. More...

Mdouble	getYMin () const
	If the length of the problem domain in y-direction is YMax - YMin, then getYMin() returns YMin. More...

Mdouble	getYMax () const
	If the length of the problem domain in y-direction is YMax - YMin, then getYMax() returns XMax. More...

Mdouble	getZMin () const
	If the length of the problem domain in z-direction is ZMax - ZMin, then getZMin() returns ZMin. More...

Mdouble	getZMax () const
	If the length of the problem domain in z-direction is ZMax - ZMin, then getZMax() returns ZMax. More...

Vec3D	getMin () const

Vec3D	getMax () const

void	setXMin (Mdouble newXMin)
	Sets the value of XMin, the lower bound of the problem domain in the x-direction. More...

void	setYMin (Mdouble newYMin)
	Sets the value of YMin, the lower bound of the problem domain in the y-direction. More...

void	setZMin (Mdouble newZMin)
	Sets the value of ZMin, the lower bound of the problem domain in the z-direction. More...

void	setXMax (Mdouble newXMax)
	Sets the value of XMax, the upper bound of the problem domain in the x-direction. More...

void	setYMax (Mdouble newYMax)
	Sets the value of YMax, the upper bound of the problem domain in the y-direction. More...

void	setZMax (Mdouble newZMax)
	Sets the value of ZMax, the upper bound of the problem domain in the z-direction. More...

void	setMax (const Vec3D &max)
	Sets the maximum coordinates of the problem domain. More...

void	setMax (Mdouble, Mdouble, Mdouble)
	Sets the maximum coordinates of the problem domain. More...

void	setDomain (const Vec3D &min, const Vec3D &max)
	Sets the minimum coordinates of the problem domain. More...

void	setMin (const Vec3D &min)
	Sets the minimum coordinates of the problem domain. More...

void	setMin (Mdouble, Mdouble, Mdouble)
	Sets the minimum coordinates of the problem domain. More...

void	setTimeStep (Mdouble newDt)
	Sets a new value for the simulation time step. More...

Mdouble	getTimeStep () const
	Returns the simulation time step. More...

void	setNumberOfOMPThreads (int numberOfOMPThreads)

int	getNumberOfOMPThreads () const

void	setXBallsColourMode (int newCMode)
	Set the xballs output mode. More...

int	getXBallsColourMode () const
	Get the xballs colour mode (CMode). More...

void	setXBallsVectorScale (double newVScale)
	Set the scale of vectors in xballs. More...

double	getXBallsVectorScale () const
	Returns the scale of vectors used in xballs. More...

void	setXBallsAdditionalArguments (std::string newXBArgs)
	Set the additional arguments for xballs. More...

std::string	getXBallsAdditionalArguments () const
	Returns the additional arguments for xballs. More...

void	setXBallsScale (Mdouble newScale)
	Sets the scale of the view (either normal, zoom in or zoom out) to display in xballs. The default is fit to screen. More...

double	getXBallsScale () const
	Returns the scale of the view in xballs. More...

void	setGravity (Vec3D newGravity)
	Sets a new value for the gravitational acceleration. More...

Vec3D	getGravity () const
	Returns the gravitational acceleration. More...

void	setDimension (unsigned int newDim)
	Sets both the system dimensions and the particle dimensionality. More...

void	setSystemDimensions (unsigned int newDim)
	Sets the system dimensionality. More...

unsigned int	getSystemDimensions () const
	Returns the system dimensionality. More...

void	setParticleDimensions (unsigned int particleDimensions)
	Sets the particle dimensionality. More...

unsigned int	getParticleDimensions () const
	Returns the particle dimensionality. More...

std::string	getRestartVersion () const
	This is to take into account for different Mercury versions. Returns the version of the restart file. More...

void	setRestartVersion (std::string newRV)
	Sets restart_version. More...

bool	getRestarted () const
	Returns the flag denoting if the simulation was restarted or not. More...

void	setRestarted (bool newRestartedFlag)
	Allows to set the flag stating if the simulation is to be restarted or not. More...

bool	getAppend () const
	Returns whether the "append" option is on or off. More...

void	setAppend (bool newAppendFlag)
	Sets whether the "append" option is on or off. More...

Mdouble	getElasticEnergy () const
	Returns the global elastic energy within the system. More...

Mdouble	getKineticEnergy () const
	Returns the global kinetic energy stored in the system. More...

Mdouble	getGravitationalEnergy () const
	Returns the global gravitational potential energy stored in the system. More...

Mdouble	getRotationalEnergy () const
	JMFT Returns the global rotational energy stored in the system. More...

Mdouble	getTotalEnergy () const

Mdouble	getTotalMass () const
	JMFT: Return the total mass of the system, excluding fixed particles. More...

Vec3D	getCentreOfMass () const
	JMFT: Return the centre of mass of the system, excluding fixed particles. More...

Vec3D	getTotalMomentum () const
	JMFT: Return the total momentum of the system, excluding fixed particles. More...

double	getCPUTime ()

double	getWallTime ()

virtual void	hGridInsertParticle (BaseParticle *obj UNUSED)

virtual void	hGridUpdateParticle (BaseParticle *obj UNUSED)

virtual void	hGridRemoveParticle (BaseParticle *obj UNUSED)

bool	mpiIsInCommunicationZone (BaseParticle *particle)
	Checks if the position of the particle is in an mpi communication zone or not. More...

bool	mpiInsertParticleCheck (BaseParticle *P)
	Function that checks if the mpi particle should really be inserted by the current domain. More...

void	insertGhostParticle (BaseParticle *P)
	This function inserts a particle in the mpi communication boundaries. More...

void	updateGhostGrid (BaseParticle *P)
	Checks if the Domain/periodic interaction distance needs to be updated and updates it accordingly. More...

virtual void	gatherContactStatistics (unsigned int index1, int index2, Vec3D Contact, Mdouble delta, Mdouble ctheta, Mdouble fdotn, Mdouble fdott, Vec3D P1_P2_normal_, Vec3D P1_P2_tangential)
	//Not unsigned index because of possible wall collisions. More...

void	setNumberOfDomains (std::vector< unsigned > direction)
	Sets the number of domains in x-,y- and z-direction. Required for parallel computations. More...

void	splitDomain (DomainSplit domainSplit)

std::vector< unsigned >	getNumberOfDomains ()
	returns the number of domains More...

Domain *	getCurrentDomain ()
	Function that returns a pointer to the domain corresponding to the processor. More...

void	removeOldFiles () const

void	setMeanVelocity (Vec3D V_mean_goal)
	This function will help you set a fixed kinetic energy and mean velocity in your system. More...

void	setMeanVelocityAndKineticEnergy (Vec3D V_mean_goal, Mdouble Ek_goal)
	This function will help you set a fixed kinetic energy and mean velocity in your system. More...

Mdouble	getTotalVolume () const
	Get the total volume of the cuboid system. More...

Matrix3D	getKineticStress () const
	Calculate the kinetic stress tensor in the system averaged over the whole volume. More...

Matrix3D	getStaticStress () const
	Calculate the static stress tensor in the system averaged over the whole volume. More...

Matrix3D	getTotalStress () const
	Calculate the total stress tensor in the system averaged over the whole volume. More...

virtual void	handleParticleRemoval (unsigned int id)
	Handles the removal of particles from the particleHandler. More...

virtual void	handleParticleAddition (unsigned int id, BaseParticle *p)

void	writePythonFileForVTKVisualisation () const

Private Member Functions
void	setRadii ()
	Sets all radii according to particleRadius and sizeDispersityParticle. More...

void	setSpecies ()
	Sets species of particles. More...

void	setDomainLimits ()
	Sets domain limits. More...

void	calculateTimeStep ()
	Calculates the time step. More...

void	insertParticles ()
	Inserts particles inside the domain. More...

void	makeCdatFile ()
	Creates the cluster data output file. More...

void	makeOverlFile ()
	Creates the cluster overlap output file. More...

bool	particleInsertionSuccessful (int n)
	This function tries to insert the n-th particle (returns true if it manage to do that). It is inside insertParticles(). More...

void	makeDataAnalysis ()
	This functions computes some important cluster information needed by the program. More...

void	writeToCdatFile ()
	This writes on the cluster data output file. More...

void	writeToOverlFile ()
	This writes on the cluster overlap output file. More...

void	applyCentralForce ()
	This applies force on each particle. More...

void	increaseForce ()
	This linearly increases the value of forceModulus (stage = 1). More...

void	dampVelocities ()
	This damps values of each particle velocity (stage = 1, stage = 2, stage = 3). More...

void	decreaseForce ()
	This linearly decreases values of forceModulus (stage = 2). More...

void	dampForce ()
	This damps values of forceModulus (stage = 3). More...

void	createAdjacencyMatrix ()
	This calculates the adjacency matrix of the cluster. More...

void	makeAmatFile ()
	This creates the adjacency matrix file. More...

void	writeAmatFile ()
	This writes on the adjacency matrix file. More...

void	computeInternalStructure ()
	This computes the internal structure of the cluster. More...

void	makeGnuplotFile ()
	This creates the gnuplot file needed for printing force vs overlaps values. More...

void	makeIntenalStructureFile ()
	This creates the file needed for writing down datas from computeInternalStructure(). More...

Private Attributes
Vec3D	position_

Mdouble	collisionTimeOverTimeStep_

Mdouble	energyRatioTolerance_

Mdouble	radiusParticle_

bool	setRadiusParticle_ = false

Mdouble	sizeDispersityParticle_

int	nParticles_

bool	setNumberOfParticles_ = false

unsigned int	idCluster_

Mdouble	radiusCluster_

bool	setRadiusCluster_ = false

Vec3D	clusterVelocity_

Mdouble	meanClusterRadius_

Mdouble	velocityDampingModulus_

int	nInternalStructurePoints_

LinearPlasticViscoelasticFrictionSpecies *	particleSpecies_

bool	isCdatOutputOn_

bool	isOverlOutputOn_

bool	isAmatOutputOn_

bool	isIntStrucOutputOn_

bool	isVtkOutputOn_

bool	isRestartOutputOn_

bool	isFStatOutputOn_

bool	isEneOutputOn_

std::vector< Mdouble >	radii_

Mdouble	smallestRadius_

Mdouble	massParticle_

Mdouble	totalParticleVolume_

Mdouble	boxSize_

Vec3D	centerOfMass_

std::vector< std::vector< int > >	adjacencyMatrix_

Mdouble	meanCoordinationNumber_

Mdouble	maxRelativeOverlap_

Mdouble	meanRelativeOverlap_

Mdouble	minRelativeOverlap_

int	nIntraClusterBonds_

std::ofstream	cdatFile_

std::ofstream	overlFile_

std::ofstream	gnuplotFile_

std::ofstream	amatFile_

std::ofstream	intStructFile_

Mdouble	fileOutputTimeInterval_

Mdouble	radiusForSolidFraction_

Mdouble	solidFraction_

Mdouble	solidFractionIntStruct_

int	stage_

Mdouble	t0_

Mdouble	clusterTimeMax_

Mdouble	maximumForceModulus_

Mdouble	forceModulus_

Mdouble	forceTuningInterval_

Mdouble	velocityDampingInterval_

Mdouble	forceTuningDuration_

Mdouble	dissipationDuration_

Mdouble	forceDampingModulus_

Additional Inherited Members
Public Types inherited from DPMBase
enum	ReadOptions : int { ReadOptions::ReadAll, ReadOptions::ReadNoInteractions, ReadOptions::ReadNoParticlesAndInteractions }

enum	DomainSplit { DomainSplit::X, DomainSplit::Y, DomainSplit::Z, DomainSplit::XY, DomainSplit::XZ, DomainSplit::YZ, DomainSplit::XYZ }

Static Public Member Functions inherited from DPMBase
static void	incrementRunNumberInFile ()
	Increment the run Number (counter value) stored in the file_counter (COUNTER_DONOTDEL) by 1 and store the new value in the counter file. More...

static int	readRunNumberFromFile ()
	Read the run number or the counter from the counter file (COUNTER_DONOTDEL) More...

static bool	areInContact (const BaseParticle pI, const BaseParticle pJ)
	Checks if two particle are in contact or is there any positive overlap. More...

Public Attributes inherited from DPMBase
SpeciesHandler	speciesHandler
	A handler to that stores the species type i.e. LinearViscoelasticSpecies, etc. More...

RNG	random
	This is a random generator, often used for setting up the initial conditions etc... More...

ParticleHandler	particleHandler
	An object of the class ParticleHandler, contains the pointers to all the particles created. More...

ParticleHandler	paoloParticleHandler
	Fake particleHandler created by Paolo needed temporary by just Paolo. More...

WallHandler	wallHandler
	An object of the class WallHandler. Contains pointers to all the walls created. More...

BoundaryHandler	boundaryHandler
	An object of the class BoundaryHandler which concerns insertion and deletion of particles into or from regions. More...

PeriodicBoundaryHandler	periodicBoundaryHandler
	Internal handler that deals with periodic boundaries, especially in a parallel build. More...

DomainHandler	domainHandler
	An object of the class DomainHandler which deals with parallel code. More...

InteractionHandler	interactionHandler
	An object of the class InteractionHandler. More...

CGHandler	cgHandler
	Object of the class cgHandler. More...

File	dataFile
	An instance of class File to handle in- and output into a .data file. More...

File	fStatFile
	An instance of class File to handle in- and output into a .fstat file. More...

File	eneFile
	An instance of class File to handle in- and output into a .ene file. More...

File	restartFile
	An instance of class File to handle in- and output into a .restart file. More...

File	statFile
	An instance of class File to handle in- and output into a .stat file. More...

File	interactionFile
	File class to handle in- and output into .interactions file. This file hold information about interactions. More...

Time	clock_
	record when the simulation started More...

Protected Member Functions inherited from Mercury3D
void	hGridFindContactsWithinTargetCell (int x, int y, int z, unsigned int l)
	Finds contacts between particles in the target cell. More...

void	hGridFindContactsWithTargetCell (int x, int y, int z, unsigned int l, BaseParticle *obj)
	Finds contacts between the BaseParticle and the target cell. More...

void	computeWallForces (BaseWall *w) override
	Compute contacts with a wall. More...

void	hGridFindParticlesWithTargetCell (int x, int y, int z, unsigned int l, BaseParticle obj, std::vector< BaseParticle > &list)
	Finds particles within target cell and stores them in a list. More...

void	hGridGetInteractingParticleList (BaseParticle obj, std::vector< BaseParticle > &list) override
	Obtains all neighbour particles of a given object, obtained from the hgrid. More...

void	computeInternalForces (BaseParticle *obj) override
	Finds contacts with the BaseParticle; avoids multiple checks. More...

bool	hGridHasContactsInTargetCell (int x, int y, int z, unsigned int l, const BaseParticle *obj) const
	Tests if the BaseParticle has contacts with other Particles in the target cell. More...

bool	hGridHasParticleContacts (const BaseParticle *obj) override
	Tests if a BaseParticle has any contacts in the HGrid. More...

void	hGridRemoveParticle (BaseParticle *obj) override
	Removes a BaseParticle from the HGrid. More...

void	hGridUpdateParticle (BaseParticle *obj) override
	Updates the cell (not the level) of a BaseParticle. More...

Protected Member Functions inherited from MercuryBase
void	hGridRebuild ()
	This sets up the parameters required for the contact model. More...

void	hGridInsertParticle (BaseParticle *obj) final
	Inserts a single Particle to current grid. More...

void	hGridUpdateMove (BaseParticle *iP, Mdouble move) final
	Computes the relative displacement of the given BaseParticle and updates the currentMaxRelativeDisplacement_ accordingly. More...

void	hGridActionsBeforeIntegration () override
	Resets the currentMaxRelativeDisplacement_ to 0. More...

void	hGridActionsAfterIntegration () override
	This function has to be called before integrateBeforeForceComputation. More...

HGrid *	getHGrid ()
	Gets the HGrid used by this problem. More...

const HGrid *	getHGrid () const
	Gets the HGrid used by this problem, const version. More...

bool	readNextArgument (int &i, int argc, char *argv[]) override
	Reads the next command line argument. More...

Protected Member Functions inherited from DPMBase
virtual void	computeAllForces ()
	Computes all the forces acting on the particles using the BaseInteractable::setForce() and BaseInteractable::setTorque() More...

virtual void	computeInternalForce (BaseParticle , BaseParticle )
	Computes the forces between two particles (internal in the sense that the sum over all these forces is zero i.e. fully modelled forces) More...

virtual void	computeExternalForces (BaseParticle *)
	Computes the external forces, such as gravity, acting on particles. More...

void	computeForcesDueToWalls (BaseParticle , BaseWall )
	Computes the forces on the particles due to the walls (normals are outward normals) More...

virtual void	actionsBeforeTimeLoop ()
	A virtual function. Allows one to carry out any operations before the start of the time loop. More...

virtual void	actionsBeforeTimeStep ()
	A virtual function which allows to define operations to be executed before the new time step. More...

virtual void	computeAdditionalForces ()
	A virtual function which allows to define operations to be executed prior to the OMP force collect. More...

void	writeVTKFiles () const

virtual void	outputXBallsData (std::ostream &os) const
	This function writes the location of the walls and particles in a format the XBalls program can read. For more information on the XBalls program, see Visualising data in xballs. More...

virtual void	outputXBallsDataParticle (unsigned int i, unsigned int format, std::ostream &os) const
	This function writes out the particle locations into an output stream in a format the XBalls program can read. For more information on the XBalls program, see Visualising data in xballs. More...

virtual void	writeEneHeader (std::ostream &os) const
	Writes a header with a certain format for ENE file. More...

virtual void	writeFstatHeader (std::ostream &os) const
	Writes a header with a certain format for FStat file. More...

virtual void	writeEneTimeStep (std::ostream &os) const
	Write the global kinetic, potential energy, etc. in the system. More...

virtual void	initialiseStatistics ()

virtual void	outputStatistics ()

void	gatherContactStatistics ()

virtual void	processStatistics (bool)

virtual void	finishStatistics ()

virtual void	integrateBeforeForceComputation ()
	Update particles' and walls' positions and velocities before force computation. More...

virtual void	integrateAfterForceComputation ()
	Update particles' and walls' positions and velocities after force computation. More...

virtual void	checkInteractionWithBoundaries ()
	There are a range of boundaries one could implement depending on ones' problem. This methods checks for interactions between particles and such range of boundaries. See BaseBoundary.h and all the boundaries in the Boundaries folder. More...

void	setFixedParticles (unsigned int n)
	Sets a number, `n`, of particles in the particleHandler as "fixed particles". More...

virtual bool	continueSolve () const
	A virtual function for deciding whether to continue the simulation, based on a user-specified criterion. More...

void	outputInteractionDetails () const
	Displays the interaction details corresponding to the pointer objects in the interaction handler. More...

bool	isTimeEqualTo (Mdouble time) const
	Checks whether the input variable "time" is the current time in the simulation. More...

void	removeDuplicatePeriodicParticles ()
	Removes periodic duplicate Particles. More...

void	checkAndDuplicatePeriodicParticles ()
	For simulations using periodic boundaries, checks and adds particles when necessary into the particle handler. See DPMBase.cc and PeriodicBoundary.cc for more details. More...

void	performGhostParticleUpdate ()
	When the Verlet scheme updates the positions and velocities of particles, ghost particles will need an update as wel. Their status will also be updated accordingly. More...

void	deleteGhostParticles (std::set< BaseParticle * > &particlesToBeDeleted)

void	synchroniseParticle (BaseParticle *, unsigned fromProcessor=0)

void	performGhostVelocityUpdate ()
	updates the final time-step velocity of the ghost particles More...

void	setSoftStop ()
	function for setting sigaction constructor. More...

Static Protected Member Functions inherited from DPMBase
static void	signalHandler (int signal)
	signal handler function. More...

Constructor & Destructor Documentation

◆ BaseCluster()

BaseCluster::BaseCluster ( )

Default constructor.

                         {
     logger(DEBUG, "BaseCluster::BaseCluster() finished");
 }

References FATAL, and logger.

◆ ~BaseCluster()

BaseCluster::~BaseCluster ( )

final

Default destructor.

                          {
     logger(DEBUG, "BaseCluster::BaseClusterr() finished");
 }

References FATAL, and logger.

Member Function Documentation

◆ actionsAfterSolve()

void BaseCluster::actionsAfterSolve ( )

overridevirtual

Overrides DPMBase actionsAfterSolve(): in this cluster data file and cluster overlap file are closed and a few final actions are executed. Details in BaseCluster.cc.

In this: -data analysis is computed and cluster data and cluster overlap file are written for the last time. -if stage == 3 that means that the simulation is over but the energy ratio threshold is not reached: for this reason the user gets a warning. -adjacency matrix file is created and written (if needed), -internal structure file is created and written (if needed), -gnuplot file is created and written (if needed), -all particles are centred around the center of mass and their velocity is set, for this reason the user gets a warning, -finally cluster data file and cluster overlap file are closed.

Reimplemented from DPMBase.

 {
  
     makeDataAnalysis();
  
     if ( isCdatOutputOn() )
         writeToCdatFile();
  
     if ( isOverlOutputOn() )
         writeToOverlFile();
  
     if (stage_ == 3)
         logger(WARN, "Dissipation process not completed: final energyRatioTollerance_ = %."
                      "Try to increase energyRatioTollerance_ or decreasing velocityDampingModulus.",
                      getKineticEnergy()/getElasticEnergy());
  
     if (isAmatOutputOn())
     {
         logger(VERBOSE, "CREATING ADJACENCY MATRIX FILE\n");
         createAdjacencyMatrix();
         makeAmatFile();
         writeAmatFile();
     }
  
     if (isIntStrucOutputOn())
     {
         logger(VERBOSE, "COMPUTING INTERNAL STRUCTURE FILE\n");
         computeInternalStructure();
     }
  
     if(isOverlOutputOn())
     {
         logger(VERBOSE, "COMPUTING GNUPLOT FILE\n");
         makeGnuplotFile();
     }
  
  
     /*
      * \brief with this loop all particles are moved so that center of mass == position_ and their velocity is set.
      */
     for (auto i = particleHandler.begin(); i != particleHandler.end(); ++i){
         (*i)->setPosition( (*i)->getPosition() + position_ - centerOfMass_ );
         (*i)->setVelocity( clusterVelocity_ );
     }
  
     logger(VERBOSE, "CLUSTER CREATED.\n");
  
     if (isCdatOutputOn())
         cdatFile_.close();
  
     if (isOverlOutputOn())
         overlFile_.close();
 }

References BaseHandler< T >::begin(), cdatFile_, centerOfMass_, clusterVelocity_, computeInternalStructure(), createAdjacencyMatrix(), BaseHandler< T >::end(), DPMBase::getElasticEnergy(), DPMBase::getKineticEnergy(), constants::i, isAmatOutputOn(), isCdatOutputOn(), isIntStrucOutputOn(), isOverlOutputOn(), logger, makeAmatFile(), makeDataAnalysis(), makeGnuplotFile(), overlFile_, DPMBase::particleHandler, position_, stage_, VERBOSE, WARN, writeAmatFile(), writeToCdatFile(), and writeToOverlFile().

◆ actionsAfterTimeStep()

void BaseCluster::actionsAfterTimeStep ( )

overridevirtual

Overrides DPMBase actionsAfterTimeStep(): in this compression and decompression are computed, depending on the variable stage_.

In this the process takes place: in particular after each time step the following tasks are computed (in order): -data analysis: calculating values of interest, -writing to cluster data file, -writing to overlap file, -increasing central force and damping velocity (stage == 1), decreasing central force and damp velocity (stage == 2), damp central force and damp velocity until the system is static (stage == 3).

Reimplemented from DPMBase.

 {
     makeDataAnalysis();
  
     if ( isCdatOutputOn() && fmod(getTime()-t0_, fileOutputTimeInterval_) < getTimeStep() )
         writeToCdatFile();
  
     if ( isOverlOutputOn() && fmod(getTime()-t0_, fileOutputTimeInterval_) < getTimeStep() )
         writeToOverlFile();
  
     /*
      * \brief If stage == 1 force is linearly increased and velocities are damped for a time T = forceTuningDuration.
      *        If t > T, stage is set to 2.
      */
     if (stage_ == 1)
     {
         if (getTime() - t0_ < forceTuningDuration_)
         {
             if (fmod(getTime() - t0_, forceTuningInterval_) < getTimeStep())
                 increaseForce();
  
             if (fmod(getTime() - t0_, velocityDampingInterval_) < getTimeStep())
                 dampVelocities();
  
             applyCentralForce();
         }
         else
         {
             logger(VERBOSE, "DECREASING CENTRAL FORCE");
  
             t0_ = getTime();
             stage_++;
         }
     }
  
     /*
      * \brief If stage == 2 force is linearly decreased and velocities are damped for a time duration of T = forceTuningDuration.
      *        If t > T, stage is set to 3.
      */
     if (stage_ == 2)
     {
         if (getTime() - t0_ < forceTuningDuration_)
         {
             if (fmod(getTime() - t0_, forceTuningInterval_) < getTimeStep())
                 decreaseForce();
  
             if (fmod(getTime() - t0_, velocityDampingInterval_) < getTimeStep())
                 dampVelocities();
  
             applyCentralForce();
         }
         else
         {
             logger(VERBOSE, "DISSIPATING ENERGY");
  
             t0_ = getTime();
             fileOutputTimeInterval_ *= 2;
             setSaveCount( floor(fileOutputTimeInterval_/getTimeStep()) );
             stage_++;
         }
     }
  
     /*
      * \details If stage == 3 force is exponentially decreased and velocities are damped for a time duration of T = dissipationDuration_.
      *          If t>T or if the energy ratio is below the minimum threshold calculation is concluded and a few last operation are computed.
      *          They are:
      *          -timeMax is set to getTime(), in order to stop the calculation,
      *          -stage is set to 4 (if the energy threshold is not reached stage will remain 3 (because the simulation is stopped by the previous
      *           definition of timeMax): if this happens the user gets a warning, see actionsAfterSolve()).
      *          If MERCURY_USE_MPI this process lasts for a time T = dissipationDuration_ - getTimeStep().
      */
     if (stage_ == 3)
     {
         // \brief Now force is damped and not decreased.
         if (fmod(getTime() - t0_, forceTuningInterval_) < getTimeStep())
             dampForce();
  
         if (fmod(getTime() - t0_, velocityDampingInterval_) < getTimeStep())
             dampVelocities();
  
         applyCentralForce();
 #ifdef MERCURY_USE_MPI
         if (getTime() - t0_ > dissipationDuration_ - getTimeStep())
 #else
         if (getKineticEnergy() / getElasticEnergy() < energyRatioTolerance_ ||
             getTime() - t0_ > dissipationDuration_)
 #endif
         {
             printTime();
             logger(VERBOSE, "ENERGY DISSIPATED\n");
  
             // stage++ now is a flag used to understand if the dissipation procedure has been completed.
             stage_++;
  
             setTimeMax(getTime());
         }
     }
  
 }

References applyCentralForce(), dampForce(), dampVelocities(), decreaseForce(), dissipationDuration_, energyRatioTolerance_, fileOutputTimeInterval_, forceTuningDuration_, forceTuningInterval_, DPMBase::getElasticEnergy(), DPMBase::getKineticEnergy(), DPMBase::getTime(), DPMBase::getTimeStep(), increaseForce(), isCdatOutputOn(), isOverlOutputOn(), logger, makeDataAnalysis(), printTime(), DPMBase::setSaveCount(), DPMBase::setTimeMax(), stage_, t0_, velocityDampingInterval_, VERBOSE, writeToCdatFile(), and writeToOverlFile().

◆ actionsOnRestart()

void BaseCluster::actionsOnRestart ( )

overridevirtual

Overrides DPMBase actionsOnRestart(): in this all variables needed by the program for restarting are initialized.

In this all variables needed by the program for restarting are initialized. DPMBase::readRestartFile() is included.

Reimplemented from DPMBase.

 {
     readRestartFile();
  
     fileOutputTimeInterval_ = forceTuningDuration_ / 100;
  
     dissipationDuration_ = forceTuningDuration_/2;
  
     setSaveCount( floor(fileOutputTimeInterval_/getTimeStep()) );
  
     forceTuningInterval_ = getTimeStep();
  
     velocityDampingInterval_ = getTimeStep();
  
     setXBallsAdditionalArguments("-v0 -p 10");
  
     setParticlesWriteVTK(isVtkOutputOn());
  
     dataFile.setFileType(FileType::ONE_FILE);
  
     restartFile.setFileType(isRestartOutputOn()?FileType::ONE_FILE:FileType::NO_FILE);
  
     fStatFile.setFileType(isFStatOutputOn()?FileType::ONE_FILE:FileType::NO_FILE);
  
     eneFile.setFileType(isEneOutputOn()?FileType::ONE_FILE:FileType::NO_FILE);
  
     if (isCdatOutputOn())
     {
         std::ostringstream cdatName;
         cdatName << getName() << ".cdat";
         cdatFile_.open(cdatName.str(), std::ios::app);
     }
  
     if (isOverlOutputOn())
     {
         std::ostringstream overlName;
         overlName << getName() << ".overl";
         overlFile_.open(overlName.str(), std::ios::app);
     }
  
     logger(VERBOSE, "CALCULATION RESTARTED\n");
 }

References cdatFile_, DPMBase::dataFile, dissipationDuration_, DPMBase::eneFile, fileOutputTimeInterval_, forceTuningDuration_, forceTuningInterval_, DPMBase::fStatFile, DPMBase::getName(), DPMBase::getTimeStep(), isCdatOutputOn(), isEneOutputOn(), isFStatOutputOn(), isOverlOutputOn(), isRestartOutputOn(), isVtkOutputOn(), logger, overlFile_, DPMBase::readRestartFile(), DPMBase::restartFile, File::setFileType(), DPMBase::setParticlesWriteVTK(), DPMBase::setSaveCount(), DPMBase::setXBallsAdditionalArguments(), velocityDampingInterval_, and VERBOSE.

◆ applyCentralForce()

void BaseCluster::applyCentralForce ( )

private

This applies force on each particle.

This applies force on each particle. The force applied is proportional to the distance from force center (which is position_) and normalized by a ( 1/(2r) + 1/norm ) factor: this way even if a particle is very close to the force center (so -forceModulus * distanceFromForceCenter / (2 * r) ~ 0 ) a force F = -forceModulus * distanceFromForceCenter / norm is applied, which is the minimum guaranteed. (r is radiusParticle and norm is the 2-norm of distanceFromForceCenter vector).

 {
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p)
     {
         //\brief distance from the center of forces (which is position_).
         Vec3D distanceFromForceCenter = (*p) -> getPosition() - position_;
  
         //\brief norm of distanceFromForceCenter vector
         Mdouble norm = distanceFromForceCenter.getLength();
  
         (*p) -> addForce( -forceModulus_ * distanceFromForceCenter * (2*radiusParticle_ + norm) / (2*radiusParticle_*norm) );
  
         }
 }

References BaseHandler< T >::begin(), BaseHandler< T >::end(), forceModulus_, Vec3D::getLength(), getPosition(), DPMBase::particleHandler, position_, and radiusParticle_.

Referenced by actionsAfterTimeStep().

◆ calculateTimeStep()

void BaseCluster::calculateTimeStep ( )

private

Calculates the time step.

Calculates the time step over the smallest particle. After this the time step and the ratio between collision time and time step are printed.

 {
     // if constantRestitution(true) mass for collision time will be automatically set to 1, otherwise the smallest particle's mass will be used
     setTimeStep(particleSpecies_ -> getCollisionTime(speciesHandler.getObject(0)->getMassFromRadius(smallestRadius_))/collisionTimeOverTimeStep_);
  
     // printing values of timeStep and ratio between collisionTime and timeStep
     std::ostringstream printTimeStep;
     printTimeStep << "timeStep: " << std::setprecision(4) << getTimeStep() << std::endl
                   << "cT/tS, at least: " << std::fixed << std::setprecision(1)
                   << particleSpecies_ -> getCollisionTime(speciesHandler.getObject(0)->getMassFromRadius(smallestRadius_))/getTimeStep()
                   << std::endl;
     logger(VERBOSE, printTimeStep.str());
 }

References collisionTimeOverTimeStep_, ParticleSpecies::getMassFromRadius(), BaseHandler< T >::getObject(), DPMBase::getTimeStep(), logger, particleSpecies_, DPMBase::setTimeStep(), smallestRadius_, DPMBase::speciesHandler, and VERBOSE.

Referenced by setupInitialConditions().

◆ computeInternalStructure()

void BaseCluster::computeInternalStructure ( )

private

This computes the internal structure of the cluster.

This computes the internal structure and solid fraction of the cluster. A total number of particles (equal to nInternalStructurePoints_) is tried to be inserted (with spherical coordinates identical to the ones used for inserting the actual particles) inside a sphere having radius radiusForSolidFraction_. If no interaction is found, nothing happens, otherwise the counuter nPointsInsideComponentsForMCTest is incremented and the corresponding position is written down in the internal structure file.

 {
  
  
  
     Vec3D mcPoint;
     SphericalParticle p0;
     Mdouble fictitiousGridPointRadiusRatio = 1.0e-5;
     p0.setSpecies(speciesHandler.getObject(0));
     p0.setRadius(radiusParticle_*fictitiousGridPointRadiusRatio);
     p0.setVelocity(Vec3D(0.0, 0.0, 0.0));
     int nMonteCarloSamplingPoints = nInternalStructurePoints_;
     Mdouble nPointsInsideComponentsForMCTest = 0;
  
     makeIntenalStructureFile();
  
     for (int i = 0; i < nMonteCarloSamplingPoints; ++i)
     {
  
         Mdouble theta = constants::pi * random.getRandomNumber(0, 2.0);
         Mdouble phi = acos(random.getRandomNumber(-1.0, 1.0));
         Mdouble rad = radiusForSolidFraction_*cbrt( random.getRandomNumber( 0, 1 ) );
  
         mcPoint.X = rad * sin(phi) * cos(theta);
         mcPoint.Y = rad * sin(phi) * sin(theta);
         mcPoint.Z = rad * cos(phi);
         mcPoint += centerOfMass_;
  
         p0.setPosition(mcPoint);
  
         if (!checkParticleForInteraction(p0)) // collision -> the counter goes to the mass fraction
         {
             nPointsInsideComponentsForMCTest++;
             intStructFile_ << std::scientific << std::setprecision(5) << std::setw(12) << mcPoint.X
                            << std::setw(13) << mcPoint.Y << std::setw(13) << mcPoint.Z << std::setw(6) << 0 << std::endl;
         }
  
     }
  
     // Solid fraction (accordance between theoretical values and penetration depth max).
     // It is very important to notice that this value is accurate only if sliding friction is set to 0.5 and relative
     // tangential stiffness is set to 0.3 while creating the cluster. Different values do not guarantee accuracy.
     solidFractionIntStruct_ = nPointsInsideComponentsForMCTest/nMonteCarloSamplingPoints;
     Mdouble theoVal = 0.58 + 3*pow(0.58,2)*particleSpecies_->getPenetrationDepthMax();
     Mdouble diff = fabs(theoVal-solidFractionIntStruct_);
     Mdouble accordance = (theoVal - diff)/theoVal;
     // Solid fraction (accordance between theoretical values and average overlap).
     // It is very important to notice that this value is accurate only if sliding friction is set to 0.5 and relative
     // tangential stiffness is set to 0.3 while creating the cluster. Different values do not guarantee accuracy.
     solidFractionIntStruct_ = nPointsInsideComponentsForMCTest/nMonteCarloSamplingPoints;
     Mdouble theoValAvOverl = 0.58 + 3*pow(0.58,2)*meanRelativeOverlap_;
     Mdouble diffAvOverl = fabs(theoValAvOverl-solidFractionIntStruct_);
     Mdouble accordanceAvOverl = (theoValAvOverl - diffAvOverl)/theoValAvOverl;
  
     intStructFile_ << "n_points_inside_boundary: " << std::scientific << nMonteCarloSamplingPoints << std::endl;
     intStructFile_ << "n_points_inside_components: " << nPointsInsideComponentsForMCTest << std::endl;
     intStructFile_ << "solidFractionIntStruct_: " << std::fixed << std::setprecision(6) << solidFractionIntStruct_
                    << ", accordance with theoretical values: " << 100*accordance << "%." << std::endl
                    << "Accordance with average overlap: " << 100*accordanceAvOverl << "%." << std::endl
                    << "It is very important to notice that this formula is accurate only if sliding friction" << std::endl
                    << "is set to 0.5 and relative tangential stiffness is set to 0.3 while creating the cluster." << std::endl
                    << "Different values do not guarantee accuracy." << std::endl << std::endl;
  
     /*
      * computeInternalStructure output is set to VERBOSE in order not to have too much output. If the user needs it,
      * it is enough to set it to INFO.
      */
  
     std::ostringstream printResults;
     printResults << "n_points_inside_boundary: " << std::scientific << nMonteCarloSamplingPoints << std::endl;
     printResults << "n_points_inside_components: " << nPointsInsideComponentsForMCTest << std::endl;
     printResults << "solidFractionIntStruct_: " << std::fixed <<  std::setprecision(6) << solidFractionIntStruct_
                  << ", accordance with theoretical values: " << 100*accordance << "%." << std::endl
                  << "Accordance with average overlap: " << 100*accordanceAvOverl << "%." << std::endl
                  << "It is very important to notice that this formula is accurate only if sliding friction" << std::endl
                  << "is set to 0.5 and relative tangential stiffness is set to 0.3 while creating the cluster." << std::endl
                  << "Different values do not guarantee accuracy." << std::endl << std::endl;
     logger(VERBOSE, printResults.str());
 }

References centerOfMass_, MercuryBase::checkParticleForInteraction(), mathsFunc::cos(), BaseHandler< T >::getObject(), RNG::getRandomNumber(), constants::i, intStructFile_, logger, makeIntenalStructureFile(), meanRelativeOverlap_, nInternalStructurePoints_, particleSpecies_, constants::pi, radiusForSolidFraction_, radiusParticle_, DPMBase::random, BaseInteractable::setPosition(), BaseParticle::setRadius(), BaseParticle::setSpecies(), BaseInteractable::setVelocity(), mathsFunc::sin(), solidFractionIntStruct_, DPMBase::speciesHandler, VERBOSE, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by actionsAfterSolve().

◆ createAdjacencyMatrix()

void BaseCluster::createAdjacencyMatrix ( )

private

This calculates the adjacency matrix of the cluster.

This calculates the adjacency matrix of the cluster. Firstly a NxN matrix is created and filled with zeros. with a for cycle on the interactions then, if there's a contact between particle i and j adjacencyMatrix(i,j) = adjacencyMatrix(j,i) = 1. (N is the number of particles).

 {
     for (int i = 0; i < particleHandler.getSize(); i++)
     {
         std::vector<int> temporaryRowVector;
         temporaryRowVector.reserve(particleHandler.getSize());
  
         for (int j = 0; j < particleHandler.getSize(); j++)
             temporaryRowVector.push_back(0);
  
         adjacencyMatrix_.push_back(temporaryRowVector);
     }
  
     for (auto i = interactionHandler.begin(); i != interactionHandler.end(); ++i)
     {
         adjacencyMatrix_[(*i) -> getP() -> getIndex()][(*i) -> getI() -> getIndex()] = 1;
         adjacencyMatrix_[(*i) -> getI() -> getIndex()][(*i) -> getP() -> getIndex()] = 1;
     }
 }

References adjacencyMatrix_, BaseHandler< T >::begin(), BaseHandler< T >::end(), BaseHandler< T >::getSize(), constants::i, DPMBase::interactionHandler, and DPMBase::particleHandler.

Referenced by actionsAfterSolve().

◆ dampForce()

void BaseCluster::dampForce ( )

private

This damps values of forceModulus (stage = 3).

This damps values of forceModulus (stage = 3). Damping is done by a factor forceDampingModulus_.

 {
     forceModulus_ *= forceDampingModulus_;
 }

References forceDampingModulus_, and forceModulus_.

Referenced by actionsAfterTimeStep().

◆ dampVelocities()

void BaseCluster::dampVelocities ( )

private

This damps values of each particle velocity (stage = 1, stage = 2, stage = 3).

This damps values of each particle velocity (stage = 1, stage = 2, stage = 3). Damping is done by a factor velocityDampingModulus.

 {
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p)
     {
         (*p) -> setVelocity(velocityDampingModulus_*( (*p) -> getVelocity() ));
     }
 }

References BaseHandler< T >::begin(), BaseHandler< T >::end(), getVelocity(), DPMBase::particleHandler, setVelocity(), and velocityDampingModulus_.

Referenced by actionsAfterTimeStep().

◆ decreaseForce()

void BaseCluster::decreaseForce ( )

private

This linearly decreases values of forceModulus (stage = 2).

This linearly decreases values of forceModulus (stage = 2). forceModulus varies from maximumForceModulus to 0 linearly with time. Actually last value reached of forceModulus with this is maximumForceModulus * timeStep / forceTuningDuration because this process is discrete: starting from this value forceModulus will then be damped in stage = 3.

 {
     forceModulus_ = maximumForceModulus_ * (1 - (getTime() - t0_)/forceTuningDuration_);
 }

References forceModulus_, forceTuningDuration_, DPMBase::getTime(), maximumForceModulus_, and t0_.

Referenced by actionsAfterTimeStep().

◆ doAmatOutput()

void BaseCluster::doAmatOutput ( bool iAOO )

This sets the bool variable that defines whether the cluster adjacency matrix output will be written or not.

                                         {
     isAmatOutputOn_ = iAOO;
 }

References isAmatOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doCdatOutput()

void BaseCluster::doCdatOutput ( bool iCOO )

This sets the bool variable that defines whether the cluster data output will be written or not.

                                         {
     isCdatOutputOn_ = iCOO;
 }

References isCdatOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doEneOutput()

void BaseCluster::doEneOutput ( bool e )

This sets the bool variable that defines whether the cluster ene output will be written or not.

                                     {
     isEneOutputOn_ = e;
 }

References isEneOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doFStatOutput()

void BaseCluster::doFStatOutput ( bool fS )

This sets the bool variable that defines whether the cluster fStat output will be written or not.

                                        {
     isFStatOutputOn_ = fS;
 }

References isFStatOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doIntStrucOutput()

void BaseCluster::doIntStrucOutput ( bool iISOO )

This sets the bool variable that defines whether the cluster internal structure output will be written or not.

                                              {
     isIntStrucOutputOn_ = iISOO;
 }

References isIntStrucOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doOverlOutput()

void BaseCluster::doOverlOutput ( bool iOOO )

This sets the bool variable that defines whether the cluster overlap output will be written or not.

                                          {
     isOverlOutputOn_ = iOOO;
 }

References isOverlOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doRestartOutput()

void BaseCluster::doRestartOutput ( bool r )

This sets the bool variable that defines whether the cluster restart output will be written or not.

                                         {
     isRestartOutputOn_ = r;
 }

References isRestartOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ doVtkOutput()

void BaseCluster::doVtkOutput ( bool iVOO )

This sets the bool variable that defines whether the cluster vtk output will be written or not.

                                        {
     isVtkOutputOn_ = iVOO;
 }

References isVtkOutputOn_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ getAverageOverlap()

Mdouble BaseCluster::getAverageOverlap ( )

this returns the average overlap.

                                       {
     return meanRelativeOverlap_;
 }

References meanRelativeOverlap_.

◆ getClusterId()

unsigned int BaseCluster::getClusterId ( ) const

This returns the value of the cluster ID.

                                              {
     return idCluster_;
 }

References idCluster_.

Referenced by makeCdatFile().

◆ getCollisionTimeOverTimeStep()

Mdouble BaseCluster::getCollisionTimeOverTimeStep ( ) const

This returns the value of the ratio between collision time and time step.

This returns the value of the ratio between collision time and time step

                                                         {
     return collisionTimeOverTimeStep_;
 }

References collisionTimeOverTimeStep_.

Referenced by makeCdatFile().

◆ getEnergyRatioTolerance()

Mdouble BaseCluster::getEnergyRatioTolerance ( ) const

This returns the value of the value of the energy ratio threshold under which the process can be considered static, and so over.

                                                    {
     return energyRatioTolerance_;
 }

References energyRatioTolerance_.

Referenced by makeCdatFile().

◆ getFinalMassFraction()

Mdouble BaseCluster::getFinalMassFraction ( )

This gets the final value obtained for the mass fraction;.

This return the value of the obtained mass fraction (could be a little different than the desired). In particular, if the internal structure output is computed, the value for the mass fraction will be solidFractionIntStruct_ (computed within the internal structure and more precise), otherwise it will be solidFraction_.

                                          {
     if (isIntStrucOutputOn_)
         return solidFractionIntStruct_;
     else
         return solidFraction_;
 }

References isIntStrucOutputOn_, solidFraction_, and solidFractionIntStruct_.

◆ getMeanClusterRadius()

Mdouble BaseCluster::getMeanClusterRadius ( )

this returns meanClusterRadius (radius of an ideal perfectly spherical cluster, there's no setter).

                                           {
     return meanClusterRadius_;
 }

References meanClusterRadius_.

◆ getNumberOfInternalStructurePoints()

int BaseCluster::getNumberOfInternalStructurePoints ( ) const

This returns the value of the number of particles used to compute internal structure.

This returns the value of the length of the number of particles used to compute the internal structure.

                                                           {
     return nInternalStructurePoints_;
 }

References nInternalStructurePoints_.

Referenced by makeCdatFile().

◆ getNumberOfParticles()

int BaseCluster::getNumberOfParticles ( ) const

This returns the value of the number of particles in the cluster.

                                             {
     return nParticles_;
 }

References nParticles_.

Referenced by makeCdatFile().

◆ getParticleSpecies()

LinearPlasticViscoelasticFrictionSpecies * BaseCluster::getParticleSpecies ( ) const

This returns the species of the particle.

                                                                                 {
     return particleSpecies_;
 }

References particleSpecies_.

◆ getPosition()

Vec3D BaseCluster::getPosition ( ) const

This returns the value of position_, which is the position in which the cluster will be inserted.

This returns the value of position_, which is the position in which the cluster will be inserted (it is also the centre of mass of the cluster).

                                     {
     return position_;
 }

References position_.

Referenced by applyCentralForce(), and makeDataAnalysis().

◆ getRadiusParticle()

Mdouble BaseCluster::getRadiusParticle ( ) const

This returns the value of particles' radius if there's no dispersity in size. In case of dispersity != 1, this is the radius from which all radii are computed (as a consequence in this case it is also the pseudo-averaged radius).

This returns the value of particles' radius if there's no dispersity in size. If the dispersity is not 1, this is the value on which all radii will be computed.

                                              {
     return radiusParticle_;
 }

References radiusParticle_.

Referenced by makeCdatFile().

◆ getSizeDispersityParticle()

Mdouble BaseCluster::getSizeDispersityParticle ( ) const

This returns the value of particles' dispersity in size.

                                                      {
     return sizeDispersityParticle_;
 }

References sizeDispersityParticle_.

Referenced by makeCdatFile().

◆ getVelocity()

Vec3D BaseCluster::getVelocity ( )

This gets the value of velocity after creation.

This returns the velocity of the cluster after creation.

                                {
     return clusterVelocity_;
 }

References clusterVelocity_.

Referenced by dampVelocities().

◆ getVelocityDampingModulus()

Mdouble BaseCluster::getVelocityDampingModulus ( ) const

This returns the value of the velocity damping modulus.

                                                      {
     return velocityDampingModulus_;
 }

References velocityDampingModulus_.

Referenced by makeCdatFile().

◆ increaseForce()

void BaseCluster::increaseForce ( )

private

This linearly increases the value of forceModulus (stage = 1).

This increases the value of forceModulus (stage = 1). ForceModulus varies from 0 to maximumForceModulus linearly with time.

 {
     forceModulus_ = maximumForceModulus_*(getTime() - t0_)/forceTuningDuration_;
 }

References forceModulus_, forceTuningDuration_, DPMBase::getTime(), maximumForceModulus_, and t0_.

Referenced by actionsAfterTimeStep().

◆ insertParticles()

void BaseCluster::insertParticles ( )

private

Inserts particles inside the domain.

Inserts particles inside the domain with a while cycle.

 {
     int nParticlesInserted = 0;
  
     while (nParticlesInserted < nParticles_)
     {
         /* nParticleInserted corresponds to the index of the particle which is being inserted:
           * for example if no particle has been inserted yet nParticlesInserted=0 which is the
           * index of the first particle, and so on. For this reason this variable is the input
           * for particleInsertionSuccessful.
           */
         if (particleInsertionSuccessful(nParticlesInserted))
         {
             nParticlesInserted++;
         }
         else
         {
             logger(ERROR, "Cannot insert all particles, try to decrase the value of initialSolidFraction in "
                           "BaseCluster::setDomainLimits();\n"
                           "Inserted %/% particles.", nParticlesInserted, nParticles_);
         }
     }
     logger(VERBOSE, "PARTICLE INSERTION TERMINATED SUCCESSFULLY\n");
 }

References ERROR, logger, nParticles_, particleInsertionSuccessful(), and VERBOSE.

Referenced by setupInitialConditions().

◆ isAmatOutputOn()

bool BaseCluster::isAmatOutputOn ( ) const

This returns the bool variable that defines whether the cluster adjacency matrix output is written or not.

                                        {
     return isAmatOutputOn_;
 }

References isAmatOutputOn_.

Referenced by actionsAfterSolve().

◆ isCdatOutputOn()

bool BaseCluster::isCdatOutputOn ( ) const

This returns the bool variable that defines whether the cluster data output (which is NOT the mercury data output) is written or not.

This returns the bool variable that defines whether the cluster data output is written or not.

                                        {
     return isCdatOutputOn_;
 }

References isCdatOutputOn_.

Referenced by actionsAfterSolve(), actionsAfterTimeStep(), actionsOnRestart(), and setupInitialConditions().

◆ isEneOutputOn()

bool BaseCluster::isEneOutputOn ( ) const

This returns the bool variable that defines whether the cluster ene output is written or not.

                                       {
     return isEneOutputOn_;
 }

References isEneOutputOn_.

Referenced by actionsOnRestart(), and setupInitialConditions().

◆ isFStatOutputOn()

bool BaseCluster::isFStatOutputOn ( ) const

This returns the bool variable that defines whether the cluster fStat output is written or not.

                                         {
     return isFStatOutputOn_;
 }

References isFStatOutputOn_.

Referenced by actionsOnRestart(), and setupInitialConditions().

◆ isIntStrucOutputOn()

bool BaseCluster::isIntStrucOutputOn ( ) const

This returns the bool variable that defines whether the cluster internal structure output is written or not.

                                            {
     return isIntStrucOutputOn_;
 }

References isIntStrucOutputOn_.

Referenced by actionsAfterSolve(), read(), and write().

◆ isOverlOutputOn()

bool BaseCluster::isOverlOutputOn ( ) const

This returns the bool variable that defines whether the cluster overlap output is written or not.

                                         {
     return isOverlOutputOn_;
 }

References isOverlOutputOn_.

Referenced by actionsAfterSolve(), actionsAfterTimeStep(), actionsOnRestart(), and setupInitialConditions().

◆ isRestartOutputOn()

bool BaseCluster::isRestartOutputOn ( ) const

This returns the bool variable that defines whether the cluster restart output is written or not.

                                           {
     return isRestartOutputOn_;
 }

References isRestartOutputOn_.

Referenced by actionsOnRestart(), and setupInitialConditions().

◆ isVtkOutputOn()

bool BaseCluster::isVtkOutputOn ( ) const

This returns the bool variable that defines whether the cluster vtk output is written or not.

                                       {
     return isVtkOutputOn_;
 }

References isVtkOutputOn_.

Referenced by actionsOnRestart(), and setupInitialConditions().

◆ makeAmatFile()

void BaseCluster::makeAmatFile ( )

private

This creates the adjacency matrix file.

 {
     std::ostringstream amatName;
     amatName << getName() << ".amat";
  
     amatFile_.open(amatName.str(), std::ios::out);
     amatFile_ << "ADJACENCY MATRIX" << std::endl << std::endl;
 }

References amatFile_, and DPMBase::getName().

Referenced by actionsAfterSolve().

◆ makeCdatFile()

void BaseCluster::makeCdatFile ( )

private

Creates the cluster data output file.

Creates the cluster data output file. In the first lines of the file some important infos about the cluster are written. They are (in order): -Ratio between collision time and time step, -radiusParticle, -size dispersity of particles, -density of the particles -number of particles, -cluster ID (group ID), -safety factor of the cluster radius, -sliding friction coefficient, -rolling friction coefficient, -torsion friction coefficient, -loading stiffness, -unloading stiffness, -cohesion stiffness, -number of particles for computing internal structure (if needed), -energy ratio threshold, -velocity damping modulus, -restitution cohefficient.

After this the indentation of the file is written. The values that will be written are (in order): -elastic energy, -energy ratio threshold, -mean coordination number, -mean cluster radius, -solid fraction, -force modulus, -mean force on interaction, -minimum relative overlap, -mean relative overlap, -maximum realative overlap, -center of mass.

 {
     std::ostringstream cdatName;
     cdatName << getName() << ".cdat";
  
     cdatFile_.open(cdatName.str(), std::ios::out);
  
     cdatFile_ << "CLUSTER DATA AND INFORMATION" << std::endl << std::endl;
     cdatFile_ << "position: " << position_ << std::endl;
     cdatFile_ << "collisionTimeOverTimeStep: " << getCollisionTimeOverTimeStep() << std::endl;
     cdatFile_ << "radiusParticle: " << std:: scientific << std::setprecision(2) << getRadiusParticle() << std::endl;
     cdatFile_ << "sizeDispersityParticle: " << std::defaultfloat << getSizeDispersityParticle() << std::endl;
     cdatFile_ << "densityParticle: " << std:: scientific << particleSpecies_ -> getDensity() << std::endl;
     cdatFile_ << "nParticles: " << std::defaultfloat << getNumberOfParticles() << std::endl;
     cdatFile_ << "idCluster: " << getClusterId() << std::endl;
     cdatFile_ << "slidingFrictionCoeff: " << particleSpecies_ -> getSlidingFrictionCoefficient() << std::endl;
     cdatFile_ << "rollingFrictionCoeff: " << particleSpecies_ -> getRollingFrictionCoefficient() << std::endl;
     cdatFile_ << "torsionFrictionCoeff: " << particleSpecies_ -> getTorsionFrictionCoefficient() << std::endl;
     // If constantRestitution(true) loading, unloading, and cohesion stiffness are multiplied by the mass of a particle (massParticle_) whose radius is radiusParticle_*2/(1+sizeDispersityParticle_),
     // which is the mass that should be used to compute collision time.
     cdatFile_ << "loadingStiffness: " << std::scientific << particleSpecies_ -> getLoadingStiffness()
                                             * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl;
     cdatFile_ << "unloadingStiffnessMax: " << particleSpecies_ -> getUnloadingStiffnessMax()
                                             * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl;
     cdatFile_ << "cohesionStiffness: " << particleSpecies_ -> getCohesionStiffness()
                                             * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl;
     cdatFile_ << "restitutionCoefficient: " << particleSpecies_ -> getRestitutionCoefficient(massParticle_) << std::endl;
     cdatFile_ << "collisionTime: " << std::scientific << std::setprecision(3) << particleSpecies_ -> getCollisionTime(massParticle_) << std::endl;
     if (getNumberOfInternalStructurePoints())
         cdatFile_ << "nInternalStructurePoints: " << getNumberOfInternalStructurePoints() << std::endl;
     cdatFile_ << "energyRatioTolerance: " << getEnergyRatioTolerance() << std::endl;
     cdatFile_ << "velocityDampingModulus: " << std::defaultfloat << getVelocityDampingModulus() << std::endl << std::endl;
  
     cdatFile_ << "progress" << std::setw(16) << "ElastEne" << std::setw(23) << "Ekin/ElastEne" << std::setw(18) << "coord_number" << std::setw(14) << "meanRadius"
              << std::setw(19) << "solidFraction" << std::setw(16) << "forceModulus" << std::setw(22) << "AveFOnOverl" << std::setw(15) << "dMin" << std::setw(17) << "dMean"
              << std::setw(14) << "dMax" << std::setw(24) << "Mass Centre" << std::endl;
 }

References cdatFile_, getClusterId(), getCollisionTimeOverTimeStep(), getEnergyRatioTolerance(), DPMBase::getName(), getNumberOfInternalStructurePoints(), getNumberOfParticles(), getRadiusParticle(), getSizeDispersityParticle(), getVelocityDampingModulus(), massParticle_, particleSpecies_, and position_.

Referenced by setupInitialConditions().

◆ makeDataAnalysis()

void BaseCluster::makeDataAnalysis ( )

private

This functions computes some important cluster information needed by the program.

This functions computes some important cluster information needed by the program. They are (in order): -mean coordination number, -center of mass, -mean cluster radius, -cluster radius used to compute solid fraction (different from mean cluster radius, see

below), -solid fraction, -mean force acting on interaction, -maximum overlap, -mean overlap, -minimum overlap.

 {
     // resetting counters and variables
     Mdouble solidVolumeInsideRadius = 0;
     Vec3D localMin;
     Vec3D localMax;
     localMin.setZero();
     localMax.setZero();
     centerOfMass_.setZero();
     //\brief vector in which it is saved the relative position of a particle from the center of mass
     Vec3D distanceFromCenterOfMass;
     //\brief distance from the center of mass of the furthest particle
     Mdouble furthestParticleDistance = 0;
     // number of particles whose distance d from the center of mass is d > furthestParticleDistance - radiusParticle_
     int counter = 0;
     Mdouble relativeOverlap = 0;
  
     meanClusterRadius_ = 0.0;
     meanCoordinationNumber_ = 0.0;
     maxRelativeOverlap_ = 0.0;
     meanRelativeOverlap_ = 0.0;
     minRelativeOverlap_ = 2 * 2 * sizeDispersityParticle_/(1+sizeDispersityParticle_);
  
     // loops over each particle to compute mean coordination number and center of mass.
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p) {
  
         meanCoordinationNumber_ += ((*p)->getInteractions()).size();
  
         centerOfMass_ += ((*p)->getVolume()) * ((*p)->getPosition());
     }
  
     meanCoordinationNumber_ /= particleHandler.getSize();
     centerOfMass_ /= totalParticleVolume_;
  
  
     // loops over each particle to compute the furthest particle from the center of mass.
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p) {
  
         distanceFromCenterOfMass = (*p)->getPosition() - centerOfMass_;
  
         if (distanceFromCenterOfMass.getLength() > furthestParticleDistance)
             furthestParticleDistance = distanceFromCenterOfMass.getLength();
  
     }
  
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p) {
  
         distanceFromCenterOfMass = (*p)->getPosition() - centerOfMass_;
  
         if (distanceFromCenterOfMass.getLength() > furthestParticleDistance - radiusParticle_) {
             meanClusterRadius_ += distanceFromCenterOfMass.getLength();
             counter++;
         }
  
     }
  
     meanClusterRadius_ /= counter;
     meanClusterRadius_ += radiusParticle_;
  
  
     /*
      * \details This is the radius used to compute solid fraction: it is smaller than the meanClusterRadius.
      */
     radiusForSolidFraction_ = meanClusterRadius_ - 1 * radiusParticle_ ;
  
     /*
      * \details With a for cycle the volume of the particles inside radiusForSolidFraction is computed and after this the value of solid
      *          fraction is calculated. This value is less precise as the maximum penetration depth increases and more precise as the
      *          number of particle increases.
      */
     for (auto p = particleHandler.begin(); p != particleHandler.end(); ++p)
     {
         distanceFromCenterOfMass = (*p) -> getPosition() - centerOfMass_;
  
         if( distanceFromCenterOfMass.getLength() < radiusForSolidFraction_ )
             solidVolumeInsideRadius += (*p) -> getVolume();
     }
  
     solidFraction_ = 3 * solidVolumeInsideRadius / ( 4 * constants::pi * pow(radiusForSolidFraction_, 3) );
  
     // loops over every interaction to compute mean force acting on interaction, maximum, mean and minimum relative particle overlap.
     for (std::vector<BaseInteraction*>::const_iterator i = interactionHandler.begin(); i != interactionHandler.end(); ++i)
     {
  
         /*
          * \details the relative overlap is computed as an average of the relative overlap on the two particles.
          *          rO = ( O/R1 + O/R2 ) / 2.
          */
         relativeOverlap = ((*i) -> getOverlap())/(particleHandler.getObject((*i) -> getP() -> getIndex()) -> getRadius()) +
                                     ((*i) -> getOverlap())/(particleHandler.getObject((*i) -> getI() -> getIndex()) -> getRadius());
         relativeOverlap /= 2;
         meanRelativeOverlap_ += relativeOverlap;
         if (relativeOverlap > maxRelativeOverlap_)
             maxRelativeOverlap_ = relativeOverlap;
  
         if (relativeOverlap < minRelativeOverlap_)
             minRelativeOverlap_ = relativeOverlap;
     }
     meanRelativeOverlap_ /= interactionHandler.getSize();
 }

References BaseHandler< T >::begin(), centerOfMass_, BaseHandler< T >::end(), Vec3D::getLength(), BaseHandler< T >::getObject(), getPosition(), BaseHandler< T >::getSize(), constants::i, DPMBase::interactionHandler, maxRelativeOverlap_, meanClusterRadius_, meanCoordinationNumber_, meanRelativeOverlap_, minRelativeOverlap_, DPMBase::particleHandler, constants::pi, radiusForSolidFraction_, radiusParticle_, Vec3D::setZero(), sizeDispersityParticle_, solidFraction_, and totalParticleVolume_.

Referenced by actionsAfterSolve(), and actionsAfterTimeStep().

◆ makeGnuplotFile()

void BaseCluster::makeGnuplotFile ( )

private

This creates the gnuplot file needed for printing force vs overlaps values.

This creates the gnuplot file needed for printing force vs overlaps values. After setting output tipe, title, labels and grid, all columns needed for overlap printing are written after the plot command. Only overlaps present at the end of the process will be printed. Loading this file with gnuplot a jpeg image is obtained showing all forces vs overlaps.

 {
     std::ostringstream gnuplotname;
     gnuplotname << getName() << ".gnuplot";
  
     gnuplotFile_.open(gnuplotname.str(), std::ios::out);
     gnuplotFile_ << "set terminal jpeg" << std::endl;
     gnuplotFile_ << "set output \"" << getName() << "_overlaps" << ".jpeg\"" << std::endl;
     std::string titleLine=R"(set title "Overlap Vs Force")";// font ",14"
     std::string xLabel=R"(set xlabel "Overlap")";
     std::string yLabel=R"(set ylabel "Force")";
     gnuplotFile_ << titleLine << std::endl;
     gnuplotFile_ << xLabel << std::endl;
     gnuplotFile_ << yLabel << std::endl;
     gnuplotFile_ << "set grid" << std::endl;
     gnuplotFile_ << "plot ";
     for (int i = 0; i < interactionHandler.getSize(); ++i)
     {
         gnuplotFile_ << "\"" << getName() << ".overl" << "\"" << " using " << 2*i+4 << ":" << 2*i+3 << " title \"\" with lines lt 1  dashtype 2, ";
     }
  
     gnuplotFile_.close();
  
 }

References DPMBase::getName(), BaseHandler< T >::getSize(), gnuplotFile_, constants::i, and DPMBase::interactionHandler.

Referenced by actionsAfterSolve().

◆ makeIntenalStructureFile()

void BaseCluster::makeIntenalStructureFile ( )

private

This creates the file needed for writing down datas from computeInternalStructure().

This creates the file needed for writing down datas from computeInternalStructure(). In the first row nInternalStructurePoints is printed: this number is the total number of points tried to be inserted (and so is grater than the number of lines of the file, which corresponds to the number of points that gave interaction).

 {
     std::ostringstream intStructName;
     intStructName << getName() << ".struct";
  
     intStructFile_.open(intStructName.str(), std::ios::out);
     intStructFile_ << "Number of Montecarlo points: " << nInternalStructurePoints_ << std::endl;
 }

References DPMBase::getName(), intStructFile_, and nInternalStructurePoints_.

Referenced by computeInternalStructure().

◆ makeOverlFile()

void BaseCluster::makeOverlFile ( )

private

Creates the cluster overlap output file.

\detail Creates the cluster overlap output file. In this file forces vs overlaps will be written. Together with this a ".gnuplot" file is created, which reads from this, ready to be loaded (see BaseCluster::makeGnuplotFile() ).

 {
     std::ostringstream overlName;
     overlName << getName() << ".overl";
  
     overlFile_.open(overlName.str(), std::ios::out);
     overlFile_ << "Overlap Vs Normal Force" << std::endl;
 }

References DPMBase::getName(), and overlFile_.

Referenced by setupInitialConditions().

◆ particleInsertionSuccessful()

bool BaseCluster::particleInsertionSuccessful ( int n )

private

This function tries to insert the n-th particle (returns true if it manage to do that). It is inside insertParticles().

Tries to insert a particle in a spherical area centered around the initial site of the cluster; With an insertion fail counter and a while cycle this function tries to insert a particle in the domain: in order to do this, after computing random spherical coordinates, checks for interaction. If no interaction is detected the particle is inserted and returns true, if it fails 1000 times returns false and the computation is over. The spherical coordinates are rescaled over the radius by a factor cbrt(rand(0,1) ) and also over vertical angle thanks to acos(rand (-1, 1) ): this has been done in order to ensure the most possible spherical shape to the cluster, which with classic spherical coordinates was not achieved.

Parameters

n	index of the particle being inserted.

Returns: bool: true if particle inserted, false if not.

                                                    {
  
     int insertionFailCounter = 0;
     Mdouble rad, theta, phi;
     Vec3D particlePosition;
     SphericalParticle p0;
  
     // setup of particle properties and initial conditions (besides position)
     p0.setVelocity(Vec3D(0.0, 0.0, 0.0));
     p0.setRadius(radii_[n]);
     p0.setSpecies(speciesHandler.getObject(0));
     p0.setGroupId(idCluster_);
  
     while (insertionFailCounter < 1000)
     {
         theta = constants::pi * random.getRandomNumber(0, 2.0);
         phi = acos(random.getRandomNumber(-1.0, 1.0));
         rad = p0.getRadius() + cbrt( random.getRandomNumber( 0, 1 ) ) * ( 0.5 * boxSize_ - 2.01 * p0.getRadius() );
  
         particlePosition.X = position_.X + rad * sin(phi) * cos(theta);
         particlePosition.Y = position_.Y + rad * sin(phi) * sin(theta);
         particlePosition.Z = position_.Z + rad * cos(phi);
  
         p0.setPosition(particlePosition);
  
         if (checkParticleForInteraction(p0))
         {
             particleHandler.copyAndAddObject(p0);
             return true;
         }
  
         insertionFailCounter++;
     }
  
     return false;
 }

References boxSize_, MercuryBase::checkParticleForInteraction(), BaseHandler< T >::copyAndAddObject(), mathsFunc::cos(), BaseHandler< T >::getObject(), BaseParticle::getRadius(), RNG::getRandomNumber(), idCluster_, n, DPMBase::particleHandler, constants::pi, position_, radii_, DPMBase::random, BaseObject::setGroupId(), BaseInteractable::setPosition(), BaseParticle::setRadius(), BaseParticle::setSpecies(), BaseInteractable::setVelocity(), mathsFunc::sin(), DPMBase::speciesHandler, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by insertParticles().

◆ printTime()

void BaseCluster::printTime ( ) const

overridevirtual

Overrides DPMBase printTime(): this way variables of interest are shown.

Overrides DPMBase printTime(): this way stage and variables of interest are shown. They are (in order): -computation progress, -energy ratio, -mean coordination number, -mean cluster radius, -mass fraction, -force modulus, -minimum relative overlap, -mean relative overlap, -maximum realative overlap, -center of mass, -number of particles.

printTime output is set to VERBOSE in order not to have too much output. If the user needs it, it is enough to set it to INFO.

Reimplemented from DPMBase.

 {
     std::ostringstream printTime;
     switch (stage_)
     {
         case 1: printTime << "Compression progress: " << std::setw(3) << int( ceil( 100 * (getTime() - t0_) / forceTuningDuration_ ) ) << "%, ";
             break;
  
         case 2: printTime << "Decompression progress: " << std::setw(3) << int( ceil( 100 * (getTime() - t0_) / forceTuningDuration_ ) )<< "%, ";
             break;
  
         case 3: printTime << "Dissipating energy: ";
             break;
  
         default: printTime << "Final values: ";
             break;
     }
     printTime <<
               "E_ratio = " << std::scientific << std::setprecision(2) << std::setw(8) << getKineticEnergy()/getElasticEnergy() <<
               ", cN = " << std::fixed << std::setw(5) << meanCoordinationNumber_ << ", rMean = " << std::scientific << meanClusterRadius_ <<
               ", mF = " << std::fixed << std::setprecision(3) << solidFraction_ << ", Force Modulus = " << std::scientific << forceModulus_ <<
               ", dMin = " << std::fixed << std::setw(7) << std::setprecision(5) << minRelativeOverlap_ << ", dMean = " << std::setw(7) << meanRelativeOverlap_ <<
               ", dMax = " << maxRelativeOverlap_ << ", centerOfMass = " << std::scientific << std::setprecision(5) << std::setw(13) << centerOfMass_.X
                           << std::setw(14) << centerOfMass_.Y << std::setw(14) << centerOfMass_.Z <<
               " nParticles: " << particleHandler.getSize();
     logger(VERBOSE, printTime.str());
 }

References centerOfMass_, forceModulus_, forceTuningDuration_, DPMBase::getElasticEnergy(), DPMBase::getKineticEnergy(), BaseHandler< T >::getSize(), DPMBase::getTime(), logger, maxRelativeOverlap_, meanClusterRadius_, meanCoordinationNumber_, meanRelativeOverlap_, minRelativeOverlap_, DPMBase::particleHandler, solidFraction_, stage_, t0_, VERBOSE, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by actionsAfterTimeStep().

◆ read()

void BaseCluster::read	(	std::istream &	is,
		ReadOptions	opt = `ReadOptions::ReadAll`
	)

overridevirtual

Overrides DPMBase read(): in this all variables needed by the program for restarting are read.

In this all variables needed by the program for restarting are read from a .restart file. As MercuryBase::write was included in ClusterDPM::write, here MercuryBase::read is included.

Reimplemented from DPMBase.

 {
     MercuryBase::read(is);
  
     std::stringstream line;
     std::string dummy;
  
     helpers::getLineFromStringStream(is, line);
     line    >> dummy >> position_
             >> dummy >> stage_
             >> dummy >> t0_;
     helpers::getLineFromStringStream(is, line);
     line    >> dummy >> idCluster_
             >> dummy >> nParticles_
             >> dummy >> radiusParticle_
             >> dummy >> massParticle_
             >> dummy >> sizeDispersityParticle_
             >> dummy >> totalParticleVolume_;
     helpers::getLineFromStringStream(is, line);
     line    >> dummy >> maximumForceModulus_
             >> dummy >> forceTuningInterval_
             >> dummy >> forceTuningDuration_
             >> dummy >> velocityDampingInterval_
             >> dummy >> velocityDampingModulus_
             >> dummy >> energyRatioTolerance_
             >> dummy >> forceDampingModulus_
             >> dummy >> forceModulus_;
     helpers::getLineFromStringStream(is, line);
     line    >> dummy >> isCdatOutputOn_
             >> dummy >> isOverlOutputOn_
             >> dummy >> isAmatOutputOn_
             >> dummy >> isIntStrucOutputOn_;
     if(isIntStrucOutputOn() )
     {
     helpers::getLineFromStringStream(is, line);
     line >> dummy >> nInternalStructurePoints_;
     }
     line    >> dummy >> isRestartOutputOn_
             >> dummy >> isFStatOutputOn_
             >> dummy >> isEneOutputOn_;
 }

References energyRatioTolerance_, forceDampingModulus_, forceModulus_, forceTuningDuration_, forceTuningInterval_, helpers::getLineFromStringStream(), idCluster_, isAmatOutputOn_, isCdatOutputOn_, isEneOutputOn_, isFStatOutputOn_, isIntStrucOutputOn(), isIntStrucOutputOn_, isOverlOutputOn_, isRestartOutputOn_, massParticle_, maximumForceModulus_, nInternalStructurePoints_, nParticles_, position_, radiusParticle_, MercuryBase::read(), sizeDispersityParticle_, stage_, t0_, totalParticleVolume_, velocityDampingInterval_, and velocityDampingModulus_.

◆ setClusterId()

void BaseCluster::setClusterId ( unsigned int iC )

This sets the value of the cluster ID.

This sets the value of the cluster ID. In addition to that, it checks if the value is acceptable.

                                               {
     if (iC < 0)
         logger(WARN, "idCluster = % is less than zero.", iC);
     idCluster_ = iC;
 }

References idCluster_, logger, and WARN.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ setCollisionTimeOverTimeStep()

void BaseCluster::setCollisionTimeOverTimeStep ( Mdouble cTOTS )

This sets the collisionTimeOverTimeStep number (which is the ratio between collision time and time step).

This sets the collisionTimeOverTimeStep_ number. In addition to that, it checks if the value is acceptable.

                                                             {
     if (cTOTS < 45 && cTOTS > 0)
         logger(WARN, "collisionTimeOverTimeStep = % is too small: consider setting it greater or equal than 50.", cTOTS);
     else if (cTOTS <= 0)
         logger(ERROR, "collisionTimeOverTimeStep = % must be grater than zero.", cTOTS);
     collisionTimeOverTimeStep_ = cTOTS;
 }

References collisionTimeOverTimeStep_, ERROR, logger, and WARN.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ setDomainLimits()

void BaseCluster::setDomainLimits ( )

private

Sets domain limits.

Sets domain limits of the simulation. Using spherical coordinates and the insertion process defined in particleInsertionSuccessful the final solid fraction obtained varies from 0.11 to 0.14 (empirically calculated, even for high size dispersity, which anyway shouldn't be contemplated in this field). For this reason the domain size (here called boxSize_) is computed as the cubic root of the total particle volume over 0.1.

 {
     Mdouble initialSolidFraction = 0.1;
     boxSize_ = cbrt(totalParticleVolume_/initialSolidFraction);
     std::ostringstream printDomainLimits;
     printDomainLimits << "Cubic size " << boxSize_ << std::endl;
     logger(VERBOSE, printDomainLimits.str());
  
     setDomain(-0.5*boxSize_*Vec3D(1,1,1) + position_, 0.5*boxSize_*Vec3D(1,1,1) + position_);
 }

References boxSize_, logger, position_, DPMBase::setDomain(), totalParticleVolume_, and VERBOSE.

Referenced by setupInitialConditions().

◆ setEnergyRatioTolerance()

void BaseCluster::setEnergyRatioTolerance ( Mdouble eRT )

This sets the value of the value of the energy ratio threshold under which the process can be considered static, and so over.

This sets the value of the value of the energy ratio threshold under which the process can be considered static, and so over. In addition to that, it checks if the value is acceptable.

                                                      {
     if (eRT <= 0)
         logger(ERROR, "energyRatioTolerance must be grater than zero. energyRatioTolerance = %", eRT);
     energyRatioTolerance_ = eRT;
 }

References energyRatioTolerance_, ERROR, and logger.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ setNumberOfInternalStructurePoints()

void BaseCluster::setNumberOfInternalStructurePoints ( int gL )

This sets the value of the number of particles used to compute the internal structure.

This sets the value of the length of the number of particles used to compute the internal structure. In addition to that, it checks if the value is acceptable.

                                                            {
     if (gL <= 0)
         logger(ERROR, "nInternalStructurePoints_ must be grater than zero. nInternalStructurePoints_ = %", gL);
     nInternalStructurePoints_ = gL;
 }

References ERROR, logger, and nInternalStructurePoints_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ setNumberOfParticles()

void BaseCluster::setNumberOfParticles ( int nP )

This sets the value of the number of particles in the cluster.

This sets the value of the number of particles in the cluster. In addition to that, it checks if the value is acceptable.

                                              {
     if (nP < 0)
         logger(ERROR, "nParticles must be grater than zero. nParticles = %", nP);
     else {
         nParticles_ = nP;
         setNumberOfParticles_ = true;
     }
 }

References ERROR, logger, nParticles_, and setNumberOfParticles_.

Referenced by RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ setParticleSpecies()

void BaseCluster::setParticleSpecies ( LinearPlasticViscoelasticFrictionSpecies * pS )

This sets the species of the particle.

                                                                                  {
     particleSpecies_ = pS;
 }

References particleSpecies_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ setPosition()

void BaseCluster::setPosition ( Vec3D p )

This sets the value of position_, which is the position in which the cluster will be inserted.

This sets the value of position_, which is the position in which the cluster will be inserted (it is also the centre of mass of the cluster).

                                     {
     position_ = p;
 }

References position_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ setRadii()

void BaseCluster::setRadii ( )

private

Sets all radii according to particleRadius and sizeDispersityParticle.

Sets all radii according to particleRadius and sizeDispersityParticle_.

 {
     totalParticleVolume_ = 0;
     smallestRadius_ = constants::inf;
     for (int i = 0; i < nParticles_; ++i)
     {
         // This is the actual radius of the i-th particle
         radii_.push_back( random.getRandomNumber( radiusParticle_*2/(1+sizeDispersityParticle_) , radiusParticle_*2*sizeDispersityParticle_/(1+sizeDispersityParticle_) ) );
         // Computing totalParticleVolume (this is done because this value is needed before particle insertion).
         totalParticleVolume_ += 4.0*constants::pi*pow(radii_[i],3.0)/3.0;
         //computing the smallest radius (needed in computeTimeStep(), which is needed before particle insertion)
         if (radii_[i] < smallestRadius_) smallestRadius_ = radii_[i];
     }
 }

References RNG::getRandomNumber(), constants::i, constants::inf, nParticles_, constants::pi, radii_, radiusParticle_, DPMBase::random, sizeDispersityParticle_, smallestRadius_, and totalParticleVolume_.

Referenced by setupInitialConditions().

◆ setRadiusCluster()

void BaseCluster::setRadiusCluster ( Mdouble rCR )

This sets the desired value of the cluster radius (there is no getter of this value, but there is a getter of the actual mean cluster radius obtained, getMeanClusterRadius)

This sets the value of the Radius of the cluster. A boolean (setRadiusCluster_) is also set to true: this is done because the user has to set exactly two among radiusCluster_, radiusCluster_ and radiusParticle_. In addition to that, it checks if the value is acceptable.

                                               {
     if (rCR <= 0)
         logger(ERROR,
                "relativeClusterRadius is smaller than 0. relativeClusterRadius = %",
                rCR);
     else
         radiusCluster_ = rCR;
  
     setRadiusCluster_ = true;
 }

References ERROR, logger, radiusCluster_, and setRadiusCluster_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ setRadiusParticle()

void BaseCluster::setRadiusParticle ( Mdouble rP )

This sets the value of particles' radius if there's no dispersity in size.

This sets the value of particles' radius if there's no dispersity in size. If the dispersity is not 1, this is the value on which all radii will be computed. In addition to that, it checks if the value is acceptable.

                                               {
     if (rP <= 0)
         logger(ERROR, "radiusParticle must be greater than zero. radiusParticle = %", rP);
     else {
         radiusParticle_ = rP;
         setRadiusParticle_ = true;
     }
 }

References ERROR, logger, radiusParticle_, and setRadiusParticle_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ setSizeDispersityParticle()

void BaseCluster::setSizeDispersityParticle ( Mdouble sDP )

This sets the value of particles' dispersity in size.

This sets the value of particles' dispersity in size. In addition to that, it checks if the value is acceptable.

                                                        {
     if (sDP < 1)
         logger(ERROR, "sizeDispersityParticle must be greater or equal than 1. sizeDispersityParticle = %", sDP);
     else sizeDispersityParticle_ = sDP;
 }

References ERROR, logger, and sizeDispersityParticle_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ setSpecies()

void BaseCluster::setSpecies ( )

private

Sets species of particles.

adds particlePureSpaces (set by the user or by default) to the species handler. After this, values of stiffnesses, restitution coefficient and collision time are printed.

 {
     if (particleSpecies_ == nullptr)
     {
         logger(ERROR, "Species not set.");
     }
     speciesHandler.copyAndAddObject(particleSpecies_);
     /*
      * \brief mass of the particle which has radius radiusParticle if constantRestitution(false) or
      * radiusParticle_*2/(1+sizeDispersityParticle_) otherwise.
      * It is set now and used various time in the code (for example for stiffnesses, collision time
      * and restitution coefficient below).
      */
      massParticle_ = particleSpecies_ -> getConstantRestitution()?
                     speciesHandler.getObject(0) -> getMassFromRadius(radiusParticle_*2/(1+sizeDispersityParticle_))
             :
                     speciesHandler.getObject(0) -> getMassFromRadius(radiusParticle_);
  
     std::ostringstream printSpecies;
     /*
      * If constantRestitution(true) loading, unloading, and cohesion stiffness are multiplied by the mass of a particle
      * whose radius is radiusParticle_*2/(1+sizeDispersityParticle_),
      * which is the mass that should be used to compute collision time.
      */
      printSpecies << "loadingStiffness: " << std::scientific << particleSpecies_ -> getLoadingStiffness()
                                                             * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl
                   << "unloadingStiffnessMax: " << particleSpecies_ -> getUnloadingStiffnessMax()
                                               * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl
                   << "cohesionStiffness: " << particleSpecies_ -> getCohesionStiffness()
                                           * (particleSpecies_->getConstantRestitution()?massParticle_:1) << std::endl
                   << "restitutionCoefficient: " << std::fixed << particleSpecies_ -> getRestitutionCoefficient(massParticle_) << std::endl
                   << "collisionTime: " << std::scientific << std::setprecision(3) << particleSpecies_ -> getCollisionTime(massParticle_) << std::endl;
     logger(VERBOSE, printSpecies.str());
 }

References BaseHandler< T >::copyAndAddObject(), ERROR, BaseHandler< T >::getObject(), logger, massParticle_, particleSpecies_, radiusParticle_, sizeDispersityParticle_, DPMBase::speciesHandler, and VERBOSE.

Referenced by setupInitialConditions().

◆ setupInitialConditions()

void BaseCluster::setupInitialConditions ( )

overridevirtual

Overrides DPMBase setupInitialConditions(): in this initial conditions for the problem are set.

Overrides DPMBase function setupInitialConditions(): in this initial conditions for the problem are set, and they are (in order): -checking that particleHandler and speciesHandler are empty, -defining cluster parameters starting from the user input, -all particles radii, -particle species, -domain limits, -time step, -particles initial positions (insertParticles), -initial time (t0), -maximum force applied on particles (maximumForceModulus), -time duration of applying (and releasing) force (forceTuningDuration) and dissipation time (dissipationDuration_), -time max, -output time for files and print time function (fileOutputTimeInterval), -time interval on which force is increased or decreased (forceTuningInterval), -value of forceDampingModulus_, -time interval on which velocity is damped (velocityTuningInterval), -xballs settings, -vtk settings, -standard mercury output data settings (dataFile, restartFile, fStatFile and eneFile), -name settings, -creation of cluster data file (if needed), -creation of overlap file (if needed), -stage of computation.

Reimplemented from DPMBase.

 {
     logger(VERBOSE, "CREATING CLUSTER");
  
     if (particleHandler.getSize()>0){
         logger(WARN, "ParticleHandler was not empty");
         particleHandler.clear();
     }
  
     if (speciesHandler.getSize()>0){
         logger(WARN, "speciesHandler was not empty");
         speciesHandler.clear();
     }
     // Defining cluster parameters starting from the user input.
     // In order to use this class the user has to set exactly 2 values among radiusParticle,
     // radiusCluster and numberOfParticles.
     if (setNumberOfParticles_*setRadiusParticle_ + setNumberOfParticles_*setRadiusCluster_ + setRadiusCluster_*setRadiusParticle_ != 1)
         logger(ERROR, "Please set exactly two values among radiusParticle, radiusCluster and numberOfParticles."
                       " radiusParticle = %, radiusCluster = %, numberOfParticles = %.",
                        radiusParticle_, radiusCluster_, nParticles_);
  
     // If the user sets the cluster radius and the radius of a single particle,
     // the number of particles has to be computed:
     if (setRadiusCluster_ && setRadiusParticle_) {
         if (radiusCluster_ < 2 * radiusParticle_)
             logger(VERBOSE, "clusterRadius is small compared to the radius of a single particle:"
                          " consider setting clusterRadius >= 2 * radiusParticle."
                           "clusterRadius = %, radiusParticle = %.", radiusCluster_, radiusParticle_);
         // relative cluster radius
         Mdouble hatR = radiusCluster_ / radiusParticle_;
         // mass fraction of the cluster in the limit of phi = 0.
         Mdouble eps0 = 0.58;
         // The number of particles (N) per cluster given the relative cluster radius (hatR) and penetration depth max (phi)
         // can be computed as: N = ( hatR / (1 - eps0*phi) )^3 * eps0.
         // It is very important to notice that this formula is accurate only if sliding friction is set to 0.5 and relative
         // tangential stiffness is set to 0.3 while creating the cluster. Different values do not guarantee accuracy.
  
         nParticles_ =
                 round (std::pow( hatR / (1.0 - eps0 * particleSpecies_->getPenetrationDepthMax() ), 3) * eps0);
         logger(VERBOSE, "Number of particles: %.\n", nParticles_);
     }
  
     // If the user sets the cluster radius and the number of particles,
     // the radius of a single particle has to be computed:
     if (setRadiusCluster_ && setNumberOfParticles_) {
         // mass fraction of the cluster in the limit of phi = 0.
         Mdouble eps0 = 0.58;
         // The radius of a single particle (r) composig the cluster given the cluster radius (R), penetration depth max (phi)
         // and the number of particles (N) can be obtained as: r = R / ( cbrt(N/eps0) * (1-eps0*phi) ).
         // It is very important to notice that this formula is accurate only if sliding friction is set to 0.5 and relative
         // tangential stiffness is set to 0.3 while creating the cluster. Different values do not guarantee accuracy.
         radiusParticle_ = radiusCluster_ / (cbrt(nParticles_/eps0) * (1-eps0*particleSpecies_->getPenetrationDepthMax()));
  
         logger(VERBOSE, "radius particle: %.\n", radiusParticle_);
     }
  
     logger(VERBOSE, "SETTING RADII");
     setRadii();
  
     logger(VERBOSE, "SETTING SPECIES");
     setSpecies();
  
     logger(VERBOSE, "SETTING DOMAIN LIMITS");
     setDomainLimits();
  
     logger(VERBOSE, "COMPUTING TIME STEP");
     calculateTimeStep();
  
     logger(VERBOSE, "PARTICLE INSERTION");
     insertParticles();
  
     logger(VERBOSE, "Number of particles: %.", particleHandler.getSize());
  
     t0_ = getTime();
  
     // \details deltaStar
     Mdouble deltaStar = particleSpecies_->getPenetrationDepthMax() * particleSpecies_->getUnloadingStiffnessMax()
                         / (particleSpecies_->getUnloadingStiffnessMax() - particleSpecies_->getLoadingStiffness());
  
     /*
      * \brief maximum force modulus applied on particles (this value is then multiplied by the relative distance from
      *          force center d, which is d = D/r).
      *          It is the force necessary to get a overlap of deltaStar (computed above this description).
      *          If constant restitution is true then it is also multiplied by the mass of the biggest particle,
      *          or if  MERCURY_USE_MPI it is the biggest possible mass computed taking into account particle dispersity,
      *          i.e. the mass of a particle having radius
      *          r = radiusParticle_ * 2 * sizeDispersityParticle_ / (1 + sizeDispersityParticle_).
      *          (In order to get the right value of loading stiffness it should be multiplied by the mass of the smallest
      *          particle; multiplying it for the biggest mass here, instead, is for safety).
      */
  
 #ifdef MERCURY_USE_MPI
     maximumForceModulus_ = radiusParticle_ * 2 * sizeDispersityParticle_ / (1 + sizeDispersityParticle_) * deltaStar *
                            particleSpecies_->getLoadingStiffness()
                            * (particleSpecies_->getConstantRestitution() ?
                               particleSpecies_->getMassFromRadius(radiusParticle_ * 2 * sizeDispersityParticle_ / (1 + sizeDispersityParticle_))
                               :
                               1);
 #else
     maximumForceModulus_ = radiusParticle_ * 2 * sizeDispersityParticle_ / (1 + sizeDispersityParticle_) * deltaStar *
     particleSpecies_->getLoadingStiffness()
                            * (particleSpecies_->getConstantRestitution() ?
                               particleHandler.getLargestParticle()->getMass()
                               :
                               1);
 #endif
  
     /*
      * \details
      * The time needed for a particle to cover a distance of x is  sqrt(2 * x * m / F), when a constant force F is applied.
      * In order to hit another particle, a single particle has to travel a distance of about boxSize/4 (boxSize is the domain length).
      * As a value for x it is used boxSize_ (instead of boxSize_/4 as a safety factor).
      * As a value for F it is used maximumForceModulus/50 which is half of maximumForceModulus/25 (in this way it is calculated
      * a measure of the time needed with a force which linearly increases from 0 to maximumForceModulus/25, again dividing for 25
      * is done for safety). As a value for m it is used the  mass of the biggest particle, or if MERCURY_USE_MPI it is
      * the mass computed taking into account size dispersity, so the mass
      * of a particle having radius r = radiusParticle_ * 2 * sizeDispersityParticle_ / (1 + sizeDispersityParticle_), for safety.
      * The factor 5* outside the sqrt is another safety factor empirically determined: with this values the computation is fast
      * and the obtained results are very similar to the ones obtained if longer times would be set.
      * All this safety factors are needed because this is not the exact value of time needed but a measure of it: the problem
      * indeed is quite complicated given that particles can also rearrange during compression and so they will eventually
      * move in a non radial direction and for this reason they will need more time to settle.
      */
 #ifdef MERCURY_USE_MPI
     forceTuningDuration_ =
             5 * sqrt(100 * boxSize_ * particleSpecies_->getMassFromRadius(radiusParticle_ * 2 * sizeDispersityParticle_ /
                                                         (1 + sizeDispersityParticle_)) / maximumForceModulus_);
 #else
     forceTuningDuration_ =
             5 * sqrt(100 * boxSize_ * particleHandler.getLargestParticle()->getMass() / maximumForceModulus_);
 #endif
  
     //\details Maximum possible time duration of dissipation (i.e. duration of dissipation if energy ration tollerance not reached).
     dissipationDuration_ = forceTuningDuration_/2;
  
     // Compression + Decompression + Dissipation = 2 * Compression + Dissipation
     clusterTimeMax_ = 2 * forceTuningDuration_ + dissipationDuration_;
     setTimeMax(clusterTimeMax_);
  
     fileOutputTimeInterval_ = forceTuningDuration_ / 100;
  
     setSaveCount(floor(fileOutputTimeInterval_ / getTimeStep()));
  
     forceTuningInterval_ = getTimeStep();
  
     forceDampingModulus_ = 0.95;
  
     velocityDampingInterval_ = getTimeStep();
  
     setXBallsAdditionalArguments("-v0 -p 10");
  
     setParticlesWriteVTK(isVtkOutputOn());
  
     dataFile.setFileType(FileType::ONE_FILE);
  
     restartFile.setFileType(isRestartOutputOn() ? FileType::ONE_FILE : FileType::NO_FILE);
  
     fStatFile.setFileType(isFStatOutputOn() ? FileType::ONE_FILE : FileType::NO_FILE);
  
     eneFile.setFileType(isEneOutputOn() ? FileType::ONE_FILE : FileType::NO_FILE);
  
     // Name setting
     std::ostringstream name;
     name << "Cluster_ID_" << idCluster_;
     setName(name.str());
  
     if (isCdatOutputOn()) {
         logger(VERBOSE, "CREATING .cdat FILE\n");
         makeCdatFile();
     }
  
     if (isOverlOutputOn()) {
         logger(VERBOSE, "CREATING .overl FILE\n");
         makeOverlFile();
     }
  
     logger(VERBOSE, "ACTIVATING CENTRAL FORCES\n");
  
     /*
      * \details
      * Stage defines in which phase of the calculation the program is:
      * stage = 1: compressing particles and increasing force
      * stage = 2: releasing force
      * stage = 3: waiting for the system to be static.
      */
     stage_ = 1;
 }

References boxSize_, calculateTimeStep(), ParticleHandler::clear(), SpeciesHandler::clear(), clusterTimeMax_, DPMBase::dataFile, dissipationDuration_, DPMBase::eneFile, ERROR, fileOutputTimeInterval_, forceDampingModulus_, forceTuningDuration_, forceTuningInterval_, DPMBase::fStatFile, ParticleHandler::getLargestParticle(), BaseParticle::getMass(), BaseHandler< T >::getSize(), DPMBase::getTime(), DPMBase::getTimeStep(), idCluster_, insertParticles(), isCdatOutputOn(), isEneOutputOn(), isFStatOutputOn(), isOverlOutputOn(), isRestartOutputOn(), isVtkOutputOn(), logger, makeCdatFile(), makeOverlFile(), maximumForceModulus_, units::name, nParticles_, DPMBase::particleHandler, particleSpecies_, radiusCluster_, radiusParticle_, DPMBase::restartFile, helpers::round(), setDomainLimits(), File::setFileType(), DPMBase::setName(), setNumberOfParticles_, DPMBase::setParticlesWriteVTK(), setRadii(), setRadiusCluster_, setRadiusParticle_, DPMBase::setSaveCount(), setSpecies(), DPMBase::setTimeMax(), DPMBase::setXBallsAdditionalArguments(), sizeDispersityParticle_, DPMBase::speciesHandler, stage_, t0_, velocityDampingInterval_, VERBOSE, and WARN.

◆ setVelocity()

void BaseCluster::setVelocity ( Vec3D v )

This sets the value of velocity after creation.

This sets the velocity of the cluster after creation.

                                      {
     clusterVelocity_ = v;
 }

References clusterVelocity_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and dampVelocities().

◆ setVelocityDampingModulus()

void BaseCluster::setVelocityDampingModulus ( Mdouble vDM )

This sets the value of the velocity damping modulus.

This sets the value of the velocity damping modulus. In addition to that, it checks if the value is acceptable.

                                                        {
     if (vDM < 0 || vDM > 1)
         logger(ERROR, "velocityDampingModulus must be grater than zero and less than 1. velocityDampingModulus = %", vDM);
     velocityDampingModulus_ = vDM;
 }

References ERROR, logger, and velocityDampingModulus_.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), and ClusterGenerator::ClusterGenerator().

◆ write()

void BaseCluster::write	(	std::ostream &	os,
		bool	writeAllParticles
	)		const

overridevirtual

Overrides DPMBase write(): in this all variables needed by the program for restarting are written.

In this all variables needed by the program for restarting are written on a .restart file Most of the needed variables are already saved by MercuryBase::write, which for this reason is included.

Reimplemented from DPMBase.

 {
     writeAllParticles = true;
     MercuryBase::write(os, writeAllParticles);
     
     os <<
        "position " << position_ << " " <<
        "stage " << stage_ << " " <<
        "t0 " << t0_
        << "\n" <<
        "idCluster " << idCluster_ << " " <<
        "nParticles " << nParticles_ << " " <<
        "radiusParticle " << radiusParticle_ << " " <<
        "massParticle " << massParticle_ << " " <<
        "sizeDispersityParticle " << sizeDispersityParticle_ << " " <<
        "totalParticleVolume " << totalParticleVolume_
        << "\n" <<
        "maximumForceModulus " << maximumForceModulus_ << " " <<
        "forceTuningInterval " << forceTuningInterval_ << " " <<
        "forceTuningDuration " << forceTuningDuration_ << " " <<
        "velocityDampingInterval " << velocityDampingInterval_ << " " <<
        "velocityDampingModulus " << velocityDampingModulus_ << " " <<
        "energyRatioTolerance " << energyRatioTolerance_ << " " <<
        "forceDampingModulus " << forceDampingModulus_ << " " <<
        "forceModulus " << forceModulus_
        << "\n" <<
        "isCdatOutputON " << isCdatOutputOn_ << " " <<
        "isOverlOutputOn " << isOverlOutputOn_ << " " <<
        "isAmatOutputOn " << isAmatOutputOn_ << " " <<
        "isIntStrucOutputOn " << isIntStrucOutputOn_
        << "\n";
     if (isIntStrucOutputOn())
     {
         os << "nInternalStructurePoints " << nInternalStructurePoints_ << "\n";
     }
     
     os << "isRestartOutputOn " << isRestartOutputOn_ << " " << //This is obviously on because otherwise restart
        // process would not take place.
        //For now it is saved but could eventually be removed.
        "isFStatOutputOn " << isFStatOutputOn_ << " " <<
        "isEneOutputOn " << isEneOutputOn_ << std::endl;
 }

References energyRatioTolerance_, forceDampingModulus_, forceModulus_, forceTuningDuration_, forceTuningInterval_, idCluster_, isAmatOutputOn_, isCdatOutputOn_, isEneOutputOn_, isFStatOutputOn_, isIntStrucOutputOn(), isIntStrucOutputOn_, isOverlOutputOn_, isRestartOutputOn_, massParticle_, maximumForceModulus_, nInternalStructurePoints_, nParticles_, position_, radiusParticle_, sizeDispersityParticle_, stage_, t0_, totalParticleVolume_, velocityDampingInterval_, velocityDampingModulus_, and MercuryBase::write().

◆ writeAmatFile()

void BaseCluster::writeAmatFile ( )

private

This writes on the adjacency matrix file.

This writes on the adjacency matrix file. With two nested for cycles adjacencyMatrix is written down. Finally number of intra-cluster bonds and mean coordination number are also written. After this the file is closed.

 {
     for(int i=0; i < particleHandler.getSize(); i++)
     {
         for(int j=0; j < particleHandler.getSize(); j++)
         {
             amatFile_ << adjacencyMatrix_[i][j] << "  ";
         }
         amatFile_ << std::endl;
     }
     nIntraClusterBonds_ = interactionHandler.getSize();
     amatFile_ << std::endl;
     amatFile_ << "THE TOTAL NUMBER OF INTRACLUSTER BONDS IS: " << nIntraClusterBonds_ << std::endl;
     amatFile_ << "THE MEAN COORDINATION NUMBER IS: " << meanCoordinationNumber_ << std::endl;
  
     amatFile_.close();
 }

References adjacencyMatrix_, amatFile_, BaseHandler< T >::getSize(), constants::i, DPMBase::interactionHandler, meanCoordinationNumber_, nIntraClusterBonds_, and DPMBase::particleHandler.

Referenced by actionsAfterSolve().

◆ writeToCdatFile()

void BaseCluster::writeToCdatFile ( )

private

This writes on the cluster data output file.

This writes on the cluster data output file. Written values are (in order): -elastic energy, -energy ratio threshold, -mean coordination number, -mean cluster radius, -solid fraction, -force modulus, -mean force on interaction, -minimum relative overlap, -mean relative overlap, -maximum realative overlap, -center of mass.

 {
     switch (stage_)
     {
         case 1:
             cdatFile_ << "C, " << std::fixed << std::setprecision(0) << std::setw(4) << 100 * (getTime() - t0_) / forceTuningDuration_ << "%: ";
             break;
  
         case 2:
             cdatFile_ << "D, " << std::fixed << std::setprecision(0) << std::setw(4) << 100 * (getTime() - t0_) / forceTuningDuration_ << "%: ";
             break;
  
         case 3:
             cdatFile_ << "D-energy: ";
             break;
  
         default:
             cdatFile_ << "Final  v: ";
     }
  
     cdatFile_ <<
             std::scientific <<
             std::setprecision(2)<<
             std::setw(14) <<
             getElasticEnergy() <<
             std::setw(18) <<
             getKineticEnergy()/getElasticEnergy() <<
             std::fixed <<
             std::setprecision(2) <<
             std::setw(15) <<
             meanCoordinationNumber_ <<
             std::scientific <<
             std::setw(20) <<
             meanClusterRadius_ <<
             std::fixed <<
             std::setprecision(2) <<
             std::setw(13) <<
             solidFraction_ <<
             std::scientific <<
             std::setprecision(3) <<
             std::setw(24) <<
             forceModulus_ <<
             std::setw(22) <<
             std::fixed <<
             std::setprecision(5) <<
             std::setw(18) <<
             minRelativeOverlap_ <<
             std::setw(16) <<
             meanRelativeOverlap_ <<
             std::setw(15) <<
             maxRelativeOverlap_ <<
             std::scientific <<
             std::setprecision(2) <<
             std::setw(19) <<
             centerOfMass_.X <<
             std::setw(12) <<
             centerOfMass_.Y <<
             std::setw(12) <<
             centerOfMass_.Z <<
             "          " <<
             std::endl;
 }

References cdatFile_, centerOfMass_, forceModulus_, forceTuningDuration_, DPMBase::getElasticEnergy(), DPMBase::getKineticEnergy(), DPMBase::getTime(), maxRelativeOverlap_, meanClusterRadius_, meanCoordinationNumber_, meanRelativeOverlap_, minRelativeOverlap_, solidFraction_, stage_, t0_, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by actionsAfterSolve(), and actionsAfterTimeStep().

◆ writeToOverlFile()

void BaseCluster::writeToOverlFile ( )

private

This writes on the cluster overlap output file.

This writes on the cluster overlap output file. At each output time and for each interaction force vs overlap is written down.

 {
     //\brief force acting on overlap.
     Mdouble forceOnOverlap = 0;
     Mdouble relativeOverlap = 0;
     switch (stage_)
     {
         case 1:
             overlFile_ << "C, " << std::fixed << std::setprecision(0) << std::setw(4) << 100 * (getTime() - t0_) / forceTuningDuration_ << "%: ";
             break;
  
         case 2:
             overlFile_ << "D, " << std::fixed << std::setprecision(0) << std::setw(4) << 100 * (getTime() - t0_) / forceTuningDuration_ << "%: ";
             break;
  
         case 3:
             overlFile_ << "D energy: ";
             break;
  
         default:
             overlFile_ << "Final  v: ";
     }
  
     for (std::vector<BaseInteraction*>::const_iterator i = interactionHandler.begin(); i != interactionHandler.end(); ++i)
     {
         forceOnOverlap = ((*i) -> getForce()).getLength();
         relativeOverlap = ((*i) -> getOverlap())/(particleHandler.getObject((*i) -> getP() -> getIndex()) -> getRadius()) +
                             ((*i) -> getOverlap())/(particleHandler.getObject((*i) -> getI() -> getIndex()) -> getRadius());
         relativeOverlap = relativeOverlap / 2;
         overlFile_ << std::setprecision(2) << std::scientific << std::setw(18) << forceOnOverlap
                     << std::defaultfloat << std::fixed << std::setprecision(4) << std::setw(9) << relativeOverlap;
     }
  
     overlFile_ << "     " << std::endl;
 }