particleCreatorFunctions2D.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2021 Nicolas Hafen, Jan E. Marquardt, 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.
*/
 
//TODO: WARNING: For now, there is a lot of code duplication, which has to be sorted out in the future.
 
/* This file contains particle creator functions.
 * Those are generally meant for users to be able to create particles
 * in a comfortable way. As this section might be subject to frequent changes,
 * those should, however, be avoided inside header files. Here, direct field access
 * as shown below should be preferred!
 *
*/
 
 
#ifndef PARTICLE_CREATOR_FUNCTIONS_2D_H
#define PARTICLE_CREATOR_FUNCTIONS_2D_H
 
 
#include "particles/particleSystem.h"
#include "particles/functions/particleCreatorHelperFunctions.h"
 
 
namespace olb {
 
namespace particles {
 
namespace creators {
 
template<typename T, typename PARTICLETYPE, bool ROTATION_IS_OPTIONAL=false>
void setResolvedObject(
  ParticleSystem<T,PARTICLETYPE>& particleSystem,
  std::size_t idxParticle, std::size_t idxSurface,
  const Vector<T,2>& position, T density, T angle,
  const Vector<T,2>& velocity)
{
  setResolvedObject<T,PARTICLETYPE,ROTATION_IS_OPTIONAL>( particleSystem, idxParticle, idxSurface, position, density,
      Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>( angle ), velocity );
}
 
template<typename T, typename PARTICLETYPE>
void addResolvedObject(
  ParticleSystem<T,PARTICLETYPE>& particleSystem, std::size_t idxSurface,
  const Vector<T,2>& position, T density=0., T angle=0.,
  const Vector<T,2>& velocity = Vector<T,2> (0.))
{
  addResolvedObject( particleSystem, idxSurface, position, density,
                     Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>( angle ), velocity );
}
 
 
 
template<typename T, typename PARTICLETYPE>
void setResolvedCircle2D(
  ParticleSystem<T,PARTICLETYPE>& particleSystem,
  std::size_t idxParticle,
  Vector<T,2> position, T radius, T epsilon, T density=0.,
  Vector<T,2> velocity = Vector<T,2>(0.))
{
  using namespace descriptors;
  typedef SmoothIndicatorF2D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCircle2D<T, T, true>(Vector<T,2>(0.), radius, epsilon ));
 
  //Pass smart pointer to particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  std::size_t idxSurface = vectorOfIndicators.size();
  vectorOfIndicators.push_back( std::move(sIndicatorPtr) );
 
  // Safety mechanism for wrong particle type - It is better not to use rotation matrix!
  if constexpr ( PARTICLETYPE::template providesNested<SURFACE,ROT_MATRIX>() ) {
    OstreamManager clout(std::cout, "creatorCircle2D");
    clout << "WARNING: A rotation matrix is provided but is not necessary for a circle." << std::endl;
  }
 
  setResolvedObject<T,PARTICLETYPE,true>(particleSystem, idxParticle, idxSurface,
                                         position, density, 0., velocity);
}
 
template<typename T, typename PARTICLETYPE>
void addResolvedCircle2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                          Vector<T,2> position, T radius, T epsilon, T density=0.,
                          Vector<T,2> velocity = Vector<T,2>(0.))
{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCircle2D( particleSystem, idxParticle, position, radius, epsilon, density, velocity );
}
 
 
 
template<typename T, typename PARTICLETYPE>
void setResolvedCuboid2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                          std::size_t idxParticle,
                          Vector<T,2> position, Vector<T,2> extend, T epsilon, T density=0.,
                          T angle = 0.,
                          Vector<T,2> velocity = Vector<T,2> (0.))
{
  using namespace descriptors;
  typedef SmoothIndicatorF2D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCuboid2D<T, T, true>(Vector<T,2>(0.), extend[0], extend[1], epsilon ));
 
  //Pass smart pointer to particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  std::size_t idxSurface = vectorOfIndicators.size();
  vectorOfIndicators.push_back( std::move(sIndicatorPtr) );
 
  setResolvedObject(particleSystem, idxParticle, idxSurface,
                    position, density, angle, velocity);
}
 
 
template<typename T, typename PARTICLETYPE>
void addResolvedCuboid2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                          Vector<T,2> position, Vector<T,2> extend, T epsilon, T density=0.,
                          T angle = 0.,
                          Vector<T,2> velocity = Vector<T,2> (0.))
{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCuboid2D( particleSystem, idxParticle, position,
                       extend, epsilon, density, angle, velocity );
}
 
 
 
template<typename T, typename PARTICLETYPE>
void setResolvedTriangle2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                            std::size_t idxParticle,
                            Vector<T,2> position, T radius, T epsilon, T density=0.,
                            T angle = 0.,
                            Vector<T,2> velocity = Vector<T,2> (0.))
{
  using namespace descriptors;
  typedef SmoothIndicatorF2D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorTriangle2D<T, T, true>(Vector<T,2>(0.), radius, epsilon ));
 
  //Pass smart pointer to particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  std::size_t idxSurface = vectorOfIndicators.size();
  vectorOfIndicators.push_back( std::move(sIndicatorPtr) );
 
  setResolvedObject(particleSystem, idxParticle, idxSurface,
                    position, density, angle, velocity);
}
 
 
template<typename T, typename PARTICLETYPE>
void addResolvedTriangle2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                            Vector<T,2> position, T radius, T epsilon, T density=0.,
                            T angle = 0.,
                            Vector<T,2> velocity = Vector<T,2> (0.))
{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedTriangle2D( particleSystem, idxParticle, position,
                         radius, epsilon, density, angle, velocity );
}
 
 
 
template<typename T, typename PARTICLETYPE>
void setResolvedArbitraryShape2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                                  std::size_t idxParticle,
                                  Vector<T,2> position,
                                  T latticeSpacing,
                                  std::shared_ptr<IndicatorF2D<T>> indPtr,
                                  T epsilon, T density=0., T angle = 0.,
                                  Vector<T,2> velocity = Vector<T,2> (0.))
{
  using namespace descriptors;
  typedef SmoothIndicatorF2D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCustom2D<T, T, true>(latticeSpacing, indPtr, Vector<T,2> (0.), epsilon, 0.));
 
  //Pass smart pointer to particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  std::size_t idxSurface = vectorOfIndicators.size();
  vectorOfIndicators.push_back( std::move(sIndicatorPtr) );
 
  setResolvedObject(particleSystem, idxParticle, idxSurface,
                    position, density, angle, velocity);
}
 
template<typename T, typename PARTICLETYPE>
void addResolvedArbitraryShape2D( ParticleSystem<T,PARTICLETYPE>& particleSystem,
                                  Vector<T,2> position,
                                  T latticeSpacing,
                                  std::shared_ptr<IndicatorF2D<T>> indPtr,
                                  T epsilon, T density=0., T angle = 0.,
                                  Vector<T,2> velocity = Vector<T,2> (0.))
{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedArbitraryShape2D( particleSystem, idxParticle, position, latticeSpacing, indPtr,
      epsilon, density, angle, velocity );
}
 
} //namespace creators
 
} //namespace particles
 
} //namespace olb
 
#endif