particleSystem3D.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2015 Thomas Henn, Davide Dapelo
 *  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_SYSTEM_3D_H
#define PARTICLE_SYSTEM_3D_H
 
// Enables particle collision functions
// CollisionModels: Can be used as an alternative to a mechanic contact force
// #define CollisionModels
// CollisionModelsCombindedWithMechContactForce: Can be used in combination with
// a mechanic contact force
// #define CollisionModelsCombindedWithMechContactForce
 
#include <set>
#include <vector>
#include <list>
#include <deque>
#include "contactDetection/contactDetection.h"
#include "geometry/superGeometry.h"
#include "forces/force3D.h"
#include "functors/analytical/analyticalF.h"
#include "boundaries/boundary3D.h"
#include "functors/lattice/latticeFrameChangeF3D.h"
#include "utilities/vectorHelpers.h"
#include "particleOperations/particleOperations3D.h"
#include "particle3D.h"
#include "particleSpecializations/particleSpecializations3D.h"
 
namespace olb {
 
template<typename T, typename DESCRIPTOR>
class SuperLatticeInterpPhysVelocity3D;
 
template<typename T, template<typename U> class PARTICLETYPE>
class Force3D;
template<typename T, template<typename U> class PARTICLETYPE>
class Boundary3D;
template<typename T, template<typename U> class PARTICLETYPE>
class ParticleSystem3D;
template<typename T, template<typename U> class PARTICLETYPE>
class SuperParticleSystem3D;
template<typename T, template<typename U> class PARTICLETYPE>
class SuperParticleSysVtuWriter;
template<typename T>
class SuperParticleSysVtuWriterMag;
 
 
 
 
 
 
template<typename T, template<typename U> class PARTICLETYPE>
class ParticleSystem3D {
private:
  void eraseInactiveParticles();
 
public:
 
  ParticleSystem3D() = default;
  ParticleSystem3D(int iGeometry, SuperGeometry<T,3>& superGeometry);
  ParticleSystem3D(const ParticleSystem3D<T, PARTICLETYPE>& pS);
  ParticleSystem3D(ParticleSystem3D<T, PARTICLETYPE> && pS);
  virtual ~ParticleSystem3D()
  {
    delete _contactDetection;
  }
 
  virtual void simulate(T deltatime, bool scale = false);
  virtual void simulateWithTwoWayCoupling_Mathias ( T dT,
      ForwardCouplingModel<T,PARTICLETYPE>& forwardCoupling,
      BackCouplingModel<T,PARTICLETYPE>& backCoupling,
      int material, int subSteps, bool scale );
  virtual void simulateWithTwoWayCoupling_Davide ( T dT,
      ForwardCouplingModel<T,PARTICLETYPE>& forwardCoupling,
      BackCouplingModel<T,PARTICLETYPE>& backCoupling,
      int material, int subSteps, bool scale );
  // multiple collision models
  virtual void simulate(T deltatime, std::set<int> sActivityOfParticle, bool scale = false);
 
  void printDeep(std::string message="");
 
  int size();
  int sizeInclShadow() const;
  int numOfActiveParticles();
  int numOfForces();
  int countMaterial(int mat = 1);
 
  void addParticle(PARTICLETYPE<T>& p);
  void clearParticles();
  void addForce(std::shared_ptr<Force3D<T, PARTICLETYPE> > pF);
  void addBoundary(std::shared_ptr<Boundary3D<T, PARTICLETYPE> > pB);
  void addParticleOperation(std::shared_ptr<ParticleOperation3D<T, PARTICLETYPE> > pO);
 
  PARTICLETYPE<T>& operator[](const int i);
  const PARTICLETYPE<T>& operator[](const int i) const;
 
  template<typename DESCRIPTOR>
  void setVelToFluidVel(SuperLatticeInterpPhysVelocity3D<T, DESCRIPTOR> &);
 
  void setVelToAnalyticalVel(AnalyticalConst3D<T, T>&);
 
  void setPosExt(std::vector<T> physPos, std::vector<T> physExtend);
 
  const std::vector<T>& getPhysPos();
  const std::vector<T>& getPhysExtend();
 
  void saveToFile(std::string name);
 
  void computeForce();
  // multiple collision models
  void computeForce(std::set<int> sActivityOfParticle)
  {
    computeForce();
  };
 
  void setStoredValues();
 
  struct getMinDistPart {
    bool operator() (std::pair<size_t, T> i, std::pair<size_t, T> j)
    {
      return (i.second < j.second);
    }
  } getMinDistPartObj;
  void getMinDistParticle (std::vector<std::pair<size_t, T>> ret_matches);
 
  void computeBoundary();
 
  void computeParticleOperation();
 
  void setContactDetection(ContactDetection<T, PARTICLETYPE>& contactDetection);
  ContactDetection<T, PARTICLETYPE>* getContactDetection();
 
  //  template<template<typename V> class DESCRIPTOR>
  //  void particleOnFluid(BlockLattice<T, DESCRIPTOR>& bLattice,
  //                       Cuboid3D<T>& cuboid, int overlap, T eps,
  //                       BlockGeometry<T,3>& bGeometry);
  //  template<template<typename V> class DESCRIPTOR>
  //  void resetFluid(BlockLattice<T, DESCRIPTOR>& bLattice,
  //                  Cuboid3D<T>& cuboid, int overlap);
 
