DropletBoundary Class Reference

Supplies a 'constant heat flux' to a cuboidal region (specified by two corner points) by adding a random velocity at each time step to each particle therein, increasing the granular temperature (velocity variance). More...

#include <DropletBoundary.h>

Inheritance diagram for DropletBoundary:

Classes
struct	Droplet

Public Member Functions
	DropletBoundary ()
	DropletBoundary (const DropletBoundary &other)
	~DropletBoundary () override
DropletBoundary *	copy () const override
	Used to create a copy of the object NB: purely virtual function. More...
std::string	getName () const override
	A purely virtual function. More...
void	checkBoundaryAfterParticlesMove (ParticleHandler &pH) override
	Runs at the end of each time step. More...
void	read (std::istream &is) override
	Reads some boundary properties from an std::istream. More...
void	write (std::ostream &os) const override
	Writes the boundary properties to an std::ostream. More...
void	setGenerateDroplets (std::function< void(DropletBoundary &)> generateDroplets)
void	setRemoveDroplets (std::function< bool(const Droplet &)> removeDroplets)
void	writeVTK (std::fstream &file) override
void	setRemoveDropletsAtWalls (bool removeDroplets)
void	setDropletSpecies (const ParticleSpecies *species)
void	setDropletTemperature (double temperature)
void	actionsBeforeTimeLoop () override
	Virtual function that does something after DPMBase::setupInitialConditions but before the first time step. More...
void	addDroplet (const Vec3D &position, const Vec3D &velocity, double radius)
void	addDroplet (const Vec3D &position, const Vec3D &velocity, double radius, double liquidVolume)
std::vector< Droplet > &	getDroplets ()
double	getDropletVolume () const
double	getAbsorbedVolume () const
double	getLostVolume () const
double	getTotalInsertedVolume () const
void	setLiquidFilmVolumeMaxFraction (double volumeFraction)
	Sets the fraction of the particle volume that indicates the maximum amount of liquid a particle may hold. More...
void	setLiquidFilmVolumeMaxFractionFromRadiusFraction (double radiusFraction)
	Sets the fraction of the particle volume that indicates the maximum amount of liquid a particle may hold, based on a liquid film thickness specified by a fraction of the particle radius. More...
Public Member Functions inherited from BaseBoundary
	BaseBoundary ()
	default constructor. More...
	BaseBoundary (const BaseBoundary &b)
	copy constructor More...
	~BaseBoundary () override
	destructor More...
virtual void	createPeriodicParticle (BaseParticle *p UNUSED, ParticleHandler &pH UNUSED)
	Creates a periodic particle in case of periodic boundaries in serial build. More...
virtual void	createPeriodicParticles (ParticleHandler &pH UNUSED)
	Creates periodic copies of given particle in case of periodic boundaries. More...
virtual void	checkBoundaryBeforeTimeStep (DPMBase *md)
	Virtual function that does things before each time step. More...
virtual void	modifyGhostAfterCreation (BaseParticle *particle, int i)
void	setHandler (BoundaryHandler *handler)
	Sets the boundary's BoundaryHandler. More...
BoundaryHandler *	getHandler () const
	Returns the boundary's BoundaryHandler. More...
Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...
	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...
virtual	~BaseObject ()=default
	virtual destructor More...
virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...
void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...
void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...
unsigned int	getIndex () const
	Returns the index of the object in the handler. More...
unsigned int	getId () const
	Returns the unique identifier of any particular object. More...
void	setGroupId (unsigned groupId)
unsigned	getGroupId () const

Public Attributes
unsigned	checkCount = 3

Private Member Functions
void	addHeatTransfer (BaseParticle *particle, double liquidVolume)
double	getSpeciesHeatCapacity (const ParticleSpecies *species) const

Private Attributes
std::function< void(DropletBoundary &)>	generateDroplets_ = [] (DropletBoundary&) {}
std::function< bool(const Droplet &)>	removeDroplets_ = [] (const Droplet&) { return false; }
std::vector< Droplet >	droplets_
double	dropletVolume_ = 0
double	absorbedVolume_ = 0
double	lostVolume_ = 0
bool	removeDropletsAtWalls_ = true
const ParticleSpecies *	dropletSpecies_ = nullptr
double	dropletTemperature_ = -1.0
double	liquidFilmVolumeMaxFraction_ = constants::inf

