ConstantMassFlowMaserBoundary Class Reference

Variation on the PeriodicBoundary which also has an outflow part. More...

#include <ConstantMassFlowMaserBoundary.h>

Inheritance diagram for ConstantMassFlowMaserBoundary:

Public Member Functions
	ConstantMassFlowMaserBoundary ()
	MaserBoundary constructor. More...
	ConstantMassFlowMaserBoundary (const PeriodicBoundary &periodicBoundary)
	Maserboundary constructor that takes a periodic boundary, and converts it to a maser boundary. More...
ConstantMassFlowMaserBoundary *	copy () const override
	Creates a copy of this maser on the heap. More...
void	set (Vec3D normal, Vec3D planewiseShift, Mdouble distanceLeft, Mdouble distanceRight)
	Sets all boundary properties at once and adds particles of the handler to the maser. This deactivates the Maser. More...
void	set (Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight)
	Sets the Maser's normal and positions, and sets the planewise shift to zero. This deactivates the Maser. More...
void	setPlanewiseShift (Vec3D planewiseShift)
	Sets a planewise direction to the shift. Doesn't change the normal or the positions. More...
void	setShift (Vec3D shift)
	Sets the shift of the Maser. Usually don't use this directly, use set() or setPlanewiseShift() instead. 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	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...
void	createPeriodicParticles (ParticleHandler &pH) override
bool	checkBoundaryAfterParticleMoved (BaseParticle *p, ParticleHandler &pH)
	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	addParticleToMaser (BaseParticle *p)
	Converts a 'normal' particle into a maser particle. More...
void	removeParticleFromMaser (BaseParticle *p)
	Convert a maser particle into a 'normal' particle. More...
bool	isMaserParticle (BaseParticle *p) const
	Returns true if the particle is a Maser particle, and false otherwise. More...
bool	isNormalParticle (BaseParticle *p) const
	Returns true if the particle is a Normal particle, and false otherwise. More...
void	actionsBeforeTimeLoop () override
	Does everything that needs to be done for this boundary between setupInitialConditions and the time loop, in this case, it activates the maser. More...
void	activateMaser ()
	Opens the gap, and transforms particles to maser particles. Also calls turnOnCopying(). More...
void	closeMaser ()
	Stops copying particles (and act merely as a chute) More...
bool	isActivated () const
	Returns whether the Maser is activated or not. More...
void	turnOnCopying ()
	Start copying particles. More...
void	turnOffCopying ()
	Stop copying particles. More...
bool	isCopying () const
	Returns whether the Maser is copying particles or not. More...
Mdouble	getDistanceLeft () const
Mdouble	getDistanceRight () const
Mdouble	getGapSize () const
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	modifyGhostAfterCreation (BaseParticle *particle, int i)
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 Member Functions
void	shiftPosition (BaseParticle *p) const
	Shifts the particle to its 'periodic' position. More...
BaseParticle *	createGhostCopy (BaseParticle *p) const
	Creates a copy of the input particle, that gets removed again in DPMBase::removeDuplicatePeriodicParticles. More...
bool	isClosestToRightBoundary (const BaseParticle *const p) const
	Returns whether the given particle is closer to the right boundary of the periodic part. More...
Mdouble	getDistance (BaseParticle *p) const
	Returns the distance of the wall to the particle. More...

Private Attributes
Vec3D	normal_
	Normal unit vector of both maser walls. Points in the flowing direction. More...
Mdouble	distanceLeft_
	position of left boundary wall, s.t. normal*x=position_left More...
Mdouble	distanceRight_
	position of right boundary wall, s.t. normal*x=position_right More...
Mdouble	gapSize_
	distance between the right side of the periodic domain and the start of the outflow domain. More...
Vec3D	shift_
	Direction in which particles are to be shifted when they cross the boundary. More...
std::map< const ParticleSpecies *, const ParticleSpecies * >	speciesConversionNormalToMaser_
	List of 'normal' particles' species, and their maser counterparts. More...
std::map< const ParticleSpecies *, const ParticleSpecies * >	speciesConversionMaserToNormal_
	List of 'maser' particles' species, and their normal counterparts. More...
bool	maserIsActivated_
	Flag whether or not the gap is created and particles transformed already. More...
bool	maserIsCopying_
	Flag whether or not the Maser is copying particles. More...

Detailed Description

Variation on the PeriodicBoundary which also has an outflow part.

