Boundary structure for boundaries used for insertion of particles. More...

#include <InsertionBoundary.h>

Inheritance diagram for InsertionBoundary:

Public Member Functions
	InsertionBoundary ()

	InsertionBoundary (const InsertionBoundary &other)
	Copy constructor (with deep copy) More...

	~InsertionBoundary () override
	Destructor: delete the particle that has to be copied at every insertion. More...

virtual BaseParticle *	generateParticle (RNG &random)
	Sets the properties of the InsertionBoundary for a single particle type ‍/ virtual void set(BaseParticle* particleToCopy, unsigned int maxFailed, Vec3D velMin, Vec3D velMax, double radMin, double radMax)=0;. More...

virtual void	placeParticle (BaseParticle *p, RNG &random)=0
	Purely virtual function that generates the extrinsic properties (position, velocity) of a particle. More...

virtual void	shiftBoundary (Vec3D shift)
	virtual function that shifts the boundary. More...

virtual void	rotateBoundary (Vec3D angle)
	virtual function that rotates the boundary. More...

void	checkBoundaryBeforeTimeStep (DPMBase *md) override
	Fills the boundary with particles. More...

void	insertParticles (DPMBase *md)
	Fill a certain domain with particles. More...

unsigned int	getNumberOfParticlesInserted () const
	Gets the number of particles inserted by the boundary. More...

Mdouble	getMassOfParticlesInserted () const
	Gets the mass of particles inserted by the boundary. More...

Mdouble	getVolumeOfParticlesInserted () const
	Gets the volume of particles inserted by the boundary. More...

void	reset ()
	resets particle property counter variables. More...

void	activate ()
	Turns on the InsertionBoundary. More...

void	deactivate ()
	Turns off the InsertionBoundary. More...

bool	isActivated ()
	Returns whether the InsertionBoundary is activated. More...

unsigned int	getMaxFailed () const
	Gets the number of times that the boundary may fail to insert a particle. More...

void	setParticleToCopy (std::vector< BaseParticle * > particleToCopy)
	Sets multiple different particles that will be inserted through the insertion boundary. More...

void	setParticleToCopy (BaseParticle *particleToCopy)
	Sets the particle that will be inserted through the insertion boundary. More...

std::vector< BaseParticle * >	getParticleToCopy ()
	Gets the particles that will be inserted through the insertion boundary. More...

void	read (std::istream &is) override
	Reads the boundary's id_ and maxFailed_. More...

void	write (std::ostream &os) const override
	Writes the boundary's id_ and maxFailed_. More...

Mdouble	getVolumeFlowRate () const
	Gets the volume flow rate of the insertion routine. More...

void	setVolumeFlowRate (Mdouble volumeFlowRate)
	Sets the volume flow rate of the insertion routine. More...

Mdouble	getInitialVolume () const
	Gets the initialVolume() . More...

void	setInitialVolume (Mdouble initialVolume)
	Gets the Volume which should be inserted by the insertion routine. More...

void	setPSD (const PSD psd)
	Sets the range of particle radii that may be generated from a user defined PSD. More...

void	setPSD (std::vector< PSD > psd, std::vector< Mdouble > probability)
	Sets the ranges of particle radii that may be generated from user defined PSDs. More...

std::vector< PSD >	getPSD ()
	Gets the particle size distributions set by the user. More...

void	setVariableVolumeFlowRate (const std::vector< Mdouble > &variableCumulativeVolumeFlowRate, Mdouble samplingInterval)
	Sets a variable volume flow rate. More...

bool	insertParticle (Mdouble time)
	Checks the inserted total volume and returns if a particle is still allowed to be inserted. More...

bool	getCheckParticleForInteraction () const
	Gets the variable that checks if a particle has an interaction. More...

void	setCheckParticleForInteraction (bool checkParticleForInteraction)
	Sets the variable that checks if a particle has an interaction. More...

void	setManualInsertion (bool manualInsertion)
	Set the flag for a manual PSD insertion routine. More...

Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...

	BaseBoundary (const BaseBoundary &b)
	copy constructor More...

	~BaseBoundary () override
	destructor More...

virtual BaseBoundary *	copy () const =0
	Used to create a copy of the object NB: purely virtual function. 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	checkBoundaryAfterParticlesMove (ParticleHandler &pH)
	Virtual function that does things to particles, each time step after particles have moved. More...

virtual void	actionsBeforeTimeLoop ()
	Virtual function that does something after DPMBase::setupInitialConditions but before the first 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 std::string	getName () const =0
	A purely virtual function. 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

Public Attributes
std::vector< BaseParticle * >	particleToCopy_
	read Distribution class from file. ‍/ friend std::istream& operator>>(std::istream& is, InsertionBoundary::Distribution& type); More...

unsigned int	maxFailed_
	Number of times that the wall may fail to insert a particle. More...

unsigned int	numberOfParticlesInserted_
	Number of particles that are already inserted. More...

Mdouble	massInserted_
	Total mass of particles inserted. More...

Mdouble	volumeInserted_
	Total volume of particles inserted. More...

bool	isActivated_
	The InsertionBoundary is activated by default. If the InsertionBoundary is deactivated, then it introduces no particles (useful for trying to maintain a certain insertion rate). More...

Mdouble	volumeFlowRate_

Mdouble	initialVolume_

std::vector< Mdouble >	variableCumulativeVolumeFlowRate_

Mdouble	samplingInterval_

bool	checkParticleForInteraction_
	Checks if a particle has an interaction with a wall or other particles. More...

std::vector< PSD >	particleSizeDistributionVector_
	Defines a particle size distribution as an object of the PSD class; if particleSizeDistributionVector_ is empty, distribution_ is used instead. More...

Vec3D	velMin_
	Minimum and maximum velocity of the particles to be inserted. More...

Vec3D	velMax_

bool	isManuallyInserting_
	A flag to enable a top-down class-by-class manual insertion of a PSD; default is FALSE. More...

std::vector< Mdouble >	probability_
	vector of probabilities in range [0,1] which determine the mixing ratio of partice size distributions. More...

int	chosenSpecies_
	stores the chosen species for each timestep. More...

BaseParticle *	p0 = nullptr
	pointer to the next particle that should be inserted (needs to be stored across time steps). More...

Detailed Description

Boundary structure for boundaries used for insertion of particles.

To cite the InsertionBoundary algorithm: A. R. Thornton, D. Krijgsman, A. Te Voortwis, V. Ogarko, S. Luding, R. Fransen, S. Gonzalez, O. Bokhove, O. Imole, and T. Weinhart. A review of recent work on the discrete particle method at the University of Twente: An introduction to the open-source package MercuryDPM. DEM6 - International Conference on DEMs, 2013.