Detailed Description

Supplies a 'constant heat flux' to a cuboidal region (specified by two corner points) by adding a random velocity at each time step to each particle therein, increasing the granular temperature (velocity variance).

Note, you need to create a species for the droplets that has liquidVolumeMax-0, or the contact happens at a non-zero distance

Constructor & Destructor Documentation

DropletBoundary() [1/2]

DropletBoundary::DropletBoundary ( )

inline

{}

Referenced by copy().

DropletBoundary() [2/2]

DropletBoundary::DropletBoundary ( const DropletBoundary &  other )

inline

                                                  {
        droplets_ = other.droplets_;
        generateDroplets_ = other.generateDroplets_;
        removeDroplets_ = other.removeDroplets_;
        dropletVolume_ = other.dropletVolume_;
        absorbedVolume_ = other.absorbedVolume_;
        lostVolume_ = other.lostVolume_;
        removeDropletsAtWalls_ = other.removeDropletsAtWalls_;
        dropletSpecies_ = other.dropletSpecies_;
        dropletTemperature_ = other.dropletTemperature_;
        liquidFilmVolumeMaxFraction_ = other.liquidFilmVolumeMaxFraction_;
    }

References absorbedVolume_, droplets_, dropletSpecies_, dropletTemperature_, dropletVolume_, generateDroplets_, liquidFilmVolumeMaxFraction_, lostVolume_, removeDroplets_, and removeDropletsAtWalls_.

~DropletBoundary()

DropletBoundary::~DropletBoundary ( )

inlineoverride

                                {
        logger(VERBOSE, "A DropletBoundary has been destroyed.");
    }

References logger, and VERBOSE.

Member Function Documentation

actionsBeforeTimeLoop()

void DropletBoundary::actionsBeforeTimeLoop ( )

inlineoverridevirtual

Virtual function that does something after DPMBase::setupInitialConditions but before the first time step.

Can be used to perform actions before the time loop, but after setupInitialConditions.

Reimplemented from BaseBoundary.

    {
        // When no droplet species were set, use the last species from the handler.
        // This is fine for when the droplets are removed at the walls, if not, a warning is shown.
        if (!dropletSpecies_)
        {
            dropletSpecies_ = getHandler()->getDPMBase()->speciesHandler.getLastObject();
            if (!removeDropletsAtWalls_)
                logger(WARN, "DropletBoundary: Droplets should repel from wall, but no droplet species was set. Using last species from the species handler instead.");
        }
 
        // When droplets should repel from the wall, it requires to be checked every time step.
        if (!removeDropletsAtWalls_)
            checkCount = 1;
 
        if (dropletTemperature_ >= 0.0 && getSpeciesHeatCapacity(dropletSpecies_) == 0.0)
            logger(ERROR, "DropletBoundary: The heat capacity of the droplet species is 0. For proper heat transfer, make sure the droplets have the correct species and the heat capacity is set.");
    }

References checkCount, dropletSpecies_, dropletTemperature_, ERROR, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), BaseHandler< T >::getLastObject(), getSpeciesHeatCapacity(), logger, removeDropletsAtWalls_, DPMBase::speciesHandler, and WARN.

addDroplet() [1/2]

void DropletBoundary::addDroplet ( const Vec3D &  position, const Vec3D &  velocity, double  radius  )

inline

    {
        double liquidVolume = std::pow(radius, 3) * constants::pi * 4.0 / 3.0;
        addDroplet(position, velocity, radius, liquidVolume);
    }

References constants::pi, Eigen::bfloat16_impl::pow(), UniformPSDSelfTest::radius, and Jeffery_Solution::velocity().

Referenced by main(), read(), NozzleDemo::setupInitialConditions(), and NozzleSelfTest::setupInitialConditions().

addDroplet() [2/2]

void DropletBoundary::addDroplet ( const Vec3D &  position, const Vec3D &  velocity, double  radius, double  liquidVolume  )

