MercuryDPM  Trunk
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...

ConstantMassFlowMaserBoundarycopy () const override
Creates a copy of this maser on the heap. More...

void set (Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight)
Sets all boundary properties at once and adds particles of the handler to the maser. More...

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

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

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

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

Definition at line 92 of file ConstantMassFlowMaserBoundary.h.

## Constructor & Destructor Documentation

 ConstantMassFlowMaserBoundary::ConstantMassFlowMaserBoundary ( )

MaserBoundary constructor.

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

Definition at line 34 of file ConstantMassFlowMaserBoundary.cc.

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

Referenced by copy().

35 {
36 #ifdef MERCURY_USE_MPI
37  logger(WARN,"Make sure the whole maser boundary is on one processor when using parallel code");
38 #endif
39  distanceLeft_ = std::numeric_limits<double>::quiet_NaN();
40  distanceRight_ = std::numeric_limits<double>::quiet_NaN();
41  gapSize_ = std::numeric_limits<double>::quiet_NaN();
42  maserIsActivated_ = false;
43 }
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
 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.

Definition at line 50 of file ConstantMassFlowMaserBoundary.cc.

50  : BaseBoundary(
51  periodicBoundary)
52 {
53  logger(INFO, "Constructor ConstantMassFlowMaserBoundary(const PeriodicBoundary&) started");
54  distanceLeft_ = periodicBoundary.getDistanceLeft();
55  distanceRight_ = periodicBoundary.getDistanceRight();
56  normal_ = periodicBoundary.getNormal();
57  shift_ = periodicBoundary.getShift();
58  gapSize_ = std::numeric_limits<double>::quiet_NaN();
59  maserIsActivated_ = false;
60
61  logger(INFO, "going to activate the maser");
62  //assume that the maser should be activated immediately when it gets constructed from a periodic boundary
63  activateMaser();
64 }
Mdouble getDistanceLeft() const
Returns the distance of the left wall to the origin, in normal direction.
void activateMaser()
Opens the gap, and transforms particles to maser particles. Also calls turnOnCopying().
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
Mdouble getDistanceRight() const
Returns the distance of the right wall to the origin, in normal direction.
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
Vec3D getNormal() const
returns the vector normal to the periodic boundary
Vec3D getShift() const
Returns the vector going from the left to the right side of the periodic boundary.
Vec3D shift_
Direction in which particles are to be shifted when they cross the boundary.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
BaseBoundary()
default constructor.
Definition: BaseBoundary.cc:32

## Member Function Documentation

 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.

Definition at line 388 of file ConstantMassFlowMaserBoundary.cc.

References activateMaser().

389 {
390  activateMaser();
391 }
void activateMaser()
Opens the gap, and transforms particles to maser particles. Also calls turnOnCopying().
 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 ?

Definition at line 401 of file ConstantMassFlowMaserBoundary.cc.

Referenced by actionsBeforeTimeLoop(), and ConstantMassFlowMaserBoundary().

402 {
403  if (!maserIsActivated_)
404  {
405  logger(INFO, "Going to add particles to the maser and shift the periodic maser boundaries");
408  logger(INFO, "just before particle loop");
409  for (BaseParticle* const p : pH)
410  {
411  if (getDistance(p) > 0)
412  {
414  }
415  }
416
417
420  maserIsActivated_ = true;
421
422  turnOnCopying();
423
424  logger(INFO, "The Maser has been activated, and is now copying particles.");
425  }
426  else
427  {
428  logger(WARN, "Cannot activate the maser boundary twice!");
429  }
430 }
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
Converts a 'normal' particle into a maser particle.
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
ParticleHandler particleHandler
An object of the class ParticleHandler, contains the pointers to all the particles created...
Definition: DPMBase.h:1329
BoundaryHandler * getHandler() const
Returns the boundary's BoundaryHandler.
Definition: BaseParticle.h:345
void turnOnCopying()
Start copying particles.
Container to store all BaseParticle.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
DPMBase * getDPMBase()
Gets the problem that is solved using this handler.
Definition: BaseHandler.h:725
Mdouble getDistance(BaseParticle *p) const
Returns the distance of the wall to the particle.
BaseParticle * getLargestParticleLocal() const
Gets a pointer to the largest BaseParticle (by interactionRadius) in the ParticleHandler of the local...
 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.

