SubcriticalMaserBoundaryTEST Class Reference

#include <SubcriticalMaserBoundaryTEST.h>

Inheritance diagram for SubcriticalMaserBoundaryTEST:

Public Member Functions
	SubcriticalMaserBoundaryTEST ()
	MaserBoundary constructor. More...
	~SubcriticalMaserBoundaryTEST () override
	destructor More...
SubcriticalMaserBoundaryTEST *	copy () const override
	Creates a copy of this maser on the heap. More...
void	read (std::istream &is) override
	reads boundary properties from istream More...
void	write (std::ostream &os) const override
	writes boundary properties to ostream More...
std::string	getName () const override
	Returns the name of the object. More...
void	actionsBeforeTimeLoop () override
void	createPeriodicParticle (BaseParticle *p, ParticleHandler &pH) override
	Creates periodic particles when the particle is a maser particle and is sufficiently close to one of the boundary walls. More...
bool	checkBoundaryAfterParticleMoved (BaseParticle *p, ParticleHandler &pH) const
	Shifts the particle to its 'periodic' position if it is a maser particle and has crossed either of the walls. Creates a 'normal' particle at its current position if it is a maser particle which crossed the RIGHT boundary wall. More...
void	checkBoundaryAfterParticlesMove (ParticleHandler &pH) override
	Evaluates what the particles have to do after they have changed position. More...
void	activateMaser ()
	Activates the maser functionaly of this periodic boundary. More...
void	deactivateMaser ()
	Stops copying particles, and act merely as a periodic domain. More...
bool	isActivated () const
	Returns whether the maser is activated or not. More...
void	setActivationTime (Mdouble time)
	sets the activate time of the maser More...
Mdouble	getDistance (const Vec3D &position) const override
	gets the distance to the closest wall if maser is inactive, otherwise distance to right wall More...
Mdouble	getDistanceFromRight (const Vec3D &position) const
	returns the distance to the right wall More...
void	modifyPeriodicComplexity (std::vector< int > &complexity, int &totalPeriodicComplexity, BaseParticle *particle, int i) const override
	modifies the periodic complexity to support a maser boundary More...
void	modifyGhostAfterCreation (BaseParticle *particle, int i) override
void	performActionsBeforeAddingParticles () override
	Checks before adding particles if the maser needs to be activated. More...
void	extendBottom () const
void	copyExtraParticles () const
void	setCopyFlowParticles (bool copyFlowParticles)
Public Member Functions inherited from PeriodicBoundary
	PeriodicBoundary ()
	default constructor More...
	~PeriodicBoundary () override
	destructor More...
	PeriodicBoundary (const PeriodicBoundary &other)
	copy constructor More...
void	set (Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight)
	Defines a PeriodicBoundary by its normal and positions. More...
void	set (Vec3D normal, Vec3D positionLeft, Vec3D positionRight)
	As above, but by specifying two positions that the boundaries go through instead of distanceLeft and distanceRight. More...
void	set (Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight, Vec3D shiftDirection)
	For general parallelogramic domains, the direction of the shift vector can to be set manually. More...
void	setPlanewiseShift (Vec3D planewiseShift)
	Set the planewise shift (projected onto the planewise direction, and zero by default). More...
Vec3D	getNormal () const
	returns the vector normal to the periodic boundary More...
Mdouble	getDistanceLeft () const
	Returns the distance of the left wall to the origin, in normal direction. More...
Mdouble	getDistanceRight () const
	Returns the distance of the right wall to the origin, in normal direction. More...
Vec3D	getShift () const
	Returns the vector going from the left to the right side of the periodic boundary. More...
void	moveLeft (Mdouble distanceLeft)
	Sets the distance from the origin of the 'left' periodic wall. More...
void	moveRight (Mdouble distanceRight)
	Sets the distance from the origin of the 'right' periodic wall. More...
Mdouble	getDistance (const BaseParticle &p) const override
	Returns the distance of the edge to the particle. More...
virtual void	shiftPosition (BaseParticle *p) const override
	shifts the particle More...
void	shiftPosition (Vec3D &p) const
virtual void	shiftPositions (Vec3D &postition1, Vec3D &postion2) const
	shifts two positions More...