inline

    {
        droplets_.emplace_back(position, velocity, radius, liquidVolume);
        dropletVolume_ += liquidVolume;
    }

References droplets_, dropletVolume_, UniformPSDSelfTest::radius, and Jeffery_Solution::velocity().

addHeatTransfer()

void DropletBoundary::addHeatTransfer ( BaseParticle *  particle, double  liquidVolume  )

private

{
    // Skip when no droplet temperature has been set.
    if (dropletTemperature_ < 0.0)
        return;
 
    auto hfp = dynamic_cast<HeatFluidCoupledParticle*>(particle);
    if (hfp)
    {
        double particleHeatCapacity = getSpeciesHeatCapacity(hfp->getSpecies());
        double dropletHeatCapacity = getSpeciesHeatCapacity(dropletSpecies_);
        if (particleHeatCapacity > 0.0 && dropletHeatCapacity > 0.0)
        {
            double transferMass = dropletSpecies_->getDensity() * liquidVolume;
            // Tf = (mp*cp*Tp + md*cd*Td) / (mp*cp + md*cd)
            double temperatureFinal = (hfp->getMass() * particleHeatCapacity * hfp->getTemperature() + transferMass * dropletHeatCapacity * dropletTemperature_) /
                                      (hfp->getMass() * particleHeatCapacity + transferMass * dropletHeatCapacity);
            hfp->setTemperature(temperatureFinal);
        }
    }
}

References dropletSpecies_, dropletTemperature_, ParticleSpecies::getDensity(), and getSpeciesHeatCapacity().

Referenced by checkBoundaryAfterParticlesMove().

checkBoundaryAfterParticlesMove()

void DropletBoundary::checkBoundaryAfterParticlesMove ( ParticleHandler &  pH )

overridevirtual

Runs at the end of each time step.

Reimplemented from BaseBoundary.