Definition at line 305 of file ConstantMassFlowMaserBoundary.cc.

Referenced by activateMaser().

306 {
307  // check if particle species already known by the maser
308  auto conversion = speciesConversionNormalToMaser_.find(p->getSpecies());
309  if (conversion != speciesConversionNormalToMaser_.end())
310  {
311  //species known and flagged (i.e. 'converted')
313  p->setSpecies(conversion->second);
314  }
315  else
316  {
317  SpeciesHandler& speciesHandler = (getHandler()->getDPMBase()->speciesHandler);
318  // species is not yet known by the maser, it has to be added to both maps
321  std::pair<const ParticleSpecies*, const ParticleSpecies*>(p->getSpecies(), newSpecies));
323  std::pair<const ParticleSpecies*, const ParticleSpecies*>(newSpecies, p->getSpecies()));
324  logger(INFO, "[ConstantMassFlowMaserBoundary::addParticleToMaser()] New species conversion created");
325  logger(INFO, "Original species ID: %, new species ID: %", p->getSpecies()->getId(), newSpecies->getId());
326
327  //Copy over the mixed species. The delete is necessary here since it is overwritten with a copy of the old mixed
328  //species, and otherwise the properties are not copied over correctly.
329  //
330  //setId and setIndex refer to the two different species which are present in this mixed species.
331  //The highest species-index should appear first andis therefore the ID, while the second species-index is the
332  //"index" of the mixed species.
333  for (const BaseSpecies* const s : speciesHandler)
334  {
335  if (s->getId() != newSpecies->getId() && s->getId() != p->getSpecies()->getId())
336  {
337  BaseSpecies* newMixed = speciesHandler.getMixedObject(s->getId(), newSpecies->getId());
338  const BaseSpecies* const oldMixed = speciesHandler.getMixedObject(s->getId(), p->getSpecies()->getId());
339  oldMixed->copyInto(newMixed);
340  newMixed->setId(newSpecies->getId());
341  newMixed->setIndex(s->getId());
342  logger(DEBUG, "mixed species of % and % is now \n %, should be \n %", s->getId(), newSpecies->getId(),
343  *newMixed, *oldMixed);
344  }
345  }
346
347  // now the species IS added, so flag (convert) it!
348  p->setSpecies(newSpecies);
349  }
350  p->move(-normal_ * gapSize_);
351 }
Container to store all ParticleSpecies.
void setIndex(unsigned int index)
Allows one to assign an index to an object in the handler/container.
Definition: BaseObject.cc:64
unsigned int getId() const
Returns the unique identifier of any particular object.
Definition: BaseObject.h:125
BaseSpecies is the class from which all other species are derived.
Definition: BaseSpecies.h:49
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
const ParticleSpecies * getSpecies() const
Returns a pointer to the species of this BaseInteractable.
virtual void copyInto(BaseSpecies *s) const =0
void setSpecies(const ParticleSpecies *species)
std::enable_if<!std::is_pointer< U >::value, U * >::type copyAndAddObject(const U &object)
Creates a copy of a Object and adds it to the BaseHandler.
Definition: BaseHandler.h:379
BoundaryHandler * getHandler() const
Returns the boundary's BoundaryHandler.
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
SpeciesHandler speciesHandler
A handler to that stores the species type i.e. LinearViscoelasticSpecies, etc.
Definition: DPMBase.h:1319
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionNormalToMaser_
List of 'normal' particles' species, and their maser counterparts.
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
virtual void move(const Vec3D &move)
Moves this BaseInteractable by adding an amount to the position.
DPMBase * getDPMBase()
Gets the problem that is solved using this handler.
Definition: BaseHandler.h:725
void setId(unsigned long id)
Assigns a unique identifier to each object in the handler (container) which remains constant even aft...
Definition: BaseObject.cc:72
 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

Definition at line 251 of file ConstantMassFlowMaserBoundary.cc.

Referenced by checkBoundaryAfterParticlesMove().

