SubcriticalMaserBoundary Class Reference

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

#include <SubcriticalMaserBoundary.h>

Inheritance diagram for SubcriticalMaserBoundary:

Public Member Functions
	SubcriticalMaserBoundary ()
	MaserBoundary constructor. More...
	SubcriticalMaserBoundary (const PeriodicBoundary &periodicBoundary)
	Maserboundary constructor that takes a periodic boundary, and converts it to a maser boundary. More...
SubcriticalMaserBoundary *	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) 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	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	deactivateMaser ()
	Stops copying particles (and act merely as a chute) More...
Mdouble	getDistanceLeft () const
Mdouble	getDistanceRight () 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

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

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

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. 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, and vice versa. The left side of the periodic domain does not influence the right side of the periodic domain. When a particle in the outflow domain tries to enter the periodic domain, it gets removed. If a particle tries to leave the periodic domain to the left, it gets removed.

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 SubcriticalMaserBoundary, please look at the output of SubcriticalMaserBoundarySelfTest.

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

SubcriticalMaserBoundary() [1/2]

SubcriticalMaserBoundary::SubcriticalMaserBoundary

(

)

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();
    maserIsActivated_ = false;
}

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

Referenced by copy().

SubcriticalMaserBoundary() [2/2]

SubcriticalMaserBoundary::SubcriticalMaserBoundary ( 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 SubcriticalMaserBoundary(const PeriodicBoundary&) started");
    distanceLeft_ = periodicBoundary.getDistanceLeft();
    distanceRight_ = periodicBoundary.getDistanceRight();
    normal_ = periodicBoundary.getNormal();
    shift_ = periodicBoundary.getShift();
    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_, PeriodicBoundary::getDistanceLeft(), PeriodicBoundary::getDistanceRight(), PeriodicBoundary::getNormal(), PeriodicBoundary::getShift(), INFO, logger, maserIsActivated_, normal_, and shift_.

Member Function Documentation

actionsBeforeTimeLoop()

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

{
    if (!maserIsActivated_)
    {
        logger(INFO, "Going to add particles to the maser and shift the periodic maser boundaries");
        ParticleHandler& pH = getHandler()->getDPMBase()->particleHandler;
        logger(INFO, "just before particle loop");
        for (BaseParticle* const p : pH)
        {
            if (getDistance(p) > 0)
            {
                addParticleToMaser(p);
            }
        }
        maserIsActivated_ = true;
    }
    else
    {
        logger(WARN, "Cannot activate the maser boundary twice!");
    }
}

References addParticleToMaser(), getDistance(), BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), INFO, logger, maserIsActivated_, p, DPMBase::particleHandler, and WARN.

Referenced by actionsBeforeTimeLoop(), and SubcriticalMaserBoundary().

addParticleToMaser()

void SubcriticalMaserBoundary::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, "[SubcriticalMaserBoundary::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, "[SubcriticalMaserBoundary::addParticleToMaser()] New species conversion created");
        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 and is 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());
                delete newMixed;
                const BaseSpecies* const oldMixed = speciesHandler.getMixedObject(s->getId(), p->getSpecies()->getId());
                newMixed = oldMixed->copy();
                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);
    }
}

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

Referenced by activateMaser().

checkBoundaryAfterParticleMoved()

bool SubcriticalMaserBoundary::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 (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) && maserIsActivated_)
        {
            BaseParticle* pCopy = p->copy();
            pCopy->setSpecies(speciesConversionMaserToNormal_.find(p->getSpecies())->second);
            pH.addObject(pCopy);
 
            // If the (original) particle has crossed a right boundary,
            // then shift that particle periodically.
            shiftPosition(p);
        }
        else if (!maserIsActivated_)
        {
            shiftPosition(p);
        }
    }
    return false;
}

References ParticleHandler::addObject(), getDistance(), isClosestToRightBoundary(), isMaserParticle(), maserIsActivated_, p, BaseParticle::setSpecies(), shiftPosition(), and speciesConversionMaserToNormal_.

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void SubcriticalMaserBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

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

Reimplemented from BaseBoundary.

{
    for (BaseParticle* p : pH)
    {
        checkBoundaryAfterParticleMoved(p, pH);
    }
}

References checkBoundaryAfterParticleMoved(), and p.

copy()

SubcriticalMaserBoundary * SubcriticalMaserBoundary::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 SubcriticalMaserBoundary(*this);
}

References SubcriticalMaserBoundary().

createGhostCopy()

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

protected

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. Same function as in PeriodicBoundary.

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 SubcriticalMaserBoundary::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 on the right side of the domain are periodic particles, to prevent double forces on the right side of the periodic domain.

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) || !maserIsActivated_)
    {
        // check if particle is near the boundaries of the maser domain
        const Mdouble periodicDistance = p->getMaxInteractionRadius() + 2.0* pH.getLargestParticle()->getMaxInteractionRadius();
        if (getDistance(p) < periodicDistance)
        {
            //furthermore, if the particle is on the right it has to be copied over to the outflow domain
            if (isClosestToRightBoundary(p))
            {
                BaseParticle* pGhost = createGhostCopy(p);
                
                // shift to the periodic location
                shiftPosition(pGhost);
                
                // add the periodic particle to the handler
                pH.addObject(pGhost);
            }
            else if (!maserIsActivated_)
            {
                BaseParticle* pGhost = createGhostCopy(p);
                
                // shift to the periodic location
                shiftPosition(pGhost);
                
                // add the periodic particle to the handler
                pH.addObject(pGhost);
            }
        }
    }
}