Creates a boundary which divides the domain into two parts: a periodic domain and an outflow domain, with a gap inbetween. Any particle flowing through the right of the periodic domain is moved to both the left side of the periodic domain (as with a PeriodicBoundary), and also copied the left side of the outflow domain. Furthermore, the particles near the right side of the periodic domain also exert forces on the left side of the outflow domain as if there were no gap. However, the outflow domain has no influence on the periodic domain. When an outflow particle tries to enter the gap between the periodic domain and the outflow domain, it gets removed.

There are two distinct properties of the state of the Maser. ‘Activated’ or ‘closed’ refer to whether the particles within the Maser have been set to the Maser species and whether they have been moved by the gapSize. Particles will be affected by the Maser (i.e. moved periodically) iff the Maser is activated. On the other hand, ‘copying’ refers to whether new particles are being produced by the Maser. Thus, a Maser that is activated but not copying behaves just as a periodic boundary.

By default, activateMaser() also turns on copying. And when a Maser is closed, the value of isCopying() is irrelevant, although it is set to false for housekeeping.

Todo:

Add functionality which allows for opening the maser boundary after a certain time, being a normal periodic boundary until then

Consider writing a destructor that closes the gap again

Consider splitting it in 2 DPMBase instances, one for the periodic domain and one for the outflow domain

Consider re-using the PeriodicBoundary by adding it as a data member

The difference between SubcriticalMaserBoundary (formerly known as MaserBoundaryOldStyle) and ConstantMassFlowMaserBoundary (formerly known simply as MaserBoundary) is that in ConstantMassFlowMaserBoundary, the left hand side of the periodic box does not have any influence on the rest of the flow, but the right side of the periodic box and the left side of the outflow domain interact. The ConstantMassFlowMaserBoundary is most useful for fast (supercritical) flows, and for flows for which the flux across the boundary needs to be controlled. The SubcriticalMaserBoundary is more useful for slow flows, as the ConstantMassFlowMaserBoundary might generate "pulse-waves" in those cases.

For a compact overview of the behaviour of ConstantMassFlowMaserBoundary, please look at the output of ConstantMassFlowMaserSelfTest.

Todo:

Which Maser is it used in Denissen2019? To cite the Maser: I. F. C. Denissen, T. Weinhart, A. Te Voortwis, S. Luding, J. M. N. T. Gray and A. R. Thornton, Bulbous head formation in bidisperse shallow granular flow over an inclined plane. Journal of Fluid Mechanics, 866:263–297, mar 2019.

Constructor & Destructor Documentation

ConstantMassFlowMaserBoundary() [1/2]

ConstantMassFlowMaserBoundary::ConstantMassFlowMaserBoundary

(

)

MaserBoundary constructor.

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

{
#ifdef MERCURYDPM_USE_MPI
    logger(WARN,"Make sure the whole maser boundary is on one processor when using parallel code");
#endif
    distanceLeft_ = std::numeric_limits<double>::quiet_NaN();
    distanceRight_ = std::numeric_limits<double>::quiet_NaN();
    gapSize_ = std::numeric_limits<double>::quiet_NaN();
    maserIsActivated_ = false;
}

References distanceLeft_, distanceRight_, gapSize_, logger, maserIsActivated_, and WARN.

Referenced by copy().

ConstantMassFlowMaserBoundary() [2/2]

ConstantMassFlowMaserBoundary::ConstantMassFlowMaserBoundary ( const PeriodicBoundary &  periodicBoundary )

explicit

Maserboundary constructor that takes a periodic boundary, and converts it to a maser boundary.

MaserBoundary constructor from a periodic boundary. It copies the properties of the periodic boundary, and then immediately opens the maser. Do not insert particles for the maser after this constructor.

Parameters

[in]

periodicBoundary

The periodic boundary on which this maser boundary is based.

                                                                                                     : BaseBoundary(
        periodicBoundary)
{
    logger(INFO, "Constructor ConstantMassFlowMaserBoundary(const PeriodicBoundary&) started\n", Flusher::NO_FLUSH);
    distanceLeft_ = periodicBoundary.getDistanceLeft();
    distanceRight_ = periodicBoundary.getDistanceRight();
    normal_ = periodicBoundary.getNormal();
    shift_ = periodicBoundary.getShift();
    gapSize_ = std::numeric_limits<double>::quiet_NaN();
    maserIsActivated_ = false;
    
    logger(INFO, "going to activate the maser");
    //assume that the maser should be activated immediately when it gets constructed from a periodic boundary
    activateMaser();
}