virtual bool	isClosestToLeftBoundary (const BaseParticle &p) const
	Returns TRUE if particle checked is closest to the 'left' edge, and FALSE if it is closest to the 'right' edge. More...
bool	isClosestToLeftBoundary (const Vec3D &p) const override
virtual void	createPeriodicParticles (ParticleHandler &pH) override
	Checks distance of particle to closer edge and creates a periodic copy if necessary. More...
void	createGhostParticle (BaseParticle *pReal)
	Creates and adds a ghost particle from a given real particle. More...
void	createPeriodicParticle (BaseParticle *p, ParticleHandler &pH) override
	Creates a single periodic particle if required from a given particle. More...
MERCURYDPM_DEPRECATED void	oldRead (std::istream &is)
	deprecated version of CubeInsertionBoundary::read(). More...
Public Member Functions inherited from BasePeriodicBoundary
	BasePeriodicBoundary ()
	default constructor. More...
	BasePeriodicBoundary (const BasePeriodicBoundary &b)
	copy constructor More...
	~BasePeriodicBoundary () override
	destructor More...
void	setPeriodicHandler (PeriodicBoundaryHandler *periodicHandler)
	Sets the periodicBoundaryHandler, required for parallel periodic boundaries. More...
PeriodicBoundaryHandler *	getPeriodicHandler () const
	Returns the periodic boundary handler. More...
void	createPeriodicParticles (ParticleHandler &pH) override
	Creates periodic ocpies of given particle in case of periodic boundaries in serial build. More...
Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...
	BaseBoundary (const BaseBoundary &b)
	copy constructor More...
	~BaseBoundary () override
	destructor More...
virtual void	createPeriodicParticle (BaseParticle *p UNUSED, ParticleHandler &pH UNUSED)
	Creates a periodic particle in case of periodic boundaries in serial build. More...
virtual void	createPeriodicParticles (ParticleHandler &pH UNUSED)
	Creates periodic copies of given particle in case of periodic boundaries. More...
virtual void	checkBoundaryBeforeTimeStep (DPMBase *md)
	Virtual function that does things before each time step. More...
virtual void	writeVTK (std::fstream &file)
void	setHandler (BoundaryHandler *handler)
	Sets the boundary's BoundaryHandler. More...
BoundaryHandler *	getHandler () const
	Returns the boundary's BoundaryHandler. More...
Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...
	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...
virtual	~BaseObject ()=default
	virtual destructor More...
virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...
void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...
void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...
unsigned int	getIndex () const
	Returns the index of the object in the handler. More...
unsigned int	getId () const
	Returns the unique identifier of any particular object. More...
void	setGroupId (unsigned groupId)
unsigned	getGroupId () const

Private Attributes
bool	maserIsActivated_
	Flag whether or not the gap is created and particles transformed already. More...
Mdouble	activationTime_
	Time at which the maser opens. More...
bool	copyFlowParticles_
	Flag for whether or not we copy a few blocks of flow particles in the front when activating the maser. More...

Additional Inherited Members
Protected Attributes inherited from PeriodicBoundary
Vec3D	normal_
	outward unit normal vector for right edge More...
Mdouble	distanceLeft_
	position of left edge, s.t. normal*x = distanceLeft_ More...
Mdouble	distanceRight_
	position of right edge, s.t. normal*x = distanceRight_ More...
Mdouble	scaleFactor_
	This is the normal to rescale the normal vector to a unit vectors. More...
Vec3D	shift_
	shift from left to right boundary More...

Constructor & Destructor Documentation

SubcriticalMaserBoundaryTEST()

SubcriticalMaserBoundaryTEST::SubcriticalMaserBoundaryTEST

(

)

MaserBoundary constructor.

MaserBoundary constructor, sets all scalars to non-sensible values.

{
    distanceLeft_ = std::numeric_limits<Mdouble>::quiet_NaN();
    distanceRight_ = std::numeric_limits<Mdouble>::quiet_NaN();
    maserIsActivated_ = false;
    activationTime_ = std::numeric_limits<Mdouble>::quiet_NaN();
    copyFlowParticles_ = false;
}