  friend class SuperParticleSystem3D<T, PARTICLETYPE>;
  friend class SuperParticleSysVtuWriter<T, PARTICLETYPE>;
  friend class SuperParticleSysVtuWriterMag<T>;
  friend class SimulateParticles<T, PARTICLETYPE>;
 
  //std::map<T, int> radiusDistribution();
 
  void explicitEuler(T dT, bool scale = false);
  // multiple collision models
  void explicitEuler(T dT, std::set<int> sActivityOfParticle, bool scale = false)
  {
    explicitEuler(dT, scale);
  };
  bool executeForwardCoupling(ForwardCouplingModel<T,PARTICLETYPE>& forwardCoupling);
  bool executeBackwardCoupling(BackCouplingModel<T,PARTICLETYPE>& backwardCoupling, int material, int subSteps=1);
 
  ContactDetection<T, PARTICLETYPE>* getDetection()
  {
    return _contactDetection;
  }
 
  int getIGeometry()
  {
    return _iGeometry;
  }
  std::deque<PARTICLETYPE<T>*> getParticlesPointer();
  std::deque<PARTICLETYPE<T>*> getAllParticlesPointer();
  std::deque<PARTICLETYPE<T>*> getShadowParticlesPointer();
 
  std::deque<PARTICLETYPE<T>>& getParticles()
  {
    return _particles;
  }
 
  void removeParticle(typename std::deque<PARTICLETYPE<T> >::iterator& p);
 
  std::list<std::shared_ptr<Force3D<T, PARTICLETYPE> > > getForcesPointer();
 
  std::deque<std::list<PARTICLETYPE<T>*>> _Agglomerates;
 
protected:
  void integrateTorque(T dT);
  void integrateTorqueMag(T dT) {};
  // multiple collision models
  void integrateTorqueMag(T dT, std::set<int> sActivityOfParticle) {};
  void resetMag() {};
  // multiple collision models
  void resetMag(std::set<int> sActivityOfParticle) {};
 
  void setOverlapZero() {};
  void setOverlapZeroForCombinationWithMechContactForce() {};
  void partialElasticImpact(T restitutionCoeff) {};
  void partialElasticImpactV2(T restitutionCoeff) {};
  void partialElasticImpactForCombinationWithMechContactForce(T restitutionCoeff) {};
 
  void findAgglomerates() {};
  void initAggloParticles() {};
 
  void addShadowParticle(PARTICLETYPE<T>& p);
 
  mutable OstreamManager clout;
  int _iGeometry = -1;
  SuperGeometry<T,3>& _superGeometry;
  ContactDetection<T, PARTICLETYPE>* _contactDetection;
  SimulateParticles<T, PARTICLETYPE> _sim;
 
  std::deque<PARTICLETYPE<T> > _particles;
 
  std::deque<PARTICLETYPE<T> > _shadowParticles;
  std::list<std::shared_ptr<Force3D<T, PARTICLETYPE> > > _forces;
  std::list<std::shared_ptr<Boundary3D<T, PARTICLETYPE> > > _boundaries;
  std::list<std::shared_ptr<ParticleOperation3D<T, PARTICLETYPE> > > _particleOperations;
 
  std::vector<T> _physPos;
  std::vector<T> _physExtend;
 
 
  void velocityVerlet1(T dT);
  void velocityVerlet2(T dT);
//  void implicitEuler(T dT, AnalyticalF<3,T,T>& getvel);
//  void adamBashforth4(T dT);
//  void predictorCorrector1(T dT);
//  void predictorCorrector2(T dT);
  void rungeKutta4_1(T dt);
  void rungeKutta4_2(T dt);
  void rungeKutta4_3(T dt);
  void rungeKutta4_4(T dt);
  void rungeKutta4(T dT);
  void updateParticleDistribution();
};
 
// Magnetic particle type
template<>
void ParticleSystem3D<double, MagneticParticle3D>::integrateTorqueMag(double dT);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::integrateTorqueMag(double dT, std::set<int> sActivityOfParticle);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::computeForce();
template<>
void ParticleSystem3D<double, MagneticParticle3D>::computeForce(std::set<int> sActivityOfParticle);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::resetMag();
template<>
void ParticleSystem3D<double, MagneticParticle3D>::resetMag(std::set<int> sActivityOfParticle);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::explicitEuler(double dT, bool scale);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::explicitEuler(double dT, std::set<int> sActivityOfParticle, bool scale);
 
template<>
void ParticleSystem3D<double, MagneticParticle3D>::setOverlapZero();
template<>
void ParticleSystem3D<double, MagneticParticle3D>::setOverlapZeroForCombinationWithMechContactForce();
template<>
void ParticleSystem3D<double, MagneticParticle3D>::partialElasticImpact(double restitutionCoeff);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::partialElasticImpactV2(double restitutionCoeff);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::partialElasticImpactForCombinationWithMechContactForce(double restitutionCoeff);
template<>
void ParticleSystem3D<double, MagneticParticle3D>::findAgglomerates();
template<>
void ParticleSystem3D<double, MagneticParticle3D>::initAggloParticles();
 
}  //namespace olb
#endif /* PARTICLE_SYSTEM_3D_H */