{
    auto dpm = dynamic_cast<MercuryBase*>(getHandler()->getDPMBase());
    logger.assert_always(dpm,"You can only run DropletBoundary with Mercury2D or Mercury3D, not DPMBase");
    // generate new droplets
    generateDroplets_(*this);
    // integrate Newtons equation of motion
    Vec3D g = dpm->getGravity();
    double dt = dpm->getTimeStep();
    for (auto& d : droplets_)
    {
        Mdouble m = dropletSpecies_->getMassFromRadius(d.radius);
        d.velocity += dt * (d.force + m * g) / m;
        d.force.setZero();
        d.position += dt*d.velocity;
    }
    // check for interaction with particles; this is costly, so we only do iit every 50 time steps
    if (dpm->getNumberOfTimeSteps() % checkCount == 0)
    {
        LiquidFilmParticle p;
        p.setSpecies(dropletSpecies_);
        for (auto &d : droplets_) {
            p.setPosition(d.position);
            p.setVelocity(d.velocity);
            p.setRadius(d.radius);
            auto q = dpm->hGridFindParticleContacts(&p);
            if (!q.empty())
            {
                if (liquidFilmVolumeMaxFraction_ == constants::inf)
                {
                    // No volume limit. Share droplet volume equally between particles.
                    double liquidVolumePerParticle = d.liquidVolume / q.size();
                    for (auto particle : q)
                    {
                        // should that be a static cast?
                        auto lfp = static_cast<LiquidFilmParticle *>(particle);
                        lfp->addLiquidVolume(liquidVolumePerParticle);
                        addHeatTransfer(particle, liquidVolumePerParticle);
                    }
                    absorbedVolume_ += d.liquidVolume;
                    dropletVolume_ -= d.liquidVolume;
                    d.liquidVolume = 0.0;
                }
                else
                {
                    // There is a volume limit. Share droplet volume equally between particles, but any excess liquid
                    // that can't fit the particles is left in the droplet. First, ignore particles that are already
                    // fully filled, so they are not taken into account with the shared volume. Do this by adding them
                    // to a separate vector, in pairs with the allowed liquid volume, since the latter uses the full
                    // liquid volume, which loops over all interactions and does a lot of dynamic_casts, so preferably
                    // we only call it once.
                    std::vector<std::pair<LiquidFilmParticle*, double>> qq;
                    for (auto particle : q)
                    {
                        // should that be a static cast?
                        auto lfp = static_cast<LiquidFilmParticle *>(particle);
                        double allowedLiquidVolume = std::max(liquidFilmVolumeMaxFraction_ * lfp->getVolume() - lfp->getFullLiquidVolume(), 0.0);
                        if (allowedLiquidVolume > 0.0)
                            qq.emplace_back( lfp, allowedLiquidVolume );
                    }
                    double liquidVolumePerParticle = d.liquidVolume / qq.size();
                    for (auto lfp : qq)
                    {
                        double liquidVolume = std::min(lfp.second, liquidVolumePerParticle);
                        lfp.first->addLiquidVolume(liquidVolume);
                        addHeatTransfer(lfp.first, liquidVolume);
                        absorbedVolume_ += liquidVolume;
                        dropletVolume_ -= liquidVolume;
                        d.liquidVolume -= liquidVolume;
                    }
                }
            }
            // Handle deletion boundaries. \todo What about other types of boundaries (e.g. periodic)?
            for (auto bb : dpm->boundaryHandler)
            {
                auto b = dynamic_cast<DeletionBoundary*>(bb);
                if (b)
                {
                    if (b->getDistance(d.position) < 0.0)
                    {
                        lostVolume_ += d.liquidVolume;
                        dropletVolume_ -= d.liquidVolume;
                        d.liquidVolume = 0.0;
                    }
                }
            }
            // check for interactions with walls
            for (BaseWall* w : dpm->wallHandler)
            {
                //Checks if the particle is interacting with the current wall
                BaseInteraction* i = w->getInteractionWith(&p, dpm->getNumberOfTimeSteps() + 1, &dpm->interactionHandler);
                // if there is a wall interacting with the droplet
                if (i != nullptr)
                {
                    if (removeDropletsAtWalls_)
                    {
                        // set droplet liquid volume to zero
                        lostVolume_ += d.liquidVolume;
                        dropletVolume_ -= d.liquidVolume;
                        d.liquidVolume = 0.0;
                    }
                    else
                    {
                        // For some reason the species have to be set here, otherwise the force is always 0.
                        i->setSpecies(dropletSpecies_);
                        i->computeForce();
                        d.force += i->getForce();
                    }
                }
            }
            // Call user defined function for removing droplets.
            if (removeDroplets_(d))
            {
                lostVolume_ += d.liquidVolume;
                dropletVolume_ -= d.liquidVolume;
                d.liquidVolume = 0.0;
            }
        }
        // erase all droplets with liquid volume 0
        droplets_.erase(std::remove_if(droplets_.begin(), droplets_.end(),
                                       [](const Droplet &d) { return d.liquidVolume <= 0; }), droplets_.end());
    }
}

References absorbedVolume_, addHeatTransfer(), LiquidFilm< Particle >::addLiquidVolume(), b, checkCount, droplets_, dropletSpecies_, dropletVolume_, generateDroplets_, BaseHandler< T >::getDPMBase(), BaseBoundary::getHandler(), ParticleSpecies::getMassFromRadius(), i, constants::inf, liquidFilmVolumeMaxFraction_, logger, lostVolume_, m, max, min, p, Eigen::numext::q, removeDroplets_, removeDropletsAtWalls_, and w.

copy()

DropletBoundary* DropletBoundary::copy ( ) const

inlineoverridevirtual

Used to create a copy of the object NB: purely virtual function.

Implements BaseBoundary.

                                           {
        return new DropletBoundary(*this);
    }

References DropletBoundary().

getAbsorbedVolume()

double DropletBoundary::getAbsorbedVolume ( ) const

inline

                                     {
        return absorbedVolume_;
    }

References absorbedVolume_.

getDroplets()

std::vector<Droplet>& DropletBoundary::getDroplets ( )

inline

                                      {
        return droplets_;
    }

References droplets_.

Referenced by NozzleDemo::printTime(), and NozzleSelfTest::printTime().

getDropletVolume()

double DropletBoundary::getDropletVolume ( ) const

inline

                                    {
        return dropletVolume_;
    }

