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:
 
    const property&     wallProperty_;
 
    // - this object is owned by geometryRepository_ 
    repository&         geometryRepository_;
 
    // all triangles of walls 
    multiTriSurface&    triSurface_;
 
    // 
    wordField&          motionComponentName_;
 
    // 
    wordField&          materialName_;
        
    int8TriSurfaceField_D&      propertyId_;
 
    realx3TriSurfaceField_D&    contactForceWall_;
 
    realx3TriSurfaceField_D&    stressWall_;
 
    bool findPropertyId();
 
    void zeroForce()
    {
        contactForceWall_.fill(zero3);
    }
 
 
public:
 
    // - type info
    TypeInfo("geometry");
 
        
        // - empty
        geometry(systemControl& control, const property& prop);
 
        // - from components
        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)
        );
 
 
        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_;
        }
 
        // owner repository
        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 { 
            
            this->zeroForce();
            return true;
            
        }
 
        bool afterIteration() override { 
            
            auto Force = contactForceWall_.deviceVectorAll();
            auto area = triSurface_.area().deviceVectorAll();
            auto stress = stressWall_.deviceVectorAll();
            auto numTri =triSurface_.size();
            
 
            Kokkos::parallel_for(
                "geometry::calculateStress",
                numTri,
                LAMBDA_HD(int32 i){
                    stress[i] = Force[i]/area[i];
                });
            Kokkos::fence();
            return true;
            
        }
 
        bool write()const
        {
            return owner().write();
        }
 
 
        // static 
 
        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