References ParticleHandler::addObject(), createGhostCopy(), getDistance(), ParticleHandler::getLargestParticle(), BaseParticle::getMaxInteractionRadius(), isClosestToRightBoundary(), isMaserParticle(), maserIsActivated_, p, and shiftPosition().

Referenced by createPeriodicParticles().

createPeriodicParticles()

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

deactivateMaser()

void SubcriticalMaserBoundary::deactivateMaser

(

)

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);
            }
        }
        maserIsActivated_ = false;
        logger(INFO, "The Maser is no longer copying particles.");
    }
    else
    {
        logger(WARN, "Cannot close the maser if it is not active");
    }
}

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

getDistance()

Mdouble SubcriticalMaserBoundary::getDistance ( BaseParticle *  p ) const

inlineprotected

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(), createPeriodicParticle(), and deactivateMaser().

getDistanceLeft()

Mdouble SubcriticalMaserBoundary::getDistanceLeft

(

)

const

{
    return distanceLeft_;
}

References distanceLeft_.

getDistanceRight()

Mdouble SubcriticalMaserBoundary::getDistanceRight

(

)

const

{
    return distanceRight_;
}

References distanceRight_.

getName()

std::string SubcriticalMaserBoundary::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 "SubcriticalMaserBoundary";
}

isClosestToRightBoundary()

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

inlineprotected

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

isMaserParticle()

bool SubcriticalMaserBoundary::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 SubcriticalMaserBoundary::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_.

read()

void SubcriticalMaserBoundary::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 >> 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 SubcriticalMaserBoundary. \nNormal: % \nDistanceLeft: % \nDistanceRight: % "
            ": % \nMaserIsActivated: %", normal_, distanceLeft_, distanceRight_, maserIsActivated_);
}

References DEBUG, distanceLeft_, distanceRight_, 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 SubcriticalMaserBoundary::removeParticleFromMaser

(

BaseParticle *

p

)

Convert a maser particle into a 'normal' particle.

{
    auto conversion = speciesConversionMaserToNormal_.find(p->getSpecies());
    p->setSpecies(conversion->second);
}

References p, and speciesConversionMaserToNormal_.

Referenced by deactivateMaser().

set() [1/2]

void SubcriticalMaserBoundary::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 SubcriticalMaserBoundary::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 ChuteWithWedge::setupInitialConditions(), and SubcriticalMaserBoundarySelfTest::setupInitialConditions().

setPlanewiseShift()

void SubcriticalMaserBoundary::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 SubcriticalMaserBoundary::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 SubcriticalMaserBoundary::shiftPosition ( BaseParticle *  p ) const

protected

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

write()

void SubcriticalMaserBoundary::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_
       << " maserIsActivated " << maserIsActivated_
       << " numberOfMaserSpecies " << speciesConversionMaserToNormal_.size();
    for (auto p : speciesConversionNormalToMaser_)
    {
        os << " outflowSpeciesIndex " << p.first->getIndex() << " maserSpeciesIndex " << p.second->getIndex();
    }
}

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

Member Data Documentation

distanceLeft_

Mdouble SubcriticalMaserBoundary::distanceLeft_

protected

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

Referenced by getDistance(), getDistanceLeft(), isClosestToRightBoundary(), read(), set(), setPlanewiseShift(), SubcriticalMaserBoundary(), and write().

distanceRight_

Mdouble SubcriticalMaserBoundary::distanceRight_

protected

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

Referenced by getDistance(), getDistanceRight(), isClosestToRightBoundary(), read(), set(), setPlanewiseShift(), SubcriticalMaserBoundary(), and write().

maserIsActivated_

bool SubcriticalMaserBoundary::maserIsActivated_

protected

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

Referenced by activateMaser(), checkBoundaryAfterParticleMoved(), createPeriodicParticle(), deactivateMaser(), read(), set(), SubcriticalMaserBoundary(), and write().

normal_

Vec3D SubcriticalMaserBoundary::normal_

protected

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

Referenced by getDistance(), isClosestToRightBoundary(), read(), set(), setPlanewiseShift(), SubcriticalMaserBoundary(), and write().

shift_

Vec3D SubcriticalMaserBoundary::shift_

protected

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 read(), set(), setPlanewiseShift(), setShift(), shiftPosition(), SubcriticalMaserBoundary(), and write().

speciesConversionMaserToNormal_

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

protected

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*> SubcriticalMaserBoundary::speciesConversionNormalToMaser_

protected

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:

• SubcriticalMaserBoundary.h
• SubcriticalMaserBoundary.cc