SpeciesHandler Class Reference

Container to store all ParticleSpecies. More...

#include <SpeciesHandler.h>

Inheritance diagram for SpeciesHandler:

Public Member Functions
	SpeciesHandler ()
	Default constructor, it creates an empty SpeciesHandler. More...
	SpeciesHandler (const SpeciesHandler &other)
	Constructor that copies all species and the pointer to the DPMBase from the given SpeciesHandler. More...
SpeciesHandler &	operator= (const SpeciesHandler &rhs)
	Assignment operator that copies all species and the pointer to the DPMBase from the given SpeciesHandler. More...
	~SpeciesHandler () override
	Destructor, it destructs the SpeciesHandler and all ParticleSpecies it contains. More...
void	addObject (ParticleSpecies *S) override
	Adds a new ParticleSpecies to the SpeciesHandler. More...
void	clear () override
	Empties the whole BaseHandler by removing all Objects and setting all other variables to 0. More...
void	removeObject (unsigned int index) override
	Remove the ParticleSpecies with given id. More...
void	readAndAddObject (std::istream &is) override
	Reads Species data into the SpeciesHandler from restart file. More...
ParticleSpecies *	readOldObject (std::istream &is)
	Reads ParticleSpecies into the SpeciesHandler from old-style restart data. More...
unsigned int	getMixedId (unsigned int id1, unsigned int id2) const
	Gets the Id of the behaviour between two given species. More...
template<typename U >
std::enable_if<!std::is_pointer< typename U::MixedSpeciesType >::value, typename U::MixedSpeciesType * >::type	getMixedObject (const U *S, const U *T)
BaseSpecies *	getMixedObject (unsigned int id1, unsigned int id2)
	Gets the mixed object that is constructed from two given species. More...
const std::vector< BaseSpecies * > &	getMixedObjects () const
	Returns a pointer to the vector of all mixed objects. More...
virtual void	write (std::ostream &os) const
	Write all the species and mixed species to an output stream. More...
std::string	getName () const override
	Returns the name of the handler, namely the string "SpeciesHandler". More...
bool	useAngularDOFs ()
	Check if angular DOF have to be used. More...
Public Member Functions inherited from BaseHandler< ParticleSpecies >
	BaseHandler ()
	Default BaseHandler constructor, it creates an empty BaseHandler and assigns DPMBase_ to a null pointer. More...
	BaseHandler (const BaseHandler< ParticleSpecies > &BH)
	Constructor that copies the objects of the given handler into itself and sets other variables to 0/nullptr. More...
virtual	~BaseHandler ()
	Destructor, it destructs the BaseHandler and all Object it contains. More...
void	copyContentsFromOtherHandler (const BaseHandler< ParticleSpecies > &BH)
	Function that copies the contents (vector of pointers, maxObject_, nextId_, DPMBase_) from one handler (container) to the other. More...
std::enable_if<!std::is_pointer< U >::value, U * >::type	copyAndAddObject (const U &object)
	Creates a copy of a Object and adds it to the BaseHandler. More...
std::enable_if< std::is_pointer< U >::value, U >::type	copyAndAddObject (const U object)
	Creates a copy of a Object and adds it to the BaseHandler. More...
std::enable_if<!std::is_pointer< U >::value, U * >::type	copyAndAddGhostObject (const U &object)
	Creates a copy of a Object and adds it to the BaseHandler. This is one locally for inserting mpi particles, they avoid the global check if the particle can actually be inserted, because the mpi domain already knows that is the case. More...
std::enable_if< std::is_pointer< U >::value, U >::type	copyAndAddGhostObject (const U object)
	Creates a copy of a Object and adds it to the BaseHandler. This is one locally for inserting mpi particles, they avoid the global check if the particle can actually be inserted, because the mpi domain already knows that is the case. More...
virtual void	addExistingObject (ParticleSpecies *O)
	Adds an existing object to the BaseHandler without changing the id of the object. More...
virtual void	addObject (ParticleSpecies *object)
	Adds a new Object to the BaseHandler. More...