References dropletVolume_.

getLostVolume()

double DropletBoundary::getLostVolume ( ) const

inline

                                 {
        return lostVolume_;
    }

References lostVolume_.

getName()

std::string DropletBoundary::getName ( ) const

inlineoverridevirtual

A purely virtual function.

Implements BaseObject.

                                       {
        return "DropletBoundary";
    }

getSpeciesHeatCapacity()

double DropletBoundary::getSpeciesHeatCapacity ( const ParticleSpecies *  species ) const

private

{
    // We only care about the ThermalSpecies part, but because it's a templated class we have to specify a
    // NormalForceSpecies to be able to cast. Templates don't allow for using e.g. BaseNormalForce, instead we really
    // have to specify the correct NormalForceSpecies. Therefore, try a few and give a warning when not successful, so
    // people may add missing classes.
 
    auto s0 = dynamic_cast<const ThermalSpecies<LinearViscoelasticNormalSpecies>*>(species);
    if (s0)
        return s0->getHeatCapacity();
 
    auto s1 = dynamic_cast<const ThermalSpecies<LinearPlasticViscoelasticNormalSpecies>*>(species);
    if (s1)
        return s1->getHeatCapacity();
 
    auto s2 = dynamic_cast<const ThermalSpecies<HertzianViscoelasticNormalSpecies>*>(species);
    if (s2)
        return s2->getHeatCapacity();
 
    logger(WARN, "DropletBoundary::getSpeciesHeatCapacity(): Failed to cast species to ThermalSpecies<T>. Returning 0.");
    return 0.0;
}

References ThermalSpecies< NormalForceSpecies >::getHeatCapacity(), logger, and WARN.

Referenced by actionsBeforeTimeLoop(), and addHeatTransfer().

getTotalInsertedVolume()

double DropletBoundary::getTotalInsertedVolume ( ) const

inline

                                          {
        return dropletVolume_ + absorbedVolume_ + lostVolume_;
    }

References absorbedVolume_, dropletVolume_, and lostVolume_.

Referenced by main(), NozzleDemo::setupInitialConditions(), and NozzleSelfTest::setupInitialConditions().

read()

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

overridevirtual

Reads some boundary properties from an std::istream.

Reads a number of boundary properties from the given std::istream.

Parameters

[in,out]

is

the istream

Implements BaseBoundary.

{
    BaseBoundary::read(is);
    std::string dummy;
    size_t n;
    Vec3D position, velocity;
    double radius, volume;
    is >> dummy >> checkCount;
    is >> dummy >> n;
    droplets_.clear();
    droplets_.reserve(n);
 
    // For backwards compatibility. Previous restart files do not have the droplet liquid volume written.
    // Skip the next 7n values (position (3), velocity (3), radius (1)).
    // If the value after that is equal to "dropletVolume", we are dealing with an old restart file.
    bool restartFileWithoutDropletLiquidVolume = helpers::lookAhead(is, "dropletVolume", 7*n+1);
    for (int i = 0; i < n; ++i)
    {
        is >> position >> velocity >> radius;
        if (restartFileWithoutDropletLiquidVolume)
            addDroplet(position, velocity, radius);
        else
        {
            is >> volume;
            addDroplet(position, velocity, radius, volume);
        }
    }
 
    is >> dummy >> dropletVolume_ >> dummy >> absorbedVolume_ >> dummy >> lostVolume_;
    if (helpers::isNext(is, "removeDropletsAtWalls")) // For backwards compatibility.
        is >> removeDropletsAtWalls_ >> dummy >> dropletTemperature_;
    if (helpers::isNext(is, "liquidFilmVolumeMaxFraction"))
        is >> liquidFilmVolumeMaxFraction_;
}

References absorbedVolume_, addDroplet(), checkCount, droplets_, dropletTemperature_, dropletVolume_, i, helpers::isNext(), liquidFilmVolumeMaxFraction_, helpers::lookAhead(), lostVolume_, n, UniformPSDSelfTest::radius, BaseBoundary::read(), removeDropletsAtWalls_, oomph::Global_string_for_annotation::string(), and Jeffery_Solution::velocity().

setDropletSpecies()

