Container to store Interaction objects. More...

#include <InteractionHandler.h>

Inheritance diagram for InteractionHandler:

Public Member Functions
	InteractionHandler ()
	Default constructor, it creates an empty InteractionHandler. More...

	InteractionHandler (const InteractionHandler &IH UNUSED)
	Copy constructor, but since interactions must not be copied, it creates an empty InteractionHandler. More...

InteractionHandler	operator= (const InteractionHandler &rhs)
	Assignment operator. More...

	~InteractionHandler ()
	Destructor, it destructs the InteractionHandler and all BaseInteraction it contains. More...

void	addObject (BaseInteraction *I)
	Adds an Interaction to the InteractionHandler. More...

void	readObject (std::istream &is)
	Reads an Interaction into the InteractionHandler from restart data. More...

BaseInteraction *	getExistingInteraction (BaseInteractable P, BaseInteractable I) const
	Returns the Interaction between the BaseInteractable's P and I if it exists, otherwise returns a null pointer. More...

BaseInteraction *	getInteraction (BaseInteractable P, BaseInteractable I, Mdouble timeStamp)
	Returns the Interaction between the BaseInteractable's P and I. More...

BaseInteraction *	getInteraction (BaseInteractable P, BaseInteractable I, Mdouble timeStamp, const Vec3D &normal)
	Returns the Interaction between the BaseInteractable's P and I closest to the contact point (should be used when multiple contacts are possible). More...

void	removeObjectKeepingPeriodics (unsigned const int id)
	Removes interactions of periodic particles when the periodic particles get deleted (see DPMBase::removeDuplicatePeriodicParticles) More...

void	eraseOldInteractions (Mdouble lastTimeStep)
	erases interactions which have an old timestamp. More...

void	actionsAfterTimeStep ()

Mdouble	getMeanOverlap () const
	The mean overlap of all interactions. More...

void	write (std::ostream &os) const
	Writes the InteractionHandler to an output stream, for example a restart file. More...

void	setWriteVTK (FileType f)

FileType	getWriteVTK () const

void	writeVTK () const
	Writes all particles into a vtk file format (unstructured grid), consisting of particle positions, velocities, radii and type of species (IndSpecies) More...

std::string	getName () const
	Returns the name of the object. More...

