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 "indexContainer.hpp"
#include "particles.hpp"
#include "property.hpp"
#include "sphereShape.hpp"
#include "boundarySphereParticlesList.hpp"
#include "systemControl.hpp"
 
namespace pFlow
{
 
class sphereParticles : public particles
{
public:
 
    using ShapeType = sphereShape;
 
private:
 
    ShapeType              spheres_;
 
    uint32PointField_D     propertyId_;
 
    realPointField_D       diameter_;
 
    realPointField_D       mass_;
 
    realPointField_D       I_;
 
    realx3PointField_D     rVelocity_;
 
    realx3PointField_D     rAcceleration_;
 
    boundarySphereParticlesList boundarySphereParticles_;
 
    uniquePtr<integration> rVelIntegration_ = nullptr;
 
    Timer                  accelerationTimer_;
 
    Timer                  intPredictTimer_;
 
    Timer                  intCorrectTimer_;
 
    Timer                  fieldUpdateTimer_;
 
private:
    
 
    bool getParticlesInfoFromShape(
      const wordVector& shapeNames,
      uint32Vector&     propIds,
      realVector&       diams,
      realVector&       m,
      realVector&       Is,
      uint32Vector&     shIndex
    );
    /*bool initializeParticles();
 
    bool insertSphereParticles(
        const wordVector& names,
        const int32IndexContainer& indices,
        bool setId = true);
 
    virtual uniquePtr<List<eventObserver*>> getFieldObjectList()const override;
    */
protected:
    Timer& accelerationTimer()
    {
        return accelerationTimer_;
    }
 
    Timer& intCorrectTimer()
    {
        return intCorrectTimer_;
    }
 
    integration& rVelIntegration()
    {
        return rVelIntegration_();
    }
    
public:
 
    sphereParticles(systemControl& control, const property& prop);
 
    ~sphereParticles() override = default;
 
    /*bool insertParticles
    (
    const realx3Vector& position,
        const wordVector&  shapes,
        const setFieldList& setField
    ) override ;*/
 
    // TODO: make this method private later 
    bool initializeParticles();
 
    const auto& spheres() const
    {
        return spheres_;
    }
 
    const auto& I() const
    {
        return I_;
    }
 
    auto& I()
    {
        return I_;
    }
 
    const auto& rVelocity() const
    {
        return rVelocity_;
    }
 
    auto& rVelocity()
    {
        return rVelocity_;
    }
 
    bool hearChanges(
      real           t,
      real           dt,
      uint32         iter,
      const message& msg,
      const anyList& varList
    ) override
    {
        notImplementedFunction;
        return false;
    }
 
    const uint32PointField_D& propertyId() const override
    {
        return propertyId_;
    }
 
    const realPointField_D& diameter() const override
    {
        return diameter_;
    }
 
    const realPointField_D& mass() const override
    {
        return mass_;
    }
 
    bool beforeIteration() override;
 
    bool iterate() override;
 
    bool insertParticles(
      const realx3Vector& position,
      const wordVector&   shapesNames,
      const anyList&      setVarList
    ) override;
 
    realx3PointField_D& rAcceleration() override
    {
        return rAcceleration_;
    }
 
    const realx3PointField_D& rAcceleration() const override
    {
        return rAcceleration_;
    }
 
    const realPointField_D& boundingSphere() const override
    {
        return diameter();
    }
 
    word         shapeTypeName() const override;
 
    const shape& getShapes() const override;
 
    void boundingSphereMinMax(real& minDiam, real& maxDiam) const override;
 
}; // sphereParticles
 
} // pFlow
 
#endif //__sphereParticles_hpp__