virtual void	addGhostObject (ParticleSpecies *O)
	Adds a new Object to the BaseHandler. called by the to avoid increasing the id. More...
void	removeIf (const std::function< bool(ParticleSpecies *)> cond)
void	removeLastObject ()
	Removes the last Object from the BaseHandler. More...
void	read (std::istream &is)
	Reads all objects from restart data. More...
ParticleSpecies *	getObjectById (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
std::vector< ParticleSpecies * >	getObjectsById (const unsigned int id)
	Gets a vector of pointers to the objects with the specific id. More...
ParticleSpecies *	getObject (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
const ParticleSpecies *	getObject (const unsigned int id) const
	Gets a constant pointer to the Object at the specified index in the BaseHandler. More...
ParticleSpecies *	getLastObject ()
	Gets a pointer to the last Object in this BaseHandler. More...
const ParticleSpecies *	getLastObject () const
	Gets a constant pointer to the last Object in this BaseHandler. More...
virtual unsigned int	getNumberOfObjects () const
	Gets the number of real Object in this BaseHandler. (i.e. no mpi or periodic particles) More...
unsigned int	getSize () const
	Gets the size of the particleHandler (including mpi and periodic particles) More...
unsigned int	getStorageCapacity () const
	Gets the storage capacity of this BaseHandler. More...
void	setStorageCapacity (const unsigned int N)
	Sets the storage capacity of this BaseHandler. More...
void	resize (const unsigned int N, const ParticleSpecies &obj)
	Resizes the container to contain N elements. More...
const std::vector< ParticleSpecies * >::const_iterator	begin () const
	Gets the begin of the const_iterator over all Object in this BaseHandler. More...
const std::vector< ParticleSpecies * >::iterator	begin ()
	Gets the begin of the iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< ParticleSpecies * >::const_iterator	end () const
	Gets the end of the const_iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< ParticleSpecies * >::iterator	end ()
	Gets the end of the iterator over all BaseBoundary in this BaseHandler. More...
void	setDPMBase (DPMBase *DPMBase)
	Sets the problem that is solved using this handler. More...
void	setId (ParticleSpecies *object, unsigned int id)
void	increaseId ()
unsigned int	getNextId ()
void	setNextId (unsigned int id)
DPMBase *	getDPMBase ()
	Gets the problem that is solved using this handler. More...
DPMBase *	getDPMBase () const
	Gets the problem that is solved using this handler and does not change the class. More...
virtual std::string	getName () const=0
	Gets the name of this handler. More...
virtual void	writeVTK () const
	now empty function for writing VTK files. More...
unsigned	getNextGroupId ()
	Should be called each time you assign a groupId. Returns the value of nextGroupId_ and increases nextGroupId_ by one. More...

Private Attributes
std::vector< BaseSpecies * >	mixedObjects_
	The list of pointers to the mixed species. More...

Additional Inherited Members
Protected Attributes inherited from BaseHandler< ParticleSpecies >
std::vector< ParticleSpecies * >	objects_
	The actual list of Object pointers. More...

Detailed Description

Container to store all ParticleSpecies.

The SpeciesHandler is a container to store all ParticleSpecies. It is implemented by a vector of pointers to ParticleSpecies.

Constructor & Destructor Documentation

SpeciesHandler() [1/2]

SpeciesHandler::SpeciesHandler

(

)

Default constructor, it creates an empty SpeciesHandler.

Constructor of the SpeciesHandler class. It creates an empty SpeciesHandler.

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

References FATAL, and logger.

SpeciesHandler() [2/2]

SpeciesHandler::SpeciesHandler

(

const SpeciesHandler &

other

)

Constructor that copies all species and the pointer to the DPMBase from the given SpeciesHandler.

Parameters

[in]

other

The SpeciesHandler that has to be copied.

This is not a copy constructor! This constructor copies only all BaseSpecies and MixedSpecies and copies the pointer to the DPMBase. It sets all other data members to 0 or nullptr.

{
    clear();
    setDPMBase(other.getDPMBase());
    copyContentsFromOtherHandler(other);
    for (BaseSpecies* mixSpec : other.mixedObjects_)
    {
        mixedObjects_.push_back(mixSpec->copy());
        mixedObjects_.back()->setHandler(this);
    }
    logger(DEBUG, "SpeciesHandler::SpeciesHandler(const SpeciesHandler &other) finished");
}

References clear(), BaseSpecies::copy(), BaseHandler< ParticleSpecies >::copyContentsFromOtherHandler(), FATAL, BaseHandler< T >::getDPMBase(), logger, mixedObjects_, and BaseHandler< ParticleSpecies >::setDPMBase().

~SpeciesHandler()

SpeciesHandler::~SpeciesHandler ( )

override

Destructor, it destructs the SpeciesHandler and all ParticleSpecies it contains.

Destructor: first destroys the objects of the BaseHandler, then destroys the mixedObjects

Todo:

TW Note: deleting the species does not delete the particles and walls of this species.

{
    clear(); //this deletes everything that comes from the BaseHandler.
    /*for (BaseSpecies* o : mixedObjects_)
    {
        delete o;
    }*/
    for (BaseSpecies* mixSpec : mixedObjects_)
    {
        delete mixSpec;
    }
    mixedObjects_.clear();
    logger(DEBUG, "SpeciesHandler::~SpeciesHandler() finished");
}

References clear(), FATAL, logger, and mixedObjects_.

Member Function Documentation

addObject()

void SpeciesHandler::addObject ( ParticleSpecies *  S )

override

Adds a new ParticleSpecies to the SpeciesHandler.

Parameters

[in]

S

A pointer to the ParticleSpecies that has to be added.

First, add the ParticleSpecies to the vector of ParticleSpecies (object_), then construct all MixedSpecies. Tell the ParticleSpecies that this is its handler and compute all masses and whether it should use angular degrees of freedom.

Note: The MixedSpecies objects are initialized with averaged values from both species: e.g., the mixedSpecies between Species A and B will have a stiffness $fk=(1/k_a+1/k_b)^{-1}$f, you have to change the MixedSpecies properties if you don't like these defaults.

Todo:

TW don't put logger messages that only make sense for one application!

{
    BaseHandler<ParticleSpecies>::addObject(S);
    //logger(INFO, "Part / Mix: % / %", objects_.size(), mixedObjects_.size());
    S->setHandler(this);
    for (unsigned int id = 0; id + 1 < getNumberOfObjects(); ++id)
    {
        mixedObjects_.push_back(S->copyMixed());
        mixedObjects_.back()->setIndex(id);
        mixedObjects_.back()->setId(getNumberOfObjects() - 1);
        mixedObjects_.back()->mixAll(S, getObject(id));
    }
    getDPMBase()->particleHandler.computeAllMasses(S->getIndex());
    getDPMBase()->setRotation(useAngularDOFs());
    S->setMaxInteractionDistance(S->getInteractionDistance());
}

References BaseHandler< T >::addObject(), ParticleHandler::computeAllMasses(), ParticleSpecies::copyMixed(), BaseHandler< ParticleSpecies >::getDPMBase(), BaseObject::getIndex(), BaseSpecies::getInteractionDistance(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), BaseHandler< ParticleSpecies >::getObject(), mixedObjects_, DPMBase::particleHandler, BaseSpecies::setHandler(), ParticleSpecies::setMaxInteractionDistance(), DPMBase::setRotation(), and useAngularDOFs().

Referenced by GranularCollapse::GranularCollapse(), main(), MD_demo::MD_demo(), ParticleParticleInteraction::ParticleParticleInteraction(), ParticleParticleInteractionWithPlasticForces::ParticleParticleInteractionWithPlasticForces(), ParticleWallInteraction::ParticleWallInteraction(), readAndAddObject(), DPMBase::readParAndIniFiles(), BoundingRadiusTester::test(), InertiaTensorTester::test(), VolumeTest::test(), ShapeGradientHessianTester::testCushion(), ShapeGradientHessianTester::testEllipsoid(), ShapeGradientHessianTester::testRoundedBeam(), and ShapeGradientHessianTester::testSphere().

clear()

void SpeciesHandler::clear ( )

inlineoverridevirtual

Empties the whole BaseHandler by removing all Objects and setting all other variables to 0.

Delete all objects stored in objects_ and set the maximum number of objects that have been in this container to 0, and set the Id of the next object that will be added to 0.

Reimplemented from BaseHandler< ParticleSpecies >.

    {
        BaseHandler<ParticleSpecies>::clear();
        mixedObjects_.clear();
    }

References BaseHandler< T >::clear(), and mixedObjects_.

Referenced by operator=(), DPMBase::readParAndIniFiles(), DrumRot::setupInitialConditions(), RotatingDrum::setupInitialConditions(), BaseCluster::setupInitialConditions(), SpeciesHandler(), and ~SpeciesHandler().

getMixedId()

unsigned int SpeciesHandler::getMixedId	(	unsigned int	id1,
		unsigned int	id2
	)		const

Gets the Id of the behaviour between two given species.

Parameters

[in]	id1	Id of the first species.
[in]	id2	Id of the second species.

Returns

An unsigned integer that denotes the Id of the mixed species.

The numbering of the mixed species is 0-1, 0-2, 1-2, 0-3, 1-3, 2-3, 0-4, 1-4, 2-4, 3-4, ..., where each pair of numbers a and b denotes the mixed species between ParticleSpecies a and b. Thus, first compute which id has a higher value, the id of the mixed species is then given by (maxId*(maxId-1))/2 + minId.

{
    unsigned int maxId = std::max(id1, id2);
    return (maxId * (maxId - 1)) / 2 + std::min(id1, id2);
}

Referenced by getMixedObject(), and removeObject().

getMixedObject() [1/2]

template<typename U >

std::enable_if<!std::is_pointer<typename U::MixedSpeciesType>::value, typename U::MixedSpeciesType*>::type SpeciesHandler::getMixedObject ( const U *  S, const U *  T  )

inline

    {
        return static_cast<typename U::MixedSpeciesType*>(getMixedObject(S->getIndex(), T->getIndex()));
    }

Referenced by InteractionHandler::addInteraction(), ChuteWithPeriodicInflow::computeInternalForces(), AngleOfRepose::createBaseSpecies(), SilbertPeriodic::createBaseSpecies(), NurbsWall::getDistanceAndNormal(), Screw::getDistanceAndNormal(), IntersectionOfWalls::getDistanceAndNormal(), InteractionHandler::getInteraction(), SuperQuadricParticle::getInteractionRadius(), SuperQuadricParticle::getInteractionWith(), ParticleSpecies::getMixedSpecies(), MembraneDemo::initializeSpecies(), main(), protectiveWall::protectiveWall(), MercuryOS::setMaterialProperties(), ParticleSpecies::setMaxInteractionDistance(), my_problem::setupInitialConditions(), Chutebelt::setupInitialConditions(), MercuryLogo::setupInitialConditions(), Binary::setupInitialConditions(), ConstantMassFlowMaserBoundaryMixedSpeciesSelfTest::setupInitialConditions(), DPM::setupInitialConditions(), ContactDetectionIntersectionOfWallsTest::setupInitialConditions(), DrumRot::setupInitialConditions(), RotatingDrum::setupInitialConditions(), SpeciesTest::setupInitialConditions(), WallSpecies::setupInitialConditions(), T_protectiveWall::T_protectiveWall(), and useAngularDOFs().

getMixedObject() [2/2]

BaseSpecies * SpeciesHandler::getMixedObject	(	unsigned int	id1,
		unsigned int	id2
	)

Gets the mixed object that is constructed from two given species.

Parameters

[in]	id1	Id of the first BaseSpecies.
[in]	id2	Id of the second BaseSpecies.

Returns

A pointer to an object that is a MixedSpecies of both input Species.

Todo:

This function should probably be made private. The user should use the function SpeciesHandler::getMixedObject(const U* S, const U* T), which deals with pointers.

{
    if (id1 == id2)
    {
        return getObject(id1);
    }
    else
    {
        const unsigned int mixedId = getMixedId(id1, id2);
        if (mixedId>=mixedObjects_.size())
        {
            logger(WARN,
                   "In: Object* SpeciesHandler::getMixedObject(const unsigned int id) const. No Object exist with index %, number of objects is %",
                   std::max(id1, id2), getNumberOfObjects());
            return nullptr;
        }
        else
        {
            return mixedObjects_[mixedId];
        }
    }
}

References getMixedId(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), BaseHandler< ParticleSpecies >::getObject(), logger, mixedObjects_, and WARN.

getMixedObjects()

const std::vector< BaseSpecies * > & SpeciesHandler::getMixedObjects

(

)

const

Returns a pointer to the vector of all mixed objects.

Returns

A reference to the vector of pointers of all the mixedObjects.

{
    return mixedObjects_;
}

References mixedObjects_.

Referenced by BaseSpecies::setInteractionDistance().

getName()

std::string SpeciesHandler::getName ( ) const

override

Returns the name of the handler, namely the string "SpeciesHandler".

Returns

The string "SpeciesHandler"

{
    return "SpeciesHandler";
}

operator=()

SpeciesHandler & SpeciesHandler::operator=

(

const SpeciesHandler &

rhs

)

Assignment operator that copies all species and the pointer to the DPMBase from the given SpeciesHandler.

Parameters

[in]

rhs

The BoundaryHandler on the right hand side of the assignment.

Returns

The SpeciesHandler that is a copy of the input SpeciesHandler rhs.

This is not a copy assignment operator! It copies only all BaseSpecies and MixedSpecies and copies the pointer to the DPMBase. It sets all other data members to 0 or nullptr.

{
    if (this != &rhs)
    {
        clear();
        copyContentsFromOtherHandler(rhs);
        for (BaseSpecies* mixSpec : mixedObjects_)
        {
            delete mixSpec;
        }
        mixedObjects_.clear();
        for (BaseSpecies* mixSpec : rhs.mixedObjects_)
        {
            mixedObjects_.push_back(mixSpec->copy());
            mixedObjects_.back()->setHandler(this);
        }
    }
    
    logger(DEBUG, "SpeciesHandler SpeciesHandler::operator =(const SpeciesHandler& rhs)");
    return *this;
}

References clear(), BaseSpecies::copy(), BaseHandler< ParticleSpecies >::copyContentsFromOtherHandler(), FATAL, logger, and mixedObjects_.

readAndAddObject()

void SpeciesHandler::readAndAddObject ( std::istream &  is )

overridevirtual

Reads Species data into the SpeciesHandler from restart file.

Parameters

[in]

is

The input stream from which the information is read.

First determine the type of the object we want to read, then read the actual object. After that, clear the mixed objects and read the mixed objects.

Todo:

TW why does deleting these objects create a segmentation fault How do you create the segmentation fault?

Author

weinhartt

Todo:

IFCD how does the numbering of mixedSpecies_ work? the numbering of mixed species is 01, 02, 12, 03, 13, 23, 04, 14, 24, 34, i.e. if you add the n-th ParticleSpecies, then you have to add n-1 MixedSpecies. So here I remove the last n-1 MixedSpecies and add n-1 new ones.

Author

weinhartt

Implements BaseHandler< ParticleSpecies >.

{
    std::string type;
    is >> type;
    logger(DEBUG, "SpeciesHandler::readAndAddObject(is): reading type %.", type);
    if (type == "LinearViscoelasticSpecies")
    {
        LinearViscoelasticSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSpecies")
    {
        LinearPlasticViscoelasticSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "SinterSpecies")
    {
        SinterSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "SinterReversibleAdhesiveSpecies")
    {
        SinterReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "SinterFrictionReversibleAdhesiveSpecies")
    {
        SinterFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "SinterFrictionSpecies")
    {
        SinterFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianSinterSpecies")
    {
        HertzianSinterSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianSinterFrictionSpecies")
    {
        HertzianSinterFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianSinterSlidingFrictionSpecies")
    {
        HertzianSinterSlidingFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionSpecies")
    {
        LinearViscoelasticSlidingFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionSpecies")
    {
        LinearViscoelasticFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionSpecies")
    {
        LinearPlasticViscoelasticFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticBondedSpecies")
    {
        LinearViscoelasticBondedSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticReversibleAdhesiveSpecies")
    {
        LinearViscoelasticReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies")
    {
        LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionReversibleAdhesiveSpecies")
    {
        LinearViscoelasticFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionLiquidBridgeWilletSpecies")
    {
        LinearViscoelasticFrictionLiquidBridgeWilletSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionLiquidMigrationWilletSpecies")
    {
        LinearViscoelasticFrictionLiquidMigrationWilletSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionLiquidMigrationWilletSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionLiquidMigrationWilletSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianViscoelasticMindlinSpecies")
    {
        HertzianViscoelasticMindlinSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianViscoelasticMindlinRollingTorsionSpecies" ||
             type == "HertzianViscoelasticFrictionSpecies")
    {
        HertzianViscoelasticMindlinRollingTorsionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "HertzianViscoelasticFrictionChargedBondedSpecies")
    {
        HertzianViscoelasticFrictionChargedBondedSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionChargedBondedSpecies")
    {
        LinearViscoelasticFrictionChargedBondedSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "ThermalSinterSlidingFrictionSpecies")
    {
        Species<ThermalSpecies<SinterNormalSpecies>, SlidingFrictionSpecies> species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "ThermalSinterFrictionSpecies")
    {
        Species<ThermalSpecies<SinterNormalSpecies>, FrictionSpecies> species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionLiquidBridgeWilletSpecies")
    {
        LinearPlasticViscoelasticFrictionLiquidBridgeWilletSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "ThermalSinterLinFrictionReversibleAdhesiveSpecies")
    {
        Species<ThermalSpecies<SinterLinNormalSpecies>, FrictionSpecies, ReversibleAdhesiveSpecies> species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "k") //for backwards compatibility
    {
        addObject(readOldObject(is));
    }
    else
    {
        logger(WARN,
               "Species type % not understood in restart file: You need to add this species to SpeciesHandler::readObject.",
               type);
        std::stringstream line;
        helpers::getLineFromStringStream(is, line);
        copyAndAddObject(LinearViscoelasticSpecies());
    }
    
    //remove the default mixed species
    for (unsigned int i = 0; i + 1 < getNumberOfObjects(); i++)
    {
        delete mixedObjects_.back();
        mixedObjects_.pop_back();
    }
    
    //Read the mixed species.
    for (unsigned int i = 0; i + 1 < getNumberOfObjects(); i++)
    {
        is >> type;
        if (type == "LinearViscoelasticMixedSpecies")
        {
            LinearViscoelasticMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticMixedSpecies")
        {
            LinearPlasticViscoelasticMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "SinterMixedSpecies")
        {
            SinterMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "SinterReversibleAdhesiveMixedSpecies")
        {
            SinterReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "SinterFrictionReversibleAdhesiveMixedSpecies")
        {
            SinterFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "SinterFrictionMixedSpecies")
        {
            SinterFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianSinterMixedSpecies")
        {
            HertzianSinterMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianSinterFrictionMixedSpecies")
        {
            HertzianSinterFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianSinterSlidingFrictionMixedSpecies")
        {
            HertzianSinterSlidingFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionMixedSpecies")
        {
            LinearViscoelasticFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticBondedMixedSpecies")
        {
            LinearViscoelasticBondedMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionLiquidMigrationWilletMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionLiquidMigrationWilletMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionLiquidBridgeWilletMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionLiquidBridgeWilletMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies")
        {
            LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionLiquidMigrationWilletMixedSpecies")
        {
            LinearViscoelasticFrictionLiquidMigrationWilletMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianViscoelasticMindlinMixedSpecies")
        {
            HertzianViscoelasticMindlinMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianViscoelasticMindlinRollingTorsionMixedSpecies" ||
                 type == "HertzianViscoelasticFrictionMixedSpecies")
        {
            HertzianViscoelasticMindlinRollingTorsionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "HertzianViscoelasticFrictionChargedBondedMixedSpecies")
        {
            HertzianViscoelasticFrictionChargedBondedMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionChargedBondedMixedSpecies")
        {
            LinearViscoelasticFrictionChargedBondedMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "ThermalSinterSlidingFrictionMixedSpecies")
        {
            MixedSpecies<ThermalSpecies<SinterNormalSpecies>, SlidingFrictionSpecies> species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "ThermalSinterFrictionMixedSpecies")
        {
            MixedSpecies<ThermalSpecies<SinterNormalSpecies>, FrictionSpecies> species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "ThermalSinterLinFrictionReversibleAdhesiveMixedSpecies")
        {
            MixedSpecies<ThermalSpecies<SinterLinNormalSpecies>, FrictionSpecies, ReversibleAdhesiveSpecies> species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "ThermalSinterFrictionMixedSpecies")
        {
            MixedSpecies<ThermalSpecies<SinterNormalSpecies>, FrictionSpecies> species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else
        {
            logger(WARN,
                   "Species type % not understood in restart file: You need to add this species to SpeciesHandler::readMixedObject.",
                   type);
            std::stringstream line;
            helpers::getLineFromStringStream(is, line);
            LinearViscoelasticMixedSpecies species;
            mixedObjects_.push_back(species.copy());
        }
    }
}

References addObject(), MixedSpecies< NormalForceSpecies, FrictionForceSpecies, AdhesiveForceSpecies >::copy(), BaseHandler< ParticleSpecies >::copyAndAddObject(), FATAL, helpers::getLineFromStringStream(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), constants::i, logger, mixedObjects_, readOldObject(), and WARN.

readOldObject()

ParticleSpecies * SpeciesHandler::readOldObject

(

std::istream &

is

)

Reads ParticleSpecies into the SpeciesHandler from old-style restart data.

Parameters

[in]

is

The input stream from which the information is read.

Returns

A pointer to the ParticleSpecies that has just been read.

To read the old object, we first make a stringstream of the line that describes this ParticleSpecies. After that, we read the properties one by one, first the stiffness and after that the other properties. We stop when we either reach the end of the file(eof) or if a string is not recognized as a property.

{
    //read in next line
    std::stringstream line;
    helpers::getLineFromStringStream(is, line);
    
    //read each property
    std::string property;
    unsigned int particleDimension = 0;
    Mdouble density = 0.0, stiffness = 0.0, dissipation = 0.0, slidingFrictionCoefficient = 0.0, slidingFrictionCoefficientStatic = 0.0, slidingStiffness = 0.0, slidingDissipation = 0.0;
    line >> stiffness;
    while (true)
    {
        line >> property;
        if (property == "disp")
            line >> dissipation;
        else if (property == "rho")
            line >> density;
        else if (property == "kt")
            line >> slidingStiffness;
        else if (property == "dispt")
            line >> slidingDissipation;
        else if (property == "mu")
            line >> slidingFrictionCoefficient;
        else if (property == "mus")
            line >> slidingFrictionCoefficientStatic;
        else if (property == "dim_particle")
        {
            line >> particleDimension;
            getDPMBase()->setParticleDimensions(particleDimension);
        }
        else if (property == "(mixed)")
        {
            density = 0;
        }
        else
        {
            logger(WARN, "Warning: % is not a species property", property);
            break;
        }
        if (line.eof())
            break;
    }
    
    //create the correct species
    if (slidingFrictionCoefficient == 0.0)
    {
        LinearViscoelasticSpecies* species = new LinearViscoelasticSpecies;
        species->setDensity(density);
        species->setStiffness(stiffness);
        species->setDissipation(dissipation);
        return species;
    }
    else
    {
        LinearViscoelasticSlidingFrictionSpecies* species = new LinearViscoelasticSlidingFrictionSpecies;
        species->setDensity(density);
        species->setStiffness(stiffness);
        species->setDissipation(dissipation);
        species->setSlidingStiffness(slidingStiffness);
        species->setSlidingDissipation(slidingDissipation);
        species->setSlidingFrictionCoefficient(slidingFrictionCoefficient);
        if (slidingFrictionCoefficientStatic == 0.0)
            slidingFrictionCoefficientStatic = slidingFrictionCoefficient;
        species->setSlidingFrictionCoefficientStatic(slidingFrictionCoefficientStatic);
        return species;
    }
}

References BaseHandler< ParticleSpecies >::getDPMBase(), helpers::getLineFromStringStream(), logger, DPMBase::setParticleDimensions(), and WARN.

Referenced by readAndAddObject().

removeObject()

void SpeciesHandler::removeObject ( unsigned int  index )

overridevirtual

Remove the ParticleSpecies with given id.

Parameters

[in]

index

The index of which ParticleSpecies has to be removed from this ParticleHandler.

The ParticleSpecies with index is removed and the last ParticleSpecies in the vector is moved to its position. It also removes all mixed species for this ParticleSpecies.

Reimplemented from BaseHandler< ParticleSpecies >.

{
    BaseHandler<ParticleSpecies>::removeObject(index);
    for (unsigned int index2 = 0; index2 < getNumberOfObjects(); ++index2)
    {
        mixedObjects_.erase(mixedObjects_.begin() + getMixedId(index, index2));
    }
    getDPMBase()->setRotation(useAngularDOFs());
}

References BaseHandler< ParticleSpecies >::getDPMBase(), getMixedId(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), mixedObjects_, BaseHandler< T >::removeObject(), DPMBase::setRotation(), and useAngularDOFs().

Referenced by CurvyChute::recreateBottom().

useAngularDOFs()

bool SpeciesHandler::useAngularDOFs

(

)

Check if angular DOF have to be used.

Returns

The boolean which says whether or not AnuglarDOFs must be used in this handler.

{
    for (unsigned int i = 0; i < getSize(); i++)
    {
        if (getObject(i)->getUseAngularDOFs())
            return true;
        for (unsigned int j = 0; j + 1 < i; j++)
        {
            if (getMixedObject(i, j)->getUseAngularDOFs())
                return true;
        }
    }
    return false;
}

References getMixedObject(), BaseHandler< ParticleSpecies >::getObject(), BaseHandler< ParticleSpecies >::getSize(), BaseSpecies::getUseAngularDOFs(), and constants::i.

Referenced by addObject(), and removeObject().

write()

void SpeciesHandler::write ( std::ostream &  os ) const

virtual

Write all the species and mixed species to an output stream.

First write "Species" and the amount of species in this handler, then write all ParticleSpecies and MixedSpecies.

{
    os << "Species " << getNumberOfObjects() << "\n";
    unsigned idMixed = 0;
    for (const ParticleSpecies* species : objects_)
    {
        os << *species << "\n";
        for (unsigned int id2 = 0; id2 < species->getIndex(); id2++)
        {
            os << *mixedObjects_[idMixed] << "\n";
            idMixed++;
        }
    }
}

References BaseHandler< ParticleSpecies >::getNumberOfObjects(), mixedObjects_, and BaseHandler< ParticleSpecies >::objects_.

Referenced by DPMBase::write().

Member Data Documentation

mixedObjects_

std::vector<BaseSpecies*> SpeciesHandler::mixedObjects_

private

The list of pointers to the mixed species.

Referenced by addObject(), clear(), getMixedObject(), getMixedObjects(), operator=(), readAndAddObject(), removeObject(), SpeciesHandler(), write(), and ~SpeciesHandler().

---

The documentation for this class was generated from the following files:

• SpeciesHandler.h
• SpeciesHandler.cc