Public Member Functions inherited from BaseHandler< BaseInteraction >
	BaseHandler ()
	Default BaseHandler constructor, it creates an empty BaseHandler and assigns DPMBase_ to a null pointer. More...

	BaseHandler (const BaseHandler< BaseInteraction > &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< BaseInteraction > &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...

virtual void	removeObject (unsigned const int id)
	Removes an Object from 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...

BaseInteraction *	getObjectById (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...

BaseInteraction *	getObject (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...

const BaseInteraction *	getObject (const unsigned int id) const
	Gets a constant pointer to the Object at the specified index in the BaseHandler. More...

BaseInteraction *	getLastObject ()
	Gets a pointer to the last Object in this BaseHandler. More...

const BaseInteraction *	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 < BaseInteraction * > ::const_iterator	begin () const
	Gets the begin of the const_iterator over all Object in this BaseHandler. More...

const std::vector < BaseInteraction * > ::iterator	begin ()
	Gets the begin of the iterator over all BaseBoundary in this BaseHandler. More...

const std::vector < BaseInteraction * > ::const_iterator	end () const
	Gets the end of the const_iterator over all BaseBoundary in this BaseHandler. More...

const std::vector < BaseInteraction * > ::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 (BaseInteraction *object, unsigned int id)
	This function sets the id and ensures that nextId is a bigger value than id. 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...

virtual void	writeVTK ()
	Over written in WallHandler and ParticleHandler. More...

Private Attributes
FileType	writeVTK_

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

Detailed Description

Container to store Interaction objects.

The InteractionHandler is a container to store all Interaction objects. It is implemented as a vector of BaseInteraction pointers.

Definition at line 37 of file InteractionHandler.h.

Constructor & Destructor Documentation

InteractionHandler::InteractionHandler ( )

Default constructor, it creates an empty InteractionHandler.

Constructor of the ParticleHandler class. It creates and empty ParticleHandler.

Definition at line 39 of file InteractionHandler.cc.

References DEBUG, logger, NO_FILE, and writeVTK_.

 {
     writeVTK_ = FileType::NO_FILE;
     logger(DEBUG, "InteractionHandler::InteractionHandler() finished");
 }

InteractionHandler::InteractionHandler ( const InteractionHandler &IH UNUSED )

Copy constructor, but since interactions must not be copied, it creates an empty InteractionHandler.

Parameters

[in] IH The InteractionHandler that has to be copied.

This is not a copy constructor! It only clears all variables, since by default interactions are not copied.

Todo:: Please check if interactions indeed don't need to be copied.

Definition at line 51 of file InteractionHandler.cc.

References DEBUG, logger, and writeVTK_.

         : BaseHandler<BaseInteraction>()
 {
     writeVTK_ = IH.writeVTK_;
     //By default interactions are not copied.
     logger(DEBUG, "InteractionHandler::InteractionHandler(const "
             "InteractionHandler &IH) finished, please note that no interactions"
             " have been copied.");
 }

InteractionHandler::~InteractionHandler ( )

Destructor, it destructs the InteractionHandler and all BaseInteraction it contains.

Definition at line 75 of file InteractionHandler.cc.

References DEBUG, and logger.

 {
     logger(DEBUG, "InteractionHandler::~InteractionHandler() finished");
 }

Member Function Documentation

void InteractionHandler::actionsAfterTimeStep ( )

Definition at line 278 of file InteractionHandler.cc.

Referenced by DPMBase::solve().

 {
     for (auto i: *this)
     {
         i->actionsAfterTimeStep();
     }
 }

void InteractionHandler::addObject ( BaseInteraction * I )

virtual

Adds an Interaction to the InteractionHandler.

Parameters

[in] P A pointer to the BaseInteraction (or derived class) that has to be added.

Reimplemented from BaseHandler< BaseInteraction >.

Definition at line 83 of file InteractionHandler.cc.

References BaseHandler< T >::addObject(), and BaseInteraction::setHandler().

Referenced by BaseInteraction::copySwitchPointer(), and getInteraction().

 {
     //Puts the particle in the Particle list
     BaseHandler<BaseInteraction>::addObject(I);
     //set the particleHandler pointer
     I->setHandler(this);
 }

void InteractionHandler::eraseOldInteractions ( Mdouble lastTimeStep )

erases interactions which have an old timestamp.

Each interaction contains a time stamp, which stores the last time that an interaction object has been called. Thus, one can see that an interaction has ended by comparing the time stamp with the last value of DPMBase::time_. This function erases all interactions that have ended.

Parameters

[in] lastTimeStep the last used value of DPMBase::time_.

Todo:: TW: this function has to be sped up with sth like this: erase(remove_if(begin(), end(), bind2nd(checkSpringTime(), lastTimeStep)), end());

Definition at line 260 of file InteractionHandler.cc.

References BaseInteraction::actionsOnErase(), BaseHandler< BaseInteraction >::getNumberOfObjects(), BaseHandler< BaseInteraction >::getObject(), BaseInteraction::getTimeStamp(), and BaseHandler< BaseInteraction >::removeObject().

Referenced by DPMBase::solve().

 {
     //std::cout<<"void InteractionHandler::eraseOldInteractions(Mdouble lastTimeStep)"<<std::endl;
     //std::cout<<"Current interactions="<<getNumberOfObjects()<<std::endl;
     //Remove_if reconstructs the vector with only elements passing the check_spring_time function
     //Erase removes the end of the vector
     for (unsigned int id = 0; id < getNumberOfObjects(); id++)
     {
         if (getObject(id)->getTimeStamp() <= lastTimeStep)
         {
             getObject(id)->actionsOnErase();
             removeObject(id);
             --id;
         }
     }
 }

BaseInteraction * InteractionHandler::getExistingInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I
	)		const

Returns the Interaction between the BaseInteractable's P and I if it exists, otherwise returns a null pointer.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.

Returns: the Interaction between the BaseInteractable's P and I, if it exists.

Definition at line 96 of file InteractionHandler.cc.

References BaseInteractable::getInteractions().

Referenced by getInteraction(), and removeObjectKeepingPeriodics().

 {
     //for particle-particle collision it is assumed BaseInteractable P has a lower index then I, so we only have to check for I, not P
     for (BaseInteraction* i :  P->getInteractions())
     {
         if (i->getI() == I)
         {
             return i;
         }
     }
     return nullptr;
 }

BaseInteraction * InteractionHandler::getInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		Mdouble	timeStamp
	)

Returns the Interaction between the BaseInteractable's P and I.

Returns a pointer to the existing Interaction, if the Interaction already exists otherwise creates a new Interaction and returns a pointer to it.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.
[in]	timeStamp	the current value of DPMBase::time_.

Returns: the Interaction between the BaseInteractable's P and I

Todo:: TW this can bet set earlier

Definition at line 117 of file InteractionHandler.cc.

References addObject(), BaseHandler< BaseInteraction >::getDPMBase(), getExistingInteraction(), BaseInteractable::getIndSpecies(), SpeciesHandler::getMixedObject(), BaseSpecies::getNewInteraction(), BaseInteraction::setSpecies(), BaseInteraction::setTimeStamp(), and DPMBase::speciesHandler.

Referenced by TriangulatedWall::getInteractionWith(), BaseWall::getInteractionWith(), BaseParticle::getInteractionWith(), and readObject().

 {
     BaseSpecies* species = getDPMBase()->speciesHandler.getMixedObject(P->getIndSpecies(), I->getIndSpecies());
     
     //std::cout << "Trying to reconnect to BaseInteraction between P=" << P->getId() << " and " << I->getId() << std::endl;
     BaseInteraction* C = getExistingInteraction(P, I);
     if (C == nullptr)
     {
         C = species->getNewInteraction(P, I, timeStamp);
         addObject(C);
         //std::cout << "Creating new interaction with index=" << getLastObject()->getIndex() << " id=" << getLastObject()->getId() << std::endl;
     }
     
     //set timeStamp
     C->setTimeStamp(timeStamp);
     
     //set species of collision
     C->setSpecies(species);
     
     return C;
 }

BaseInteraction * InteractionHandler::getInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		Mdouble	timeStamp,
		const Vec3D &	normal
	)