References activationTime_, copyFlowParticles_, PeriodicBoundary::distanceLeft_, PeriodicBoundary::distanceRight_, and maserIsActivated_.

Referenced by copy().

~SubcriticalMaserBoundaryTEST()

SubcriticalMaserBoundaryTEST::~SubcriticalMaserBoundaryTEST ( )

override

destructor

destructor

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

References DEBUG, and logger.

Member Function Documentation

actionsBeforeTimeLoop()

void SubcriticalMaserBoundaryTEST::actionsBeforeTimeLoop ( )

overridevirtual

Helper function to make sure that the particles are maser particles after restarting.

Reimplemented from BaseBoundary.

{
    if (maserIsActivated_)
    {
        for (BaseParticle* p : getHandler()->getDPMBase()->particleHandler)
        {
            if (getDistance(p->getPosition()) > 0)
            {
                p->setMaserParticle(true);
            }
        }
    }
}

References getDistance(), BaseBoundary::getHandler(), and maserIsActivated_.

activateMaser()

void SubcriticalMaserBoundaryTEST::activateMaser

(

)

Activates the maser functionaly of this periodic boundary.

Activates the maser boundary by flagging all particles within as isMaserParticles. These maser particle will generate real particles at the right side of the maser.

{
    logger(INFO, "SubcriticalMaserBoundaryTEST::activateMaser ");
#ifdef MERCURYDPM_USE_MPI
    //Clear the periodic boundaryHandler, only want real particles
    getPeriodicHandler()->clearCommunicationLists();
#endif
    //Flag that the maser is active!
    maserIsActivated_ = true;
    
    extendBottom();
    if (copyFlowParticles_)
    {
        copyExtraParticles();
    }
    
    //Loop over all particles to see if they are within the maser boundary
    ParticleHandler& pH = getHandler()->getDPMBase()->particleHandler;
    for (BaseParticle* particle : pH)
    {
        particle->setMaserParticle((getDistance(particle->getPosition()) > 0));
    }
 
#ifdef MERCURYDPM_USE_MPI
    //Generate ghost particles
    getPeriodicHandler()->addNewParticles();
#endif
 
}

References PeriodicBoundaryHandler::addNewParticles(), PeriodicBoundaryHandler::clearCommunicationLists(), copyExtraParticles(), copyFlowParticles_, extendBottom(), getDistance(), BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BasePeriodicBoundary::getPeriodicHandler(), INFO, logger, maserIsActivated_, and DPMBase::particleHandler.

Referenced by checkBoundaryAfterParticlesMove(), and performActionsBeforeAddingParticles().

checkBoundaryAfterParticleMoved()

bool SubcriticalMaserBoundaryTEST::checkBoundaryAfterParticleMoved	(	BaseParticle *	p,
		ParticleHandler &	pH
	)		const

Shifts the particle to its 'periodic' position if it is a maser particle and has crossed either of the walls. Creates a 'normal' particle at its current position if it is a maser particle which crossed the RIGHT boundary wall.

Checks whether a given particle (a) is in the Maser and (b) has crossed the closest wall. If so, shifts its position so as to have it appear at the other wall, and creates a 'real' equivalent in the outflow domain.

Parameters

[in]	p	The particle to be checked and possibly shifted and copied
	pH	The ParticleHandler, which is unused in this implementation

Returns

Returns true if particle p has interacted with the boundary, false otherwise

{
    // check if particle passed either of the boundary walls
    if (maserIsActivated_)
    {
        if (p->isMaserParticle() && (getDistanceFromRight(p->getPosition()) < 0))
        {
            //Do the maser stuff
            BaseParticle* pCopy = p->copy();
            pCopy->setMaserParticle(false);
            pH.addObject(pCopy);
            /*
            logger(INFO, "copying particle");
            p->write(std::cout);
            */
            logger(VERBOSE, "copying particle %", p);
            //Shift position of the particle
            shiftPosition(p);
        }
    }
    else
    {
        //note, if we already made a rough bottom on beforehand, we do not want the bottom particles to be eaten up,
        //that is, all shifted inside the domain.
        if (getDistance(p->getPosition()) < 0)
        {
            shiftPosition(p);
        }
    }
    
    return false;
}

