grainParticles.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 __grainParticles_hpp__
#define __grainParticles_hpp__
 
#include "indexContainer.hpp"
#include "particles.hpp"
#include "property.hpp"
#include "grainShape.hpp"
#include "boundaryGrainParticlesList.hpp"
#include "systemControl.hpp"
 
namespace pFlow
{
 
class grainParticles : public particles
{
public:
 
    using ShapeType = grainShape;
 
private:
 
    ShapeType              grains_;
 
    uint32PointField_D     propertyId_;
 
    realPointField_D       grainDiameter_;
 
    realPointField_D       coarseGrainFactor_;
 
 
    realPointField_D       mass_;
 
    realPointField_D       I_;
 
    realx3PointField_D     rVelocity_;
 
    realx3PointField_D     rAcceleration_;
 
    boundaryGrainParticlesList boundaryGrainParticles_;
 
    uniquePtr<integration> rVelIntegration_ = nullptr;
 
    Timer                  accelerationTimer_;
 
    Timer                  intPredictTimer_;
 
    Timer                  intCorrectTimer_;
 
    Timer                  fieldUpdateTimer_;
 
private:
    
 
    bool getParticlesInfoFromShape(
      const wordVector& shapeNames,
      uint32Vector&     propIds,
      realVector&       diams,
      realVector&       coarseGrainFactors,
      realVector&       m,
      realVector&       Is,
      uint32Vector&     shIndex
    );
    
protected:
 
    Timer& accelerationTimer()
    {
        return accelerationTimer_;
    }
 
    Timer& intCorrectTimer()
    {
        return intCorrectTimer_;
    }
 
    integration& rVelIntegration()
    {
        return rVelIntegration_();
    }
 
public:
 
    grainParticles(systemControl& control, const property& prop);
 
    ~grainParticles() override = default;
 
    /*bool insertParticles
    (
    const realx3Vector& position,
        const wordVector&  shapes,
        const setFieldList& setField
    ) override ;*/
 
    // TODO: make this method private later 
    bool initializeParticles();
 
    const auto& grains() const
    {
        return grains_;
    }
 
    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 grainDiameter_;
    }
 
    const realPointField_D& grainDiameter()const
    {
        return grainDiameter_;
    }
 
    const realPointField_D& coarseGrainFactor() const 
    {
        return coarseGrainFactor_;
    }
 
 
    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;
 
};// grainParticles
 
} // pFlow
 
#endif //__sphereParticles_hpp__