particleDynamicsBase.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2021 Nicolas Hafen, Mathias J. Krause
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
#ifndef PARTICLE_DYNAMICS_BASE_H
#define PARTICLE_DYNAMICS_BASE_H
 
namespace olb {
 
namespace particles {
 
namespace dynamics {
 
 
template<typename T, typename PARTICLETYPE>
struct ParticleDynamics {
  virtual ~ParticleDynamics() { }
  virtual void process(Particle<T,PARTICLETYPE>& particle, T timeStepSize) =0;
  std::string& getName();
  std::string const& getName() const;
private:
  std::string _name;
};
 
template<typename T, typename PARTICLETYPE>
class NoParticleDynamics : public ParticleDynamics<T,PARTICLETYPE> {
public:
  NoParticleDynamics( T rhoDummy );
  void process(Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class VerletParticleDynamics : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamics( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsTranslationOnly : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamicsTranslationOnly( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsRotationOnly : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamicsRotationOnly( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsRotor : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamicsRotor( Vector<T,PARTICLETYPE::d> angVel );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  Vector<T,PARTICLETYPE::d> _angVel;
};
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsVelocityWallReflection
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsVelocityWallReflection( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
};
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsWallCapture
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
};
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialCapture
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialCapture(
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _materialIndicator;
};
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialAwareWallCapture
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialAwareWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _materialIndicator;
};
 
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsEscape
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsEscape ( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
};
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialEscape
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialEscape(
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> materialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _materialIndicator;
};
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialAwareEscape
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialAwareEscape( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> materialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _materialIndicator;
};
 
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialCaptureAndEscape
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialCaptureAndEscape(
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> captureMaterialIndicator,
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> escapeMaterialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _captureMaterialIndicator;
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _escapeMaterialIndicator;
};
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class VerletParticleDynamicsMaterialAwareWallCaptureAndEscape
  : public VerletParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  VerletParticleDynamicsMaterialAwareWallCaptureAndEscape( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> captureMaterialIndicator,
    std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> escapeMaterialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _captureMaterialIndicator;
  std::shared_ptr<SuperIndicatorMaterial<T,PARTICLETYPE::d>> _escapeMaterialIndicator;
};
 
 
template<typename T, typename PARTICLETYPE>
class ParticleDetachmentDynamics
  : public VerletParticleDynamics<T,PARTICLETYPE,conditions::active_particles> {
public:
  ParticleDetachmentDynamics( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
                              Vector<T,PARTICLETYPE::d>& mainFlowDirection,
                              T tiltThreshold = 0.3*M_PI );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  Vector<T,PARTICLETYPE::d> _mainFlowDirection;
  T _tiltThreshold; //Tilt angle initiating particle release
};
 
 
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class EulerParticleDynamics : public ParticleDynamics<T,PARTICLETYPE> {
public:
  EulerParticleDynamics( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class EulerParticleDynamicsMaterialAwareWallCapture
  : public EulerParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  EulerParticleDynamicsMaterialAwareWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary ,
    SuperIndicatorMaterial<T,PARTICLETYPE::d>& materialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& _materialIndicator;
};
 
 
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class EulerParticleDynamicsTranslationOnly : public ParticleDynamics<T,PARTICLETYPE> {
public:
  EulerParticleDynamicsTranslationOnly( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class AnalyticalParticleDynamicsTranslationOnly : public ParticleDynamics<T,PARTICLETYPE> {
public:
  AnalyticalParticleDynamicsTranslationOnly( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
 
 
template<typename T, typename PARTICLETYPE,
         typename PCONDITION=conditions::active_particles>
class AnalyticalParticleDynamicsTranslationOnlyMaterialAwareWallCapture
  : public AnalyticalParticleDynamicsTranslationOnly<T,PARTICLETYPE,PCONDITION> {
public:
  AnalyticalParticleDynamicsTranslationOnlyMaterialAwareWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
    SuperIndicatorMaterial<T,PARTICLETYPE::d>& materialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& _materialIndicator;
};
 
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class EulerSpheroidParticleDynamics : public ParticleDynamics<T,PARTICLETYPE> {
public:
  EulerSpheroidParticleDynamics( );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
};
 
 
template<typename T, typename PARTICLETYPE, typename PCONDITION=conditions::active_particles>
class EulerSpheroidParticleDynamicsPeriodic : public ParticleDynamics<T,PARTICLETYPE> {
public:
  EulerSpheroidParticleDynamicsPeriodic( Vector<int,3> periodic_direction);
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
   Vector<int,3> _periodic_direction;
};
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class EulerSpheroidParticleDynamicsWallCapture
  : public EulerSpheroidParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  EulerSpheroidParticleDynamicsWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
};
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class EulerSpheroidParticleDynamicsMaterialAwareWallCapture
  : public EulerSpheroidParticleDynamics<T,PARTICLETYPE,PCONDITION> {
public:
  EulerSpheroidParticleDynamicsMaterialAwareWallCapture( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& materialIndicator );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& _materialIndicator;
 
};
 
 
template<typename T, typename PARTICLETYPE, bool useCubicBounds=false,
         typename PCONDITION=conditions::active_particles>
class EulerSpheroidParticleDynamicsMaterialAwareWallCapturePeriodic
  : public EulerSpheroidParticleDynamicsPeriodic<T,PARTICLETYPE,PCONDITION> {
public:
  EulerSpheroidParticleDynamicsMaterialAwareWallCapturePeriodic( SolidBoundary<T,PARTICLETYPE::d>& solidBoundary,
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& materialIndicator, Vector<int,3> direction );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  SolidBoundary<T,PARTICLETYPE::d>& _solidBoundary;
  SuperIndicatorMaterial<T,PARTICLETYPE::d>& _materialIndicator;
  Vector<int,3> _direction;
 
};
 
 
 
 
 
 
 
 
//TODO: REWORK FOLLOWING DYNAMICS ACCORDING TO OBOVE ONES
 
 
//TODO: remove for release
template<typename T, typename PARTICLETYPE>
class VerletParticleDynamicsCubicBoundsAdhesion : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamicsCubicBoundsAdhesion( PhysR<T,PARTICLETYPE::d>& domainMin,
      PhysR<T,PARTICLETYPE::d>& domainMax );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  PhysR<T,PARTICLETYPE::d> _domainMin;
  PhysR<T,PARTICLETYPE::d> _domainMax;
};
 
 
//TODO: remove for release
template<typename T, typename PARTICLETYPE, typename DEPOSITION_MODEL>
class VerletParticleDynamicsCubicBoundsDeposition : public ParticleDynamics<T,PARTICLETYPE> {
public:
  VerletParticleDynamicsCubicBoundsDeposition( PhysR<T,PARTICLETYPE::d>& domainMin,
    PhysR<T,PARTICLETYPE::d>& domainMax, DEPOSITION_MODEL& depositionModel );
  void process (Particle<T,PARTICLETYPE>& particle, T timeStepSize) override;
private:
  PhysR<T,PARTICLETYPE::d> _domainMin;
  PhysR<T,PARTICLETYPE::d> _domainMax;
  DEPOSITION_MODEL& _depositionModel;
};
 
} //namespace dynamics
 
} //namespace particles
 
} //namespace olb
 
#endif