References ParticleHandler::addObject(), BaseParticle::copy(), getDistance(), getDistanceFromRight(), BaseInteractable::getPosition(), BaseParticle::isMaserParticle(), logger, maserIsActivated_, BaseParticle::setMaserParticle(), PeriodicBoundary::shiftPosition(), and VERBOSE.

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void SubcriticalMaserBoundaryTEST::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

Evaluates what the particles have to do after they have changed position.

After particles have moved, check if the maser needs to be update or not. This function also updates the particles in the particleHandler based on their new position

Parameters

[in]

pH

The particle handler, is used to loop over all particles to flag maser particles

Reimplemented from PeriodicBoundary.

{
#ifdef MERCURYDPM_USE_MPI
    if (NUMBER_OF_PROCESSORS == 1)
    {
#endif
    //Activate the maser at the given time
    if (getHandler()->getDPMBase()->getTime() > activationTime_)
    {
        if (!maserIsActivated_)
        {
            logger(INFO, "Activating the maser at time: %", activationTime_);
            activateMaser();
        }
    }
    
    //Update particles
    for (BaseParticle* p : pH)
    {
        checkBoundaryAfterParticleMoved(p, pH);
    }
#ifdef MERCURYDPM_USE_MPI
    }
 
#endif
}

References activateMaser(), activationTime_, checkBoundaryAfterParticleMoved(), BaseBoundary::getHandler(), INFO, logger, maserIsActivated_, and NUMBER_OF_PROCESSORS.

copy()

SubcriticalMaserBoundaryTEST * SubcriticalMaserBoundaryTEST::copy ( ) const

overridevirtual

Creates a copy of this maser on the heap.

Copy method, creates a copy of the object on the heap and returns a pointer to it.

Returns

pointer to the copy

Reimplemented from PeriodicBoundary.

{
    return new SubcriticalMaserBoundaryTEST(*this);
}

References SubcriticalMaserBoundaryTEST().

copyExtraParticles()

void SubcriticalMaserBoundaryTEST::copyExtraParticles

(

)

const

when activating the maser, extend the bottom periodically until the end of the domain, by copying the fixed particles of the periodic part of the maser with intervals of shift_.

{
    logger(INFO, "copying flow particles");
#ifdef MERCURYDPM_USE_MPI
    MPIContainer& communicator = MPIContainer::Instance();
    std::vector<unsigned int> numberOfParticlesPerCore(NUMBER_OF_PROCESSORS);
    std::vector<std::vector<BaseParticle*>> particlesToCores(NUMBER_OF_PROCESSORS);
    if (PROCESSOR_ID == 0)
    {
#endif
    std::vector<BaseParticle*> flowParticles;
    std::vector<BaseParticle*> newParticles;
    for (BaseParticle* p : getHandler()->getDPMBase()->particleHandler)
    {
        if (!p->isFixed() && !(p->isPeriodicGhostParticle()) && !(p->isMPIParticle()))
        {
            flowParticles.push_back(p);
        }
    }
    
    for (BaseParticle* p : flowParticles)
    {
        Vec3D newPosition = p->getPosition() + shift_;
        for (unsigned i = 0; i < 4; ++i)
        {
            p = p->copy();
            p->setPosition(newPosition);
            newParticles.push_back(p);
            newPosition += shift_;
        }
    }
#ifndef MERCURYDPM_USE_MPI
    for (BaseParticle* p : newParticles)
    {
        getHandler()->getDPMBase()->particleHandler.addObject(p);
    }
#else
    if (NUMBER_OF_PROCESSORS == 1)
    {
        for (BaseParticle* p : newParticles)
        {
            getHandler()->getDPMBase()->particleHandler.addObject(p);
        }
    }
    else
    {
        //count how many particles go to each core
        for (BaseParticle* p : newParticles)
        {
            int targetGlobalIndex = getHandler()->getDPMBase()->domainHandler.getParticleDomainGlobalIndex(p);
            int targetProcessor = getHandler()->getDPMBase()->domainHandler.getParticleProcessor(
                    targetGlobalIndex);
            particlesToCores[targetProcessor].push_back(p);
        }
        for (int i = 0; i < NUMBER_OF_PROCESSORS; ++i)
        {
            numberOfParticlesPerCore[i] = (particlesToCores[i].size());
        }
    }
}
if (NUMBER_OF_PROCESSORS > 1)
{
    //broadcast numberOfParticlesPerCore to other processors
    communicator.broadcast(numberOfParticlesPerCore.data(), NUMBER_OF_PROCESSORS, 0);
    for (unsigned i = 0; i < numberOfParticlesPerCore.size(); ++i)
    {
        for (unsigned p = 0; p < numberOfParticlesPerCore[i]; ++p)
        {
            BaseParticle* particle;
            if (PROCESSOR_ID == 0)
            {
                particle = particlesToCores[i][p];
            }
            else
            {
                particle = new SphericalParticle();
            }
 
            getHandler()->getDPMBase()->particleHandler.addObject(0, particle);
            //particle->setPeriodicComplexity(getPeriodicHandler()->computePeriodicComplexity(particle->getPosition()));
        }
    }
}
#endif
    
    logger(INFO, "completed copying particles");
}

