DomainHandler Class Reference

Container to store all Domain. More...

#include <DomainHandler.h>

Inheritance diagram for DomainHandler:

Public Member Functions
	DomainHandler ()
	Default constructor, it creates an empty DomainHandler. More...
	DomainHandler (const DomainHandler &DH)
	Constructor that copies all Domain it contains. More...
DomainHandler &	operator= (const DomainHandler &rhs)
	Assignment operator. More...
	~DomainHandler () final
	Destructor, it destructs the DomainHandler and all Domain it contains. More...
void	createMesh (std::vector< Mdouble > &simulationMin, std::vector< Mdouble > &simulationMax, std::vector< unsigned > &numberOfDomains, bool open)
	Creates a Cartesian square mesh in 3D. More...
void	createDomains (std::vector< Mdouble > domainMin, std::vector< Mdouble > domainMax, std::vector< unsigned > &globalMeshIndex, std::vector< unsigned > &numberOfDomains, int dimCounter, std::vector< Mdouble > &meshSize, bool open)
	Recursive function that creates the domains for a 3D mesh. More...
void	addObject (Domain *D) final
	Adds a Domain to the DomainHandler. More...
void	readAndAddObject (std::istream &is) final
	reads a domain object More...
void	readOldObject (std::istream &is)
	reads an old domain object More...
std::string	getName () const final
	returns the name of the class More...
void	setCurrentDomainIndex (unsigned int index)
	This sets a domain to the processor. More...
Domain *	getCurrentDomain ()
	Gets the domain assigned to the processor. More...
const Domain *	getCurrentDomain () const
unsigned int	getCurrentDomainIndex () const
	Gets the domain index assigned to the processor. More...
void	setNumberOfDomains (std::vector< unsigned > &numberOfdomains)
	Sets the number of domains in the domain handler. More...
std::vector< unsigned >	getNumberOfDomains ()
	Gets the number of domains in the domain handler. More...
void	setInteractionDistance (Mdouble interactionDistance)
	Sets the interaction distance of the domain handler. More...
Mdouble	getInteractionDistance ()
	Gets the interaction distance of the domain handler. More...