Returns the Interaction between the BaseInteractable's P and I closest to the contact point (should be used when multiple contacts are possible).

Returns a pointer to the existing Interaction, if the Interaction already exists otherwise creates a new Interaction and returns a pointer to it.

Parameters

[in]	P	the first BaseInteractable by which the interaction is defined.
[in]	I	the first BaseInteractable by which the interaction is defined.
[in]	timeStamp	the current value of DPMBase::time_.

Returns: the Interaction between the BaseInteractable's P and I

Definition at line 149 of file InteractionHandler.cc.

References addObject(), Vec3D::dot(), BaseHandler< BaseInteraction >::getDPMBase(), BaseInteractable::getIndSpecies(), BaseInteractable::getInteractions(), SpeciesHandler::getMixedObject(), BaseSpecies::getNewInteraction(), BaseInteraction::setSpecies(), BaseInteraction::setTimeStamp(), and DPMBase::speciesHandler.

 {
     BaseInteraction* c = nullptr;
     Mdouble dNormalMax = 0.9; //minimal agreement required
     for (const auto& i : P->getInteractions())
     {
         if (i->getI() == I && i->getTimeStamp() != timeStamp)
         {
             const Mdouble dNormal = Vec3D::dot(normal, i->getNormal());
             if (dNormal > dNormalMax)
             {
                 c = i;
                 dNormalMax = dNormal;
             }
         }
     }
     
     BaseSpecies* species = getDPMBase()->speciesHandler.getMixedObject(P->getIndSpecies(), I->getIndSpecies());
     
     if (c)
     {
         c->setTimeStamp(timeStamp);
     } else
     {
         c = species->getNewInteraction(P, I, timeStamp);
         c->setSpecies(species);
         addObject(c);
         //logger(INFO,"new interaction t=%: i=%, n=%",timeStamp,getNumberOfObjects(),normal);
     }
     
     return c;
 }

Mdouble InteractionHandler::getMeanOverlap ( ) const

The mean overlap of all interactions.