References ParticleHandler::addObject(), MPIContainer::broadcast(), DPMBase::domainHandler, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DomainHandler::getParticleDomainGlobalIndex(), DomainHandler::getParticleProcessor(), constants::i, INFO, MPIContainer::Instance(), logger, NUMBER_OF_PROCESSORS, DPMBase::particleHandler, PROCESSOR_ID, and PeriodicBoundary::shift_.

Referenced by activateMaser().

createPeriodicParticle()

void SubcriticalMaserBoundaryTEST::createPeriodicParticle ( BaseParticle *  p, ParticleHandler &  pH  )

override

Creates periodic particles when the particle is a maser particle and is sufficiently close to one of the boundary walls.

If the maser is active only maser particles can create a ghost of they are close to the right boundary. If this is the case a ghost will be created and added to the particleHandler at the appropriate position. If the maser is not active then this acts as a normal periodic boundary and so the left boundary is also allowed to create ghosts.

Parameters

[in]	p	Particle to be checked and possibly periodically copied
[in,out]	pH	System's ParticleHandler, (1) from which the interaction radius of its largest particle is retrieved to determine the maximum distance from the wall at which a particle should still have a periodic copy created, and (2) to which a possible periodic copy of the particle will be added

Todo:

why 2.0?

{
    const Mdouble proximityDistance = p->getMaxInteractionRadius() + 2.0* pH.getLargestParticle()->getMaxInteractionRadius();
    if (maserIsActivated_)
    {
        if (p->isMaserParticle())
        {
            //Only if the particle is close to the right wall a ghost can be generated
            if (getDistanceFromRight(p->getPosition()) < proximityDistance)
            {
                createGhostParticle(p);
            }
        }
    }
    else
    {
        //If a particle is at any wall, the ghost can be generated
        if (getDistance(p->getPosition()) < proximityDistance)
        {
            createGhostParticle(p);
        }
    }
}

References PeriodicBoundary::createGhostParticle(), getDistance(), getDistanceFromRight(), ParticleHandler::getLargestParticle(), BaseParticle::getMaxInteractionRadius(), BaseInteractable::getPosition(), BaseParticle::isMaserParticle(), and maserIsActivated_.

deactivateMaser()

void SubcriticalMaserBoundaryTEST::deactivateMaser

(

)

Stops copying particles, and act merely as a periodic domain.

{
    if (maserIsActivated_)
    {
        for (BaseParticle* particle : getHandler()->getDPMBase()->particleHandler)
        {
            if (getDistance(particle->getPosition()) > 0)
            {
                particle->setMaserParticle(false);
            }
        }
 
        maserIsActivated_ = false;
 
 
        // TODO JMFT: @Marnix In activateMaser(), what do extendBottom() and
        // addNewParticles() do, and how do I undo their effects?
    }
    else
        logger(WARN, "[SubcriticalMaserBoundaryTEST::deactivateMaser()] Maser is not activated, so can't deactivate");
}

References getDistance(), BaseBoundary::getHandler(), logger, maserIsActivated_, and WARN.

extendBottom()

void SubcriticalMaserBoundaryTEST::extendBottom

(

)

const

