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 ()
	Destructor, it destructs the SpeciesHandler and all ParticleSpecies it contains. More...
virtual void	addObject (ParticleSpecies *const S)
	Adds a new ParticleSpecies to the SpeciesHandler. More...
void	removeObject (unsigned const int id)
	Remove the ParticleSpecies with given id. More...
void	readObject (std::istream &is)
	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 (const unsigned int id1, const unsigned int id2) const
	Gets the Id of the behaviour between two given species. More...
template<typename U >
U::MixedSpeciesType *	getMixedObject (const U *S, const U *T)
BaseSpecies *	getMixedObject (const unsigned int id1, const 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
	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...
U *	copyAndAddObject (const U &O)
	Creates a copy of a Object and adds it to the BaseHandler. More...
U *	copyAndAddObject (U *O)
	Creates a copy of a Object and adds it to the BaseHandler. More...
void	removeLastObject ()
	Removes the last Object from the BaseHandler. More...
void	clear ()
	Empties the whole BaseHandler by removing all Objects and setting all other variables to 0. 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...
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...
unsigned int	getNumberOfObjects () const
	Gets the number of Object in this BaseHandler. 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...
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...
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...

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.

Definition at line 37 of file SpeciesHandler.h.

Constructor & Destructor Documentation

SpeciesHandler::SpeciesHandler

(

)

Default constructor, it creates an empty SpeciesHandler.

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

Definition at line 56 of file SpeciesHandler.cc.

References DEBUG, and logger.

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

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.

Definition at line 67 of file SpeciesHandler.cc.

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

{
    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");
}

SpeciesHandler::~SpeciesHandler

(

)

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

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

Definition at line 111 of file SpeciesHandler.cc.

References BaseHandler< ParticleSpecies >::clear(), DEBUG, logger, and mixedObjects_.

{
    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");
}

Member Function Documentation

void SpeciesHandler::addObject ( ParticleSpecies *const  S )

virtual

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!

Reimplemented from BaseHandler< ParticleSpecies >.

Definition at line 546 of file SpeciesHandler.cc.

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

Referenced by readObject(), and DPMBase::readParAndIniFiles().

{
    BaseHandler<ParticleSpecies>::addObject(S);
    //logger(INFO, "Part / Mix: % / %", objects_.size(), mixedObjects_.size());
    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));
    }
    S->setHandler(this);
    getDPMBase()->particleHandler.computeAllMasses(S->getIndex());
    getDPMBase()->setRotation(useAngularDOFs());
    getDPMBase()->setRotation(useAngularDOFs());
}

