boundaryBase.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 __boundaryBase_hpp__
#define __boundaryBase_hpp__
 
#include "virtualConstructor.hpp"
#include "subscriber.hpp"
#include "VectorSingles.hpp"
#include "plane.hpp"
#include "scatteredFieldAccess.hpp"
#include "timeInfo.hpp"
 
 
namespace pFlow
{
 
// forward 
 
class internalPoints;
class dictionary;
class boundaryList;
class pointStructure;
class Time;
 
class boundaryBase
:
    public subscriber
{
public:
 
    using pointFieldAccessType = 
        deviceScatteredFieldAccess<realx3>;
 
private:
 
    // friend et al.
    friend boundaryList;
 
    const plane&           boundaryPlane_;
 
    uint32Vector_D         indexList_;
 
    mutable uint32Vector_H indexListHost_;
 
    mutable bool           listsSync_ = false;
 
    real                   neighborLength_;
 
    bool                   updateTime_ = false;
 
    bool                   iterBeforeUpdate_ = false;
 
    real                   boundaryExtntionLengthRatio_;
 
    internalPoints&        internal_;
 
    boundaryList&          boundaries_;
 
    uint32                 thisBoundaryIndex_;
 
    int                    neighborProcessorNo_;
 
    bool                   isBoundaryMaster_;
 
    word                   name_;
 
    word                   type_;
 
protected:
    
    virtual void setSize(uint32 newSize);
 
 
    void setUpdateTime(bool val)
    {
        updateTime_ = val;
    }
 
    void setNewIndices(const uint32Vector_D& newIndices);
 
    bool appendNewIndices(const uint32Vector_D& newIndices);
    
    bool removeIndices(
        uint32 numRemove, 
        const uint32Vector_D& removeMask);
    
    bool setRemoveKeepIndices(
        const uint32Vector_D& removeIndices,
        const uint32Vector_D& keepIndices);
    
    bool transferPointsToMirror(
        uint32 numTransfer, 
        const uint32Vector_D& transferMask,
        uint32 transferBoundaryIndex,
        realx3 transferVector);
    
    void unSyncLists()
    {
        listsSync_ = false;
    }
 
    void syncLists()const
    {
        if(!listsSync_)
        {
            indexListHost_.assignFromDevice(indexList_, true);
            listsSync_ = true;
        }
    }
 
    virtual 
    bool updataBoundaryData(int step)
    {
        return true;
    }
 
    virtual 
    bool transferData(uint32 iter, int step, bool& callAgain)
    {
        callAgain = false;
        return true;
    }
    
 
public:
 
    uint32 markInNegativeSide(const word& name, uint32Vector_D& markedIndices )const;
 
 
    TypeInfo("boundaryBase");
    
    boundaryBase(
        const dictionary &dict,
        const plane     &bplane,
        internalPoints  &internal,
        boundaryList    &bndrs,
        uint32          thisIndex);
 
    boundaryBase(const boundaryBase&) = delete;
 
    boundaryBase& operator=(const boundaryBase&) = delete;
 
    boundaryBase(boundaryBase&&) = default;
 
    boundaryBase& operator=(boundaryBase&&) = default;
 
    ~boundaryBase() override = default;
    
 
    create_vCtor
    (
        boundaryBase,
        dictionary,
        (
            const dictionary &dict,
            const plane     &bplane,
            internalPoints  &internal,
            boundaryList    &bndrs,
            uint32          thisIndex
        ),
        (dict, bplane, internal, bndrs, thisIndex)
    );
 
    inline
    real neighborLengthIntoInternal()const
    {
        return neighborLength_;
    }
 
    virtual 
    real neighborLength()const
    {
        return (1+boundaryExtntionLengthRatio_)*neighborLength_;
    }
 
    virtual 
    realx3 boundaryExtensionLength()const
    {
        return -boundaryExtntionLengthRatio_*neighborLength_ * boundaryPlane_.normal();
    }
 
    inline
    bool performBoundarytUpdate()const
    {
        return updateTime_;
    }
 
    inline
    bool iterBeforeBoundaryUpdate()const
    {
        return iterBeforeUpdate_;
    }
 
    inline
    const word& type()const
    {
        return type_;
    }
 
    inline
    const word& name()const
    {
        return name_;
    }
 
    inline
    bool empty()const
    {
        return indexList_.size()==0;
    }
 
    inline
    auto size()const
    {
        return indexList_.size();
    }
 
    inline
    auto capacity()const
    {
        return indexList_.capacity();
    }
 
    inline 
    int neighborProcessorNo()const
    {
        return neighborProcessorNo_;
    }
 
    inline 
    int thisProcessorNo()const
    {
        return pFlowProcessors().localRank();
    }
 
    inline
    bool isBoundaryMaster()const
    {
        return isBoundaryMaster_;
    }
 
    inline
    uint32 thisBoundaryIndex()const
    {
        return thisBoundaryIndex_;
    }
 
    inline
    uint32 mirrorBoundaryIndex()const
    {
        return thisBoundaryIndex_%2==0? thisBoundaryIndex_+1:thisBoundaryIndex_-1;
    }
 
    inline
    const internalPoints& internal()const
    {
        return internal_;
    }
 
    inline
    internalPoints& internal()
    {
        return internal_;
    }
 
    const pointStructure& pStruct()const;
 
    const Time& time()const;
 
    inline
    const auto& indexList()const
    {
        return indexList_;
    }
 
    inline
    const auto& indexListHost()const
    {
        syncLists();
        return indexListHost_;
    }
 
    boundaryBase& mirrorBoundary();
 
    const boundaryBase& mirrorBoundary()const;
    
    const plane& boundaryPlane()const
    {
        return boundaryPlane_;
    }
 
    virtual
    realx3 displacementVectroToMirror()const;
    
 
    virtual 
    bool beforeIteration(
        uint32 step, 
        const timeInfo& ti, 
        bool updateIter, 
        bool iterBeforeUpdate , 
        bool& callAgain
    )
    {
        updateTime_ = updateIter;
        iterBeforeUpdate_ = iterBeforeUpdate;
        return true;
    }
 
    virtual 
    bool iterate(const timeInfo& ti) = 0;
 
    virtual 
    bool afterIteration(const timeInfo& ti) = 0;
    
    pointFieldAccessType thisPoints()const;
 
    virtual 
    uint32 neighborProcSize()const
    {
        return 0;
    }
 
    virtual
    realx3Vector_D& neighborProcPoints();
 
    virtual
    const realx3Vector_D& neighborProcPoints()const;
    
    virtual 
    uint32 numToTransfer()const
    {
        return 0u;
    }
 
    virtual 
    uint32 numToRecieve()const
    {
        return 0u;
    }
 
    static
    uniquePtr<boundaryBase> create
    (
        const dictionary &dict,
        const plane     &bplane,
        internalPoints  &internal,
        boundaryList    &bndrs,
        uint32          thisIndex
    );
 
    
};
 
}
 
 
#endif //__boundaryBase_hpp__