252 {
253  // check if particle passed either of the boundary walls
254  if (isMaserParticle(p) && getDistance(p) < 0)
255  {
256  // Checks if the particle is closest to the right boundary.
257  // If so, and if the Maser is turned on, then create a 'real'
258  // equivalent and move it over to the outflow domain
260  {
261  BaseParticle* pCopy = p->copy();
262  pCopy->setSpecies(speciesConversionMaserToNormal_.find(p->getSpecies())->second);
263  pCopy->move(gapSize_ * normal_);
265  }
266
267  // If the (original) particle has crossed a boundary wall (be it left or right),
268  // then shift that particle periodically.
269  shiftPosition(p);
270  }
271  else //remove normal particles trying to enter the gap between the maser and the outflow domain
272  {
273  const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
274  if (distance < gapSize_ + distanceRight_ && isNormalParticle(p))
275  {
276  pH.removeObject(p->getIndex());
277  return true;
278  }
279  }
280  return false;
281 }
unsigned int getIndex() const
Returns the index of the object in the handler.
Definition: BaseObject.h:118
const Vec3D & getPosition() const
Returns the position of this BaseInteractable.
void removeObject(unsigned int index) override
Removes a BaseParticle from the ParticleHandler.
Adds a BaseParticle to the ParticleHandler.
double Mdouble
Definition: GeneralDefine.h:34
const ParticleSpecies * getSpecies() const
Returns a pointer to the species of this BaseInteractable.
void setSpecies(const ParticleSpecies *species)
static Mdouble dot(const Vec3D &a, const Vec3D &b)
Calculates the dot product of two Vec3D: .
Definition: Vector.cc:76
virtual BaseParticle * copy() const =0
Particle copy method. It calls to copy constructor of this Particle, useful for polymorfism.
bool isMaserParticle(BaseParticle *p) const
Returns true if the particle is a Maser particle, and false otherwise.
bool isNormalParticle(BaseParticle *p) const
Returns true if the particle is a Normal particle, and false otherwise.
bool isClosestToRightBoundary(const BaseParticle *const p) const
Returns whether the given particle is closer to the right boundary of the periodic part...
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
void shiftPosition(BaseParticle *p) const
Shifts the particle to its 'periodic' position.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
virtual void move(const Vec3D &move)
Moves this BaseInteractable by adding an amount to the position.
Mdouble getDistance(BaseParticle *p) const
Returns the distance of the wall to the particle.
bool isCopying() const
Returns whether the Maser is copying particles or not.
 void ConstantMassFlowMaserBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler & pH )
overridevirtual

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

Reimplemented from BaseBoundary.

Definition at line 283 of file ConstantMassFlowMaserBoundary.cc.

284 {
285  for (auto p = pH.begin(); p != pH.end(); ++p)
286  {
287  //If the particle has interacted with the boundary, change the iterator
289  {
290  p--;
291  }
292  }
293 }
bool checkBoundaryAfterParticleMoved(BaseParticle *p, ParticleHandler &pH)
Shifts the particle to its 'periodic' position if it is a maser particle and has crossed either of th...
const std::vector< T * >::const_iterator end() const
Gets the end of the const_iterator over all BaseBoundary in this BaseHandler.
Definition: BaseHandler.h:704
const std::vector< T * >::const_iterator begin() const
Gets the begin of the const_iterator over all Object in this BaseHandler.
Definition: BaseHandler.h:690
 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.

Definition at line 434 of file ConstantMassFlowMaserBoundary.cc.

435 {
436  if (maserIsActivated_)
437  {
438  for (BaseParticle* const p : getHandler()->getDPMBase()->particleHandler)
439  {
440  if (getDistance(p) > 0)
441  {
443  }
444  }
447  maserIsActivated_ = false;
448
449  turnOffCopying();
450
451  logger(INFO, "The Maser has been deactivated.");
452  }
453  else
454  {
455  logger(WARN, "Cannot close the maser if it is not active");
456  }
457 }
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
void removeParticleFromMaser(BaseParticle *p)
Convert a maser particle into a 'normal' particle.
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
void turnOffCopying()
Stop copying particles.
BoundaryHandler * getHandler() const
Returns the boundary's BoundaryHandler.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
Mdouble getDistance(BaseParticle *p) const
Returns the distance of the wall to the particle.
 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.