Constructor & Destructor Documentation

◆ InsertionBoundary() [1/2]

InsertionBoundary::InsertionBoundary ( )

Todo:: think about making both possible; a discrete distribution and a continuous which is more accurate

 \brief Defines a custom particle size distribution; distribution_ will always be used, unless particleSizeDistributionVector_ is non-empty
&zwj;/

enum class Distribution { Uniform, Normal_1_5 // TODO add LogNormal distribution // LogNormal };

/*!
   \brief Default constructor: set everything to 0/nullptr.

Default constructor, sets all data members to 0 or default.

                                      : BaseBoundary()
 {
     numberOfParticlesInserted_ = 0;
     massInserted_ = 0;
     volumeInserted_ = 0;
     maxFailed_ = 0;
     isActivated_ = true;
     volumeFlowRate_ = constants::inf;
     initialVolume_ = 0;
     samplingInterval_ = 0;
     checkParticleForInteraction_ = true;
     velMin_ = Vec3D(0.0, 0.0, 0.0);
     velMax_ = Vec3D(0.0, 0.0, 0.0);
     particleSizeDistributionVector_.resize(1);
     isManuallyInserting_ = false;
     chosenSpecies_ = 0;
 }

References checkParticleForInteraction_, chosenSpecies_, constants::inf, initialVolume_, isActivated_, isManuallyInserting_, massInserted_, maxFailed_, numberOfParticlesInserted_, particleSizeDistributionVector_, samplingInterval_, velMax_, velMin_, volumeFlowRate_, and volumeInserted_.

◆ InsertionBoundary() [2/2]

InsertionBoundary::InsertionBoundary ( const InsertionBoundary & other )

Copy constructor (with deep copy)

Copy constructor

         : BaseBoundary(other)
 {
     numberOfParticlesInserted_ = other.numberOfParticlesInserted_;
     massInserted_ = other.massInserted_;
     volumeInserted_ = other.volumeInserted_;
     maxFailed_ = other.maxFailed_;
     isActivated_ = other.isActivated_;
     volumeFlowRate_ = other.volumeFlowRate_;
     initialVolume_ = other.initialVolume_;
     samplingInterval_ = other.samplingInterval_;
     variableCumulativeVolumeFlowRate_ = other.variableCumulativeVolumeFlowRate_;
     checkParticleForInteraction_ = other.checkParticleForInteraction_;
     particleSizeDistributionVector_ = other.particleSizeDistributionVector_;
     probability_ = other.probability_;
     velMin_ = other.velMin_;
     velMax_ = other.velMax_;
     isManuallyInserting_ = other.isManuallyInserting_;
     chosenSpecies_ = other.chosenSpecies_;
  
     for (int i = 0; i < other.particleToCopy_.size(); i++)
     {
         particleToCopy_.resize(other.particleToCopy_.size());
         particleToCopy_[i] = other.particleToCopy_[i]->copy();
     }
 }

References checkParticleForInteraction_, chosenSpecies_, i, initialVolume_, isActivated_, isManuallyInserting_, massInserted_, maxFailed_, numberOfParticlesInserted_, particleSizeDistributionVector_, particleToCopy_, probability_, samplingInterval_, variableCumulativeVolumeFlowRate_, velMax_, velMin_, volumeFlowRate_, and volumeInserted_.

◆ ~InsertionBoundary()

InsertionBoundary::~InsertionBoundary ( )

override

Destructor: delete the particle that has to be copied at every insertion.

Destructor that deletes the BaseParticle that is copied and inserted at every insertion.

 {
     for (auto& particleToCopy: particleToCopy_)
     {
         delete particleToCopy;
     }
  
 }

References particleToCopy_.

Member Function Documentation

◆ activate()

void InsertionBoundary::activate ( )

Turns on the InsertionBoundary.

Turns on the InsertionBoundary by setting the boolean to TRUE.

 {
     isActivated_ = true;
 }

References isActivated_.

Referenced by Chutebelt::actionsAfterTimeStep().

◆ checkBoundaryBeforeTimeStep()

void InsertionBoundary::checkBoundaryBeforeTimeStep ( DPMBase * md )

overridevirtual

Fills the boundary with particles.

Is used to fill the insides of the boundary with particles until it is filled up.

Parameters

[in,out] md the problem's DPMBase object

Todo:: rename to something like "insertUntilMaxFailed"?

Todo:: create a definition for zero-size particles. Right now the zero-size particle is only used as a stop criterion for the manual PSD insertion

Reimplemented from BaseBoundary.

Reimplemented in RandomClusterInsertionBoundary.

 {
     logger(VERBOSE, "In InsertionBoundary::checkBoundaryBeforeTimeStep\n");
  
     if (!isActivated_)
     {
         return;
     }
  
     /* Each timestep, the InsertionBoundary attempts to fill up a region with
      * particles.
      *
      * It first calls generateParticle() to get a randomised particle, subject
      * to a specified distribution over sizes and species. (The basic class
      * supports size dispersity only but PolydisperseInsertionBoundary will
      * support species dispersity.) 
      * Then it repeatedly calls placeParticle(), which gives the particle a
      * random location (and possibly velocity) in a specified,
      * geometry-dependent bound. Each time, it checks whether the new particle
      * would have an interaction with another particle or a wall. 
      *
      * If it manages to do that within maxFailed_ tries, then:
      *   * the new particle is inserted, 
      *   * the failure counter is reset, and
      * the processes is repeated with a new generateParticle().
      *
      * Otherwise, the processes terminates for this timestep.
      * */
  
