InsertionBoundary.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef BOUNDARIES_INSERTIONBOUNDARY_H
#define BOUNDARIES_INSERTIONBOUNDARY_H
 
#include "BaseBoundary.h"
#include <Math/PSD.h>
 
class MD;
 
class RNG;
 
class PSD;
 
class InsertionBoundary : public BaseBoundary
{
public:
 
//    /*!
// * \brief Defines a custom particle size distribution; distribution_ will always be used, unless particleSizeDistributionVector_ is non-empty
// */
//    enum class Distribution
//    {
//        Uniform,
//        Normal_1_5
//        // TODO add LogNormal distribution
//        // LogNormal
//    };
 
 
    InsertionBoundary();
    
    InsertionBoundary(const InsertionBoundary& other);
    
    ~InsertionBoundary() override;
 
 
//    /*!
//     * \brief Sets the properties of the InsertionBoundary for mutliple different particle types
//     */
//    virtual void set(std::vector<BaseParticle*> particleToCopy, unsigned int maxFailed, Vec3D velMin, Vec3D velMax,
//                    double radMin, double radMax)=0;
//
//    /*!
//     * \brief 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;
    
    virtual BaseParticle* generateParticle(RNG& random);
 
    virtual void placeParticle(BaseParticle* p, RNG& random) = 0;
 
    void checkBoundaryBeforeTimeStep(DPMBase* md) override;
 
    void insertParticles(DPMBase* md);
 
    unsigned int getNumberOfParticlesInserted() const;
    
    Mdouble getMassOfParticlesInserted() const;
 
   Mdouble getVolumeOfParticlesInserted() const;
 
    void reset();
 
    void activate();
 
    void deactivate();
 
    bool isActivated();
 
 
    
    unsigned int getMaxFailed() const;
    
    void setParticleToCopy(std::vector<BaseParticle*> particleToCopy);
 
    void setParticleToCopy(BaseParticle* particleToCopy);
    
    std::vector<BaseParticle*> getParticleToCopy();
    
    void read(std::istream& is) override;
    
    void write(std::ostream& os) const override;
 
    Mdouble getVolumeFlowRate() const;
 
    void setVolumeFlowRate(Mdouble volumeFlowRate_);
 
    Mdouble getInitialVolume() const;
 
    void setInitialVolume(Mdouble initialVolume);
 
    void setPSD(const PSD psd);
 
    void setPSD(std::vector<PSD> psd, std::vector<Mdouble> probability);
 
    std::vector<PSD> getPSD();
 
    void
    setVariableVolumeFlowRate(const std::vector<Mdouble>& variableCumulativeVolumeFlowRate, Mdouble samplingInterval);
 
    bool insertParticle(Mdouble time);
 
    bool getCheckParticleForInteraction() const;
 
    void setCheckParticleForInteraction(bool checkParticleForInteraction);
 
    void setManualInsertion(bool manualInsertion);
 
//    /*!
//     * \brief write Distribution class to file.
//     */
//    friend std::ostream& operator<<(std::ostream& os, InsertionBoundary::Distribution type);
//
//    /*!
//     * \brief read Distribution class from file.
//     */
//    friend std::istream& operator>>(std::istream& is, InsertionBoundary::Distribution& type);
 
protected:
 
    std::vector<BaseParticle*> particleToCopy_;
    
    unsigned int maxFailed_;
    
    unsigned int numberOfParticlesInserted_;
 
    Mdouble massInserted_;
 
    Mdouble volumeInserted_;
 
    bool isActivated_;
 
    Mdouble volumeFlowRate_;
 
    Mdouble initialVolume_;
 
    std::vector<Mdouble> variableCumulativeVolumeFlowRate_;
 
    Mdouble samplingInterval_;
 
    bool checkParticleForInteraction_;
 
    std::vector<PSD> particleSizeDistributionVector_;
 
    Vec3D velMin_, velMax_;
 
    bool isManuallyInserting_;
 
    std::vector<Mdouble> probability_;
    
    int chosenSpecies_;
 
};
 
#endif