when activating the maser, extend the bottom periodically until the end of the domain, by copying the fixed particles of the periodic part of the maser with intervals of shift_.

{
    logger(INFO, "extending bottom");
#ifdef MERCURYDPM_USE_MPI
    MPIContainer& communicator = MPIContainer::Instance();
    std::vector<unsigned int> numberOfParticlesPerCore(NUMBER_OF_PROCESSORS);
    std::vector<std::vector<BaseParticle*>> particlesToCores(NUMBER_OF_PROCESSORS);
    if (PROCESSOR_ID == 0)
    {
#endif
    std::vector<BaseParticle*> fixedParticles;
    std::vector<BaseParticle*> newParticles;
    for (BaseParticle* p : getHandler()->getDPMBase()->particleHandler)
    {
        if (p->isFixed() && !(p->isPeriodicGhostParticle()) && !(p->isMPIParticle()))
        {
            fixedParticles.push_back(p);
        }
    }
    
    for (BaseParticle* p : fixedParticles)
    {
        Vec3D newPosition = p->getPosition() + shift_;
        Vec3D maxDomain = getHandler()->getDPMBase()->getMax();
        Vec3D minDomain = getHandler()->getDPMBase()->getMin();
        while (newPosition.X < maxDomain.X && newPosition.Y < maxDomain.Y && newPosition.Z < maxDomain.Z
               && newPosition.X > minDomain.X && newPosition.Y > minDomain.Y && newPosition.Z > minDomain.Z)
        {
            p = p->copy();
            p->setPosition(newPosition);
            newParticles.push_back(p);
            newPosition += shift_;
        }
    }
#ifndef MERCURYDPM_USE_MPI
    for (BaseParticle* p : newParticles)
    {
        getHandler()->getDPMBase()->particleHandler.addObject(p);
    }
#else
    if (NUMBER_OF_PROCESSORS == 1)
    {
        for (BaseParticle* p : newParticles)
        {
            getHandler()->getDPMBase()->particleHandler.addObject(p);
        }
    }
    else
    {
        //count how many particles go to each core
        for (BaseParticle* p : newParticles)
        {
            int targetGlobalIndex = getHandler()->getDPMBase()->domainHandler.getParticleDomainGlobalIndex(p);
            int targetProcessor = getHandler()->getDPMBase()->domainHandler.getParticleProcessor(
                    targetGlobalIndex);
            particlesToCores[targetProcessor].push_back(p);
        }
        for (int i = 0; i < NUMBER_OF_PROCESSORS; ++i)
        {
            numberOfParticlesPerCore[i] = (particlesToCores[i].size());
        }
    }
}
if (NUMBER_OF_PROCESSORS > 1)
{
    //broadcast numberOfParticlesPerCore to other processors
    communicator.broadcast(numberOfParticlesPerCore.data(), NUMBER_OF_PROCESSORS, 0);
    for (unsigned i = 0; i < numberOfParticlesPerCore.size(); ++i)
    {
        for (unsigned p = 0; p < numberOfParticlesPerCore[i]; ++p)
        {
            BaseParticle* particle;
            if (PROCESSOR_ID == 0)
            {
                particle = particlesToCores[i][p];
            }
            else
            {
                particle = new SphericalParticle();
            }
 
            getHandler()->getDPMBase()->particleHandler.addObject(0, particle);
        }
    }
}
#endif
}

References ParticleHandler::addObject(), MPIContainer::broadcast(), DPMBase::domainHandler, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), DPMBase::getMax(), DPMBase::getMin(), DomainHandler::getParticleDomainGlobalIndex(), DomainHandler::getParticleProcessor(), constants::i, INFO, MPIContainer::Instance(), logger, NUMBER_OF_PROCESSORS, DPMBase::particleHandler, PROCESSOR_ID, PeriodicBoundary::shift_, Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by activateMaser().

getDistance()

Mdouble SubcriticalMaserBoundaryTEST::getDistance ( const Vec3D &  position ) const

overridevirtual

gets the distance to the closest wall if maser is inactive, otherwise distance to right wall

getDistance is used in a periodic boundary to measure the distance from a certain position to the periodic boundary that actually mirrors are particle. For a maser boundary, if the boundary is active, this is only the right boundary and hence the generic getDistance function is overwritten with getDistanceFromRight()