     // Keep count of how many successive times we have failed to place a new
     // particle. 
     unsigned int failed = 0;
     while (failed <= maxFailed_ && insertParticle(md->getNextTime())) // 'generating' loop
     {
         /* Generate random *intrinsic* properties for the new particle. */
         logger(VERBOSE, "about to call generateParticle\n");
  
         //generate a particle the first time
         if (!p0) p0 = generateParticle(md->random);
         // Important for particle generation with a particle size distribution as it generates a particle with zero
         // radius. If a particle is not allowed to be inserted by the PSD criteria it will generate a particle with
         // zero diameter. This if statement prevents inserting particles with zero radius, which would else be a problem.
         if (p0->getRadius() == 0)
         {
             logger(VERBOSE, "The PSD for the specified volume is fully set");
             // free up memory space
             delete p0;
             // out of the 'placing' loop
             failed = maxFailed_ + 1;
             continue;
         }
         logger(VERBOSE, "generated a particle with intrinsics %", p0);
  
         while (true) // 'placing' loop
         {
             /* Generate extrinsic properties (position and velocity) for this
              * new particle. */
             placeParticle(p0, md->random);
             logger(VERBOSE, "attempting to place particle with radius % at %, vel %", p0->getMaxInteractionRadius(), p0->getPosition(), p0->getVelocity());
  
 #ifdef MERCURYDPM_USE_MPI
             /* Communicate the new particle's properties by setHandler (note
                  * that this doesn't actually add the particle to the handler). */
                 if (NUMBER_OF_PROCESSORS > 1)
                 {
                     MPIParticle particle;
                     //  //Every domain generates a particle (to get the species right etc)
  
                     //Send particle data from root to other processors to sync the particle properties
                     if (PROCESSOR_ID == 0)
                     {
                         particle.copyDataFromParticleToMPIParticle(p0);
                     }
  
                     MPIContainer::Instance().broadcast(&particle,MercuryMPIType::PARTICLE);
  
                     //Process the received data
                     if (PROCESSOR_ID != 0)
                     {
                         copyDataFromMPIParticleToParticle(&particle, p0, &(md->particleHandler));
                     }
                 }
 #endif
             p0->setHandler(&md->particleHandler);
             /* Check whether the particle has any interactions. */
             if (!checkParticleForInteraction_ || md->checkParticleForInteraction(*p0))
             {
                 //Note: in parallel only one of the domains will actually add the particle
                 md->particleHandler.copyAndAddObject(p0);
                 failed = 0;
                 
                 ++numberOfParticlesInserted_;
                 const double volume = p0->getVolume();
                 volumeInserted_ += volume;
                 massInserted_ += p0->getSpecies()->getDensity() * volume;
                 logger(VERBOSE, "successfully placed a particle %, with position: % after % fails.", p0,
                        p0->getPosition(), failed);
                 /* JMFT: The generateParticle() routine allocates memory, so we should
                  * free it here. (Don't worry, the particle will have been copied to the
                  * particleHandler by this point iff we want it.) */
                 delete p0;
                 // generate a new particle to be inserted only if the last particle could be successfully places
                 p0 = generateParticle(md->random);
                 break; // out of the 'placing' loop
             }
             else
             {
                 failed++;
                 logger(VERBOSE, "failed to place a particle; have failed % times", failed);
             }
  
             if (failed > maxFailed_)
             {
                 logger(VERBOSE, "failed too many times; giving up");
                 if (isManuallyInserting_)
                 {
                     particleSizeDistributionVector_[chosenSpecies_].decrementNParticlesPerClass();
                     particleSizeDistributionVector_[chosenSpecies_].decrementVolumePerClass(p0->getVolume());
                 }
                 break; // out of the 'placing' loop (and will leave the 'generating' loop too
             }
         }
         logger(VERBOSE, "failed % times, so breaking out of InsertionBoundary loop for this timestep.", failed);
     }
     // logger(INFO, "volumeInserted_ = %", volumeInserted_);
 }

References MPIContainer::broadcast(), checkParticleForInteraction_, chosenSpecies_, copyDataFromMPIParticleToParticle(), MPISphericalParticle::copyDataFromParticleToMPIParticle(), generateParticle(), ParticleSpecies::getDensity(), BaseParticle::getMaxInteractionRadius(), BaseInteractable::getPosition(), BaseParticle::getRadius(), BaseInteractable::getSpecies(), BaseInteractable::getVelocity(), BaseParticle::getVolume(), insertParticle(), MPIContainer::Instance(), isActivated_, isManuallyInserting_, logger, massInserted_, maxFailed_, md, NUMBER_OF_PROCESSORS, numberOfParticlesInserted_, p0, PARTICLE, particleSizeDistributionVector_, placeParticle(), PROCESSOR_ID, BaseParticle::setHandler(), VERBOSE, and volumeInserted_.

Referenced by GranuDrum::GranuDrum(), GranuHeap::GranuHeap(), insertParticles(), main(), FreeCooling2DinWalls::setupInitialConditions(), StressStrainControl::setupInitialConditions(), and ConstantMassFlowMaserSelfTest::setupInitialConditions().

◆ deactivate()

void InsertionBoundary::deactivate ( )

Turns off the InsertionBoundary.

Turns off the InsertionBoundary by setting the boolean to FALSE.

 {
     isActivated_ = false;
 }

References isActivated_.

Referenced by Chutebelt::actionsAfterTimeStep(), and Chutebelt::setupInitialConditions().

◆ generateParticle()

BaseParticle * InsertionBoundary::generateParticle ( RNG & random )

virtual

Sets the properties of the InsertionBoundary for a single particle type ‍/ virtual void set(BaseParticle* particleToCopy, unsigned int maxFailed, Vec3D velMin, Vec3D velMax, double radMin, double radMax)=0;.

     \brief Sets the properties of the InsertionBoundary for mutliple different particle types
    &zwj;/

virtual void set(std::vector<BaseParticle*> particleToCopy, unsigned int maxFailed, Vec3D velMin, Vec3D velMax, double radMin, double radMax)=0;

