sphereParticles.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 __sphereParticles_hpp__
#define __sphereParticles_hpp__ 
 
#include "systemControl.hpp"
#include "particles.hpp"
#include "sphereShape.hpp"
#include "property.hpp"
#include "indexContainer.hpp"
 
 
 
namespace pFlow
{
 
class sphereParticles
:
    public particles 
{
protected:
 
    const property&     property_;
 
    sphereShape&        shapes_;
 
    realPointField_D&       I_;
 
    realx3PointField_D&     rVelocity_;
 
    realx3PointField_D&     rAcceleration_; 
 
    uniquePtr<integration>  rVelIntegration_ = nullptr;
 
    Timer                   accelerationTimer_;
 
    Timer                   intPredictTimer_;
 
    Timer                   intCorrectTimer_;
 
    bool diameterMassInertiaPropId(const word& shName, real& diam, real& mass, real& I, int8& propIdx);
 
    bool initializeParticles();
 
    bool insertSphereParticles(
        const wordVector& names, 
        const int32IndexContainer& indices,
        bool setId = true);
 
    virtual uniquePtr<List<eventObserver*>> getFieldObjectList()const override;
 
public:
 
    sphereParticles(systemControl &control, const property& prop);
 
    sphereParticles(const sphereParticles&) = delete;
 
    sphereParticles(sphereParticles&&) = default;
 
    sphereParticles& operator=(const sphereParticles&) = delete;
 
    sphereParticles& operator=(sphereParticles&&) = default;
 
    virtual ~sphereParticles()=default;
 
    bool insertParticles
    (
        const realx3Vector& position,
        const wordVector&  shapes,
        const setFieldList& setField
    ) override ;
 
    const auto& shapes()const
    {
        return shapes_;
    }
 
    const auto& I()const
    {
        return I_;
    }
 
    auto& I()
    {
        return I_;
    }
    
    const realx3Vector_D rVelocity()const 
    {   
        return rVelocity_;
    }
 
    const realVector_D& boundingSphere()const override
    {
        return this->diameter();
    }
 
    word shapeTypeName() const override
    {
        return "sphere";
    }
 
    void boundingSphereMinMax(
        real& minDiam,
        real& maxDiam )const override
    {
        shapes_.diameterMinMax(minDiam, maxDiam);
    }
 
    bool update(const eventMessage& msg) override;
    
    
    realx3PointField_D& rAcceleration() override
    {
        return rAcceleration_;
    }
    
    const realx3PointField_D& rAcceleration() const override
    {
        return rAcceleration_;
    }
 
    bool beforeIteration() override;
 
    bool iterate() override;    
 
    bool afterIteration() override;
    
 
    
}; //sphereParticles
 
} // pFlow
 
#endif //__sphereParticles_hpp__