particle.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_H
#define PARTICLE_H
 
#include "core/fieldArrayD.h"
#include "core/blockDynamicsMap.h"
 
namespace olb {
 
namespace particles{
 
//Forward declaration
namespace dynamics {
template<typename T, typename PARTICLETYPE> struct ParticleDynamics;
}
 
 
//Particle interface as pendent to cell interface
template <typename T, typename PARTICLETYPE>
class Particle {
private:
  using DATA = DynamicFieldGroupsD<T, typename PARTICLETYPE::fields_t>;
  DATA& _dynamicFieldGroupsD;
  std::vector<std::shared_ptr<dynamics::ParticleDynamics<T,PARTICLETYPE>>>& _dynamicsVector;
  std::size_t _iParticle;
public:
  Particle( DATA& dynamicFieldGroupsD,
            std::vector<std::shared_ptr<dynamics::ParticleDynamics<T,PARTICLETYPE>>>& dynamicsVector,
            std::size_t iParticle );
 
  void init();
 
  template<bool multiOutput=PARTICLETYPE::template providesNested<descriptors::PARALLELIZATION>()>
  void print(std::size_t iParticle);
  template<bool multiOutput=PARTICLETYPE::template providesNested<descriptors::PARALLELIZATION>()>
  void print();
 
  std::size_t getId() const;
 
  void setId( std::size_t iParticle );
 
  void advanceId();
 
  void addDynamics(std::shared_ptr<dynamics::ParticleDynamics<T,PARTICLETYPE>>& dynamicsSPtr );
 
  template <typename DYNAMICS, typename ...Args>
  void defineDynamics(Args&& ...args);
 
  template<bool boundsCheck=false>
  dynamics::ParticleDynamics<T,PARTICLETYPE>* getDynamics(unsigned iDyn=0);
 
  void process(T timeStepSize, unsigned short iDyn=0);
 
 
  template <typename GROUP, typename FIELD>
  std::enable_if_t<(
    PARTICLETYPE::template size<
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>
      >() > 1),
      FieldD<T,PARTICLETYPE,
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>>>
          getField();
 
  template <typename GROUP, typename FIELD>
  std::enable_if_t<(
    PARTICLETYPE::template size<
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>
      >() == 1),
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>::template value_type<T>>
  getField();
 
  template <typename GROUP, typename FIELD>
  std::enable_if_t<(
    PARTICLETYPE::template size<
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>
      >() > 1),
      void>
      setField(const FieldD<T,PARTICLETYPE,
               typename PARTICLETYPE::template derivedField<GROUP>
               ::template derivedField<FIELD>>& v);
 
  template <typename GROUP, typename FIELD>
  std::enable_if_t<(
    PARTICLETYPE::template size<
      typename PARTICLETYPE::template derivedField<GROUP>::template derivedField<FIELD>
      >() == 1),
      void>
      setField( typename PARTICLETYPE::template derivedField<GROUP>
                ::template derivedField<FIELD>
                ::template value_type<T> value );
 
 
  using Communicatable = typename GroupedDataCommunicatableHelper<DATA,PARTICLETYPE>::type;
  Communicatable getCommunicatable(){
    return Communicatable(_dynamicFieldGroupsD);
  }
  std::size_t getSerialSize() const {
    const std::vector<unsigned int> indices{static_cast<unsigned int>(_iParticle)};
    return Communicatable(_dynamicFieldGroupsD).size(indices);
  }
  std::size_t serialize(std::uint8_t* buffer) const {
    const std::vector<unsigned int> indices{static_cast<unsigned int>(_iParticle)};
    return Communicatable(_dynamicFieldGroupsD).serialize(indices, buffer);
  }
  std::size_t deserialize(const std::uint8_t* buffer){
    const std::vector<unsigned int> indices{static_cast<unsigned int>(_iParticle)};
    return Communicatable(_dynamicFieldGroupsD).deserialize(indices, buffer);
  }
 
};
 
} //namespace particles
 
} //namespace olb
 
#endif