/*!

/*!
   \brief Virtual function that generates the intrinsic properties
   (species, radius) of one particle.
   \param[in] random  Random number generator

The default behaviour will be to return particleToCopy_, but this can be overridden by the children (to get size or species dispersity).

Reimplemented in PolydisperseInsertionBoundary, BidisperseCubeInsertionBoundary, and FixedClusterInsertionBoundary.

 {
     double check = random.getRandomNumber(0, 1);
     for (int i = 0; i < probability_.size(); i++)
     {
         if (check < probability_[i])
         {
             chosenSpecies_ = i;
             break;
         }
         else
         {
             check -= probability_[i];
         }
     }
     BaseParticle* P = particleToCopy_[chosenSpecies_]->copy();
     if (particleSizeDistributionVector_[chosenSpecies_].getParticleSizeDistribution().empty())
     {
         particleSizeDistributionVector_[chosenSpecies_].setDistributionUniform(P->getRadius(), P->getRadius(), 50);
         logger(INFO, "Assembling a discrete uniform particle size distribution (50 bins) with the radius set for the "
                      "InsertionBoundary.");
     }
     // manual insertion routine to insert PSDs as accurate as possible into a given volume
     if (isManuallyInserting_)
     {
         logger.assert_debug(initialVolume_ > 0.0, "Use setInitialVolume to define the particle insertion volume");
         Mdouble radius;
         // getVolumeFlowRate() * time + initialVolume_ - volumeInserted_ lead to more inaccurate results, therfore
         // -volumeInserted was removed.
         radius = particleSizeDistributionVector_[chosenSpecies_].insertManuallyByVolume(getVolumeFlowRate() *
                                                                                        getHandler()->getDPMBase()->getTime() +
                                                                                        initialVolume_);
         P->setRadius(radius);
         return P;
     }
     Mdouble radius;
     radius = particleSizeDistributionVector_[chosenSpecies_].drawSample();
     P->setRadius(radius);
     return P;
 }

References check(), chosenSpecies_, BaseBoundary::getHandler(), RNG::getRandomNumber(), getVolumeFlowRate(), i, INFO, initialVolume_, isManuallyInserting_, logger, Global_Physical_Variables::P, particleSizeDistributionVector_, particleToCopy_, probability_, and UniformPSDSelfTest::radius.

Referenced by checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ getCheckParticleForInteraction()

bool InsertionBoundary::getCheckParticleForInteraction ( ) const

Gets the variable that checks if a particle has an interaction.

Gets the variable that checks if a particle has an interaction with a wall or another particle.

Returns: if TRUE the particle has an interaction and if FALSE the particle has no interaction.

 {
     return checkParticleForInteraction_;
 }

References checkParticleForInteraction_.

◆ getInitialVolume()

Mdouble InsertionBoundary::getInitialVolume ( ) const

Gets the initialVolume() .

Gets the volume to be inserted by the insertion routine.

Returns: A double which corresponds to volume to be inserted by the insertion routines

 {
     return initialVolume_;
 }

References initialVolume_.

Referenced by NozzleDemo::actionsAfterTimeStep(), RotatingDrumBidisperseInitialise::actionsAfterTimeStep(), Chutebelt::actionsAfterTimeStep(), NozzleSelfTest::actionsAfterTimeStep(), and RotatingDrumBidisperseInitialise::RotatingDrumBidisperseInitialise().

◆ getMassOfParticlesInserted()

Mdouble InsertionBoundary::getMassOfParticlesInserted ( ) const

Gets the mass of particles inserted by the boundary.

Returns the mass of particles inserted in the boundary

Returns: the mass of particles inserted

 {
     return massInserted_;
 }

References massInserted_.

Referenced by RotatingDrumBidisperseInitialise::actionsAfterTimeStep(), Chutebelt::actionsAfterTimeStep(), BoundariesSelfTest::actionsAfterTimeStep(), and FluxBoundarySelfTest::actionsAfterTimeStep().

◆ getMaxFailed()

unsigned int InsertionBoundary::getMaxFailed ( ) const

Gets the number of times that the boundary may fail to insert a particle.

Return maxFailed_ (see InsertionBoundary::set).

Returns: the maximum number of particle insertion trials

 {
     return maxFailed_;
 }

References maxFailed_.

◆ getNumberOfParticlesInserted()

unsigned int InsertionBoundary::getNumberOfParticlesInserted ( ) const

Gets the number of particles inserted by the boundary.

Returns the number of particles inserted in the boundary

Returns: the number of particles inserted

 {
     return numberOfParticlesInserted_;
 }

References numberOfParticlesInserted_.

Referenced by T_protectiveWall::actionsAfterTimeStep(), BoundariesSelfTest::actionsAfterTimeStep(), FluxBoundarySelfTest::actionsAfterTimeStep(), insertParticles(), RotatingDrumBidisperseInitialise::printTime(), and Chute::write().

◆ getParticleToCopy()

std::vector< BaseParticle * > InsertionBoundary::getParticleToCopy ( )

Gets the particles that will be inserted through the insertion boundary.

returns pointer to the particle copies which are to be inserted

 {
     if (particleToCopy_.empty())
     {
         logger(ERROR, "particleToCopy not set");
     }
     return particleToCopy_;
 }

References ERROR, logger, and particleToCopy_.

◆ getPSD()

std::vector< PSD > InsertionBoundary::getPSD ( )

Gets the particle size distributions set by the user.

gets the user defined particle size distributions

Returns: a vector of PSD class objects containing containing the differnt user defined particle size distributions

 {
     return particleSizeDistributionVector_;
 }

References particleSizeDistributionVector_.

◆ getVolumeFlowRate()

Mdouble InsertionBoundary::getVolumeFlowRate ( ) const

Gets the volume flow rate of the insertion routine.

Gets the volumetric flow rate of the insertion routine.

Returns: A double which corresponds to the flow rate of the insertion routine

 {
     return volumeFlowRate_;
 }

References volumeFlowRate_.

Referenced by generateParticle(), and insertParticle().

◆ getVolumeOfParticlesInserted()

Mdouble InsertionBoundary::getVolumeOfParticlesInserted ( ) const

Gets the volume of particles inserted by the boundary.

Returns the volume of particles inserted in the boundary

Returns: the volume of particles inserted

 {
     return volumeInserted_;
 }

References volumeInserted_.

Referenced by T_protectiveWall::actionsAfterTimeStep(), NozzleDemo::actionsAfterTimeStep(), RotatingDrumBidisperseInitialise::actionsAfterTimeStep(), BoundariesSelfTest::actionsAfterTimeStep(), FluxBoundarySelfTest::actionsAfterTimeStep(), NozzleSelfTest::actionsAfterTimeStep(), protectiveWall::actionsAfterTimeStep(), and GranuHeap::GranuHeap().

◆ insertParticle()

bool InsertionBoundary::insertParticle ( Mdouble time )

Checks the inserted total volume and returns if a particle is still allowed to be inserted.

Checks the inserted total volume by the flowrate and initialVolume and returns if a particle is allowed to be inserted.

Returns: TRUE if the inserted volume is lower than the total volume and FALSE if the inserted volume is higher than the total volume.

 {
     // check if the flow rate limit has been reached
     if (variableCumulativeVolumeFlowRate_.empty())
     {
         return volumeInserted_ < getVolumeFlowRate() * time + initialVolume_;
     }
     else
     {
         const Mdouble iMax = (Mdouble) variableCumulativeVolumeFlowRate_.size() - 2;
         const Mdouble i = std::min(time / samplingInterval_, iMax);
         if (i == iMax)
         {
             static unsigned count = 0;
             if (count == 0)
             {
                 logger(WARN, "Reached end of volume flowrate function");
             }
             ++count;
         }
         const size_t id = i;
         const Mdouble allowedVolume = variableCumulativeVolumeFlowRate_[id] +
                 (variableCumulativeVolumeFlowRate_[id + 1] -
                         variableCumulativeVolumeFlowRate_[id]) * (i - id);
         return volumeInserted_ < allowedVolume;
     }
 }

References getVolumeFlowRate(), i, initialVolume_, logger, min, samplingInterval_, variableCumulativeVolumeFlowRate_, volumeInserted_, and WARN.

Referenced by checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ insertParticles()

void InsertionBoundary::insertParticles ( DPMBase * md )

Fill a certain domain with particles.

\detail calls the function checkBoundaryBeforeTimeStep() to fill a domain with particles; also reports how many particles where inserted at the end of the routine.

 {
     checkBoundaryBeforeTimeStep(md);
     logger(INFO, "Inserted % particles", getNumberOfParticlesInserted());
 }

References checkBoundaryBeforeTimeStep(), getNumberOfParticlesInserted(), INFO, logger, and md.

Referenced by RotatingDrumWet::setupInitialConditions().

◆ isActivated()

bool InsertionBoundary::isActivated ( )

Returns whether the InsertionBoundary is activated.

checks the activation status of the InsertionBoundary by checking the respective boolean variable.

Returns: TRUE for an activated InsertionBoundary and FALSE for a deactivated InsertionBoundary

 {
     return isActivated_;
 }

References isActivated_.

◆ placeParticle()

virtual void InsertionBoundary::placeParticle	(	BaseParticle *	p,
		RNG &	random
	)

pure virtual

Purely virtual function that generates the extrinsic properties (position, velocity) of a particle.

Parameters

[in]	p	The particle to be placed
[in]	random	Random number generator

This should be implemented by the children such as CubeInsertionBoundary, as the implementation will be geometry-dependent.

Implemented in SphereInsertionBoundary, RandomClusterInsertionBoundary, PolydisperseInsertionBoundary, HopperInsertionBoundary, CylinderInsertionBoundary, CubeInsertionBoundary, ChuteInsertionBoundary, BaseClusterInsertionBoundary, and FixedClusterInsertionBoundary.

Referenced by checkBoundaryBeforeTimeStep().

◆ read()

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

overridevirtual

Reads the boundary's id_ and maxFailed_.

reads the boundary's id_ and maxFailed_ from the given istream

Parameters

[in,out] is stream the data members are read from

Todo:: make theses reads non-optional

Implements BaseBoundary.

Reimplemented in SphereInsertionBoundary, and PolydisperseInsertionBoundary.

 {
     BaseBoundary::read(is);
     std::string dummy, type;
     is >> dummy >> maxFailed_ >> dummy;
     if (dummy == "volumeFlowRate")
     {
         is >> volumeFlowRate_ >> dummy;
     }
     is >> massInserted_;
     is >> dummy >> volumeInserted_;
     is >> dummy >> numberOfParticlesInserted_;
     is >> dummy >> isActivated_;
     size_t psdVectorSize;
     is >> dummy >> psdVectorSize;
     particleSizeDistributionVector_.clear();
     particleSizeDistributionVector_.resize(psdVectorSize);
     for (auto& particleSizeDistributionVector: particleSizeDistributionVector_)
     {
         size_t psdSize;
         DistributionElements radiusAndProbability{};
         std::vector<DistributionElements> particleSizeDistribution{};
         is >> dummy >> psdSize;
         particleSizeDistribution.clear();
         particleSizeDistribution.reserve(psdSize);
         for (size_t i = 0; i < psdSize; i++)
         {
             is >> radiusAndProbability.internalVariable;
             is >> radiusAndProbability.probability;
             particleSizeDistribution.push_back(radiusAndProbability);
         }
         particleSizeDistributionVector.setPSDFromVector(particleSizeDistribution, PSD::TYPE::CUMULATIVE_NUMBER_DISTRIBUTION);
     }
     if (psdVectorSize > 1)
     {
         is >> dummy;
         Mdouble psdRatio;
         probability_.clear();
         probability_.reserve(psdVectorSize);
         for (size_t i = 0; i < psdVectorSize; i++)
         {
             is >> psdRatio;
             probability_.push_back(psdRatio);
         }
     }
  
     helpers::readOptionalVariable(is, "checkParticleForInteraction", checkParticleForInteraction_);
     helpers::readOptionalVariable(is, "initialVolume", initialVolume_);
     if (helpers::readOptionalVariable(is, "samplingInterval", samplingInterval_))
     {
         size_t n;
         Mdouble flowRate;
         is >> dummy >> n;
         //variableCumulativeVolumeFlowRate_.clear();
         variableCumulativeVolumeFlowRate_.reserve(n);
         for (size_t i = 0; i < n; ++i)
         {
             is >> flowRate;
             variableCumulativeVolumeFlowRate_.push_back(flowRate);
         }
     }
     is >> dummy;
     if (dummy != "noParticleToCopy")
     {
         size_t particleToCopySize;
         for (auto& particleToCopy: particleToCopy_)
         {
             delete particleToCopy;
         }
         is >> particleToCopySize;
         particleToCopy_.resize(particleToCopySize);
         for (auto& particleToCopy: particleToCopy_)
         {
             particleToCopy = getHandler()->getDPMBase()->particleHandler.readAndCreateObject(is);
             // The .restart file records the index of the particle's species, but
             // doesn't record the pointer, i.e. the memory address of the species within
             // the speciesHandler. The latter needs to be reset now.
             particleToCopy->setSpecies(getHandler()->getDPMBase()->speciesHandler.getObject(
                     particleToCopy->getIndSpecies()));
         }
     }
 }

References checkParticleForInteraction_, PSD::CUMULATIVE_NUMBER_DISTRIBUTION, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BaseHandler< T >::getObject(), i, initialVolume_, DistributionElements::internalVariable, isActivated_, massInserted_, maxFailed_, n, numberOfParticlesInserted_, DPMBase::particleHandler, particleSizeDistributionVector_, particleToCopy_, probability_, BaseBoundary::read(), ParticleHandler::readAndCreateObject(), helpers::readOptionalVariable(), samplingInterval_, BaseParticle::setSpecies(), oomph::Global_string_for_annotation::string(), compute_granudrum_aor::type, variableCumulativeVolumeFlowRate_, volumeFlowRate_, and volumeInserted_.

Referenced by BaseClusterInsertionBoundary::read(), ChuteInsertionBoundary::read(), CubeInsertionBoundary::read(), CylinderInsertionBoundary::read(), HopperInsertionBoundary::read(), PolydisperseInsertionBoundary::read(), and SphereInsertionBoundary::read().

◆ reset()

void InsertionBoundary::reset ( )

resets particle property counter variables.

set all particle property counter variables to zero. reset() does not activate or deactivate the InsertionBoundary.

 {
     numberOfParticlesInserted_ = 0;
     massInserted_ = 0;
     volumeInserted_ = 0;
 }

References massInserted_, numberOfParticlesInserted_, and volumeInserted_.

◆ rotateBoundary()

void InsertionBoundary::rotateBoundary ( Vec3D angle )

virtual

virtual function that rotates the boundary.

Parameters

[in] angle The angles by which the boundary should be rotated.

This should be implemented by the children such as CylinderInsertionBoundary, as the implementation will be geometry-dependent.

Reimplemented in CylinderInsertionBoundary.

 {
  
 }

◆ setCheckParticleForInteraction()

void InsertionBoundary::setCheckParticleForInteraction ( bool checkParticleForInteraction )

Sets the variable that checks if a particle has an interaction.

Sets the distribution type from the Distribution class.

Parameters

[in] checkParticleForInteraction boolean which determines if a particle has an interaction.

 {
     checkParticleForInteraction_ = checkParticleForInteraction;
 }

References checkParticleForInteraction_.

Referenced by GranuDrum::GranuDrum().

◆ setInitialVolume()

void InsertionBoundary::setInitialVolume ( Mdouble initialVolume )

Gets the Volume which should be inserted by the insertion routine.

Sets the volume to be inserted by the insertion routine. (Total volume to insert = getVolumeFlowRate() * time + initialVolume_)

 {
     initialVolume_ = initialVolume;
     if (!std::isfinite(volumeFlowRate_))
     {
         volumeFlowRate_ = 0;
     }
 }

References initialVolume_, isfinite, and volumeFlowRate_.

◆ setManualInsertion()

void InsertionBoundary::setManualInsertion ( bool isManuallyInserting )

Set the flag for a manual PSD insertion routine.

sets the isManuallyInserting_ to TRUE, resulting in a top-down class-by-class insertion routine to insert PSDs as accurate as possible.

 {
     isManuallyInserting_ = isManuallyInserting;
 }

References isManuallyInserting_.

Referenced by PSDManualInsertionSelfTest::setupInitialConditions().

◆ setParticleToCopy() [1/2]

void InsertionBoundary::setParticleToCopy ( BaseParticle * particleToCopy )

Sets the particle that will be inserted through the insertion boundary.

Sets the vector of pointers to particles which will be inserted by the insertion boundary.

Parameters

[in] particleToCopy pointer to the particle to be inserted

 {
     if (particleToCopy == nullptr)
     {
         logger(ERROR, "Setting particleToCopy to be a null pointer?");
     }
     else
     {
         if (!particleToCopy_.empty())
         {
             for (auto& particleToCopy: particleToCopy_)
             {
                 delete particleToCopy;
             }
         }
         particleToCopy_.resize(1);
         particleToCopy_[0] = particleToCopy->copy();
     }
 }

References BaseParticle::copy(), ERROR, logger, and particleToCopy_.

◆ setParticleToCopy() [2/2]

void InsertionBoundary::setParticleToCopy ( std::vector< BaseParticle * > particleToCopy )

Sets multiple different particles that will be inserted through the insertion boundary.

Sets the vector of pointers to particles which will be inserted by the insertion boundary. This is mainly used to insert particles with different intrinsic properties (such as PSD, mechanical properties, etc.)

Parameters

[in] particleToCopy vector of pointers to the particles which are to be inserted

 {
     if (particleToCopy.empty())
     {
         logger(ERROR, "Setting particleToCopy to be empty?");
     }
     if (!particleToCopy_.empty())
     {
         for (auto& ParticleToCopy: particleToCopy_)
         {
             delete ParticleToCopy;
         }
     }
     for (int i = 0; i < particleToCopy.size(); i++)
     {
         particleToCopy_.resize(particleToCopy.size());
         particleToCopy_[i] = particleToCopy[i]->copy();
     }
 }

References ERROR, i, logger, and particleToCopy_.

Referenced by RandomClusterInsertionBoundary::set(), FixedClusterInsertionBoundary::set(), HopperInsertionBoundary::set(), CylinderInsertionBoundary::set(), SphereInsertionBoundary::set(), ChuteInsertionBoundary::set(), and CubeInsertionBoundary::set().

◆ setPSD() [1/2]

void InsertionBoundary::setPSD ( const PSD psd )

Sets the range of particle radii that may be generated from a user defined PSD.

Sets the range of particle radii that may be generated to a PSD defined by the user.

Todo:: TP: Consider std::move instead of a set function. This would result in a speedup + no one has to set the PSD for insertionBoundaries again as it is set when a PSD is inserted.

 {
     particleSizeDistributionVector_.resize(1);
     particleSizeDistributionVector_[0] = psd;
 }

References particleSizeDistributionVector_.

◆ setPSD() [2/2]

void InsertionBoundary::setPSD	(	std::vector< PSD >	psd,
		std::vector< Mdouble >	psdRatio
	)

Sets the ranges of particle radii that may be generated from user defined PSDs.

Sets the ranges of particle radii that may be generated by different PSDs defined by the user.

Todo:: TP: Consider std::move instead of a set function. This would result in a speedup + no one has to set the PSD for insertionBoundaries again as it is set when a PSD is inserted.

 {
     particleSizeDistributionVector_.resize(psd.size());
     particleSizeDistributionVector_ = psd;
  
     // check whether the distribution is normalised
     double cumRatio = std::accumulate(psdRatio.begin(), psdRatio.end(), 0.0);
     if (fabs(cumRatio-1.0)>1e-2) {
         logger(INFO, "PSD probabilities add up to %, not 1. Hence, they will be normalised.");
     }
     for (auto& ratio : psdRatio ) {
         ratio /= cumRatio;
     }
  
     probability_.resize(psdRatio.size());
     probability_ = psdRatio;
  
 }

References e(), boost::multiprecision::fabs(), INFO, logger, particleSizeDistributionVector_, and probability_.

◆ setVariableVolumeFlowRate()

void InsertionBoundary::setVariableVolumeFlowRate	(	const std::vector< Mdouble > &	variableCumulativeVolumeFlowRate,
		Mdouble	samplingInterval
	)

Sets a variable volume flow rate.

See also: variableCumulativeVolumeFlowRate_

Sets a variable volume flow rate taken at fixed sampling intervals; the values are cumulative; thus, we need to ensure the volume inserted before time t=n*samplingInterval is less than variableCumulativeVolumeFlowRate[n].

See also: variableCumulativeVolumeFlowRate_

 {
     logger.assert_debug(samplingInterval > 0, "sampling interval needs to be positive");
     const Mdouble endTime = variableCumulativeVolumeFlowRate.size() * samplingInterval;
     logger(INFO, "variable flowrate is defined up to %", endTime);
     logger.assert_always(getHandler()->getDPMBase()->getTimeMax() < endTime,
                          "variable flowrate is defined up to %, but tMax is set to %", endTime,
                          getHandler()->getDPMBase()->getTimeMax());
     variableCumulativeVolumeFlowRate_ = variableCumulativeVolumeFlowRate;
     samplingInterval_ = samplingInterval;
 }

References BaseBoundary::getHandler(), INFO, logger, samplingInterval_, and variableCumulativeVolumeFlowRate_.

◆ setVolumeFlowRate()

void InsertionBoundary::setVolumeFlowRate ( Mdouble volumeFlowRate )

Sets the volume flow rate of the insertion routine.

Sets the volumetric flow rate of the insertion routine.

 {
     volumeFlowRate_ = volumeFlowRate;
 }

References volumeFlowRate_.

◆ shiftBoundary()

void InsertionBoundary::shiftBoundary ( Vec3D shift )

virtual

virtual function that shifts the boundary.

Parameters

[in] shift The amount by which the boundary should be shifted.

This should be implemented by the children such as CylinderInsertionBoundary, as the implementation will be geometry-dependent.

Reimplemented in SphereInsertionBoundary, and CylinderInsertionBoundary.

 {
  
 }

◆ write()

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

overridevirtual

Writes the boundary's id_ and maxFailed_.

adds the boundary's id_ and maxFailed_ to the given ostream

Parameters

[in,out] is stream the data members are to be added to

Implements BaseBoundary.

Reimplemented in SphereInsertionBoundary, and PolydisperseInsertionBoundary.

 {
     logger(VERBOSE, "In InsertionBoundary::write\n");
     BaseBoundary::write(os);
     os << " maxFailed " << maxFailed_;
     if (std::isfinite(volumeFlowRate_))
         os << " volumeFlowRate " << volumeFlowRate_;
     os << " massInserted " << massInserted_;
     os << " volumeInserted " << volumeInserted_;
     os << " numberOfParticlesInserted " << numberOfParticlesInserted_;
     os << " isActivated " << isActivated_;
     os << " psdCount " << particleSizeDistributionVector_.size();
     for (auto& particleSizeDistribution: particleSizeDistributionVector_)
     {
         os << " psd " << particleSizeDistribution.getParticleSizeDistribution().size();
         for (auto p: particleSizeDistribution.getParticleSizeDistribution())
         {
             os << " " << p.internalVariable
                << " " << p.probability;
         }
     }
     if (!probability_.empty())
     {
         os << " psdRatio";
         for (auto& psdRatio: probability_)
         {
             os << " " << psdRatio;
         }
     }
     if (!checkParticleForInteraction_)
     {
         os << " checkParticleForInteraction " << checkParticleForInteraction_;
     }
     os << " initialVolume " << initialVolume_;
     os << " samplingInterval " << samplingInterval_;
     os << " variableCumulativeVolumeFlowRate " << variableCumulativeVolumeFlowRate_.size();
     for (const auto flowRate: variableCumulativeVolumeFlowRate_)
     {
         os << ' ' << flowRate;
     }
     if (!particleToCopy_.empty())
     {
         os << " particleToCopy " << particleToCopy_.size();
         for (auto& particleToCopy: particleToCopy_)
         {
             os << " " << *particleToCopy;
         }
     }
     else
     {
         os << " noParticleToCopy";
     }
 }

References checkParticleForInteraction_, initialVolume_, isActivated_, isfinite, logger, massInserted_, maxFailed_, numberOfParticlesInserted_, p, particleSizeDistributionVector_, particleToCopy_, probability_, samplingInterval_, variableCumulativeVolumeFlowRate_, VERBOSE, volumeFlowRate_, volumeInserted_, and BaseBoundary::write().

Referenced by BaseClusterInsertionBoundary::write(), ChuteInsertionBoundary::write(), CubeInsertionBoundary::write(), CylinderInsertionBoundary::write(), HopperInsertionBoundary::write(), PolydisperseInsertionBoundary::write(), and SphereInsertionBoundary::write().

Member Data Documentation

◆ checkParticleForInteraction_

bool InsertionBoundary::checkParticleForInteraction_

Checks if a particle has an interaction with a wall or other particles.

Referenced by checkBoundaryBeforeTimeStep(), getCheckParticleForInteraction(), InsertionBoundary(), read(), setCheckParticleForInteraction(), and write().

◆ chosenSpecies_

int InsertionBoundary::chosenSpecies_

stores the chosen species for each timestep.

Referenced by checkBoundaryBeforeTimeStep(), generateParticle(), and InsertionBoundary().

◆ initialVolume_

Mdouble InsertionBoundary::initialVolume_

See also: volumeFlowRate_

Referenced by generateParticle(), getInitialVolume(), InsertionBoundary(), insertParticle(), read(), setInitialVolume(), and write().

◆ isActivated_

bool InsertionBoundary::isActivated_

The InsertionBoundary is activated by default. If the InsertionBoundary is deactivated, then it introduces no particles (useful for trying to maintain a certain insertion rate).

Todo:: JMFT: This is currently not saved to .restart files.

Referenced by activate(), FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), deactivate(), InsertionBoundary(), isActivated(), read(), and write().

◆ isManuallyInserting_

bool InsertionBoundary::isManuallyInserting_

A flag to enable a top-down class-by-class manual insertion of a PSD; default is FALSE.

Referenced by checkBoundaryBeforeTimeStep(), generateParticle(), InsertionBoundary(), and setManualInsertion().

◆ massInserted_

Mdouble InsertionBoundary::massInserted_

Total mass of particles inserted.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), getMassOfParticlesInserted(), InsertionBoundary(), read(), reset(), and write().

◆ maxFailed_

unsigned int InsertionBoundary::maxFailed_

Number of times that the wall may fail to insert a particle.

Referenced by checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), getMaxFailed(), InsertionBoundary(), read(), RandomClusterInsertionBoundary::set(), HopperInsertionBoundary::set(), CylinderInsertionBoundary::set(), SphereInsertionBoundary::set(), ChuteInsertionBoundary::set(), CubeInsertionBoundary::set(), PolydisperseInsertionBoundary::setGeometry(), and write().

◆ numberOfParticlesInserted_

unsigned int InsertionBoundary::numberOfParticlesInserted_

Number of particles that are already inserted.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), getNumberOfParticlesInserted(), InsertionBoundary(), read(), reset(), and write().

◆ p0

BaseParticle* InsertionBoundary::p0 = nullptr

pointer to the next particle that should be inserted (needs to be stored across time steps).

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), checkBoundaryBeforeTimeStep(), and RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep().

◆ particleSizeDistributionVector_

std::vector<PSD> InsertionBoundary::particleSizeDistributionVector_

Defines a particle size distribution as an object of the PSD class; if particleSizeDistributionVector_ is empty, distribution_ is used instead.

Referenced by checkBoundaryBeforeTimeStep(), generateParticle(), getPSD(), InsertionBoundary(), read(), setPSD(), and write().

◆ particleToCopy_

std::vector<BaseParticle*> InsertionBoundary::particleToCopy_

read Distribution class from file. ‍/ friend std::istream& operator>>(std::istream& is, InsertionBoundary::Distribution& type);

     \brief write Distribution class to file.
    &zwj;/

friend std::ostream& operator<<(std::ostream& os, InsertionBoundary::Distribution type);

/*!

protected:

/*!
   \brief Particle that will be inserted through the insertion boundary.

Referenced by generateParticle(), FixedClusterInsertionBoundary::generateParticle(), getParticleToCopy(), InsertionBoundary(), read(), setParticleToCopy(), write(), and ~InsertionBoundary().

◆ probability_

std::vector<Mdouble> InsertionBoundary::probability_

vector of probabilities in range [0,1] which determine the mixing ratio of partice size distributions.

Referenced by generateParticle(), InsertionBoundary(), read(), setPSD(), and write().

◆ samplingInterval_

Mdouble InsertionBoundary::samplingInterval_

See also: variableCumulativeVolumeFlowRate_

Referenced by InsertionBoundary(), insertParticle(), read(), setVariableVolumeFlowRate(), and write().

◆ variableCumulativeVolumeFlowRate_

std::vector<Mdouble> InsertionBoundary::variableCumulativeVolumeFlowRate_

Defines a variable volume flow rate, taken at fixed sampling intervals; the values are cumulative; thus, we need to ensure the volume inserted before time t=n*samplingInterval is less than variableCumulativeVolumeFlowRate[n].

By default, this vector is empty; in that case, a constant volume flow rate will be used.

See also: volumeFlowRate_.

Referenced by InsertionBoundary(), insertParticle(), read(), setVariableVolumeFlowRate(), and write().

◆ velMax_

Vec3D InsertionBoundary::velMax_

Referenced by BidisperseCubeInsertionBoundary::generateParticle(), InsertionBoundary(), CubeInsertionBoundary::placeParticle(), CylinderInsertionBoundary::placeParticle(), SphereInsertionBoundary::placeParticle(), CubeInsertionBoundary::read(), CylinderInsertionBoundary::read(), SphereInsertionBoundary::read(), CylinderInsertionBoundary::set(), SphereInsertionBoundary::set(), CubeInsertionBoundary::set(), CubeInsertionBoundary::write(), CylinderInsertionBoundary::write(), and SphereInsertionBoundary::write().

◆ velMin_

Vec3D InsertionBoundary::velMin_

Minimum and maximum velocity of the particles to be inserted.

Referenced by BidisperseCubeInsertionBoundary::generateParticle(), InsertionBoundary(), CubeInsertionBoundary::placeParticle(), CylinderInsertionBoundary::placeParticle(), SphereInsertionBoundary::placeParticle(), CubeInsertionBoundary::read(), CylinderInsertionBoundary::read(), SphereInsertionBoundary::read(), CylinderInsertionBoundary::set(), SphereInsertionBoundary::set(), CubeInsertionBoundary::set(), CubeInsertionBoundary::write(), CylinderInsertionBoundary::write(), and SphereInsertionBoundary::write().

◆ volumeFlowRate_

Mdouble InsertionBoundary::volumeFlowRate_

The inflow can be controlled by setting a volume flow rate and an initial volume thus, this ensures the volume V inserted before time t is less than V = initialVolume_+volumeFlowRate_*t

The default value is volumeFlowRate_=inf, i.e. the volume is not controlled.

See also: To set a variable flow rate instead, see variableCumulativeVolumeFlowRate_.

Referenced by getVolumeFlowRate(), InsertionBoundary(), read(), setInitialVolume(), setVolumeFlowRate(), and write().

◆ volumeInserted_

Mdouble InsertionBoundary::volumeInserted_

Total volume of particles inserted.

Referenced by FixedClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), checkBoundaryBeforeTimeStep(), RandomClusterInsertionBoundary::checkBoundaryBeforeTimeStep(), getVolumeOfParticlesInserted(), InsertionBoundary(), insertParticle(), read(), reset(), and write().

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

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InsertionBoundary() [1/2]

◆ InsertionBoundary() [2/2]

◆ ~InsertionBoundary()

Member Function Documentation

◆ activate()

◆ checkBoundaryBeforeTimeStep()

◆ deactivate()

◆ generateParticle()

◆ getCheckParticleForInteraction()

◆ getInitialVolume()

◆ getMassOfParticlesInserted()

◆ getMaxFailed()

◆ getNumberOfParticlesInserted()

◆ getParticleToCopy()

◆ getPSD()

◆ getVolumeFlowRate()

◆ getVolumeOfParticlesInserted()

◆ insertParticle()

◆ insertParticles()

◆ isActivated()

◆ placeParticle()

◆ read()

◆ reset()

◆ rotateBoundary()

◆ setCheckParticleForInteraction()

◆ setInitialVolume()

◆ setManualInsertion()

◆ setParticleToCopy() [1/2]

◆ setParticleToCopy() [2/2]

◆ setPSD() [1/2]

◆ setPSD() [2/2]

◆ setVariableVolumeFlowRate()

◆ setVolumeFlowRate()

◆ shiftBoundary()

◆ write()

Member Data Documentation

◆ checkParticleForInteraction_

◆ chosenSpecies_

◆ initialVolume_

◆ isActivated_

◆ isManuallyInserting_

◆ massInserted_

◆ maxFailed_

◆ numberOfParticlesInserted_

◆ p0

◆ particleSizeDistributionVector_

◆ particleToCopy_

◆ probability_

◆ samplingInterval_

◆ variableCumulativeVolumeFlowRate_

◆ velMax_

◆ velMin_

◆ volumeFlowRate_

◆ volumeInserted_