void DropletBoundary::setDropletSpecies ( const ParticleSpecies *  species )

inline

                                                           {
        dropletSpecies_ = species;
    }

References dropletSpecies_.

setDropletTemperature()

void DropletBoundary::setDropletTemperature ( double  temperature )

inline

                                                   {
        dropletTemperature_ = temperature;
    }

References dropletTemperature_.

setGenerateDroplets()

void DropletBoundary::setGenerateDroplets ( std::function< void(DropletBoundary &)>  generateDroplets )

inline

                                                                                   {
        generateDroplets_=generateDroplets;
    }

References generateDroplets_.

Referenced by main(), NozzleDemo::setupInitialConditions(), and NozzleSelfTest::setupInitialConditions().

setLiquidFilmVolumeMaxFraction()

void DropletBoundary::setLiquidFilmVolumeMaxFraction ( double  volumeFraction )

inline

Sets the fraction of the particle volume that indicates the maximum amount of liquid a particle may hold.

                                                               {
        logger.assert_always(volumeFraction > 0.0, "Error in DropletBoundary::setLiquidFilmVolumeFraction(%), volumeFraction must > 0.", volumeFraction);
        liquidFilmVolumeMaxFraction_ = volumeFraction;
    }

References liquidFilmVolumeMaxFraction_, and logger.

setLiquidFilmVolumeMaxFractionFromRadiusFraction()

void DropletBoundary::setLiquidFilmVolumeMaxFractionFromRadiusFraction ( double  radiusFraction )

inline

Sets the fraction of the particle volume that indicates the maximum amount of liquid a particle may hold, based on a liquid film thickness specified by a fraction of the particle radius.

                                                                                 {
        logger.assert_always(radiusFraction > 0.0, "Error in DropletBoundary::setLiquidFilmVolumeFractionFromRadiusFraction(%), radiusFraction must > 0.", radiusFraction);
        liquidFilmVolumeMaxFraction_ = std::pow(1.0 + radiusFraction, 3) - 1.0;
    }

References liquidFilmVolumeMaxFraction_, logger, and Eigen::bfloat16_impl::pow().

setRemoveDroplets()

void DropletBoundary::setRemoveDroplets ( std::function< bool(const Droplet &)>  removeDroplets )

inline

                                                                             {
        removeDroplets_ = removeDroplets;
    }

References removeDroplets_.

setRemoveDropletsAtWalls()

void DropletBoundary::setRemoveDropletsAtWalls ( bool  removeDroplets )

inline

                                                       {
        removeDropletsAtWalls_ = removeDroplets;
    }

References removeDropletsAtWalls_.

write()

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

overridevirtual

Writes the boundary properties to an std::ostream.

Writes the boundary properties to an std::ostream.

Parameters

[out]

os

the ostream the properties are to be written to.

Implements BaseBoundary.

{
    BaseBoundary::write(os);
    os << " checkCount " << checkCount;
    os << " n " << droplets_.size();
    for (auto& d : droplets_)
    {
        os << " " << d.position;
        os << " " << d.velocity;
        os << " " << d.radius;
        os << " " << d.liquidVolume;
    }
    os << " dropletVolume " << dropletVolume_ << " absorbedVolume " << absorbedVolume_ << " lostVolume " << lostVolume_;
    // Droplet species not written, so should be set in actionsOnRestart() if needed.
    os << " removeDropletsAtWalls " << removeDropletsAtWalls_ << " dropletTemperature " << dropletTemperature_;
    os << " liquidFilmVolumeMaxFraction " << liquidFilmVolumeMaxFraction_;
}

References absorbedVolume_, checkCount, droplets_, dropletTemperature_, dropletVolume_, liquidFilmVolumeMaxFraction_, lostVolume_, removeDropletsAtWalls_, and BaseBoundary::write().

writeVTK()

void DropletBoundary::writeVTK ( std::fstream &  file )

overridevirtual