Definition at line 71 of file ConstantMassFlowMaserBoundary.cc.

References ConstantMassFlowMaserBoundary().

72 {
73  return new ConstantMassFlowMaserBoundary(*this);
74 }
ConstantMassFlowMaserBoundary()
MaserBoundary constructor.
 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

Definition at line 226 of file ConstantMassFlowMaserBoundary.cc.

Referenced by createPeriodicParticle().

227 {
228  // Copy the particle and its interactions
229  BaseParticle* pGhost = p->copy();
231
232  //Set the 'last' particle. If Particle is multiply shifted, get correct original particle
233  BaseParticle* last = p;
234  while (last->getPeriodicFromParticle() != nullptr)
235  {
236  last = last->getPeriodicFromParticle();
237  }
238  pGhost->setPeriodicFromParticle(last);
239  return pGhost;
240 }
void setPeriodicFromParticle(BaseParticle *p)
Assigns the pointer to the 'original' particle this one's a periodic copy of (used in periodic bounda...
Definition: BaseParticle.h:438
BaseParticle * getPeriodicFromParticle() const
Returns the 'original' particle this one's a periodic copy of.
Definition: BaseParticle.h:338
virtual BaseParticle * copy() const =0
Particle copy method. It calls to copy constructor of this Particle, useful for polymorfism.
void copyInteractionsForPeriodicParticles(const BaseInteractable &p)
Copies interactions to this BaseInteractable whenever a periodic copy made.
 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

Definition at line 181 of file ConstantMassFlowMaserBoundary.cc.

Referenced by createPeriodicParticles().

182 {
183  if (isMaserParticle(p))
184  {
185  // check if particle is near the boundaries of the maser domain
187  {
188  BaseParticle* pGhost = createGhostCopy(p);
189
190  // shift to the periodic location
191  shiftPosition(pGhost);
192
193  // add the periodic particle to the handler
195
196  //furthermore, if the particle is on the right it has to be copied over to the outflow domain
198  {
199  // Copy the particle and its interactions if it is a maser particle
200  BaseParticle* pGhostOut = createGhostCopy(p);
201
202  // shift to the outflow location
203  pGhostOut->move(gapSize_ * normal_);
204  // add the periodic particle to the handler
206  }
207  }
208  }
209 }
Adds a BaseParticle to the ParticleHandler.
Returns the particle's interaction radius, which might be different from radius_ (e.g., when dealing with wet particles)
Definition: BaseParticle.h:359
BaseParticle * createGhostCopy(BaseParticle *p) const
Creates a copy of the input particle, that gets removed again in DPMBase::removeDuplicatePeriodicPart...
bool isMaserParticle(BaseParticle *p) const
Returns true if the particle is a Maser particle, and false otherwise.
bool isClosestToRightBoundary(const BaseParticle *const p) const
Returns whether the given particle is closer to the right boundary of the periodic part...
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
void shiftPosition(BaseParticle *p) const
Shifts the particle to its 'periodic' position.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
virtual void move(const Vec3D &move)
Moves this BaseInteractable by adding an amount to the position.
Mdouble getDistance(BaseParticle *p) const
Returns the distance of the wall to the particle.
BaseParticle * getLargestParticleLocal() const
Gets a pointer to the largest BaseParticle (by interactionRadius) in the ParticleHandler of the local...
 void ConstantMassFlowMaserBoundary::createPeriodicParticles ( ParticleHandler & pH )
override

Definition at line 211 of file ConstantMassFlowMaserBoundary.cc.

212 {
213  unsigned numberOfParticles = pH.getSize();
214  for (unsigned i = 0; i < numberOfParticles; i++)
215  {
217  }
218 }
unsigned int getSize() const
Gets the size of the particleHandler (including mpi and periodic particles)
Definition: BaseHandler.h:655
const std::complex< Mdouble > i
Definition: ExtendedMath.h:50
T * getObject(const unsigned int id)
Gets a pointer to the Object at the specified index in the BaseHandler.
Definition: BaseHandler.h:613
void createPeriodicParticle(BaseParticle *p, ParticleHandler &pH) override
Creates periodic particles when the particle is a maser particle and is sufficiently close to one of ...
 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.