Parameters

[in]

position

The position of which we want to know the distance towards the nearest active boundary

Reimplemented from PeriodicBoundary.

{
    if (maserIsActivated_)
    {
        return getDistanceFromRight(position);
    }
    else
    {
        return PeriodicBoundary::getDistance(position);
    }
}

References PeriodicBoundary::getDistance(), getDistanceFromRight(), and maserIsActivated_.

Referenced by actionsBeforeTimeLoop(), activateMaser(), checkBoundaryAfterParticleMoved(), createPeriodicParticle(), and deactivateMaser().

getDistanceFromRight()

Mdouble SubcriticalMaserBoundaryTEST::getDistanceFromRight

(

const Vec3D &

position

)

const

returns the distance to the right wall

The maser only requires particles at the right boundary to create ghosts therefore the distance towards the right boundary is an important quantity to compute.

Parameters

[in]

Position

from which the distance to the right wall is computd

{
    Mdouble distanceFromPlaneThroughOrigin = Vec3D::dot(position, normal_);
    return distanceRight_ - distanceFromPlaneThroughOrigin;
}

References PeriodicBoundary::distanceRight_, Vec3D::dot(), and PeriodicBoundary::normal_.

Referenced by checkBoundaryAfterParticleMoved(), createPeriodicParticle(), getDistance(), and modifyPeriodicComplexity().

getName()

std::string SubcriticalMaserBoundaryTEST::getName ( ) const

overridevirtual

Returns the name of the object.

Returns the name of the object class

Returns

the object's class' name, i.e. 'SubcriticalMaserBoundaryTEST'

Reimplemented from PeriodicBoundary.

{
    return "SubcriticalMaserBoundaryTEST";
}

isActivated()

bool SubcriticalMaserBoundaryTEST::isActivated

(

)

const

Returns whether the maser is activated or not.

{
    return maserIsActivated_; 
}

References maserIsActivated_.

modifyGhostAfterCreation()

void SubcriticalMaserBoundaryTEST::modifyGhostAfterCreation ( BaseParticle *  particle, int  i  )

overridevirtual

Reimplemented from BaseBoundary.

{
    if (maserIsActivated_)
    {
        if (!particle->isMaserParticle())
        {
            std::vector<int> periodicComplexity = particle->getPeriodicComplexity();
            periodicComplexity[i] = 3;
            particle->setPeriodicComplexity(periodicComplexity);
        }
    }
}

References BaseParticle::getPeriodicComplexity(), constants::i, BaseParticle::isMaserParticle(), maserIsActivated_, and BaseParticle::setPeriodicComplexity().

modifyPeriodicComplexity()

void SubcriticalMaserBoundaryTEST::modifyPeriodicComplexity ( std::vector< int > &  complexity, int &  totalPeriodicComplexity, BaseParticle *  particle, int  i  ) const

overridevirtual

modifies the periodic complexity to support a maser boundary

In the parallel periodic boundary, everything is computed by the periodic complexity of a particle. Generally it is not possible to be a real particle outside a periodic boundary, but in case of a maser this is definetly possible. To accomodate this the periodic complexity needs to be modified such that this particle remains to be marked as a real particle. When the distance from the maser boundary is negative we give the flag 3 of the periodic complexity to mark that this is actually a real particle outside the maser boundary

Parameters

[in,out]	complexity	The periodic complexity, indicates how a position/particle is related to periodioc boundaries
[in]	position	The position of the given periodic complexity
[in]	The	index in the complexity vector that this boundary corresponds to

Reimplemented from BasePeriodicBoundary.

{
    if (maserIsActivated_)
    {
        if (particle->isMaserParticle())
        {
            //Check if this particle is flagged periodic in this boundary
            if (complexity[i] < 0)
            {
                //Make sure that only a ghost close to the right boundary is flagged as real in this boundary
                if (getDistanceFromRight(particle->getPosition()) < 0)
                {
                    complexity[i] = 3;
                }
                
            }
            if (complexity[i] == -3)
            {
                logger(INFO, "Something went wrong in SubcriticalMaserBoundaryTEST::modifyPeriodicComplexity, "
                             "complexity[%] = -3", i);
            }
        }
        else
        {
            if (complexity[i] == 1)
            {
                totalPeriodicComplexity--;
            }
            complexity[i] = 3;
        }
    }
}