int	getParticleDomainGlobalIndex (BaseParticle *particle)
int	getParticleProcessor (int globalIndex)
Domain *	getParticleDomain (int globalIndex)
void	updateStatus (std::set< BaseParticle * > &particlesToBeDeleted)
void	updateVelocity ()
void	addNewParticles ()
void	initialise ()
Public Member Functions inherited from BaseHandler< Domain >
	BaseHandler ()
	Default BaseHandler constructor, it creates an empty BaseHandler and assigns DPMBase_ to a null pointer. More...
	BaseHandler (const BaseHandler< Domain > &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< Domain > &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 (Domain *O)
	Adds an existing object to the BaseHandler without changing the id of the object. More...
virtual void	addObject (Domain *object)
	Adds a new Object to the BaseHandler. More...
virtual void	addGhostObject (Domain *O)
	Adds a new Object to the BaseHandler. called by the to avoid increasing the id. More...
void	removeIf (const std::function< bool(Domain *)> cond)
virtual void	removeObject (unsigned const int index)
	Removes an Object from the BaseHandler. More...
virtual void	removeObjects (std::vector< unsigned int > indices)
void	removeLastObject ()
	Removes the last Object from the BaseHandler. More...
virtual 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...
Domain *	getObjectById (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
std::vector< Domain * >	getObjectsById (const unsigned int id)
	Gets a vector of pointers to the objects with the specific id. More...
Domain *	getObject (const unsigned int id)
	Gets a pointer to the Object at the specified index in the BaseHandler. More...
const Domain *	getObject (const unsigned int id) const
	Gets a constant pointer to the Object at the specified index in the BaseHandler. More...
Domain *	getLastObject ()
	Gets a pointer to the last Object in this BaseHandler. More...
const Domain *	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 Domain &obj)
	Resizes the container to contain N elements. More...
const std::vector< Domain * >::const_iterator	begin () const
	Gets the begin of the const_iterator over all Object in this BaseHandler. More...
const std::vector< Domain * >::iterator	begin ()
	Gets the begin of the iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< Domain * >::const_iterator	end () const
	Gets the end of the const_iterator over all BaseBoundary in this BaseHandler. More...
const std::vector< Domain * >::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 (Domain *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 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
unsigned int	currentDomainIndex_
	Index to the particular domain of this process. More...
std::vector< int >	globalIndexToProcessorList_
	look-up table to find the processor of a domain given the globalIndex of the domain More...
std::vector< unsigned >	numberOfDomains_
	vector containing the number of domains in Cartesian direction More...
Mdouble	interactionDistance_
	Interaction distance between a domain boundary and the communication zone boundary. More...

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

Detailed Description

Container to store all Domain.

The DomainHandler is a container to store all Domain. It is implemented by a vector of pointers to domain. Additionally it also contains an index that points to the current domain of the processorID. Such that the processor knows which Domain it has to compute

Constructor & Destructor Documentation

DomainHandler() [1/2]

DomainHandler::DomainHandler

(

)

Default constructor, it creates an empty DomainHandler.

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

{
    currentDomainIndex_ = 0;
    interactionDistance_ = 0.0;
    logger(DEBUG, "DomainHandler::DomainHandler() finished");
}

References currentDomainIndex_, DEBUG, interactionDistance_, and logger.

DomainHandler() [2/2]

DomainHandler::DomainHandler

(

const DomainHandler &

DH

)

Constructor that copies all Domain it contains.

Parameters

[in]

DH

The DomainHandler that has to be copied.

This is not a copy constructor! It copies the DPMBase and all Domain, and sets the other variables to 0.

        : BaseHandler<Domain>()
{
    copyContentsFromOtherHandler(DH);
    logger(DEBUG, "DomainHandler::DomainHandler(const DomainHandler &DH) finished");
}

References BaseHandler< Domain >::copyContentsFromOtherHandler(), DEBUG, and logger.

~DomainHandler()

DomainHandler::~DomainHandler ( )

final

Destructor, it destructs the DomainHandler and all Domain it contains.

All Domain are destroyed, the DomainHandler afterwards.

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

References DEBUG, and logger.

Member Function Documentation

addNewParticles()

void DomainHandler::addNewParticles

(

)

{
    getCurrentDomain()->addNewParticles();
}

References Domain::addNewParticles(), and getCurrentDomain().

Referenced by DPMBase::performGhostParticleUpdate(), DPMBase::read(), and DPMBase::updateGhostGrid().

addObject()

void DomainHandler::addObject ( Domain *  D )

final

Adds a Domain to the DomainHandler.

Parameters

[in]

D

A pointer to the Domain that has to be added.

Adds the object to the DomainHandler and sets the DomainHandler pointer in the Domain to this DomainHandler.

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

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

createDomains()

void DomainHandler::createDomains	(	std::vector< Mdouble >	domainMin,
		std::vector< Mdouble >	domainMax,
		std::vector< unsigned > &	globalMeshIndex,
		std::vector< unsigned > &	numberOfDomains,
		int	dimCounter,
		std::vector< Mdouble > &	meshSize,
		bool	open
	)

Recursive function that creates the domains for a 3D mesh.

For a given dimension, dimCounter, compute the size of the domain, and accordingly create domains with the correct minimum and maximum value in the dimCounter-direction. When all bounds of a domain are set, i.e. dimCounter is zero, the domain is actually created.

Parameters

[in,out]	domainMin	The minimum simulation values in Cartesian direction as input and the minimum domain values as output/input
[in]	domainMax	The maximum simulation values in Cartesian direction as input and the maximum domain values as output/input
[in]	globalMeshIndex	A Vector containing the mesh indices, i.e. (i,j,k) = (3,5,2)
[in]	numberOfDomains	A vector containing the number of domains in Cartesian direction
[in]	dimCounter	The dimension counter that keeps track in which direction the recursive function is working
[in]	open	determines if a domain boundary is open (inf) or closed

{
    //
    if (dimCounter == 0)
    {
        //Create a new domain
        Domain domain(globalMeshIndex);
        domain.setHandler(this);
        const std::vector<double>& domainBoundMin = domainMin;
        const std::vector<double>& domainBoundMax = domainMax;
        domain.setBounds(domainBoundMin, domainBoundMax, true);
        this->copyAndAddObject(domain);
    }
    else
    {
        dimCounter--;
        //Compute size of a domain in the dimCounter'th direction.
        Mdouble boundLeft = domainMin[dimCounter];
        //Starting with the bound left, create the number of domains in the given dimCounter-direction
        for (int i = 0; i < numberOfDomains[dimCounter]; i++)
        {
            globalMeshIndex[dimCounter] = i;
            domainMin[dimCounter] = boundLeft + i * meshSize[dimCounter];
            domainMax[dimCounter] = boundLeft + (i + 1) * meshSize[dimCounter];
            if ((i == 0) && (open))
            {
                domainMin[dimCounter] = -constants::inf;
            }
            
            if ((i == numberOfDomains[dimCounter] - 1) && (open))
            {
                domainMax[dimCounter] = constants::inf;
            }
            
            //Start recursively a new createDomains function
            createDomains(domainMin, domainMax, globalMeshIndex, numberOfDomains, dimCounter, meshSize, open);
        }
    }
}

References BaseHandler< Domain >::copyAndAddObject(), domain, i, and constants::inf.

Referenced by createMesh().

createMesh()

void DomainHandler::createMesh	(	std::vector< Mdouble > &	simulationMin,
		std::vector< Mdouble > &	simulationMax,
		std::vector< unsigned > &	numberOfDomains,
		bool	open
	)

Creates a Cartesian square mesh in 3D.

Creates a cartesian square mesh in 3D.

By default the number of domains should be 1 in each direction. The mesh creates the required 3D domains and then disables any domain boundaries that are not connected to another domain. Lookup tables are created between domains and ranks.

Parameters

[in]	simulationMin	The minimum values of the simulation domain in cartesian coordinates
[in]	simulationMax	The maximum values of the simulation domain in cartesian coordinates
[in]	numberOfDomains	The number of domains in cartesian direction
[in]	open	Determines if the boundary domains have infinite limits (true) or not (false)

{
    //Clear the objects in the list, we're gonna make a new mesh, owyeah
    objects_.clear();
    
    //Create the mesh
    setNumberOfDomains(numberOfDomains);
    
    std::vector<unsigned> globalMeshIndex(3);
    //Recursive function creating the domains
    int dimCounter = 3;
    //Compute the mesh size in each direction
    std::vector<Mdouble> meshSize;
    for (int d = 0; d < 3; d++)
    {
        meshSize.push_back((simulationMax[d] - simulationMin[d]) / numberOfDomains[d]);
    }
    //Create the domains
    createDomains(simulationMin, simulationMax, globalMeshIndex, numberOfDomains, dimCounter, meshSize, open);
    
    //Create lookup tables
    for (Domain* domain : objects_)
    {
        domain->setRank(domain->getGlobalIndex());
        domain->createLookUpTable();
    }
    
    //Disable boundaries that dont require communication
    for (Domain* domain : objects_)
    {
        domain->disableBoundaries();
    }
    
    //Output the result
    std::string meshType;
    if (open)
    {
        meshType = "open";
    }
    else
    {
        meshType = "closed";
    }
    if (PROCESSOR_ID == 0)
    {
        logger(INFO, "A simulation mesh has been created with % number of domains and % boundaries.", this->getSize(),
               meshType);
    }
}

References createDomains(), domain, BaseHandler< Domain >::getSize(), INFO, logger, BaseHandler< Domain >::objects_, PROCESSOR_ID, setNumberOfDomains(), and oomph::Global_string_for_annotation::string().

Referenced by DPMBase::decompose().

getCurrentDomain() [1/2]

Domain * DomainHandler::getCurrentDomain

(

)

Gets the domain assigned to the processor.

Returns a pointer to the active domain.

The active domain is the domain that was assigned to the processor

Returns

Pointer to a Domain on which the processor has to do computations

{
    return getObject(currentDomainIndex_);
}

References currentDomainIndex_, and BaseHandler< Domain >::getObject().

Referenced by addNewParticles(), DPMBase::deleteGhostParticles(), PeriodicBoundaryHandler::findTargetProcessor(), DPMBase::getCurrentDomain(), PeriodicBoundaryHandler::getMPIFlags(), ParticleHandler::getNumberOfRealObjectsLocal(), DPMBase::insertGhostParticle(), DPMBase::mpiInsertParticleCheck(), DPMBase::mpiIsInCommunicationZone(), ForceLawsMPI2Test::printTime(), setInteractionDistance(), DPMBase::updateGhostGrid(), updateStatus(), and updateVelocity().

getCurrentDomain() [2/2]

const Domain * DomainHandler::getCurrentDomain

(

)

const

{
    return getObject(currentDomainIndex_);
}

References currentDomainIndex_, and BaseHandler< Domain >::getObject().

getCurrentDomainIndex()

unsigned int DomainHandler::getCurrentDomainIndex

(

)

const

Gets the domain index assigned to the processor.

Gets the Domain Index in the vector of the DomainHandler assigned to this processor

Returns

Index of a Domain on which the processor has to do computations

{
    return currentDomainIndex_;
}

References currentDomainIndex_.

getInteractionDistance()

Mdouble DomainHandler::getInteractionDistance

(

)

Gets the interaction distance of the domain handler.

Gets the interaction distance of the communication zone.

The interaction distance is used to define how large the communication zone of the domains have to be. generally twice the size of the largest interaction radius

Returns

Returns the interaction distance of the communication zone

{
    return interactionDistance_;
}

References interactionDistance_.

Referenced by Domain::findNearbyBoundaries(), Domain::isInGreaterDomain(), Domain::isInInnerDomain(), and DPMBase::updateGhostGrid().

getName()

std::string DomainHandler::getName ( ) const

finalvirtual

returns the name of the class

Todo:

Still has to be implemented

Implements BaseHandler< Domain >.

{
    return "DomainHandler";
}

getNumberOfDomains()

std::vector< unsigned > DomainHandler::getNumberOfDomains

(

)

Gets the number of domains in the domain handler.

The number of domains is given as a vector in the form of (nx,ny,nz) where nx,ny,nz are the number of domains in their respective direction

Returns

The number of domains in Cartesian direction

{
    return numberOfDomains_;
}

References numberOfDomains_.

Referenced by Domain::createLookUpTable(), Domain::disableBoundaries(), and getParticleDomainGlobalIndex().

getParticleDomain()

Domain * DomainHandler::getParticleDomain

(

int

globalIndex

)

Todo:

TW, Marnix should this be unsigned int?

{
    return getObject(globalIndex);
}

References BaseHandler< Domain >::getObject().

getParticleDomainGlobalIndex()

int DomainHandler::getParticleDomainGlobalIndex

(

BaseParticle *

particle

)

Todo:

MX: function under construction

TW, Marnix should this be unsigned int?

Todo:

MX: This function is still under development the goal of this function is to obtain the globalIndex of the domain the particle is located in

Todo:

this could possibly be stored in the domainHandler to save computational power

{
    //Step 1: obtain values i,j,k by looking at the position
    std::vector<int> decompositionVector(3);
    
    int i, j, k;
    Mdouble dx = (getDPMBase()->getXMax() - getDPMBase()->getXMin()) / getDPMBase()->getNumberOfDomains()[0];
    Mdouble dy = (getDPMBase()->getYMax() - getDPMBase()->getYMin()) / getDPMBase()->getNumberOfDomains()[1];
    Mdouble dz = (getDPMBase()->getZMax() - getDPMBase()->getZMin()) / getDPMBase()->getNumberOfDomains()[2];
    
    //x-direction
    if ((particle->getPosition().X - getDPMBase()->getXMin()) <= 0)
    {
        i = 0;
    }
    else
    {
        //Compute the relative domain cell it is in
        i = floor((particle->getPosition().X - getDPMBase()->getXMin()) / dx);
        
        //Make sure we dont go over our number of domain bounds
        if (i >= getDPMBase()->getNumberOfDomains()[0] - 1)
        {
            i = getDPMBase()->getNumberOfDomains()[0] - 1;
        }
        if (i < 0)
        {
            i = 0;
        }
    }
    
    //y-direction
    if ((particle->getPosition().Y - getDPMBase()->getYMin()) <= 0)
    {
        j = 0;
    }
    else
    {
        j = floor((particle->getPosition().Y - getDPMBase()->getYMin()) / dy);
        
        //Make sure we dont go over our number of domain bounds
        if (j >= getDPMBase()->getNumberOfDomains()[1] - 1)
        {
            j = getDPMBase()->getNumberOfDomains()[1] - 1;
        }
        if (i < 0)
        {
            j = 0;
        }
    }
    
    //z-direction
    if ((particle->getPosition().Z - getDPMBase()->getZMin()) <= 0)
    {
        k = 0;
    }
    else
    {
        k = floor((particle->getPosition().Z - getDPMBase()->getZMin()) / dz);
        //Make sure we dont go over our number of domain bounds
        if (k >= getDPMBase()->getNumberOfDomains()[2] - 1)
        {
            k = getDPMBase()->getNumberOfDomains()[2] - 1;
        }
        if (k < 0)
        {
            k = 0;
        }
        
    }
    
    //Step 2: obtain the processor number
    int globalIndex = i +
                      getDPMBase()->getNumberOfDomains()[0] * j +
                      getDPMBase()->getNumberOfDomains()[1] * getDPMBase()->getNumberOfDomains()[0] * k;
    return globalIndex;
}

References Eigen::bfloat16_impl::floor(), BaseHandler< Domain >::getDPMBase(), getNumberOfDomains(), DPMBase::getNumberOfDomains(), BaseInteractable::getPosition(), DPMBase::getXMax(), DPMBase::getXMin(), DPMBase::getYMax(), DPMBase::getYMin(), DPMBase::getZMax(), DPMBase::getZMin(), i, j, k, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by SubcriticalMaserBoundaryTEST::copyExtraParticles(), SubcriticalMaserBoundaryTEST::extendBottom(), and PeriodicBoundaryHandler::findTargetProcessor().

getParticleProcessor()

int DomainHandler::getParticleProcessor

(

int

globalIndex

)

Todo:

TW, Marnix should this be unsigned int?

{
    return globalIndex;//ToProcessorList_[globalIndex];
}

Referenced by SubcriticalMaserBoundaryTEST::copyExtraParticles(), SubcriticalMaserBoundaryTEST::extendBottom(), and PeriodicBoundaryHandler::findTargetProcessor().

initialise()

void DomainHandler::initialise

(

)

{
    //Create a single domain
    Domain domain;
    domain.setHandler(this);
    std::vector<double> domainBoundMin = {-constants::inf, -constants::inf, -constants::inf};
    std::vector<double> domainBoundMax = {constants::inf, constants::inf, constants::inf};
    domain.setBounds(domainBoundMin, domainBoundMax, false);
    this->copyAndAddObject(domain);
    currentDomainIndex_ = 0;
}

References BaseHandler< Domain >::copyAndAddObject(), currentDomainIndex_, domain, and constants::inf.

Referenced by DPMBase::constructor(), and DPMBase::DPMBase().

operator=()

DomainHandler & DomainHandler::operator=

(

const DomainHandler &

rhs

)

Assignment operator.

Parameters

[in]

rhs

The DomainHandler on the right hand side of the assignment.

This is not a copy assignment operator! It copies the DPMBase and all Domain, and sets the other variables to 0.

{
    if (this != &rhs)
    {
        clear();
        copyContentsFromOtherHandler(rhs);
    }
    logger(DEBUG, "DomainHandler DomainHandler::operator =(const DomainHandler& rhs)");
    return *this;
}

References BaseHandler< Domain >::clear(), BaseHandler< Domain >::copyContentsFromOtherHandler(), DEBUG, and logger.

readAndAddObject()

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

finalvirtual

reads a domain object

Todo:

Still has to be implemented

There is no need to read domain object, they can be computed easily

Implements BaseHandler< Domain >.

{
}

readOldObject()

void DomainHandler::readOldObject

(

std::istream &

is

)

reads an old domain object

Todo:

Still has to be implemented

There is no need to read a domain object, they can be computed easily

{
}

setCurrentDomainIndex()

void DomainHandler::setCurrentDomainIndex

(

unsigned int

index

)

This sets a domain to the processor.

Parameters

[in]

index

An integer to a Domain in the DomainHandler

Sets an index to a Domain in the DomainHandler which belongs to the current processor.

{
    currentDomainIndex_ = index;
}

References currentDomainIndex_.

Referenced by DPMBase::decompose().

setInteractionDistance()

void DomainHandler::setInteractionDistance

(

Mdouble

interactionDistance

)

Sets the interaction distance of the domain handler.

Sets the interaction distance of the domainHandler.

The interaction distance is used to define how large the communication zone of the domains have to be. generally twice the size of the largest interaction radius

Parameters

[in]

interactionDistance

Interaction distance between domain boundary and communication zone boundary

{
    //Update the interaction distance
    interactionDistance_ = interactionDistance;
    
    //Check if the domainsize is not too small
    Domain* domain = getCurrentDomain();
    logger.assert_always((domain->getDomainMax()[0] - domain->getDomainMin()[0]) > 2 * interactionDistance_,
                         "Size of the domain in x-direction is smaller than communication zone. Size: %, communication zone: %",
                         (domain->getDomainMax()[0] - domain->getDomainMin()[0]), 2 * interactionDistance_);
    logger.assert_always((domain->getDomainMax()[1] - domain->getDomainMin()[1]) > 2 * interactionDistance_,
                         "Size of the domain in y-direction is smaller than communication zone. Size: %, communication zone: %",
                         (domain->getDomainMax()[1] - domain->getDomainMin()[1]), 2 * interactionDistance);
    logger.assert_always((domain->getDomainMax()[2] - domain->getDomainMin()[2]) > 2 * interactionDistance_,
                         "Size of the domain in z-direction is smaller than communication zone. Size: %, communication zone: %",
                         (domain->getDomainMax()[2] - domain->getDomainMin()[2]), 2 * interactionDistance_);
}

References domain, getCurrentDomain(), interactionDistance_, and logger.

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

setNumberOfDomains()

void DomainHandler::setNumberOfDomains

(

std::vector< unsigned > &

numberOfDomains

)

Sets the number of domains in the domain handler.

The number of domains is given as a vector in the form of (nx,ny,nz) where nx,ny,nz are the number of domains in their respective direction

Parameters

[in}	numberOfDomains the number of domains in Cartesian direction

{
    numberOfDomains_ = numberOfDomains;
}

References numberOfDomains_.

Referenced by createMesh().

updateStatus()

void DomainHandler::updateStatus

(

std::set< BaseParticle * > &

particlesToBeDeleted

)

{
    getCurrentDomain()->updateStatus(particlesToBeDeleted);
}

References getCurrentDomain(), and Domain::updateStatus().

Referenced by DPMBase::performGhostParticleUpdate().

updateVelocity()

void DomainHandler::updateVelocity

(

)

{
    getCurrentDomain()->updateVelocity();
}

References getCurrentDomain(), and Domain::updateVelocity().

Member Data Documentation

currentDomainIndex_

unsigned int DomainHandler::currentDomainIndex_

private

Index to the particular domain of this process.

Referenced by DomainHandler(), getCurrentDomain(), getCurrentDomainIndex(), initialise(), and setCurrentDomainIndex().

globalIndexToProcessorList_

std::vector<int> DomainHandler::globalIndexToProcessorList_

private

look-up table to find the processor of a domain given the globalIndex of the domain

interactionDistance_

Mdouble DomainHandler::interactionDistance_

private

Interaction distance between a domain boundary and the communication zone boundary.

Referenced by DomainHandler(), getInteractionDistance(), and setInteractionDistance().

numberOfDomains_

std::vector<unsigned> DomainHandler::numberOfDomains_

private

vector containing the number of domains in Cartesian direction

Referenced by getNumberOfDomains(), and setNumberOfDomains().

---

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

• DomainHandler.h
• DomainHandler.cc