References activateMaser(), distanceLeft_, distanceRight_, gapSize_, PeriodicBoundary::getDistanceLeft(), PeriodicBoundary::getDistanceRight(), PeriodicBoundary::getNormal(), PeriodicBoundary::getShift(), INFO, logger, maserIsActivated_, NO_FLUSH, normal_, and shift_.

Member Function Documentation

actionsBeforeTimeLoop()

void ConstantMassFlowMaserBoundary::actionsBeforeTimeLoop ( )

overridevirtual

Does everything that needs to be done for this boundary between setupInitialConditions and the time loop, in this case, it activates the maser.

The maser boundary should be activated before the time loop starts, but after all particles are added.

Reimplemented from BaseBoundary.

{
    activateMaser();
}

References activateMaser().

activateMaser()

void ConstantMassFlowMaserBoundary::activateMaser

(

)

Opens the gap, and transforms particles to maser particles. Also calls turnOnCopying().

Activate the maser by creating a gap betweeen the periodic domain and the outflow domain, and transforming all the particles in the domain to maser particles. For an explanation of the magic number 6, see the detailed documentation for gapSize_. Note that gapSize_ is set here and not in set, since it is possible that the user first adds boundaries to the domain before the particles. The maser boundary should only be activated after all particles are in.

Todo:

JMFT: Would it be helpful to be able to set a custom gapSize ?

{
    if (!maserIsActivated_)
    {
        logger(INFO, "Going to add particles to the maser and shift the periodic maser boundaries\n",
               Flusher::NO_FLUSH);
        ParticleHandler& pH = getHandler()->getDPMBase()->particleHandler;
        gapSize_ = 6 * pH.getLargestParticleLocal()->getRadius();
        logger(INFO, "just before particle loop");
        for (BaseParticle* const p: pH)
        {
            if (getDistance(p) > 0)
            {
                addParticleToMaser(p);
            }
        }
        
        
        distanceLeft_ -= gapSize_;
        distanceRight_ -= gapSize_;
        maserIsActivated_ = true;
 
        turnOnCopying();
 
        logger(INFO, "The Maser has been activated, and is now copying particles.");
    }
    else
    {
        logger(WARN, "Cannot activate the maser boundary twice!");
    }
}

References addParticleToMaser(), distanceLeft_, distanceRight_, gapSize_, getDistance(), BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), ParticleHandler::getLargestParticleLocal(), BaseParticle::getRadius(), INFO, logger, maserIsActivated_, NO_FLUSH, p, DPMBase::particleHandler, turnOnCopying(), and WARN.

Referenced by actionsBeforeTimeLoop(), and ConstantMassFlowMaserBoundary().

addParticleToMaser()

void ConstantMassFlowMaserBoundary::addParticleToMaser

(

BaseParticle *

p

)

Converts a 'normal' particle into a maser particle.

Turns given particle into a 'maser particle' by changing its species into a 'maser particle' copy species. If the particle species is not yet in the std::map speciesConversionNormalToMaser_, it and its maser copy species are added. This function should be called at the beginning of the simulation, right after actually filling the maser with particles, flagging each particle as one belonging to the maser.

Parameters

[in,out]

p

The particle which is added to the maser. Its species is 'changed' to the maser copy species.

{
    // check if particle species already known by the maser
    auto conversion = speciesConversionNormalToMaser_.find(p->getSpecies());
    if (conversion != speciesConversionNormalToMaser_.end())
    {
        //species known and flagged (i.e. 'converted')
        logger(VERBOSE, "[ConstantMassFlowMaserBoundary::addParticleToMaser()] Species conversion already present");
        p->setSpecies(conversion->second);
    }
    else
    {
        SpeciesHandler& speciesHandler = (getHandler()->getDPMBase()->speciesHandler);
        // species is not yet known by the maser, it has to be added to both maps
        ParticleSpecies* newSpecies = speciesHandler.copyAndAddObject(*(p->getSpecies()));
        speciesConversionNormalToMaser_.insert(
                std::pair<const ParticleSpecies*, const ParticleSpecies*>(p->getSpecies(), newSpecies));
        speciesConversionMaserToNormal_.insert(
                std::pair<const ParticleSpecies*, const ParticleSpecies*>(newSpecies, p->getSpecies()));
        logger(INFO, "[ConstantMassFlowMaserBoundary::addParticleToMaser()] New species conversion created\n",
               Flusher::NO_FLUSH);
        logger(INFO, "Original species ID: %, new species ID: %", p->getSpecies()->getId(), newSpecies->getId());
    
        //Copy over the mixed species. The delete is necessary here since it is overwritten with a copy of the old mixed
        //species, and otherwise the properties are not copied over correctly.
        //
        //setId and setIndex refer to the two different species which are present in this mixed species.
        //The highest species-index should appear first andis therefore the ID, while the second species-index is the
        //"index" of the mixed species.
        for (const BaseSpecies* const s: speciesHandler)
        {
            if (s->getId() != newSpecies->getId() && s->getId() != p->getSpecies()->getId())
            {
                BaseSpecies* newMixed = speciesHandler.getMixedObject(s->getId(), newSpecies->getId());
                const BaseSpecies* const oldMixed = speciesHandler.getMixedObject(s->getId(), p->getSpecies()->getId());
                oldMixed->copyInto(newMixed);
                newMixed->setId(newSpecies->getId());
                newMixed->setIndex(s->getId());
                logger(DEBUG, "mixed species of % and % is now \n %, should be \n %", s->getId(), newSpecies->getId(),
                       *newMixed, *oldMixed);
            }
        }
        
        // now the species IS added, so flag (convert) it!
        p->setSpecies(newSpecies);
    }
    p->move(-normal_ * gapSize_);
}