Reimplemented from BaseBoundary.

                                               {
    file << "<Piece NumberOfPoints=\"" << droplets_.size() << "\" NumberOfCells=\"" << 0 << "\">\n";
    file << "<Points>\n";
    file << "  <DataArray type=\"Float32\" Name=\"Position\" NumberOfComponents=\"3\" format=\"ascii\">\n";
    for (const auto& d : droplets_) file << '\t' << (float)d.position.X << ' ' << (float)d.position.Y << ' ' << (float)d.position.Z << '\n';
    file << "  </DataArray>\n";
    file << "</Points>\n";
    file << "<PointData  Vectors=\"vector\">\n";
    file << "  <DataArray type=\"Float32\" Name=\"Velocity\" NumberOfComponents=\"3\" format=\"ascii\">\n";
    for (const auto& d : droplets_) file << '\t' << (float)d.velocity.X << ' ' << (float)d.velocity.Y << ' ' << (float)d.velocity.Z << '\n';
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"Float32\" Name=\"Radius\" format=\"ascii\">\n";
    for (const auto& d : droplets_) file << '\t' << (float)d.radius << '\n';
    file << "  </DataArray>\n";
    file << "  <DataArray type=\"Float32\" Name=\"LiquidVolume\" format=\"ascii\">\n";
    for (const auto& d : droplets_) file << '\t' << (float)d.liquidVolume << '\n';
    file << "  </DataArray>\n";
    file << "</PointData>\n";
}

References droplets_, and for().

Member Data Documentation

absorbedVolume_

double DropletBoundary::absorbedVolume_ = 0

private

Referenced by checkBoundaryAfterParticlesMove(), DropletBoundary(), getAbsorbedVolume(), getTotalInsertedVolume(), read(), and write().

checkCount

unsigned DropletBoundary::checkCount = 3

Referenced by actionsBeforeTimeLoop(), checkBoundaryAfterParticlesMove(), read(), and write().

droplets_

std::vector<Droplet> DropletBoundary::droplets_

private

Referenced by addDroplet(), checkBoundaryAfterParticlesMove(), DropletBoundary(), getDroplets(), read(), write(), and writeVTK().

dropletSpecies_

const ParticleSpecies* DropletBoundary::dropletSpecies_ = nullptr

private

Referenced by actionsBeforeTimeLoop(), addHeatTransfer(), checkBoundaryAfterParticlesMove(), DropletBoundary(), and setDropletSpecies().

dropletTemperature_

double DropletBoundary::dropletTemperature_ = -1.0

private

Referenced by actionsBeforeTimeLoop(), addHeatTransfer(), DropletBoundary(), read(), setDropletTemperature(), and write().

dropletVolume_

double DropletBoundary::dropletVolume_ = 0

private

Referenced by addDroplet(), checkBoundaryAfterParticlesMove(), DropletBoundary(), getDropletVolume(), getTotalInsertedVolume(), read(), and write().

generateDroplets_

std::function<void(DropletBoundary&)> DropletBoundary::generateDroplets_ = [] (DropletBoundary&) {}

private

Referenced by checkBoundaryAfterParticlesMove(), DropletBoundary(), and setGenerateDroplets().

liquidFilmVolumeMaxFraction_

double DropletBoundary::liquidFilmVolumeMaxFraction_ = constants::inf

private

Referenced by checkBoundaryAfterParticlesMove(), DropletBoundary(), read(), setLiquidFilmVolumeMaxFraction(), setLiquidFilmVolumeMaxFractionFromRadiusFraction(), and write().

lostVolume_

double DropletBoundary::lostVolume_ = 0

private

Referenced by checkBoundaryAfterParticlesMove(), DropletBoundary(), getLostVolume(), getTotalInsertedVolume(), read(), and write().

removeDroplets_

std::function<bool(const Droplet&)> DropletBoundary::removeDroplets_ = [] (const Droplet&) { return false; }

private

Referenced by checkBoundaryAfterParticlesMove(), DropletBoundary(), and setRemoveDroplets().

removeDropletsAtWalls_

bool DropletBoundary::removeDropletsAtWalls_ = true

private

Referenced by actionsBeforeTimeLoop(), checkBoundaryAfterParticlesMove(), DropletBoundary(), read(), setRemoveDropletsAtWalls(), and write().

---

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

• DropletBoundary.h
• DropletBoundary.cc