particles.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 __particles_hpp__
#define __particles_hpp__
 
#include "dynamicPointStructure.hpp"
#include "particleIdHandler.hpp"
#include "demParticles.hpp"
namespace pFlow
{
 
class setFieldList;
 
class particles
:
    public eventObserver,
    public demParticles
{
protected:
    
    // owner repository 
    Time& time_;
 
    const word integrationMethod_;
 
    // dynamic point structure for particles 
    dynamicPointStructure   dynPointStruct_;
 
    // - name of shapes - this is managed by particles 
    wordPointField&         shapeName_;
 
    // id of particles on host
    int32PointField_HD&     id_;
 
    // property id on device
    int8PointField_D&       propertyId_;
 
    // diameter / boundig sphere size of particles on device
    realPointField_D&       diameter_;
 
    // mass on device
    realPointField_D&       mass_;
 
    // - acceleration on device
    realx3PointField_D&     accelertion_;
 
 
    realx3PointField_D&     contactForce_;
 
 
    realx3PointField_D&     contactTorque_; 
 
    
    // - object handling particle id
    particleIdHandler       idHandler_;
 
    virtual uniquePtr<List<eventObserver*>> getFieldObjectList()const;
 
    void zeroForce()
    {
        contactForce_.fill(zero3);
    }
 
    void zeroTorque()
    {
        contactTorque_.fill(zero3);
    }
 
public:
 
    // type info
    TypeInfo("particles");
 
    particles(systemControl& control, const word& integrationMethod);
 
    inline const auto& time()const {
        return time_;
    }
 
    inline auto& time() {
        return time_;
    }
    
    inline auto integrationMethod()const
    {
        return integrationMethod_;
    }
 
    inline const auto& dynPointStruct()const 
    {
        return dynPointStruct_;
    }
 
    inline auto& dynPointStruct()
    {
        return dynPointStruct_;
    }
 
    inline const auto& pStruct()const{
        return dynPointStruct_.pStruct();
    }
 
    inline auto& pStruct(){
        return dynPointStruct_.pStruct();
    }
 
    inline auto size()const{
        return pStruct().size();
    }
 
    inline auto capacity() const{
        return pStruct().capacity();
    }
 
    inline auto activePointsMaskD()const{
        return pStruct().activePointsMaskD();
    }
 
    inline auto numActive()const
    {
        return pStruct().numActive();
    }
    
    inline bool allActive()const{
        return pStruct().allActive();
    }
 
    inline auto activeRange()const{
        return pStruct().activeRange();
    }
 
    inline auto activePointsMaskH()const{
        return pStruct().activePointsMaskH();
    }
 
    inline const auto& pointPosition()const{
        return pStruct().pointPosition();
    }
 
    inline const auto& position()const
    {
        return pStruct().pointPosition();   
    }
 
    inline const auto& pointVelocity()const{
        return dynPointStruct().velocity();
    }
 
    inline const auto& velocity()const{
        return dynPointStruct().velocity();
    }
 
    inline const auto& id()const{
        return id_;
    }
 
    inline auto& id(){
        return id_;
    }
 
    inline const auto& diameter()const{
        return diameter_;
    }
 
    inline auto& diameter(){
        return diameter_;
    }
 
    inline const auto& mass()const{
        return mass_;
    }
 
    inline auto& mass() {
        return mass_;
    }
 
    inline const auto& accelertion()const{
        return accelertion_;
    }
 
    inline auto& accelertion(){
        return accelertion_;
    }
 
    inline 
    realx3PointField_D& contactForce() 
    {
        return contactForce_;
    }
 
    inline
    const realx3PointField_D& contactForce() const
    {
        return contactForce_;
    }
 
    inline
    realx3PointField_D& contactTorque()
    {
        return contactTorque_;
    }
 
    inline
    const realx3PointField_D& contactTorque() const 
    {
        return contactTorque_;
    }
 
    inline const auto& propertyId()const{
        return propertyId_;
    }
 
    inline auto& propertyId(){
        return propertyId_;
    }
 
    inline const auto& shapeName()const{
        return shapeName_;
    }
 
    inline auto& shapName(){
        return shapeName_;
    }
 
    bool beforeIteration() override
    {
        auto domain = this->control().domain();
 
        auto numMarked = dynPointStruct_.markDeleteOutOfBox(domain);
        /*if(numMarked)
        {
            output<<"\nNumber of deleted points/particles that are out of domain box: "<<numMarked<<endl;
        }*/
 
        this->zeroForce();
        this->zeroTorque();
 
        return true;
    }
 
    virtual
    bool insertParticles
    (
        const realx3Vector& position,
        const wordVector&  shapes,
        const setFieldList& setField
     ) = 0;
 
    
 
    virtual
    realx3PointField_D& rAcceleration() = 0;
 
    virtual
    const realx3PointField_D& rAcceleration() const = 0;
 
    virtual
    const realVector_D& boundingSphere()const = 0;
 
    virtual 
    word shapeTypeName()const = 0;
 
    virtual
    void boundingSphereMinMax(real & minDiam, real& maxDiam)const = 0;
 
    
 
}; // particles
 
} // pFlow
 
#endif //__particles_hpp__