pointStructure.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 __pointStructure_hpp__
#define __pointStructure_hpp__
 
#include "IOobject.hpp"
#include "demComponent.hpp"
#include "internalPoints.hpp"
#include "simulationDomain.hpp"
#include "pointSorting.hpp"
#include "boundaryList.hpp"
#include "streams.hpp"
 
namespace pFlow
{
 
class pointStructure
:
    public IOobject,
    public demComponent,
    public internalPoints
{
public:
    
    using PointsType        = typename internalPoints::PointsType;
 
    using PointsTypeHost    = typename PointsType::FieldTypeHost;
 
    using device_type       = typename PointsType::device_type;
 
    using memory_space      = typename PointsType::memory_space;
 
    using execution_space   = typename PointsType::execution_space;
 
private:
 
    uniquePtr<simulationDomain> simulationDomain_ = nullptr;
 
    uniquePtr<pointSorting>     pointSorting_ = nullptr;
 
    boundaryList                boundaries_;
    
    Timer                       boundaryUpdateTimer_;
 
    Timer                       boundaryDataTransferTimer_;
 
    
 
    bool setupPointStructure(const realx3Vector& points);
 
    bool setupPointStructure(const PointsTypeHost& points);
 
    bool initializePoints(const PointsTypeHost& points);
 
public:
 
        
    // - type info
    TypeInfo("pointStructure");
    
 
 
        explicit pointStructure(systemControl& control);
 
        pointStructure(
            systemControl& control,
            const realx3Vector& posVec);
 
        pointStructure(const pointStructure&) = delete;
 
        // - no move construct 
        pointStructure(pointStructure&&) = delete;
 
        
        pointStructure& operator=(const pointStructure&) = delete;
 
        // - no move assignment 
        pointStructure& operator=(pointStructure&&) = delete;
 
        // - destructor 
        ~pointStructure() override = default;
 
    // - Iteration methods
 
        bool beforeIteration() override;
 
        bool iterate() override;
 
        bool afterIteration() override;
 
    // - Access methods 
 
        auto& boundaries()
        {
            return boundaries_;
        }
 
        const auto& boundaries()const
        {
            return boundaries_;
        }
 
        Time& time() override
        {
            return demComponent::time();
        }
        
        const Time& time() const override
        {
            return demComponent::time();
        }
        
        boundaryBase& boundary(size_t i ) override
        {
            return boundaries_[i];
        }
 
        const boundaryBase& boundary(size_t i)const override
        {
            return boundaries_[i];
        }
 
        inline
        const auto& simDomain()const
        {
            return simulationDomain_();
        }
 
        inline 
        const auto& thisDomain()const
        {
            return simulationDomain_().thisDomain();
        }
 
        inline 
        const auto& extendedDomain()const
        {
            return boundaries_.extendedDomain();
        }
 
        inline 
        auto internalDomainBox()const
        {
            return boundaries_.internalDomainBox();
        }
        
    // - IO methods 
 
        bool read(iIstream& is, const IOPattern& iop) override;
        
 
        bool write(iOstream& os, const IOPattern& iop)const override;
        
 
};
 
 
/*inline iOstream& operator << (iOstream& os, const pointStructure& ps )
{   
    if( !ps.write(os, IOPattern::AllProcessorsDifferent) )
    {
        ioErrorInFile(os.name(), os.lineNumber());
        fatalExit;
    }
    return os; 
}*/
 
} // pFlow
 
 
 
 
#endif //__pointStructure_hpp__