References BaseHandler< T >::copyAndAddObject(), BaseSpecies::copyInto(), DEBUG, gapSize_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BaseObject::getId(), SpeciesHandler::getMixedObject(), INFO, logger, NO_FLUSH, normal_, p, s, BaseObject::setId(), BaseObject::setIndex(), speciesConversionMaserToNormal_, speciesConversionNormalToMaser_, DPMBase::speciesHandler, and VERBOSE.

Referenced by activateMaser().

checkBoundaryAfterParticleMoved()

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

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 (isMaserParticle(p) && getDistance(p) < 0)
    {
        // Checks if the particle is closest to the right boundary.
        // If so, and if the Maser is turned on, then create a 'real'
        // equivalent and move it over to the outflow domain
        if (isClosestToRightBoundary(p) && isCopying())
        {
            BaseParticle* pCopy = p->copy();
            pCopy->setSpecies(speciesConversionMaserToNormal_.find(p->getSpecies())->second);
            pCopy->move(gapSize_ * normal_);
            pH.addObject(pCopy);
        }
        
        // If the (original) particle has crossed a boundary wall (be it left or right),
        // then shift that particle periodically.
        shiftPosition(p);
    }
    else //remove normal particles trying to enter the gap between the maser and the outflow domain
    {
        const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
        if (distance < gapSize_ + distanceRight_ && isNormalParticle(p))
        {
            pH.removeObject(p->getIndex());
            return true;
        }
    }
    return false;
}

References ParticleHandler::addObject(), distanceRight_, Vec3D::dot(), gapSize_, getDistance(), isClosestToRightBoundary(), isCopying(), isMaserParticle(), isNormalParticle(), BaseInteractable::move(), normal_, p, ParticleHandler::removeObject(), BaseParticle::setSpecies(), shiftPosition(), and speciesConversionMaserToNormal_.

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void ConstantMassFlowMaserBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

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

Reimplemented from BaseBoundary.

{
    for (auto p = pH.begin(); p != pH.end(); ++p)
    {
        //If the particle has interacted with the boundary, change the iterator
        if (checkBoundaryAfterParticleMoved(*p, pH))
        {
            p--;
        }
    }
}

References BaseHandler< T >::begin(), checkBoundaryAfterParticleMoved(), BaseHandler< T >::end(), and p.

closeMaser()

void ConstantMassFlowMaserBoundary::closeMaser

(

)

Stops copying particles (and act merely as a chute)

closing the maser: do exactly the opposite of activating the maser: close the gap by moving all particles, and assign the "normal" species to all maser particles again.

{
    if (maserIsActivated_)
    {
        for (BaseParticle* const p : getHandler()->getDPMBase()->particleHandler)
        {
            if (getDistance(p) > 0)
            {
                removeParticleFromMaser(p);
            }
        }
        distanceLeft_ += gapSize_;
        distanceRight_ += gapSize_;
        maserIsActivated_ = false;
 
        turnOffCopying();
 
        logger(INFO, "The Maser has been deactivated.");
    }
    else
    {
        logger(WARN, "Cannot close the maser if it is not active");
    }
}

References distanceLeft_, distanceRight_, gapSize_, getDistance(), BaseBoundary::getHandler(), INFO, logger, maserIsActivated_, p, removeParticleFromMaser(), turnOffCopying(), and WARN.

copy()

ConstantMassFlowMaserBoundary * ConstantMassFlowMaserBoundary::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

Implements BaseBoundary.