Definition at line 231 of file ConstantMassFlowMaserBoundary.h.

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

232  {
233  const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
234  return std::min(distance - distanceLeft_, distanceRight_ - distance);
235  }
const Vec3D & getPosition() const
Returns the position of this BaseInteractable.
double Mdouble
Definition: GeneralDefine.h:34
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
static Mdouble dot(const Vec3D &a, const Vec3D &b)
Calculates the dot product of two Vec3D: .
Definition: Vector.cc:76
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
 Mdouble ConstantMassFlowMaserBoundary::getDistanceLeft ( ) const

Definition at line 483 of file ConstantMassFlowMaserBoundary.cc.

References distanceLeft_.

484 {
485  return distanceLeft_;
486 }
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
 Mdouble ConstantMassFlowMaserBoundary::getDistanceRight ( ) const

Definition at line 488 of file ConstantMassFlowMaserBoundary.cc.

References distanceRight_.

489 {
490  return distanceRight_;
491 }
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
 Mdouble ConstantMassFlowMaserBoundary::getGapSize ( ) const

Definition at line 493 of file ConstantMassFlowMaserBoundary.cc.

References gapSize_.

494 {
495  return gapSize_;
496 }
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
 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.

Definition at line 147 of file ConstantMassFlowMaserBoundary.cc.

148 {
149  return "ConstantMassFlowMaserBoundary";
150 }
 bool ConstantMassFlowMaserBoundary::isActivated ( ) const

Returns whether the Maser is activated or not.

Definition at line 459 of file ConstantMassFlowMaserBoundary.cc.

References maserIsActivated_.

Referenced by isCopying().

460 {
461  return maserIsActivated_;
462 }
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
 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

Definition at line 219 of file ConstantMassFlowMaserBoundary.h.

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

220  {
221  const Mdouble distance = Vec3D::dot(p->getPosition(), normal_);
222  return (distanceRight_ - distance < distance - distanceLeft_);
223  }
const Vec3D & getPosition() const
Returns the position of this BaseInteractable.
double Mdouble
Definition: GeneralDefine.h:34
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
static Mdouble dot(const Vec3D &a, const Vec3D &b)
Calculates the dot product of two Vec3D: .
Definition: Vector.cc:76
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
 bool ConstantMassFlowMaserBoundary::isCopying ( ) const

Returns whether the Maser is copying particles or not.

Definition at line 475 of file ConstantMassFlowMaserBoundary.cc.

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

Referenced by checkBoundaryAfterParticleMoved().

476 {
477  if (!isActivated())
478  logger(WARN, "The Maser is closed, so isCopying() is irrelevant.");
479
480  return maserIsCopying_;
481 }
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
bool isActivated() const
Returns whether the Maser is activated or not.
bool maserIsCopying_
Flag whether or not the Maser is copying particles.
 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

Definition at line 367 of file ConstantMassFlowMaserBoundary.cc.

References BaseInteractable::getSpecies(), and speciesConversionMaserToNormal_.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

368 {
369  // Check if the particle is in the Maser, by checking whether its
370  // species is found in the list of maser particle species
371  auto positionMaserSpeciesInMap = speciesConversionMaserToNormal_.find(p->getSpecies());
372  return (positionMaserSpeciesInMap != speciesConversionMaserToNormal_.end()); //Test if it is a maser particle
373 }
const ParticleSpecies * getSpecies() const
Returns a pointer to the species of this BaseInteractable.
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
 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_().

Definition at line 379 of file ConstantMassFlowMaserBoundary.cc.

References BaseInteractable::getSpecies(), and speciesConversionNormalToMaser_.

Referenced by checkBoundaryAfterParticleMoved().

380 {
381  auto toFindOutflowSpecies = speciesConversionNormalToMaser_.find(p->getSpecies());
382  return (toFindOutflowSpecies != speciesConversionNormalToMaser_.end());
383 }
const ParticleSpecies * getSpecies() const
Returns a pointer to the species of this BaseInteractable.
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionNormalToMaser_
List of 'normal' particles' species, and their maser counterparts.
 void ConstantMassFlowMaserBoundary::read ( std::istream & is )
overridevirtual

Reads the boundary properties from an istream

Parameters
 [in,out] is the istream from which the boundary must be read

