insertionRegion.hpp

Go to the documentation of this file.

/*------------------------------- phasicFlow ---------------------------------
      O        C enter of
     O O       E ngineering and
    O   O      M ultiscale modeling of
   OOOOOOO     F luid flow
------------------------------------------------------------------------------
  Copyright (C): www.cemf.ir
  email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------
Licence:
  This file is part of phasicFlow code. It is a free software for simulating
  granular and multiphase flows. You can redistribute it and/or modify it under
  the terms of GNU General Public License v3 or any other later versions.
 
  phasicFlow is distributed to help others in their research in the field of
  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
-----------------------------------------------------------------------------*/
 
#ifndef __insertionRegion_hpp__
#define __insertionRegion_hpp__
 
#include "anyList.hpp"
#include "baseTimeControl.hpp"
#include "peakableRegion.hpp"
#include "shapeMixture.hpp"
 
namespace pFlow
{
 
class dictionary;
class insertion;
class pointStructure;
 
class insertionRegion
{
private:
 
    const word                name_;
 
    const dictionary&         dict_;
 
    const insertion&          insertion_;
 
    baseTimeControl           tControl_;
 
    real                      rate_;
 
    uint32                    numInserted_ = 0;
 
    word                      type_;
 
    uniquePtr<peakableRegion> pRegion_ = nullptr;
 
    uniquePtr<shapeMixture>   mixture_ = nullptr;
 
    uniquePtr<dictionary>     setFieldDict_ = nullptr;
 
    anyList                   setFieldList_;
 
private:
 
    // - private methods
 
    bool readInsertionRegion(const dictionary& dict);
 
    bool writeInsertionRegion(dictionary& dict) const;
 
    bool readSetFieldDict();
 
public:
 
    TypeInfoNV("insertionRegion");
 
    // - Constructors
 
    insertionRegion(const word& name, const insertion& instn);
 
    ~insertionRegion() = default;
 
    // - Methods
 
    const auto& name() const
    {
        return name_;
    }
 
    const auto& type() const
    {
        return type_;
    }
 
    const auto& dict()const
    {
        return dict_;
    }
 
    const auto& Insertion() const
    {
        return insertion_;
    }
 
    const pointStructure& pStruct()const;
 
    inline bool insertionTime(uint32 iter, real t, real dt) const
    {
        return tControl_.timeEvent(iter, t, dt);
    }
 
    uint32        numberToBeInserted(uint32 iter, real t, real dt);
 
    inline uint32 addToNumInserted(uint32 newInserted)
    {
        return numInserted_ += newInserted;
    }
 
    inline uint32 totalInserted() const
    {
        return numInserted_;
    }
 
    auto& mixture()
    {
        return mixture_();
    }
 
    auto& pRegion()
    {
        return pRegion_();
    }
 
    const auto& setFieldList() const
    {
        return setFieldList_;
    }
    // - IO operation
 
    /*bool read(const dictionary& dict)
    {
        if (!timeFlowControl::read(dict))
            return false;
 
        return readInsertionRegion(dict);
    }*/
 
    bool write(dictionary& dict) const
    {
        return writeInsertionRegion(dict);
    }
};
 
} // pFlow
 
#endif //__insertionRegion_hpp__