{
    return new ConstantMassFlowMaserBoundary(*this);
}

References ConstantMassFlowMaserBoundary().

createGhostCopy()

BaseParticle * ConstantMassFlowMaserBoundary::createGhostCopy ( BaseParticle *  p ) const

private

Creates a copy of the input particle, that gets removed again in DPMBase::removeDuplicatePeriodicParticles.

Helper function for createPeriodicParticles. It makes a copy of the particle p, and labels the copy as a ghost particle.

Parameters

[in]

p

Particle that needs to be copied

Returns

Copy of particle p, labeled as a ghost particle

{
    // Copy the particle and its interactions
    BaseParticle* pGhost = p->copy();
    pGhost->copyInteractionsForPeriodicParticles(*p);
    
    //Set the 'last' particle. If Particle is multiply shifted, get correct original particle
    BaseParticle* last = p;
    while (last->getPeriodicFromParticle() != nullptr)
    {
        last = last->getPeriodicFromParticle();
    }
    pGhost->setPeriodicFromParticle(last);
    return pGhost;
}

References BaseInteractable::copyInteractionsForPeriodicParticles(), Eigen::placeholders::last, p, and BaseParticle::setPeriodicFromParticle().

Referenced by createPeriodicParticle().

createPeriodicParticle()

void ConstantMassFlowMaserBoundary::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.

Checks the distance of given particle to the closest of both walls, and creates a periodic copy of the particle if needed (i.e. if the particle is closer to the periodic wall than the radius of the largest particle in the system). Note that this is the same function as in PeriodicBoundary, but with the extra check to make sure that only maser particles are periodic particles

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

{
    if (isMaserParticle(p))
    {
        // check if particle is near the boundaries of the maser domain
        if (getDistance(p) < p->getMaxInteractionRadius() + pH.getLargestParticleLocal()->getMaxInteractionRadius())
        {
            BaseParticle* pGhost = createGhostCopy(p);
            
            // shift to the periodic location
            shiftPosition(pGhost);
            
            // add the periodic particle to the handler
            pH.addObject(pGhost);
            
            //furthermore, if the particle is on the right it has to be copied over to the outflow domain
            if (isClosestToRightBoundary(p) && maserIsActivated_)
            {
                // Copy the particle and its interactions if it is a maser particle
                BaseParticle* pGhostOut = createGhostCopy(p);
                
                // shift to the outflow location
                pGhostOut->move(gapSize_ * normal_);
                // add the periodic particle to the handler
                pH.addObject(pGhostOut);
            }
        }
    }
}

References ParticleHandler::addObject(), createGhostCopy(), gapSize_, getDistance(), ParticleHandler::getLargestParticleLocal(), BaseParticle::getMaxInteractionRadius(), isClosestToRightBoundary(), isMaserParticle(), maserIsActivated_, BaseInteractable::move(), normal_, p, and shiftPosition().

Referenced by createPeriodicParticles().

createPeriodicParticles()

void ConstantMassFlowMaserBoundary::createPeriodicParticles ( ParticleHandler &  pH )

override

{
    unsigned numberOfParticles = pH.getSize();
    for (unsigned i = 0; i < numberOfParticles; i++)
    {
        createPeriodicParticle(pH.getObject(i), pH);
    }
}

References createPeriodicParticle(), BaseHandler< T >::getObject(), BaseHandler< T >::getSize(), and i.

getDistance()

Mdouble ConstantMassFlowMaserBoundary::getDistance ( BaseParticle *  p ) const

inlineprivate

Returns the distance of the wall to the particle.

Parameters

[in]

p

Pointer to the particle of which we want to know the distance to the wall to

Returns

Distance of the particle to the boundary: positive means the particle is inside the periodic part of the boundary, negative means it's outside.

    {
        const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
        return std::min(distance - distanceLeft_, distanceRight_ - distance);
    }

References distanceLeft_, distanceRight_, Vec3D::dot(), min, normal_, and p.

Referenced by activateMaser(), checkBoundaryAfterParticleMoved(), closeMaser(), and createPeriodicParticle().

getDistanceLeft()

Mdouble ConstantMassFlowMaserBoundary::getDistanceLeft

(

)

const

{
    return distanceLeft_;
}

References distanceLeft_.

getDistanceRight()

Mdouble ConstantMassFlowMaserBoundary::getDistanceRight

(

)

const

{
    return distanceRight_;
}

References distanceRight_.

getGapSize()

Mdouble ConstantMassFlowMaserBoundary::getGapSize

(

)

const