References getDistanceFromRight(), BaseInteractable::getPosition(), constants::i, INFO, BaseParticle::isMaserParticle(), logger, and maserIsActivated_.

performActionsBeforeAddingParticles()

void SubcriticalMaserBoundaryTEST::performActionsBeforeAddingParticles ( )

overridevirtual

Checks before adding particles if the maser needs to be activated.

Before adding particles a check is made to see if the maser needs to be activated or not This check is based on the give activation time, if not set by default it is NaN and the maser will never be activated

Reimplemented from BasePeriodicBoundary.

{
    //Activate the maser at the given time
    if (getHandler()->getDPMBase()->getTime() > activationTime_)
    {
        if (!maserIsActivated_)
        {
            logger(INFO, "Activating the maser at time: %", activationTime_);
            activateMaser();
        }
    }
}

References activateMaser(), activationTime_, BaseBoundary::getHandler(), INFO, logger, and maserIsActivated_.

read()

void SubcriticalMaserBoundaryTEST::read ( std::istream &  is )

overridevirtual

reads boundary properties from istream

Reads the boundary properties from an istream

Parameters

[in,out]

is

the istream from which the boundary must be read

Reimplemented from PeriodicBoundary.

{
    PeriodicBoundary::read(is);
    std::string dummy;
    is >> dummy >> maserIsActivated_
       >> dummy >> activationTime_;
    logger(INFO, "maser is activated: %", maserIsActivated_);
}

References activationTime_, INFO, logger, maserIsActivated_, and PeriodicBoundary::read().

setActivationTime()

void SubcriticalMaserBoundaryTEST::setActivationTime

(

Mdouble

time

)

sets the activate time of the maser

The maser is disabled by default and has to be activated. The activation can be done by setting the activation time.

Parameters

[in]

time

The time at which the maser needs to be activated

{
    activationTime_ = time;
}

References activationTime_.

Referenced by MaserRepeatedOutInMPI2Test::setupInitialConditions(), and MpiMaserChuteTest::setupInitialConditions().

setCopyFlowParticles()

void SubcriticalMaserBoundaryTEST::setCopyFlowParticles

(

bool

copyFlowParticles

)

{
    copyFlowParticles_ = copyFlowParticles;
}

References copyFlowParticles_.

write()

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

overridevirtual

writes boundary properties to ostream

Writes boundary's properties to an ostream

Parameters

[in]

os

the ostream to which the boundary must be written

Reimplemented from PeriodicBoundary.

{
    PeriodicBoundary::write(os);
    os << " maserIsActivated " << maserIsActivated_
       << " activationTime " << activationTime_;
}

References activationTime_, maserIsActivated_, and PeriodicBoundary::write().

Member Data Documentation

activationTime_

Mdouble SubcriticalMaserBoundaryTEST::activationTime_

private

Time at which the maser opens.

Referenced by checkBoundaryAfterParticlesMove(), performActionsBeforeAddingParticles(), read(), setActivationTime(), SubcriticalMaserBoundaryTEST(), and write().

copyFlowParticles_

bool SubcriticalMaserBoundaryTEST::copyFlowParticles_

private

Flag for whether or not we copy a few blocks of flow particles in the front when activating the maser.

Referenced by activateMaser(), setCopyFlowParticles(), and SubcriticalMaserBoundaryTEST().

maserIsActivated_

bool SubcriticalMaserBoundaryTEST::maserIsActivated_

private

Flag whether or not the gap is created and particles transformed already.

Referenced by actionsBeforeTimeLoop(), activateMaser(), checkBoundaryAfterParticleMoved(), checkBoundaryAfterParticlesMove(), createPeriodicParticle(), deactivateMaser(), getDistance(), isActivated(), modifyGhostAfterCreation(), modifyPeriodicComplexity(), performActionsBeforeAddingParticles(), read(), SubcriticalMaserBoundaryTEST(), and write().

---

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

• SubcriticalMaserBoundaryTEST.h
• SubcriticalMaserBoundaryTEST.cc