Implements BaseBoundary.

Definition at line 97 of file ConstantMassFlowMaserBoundary.cc.

98 {
100  std::string dummy;
101  is >> dummy >> normal_
102  >> dummy >> distanceLeft_
103  >> dummy >> distanceRight_
104  >> dummy >> shift_
105  >> dummy >> gapSize_
106  >> dummy >> maserIsActivated_;
107  unsigned int n;
108  is >> dummy >> n;
109  const SpeciesHandler& speciesHandler = getHandler()->getDPMBase()->speciesHandler;
110  for (unsigned int i = 0; i < n; ++i)
111  {
112  unsigned int key;
113  unsigned int value;
114  is >> dummy >> key >> dummy >> value;
115  speciesConversionNormalToMaser_[speciesHandler.getObject(key)] = speciesHandler.getObject(value);
116  speciesConversionMaserToNormal_[speciesHandler.getObject(value)] = speciesHandler.getObject(key);
117  }
118  logger(DEBUG, "Finished reading ConstantMassFlowMaserBoundary. \nNormal: % \nDistanceLeft: % \nDistanceRight: % "
119  "\nGapsize: % \nMaserIsActivated: %", normal_, distanceLeft_, distanceRight_, gapSize_,
120  maserIsActivated_);
121 }
Container to store all ParticleSpecies.
Logger< MERCURY_LOGLEVEL > logger("MercuryKernel")
const std::complex< Mdouble > i
Definition: ExtendedMath.h:50
Reads the object's id_ from given istream NB: purely virtual function, overriding the version of Base...
Definition: BaseBoundary.cc:61
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
Vec3D shift_
Direction in which particles are to be shifted when they cross the boundary.
T * getObject(const unsigned int id)
Gets a pointer to the Object at the specified index in the BaseHandler.
Definition: BaseHandler.h:613
BoundaryHandler * getHandler() const
Returns the boundary's BoundaryHandler.
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
SpeciesHandler speciesHandler
A handler to that stores the species type i.e. LinearViscoelasticSpecies, etc.
Definition: DPMBase.h:1319
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionNormalToMaser_
List of 'normal' particles' species, and their maser counterparts.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
DPMBase * getDPMBase()
Gets the problem that is solved using this handler.
Definition: BaseHandler.h:725
 void ConstantMassFlowMaserBoundary::removeParticleFromMaser ( BaseParticle * p )

Convert a maser particle into a 'normal' particle.

Definition at line 353 of file ConstantMassFlowMaserBoundary.cc.

Referenced by closeMaser().

354 {
355  auto conversion = speciesConversionMaserToNormal_.find(p->getSpecies());
356  if (conversion != speciesConversionMaserToNormal_.end())
357  {
358  p->setSpecies(conversion->second);
359  p->move(normal_ * gapSize_);
360  }
361 }
const ParticleSpecies * getSpecies() const
Returns a pointer to the species of this BaseInteractable.
void setSpecies(const ParticleSpecies *species)
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...
virtual void move(const Vec3D &move)
Moves this BaseInteractable by adding an amount to the position.
 void ConstantMassFlowMaserBoundary::set ( Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight )

Sets all boundary properties at once and adds particles of the handler to 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

Definition at line 82 of file ConstantMassFlowMaserBoundary.cc.

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

83 {
84  // factor is used to set normal to unit length
85  Mdouble scaleFactor_ = 1. / std::sqrt(Vec3D::dot(normal, normal));
86  normal_ = normal * scaleFactor_;
87  distanceLeft_ = distanceLeft * scaleFactor_;
88  distanceRight_ = distanceRight * scaleFactor_;
90  maserIsActivated_ = false;
91 }
double Mdouble
Definition: GeneralDefine.h:34
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
static Mdouble dot(const Vec3D &a, const Vec3D &b)
Calculates the dot product of two Vec3D: .
Definition: Vector.cc:76
Vec3D shift_
Direction in which particles are to be shifted when they cross the boundary.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
 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.

Definition at line 156 of file ConstantMassFlowMaserBoundary.cc.

References isClosestToRightBoundary(), BaseInteractable::move(), and shift_.

Referenced by checkBoundaryAfterParticleMoved(), and createPeriodicParticle().