{
    return gapSize_;
}

References gapSize_.

getName()

std::string ConstantMassFlowMaserBoundary::getName ( ) const

overridevirtual

Returns the name of the object.

Returns the name of the object class

Returns

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

Implements BaseObject.

{
    return "ConstantMassFlowMaserBoundary";
}

isActivated()

bool ConstantMassFlowMaserBoundary::isActivated

(

)

const

Returns whether the Maser is activated or not.

{
    return maserIsActivated_;
}

References maserIsActivated_.

Referenced by isCopying().

isClosestToRightBoundary()

bool ConstantMassFlowMaserBoundary::isClosestToRightBoundary ( const BaseParticle *const  p ) const

inlineprivate

Returns whether the given particle is closer to the right boundary of the periodic part.

Parameters

[in]

p

Particle for which we would like to know whether it is closest to the right boundary

Returns

True if p is closer to the right boundary, false otherwise

    {
        const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
        return (distanceRight_ - distance < distance - distanceLeft_);
    }

References distanceLeft_, distanceRight_, Vec3D::dot(), normal_, and p.

Referenced by checkBoundaryAfterParticleMoved(), createPeriodicParticle(), and shiftPosition().

isCopying()

bool ConstantMassFlowMaserBoundary::isCopying

(

)

const

Returns whether the Maser is copying particles or not.

{
    if (!isActivated())
        logger(WARN, "The Maser is closed, so isCopying() is irrelevant.");
 
    return maserIsCopying_;
}

References isActivated(), logger, maserIsCopying_, and WARN.

Referenced by checkBoundaryAfterParticleMoved().

isMaserParticle()

bool ConstantMassFlowMaserBoundary::isMaserParticle

(

BaseParticle *

p

)

const

Returns true if the particle is a Maser particle, and false otherwise.

One checks if the particle is in the Maser, by checking whether its species is found in the list of maser particle species

{
    // Check if the particle is in the Maser, by checking whether its
    // species is found in the list of maser particle species
    auto positionMaserSpeciesInMap = speciesConversionMaserToNormal_.find(p->getSpecies());
    return (positionMaserSpeciesInMap != speciesConversionMaserToNormal_.end()); //Test if it is a maser particle
}

References p, and speciesConversionMaserToNormal_.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

isNormalParticle()

bool ConstantMassFlowMaserBoundary::isNormalParticle

(

BaseParticle *

p

)

const

Returns true if the particle is a Normal particle, and false otherwise.

One checks if the particle is a normal particle, by checking whether the species changes when we do speciesConversionNormalToMaser_().

{
    auto toFindOutflowSpecies = speciesConversionNormalToMaser_.find(p->getSpecies());
    return (toFindOutflowSpecies != speciesConversionNormalToMaser_.end());
}

References p, and speciesConversionNormalToMaser_.

Referenced by checkBoundaryAfterParticleMoved().

read()

void ConstantMassFlowMaserBoundary::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

Implements BaseBoundary.

{
    BaseBoundary::read(is);
    std::string dummy;
    is >> dummy >> normal_
       >> dummy >> distanceLeft_
       >> dummy >> distanceRight_
       >> dummy >> shift_
       >> dummy >> gapSize_
       >> dummy >> maserIsActivated_;
    unsigned int n;
    is >> dummy >> n;
    const SpeciesHandler& speciesHandler = getHandler()->getDPMBase()->speciesHandler;
    for (unsigned int i = 0; i < n; ++i)
    {
        unsigned int key;
        unsigned int value;
        is >> dummy >> key >> dummy >> value;
        speciesConversionNormalToMaser_[speciesHandler.getObject(key)] = speciesHandler.getObject(value);
        speciesConversionMaserToNormal_[speciesHandler.getObject(value)] = speciesHandler.getObject(key);
    }
    logger(DEBUG, "Finished reading ConstantMassFlowMaserBoundary. \nNormal: % \nDistanceLeft: % \nDistanceRight: % "
                  "\nGapsize: % \nMaserIsActivated: %",
           normal_, distanceLeft_, distanceRight_, gapSize_, maserIsActivated_);
}

References DEBUG, distanceLeft_, distanceRight_, gapSize_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BaseHandler< T >::getObject(), i, logger, maserIsActivated_, n, normal_, BaseBoundary::read(), shift_, speciesConversionMaserToNormal_, speciesConversionNormalToMaser_, DPMBase::speciesHandler, oomph::Global_string_for_annotation::string(), and Eigen::value.

removeParticleFromMaser()

