geometry.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 __geometry_hpp__
#define __geometry_hpp__
 
 
#include "virtualConstructor.hpp"
#include "demGeometry.hpp"
#include "property.hpp"
#include "Fields.hpp"
#include "Vectors.hpp"
#include "multiTriSurface.hpp"
#include "triSurfaceFields.hpp"
#include "dictionary.hpp"
 
namespace pFlow
{
 
 
class geometry
:
    public demGeometry
{
protected:
 
    // - Protected members 
 
        const property&     wallProperty_;
 
        repository&         geometryRepository_;
 
        multiTriSurface&    triSurface_;
 
        wordField&          motionComponentName_;
 
        wordField&          materialName_;
        
        int8TriSurfaceField_D&      propertyId_;
 
        realx3TriSurfaceField_D&    contactForceWall_;
 
        realx3TriSurfaceField_D&    stressWall_;
 
    // - Protected member functions
    
        bool findPropertyId();
 
        void zeroForce()
        {
            contactForceWall_.fill(zero3);
        }
 
 
public:
 
    TypeInfo("geometry");
 
    // - Constructors 
        
        geometry(systemControl& control, const property& prop);
 
        geometry(systemControl& control,
                 const property& prop,
                 const multiTriSurface& triSurface,
                 const wordVector& motionCompName,
                 const wordVector& propName
                );
 
        geometry(systemControl& control,
                 const property& prop,
                 const dictionary& dict,
                 const multiTriSurface& triSurface,
                 const wordVector& motionCompName,
                 const wordVector& propName);
 
        virtual ~geometry() = default;
 
        create_vCtor
        (
            geometry,
            systemControl,
            (
                systemControl& control,
                const property& prop
            ),
            (control, prop)
        );
 
        create_vCtor
        (
            geometry,
            dictionary,
            (systemControl& control,
             const property& prop,
             const dictionary& dict,
             const multiTriSurface& triSurface,
             const wordVector& motionCompName,
             const wordVector& propName),
            (control, prop, dict, triSurface, motionCompName, propName)
        );
 
    //- Methods 
 
        inline
        auto size()const
        {
            return triSurface_.size();
        }
 
        inline
        auto numPoints()const
        {
            return triSurface_.numPoints();
        }
 
        inline
        auto numTriangles()const
        {
            return size();
        }
 
        inline
        const auto& points()const
        {
            return triSurface_.points();
        }
 
        inline
        const auto& vertices()const
        {
            return triSurface_.vertices();
        }
 
        inline auto getTriangleAccessor()const
        {
            return triSurface_.getTriangleAccessor();
        }
 
        inline auto& surface()
        {
            return triSurface_;
        }
 
        inline const auto& surface()const
        {
            return triSurface_;
        }
 
        inline
        realx3TriSurfaceField_D& contactForceWall()
        {
            return contactForceWall_;
        }
 
        inline
        const realx3TriSurfaceField_D& contactForceWall() const
        {
            return contactForceWall_;
        }
 
        inline const auto& wallProperty()const
        {
            return wallProperty_;
        }
 
        inline
        const repository& owner()const
        {
            return geometryRepository_;
        }
 
        inline
        repository& owner()
        {
            return geometryRepository_;
        }
 
        inline auto path()
        {
            return owner().path();
        }
 
        virtual 
        word motionModelTypeName()const = 0;
 
        virtual
        const int8Vector_HD&            triMotionIndex() const =0;
 
        virtual 
        const int8Vector_HD&            pointMotionIndex()const = 0;
 
        const int8TriSurfaceField_D&    propertyId() const
        {
            return propertyId_;
        }
 
        bool beforeIteration() override;
 
        bool afterIteration() override;
 
    //- IO
 
        bool write()const
        {
            return owner().write();
        }
 
 
    //- Static members 
 
        static
        uniquePtr<geometry> create(systemControl& control, const property& prop);
 
        static
        uniquePtr<geometry> create(
                systemControl& control,
                const property& prop,
                const dictionary& dict,
                const multiTriSurface& triSurface,
                const wordVector& motionCompName,
                const wordVector& propName);
 
};
 
}
 
#endif