Returns: The mean overlap of all interactions

Definition at line 289 of file InteractionHandler.cc.

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

 {
     Mdouble sum = 0;
     for (BaseInteraction* const p : objects_)
     {
         sum += p->getOverlap();
     }
     return sum / getNumberOfObjects();
 }

std::string InteractionHandler::getName ( ) const

virtual

Returns the name of the object.

Returns: the string InteractionHandler

Implements BaseHandler< BaseInteraction >.

Definition at line 302 of file InteractionHandler.cc.

 {
     return "InteractionHandler";
 }

FileType InteractionHandler::getWriteVTK ( ) const

Definition at line 460 of file InteractionHandler.cc.

References writeVTK_.

Referenced by DPMBase::write(), writeVTK(), and DPMBase::writeVTK().

                                                {
     return writeVTK_;
 }

InteractionHandler InteractionHandler::operator= ( const InteractionHandler & rhs )

Assignment operator.

Parameters

[in] rhs The BoundaryHandler on the right hand side of the assignment.

Definition at line 64 of file InteractionHandler.cc.

References BaseHandler< BaseInteraction >::clear(), DEBUG, logger, and writeVTK_.

 {
     if (this != &rhs)
     {
         clear();
     }
     writeVTK_ = rhs.writeVTK_;
     logger(DEBUG, "InteractionHandler::operator =(const InteractionHandler& rhs) finished.");
     return *this;
 }

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

virtual

Reads an Interaction into the InteractionHandler from restart data.

Parameters

[in] is The input stream from which the information is read.