void ConstantMassFlowMaserBoundary::removeParticleFromMaser

(

BaseParticle *

p

)

Convert a maser particle into a 'normal' particle.

{
    auto conversion = speciesConversionMaserToNormal_.find(p->getSpecies());
    if (conversion != speciesConversionMaserToNormal_.end())
    {
        p->setSpecies(conversion->second);
        p->move(normal_ * gapSize_);
    }
}

References gapSize_, normal_, p, and speciesConversionMaserToNormal_.

Referenced by closeMaser().

set() [1/2]

void ConstantMassFlowMaserBoundary::set	(	Vec3D	normal,
		Mdouble	distanceLeft,
		Mdouble	distanceRight
	)

Sets the Maser's normal and positions, and sets the planewise shift to zero. This deactivates the Maser.

Set all the properties of the boundary at once.

Parameters

[in]	normal	Normal unit vector of the (parallel) boundary walls
[in]	distanceLeft	The distance of the left wall to the origin
[in]	distanceRight	The distance of the right wall to the origin

{
    // factor is used to set normal to unit length
    Mdouble scaleFactor_ = 1. / std::sqrt(Vec3D::dot(normal, normal));
    normal_ = normal * scaleFactor_;
    distanceLeft_ = distanceLeft * scaleFactor_;
    distanceRight_ = distanceRight * scaleFactor_;
    shift_ = normal_ * (distanceRight_ - distanceLeft_);
    maserIsActivated_ = false;
}

References distanceLeft_, distanceRight_, Vec3D::dot(), maserIsActivated_, WallFunction::normal(), normal_, shift_, and sqrt().

set() [2/2]

void ConstantMassFlowMaserBoundary::set	(	Vec3D	normal,
		Vec3D	planewiseShift,
		Mdouble	distanceLeft,
		Mdouble	distanceRight
	)

Sets all boundary properties at once and adds particles of the handler to the maser. This deactivates the Maser.

{
    set(normal, distanceLeft, distanceRight);
    setPlanewiseShift(planewiseShift);
}

References WallFunction::normal(), and setPlanewiseShift().

Referenced by ConstantMassFlowMaserBoundaryMixedSpeciesSelfTest::setupInitialConditions(), and ConstantMassFlowMaserSelfTest::setupInitialConditions().

setPlanewiseShift()

void ConstantMassFlowMaserBoundary::setPlanewiseShift

(

Vec3D

planewiseShift

)

Sets a planewise direction to the shift. Doesn't change the normal or the positions.

Sets the shift_ vector through setting the planewise shift. We delete the component of planewiseShift that is parallel to normal_. Allows Lees–Edwards type Masers.

{
    planewiseShift -= Vec3D::dot(planewiseShift, normal_) / Vec3D::dot(normal_, normal_) * normal_;
    shift_ = normal_ * (distanceRight_ - distanceLeft_) + planewiseShift;
}

References distanceLeft_, distanceRight_, Vec3D::dot(), normal_, and shift_.

Referenced by set().

setShift()

void ConstantMassFlowMaserBoundary::setShift

(

Vec3D

shift

)

Sets the shift of the Maser. Usually don't use this directly, use set() or setPlanewiseShift() instead.

{
    shift_ = shift;
}

References shift_.

shiftPosition()

void ConstantMassFlowMaserBoundary::shiftPosition ( BaseParticle *  p ) const

private

Shifts the particle to its 'periodic' position.

Shifts the particle (using the closestToLeftBoundary_ value)

Parameters

[in]

p

A pointer to the particle which will be shifted.

{
    if (isClosestToRightBoundary(p))
    {
        p->move(-shift_);
    }
    else // if closest to right boundary
    {
        p->move(shift_);
    }
}

References isClosestToRightBoundary(), p, and shift_.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

turnOffCopying()

void ConstantMassFlowMaserBoundary::turnOffCopying

(

)

Stop copying particles.

{
    maserIsCopying_ = false;
}

References maserIsCopying_.

Referenced by closeMaser().

turnOnCopying()

void ConstantMassFlowMaserBoundary::turnOnCopying

(

)

Start copying particles.

{
    maserIsCopying_ = true;
}

References maserIsCopying_.

Referenced by activateMaser().

write()

void ConstantMassFlowMaserBoundary::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

Implements BaseBoundary.

