DropletBoundary.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef DROPLETBOUNDARY_H
#define DROPLETBOUNDARY_H
 
#include "DPMBase.h"
#include "BaseBoundary.h"
#include "Math/Vector.h"
#include "Math/RNG.h"
 
class DPMBase;
 
class ParticleHandler;
 
class BaseParticle;
 
class RNG;
 
class DropletBoundary : public BaseBoundary
{
public:
 
    struct Droplet {
        Droplet(const Vec3D& position, const Vec3D& velocity, double radius, double liquidVolume) :
            position(position), velocity(velocity), radius(radius), liquidVolume(liquidVolume) {}
 
        Vec3D position;
        Vec3D velocity;
        double radius;
        double liquidVolume;
 
        // Used for when to repel droplet at walls.
        Vec3D force;
    };
 
    DropletBoundary() {}
    
    DropletBoundary(const DropletBoundary& other) {
        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_;
    }
    
    ~DropletBoundary() override {
        logger(VERBOSE, "A DropletBoundary has been destroyed.");
    }
    
    DropletBoundary* copy() const override {
        return new DropletBoundary(*this);
    }
 
    std::string getName() const override {
        return "DropletBoundary";
    }
 
    void checkBoundaryAfterParticlesMove(ParticleHandler& pH) override;
 
    void read(std::istream& is) override;
    
    void write(std::ostream& os) const override;
 
    void setGenerateDroplets(std::function<void(DropletBoundary&)> generateDroplets) {
        generateDroplets_=generateDroplets;
    }
 
    void setRemoveDroplets(std::function<bool(const Droplet&)> removeDroplets) {
        removeDroplets_ = removeDroplets;
    }
 
    void writeVTK(std::fstream& file) override;
 
    // this is the number of timesteps between checks whether the droplet is in contact with a particle or wall.
    unsigned checkCount = 3;
 
    void setRemoveDropletsAtWalls(bool removeDroplets) {
        removeDropletsAtWalls_ = removeDroplets;
    }
 
    void setDropletSpecies(const ParticleSpecies* species) {
        dropletSpecies_ = species;
    }
 
    void setDropletTemperature(double temperature) {
        dropletTemperature_ = temperature;
    }
 
    void actionsBeforeTimeLoop() override
    {
        // 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.");
    }
 
    void addDroplet(const Vec3D& position, const Vec3D& velocity, double radius)
    {
        double liquidVolume = std::pow(radius, 3) * constants::pi * 4.0 / 3.0;
        addDroplet(position, velocity, radius, liquidVolume);
    }
 
    void addDroplet(const Vec3D& position, const Vec3D& velocity, double radius, double liquidVolume)
    {
        droplets_.emplace_back(position, velocity, radius, liquidVolume);
        dropletVolume_ += liquidVolume;
    }
 
    std::vector<Droplet>& getDroplets() {
        return droplets_;
    }
 
    double getDropletVolume() const {
        return dropletVolume_;
    }
 
    double getAbsorbedVolume() const {
        return absorbedVolume_;
    }
 
    double getLostVolume() const {
        return lostVolume_;
    }
 
    double getTotalInsertedVolume() const {
        return dropletVolume_ + absorbedVolume_ + lostVolume_;
    }
 
    void setLiquidFilmVolumeMaxFraction(double volumeFraction) {
        logger.assert_always(volumeFraction > 0.0, "Error in DropletBoundary::setLiquidFilmVolumeFraction(%), volumeFraction must > 0.", volumeFraction);
        liquidFilmVolumeMaxFraction_ = volumeFraction;
    }
 
    void setLiquidFilmVolumeMaxFractionFromRadiusFraction(double radiusFraction) {
        logger.assert_always(radiusFraction > 0.0, "Error in DropletBoundary::setLiquidFilmVolumeFractionFromRadiusFraction(%), radiusFraction must > 0.", radiusFraction);
        liquidFilmVolumeMaxFraction_ = std::pow(1.0 + radiusFraction, 3) - 1.0;
    }
 
private:
    std::function<void(DropletBoundary&)> generateDroplets_ = [] (DropletBoundary&) {};
    std::function<bool(const Droplet&)> removeDroplets_ = [] (const Droplet&) { return false; };
 
    void addHeatTransfer(BaseParticle* particle, double liquidVolume);
    double getSpeciesHeatCapacity(const ParticleSpecies* species) const;
 
private:
    std::vector<Droplet> droplets_;
 
    // volume of liquid stored in droplets
    double dropletVolume_ = 0;
    // volume of liquid absorbed by particles
    double absorbedVolume_ = 0;
    // volume of liquid lost at walls
    double lostVolume_ = 0;
 
    bool removeDropletsAtWalls_ = true;
    const ParticleSpecies* dropletSpecies_ = nullptr;
 
    double dropletTemperature_ = -1.0; // Default negative, means no heat transfer.
 
    // Indicates the maximum liquid volume of a particle, depending on it's size. By default infinite, so no limit.
    // This prevents a droplet from adding all its liquid to only one or a few particles, and instead only fills the
    // particles to their max. The droplet itself has a volume property, which is used to track the remaining available
    // liquid. I.e. the droplet size does not change.
    // Added as a property here and not in LiquidFilmParticle, because then the complete liquid migration codes must
    // work with that as well. This would require a fundamental overhaul of the code, which seems like overkill for a
    // safeguard that's only needed here.
    double liquidFilmVolumeMaxFraction_ = constants::inf;
};
 
#endif