unsigned int SpeciesHandler::getMixedId	(	const unsigned int	id1,
		const 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.

Definition at line 485 of file SpeciesHandler.cc.

Referenced by getMixedObject(), and removeObject().

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

template<class U >

U::MixedSpeciesType * SpeciesHandler::getMixedObject	(	const U *	S,
		const U *	T
	)

Parameters

[in]	S	A pointer to the first ParticleSpecies.
[in]	T	A pointer to the second ParticleSpecies.

Returns

A pointer to the MixedSpecies between the ParticleSpecies S and T.

Definition at line 496 of file SpeciesHandler.cc.

Referenced by InteractionHandler::getInteraction(), and useAngularDOFs().

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

BaseSpecies * SpeciesHandler::getMixedObject	(	const unsigned int	id1,
		const 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.

Definition at line 516 of file SpeciesHandler.cc.

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

{
    if (id1 == id2)
    {
      return getObject(id1);
    }
    else
    {
        if (std::max(id1,id2) >= getNumberOfObjects())
        {
            logger(ERROR, "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_[getMixedId(id1,id2)];
        }        
    }
}

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.

Definition at line 504 of file SpeciesHandler.cc.

References mixedObjects_.

{
    return mixedObjects_;
}

std::string SpeciesHandler::getName ( ) const

virtual

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

Returns

The string "SpeciesHandler"

Implements BaseHandler< ParticleSpecies >.

Definition at line 619 of file SpeciesHandler.cc.

{
    return "SpeciesHandler";
}

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.

Definition at line 87 of file SpeciesHandler.cc.

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

{
    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;
}

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

virtual

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 >.

Definition at line 130 of file SpeciesHandler.cc.

References addObject(), BaseHandler< ParticleSpecies >::copyAndAddObject(), ERROR, helpers::getLineFromStringStream(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), logger, mixedObjects_, and readOldObject().

{
    std::string type;
    is >> type;
    if (type == "LinearViscoelasticSpecies")
    {
        LinearViscoelasticSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSpecies")
    {
        LinearPlasticViscoelasticSpecies 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 == "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 == "k") //for backwards compatibility
    {
        addObject(readOldObject(is));
    }
    else
    {        
        std::stringstream line(std::stringstream::in | std::stringstream::out);
        helpers::getLineFromStringStream(is, line);
        logger(ERROR, "Species type % not understood in restart file. %", type, line.str());
    }

    //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 == "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 == "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 == "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;
        }
        else if (type == "LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies")
        {
            LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies species;
            is >> species;
        }
        else if (type == "k") //for backwards compatibility
        {
            mixedObjects_.push_back(readOldObject(is));
        }
        else
        {
            logger(ERROR, "Species type: % not understood in restart file", type);
        }
    }
}

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.

Definition at line 407 of file SpeciesHandler.cc.

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

Referenced by readObject().

{
    //read in next line
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    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;
    }
}

void SpeciesHandler::removeObject ( unsigned const int  id )

virtual

Remove the ParticleSpecies with given id.

Parameters

[in]

id

The identity of the ParticleSpecies that must be removed.

First remove the object itself, then remove all mixed species for this ParticleSpecies.

Reimplemented from BaseHandler< ParticleSpecies >.

Definition at line 569 of file SpeciesHandler.cc.

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

{
    BaseHandler<ParticleSpecies>::removeObject(id);
    for (unsigned int id2 = 0; id2 < getNumberOfObjects(); ++id2)
    {
        mixedObjects_.erase(mixedObjects_.begin()+getMixedId(id, id2));
    }
    getDPMBase()->setRotation(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.

Definition at line 627 of file SpeciesHandler.cc.

References getMixedObject(), BaseHandler< ParticleSpecies >::getNumberOfObjects(), BaseHandler< ParticleSpecies >::getObject(), and BaseSpecies::getUseAngularDOFs().

Referenced by addObject(), and removeObject().

{
    for (unsigned int i = 0; i < getNumberOfObjects(); 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;
}

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

virtual

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

Parameters

[in]

os

The output stream where the object needs to be written to.

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

Definition at line 583 of file SpeciesHandler.cc.

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

Referenced by DPMBase::write().

{
    os << "Species " << getNumberOfObjects() << std::endl;
    std::vector<BaseSpecies*>::const_iterator it2 = mixedObjects_.begin();
    for (std::vector<ParticleSpecies*>::const_iterator it = begin(); it != end(); ++it)
    {
        os << (**it) << std::endl;
        for (unsigned int id2 =0; id2 < (*it)->getIndex(); id2++)
        {
            os << (**it2) << std::endl;
            it2++;
        }
    }
    /*
    This behaves like the code above but is actually readable
    @weinhartt is there a reason?
    
    there is a reason. Curernt architecture does not allow this
    \todo define new restart format. @dducks
    
    The code is written such that it writes PS0, then PS1 and MS01, then PS2 and 
    MS02, MS12, and so on (PS=ParticleSpecies, MS=MixedSpecies). We can change 
    the restart format, but we should write the read(os) function such that 
    it can also read the old format @weinhartt
    
    for (ParticleSpecies * spec : objects_) {
      os << *spec << std::endl;
    }
    for (BaseSpecies * spec : mixedObjects_) {
       os << *spec << std::endl;
    }
    */
}

Member Data Documentation

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

private

The list of pointers to the mixed species.

Definition at line 93 of file SpeciesHandler.h.

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

---

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

• SpeciesHandler.h
• SpeciesHandler.cc