{
    BaseBoundary::write(os);
    os << " normal " << normal_
       << " distanceLeft " << distanceLeft_
       << " distanceRight " << distanceRight_
       << " shift " << shift_
       << " gapSize " << gapSize_
       << " maserIsActivated " << maserIsActivated_
       << " numberOfMaserSpecies " << speciesConversionMaserToNormal_.size();
    for (auto p : speciesConversionNormalToMaser_)
    {
        os << " outflowSpeciesIndex " << p.first->getIndex() << " maserSpeciesIndex " << p.second->getIndex();
    }
}

References distanceLeft_, distanceRight_, gapSize_, maserIsActivated_, normal_, p, shift_, speciesConversionMaserToNormal_, speciesConversionNormalToMaser_, and BaseBoundary::write().

Member Data Documentation

distanceLeft_

Mdouble ConstantMassFlowMaserBoundary::distanceLeft_

private

position of left boundary wall, s.t. normal*x=position_left

Referenced by activateMaser(), closeMaser(), ConstantMassFlowMaserBoundary(), getDistance(), getDistanceLeft(), isClosestToRightBoundary(), read(), set(), setPlanewiseShift(), and write().

distanceRight_

Mdouble ConstantMassFlowMaserBoundary::distanceRight_

private

position of right boundary wall, s.t. normal*x=position_right

Referenced by activateMaser(), checkBoundaryAfterParticleMoved(), closeMaser(), ConstantMassFlowMaserBoundary(), getDistance(), getDistanceRight(), isClosestToRightBoundary(), read(), set(), setPlanewiseShift(), and write().

gapSize_

Mdouble ConstantMassFlowMaserBoundary::gapSize_

private

distance between the right side of the periodic domain and the start of the outflow domain.

I.e., each particle in the maser is moved -distanceToOutflowDomain_ * normal when it becomes part of the maser, and moved distanceToOutflowDomain_ * normal when it is inserted in the outflow domain. Generally this is 6 times the radius of the largest particle, so that the ghost particles do not touch each other: the centre of the ghostparticle is at most 1 diameter (2 radii) away from the boundary, so a ghost particle can extend at most 3 particle radii away from the domain. Do this on both sides, and it follows that the gap should be at least 6 diameters wide.

Todo:

JMFT: Do you mean 6 radii?

Referenced by activateMaser(), addParticleToMaser(), checkBoundaryAfterParticleMoved(), closeMaser(), ConstantMassFlowMaserBoundary(), createPeriodicParticle(), getGapSize(), read(), removeParticleFromMaser(), and write().

maserIsActivated_

bool ConstantMassFlowMaserBoundary::maserIsActivated_

private

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

Referenced by activateMaser(), closeMaser(), ConstantMassFlowMaserBoundary(), createPeriodicParticle(), isActivated(), read(), set(), and write().

maserIsCopying_

bool ConstantMassFlowMaserBoundary::maserIsCopying_

private

Flag whether or not the Maser is copying particles.

Referenced by isCopying(), turnOffCopying(), and turnOnCopying().

normal_

Vec3D ConstantMassFlowMaserBoundary::normal_

private

Normal unit vector of both maser walls. Points in the flowing direction.

Referenced by addParticleToMaser(), checkBoundaryAfterParticleMoved(), ConstantMassFlowMaserBoundary(), createPeriodicParticle(), getDistance(), isClosestToRightBoundary(), read(), removeParticleFromMaser(), set(), setPlanewiseShift(), and write().

shift_

Vec3D ConstantMassFlowMaserBoundary::shift_

private

Direction in which particles are to be shifted when they cross the boundary.

I.e., the vector pointing from a point the left boundary wall to the equivalent point on the right one.

By default this is equal to normal_ * (distanceRight_ - distanceLeft_) but you can also set a planewise direction to the shift.

Referenced by ConstantMassFlowMaserBoundary(), read(), set(), setPlanewiseShift(), setShift(), shiftPosition(), and write().

speciesConversionMaserToNormal_

std::map<const ParticleSpecies*, const ParticleSpecies*> ConstantMassFlowMaserBoundary::speciesConversionMaserToNormal_

private

List of 'maser' particles' species, and their normal counterparts.

Referenced by addParticleToMaser(), checkBoundaryAfterParticleMoved(), isMaserParticle(), read(), removeParticleFromMaser(), and write().

speciesConversionNormalToMaser_

std::map<const ParticleSpecies*, const ParticleSpecies*> ConstantMassFlowMaserBoundary::speciesConversionNormalToMaser_

private

List of 'normal' particles' species, and their maser counterparts.

Referenced by addParticleToMaser(), isNormalParticle(), read(), and write().

---

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

• ConstantMassFlowMaserBoundary.h
• ConstantMassFlowMaserBoundary.cc