157 {
159  {
160  p->move(-shift_);
161  }
162  else // if closest to right boundary
163  {
164  p->move(shift_);
165  }
166 }
Vec3D shift_
Direction in which particles are to be shifted when they cross the boundary.
bool isClosestToRightBoundary(const BaseParticle *const p) const
Returns whether the given particle is closer to the right boundary of the periodic part...
virtual void move(const Vec3D &move)
Moves this BaseInteractable by adding an amount to the position.
 void ConstantMassFlowMaserBoundary::turnOffCopying ( )

Stop copying particles.

Definition at line 469 of file ConstantMassFlowMaserBoundary.cc.

References maserIsCopying_.

Referenced by closeMaser().

470 {
471  maserIsCopying_ = false;
472 }
bool maserIsCopying_
Flag whether or not the Maser is copying particles.
 void ConstantMassFlowMaserBoundary::turnOnCopying ( )

Start copying particles.

Definition at line 464 of file ConstantMassFlowMaserBoundary.cc.

References maserIsCopying_.

Referenced by activateMaser().

465 {
466  maserIsCopying_ = true;
467 }
bool maserIsCopying_
Flag whether or not the Maser is copying particles.
 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.

Definition at line 127 of file ConstantMassFlowMaserBoundary.cc.

128 {
130  os << " normal " << normal_
131  << " distanceLeft " << distanceLeft_
132  << " distanceRight " << distanceRight_
133  << " shift " << shift_
134  << " gapSize " << gapSize_
135  << " maserIsActivated " << maserIsActivated_
136  << " numberOfMaserSpecies " << speciesConversionMaserToNormal_.size();
137  for (auto p : speciesConversionNormalToMaser_)
138  {
139  os << " outflowSpeciesIndex " << p.first->getIndex() << " maserSpeciesIndex " << p.second->getIndex();
140  }
141 }
Mdouble distanceLeft_
position of left boundary wall, s.t. normal*x=position_left
Vec3D shift_
Direction in which particles are to be shifted when they cross the boundary.
void write(std::ostream &os) const override=0
Adds object's id_ to given ostream NB: purely virtual function, overriding the version of BaseObject...
Definition: BaseBoundary.cc:70
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionMaserToNormal_
List of 'maser' particles' species, and their normal counterparts.
std::map< const ParticleSpecies *, const ParticleSpecies * > speciesConversionNormalToMaser_
List of 'normal' particles' species, and their maser counterparts.
bool maserIsActivated_
Flag whether or not the gap is created and particles transformed already.
Mdouble distanceRight_
position of right boundary wall, s.t. normal*x=position_right
Vec3D normal_
Normal unit vector of both maser walls. Points in the flowing direction.
Mdouble gapSize_
distance between the right side of the periodic domain and the start of the outflow domain...

## Member Data Documentation

 Mdouble ConstantMassFlowMaserBoundary::distanceLeft_
private

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

Definition at line 245 of file ConstantMassFlowMaserBoundary.h.

 Mdouble ConstantMassFlowMaserBoundary::distanceRight_
private

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

Definition at line 250 of file ConstantMassFlowMaserBoundary.h.

 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?

Definition at line 265 of file ConstantMassFlowMaserBoundary.h.

 bool ConstantMassFlowMaserBoundary::maserIsActivated_
private

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

Definition at line 287 of file ConstantMassFlowMaserBoundary.h.

 bool ConstantMassFlowMaserBoundary::maserIsCopying_
private

Flag whether or not the Maser is copying particles.

Definition at line 292 of file ConstantMassFlowMaserBoundary.h.

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

 Vec3D ConstantMassFlowMaserBoundary::normal_
private

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

Definition at line 240 of file ConstantMassFlowMaserBoundary.h.

 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.

Definition at line 272 of file ConstantMassFlowMaserBoundary.h.

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

 std::map ConstantMassFlowMaserBoundary::speciesConversionMaserToNormal_
private

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

Definition at line 282 of file ConstantMassFlowMaserBoundary.h.

 std::map ConstantMassFlowMaserBoundary::speciesConversionNormalToMaser_
private

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

Definition at line 277 of file ConstantMassFlowMaserBoundary.h.