Mirror.h

//Calculation of the Fluid Wall interaction by a function
 
#ifndef MIRROR_H_
#define MIRROR_H_
 
#include "PluginBase.h"
#include "utils/Random.h"
#include "utils/ObserverBase.h"
#include "utils/Region.h"
 
#include <string>
#include <map>
#include <list>
#include <cstdint>
#include <vector>
#include <memory>
#include <utility>
 
#include "utils/CommVar.h"
 
enum MirrorDirection : uint16_t {
    MD_LEFT_MIRROR = 0,
    MD_RIGHT_MIRROR = 1
};
 
enum MirrorType : uint16_t {
    MT_UNKNOWN = 0,
    MT_REFLECT = 1,
    MT_FORCE_CONSTANT = 2,
    MT_ZERO_GRADIENT = 3, // Deprecated
    MT_NORMDISTR_MB = 4,  // Deprecated
    MT_MELAND_2004 = 5,   // Algorithm proposed by Meland et al., Phys. Fluids, Vol. 16, No. 2 (2004)
    MT_RAMPING = 6,
};
 
class ParticleContainer;
class DomainDecompBase;
class Domain;
 
class Mirror : public PluginBase, public ObserverBase, public ControlInstance
{
public:
    // constructor and destructor
    Mirror();
    ~~Mirror() override = default;
 
    void readXML(XMLfileUnits& xmlconfig) override;
 
    void init(ParticleContainer *particleContainer,
              DomainDecompBase *domainDecomp, Domain *domain) override;
 
    void beforeForces(
            ParticleContainer* particleContainer, DomainDecompBase* domainDecomp,
            unsigned long simstep
    ) override;
 
    void afterForces(
            ParticleContainer* particleContainer, DomainDecompBase* domainDecomp,
            unsigned long simstep
    ) override;
 
    void endStep(
            ParticleContainer *particleContainer,
            DomainDecompBase *domainDecomp, Domain *domain,
            unsigned long simstep) override {}
 
    void finish(ParticleContainer *particleContainer,
                DomainDecompBase *domainDecomp, Domain *domain) override {}
 
    std::string getPluginName() override {return std::string("Mirror");}
    static PluginBase* createInstance() {return new Mirror();}
 
    // Getters, Setters
    uint64_t getReflectedParticlesCountLocal(const uint16_t& componentid){return _particleManipCount.reflected.local.at(componentid);}
    uint64_t getDeletedParticlesCountLocal(const uint16_t& componentid) {return _particleManipCount.deleted.local.at(componentid);}
    uint32_t getPluginID() {return _pluginID;}
    void setPluginID(const uint32_t& id) {_pluginID = id;}
    double getPosition() {return _position.coord;}
 
    // Observer, ControlInstance
    SubjectBase* getSubject();
    void update(SubjectBase* subject) override;
    std::string getShortName() override {return "Mirr";}
 
private:
        void VelocityChange(ParticleContainer* particleContainer);
 
private:
    uint32_t _pluginID;
    uint32_t _targetComp;
    struct MirrorPosition {
        uint16_t axis;
        double coord;
        struct RefPoint {
            uint16_t id;
            double origin;
            double coord;
        } ref;
    } _position;
    double _forceConstant;
    MirrorDirection _direction;
    MirrorType _type;
 
    std::unique_ptr<Random> _rnd;
 
    struct MelandParams {
        double velo_target {0.4};
        float fixed_probability_factor {-1};
    } _melandParams;
    
    struct RampingParams {
        unsigned long startStep {1000};
        unsigned long stopStep {2000};
        int treatment {1};
    } _rampingParams;
 
    struct ParticleManipCount {
        CommVar<std::vector<uint64_t> > reflected;
        CommVar<std::vector<uint64_t> > deleted;
    } _particleManipCount;
    
    struct DiffuseMirror {
        bool enabled;
        float width;
        std::map<uint64_t,double> pos_map;
    } _diffuse_mirror;
};
 
#endif /*MIRROR_H_*/