Todo:: TW: Change identifier in restart file from id to index; is there any reason the id should be kept after restarting, once this is done? (Note, the id is set to the old one in the particle handler because interactions store id, not indices; also note id's are slow

Implements BaseHandler< BaseInteraction >.

Definition at line 321 of file InteractionHandler.cc.

References BaseHandler< BaseInteraction >::getDPMBase(), getInteraction(), helpers::getLineFromStringStream(), BaseHandler< T >::getObjectById(), logger, DPMBase::particleHandler, VERBOSE, and DPMBase::wallHandler.

 {
     std::string type, dummy, idType;
     unsigned int id0, id1;
     Mdouble timeStamp;
     
     std::stringstream line(std::stringstream::in | std::stringstream::out);
     helpers::getLineFromStringStream(is, line);
     
     line >> type >> idType >> id0 >> id1 >> dummy >> timeStamp;
     logger(VERBOSE, "InteractionHandler::readObject(is): reading type % % %", type, id0, id1);
     BaseInteraction* C;
     if (idType.compare("particleIds") == 0) {
 //        C =  getDPMBase()->particleHandler.getObjectById(id1)->getInteractionWith(getDPMBase()->particleHandler.getObjectById(id0), timeStamp, this)[0];
         C = getInteraction(getDPMBase()->particleHandler.getObjectById(id0),
                            getDPMBase()->particleHandler.getObjectById(id1), timeStamp);
     }
     else {
 //        C =  getDPMBase()->wallHandler.getObjectById(id1)->getInteractionWith(getDPMBase()->particleHandler.getObjectById(id0), timeStamp, this)[0];
         C = getInteraction(getDPMBase()->particleHandler.getObjectById(id0),
                            getDPMBase()->wallHandler.getObjectById(id1), timeStamp);
     }
     line >> (*C);
 }

void InteractionHandler::removeObjectKeepingPeriodics ( unsigned const int id )

Removes interactions of periodic particles when the periodic particles get deleted (see DPMBase::removeDuplicatePeriodicParticles)

Deleting the three periodic interactions between two real particles is difficult, because its interaction information has to be saved. If the two real particles interacted (which can be checked by looking at the time stamp), the interaction between the real particles is kept, and all interactions that involve ghost particles gets removed; otherwise, the interaction between the lower-indexed real particle with the ghost particle of the higher indexed particles is saved (with the ghost particle replaced by the real particle), and all other interactions removed.

This is what this function is intended for, and it does it in the following way: When an interaction is removed the periodic particle has to be stored in the I pointer So when an interaction is removed where P is normal and I is periodic, and the information is new it will be transfered when the index of P is lower than the index of the real particle of I.

Parameters

[in] the id of the Interaction that needs to be deleted.

Todo:: TW The code assumes in a few places that P->getIndex()<I->getIndex(), but the copySwitchPointer function does not obey that rule; we have to check if this is valid behaviour.

Todo:: this function will create an error if the timeStamp is in the future! This should not happen (ever), but who knows.

Definition at line 200 of file InteractionHandler.cc.

References getExistingInteraction(), BaseInteraction::getI(), BaseObject::getIndex(), BaseHandler< BaseInteraction >::getObject(), BaseInteraction::getP(), BaseParticle::getPeriodicFromParticle(), BaseInteraction::getTimeStamp(), BaseHandler< T >::removeObject(), BaseHandler< BaseInteraction >::removeObject(), and BaseInteraction::setI().

Referenced by DPMBase::removeDuplicatePeriodicParticles().

 {
     BaseInteraction* iMain = getObject(id);
     
     BaseParticle* P = dynamic_cast<BaseParticle*>(iMain->getP());
     BaseParticle* I = dynamic_cast<BaseParticle*>(iMain->getI());
     if (P != nullptr && I != nullptr) //check that both P and I are particles (not walls)
     {
         BaseInteractable* realI = I->getPeriodicFromParticle();
         if (realI != nullptr && !P->getPeriodicFromParticle()) //check that P is a real and I is a ghost particle
         {
             if (P->getIndex() < realI->getIndex())
             {
                 BaseInteraction* iOther = getExistingInteraction(P, realI);
                 //You have to also check for existing interactions of the particles in reverse order since the copySwitchPointer function can revert the order of the particles
                 if (iOther == nullptr)
                 {
                     iOther = getExistingInteraction(realI, P);
                 }
                 if (iOther != nullptr) //if the interaction existed before the ghost particles were created
                 {
                     //Here we decide which of the two interactions should be kept:
                     //the interaction between the two real particles (iMain), or
                     //the interaction between the real and a ghost particle (iOther).
                     //It picks the one for which a collision has happened,
                     //i.e. the one with the newer timeStamp.
                     if (iOther->getTimeStamp() < iMain->getTimeStamp()) //if the interaction has been active during the last computeForce routine, make this the new (real) interaction.
 
                     {
                         iMain->setI(realI);
                         removeObject(iOther->getIndex());
                         return;
                     }
                     else  //if the interaction has not been active during the last computeForce routine
                     {
                         BaseHandler<BaseInteraction>::removeObject(id);
                         return;
                     }
                 }
                 else //if the interaction has been created during the last computeForce routine, make this a new (real) interaction. 
                 {
                     iMain->setI(realI);
                     return;
                 }
             }
         }
     }
     //this point is reached if either P or I are walls, or P and I are both ghost particles; in these cases, the interaction gets deleted
     BaseHandler<BaseInteraction>::removeObject(id);
 }

void InteractionHandler::setWriteVTK ( FileType f )

Definition at line 456 of file InteractionHandler.cc.

References writeVTK_.

Referenced by main(), and DPMBase::read().

                                                       {
     writeVTK_ = fileType;
 }

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

Writes the InteractionHandler to an output stream, for example a restart file.

Parameters

[in] os The output stream where the InteractionHandler must be written to, usually a restart file.

Definition at line 311 of file InteractionHandler.cc.

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

Referenced by DPMBase::write().

 {
     os << "Interactions " << getNumberOfObjects() << std::endl;
     for (BaseInteraction* i : objects_)
         os << (*i) << std::endl;
 }

void InteractionHandler::writeVTK ( ) const

Writes all particles into a vtk file format (unstructured grid), consisting of particle positions, velocities, radii and type of species (IndSpecies)

Writes all points ans cells to a file in the VTK format. The filename is hard-coded in this method, and is based on the name of the DPMBase and has a unique counter in it to ensure there are no two files with the same name.

Todo:: Check if this should indeed be a WARN

Definition at line 353 of file InteractionHandler.cc.

References BaseHandler< BaseInteraction >::getDPMBase(), BaseHandler< BaseInteraction >::getLastObject(), Files::getName(), BaseInteraction::getNameVTK(), BaseInteraction::getNumberOfFieldsVTK(), BaseHandler< BaseInteraction >::getNumberOfObjects(), BaseInteraction::getTypeVTK(), getWriteVTK(), INFO, logger, NO_FILE, helpers::to_string(), and WARN.

Referenced by DPMBase::writeVTK().

 {
     if (getWriteVTK()==FileType::NO_FILE)
         return;
 
     static unsigned fileCounter = 0;
     const std::string fileName = getDPMBase()->getName() + "Interaction_" +
                                  std::to_string(fileCounter++) + ".vtu";
     logger(INFO, "writing % (t=%, N=%)", fileName, getDPMBase()->getTime(), this->getNumberOfObjects());
 
     std::fstream file;
     file.open(fileName.c_str(), std::ios::out);
     if (file.fail())
     {
         logger(WARN, "Error in writeToFile: file % could not be opened", fileName);
     }
 
     file << "<?xml version=\"1.0\"?>\n\n";
     file << "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n";
     file << "<UnstructuredGrid>\n";
     file << "<Piece NumberOfPoints=\"" << this->getNumberOfObjects() << "\" NumberOfCells=\"" << 0 << "\">\n";
     file << "<Points>\n";
     file << "  <DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
     for (const auto &p: *this)
     {
         file << '\t' << p->getContactPoint() << '\n';
     }
     file << "  </DataArray>\n";
     file << "</Points>\n";
     file << "<PointData  Vectors=\"vector\">\n";
     file << "  <DataArray type=\"Float32\" Name=\"Normal\" NumberOfComponents=\"3\" format=\"ascii\">\n";
     // Add velocity
     for (const auto &p: *this)
     {
         file << '\t' << p->getNormal() << '\n';
     }
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Float32\" Name=\"Overlap\" format=\"ascii\">\n";
     // Add radius
     for (const auto &p: *this)
     {
         file << '\t' << p->getOverlap() << '\n';
     }
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Float32\" Name=\"ContactRadius\" format=\"ascii\">\n";
     // Add radius
     for (const auto &p: *this)
     {
         file << '\t' << p->getContactRadius() << '\n';
     }
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Float32\" Name=\"Force\" format=\"ascii\">\n";
     // Add species type
     for (const auto &p: *this)
     {
         file << '\t' << p->getForce() << '\n';
     }
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Float32\" Name=\"TangentialOverlap\" format=\"ascii\">\n";
     // Add species type
     for (const auto &p: *this)
     {
         file << '\t' << p->getTangentialOverlap() << '\n';
     }
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Float32\" Name=\"Torque\" format=\"ascii\">\n";
     // Add species type
     for (const auto &p: *this)
     {
         file << '\t' << p->getTorque() << '\n';
     }
     file << "  </DataArray>\n";
     //check if this type of Interaction has extra fields
     if (getLastObject()!= nullptr)
     {
         for (unsigned i = 0; i<getLastObject()->getNumberOfFieldsVTK(); i++)
         {
             file << "  <DataArray type=\"" << getLastObject()->getTypeVTK(i) << "\" Name=\"" << getLastObject()->getNameVTK(i) << "\" format=\"ascii\">\n";
             // Add species type
             for (const auto &p: *this)
             {
                 for (auto f : p->getFieldVTK(i))
                     file << '\t' << f << '\n';
             }
             file << "  </DataArray>\n";
         }
     }
     file << "</PointData>\n";
     file << "<Cells>\n";
     file << "  <DataArray type=\"Int32\" Name=\"connectivity\" format=\"ascii\">\n";
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"Int32\" Name=\"offsets\" format=\"ascii\">\n";
     file << "  </DataArray>\n";
     file << "  <DataArray type=\"UInt8\"  Name=\"types\" format=\"ascii\">\n";
     file << "  </DataArray>\n";
     file << "</Cells>\n";
     file << "</Piece>\n";
     file << "</UnstructuredGrid>\n";
     file << "</VTKFile>\n";
     file.close();
 }

Member Data Documentation

FileType InteractionHandler::writeVTK_

private

Definition at line 133 of file InteractionHandler.h.

Referenced by getWriteVTK(), InteractionHandler(), operator=(), and setWriteVTK().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation