olb::particles::creators Namespace Reference

Classes
struct	SpawnData

Functions
template<typename T , typename PARTICLETYPE >
std::set< int >	prepareParallelResolvedParticle (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, Vector< T, PARTICLETYPE::d > position, T circumRadius, const T epsilon, int &globiCcentre, const T physDeltaX, const Vector< bool, PARTICLETYPE::d > &periodicity)
template<typename T , typename PARTICLETYPE >
Particle< T, PARTICLETYPE >	assignParallelResolvedParticleToiC (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxSurface, std::size_t globID, int globiCcentre, const Vector< T, PARTICLETYPE::d > &position, T density=0., const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &angleInDegree=Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >(0.), const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.))
template<typename T , typename PARTICLETYPE >
bool	assignParallelResolvedParticle (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::set< int > &setOfICs, int globiC, std::size_t idxSurface, std::size_t globID, std::size_t &localID, int globiCcentre, const Vector< T, PARTICLETYPE::d > &position, T density=0., const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &angleInDegree=Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >(0.), const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedObject (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, std::size_t idxSurface, const Vector< T, PARTICLETYPE::d > &position, T density=0., const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &angleInDegree=Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >(0.), const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.), const Vector< bool, PARTICLETYPE::d > &periodicity=Vector< T, PARTICLETYPE::d >(false))
template<typename T , typename PARTICLETYPE , typename F >
std::size_t	addSurface (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, F createUniqueIndicatorPtr)
	Adds surface (SmoothIndicator) to all block particle systems.
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedSphere3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T radius, T epsilon, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), const Vector< bool, 3 > &periodicity=Vector< bool, 3 >(false))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedCuboid3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, const Vector< T, 3 > &extend, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), const Vector< bool, 3 > &periodicity=Vector< bool, 3 >(false))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedCylinder3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, const Vector< T, 3 > &normal, T height, T radius, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), const Vector< bool, 3 > &periodicity=Vector< bool, 3 >(false))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedArbitraryShape3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T latticeSpacing, std::shared_ptr< IndicatorF3D< T > > indPtr, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), const Vector< bool, 3 > &periodicity=Vector< bool, 3 >(false))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addResolvedCircle2D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 2 > &position, T radius, T epsilon, T density=0., const Vector< T, 2 > &velocity=Vector< T, 2 >(0.), const Vector< bool, 2 > &periodicity=Vector< bool, 2 >(false))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addSubgridSphere3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T radius, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
template<typename T , typename PARTICLETYPE >
ParallelParticleLocator	addSubgridSphereWithSpecies3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T radius, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), const int species=0)
template<typename T , unsigned D>
T	calcParticleVolume (const std::vector< SpawnData< T, D > > &spawnData, const std::function< T(const std::size_t &)> &getParticleVolume)
template<typename T , unsigned D>
T	calcParticleVolumeFraction (const std::vector< SpawnData< T, D > > &spawnData, const T fluidVolume, const std::function< T(const std::size_t &)> &getParticleVolume)
template<typename T , unsigned D>
void	extendSpawnData (std::vector< SpawnData< T, D > > &spawnData, const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const std::function< T(const std::size_t &)> &getCircumRadius, const std::function< T(const std::size_t &)> &getParticleVolume)
template<typename T , unsigned D>
std::vector< SpawnData< T, D > >	setParticles (const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const std::function< T(const std::size_t &)> &getCircumRadius, const std::function< T(const std::size_t &)> &getParticleVolume, const std::function< void(const SpawnData< T, D > &, const std::size_t &)> createParticle)
std::vector< std::vector< std::string > >	readParticlePositions (const std::string &filename)
template<typename T , unsigned D>
void	saveParticlePositions (const std::string &filename, const std::vector< SpawnData< T, D > > &spawnData, const std::function< std::string(const std::size_t &)> &evalIdentifier)
template<typename T , unsigned D>
std::vector< SpawnData< T, D > >	setParticles (const std::string &filename, const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const std::function< T(const std::size_t &)> &getParticleVolume, const std::function< void(const SpawnData< T, D > &, const std::string &)> createParticle)
template<typename T , unsigned D>
void	extendSpawnData (std::vector< SpawnData< T, D > > &spawnData, const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMin, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMax, const std::function< T(const std::size_t &)> &getParticleVolume)
template<typename T , unsigned D>
std::vector< SpawnData< T, D > >	setParticles (const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMin, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMax, const std::function< T(const std::size_t &)> &getParticleVolume, const std::function< void(const SpawnData< T, D > &, const std::size_t &)> createParticle)
template<typename T , unsigned D>
void	extendSpawnData (std::vector< SpawnData< T, D > > &spawnData, const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const T deltaX, const T contactDetectionDistance, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMin, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMax, const std::function< T(const std::size_t &, const SpawnData< T, D > &, const PhysR< T, D > &)> &signedDistanceToParticle, const std::function< T(const std::size_t &)> &getParticleVolume)
template<typename T , unsigned D>
std::vector< SpawnData< T, D > >	setParticles (const T wantedParticleVolumeFraction, IndicatorF< T, D > &fluidDomain, const T fluidDomainVolume, const T deltaX, const T contactDetectionDistance, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMin, const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &getMax, const std::function< T(const std::size_t &, const SpawnData< T, D > &, const PhysR< T, D > &)> &signedDistanceToParticle, const std::function< T(const std::size_t &)> &getParticleVolume, const std::function< void(const SpawnData< T, D > &, const std::size_t &)> createParticle)
template<typename T , typename PARTICLETYPE >
std::vector< SpawnData< T, PARTICLETYPE::d > >	updateParticlePositions (std::vector< SpawnData< T, PARTICLETYPE::d > > spawnData, XParticleSystem< T, PARTICLETYPE > &particleSystem, MPI_Comm particleCreatorComm=MPI_COMM_WORLD)
	Updates particle positions so that they can be easily written to a txt file with the function above.
template<typename T , typename PARTICLETYPE >
std::vector< SpawnData< T, PARTICLETYPE::d > >	saveUpdatedParticlePositions (const std::string &filename, const std::vector< SpawnData< T, PARTICLETYPE::d > > &originalSpawnData, const std::function< std::string(const std::size_t &)> &evalIdentifier, XParticleSystem< T, PARTICLETYPE > &particleSystem, MPI_Comm particleCreatorComm=MPI_COMM_WORLD)
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)
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.))
	Add resolved object as new particle with existing surface.
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.))
	Set resolved circle for existing particle but new surface.
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.))
	Add resolved circle as new particle with new surface.
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.))
	Set resolved cuboid for existing particle but new surface.
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.))
	Add resolved cuboid as new particle with new surface.
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.))
	Set resolved cuboid for existing particle but new surface.
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.))
	Add resolved triangle as new particle with new surface.
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.))
	Set resolved cuboid for existing particle but new surface.
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.))
	Add resolved arbitrary shape as new particle with new surface.
template<typename T , typename PARTICLETYPE , bool IGNORE_WARNINGS = false>
void	setResolvedSphere3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, T radius, T epsilon, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Set resolved sphere for existing particle but new surface.
template<typename T , typename PARTICLETYPE , bool IGNORE_WARNINGS = false>
void	addResolvedSphere3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, T radius, T epsilon, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Add resolved sphere as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	setResolvedCylinder3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, const Vector< T, 3 > &normal, T height, T radius, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Set resolved cylinder for existing particle but new surface.
template<typename T , typename PARTICLETYPE >
void	addResolvedCylinder3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, const Vector< T, 3 > &normal, T height, T radius, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Add resolved cylinder as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	setResolvedCuboid3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, const Vector< T, 3 > &extend, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Set resolved cuboid for existing particle but new surface.
template<typename T , typename PARTICLETYPE >
void	addResolvedCuboid3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, const Vector< T, 3 > &extend, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Add resolved cuboid as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	setResolvedCone3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position1, const Vector< T, 3 > &position2, T radius1, T radius2, T epsilon, T density=0, const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Set resolved cone for existing particle but new surface.
template<typename T , typename PARTICLETYPE >
void	addResolvedCone3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position1, const Vector< T, 3 > &position2, T radius1, T radius2, T epsilon, T density=0, const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Add resolved cone as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	setResolvedEllipsoid3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, const Vector< T, 3 > &radius, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Set resolved ellipsoid for existing particle but new surface.
template<typename T , typename PARTICLETYPE >
void	addResolvedEllipsoid3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, const Vector< T, 3 > &radius, T epsilon, T density=0., const Vector< T, 3 > &angleInDegree=Vector< T, 3 >(0.), const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
	Add resolved ellipsoid as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	setResolvedArbitraryShape3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, Vector< T, 3 > position, T latticeSpacing, std::shared_ptr< IndicatorF3D< T > > indPtr, T epsilon, T density=0., Vector< T, 3 > angleInDegree=Vector< T, 3 >(0.), Vector< T, 3 > velocity=Vector< T, 3 >(0.))
	Set resolved cuboid for existing particle but new surface.
template<typename T , typename PARTICLETYPE >
void	addResolvedArbitraryShape3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, Vector< T, 3 > position, T latticeSpacing, std::shared_ptr< IndicatorF3D< T > > indPtr, T epsilon, T density=0., Vector< T, 3 > angleInDegree=Vector< T, 3 >(0.), Vector< T, 3 > velocity=Vector< T, 3 >(0.))
	Add resolved arbitrary shape as new particle with new surface.
template<typename T , typename PARTICLETYPE >
void	addSubgridSphere3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, T radius, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
template<typename T , typename PARTICLETYPE >
void	setSubgridHaiderLevenspielObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, PARTICLETYPE::d > &position, T radius, T sphericity, T mass, T density, const Vector< T, PARTICLETYPE::d > &velocity, T lengthP=1., T diameterP=1.)
	Set new particle.
template<typename T , typename PARTICLETYPE >
void	addSubgridHaiderLevenspielObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, PARTICLETYPE::d > &position, T radius, T sphericity, T mass=0., T density=1., const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.), T lengthP=1., T diameterP=1.)
	Add subgrid object as new particle.
template<typename T , typename PARTICLETYPE >
void	addSubgridHaiderLevenspiel3D (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, 3 > &position, T surface, T volume, T density=0., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), T lengthP=1., T diameterP=1.)
template<typename T , typename PARTICLETYPE >
void	addSubgridHaiderLevenspiel3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T surface, T volume, T density=1., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.), T lengthP=1., T diameterP=1.)
template<typename T , typename PARTICLETYPE >
void	setSubgridTranCongObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, PARTICLETYPE::d > &position, T radius, T c, T A_p, T dA_dnn, T mass, T density, const Vector< T, PARTICLETYPE::d > &velocity)
	Set new particle Tran Cong.
template<typename T , typename PARTICLETYPE >
void	addSubgridTranCongObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, PARTICLETYPE::d > &position, T radius, T c, T A_p, T dA_dn, T mass=0., T density=1., const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.))
template<typename T , typename PARTICLETYPE >
void	addSubgridTranCongFromCylinder3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T length, T diameter, T _angle=0., T density=1., const Vector< T, 3 > &velocity=Vector< T, 3 >(0.))
template<typename T , typename PARTICLETYPE >
void	setSubgridEulerRotationSpheroid (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, T length, T diameter, T density=1., Vector< T, 4 > quaternion=Vector< T, 4 >(0., 0., 0., 1.), Vector< T, 3 > velocity=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > ang_velocity=Vector< T, 3 >(0., 0., 0.), int label=0)
	EULER ROTATION SPHEROIDS.
template<typename T , typename PARTICLETYPE >
void	setSubgridEulerRotationSpheroid (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, 3 > &position, T length, T diameter, T density=1., Vector< T, 3 > eul_ang=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > velocity=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > ang_velocity=Vector< T, 3 >(0., 0., 0.), int label=0)
template<typename T , typename PARTICLETYPE >
void	addSubgridEulerRotationSpheroid (ParticleSystem< T, PARTICLETYPE > &ParticleSystem, const Vector< T, 3 > &position, T length, T diameter, T density=1., Vector< T, 4 > quaternion=Vector< T, 4 >(0., 0., 0., 1.), Vector< T, 3 > velocity=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > ang_velocity=Vector< T, 3 >(0., 0., 0.), int label=0)
template<typename T , typename PARTICLETYPE >
void	addSubgridEulerRotationSpheroid (ParticleSystem< T, PARTICLETYPE > &ParticleSystem, const Vector< T, 3 > &position, T length, T diameter, T density=1., Vector< T, 3 > eul_ang=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > velocity=Vector< T, 3 >(0., 0., 0.), Vector< T, 3 > ang_velocity=Vector< T, 3 >(0., 0., 0.), int label=0)
template<typename T , typename PARTICLETYPE >
void	addSubgridEulerRotationSpheroid3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T length, T diameter, T density=1., const Vector< T, 3 > velocity=Vector< T, 3 >(0.), const Vector< T, 3 > eul_ang=Vector< T, 3 >(0., 0., 0.), const Vector< T, 3 > ang_velocity=Vector< T, 3 >(0.), int label=0)
template<typename T , typename PARTICLETYPE >
void	addSubgridEulerRotationSpheroid3D (SuperParticleSystem< T, PARTICLETYPE > &sParticleSystem, const Vector< T, 3 > &position, T length, T diameter, T density=1., const Vector< T, 3 > velocity=Vector< T, 3 >(0.), const Vector< T, 4 > eul_quat=Vector< T, 4 >(0., 0., 0., 1.), const Vector< T, 3 > ang_velocity=Vector< T, 3 >(0.), int label=0)
template<typename PARTICLETYPE , bool ROTATION_IS_OPTIONAL = false>
void	checkForErrors ()
template<typename T , typename PARTICLETYPE , bool ROTATION_IS_OPTIONAL = false>
Particle< T, PARTICLETYPE >	setResolvedObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, std::size_t idxSurface, const Vector< T, PARTICLETYPE::d > &position, T density, Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > angleInDegree, const Vector< T, PARTICLETYPE::d > &velocity)
	Set new particle for existing surface (and return particle object)
template<typename T , typename PARTICLETYPE >
Particle< T, PARTICLETYPE >	addResolvedObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxSurface, const Vector< T, PARTICLETYPE::d > &position, T density=0., const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &angleInDegree=Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >(0.), const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.))
	Add resolved object as new particle with existing surface (and return particle object)
template<typename T , typename PARTICLETYPE >
Particle< T, PARTICLETYPE >	setSubgridObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, std::size_t idxParticle, const Vector< T, PARTICLETYPE::d > &position, T radius, T density, const Vector< T, PARTICLETYPE::d > &velocity, T shapeFactor=T{1})
	Set new particle (and return particle object)
template<typename T , typename PARTICLETYPE >
Particle< T, PARTICLETYPE >	addSubgridObject (ParticleSystem< T, PARTICLETYPE > &particleSystem, const Vector< T, PARTICLETYPE::d > &position, T radius, T density=0., const Vector< T, PARTICLETYPE::d > &velocity=Vector< T, PARTICLETYPE::d >(0.))
	Add subgrid object as new particle (and return particle object)

Function Documentation

addResolvedArbitraryShape2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Add resolved arbitrary shape as new particle with new surface.

Set resolved arbitrary shape 2D at given index

Definition at line 252 of file particleCreatorFunctions2D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedArbitraryShape2D( particleSystem, idxParticle, position, latticeSpacing, indPtr,
      epsilon, density, angle, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedArbitraryShape2D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedArbitraryShape3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedArbitraryShape3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		Vector< T, 3 >	position,
		T	latticeSpacing,
		std::shared_ptr< IndicatorF3D< T > >	indPtr,
		T	epsilon,
		T	density = 0.,
		Vector< T, 3 >	angleInDegree = Vector<T,3> (0.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.) )

Add resolved arbitrary shape as new particle with new surface.

Set resolved arbitrary shape 3D at given index

Definition at line 337 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedArbitraryShape3D( particleSystem, idxParticle, position,
      latticeSpacing, indPtr, epsilon, density, angleInDegree, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedArbitraryShape3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedArbitraryShape3D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedArbitraryShape3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	latticeSpacing,
		std::shared_ptr< IndicatorF3D< T > >	indPtr,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		const Vector< bool, 3 > &	periodicity = Vector<bool,3>(false) )

Definition at line 345 of file particleParallelCreatorFunctions3D.h.

{
  //Get circumRadius and set angleInDegree
  T circumRadius = SmoothIndicatorCustom3D<T,T,true>(
      latticeSpacing, indPtr, PhysR<T, 3>(T {}), epsilon, angleInDegree).getCircumRadius();
 
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
 
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, epsilon, globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  std::size_t idxSurface = addSurface(sParticleSystem,
      [&](){
        return std::make_unique<SmoothIndicatorCustom3D<T, T, true>>(
          latticeSpacing, indPtr, PhysR<T, 3>(T {}), epsilon, angleInDegree);
      });
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Do for all iCs
 
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References addSurface(), assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

addResolvedCircle2D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedCircle2D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		Vector< T, 2 >	position,
		T	radius,
		T	epsilon,
		T	density = 0.,
		Vector< T, 2 >	velocity = Vector<T,2>(0.) )

Add resolved circle as new particle with new surface.

Set resolved circle 2D at given index

Definition at line 109 of file particleCreatorFunctions2D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCircle2D( particleSystem, idxParticle, position, radius, epsilon, density, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedCircle2D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedCircle2D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedCircle2D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 2 > &	position,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 2 > &	velocity = Vector<T,2> (0.),
		const Vector< bool, 2 > &	periodicity = Vector<bool,2>(false) )

Definition at line 394 of file particleParallelCreatorFunctions3D.h.

{
  //Get circumRadius and set angleInDegree
  T circumRadius = SmoothIndicatorCircle2D<T,T,true>(
    Vector<T,2> (0.), radius, epsilon).getCircumRadius();
  Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>
    angleInDegree(0.);
 
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
 
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, epsilon, globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  std::size_t idxSurface = addSurface(sParticleSystem,
      [&](){
        return std::make_unique<SmoothIndicatorCircle2D<T, T, true>>(Vector<T,2> (0.), radius, epsilon );
      });
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Do for all iCs
 
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References addSurface(), assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SmoothIndicatorF2D< T, S, false >::getCircumRadius(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

addResolvedCone3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedCone3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position1,
		const Vector< T, 3 > &	position2,
		T	radius1,
		T	radius2,
		T	epsilon,
		T	density = 0,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Add resolved cone as new particle with new surface.

Set resolved cone 3D at given index

Definition at line 234 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCone3D( particleSystem, idxParticle,
                     position1, position2, radius1, radius2, epsilon, density, angleInDegree, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedCone3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedCuboid2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Add resolved cuboid as new particle with new surface.

Set resolved cuboid 2D at given index

Definition at line 155 of file particleCreatorFunctions2D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCuboid2D( particleSystem, idxParticle, position,
                       extend, epsilon, density, angle, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedCuboid2D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedCuboid3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedCuboid3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	extend,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Add resolved cuboid as new particle with new surface.

Set resolved cuboid 3D at given index

Definition at line 184 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCuboid3D( particleSystem, idxParticle, position,
                       extend, epsilon, density, angleInDegree, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedCuboid3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedCuboid3D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedCuboid3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	extend,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		const Vector< bool, 3 > &	periodicity = Vector<bool,3>(false) )

Definition at line 249 of file particleParallelCreatorFunctions3D.h.

{
  //Get circumRadius
  T circumRadius = SmoothIndicatorCuboid3D<T,T,true>(
    extend[0], extend[1], extend[2], Vector<T,3>(0.), epsilon ).getCircumRadius();
 
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
 
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, epsilon, globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  std::size_t idxSurface = addSurface(sParticleSystem,
      [&](){
        return std::make_unique<SmoothIndicatorCuboid3D<T, T, true>>(
            extend[0], extend[1], extend[2], Vector<T,3>(0.), epsilon );
      });
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Do for all iCs
 
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  //Return globiC, globID, localiD
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References addSurface(), assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SmoothIndicatorF3D< T, S, false >::getCircumRadius(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

addResolvedCylinder3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedCylinder3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	normal,
		T	height,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Add resolved cylinder as new particle with new surface.

Set resolved cylinder 3D at given index

Definition at line 135 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedCylinder3D( particleSystem, idxParticle, position,
                         normal, height, radius, epsilon, density, angleInDegree, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedCylinder3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedCylinder3D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedCylinder3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	normal,
		T	height,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		const Vector< bool, 3 > &	periodicity = Vector<bool,3>(false) )

Definition at line 298 of file particleParallelCreatorFunctions3D.h.

{
  //Get circumRadius and set angleInDegree
  T circumRadius = SmoothIndicatorCylinder3D<T,T,true>(Vector<T,3>(0.), normal, radius, height, epsilon ).getCircumRadius();
 
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
 
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, epsilon, globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  std::size_t idxSurface = addSurface(sParticleSystem,
      [&](){
        return std::make_unique<SmoothIndicatorCylinder3D<T, T, true>>(
            Vector<T,3>(0.), normal, radius, height, epsilon );
      });
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Do for all iCs
 
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References addSurface(), assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SmoothIndicatorF3D< T, S, false >::getCircumRadius(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

addResolvedEllipsoid3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addResolvedEllipsoid3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Add resolved ellipsoid as new particle with new surface.

Set resolved ellipsoid 3D at given index

Definition at line 285 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedEllipsoid3D( particleSystem, idxParticle, position,
                          radius, epsilon, density, angleInDegree, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedEllipsoid3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedObject() [1/3]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Add resolved object as new particle with existing surface.

Set resolved object 2D at given index

Definition at line 62 of file particleCreatorFunctions2D.h.

{
  addResolvedObject( particleSystem, idxSurface, position, density,
                     Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>( angle ), velocity );
}

References addResolvedObject().

Here is the call graph for this function:

addResolvedObject() [2/3]

template<typename T , typename PARTICLETYPE >

Particle< T, PARTICLETYPE > olb::particles::creators::addResolvedObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxSurface,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	density = 0.,
		const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &	angleInDegree = Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation> (0.),
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.) )

Add resolved object as new particle with existing surface (and return particle object)

Set resolved object 3D at given index

Return new particle object

Definition at line 101 of file particleCreatorHelperFunctions.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedObject( particleSystem, idxParticle, idxSurface, position, density, angleInDegree, velocity );
 
  return particleSystem.get(idxParticle);
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedObject() [3/3]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedObject	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		std::size_t	idxSurface,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	density = 0.,
		const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &	angleInDegree = Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation> (0.),
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.),
		const Vector< bool, PARTICLETYPE::d > &	periodicity = Vector<T,PARTICLETYPE::d>(false) )

Definition at line 129 of file particleParallelCreatorFunctions3D.h.

{
  //Retrieve circumRadius from smoothIndicator
  constexpr unsigned D = PARTICLETYPE::d;
  typedef SmoothIndicatorF<T,T,D,true> SIndicatorBaseType;
  auto bParticleSystems = sParticleSystem.getBlockParticleSystems();
  auto& particleSystem = *bParticleSystems[0]; //Use first randomly
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  T circumRadius = vectorOfIndicators[idxSurface]->getCircumRadius();
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, vectorOfIndicators[idxSurface].get()->getEpsilon(), globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  //Return globiC, globID, localiD
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getBlockParticleSystems(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

addResolvedSphere3D() [1/2]

template<typename T , typename PARTICLETYPE , bool IGNORE_WARNINGS = false>

void olb::particles::creators::addResolvedSphere3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Add resolved sphere as new particle with new surface.

Set resolved sphere 3D at given index

Definition at line 87 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedSphere3D<T,PARTICLETYPE,IGNORE_WARNINGS>(
      particleSystem, idxParticle, position, radius, epsilon, density, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedSphere3D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addResolvedSphere3D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addResolvedSphere3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		const Vector< bool, 3 > &	periodicity = Vector<bool,3>(false) )

Definition at line 201 of file particleParallelCreatorFunctions3D.h.

{
  //Get circumRadius and set angleInDegree
  T circumRadius = SmoothIndicatorSphere3D<T,T,true>(
    Vector<T,3> (0.), radius, epsilon).getCircumRadius();
  Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>
    angleInDegree(0.);
 
  //Get new global particle id
  std::size_t globID = sParticleSystem.getGlobID();
 
  //Prepare particle and get list of touching iCs
  int globiCcentre;
  std::set<int> setOfICs = prepareParallelResolvedParticle(sParticleSystem,
    position, circumRadius, epsilon, globiCcentre,
    sParticleSystem.getSuperStructure().getCuboidDecomposition().getMotherCuboid().getDeltaR(),
    periodicity);
 
  std::size_t idxSurface = addSurface(sParticleSystem,
      [&](){
        return std::make_unique<SmoothIndicatorSphere3D<T, T, true>>(Vector<T,3> (0.), radius, epsilon );
      });
 
  //Iterate over particle systems
  std::size_t localIDcentre=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
    //Do for all iCs
 
    //Assigne resolved particle to iCs specified in setOfICs
    std::size_t localID=0;
    assignParallelResolvedParticle( particleSystem, setOfICs, globiC,
      idxSurface, globID, localID, globiCcentre,
      position, density, angleInDegree, velocity );
    //Set localID if centre
    if (globiC==globiCcentre){ localIDcentre=localID; }
  });
 
  //Return globiC, globID, localiD
  return ParallelParticleLocator(globiCcentre, globID, localIDcentre);
}

References addSurface(), assignParallelResolvedParticle(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::SmoothIndicatorF3D< T, S, false >::getCircumRadius(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and prepareParallelResolvedParticle().

Here is the call graph for this function:

addResolvedTriangle2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Add resolved triangle as new particle with new surface.

Set resolved triangle 2D at given index

Definition at line 203 of file particleCreatorFunctions2D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setResolvedTriangle2D( particleSystem, idxParticle, position,
                         radius, epsilon, density, angle, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setResolvedTriangle2D(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridEulerRotationSpheroid() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridEulerRotationSpheroid	(	ParticleSystem< T, PARTICLETYPE > &	ParticleSystem,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		Vector< T, 3 >	eul_ang = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	ang_velocity = Vector<T,3> (0.,0.,0.),
		int	label = 0 )

Definition at line 732 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = ParticleSystem.size();
 
  //Initialize particle address
 
  ParticleSystem.extend();
  setSubgridEulerRotationSpheroid( ParticleSystem, idxParticle,
    position, length, diameter, density , eul_ang, velocity, ang_velocity, label );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setSubgridEulerRotationSpheroid(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridEulerRotationSpheroid() [2/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridEulerRotationSpheroid	(	ParticleSystem< T, PARTICLETYPE > &	ParticleSystem,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		Vector< T, 4 >	quaternion = Vector<T,4> (0.,0.,0.,1.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	ang_velocity = Vector<T,3> (0.,0.,0.),
		int	label = 0 )

Definition at line 713 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = ParticleSystem.size();
 
  //Initialize particle address
 
  ParticleSystem.extend();
  setSubgridEulerRotationSpheroid( ParticleSystem, idxParticle,
    position, length, diameter, density , quaternion, velocity, ang_velocity, label );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setSubgridEulerRotationSpheroid(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

addSubgridEulerRotationSpheroid3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridEulerRotationSpheroid3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		const Vector< T, 3 >	velocity = Vector<T,3> (0.),
		const Vector< T, 3 >	eul_ang = Vector<T,3> (0.,0.,0.),
		const Vector< T, 3 >	ang_velocity = Vector<T,3> (0.),
		int	label = 0 )

Definition at line 753 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  bool inDomain = false;
  if (auto iC = cuboidDecomposition.getC(position)) {
    inDomain = true;
    globiCcentre = *iC;
  }
  if (!inDomain){ std::cerr << "ERROR: Particle added outside domain!" << std::endl; }
  //Iterate over particle systems
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
  //Do only on residence iC
  if (globiC == globiCcentre){
    //Run creator on particleSystem
 
  addSubgridEulerRotationSpheroid( particleSystem,
    position, length, diameter, density, eul_ang, velocity, ang_velocity, label );
      //Add additional data due to parallization
      auto particle = particleSystem.get(particleSystem.size()-1);
      particle.template setField<PARALLELIZATION,ID>( globID );
      //Reinforcing default values
      particle.template setField<GENERAL,INVALID>( false );
    }
  });
}

References addSubgridEulerRotationSpheroid(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridEulerRotationSpheroid3D() [2/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridEulerRotationSpheroid3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		const Vector< T, 3 >	velocity = Vector<T,3> (0.),
		const Vector< T, 4 >	eul_quat = Vector<T,4> (0.,0.,0.,1.),
		const Vector< T, 3 >	ang_velocity = Vector<T,3> (0.),
		int	label = 0 )

Definition at line 794 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition= sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  bool inDomain = false;
  if (auto iC = cuboidDecomposition.getC(position)) {
    inDomain = true;
    globiCcentre = *iC;
  }
  if (!inDomain){ std::cerr << "ERROR: Particle added outside domain!" << std::endl; }
  //Iterate over particle systems
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
    //Do only on residence iC
    if (globiC == globiCcentre){
      //Run creator on particleSystem
      T a = diameter/2.;//semi_minor_axis
 
  addSubgridEulerRotationSpheroid( particleSystem,
    position, length, diameter, density, eul_quat, velocity, ang_velocity, label );
      //Add additional data due to parallization
      auto particle = particleSystem.get(particleSystem.size()-1);
      particle.template setField<PARALLELIZATION,ID>( globID );
      //Reinforcing default values
      particle.template setField<GENERAL,INVALID>( false );
    }
  });
}

References addSubgridEulerRotationSpheroid(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridHaiderLevenspiel3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridHaiderLevenspiel3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		T	surface,
		T	volume,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		T	lengthP = 1.,
		T	diameterP = 1. )

Definition at line 430 of file particleCreatorFunctions3D.h.

{
  //volume equivalent radius used
  T radius=util::pow(3*volume/(4*3.141592653),0.33333333333333);
  T sphericity = (4*M_PI*std::pow(3*volume/(4*M_PI),0.66666666666))/surface;
  T mass = density*volume;
  addSubgridHaiderLevenspielObject( particleSystem,
    position, radius, sphericity, mass, velocity, lengthP, diameterP );
}

References addSubgridHaiderLevenspielObject(), M_PI, and olb::util::pow().

Here is the call graph for this function:

addSubgridHaiderLevenspiel3D() [2/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridHaiderLevenspiel3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	surface,
		T	volume,
		T	density = 1.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		T	lengthP = 1.,
		T	diameterP = 1. )

Definition at line 446 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  bool inDomain = false;
  if (auto iC = cuboidDecomposition.getC(position)) {
    inDomain = true;
    globiCcentre = *iC;
  }
  if (!inDomain){ std::cerr << "ERROR: Particle added outside domain!" << std::endl; }
  //Iterate over particle systems
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
  //Do only on residence iC
  if (globiC == globiCcentre){
  //Run creator on particleSystem
  T radius=util::pow(3*volume/(4*3.141592653),0.33333333333333);//volume equivalent
  T sphericity = (4*M_PI*std::pow(3*volume/(4*M_PI),0.66666666666))/surface;
  T mass = density*volume;
  addSubgridHaiderLevenspielObject( particleSystem,
  position, radius, sphericity, mass, density, velocity, lengthP, diameterP );
  //Add additional data due to parallization
  auto particle = particleSystem.get(particleSystem.size()-1);
  particle.template setField<PARALLELIZATION,ID>( globID );
  //Reinforcing default values
  particle.template setField<GENERAL,INVALID>( false );
    }
  });
}

References addSubgridHaiderLevenspielObject(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), M_PI, olb::util::pow(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridHaiderLevenspielObject()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridHaiderLevenspielObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	sphericity,
		T	mass = 0.,
		T	density = 1.,
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.),
		T	lengthP = 1.,
		T	diameterP = 1. )

Add subgrid object as new particle.

Set subgrid object 3D at given index

Definition at line 412 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setSubgridHaiderLevenspielObject( particleSystem, idxParticle, position, radius, sphericity, mass, density, velocity, lengthP, diameterP );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setSubgridHaiderLevenspielObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

addSubgridObject()

template<typename T , typename PARTICLETYPE >

Particle< T, PARTICLETYPE > olb::particles::creators::addSubgridObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	density = 0.,
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.) )

Add subgrid object as new particle (and return particle object)

Set subgrid object 3D at given index

Return new particle object

Definition at line 168 of file particleCreatorHelperFunctions.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
  particleSystem.extend();
 
  setSubgridObject( particleSystem, idxParticle, position, radius, density,velocity );
 
  return particleSystem.get(idxParticle);
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), setSubgridObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

addSubgridSphere3D() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridSphere3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, 3 > &	position,
		T	radius,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Definition at line 361 of file particleCreatorFunctions3D.h.

{
  addSubgridObject( particleSystem,
    position, radius, density, velocity );
}

References addSubgridObject().

Here is the call graph for this function:

addSubgridSphere3D() [2/2]

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addSubgridSphere3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	radius,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Definition at line 443 of file particleParallelCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  if (auto iC = cuboidDecomposition.getC(position)) {
    globiCcentre = *iC;
  } else {
    std::cerr << "ERROR: Particle added outside domain!" << std::endl;
  }
 
  //Iterate over particle systems
  std::size_t localID=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
    //Do only on residence iC
    if (globiC == globiCcentre){
      //Run creator on particleSystem
      addSubgridObject( particleSystem,
        position, radius, density, velocity );
      //Add additional data due to parallization
      auto particle = particleSystem.get(particleSystem.size()-1);
      particle.template setField<PARALLELIZATION,ID>( globID );
      //Set localID
      localID=particle.getId();
    }
  });
 
  //Return globiC, globID, localiD
  return ParallelParticleLocator(globiCcentre, globID, localID);
}

References addSubgridObject(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

addSubgridSphereWithSpecies3D()

template<typename T , typename PARTICLETYPE >

ParallelParticleLocator olb::particles::creators::addSubgridSphereWithSpecies3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	radius,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.),
		const int	species = 0 )

Definition at line 485 of file particleParallelCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  if (auto iC = cuboidDecomposition.getC(position)) {
    globiCcentre = *iC;
  } else {
    std::cerr << "ERROR: Particle added outside domain!" << std::endl;
  }
 
  //Iterate over particle systems
  std::size_t localID=0; //Return localID of particle inside particleSystem holding centre
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
    //Do only on residence iC
    if (globiC == globiCcentre){
      //Run creator on particleSystem
      addSubgridObject( particleSystem,
        position, radius, density, velocity );
      //Add additional data due to parallization
      auto particle = particleSystem.get(particleSystem.size()-1);
      particle.template setField<PARALLELIZATION,ID>( globID );
      //Add species type to particle
      if constexpr( access::providesSpecies<PARTICLETYPE>() ){
        particle.template setField<PHYSPROPERTIES,SPECIES>( species );
      }
      //Set localID
      localID=particle.getId();
    }
  });
 
  //Return globiC, globID, localiD
  return ParallelParticleLocator(globiCcentre, globID, localID);
}

References addSubgridObject(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), olb::particles::access::providesSpecies(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

addSubgridTranCongFromCylinder3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridTranCongFromCylinder3D	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	_angle = 0.,
		T	density = 1.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Definition at line 538 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Get global particle id
  std::size_t globID = sParticleSystem.getGlobID();
  //Find globiC the particle belongs to
  int globiCcentre;
  bool inDomain = false;
  if (auto iC = cuboidDecomposition.getC(position)) {
    inDomain = true;
    globiCcentre = *iC;
  }
  if (!inDomain){ std::cerr << "ERROR: Particle added outside domain!" << std::endl; }
  //Iterate over particle systems
  communication::forSystemsInSuperParticleSystem( sParticleSystem,
  [&](ParticleSystem<T,PARTICLETYPE>& particleSystem, int iC, int globiC){
 
    //Do only on residence iC
    if (globiC == globiCcentre){
      //Run creator on particleSystem
      T r = diameter/2.;
      T angle = _angle/360.*(2*M_PI);
      T volume = M_PI*r*r*length;
      T A_p = util::abs(M_PI*diameter*diameter/4.*olb::util::cos(angle)) + util::abs(diameter*length*olb::util::sin(angle));
      T P_p = 2*M_PI*r*olb::util::cos(angle) + (2*r+length)*2*olb::util::sin(angle);
      T d_n=util::pow(6*volume/M_PI, 0.33333333333); //volume equivalent diameter
      T d_A = util::sqrt(4*A_p/M_PI);//projected surface equivalent diameter7
      T c = (M_PI*d_A)/P_p;//circularity
      T dA_dn = d_A/d_n;
      T radius = r*olb::util::cos(angle) + length/2.*olb::util::sin(angle);//calculated for the deposition function
      //T radius = r;//calculated for the deposition function
 
 
  T mass = density*volume;
  addSubgridTranCongObject( particleSystem,
    position, radius, c, A_p,  dA_dn, mass, density, velocity );
      //Add additional data due to parallization
      auto particle = particleSystem.get(particleSystem.size()-1);
      particle.template setField<PARALLELIZATION,ID>( globID );
      T beta = length/diameter;
      T a = r;
        Vector<T,3> scaling(beta*a,a,a);
      particle.template setField<NUMERICPROPERTIES,SCALING>( scaling); //used for visualisation in Paraview
      //Reinforcing default values
      particle.template setField<GENERAL,INVALID>( false );
    }
  });
}

References olb::util::abs(), addSubgridTranCongObject(), olb::util::cos(), olb::particles::communication::forSystemsInSuperParticleSystem(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getGlobID(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), M_PI, olb::util::pow(), olb::util::sin(), olb::particles::ParticleSystem< T, PARTICLETYPE >::size(), and olb::util::sqrt().

Here is the call graph for this function:

addSubgridTranCongObject()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::addSubgridTranCongObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	c,
		T	A_p,
		T	dA_dn,
		T	mass = 0.,
		T	density = 1.,
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.) )

Definition at line 521 of file particleCreatorFunctions3D.h.

{
  //Retrieve new index
  std::size_t idxParticle = particleSystem.size();
 
  //Initialize particle address
 
  particleSystem.extend();
  setSubgridTranCongObject( particleSystem, idxParticle,
    position, radius, c, A_p , dA_dn, mass, density, velocity );
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::extend(), setSubgridTranCongObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

addSurface()

template<typename T , typename PARTICLETYPE , typename F >

std::size_t olb::particles::creators::addSurface	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		F	createUniqueIndicatorPtr )

Adds surface (SmoothIndicator) to all block particle systems.

Definition at line 174 of file particleParallelCreatorFunctions3D.h.

{
  typedef SmoothIndicatorF<T, T, PARTICLETYPE::d, true> SIndicatorBaseType;
  std::size_t idxSurface = 0;
 
  std::vector<olb::particles::ParticleSystem<T, PARTICLETYPE>*>&
      blockParticleSystems = sParticleSystem.getBlockParticleSystems();
  // Iteration over each element independent from cuboids to ensure that surfaces are added everywhere
  // as some blocks may not have a corresponding cuboid
  for (unsigned i = 0; i < blockParticleSystems.size(); ++i) {
    auto& particleSystem     = *blockParticleSystems[i];
    auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                               std::vector<std::unique_ptr<SIndicatorBaseType>>>();
    if(i > 0 && idxSurface != vectorOfIndicators.size()) {
      std::cerr << "ERROR: Number of particle surfaces don't match." << std::endl;
      assert(false);
    }
    idxSurface   = vectorOfIndicators.size();
    vectorOfIndicators.push_back( createUniqueIndicatorPtr() );
  }
 
  return idxSurface;
}

References olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getBlockParticleSystems(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

assignParallelResolvedParticle()

template<typename T , typename PARTICLETYPE >

bool olb::particles::creators::assignParallelResolvedParticle	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::set< int > &	setOfICs,
		int	globiC,
		std::size_t	idxSurface,
		std::size_t	globID,
		std::size_t &	localID,
		int	globiCcentre,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	density = 0.,
		const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &	angleInDegree = Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation> (0.),
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.) )

Definition at line 102 of file particleParallelCreatorFunctions3D.h.

{
  //Check whether asignment needed for globiC
  bool assigned=false;
  if( setOfICs.find(globiC) != setOfICs.end() ) {
    //Attach particle to cuboid with globiC (and retrieve new particle object)
    auto particle = assignParallelResolvedParticleToiC( particleSystem, idxSurface,
      globID, globiCcentre, position, density, angleInDegree, velocity );
    //Declare assignement found
    assigned=true;
    //Retrieve localID
    localID = particle.getId();
  } //if( std::find() )
  //Return whether assigned
  return assigned;
}

References assignParallelResolvedParticleToiC().

Here is the call graph for this function:

Here is the caller graph for this function:

assignParallelResolvedParticleToiC()

template<typename T , typename PARTICLETYPE >

Particle< T, PARTICLETYPE > olb::particles::creators::assignParallelResolvedParticleToiC	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxSurface,
		std::size_t	globID,
		int	globiCcentre,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	density = 0.,
		const Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation > &	angleInDegree = Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation> (0.),
		const Vector< T, PARTICLETYPE::d > &	velocity = Vector<T,PARTICLETYPE::d> (0.) )

Definition at line 79 of file particleParallelCreatorFunctions3D.h.

{
  using namespace descriptors;
  //Add resolved object
  auto particle = creators::addResolvedObject( particleSystem, idxSurface,
    position, density, angleInDegree, velocity );
  //Add additional data due to parallization
  particle.template setField<PARALLELIZATION,ID>( globID );
  particle.template setField<PARALLELIZATION,IC>( globiCcentre );
  particle.template setField<SURFACE,SURFACE_ID>( idxSurface );
  //Return particle object
  return particle;
}

References addResolvedObject().

Here is the call graph for this function:

Here is the caller graph for this function:

calcParticleVolume()

template<typename T , unsigned D>

T olb::particles::creators::calcParticleVolume	(	const std::vector< SpawnData< T, D > > &	spawnData,
		const std::function< T(const std::size_t &)> &	getParticleVolume )

Definition at line 57 of file particleCreatorFunctions.h.

{
  T           particleVolume(0);
  std::size_t pID(0);
 
  // Use with C++20:
  //for(std::size_t pID = 0; [[maybe_unused]] const SpawnData<T,D>& entry : spawnData) {
  for ([[maybe_unused]] const SpawnData<T, D>& entry : spawnData) {
    particleVolume += getParticleVolume(pID++);
  }
  return particleVolume;
}

Here is the caller graph for this function:

calcParticleVolumeFraction()

template<typename T , unsigned D>

T olb::particles::creators::calcParticleVolumeFraction	(	const std::vector< SpawnData< T, D > > &	spawnData,
		const T	fluidVolume,
		const std::function< T(const std::size_t &)> &	getParticleVolume )

Definition at line 73 of file particleCreatorFunctions.h.

{
  return calcParticleVolume(spawnData, getParticleVolume) / fluidVolume;
}

References calcParticleVolume().

Here is the call graph for this function:

checkForErrors()

template<typename PARTICLETYPE , bool ROTATION_IS_OPTIONAL = false>

void olb::particles::creators::checkForErrors

(

)

Definition at line 36 of file particleCreatorHelperFunctions.h.

{
  using namespace descriptors;
 
  static_assert(ROTATION_IS_OPTIONAL || PARTICLETYPE::template providesNested<SURFACE,ROT_MATRIX>(),
                "A rotation matrix is necessary but not provided.");
}

Here is the caller graph for this function:

extendSpawnData() [1/3]

template<typename T , unsigned D>

void olb::particles::creators::extendSpawnData	(	std::vector< SpawnData< T, D > > &	spawnData,
		const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMin,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMax,
		const std::function< T(const std::size_t &)> &	getParticleVolume )

Definition at line 263 of file particleCreatorFunctions.h.

{
  constexpr unsigned maxTries  = 1e6;
  const auto         getPoints = [&](const PhysR<T, D>& position,
                             const PhysR<T, D>& min, const PhysR<T, D>& max) {
    std::vector<PhysR<T, D>> points;
    if constexpr (D == 3) {
      points.reserve(9);
      points.push_back(PhysR<T, D>(min[0], min[1], min[2]));
      points.push_back(PhysR<T, D>(min[0], min[1], max[2]));
      points.push_back(PhysR<T, D>(min[0], max[1], min[2]));
      points.push_back(PhysR<T, D>(min[0], max[1], max[2]));
      points.push_back(PhysR<T, D>(max[0], min[1], max[2]));
      points.push_back(PhysR<T, D>(max[0], min[1], min[2]));
      points.push_back(PhysR<T, D>(max[0], max[1], min[2]));
      points.push_back(PhysR<T, D>(max[0], max[1], max[2]));
    }
    else {
      points.reserve(5);
      points.push_back(PhysR<T, D>(min[0], min[1]));
      points.push_back(PhysR<T, D>(min[0], max[1]));
      points.push_back(PhysR<T, D>(max[0], min[1]));
      points.push_back(PhysR<T, D>(max[0], max[1]));
    }
    points.push_back(position);
    return points;
  };
 
  OstreamManager clout(std::cout, "ParticleSeeding");
  //Create randomizer
  util::Randomizer<T> randomizer;
 
  std::size_t pID            = spawnData.size();
  unsigned    count          = 0;
  T    currVolumeOfParticles = calcParticleVolume(spawnData, getParticleVolume);
  bool isPositionValid;
 
  const Vector<T, D> extent = fluidDomain.getMax() - fluidDomain.getMin();
 
  while (currVolumeOfParticles / fluidDomainVolume <
             wantedParticleVolumeFraction &&
         count < maxTries) {
    isPositionValid = true;
 
    // Randomize position
    PhysR<T, D> randomPosition = randomizer.template generate<PhysR<T, D>>();
    randomPosition *= extent;
    randomPosition += fluidDomain.getMin();
    const std::vector<PhysR<T, D>> pointsToCheck =
        getPoints(randomPosition, getMin(pID, randomPosition),
                  getMax(pID, randomPosition));
 
    // check overlap with other particles
    for (std::size_t iP = 0; iP < spawnData.size(); ++iP) {
      const PhysR<T, D> min = getMin(iP, spawnData[iP].position);
      const PhysR<T, D> max = getMax(iP, spawnData[iP].position);
 
      for (const PhysR<T, D>& point : pointsToCheck) {
        /*
        const int count = std::count(cornerPoints.begin(), cornerPoints.end(), corner);
        if (count > 1) {
          clout<< "WARNING: Same point was checked twice during the particle seeding";
        }
        */
 
        bool overlap = true;
        for (unsigned iD = 0; iD < D; ++iD) {
          overlap = overlap && min[iD] <= point[iD] && max[iD] >= point[iD];
        }
        if (overlap) {
          isPositionValid = false;
          break;
        }
      }
 
      if (!isPositionValid) {
        break;
      }
    }
    if (!isPositionValid) {
      ++count;
      continue;
    }
 
    // check overlap with boundaries (should work for convex geometries)
    // for better results an iteration over the whole volume could be added
    for (const PhysR<T, D>& point : pointsToCheck) {
      bool isInside;
      fluidDomain(&isInside, point.data());
      if (!isInside) {
        isPositionValid = false;
        break;
      }
    }
 
    if (isPositionValid) {
      spawnData.push_back(SpawnData<T, D>(
          randomPosition,
          Vector<T, utilities::dimensions::convert<D>::rotation>(T {0.})));
      count = 0;
      currVolumeOfParticles += getParticleVolume(pID++);
    }
    else {
      ++count;
    }
  }
  if (count >= maxTries) {
    clout << "WARNING: Could not set a particle volume fraction of "
          << wantedParticleVolumeFraction
          << ", only a particle volume fraction of "
          << currVolumeOfParticles / fluidDomainVolume << " was possible."
          << std::endl;
  }
 
  return;
}

References calcParticleVolume(), and olb::max().

Here is the call graph for this function:

extendSpawnData() [2/3]

template<typename T , unsigned D>

void olb::particles::creators::extendSpawnData	(	std::vector< SpawnData< T, D > > &	spawnData,
		const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const std::function< T(const std::size_t &)> &	getCircumRadius,
		const std::function< T(const std::size_t &)> &	getParticleVolume )

Definition at line 81 of file particleCreatorFunctions.h.

{
  constexpr unsigned maxTries = 1e6;
 
  OstreamManager clout(std::cout, "ParticleSeeding");
  //Create randomizer
  util::Randomizer<T> randomizer;
 
  std::size_t pID            = spawnData.size();
  unsigned    count          = 0;
  T    currVolumeOfParticles = calcParticleVolume(spawnData, getParticleVolume);
  bool isPositionValid;
 
  const Vector<T, D> extent = fluidDomain.getMax() - fluidDomain.getMin();
 
  while (currVolumeOfParticles / fluidDomainVolume <
             wantedParticleVolumeFraction &&
         count < maxTries) {
    const T circumRadius = getCircumRadius(pID);
    isPositionValid      = true;
 
    // Randomize position
    PhysR<T, D> randomPosition = randomizer.template generate<PhysR<T, D>>();
    randomPosition *= extent;
    randomPosition += fluidDomain.getMin();
 
    // check overlap with other particles
    std::size_t i = 0;
    for (const SpawnData<T, D>& entry : spawnData) {
      const T distanceCenterOfMass = norm(entry.position - randomPosition);
      if (distanceCenterOfMass <= circumRadius + getCircumRadius(i++)) {
        ++count;
        isPositionValid = false;
        break;
      }
    }
    if (!isPositionValid) {
      continue;
    }
 
    // check overlap with boundaries (should work for convex geometries)
    // for better results an iteration over the whole volume could be added
    auto pointsOnHull = particles::discrete_points_on_hull::calculate(
        randomPosition, circumRadius);
    for (const PhysR<T, D>& pointOnHull : pointsOnHull) {
      bool isInside;
      fluidDomain(&isInside, pointOnHull.data());
      if (!isInside) {
        isPositionValid = false;
        break;
      }
    }
 
    if (isPositionValid) {
      spawnData.push_back(SpawnData<T, D>(
          randomPosition,
          Vector<T, utilities::dimensions::convert<D>::rotation>(T {0})));
      count = 0;
      currVolumeOfParticles += getParticleVolume(pID++);
    }
    else {
      ++count;
    }
  }
  if (count >= maxTries) {
    clout << "WARNING: Could not set a particle volume fraction of "
          << wantedParticleVolumeFraction
          << ", only a particle volume fraction of "
          << currVolumeOfParticles / fluidDomainVolume << " was possible."
          << std::endl;
  }
 
  return;
}

References calcParticleVolume(), olb::particles::discrete_points_on_hull::calculate(), and olb::norm().

Here is the call graph for this function:

Here is the caller graph for this function:

extendSpawnData() [3/3]

template<typename T , unsigned D>

void olb::particles::creators::extendSpawnData	(	std::vector< SpawnData< T, D > > &	spawnData,
		const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const T	deltaX,
		const T	contactDetectionDistance,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMin,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMax,
		const std::function< T(const std::size_t &, const SpawnData< T, D > &, const PhysR< T, D > &)> &	signedDistanceToParticle,
		const std::function< T(const std::size_t &)> &	getParticleVolume )

Definition at line 411 of file particleCreatorFunctions.h.

{
  OstreamManager     clout(std::cout, "ParticleSeeding");
  constexpr unsigned maxTries = 1e6;
 
  //Create randomizer
  util::Randomizer<T> randomizer;
 
  std::size_t pID         = spawnData.size();
  unsigned    count       = 0;
  T currVolumeOfParticles = calcParticleVolume(spawnData, getParticleVolume);
 
  const Vector<T, D> extent = fluidDomain.getMax() - fluidDomain.getMin();
 
  while (currVolumeOfParticles / fluidDomainVolume <
             wantedParticleVolumeFraction &&
         count < maxTries) {
    bool isPositionValid = true;
 
    // Randomize position
    PhysR<T, D> randomPosition = randomizer.template generate<PhysR<T, D>>();
    randomPosition *= extent;
    randomPosition += fluidDomain.getMin();
 
    const PhysR<T, D> min = getMin(pID, randomPosition);
    const PhysR<T, D> max = getMax(pID, randomPosition);
    Vector<int, D>    start;
    Vector<int, D>    end;
    for (unsigned iD = 0; iD < D; ++iD) {
      start[iD] = util::floor(min[iD] / deltaX);
      end[iD]   = util::ceil(max[iD] / deltaX);
    }
 
    const auto evalCurrentPosition = [&](const Vector<int, D>& pos,
                                         bool&                 breakLoop) {
      const PhysR<T, D> physPos = deltaX * pos;
      if (signedDistanceToParticle(
              pID,
              SpawnData<T, D>(
                  randomPosition,
                  Vector<T, utilities::dimensions::convert<D>::rotation>(
                      T {0.})),
              physPos) < contactDetectionDistance) {
 
        // Check wall intersection
        if (fluidDomain.signedDistance(physPos) > -contactDetectionDistance) {
          breakLoop       = true;
          isPositionValid = false;
          return;
        }
 
        // Check intersection with particles
        for (std::size_t i = 0; i < spawnData.size(); ++i) {
          if (signedDistanceToParticle(i, spawnData[i], physPos) <
              contactDetectionDistance) {
            breakLoop       = true;
            isPositionValid = false;
            return;
          }
        }
      }
    };
 
    particles::contact::forEachPositionWithBreak(start, end,
                                                 evalCurrentPosition);
 
    if (!isPositionValid) {
      ++count;
    }
    else {
      spawnData.push_back(SpawnData<T, D>(
          randomPosition,
          Vector<T, utilities::dimensions::convert<D>::rotation>(T {0})));
      currVolumeOfParticles += getParticleVolume(pID++);
      count = 0;
    }
  }
 
  if (count >= maxTries) {
    clout << "WARNING: Could not set a particle volume fraction of "
          << wantedParticleVolumeFraction
          << ", only a particle volume fraction of "
          << currVolumeOfParticles / fluidDomainVolume << " was possible."
          << std::endl;
  }
 
  return;
}

References calcParticleVolume(), olb::util::ceil(), olb::util::floor(), and olb::particles::contact::forEachPositionWithBreak().

Here is the call graph for this function:

prepareParallelResolvedParticle()

template<typename T , typename PARTICLETYPE >

std::set< int > olb::particles::creators::prepareParallelResolvedParticle	(	SuperParticleSystem< T, PARTICLETYPE > &	sParticleSystem,
		Vector< T, PARTICLETYPE::d >	position,
		T	circumRadius,
		const T	epsilon,
		int &	globiCcentre,
		const T	physDeltaX,
		const Vector< bool, PARTICLETYPE::d > &	periodicity )

Definition at line 46 of file particleParallelCreatorFunctions3D.h.

{
  //Retrieving cuboid geometry
  auto& cuboidDecomposition = sParticleSystem.getSuperStructure().getCuboidDecomposition();
  //Find globiC of particle centre
  const bool inDomain = particles::communication::getCuboid(
      cuboidDecomposition, periodicity, position, globiCcentre);
  //TODO: add error handling, when !inDomain
  if (!inDomain){
    std::cerr << "ERROR: Particle added outside domain!" << std::endl;
  }
  if constexpr (access::providesContactMaterial<PARTICLETYPE>()) {
    // without particle enlargement for contact, since it is 0 at the time of creation
    const T detectionDistance = T{0.5} * util::sqrt(PARTICLETYPE::d) * physDeltaX;
    const T halfEpsilon = T{0.5} * epsilon;
    circumRadius = circumRadius - halfEpsilon + util::max(halfEpsilon, detectionDistance);
  }
  sParticleSystem.updateOffsetFromCircumRadius(circumRadius);
  //Find globiCs touching the surface hull
  std::set<int> setOfICs = communication::getSurfaceTouchingICs( sParticleSystem,
    position, circumRadius, periodicity, globiCcentre );
  //Add globiCcentre to list
  setOfICs.insert(globiCcentre);
  //Return list of iCs
  return setOfICs;
}

References olb::particles::communication::getCuboid(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::particles::SuperParticleSystem< T, PARTICLETYPE >::getSuperStructure(), olb::particles::communication::getSurfaceTouchingICs(), olb::util::max(), olb::particles::access::providesContactMaterial(), olb::util::sqrt(), and olb::particles::SuperParticleSystem< T, PARTICLETYPE >::updateOffsetFromCircumRadius().

Here is the call graph for this function:

Here is the caller graph for this function:

readParticlePositions()

std::vector< std::vector< std::string > > olb::particles::creators::readParticlePositions

(

const std::string &

filename

)

Definition at line 183 of file particleCreatorFunctions.h.

{
  std::vector<std::vector<std::string>> content;
  std::vector<std::string>              row;
  std::string                           line, word;
 
  std::fstream file(filename, std::ios::in);
  if (file.is_open()) {
    while (getline(file, line)) {
      row.clear();
 
      std::stringstream str(line);
 
      while (getline(str, word, ';')) {
        row.push_back(word);
      }
      content.push_back(row);
    }
  }
  else {
    std::cerr << "Could not open the file " << filename << std::endl;
  }
 
  return content;
}

Here is the caller graph for this function:

saveParticlePositions()

template<typename T , unsigned D>

void olb::particles::creators::saveParticlePositions	(	const std::string &	filename,
		const std::vector< SpawnData< T, D > > &	spawnData,
		const std::function< std::string(const std::size_t &)> &	evalIdentifier )

Definition at line 210 of file particleCreatorFunctions.h.

{
  std::ofstream file;
  file.open(filename.c_str(), std::ios::trunc);
  std::size_t pID = 0;
  for (const SpawnData<T, D>& entry : spawnData) {
    for (unsigned iD = 0; iD < D; ++iD) {
      file << std::setprecision(16) << entry.position[iD] << ';';
    }
    for (unsigned iD = 0; iD < utilities::dimensions::convert<D>::rotation;
         ++iD) {
      file << std::setprecision(16) << entry.angleInDegree[iD] << ';';
    }
    file << evalIdentifier(pID++) << std::endl;
  }
  file.close();
}

Here is the caller graph for this function:

saveUpdatedParticlePositions()

template<typename T , typename PARTICLETYPE >

std::vector< SpawnData< T, PARTICLETYPE::d > > olb::particles::creators::saveUpdatedParticlePositions	(	const std::string &	filename,
		const std::vector< SpawnData< T, PARTICLETYPE::d > > &	originalSpawnData,
		const std::function< std::string(const std::size_t &)> &	evalIdentifier,
		XParticleSystem< T, PARTICLETYPE > &	particleSystem,
		MPI_Comm	particleCreatorComm = MPI_COMM_WORLD )

Definition at line 650 of file particleCreatorFunctions.h.

{
  std::vector<SpawnData<T, PARTICLETYPE::d>> spawnData =
      updateParticlePositions<T, PARTICLETYPE>(originalSpawnData, particleSystem
#ifdef PARALLEL_MODE_MPI
                                               ,
                                               particleCreatorComm
#endif
      );
  saveParticlePositions(filename, spawnData, evalIdentifier);
  return spawnData;
}

References saveParticlePositions(), and updateParticlePositions().

Here is the call graph for this function:

setParticles() [1/4]

template<typename T , unsigned D>

std::vector< SpawnData< T, D > > olb::particles::creators::setParticles	(	const std::string &	filename,
		const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const std::function< T(const std::size_t &)> &	getParticleVolume,
		const std::function< void(const SpawnData< T, D > &, const std::string &)>	createParticle )

Definition at line 231 of file particleCreatorFunctions.h.

{
  std::vector<SpawnData<T, D>>          spawnData;
  std::vector<std::vector<std::string>> filecontent =
      particles::creators::readParticlePositions(filename);
  for (const std::vector<std::string>& line : filecontent) {
    PhysR<T, D>                                            particlePosition;
    Vector<T, utilities::dimensions::convert<D>::rotation> particleAngle;
    unsigned                                               iD = 0;
    for (; iD < D; ++iD) {
      particlePosition[iD] = std::stod(line[iD]);
    }
    for (; iD < (D + utilities::dimensions::convert<D>::rotation); ++iD) {
      particleAngle[iD - D] = std::stod(line[iD]);
    }
    SpawnData<T, D> tmpSpawnData(particlePosition, particleAngle);
    spawnData.push_back(tmpSpawnData);
    createParticle(tmpSpawnData, line[iD]);
  }
 
  return spawnData;
}

References readParticlePositions().

Here is the call graph for this function:

setParticles() [2/4]

template<typename T , unsigned D>

std::vector< SpawnData< T, D > > olb::particles::creators::setParticles	(	const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMin,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMax,
		const std::function< T(const std::size_t &)> &	getParticleVolume,
		const std::function< void(const SpawnData< T, D > &, const std::size_t &)>	createParticle )

Definition at line 389 of file particleCreatorFunctions.h.

{
  std::vector<SpawnData<T, D>> spawnData;
  extendSpawnData<T, D>(spawnData, wantedParticleVolumeFraction, fluidDomain,
                        fluidDomainVolume, getMin, getMax, getParticleVolume);
 
  for (std::size_t pID = 0; pID < spawnData.size(); ++pID) {
    createParticle(spawnData[pID], pID);
  }
  return spawnData;
}

References extendSpawnData().

Here is the call graph for this function:

setParticles() [3/4]

template<typename T , unsigned D>

std::vector< SpawnData< T, D > > olb::particles::creators::setParticles	(	const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const std::function< T(const std::size_t &)> &	getCircumRadius,
		const std::function< T(const std::size_t &)> &	getParticleVolume,
		const std::function< void(const SpawnData< T, D > &, const std::size_t &)>	createParticle )

Definition at line 162 of file particleCreatorFunctions.h.

{
  std::vector<SpawnData<T, D>> spawnData;
  extendSpawnData<T, D>(spawnData, wantedParticleVolumeFraction, fluidDomain,
                        fluidDomainVolume, getCircumRadius, getParticleVolume);
 
  std::size_t pID = 0;
  for (const SpawnData<T, D>& entry : spawnData) {
    createParticle(entry, pID++);
  }
 
  return spawnData;
}

References extendSpawnData().

Here is the call graph for this function:

setParticles() [4/4]

template<typename T , unsigned D>

std::vector< SpawnData< T, D > > olb::particles::creators::setParticles	(	const T	wantedParticleVolumeFraction,
		IndicatorF< T, D > &	fluidDomain,
		const T	fluidDomainVolume,
		const T	deltaX,
		const T	contactDetectionDistance,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMin,
		const std::function< PhysR< T, D >(const std::size_t &, const PhysR< T, D > &)> &	getMax,
		const std::function< T(const std::size_t &, const SpawnData< T, D > &, const PhysR< T, D > &)> &	signedDistanceToParticle,
		const std::function< T(const std::size_t &)> &	getParticleVolume,
		const std::function< void(const SpawnData< T, D > &, const std::size_t &)>	createParticle )

Definition at line 511 of file particleCreatorFunctions.h.

{
  std::vector<SpawnData<T, D>> spawnData;
  extendSpawnData<T, D>(spawnData, wantedParticleVolumeFraction, fluidDomain,
                        fluidDomainVolume, deltaX, contactDetectionDistance,
                        getMin, getMax, signedDistanceToParticle,
                        getParticleVolume);
 
  for (std::size_t pID = 0; pID < spawnData.size(); ++pID) {
    createParticle(spawnData[pID], pID);
  }
  return spawnData;
}

References extendSpawnData().

Here is the call graph for this function:

setResolvedArbitraryShape2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Set resolved cuboid for existing particle but new surface.

Set resolved arbitrary shape with given suface

Definition at line 224 of file particleCreatorFunctions2D.h.

{
  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);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedArbitraryShape3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setResolvedArbitraryShape3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		Vector< T, 3 >	position,
		T	latticeSpacing,
		std::shared_ptr< IndicatorF3D< T > >	indPtr,
		T	epsilon,
		T	density = 0.,
		Vector< T, 3 >	angleInDegree = Vector<T,3> (0.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.) )

Set resolved cuboid for existing particle but new surface.

Set resolved arbitrary shape with given suface

Definition at line 308 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCustom3D<T, T, true>(latticeSpacing, indPtr, Vector<T,3> (0.), epsilon, Vector<T,3> (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, angleInDegree, velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedCircle2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Set resolved circle for existing particle but new surface.

Set resolved circle 2D with given suface

Definition at line 77 of file particleCreatorFunctions2D.h.

{
  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);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedCone3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setResolvedCone3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position1,
		const Vector< T, 3 > &	position2,
		T	radius1,
		T	radius2,
		T	epsilon,
		T	density = 0,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Set resolved cone for existing particle but new surface.

Set resolved cone 3D with given suface

Definition at line 205 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCone3D<T, T, true>(position1, position2, radius1, radius2, epsilon ));
 
  //Pass smart pointer to particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  std::size_t idxSurface = vectorOfIndicators.size();
  const Vector<T,3> position = sIndicatorPtr->calcCenterOfMass();
  vectorOfIndicators.push_back( std::move(sIndicatorPtr) );
 
  setResolvedObject(particleSystem, idxParticle, idxSurface,
                    position, density, angleInDegree, velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedCuboid2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Set resolved cuboid for existing particle but new surface.

Set resolved cuboid 3D with given suface

Definition at line 128 of file particleCreatorFunctions2D.h.

{
  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);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedCuboid3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setResolvedCuboid3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	extend,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Set resolved cuboid for existing particle but new surface.

Set resolved cuboid 3D with given suface

Definition at line 157 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCuboid3D<T, T, true>(extend[0], extend[1], extend[2], Vector<T,3>(0.), 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, angleInDegree, velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedCylinder3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setResolvedCylinder3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	normal,
		T	height,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Set resolved cylinder for existing particle but new surface.

Set resolved cylinder 3D with given suface

Definition at line 107 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorCylinder3D<T, T, true>(Vector<T,3>(0.), normal, radius, height, 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, angleInDegree, velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedEllipsoid3D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setResolvedEllipsoid3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		const Vector< T, 3 > &	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	angleInDegree = Vector<T,3> (0.),
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Set resolved ellipsoid for existing particle but new surface.

Set resolved ellipsoid 3D with given suface

Definition at line 256 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorEllipsoid3D<T, T, true>(Vector<T,3>(0.), radius, epsilon, Vector<T,3>(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, angleInDegree, velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedObject() [1/2]

template<typename T , typename PARTICLETYPE , bool ROTATION_IS_OPTIONAL = false>

void olb::particles::creators::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 )

Definition at line 50 of file particleCreatorFunctions2D.h.

{
  setResolvedObject<T,PARTICLETYPE,ROTATION_IS_OPTIONAL>( particleSystem, idxParticle, idxSurface, position, density,
      Vector<T,utilities::dimensions::convert<PARTICLETYPE::d>::rotation>( angle ), velocity );
}

References setResolvedObject().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedObject() [2/2]

template<typename T , typename PARTICLETYPE , bool ROTATION_IS_OPTIONAL = false>

Particle< T, PARTICLETYPE > olb::particles::creators::setResolvedObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		std::size_t	idxSurface,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	density,
		Vector< T, utilities::dimensions::convert< PARTICLETYPE::d >::rotation >	angleInDegree,
		const Vector< T, PARTICLETYPE::d > &	velocity )

Set new particle for existing surface (and return particle object)

Return new particle object

Definition at line 46 of file particleCreatorHelperFunctions.h.

{
  particles::creators::checkForErrors<PARTICLETYPE,ROTATION_IS_OPTIONAL>();
 
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  typedef SmoothIndicatorF<T,T,D,true> SIndicatorBaseType;
 
  //Retrieve smart pointer from particleSystem
  auto& vectorOfIndicators = particleSystem.template getAssociatedData<
                             std::vector<std::unique_ptr<SIndicatorBaseType>>>();
  auto sIndicatorPtr = vectorOfIndicators.at( idxSurface ).get();
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  dynamics::initializeParticle<T,PARTICLETYPE>(particleSystem.get().data(), idxParticle);
 
  //Calculate moment of inertia and mass
  Vector<T,utilities::dimensions::convert<D>::rotation> momentOfInertia;
  if constexpr(D==3) {
    for (unsigned iD=0; iD<D; ++iD) {
      momentOfInertia[iD] = sIndicatorPtr->calcMofiAndMass(density)[iD];
    }
  }
  else {
    momentOfInertia[0] = sIndicatorPtr->calcMofiAndMass(density)[0];
  }
 
  //Set values
  auto particle = particleSystem.get( idxParticle );
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<SURFACE,SINDICATOR>( sIndicatorPtr );
  access::setDensity(particle, density);
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,MOFI>( utilities::dimensions::convert<D>::serialize_rotation(momentOfInertia) );
 
  auto angle = util::degreeToRadian(angleInDegree);
  particle.template setField<SURFACE,ANGLE>( utilities::dimensions::convert<D>::serialize_rotation(angle) );
  if constexpr ( PARTICLETYPE::template providesNested<SURFACE,ROT_MATRIX>() ) {
    const Vector<T,utilities::dimensions::convert<D>::matrix> rotationMatrix = util::calculateRotationMatrix<T,D>(
          utilities::dimensions::convert<D>::serialize_rotation(angle) );
    particle.template setField<SURFACE,ROT_MATRIX>( rotationMatrix );
  }
 
  return particle;
}

References olb::util::calculateRotationMatrix(), checkForErrors(), olb::util::degreeToRadian(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::particles::dynamics::initializeParticle(), and olb::particles::access::setDensity().

Here is the call graph for this function:

setResolvedSphere3D()

template<typename T , typename PARTICLETYPE , bool IGNORE_WARNINGS = false>

void olb::particles::creators::setResolvedSphere3D	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		T	radius,
		T	epsilon,
		T	density = 0.,
		const Vector< T, 3 > &	velocity = Vector<T,3> (0.) )

Set resolved sphere for existing particle but new surface.

Set resolved sphere 3D with given suface

Definition at line 54 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  typedef SmoothIndicatorF3D<T, T, true> SIndicatorBaseType;
 
  //Create SmoothIndicator
  std::unique_ptr<SIndicatorBaseType> sIndicatorPtr(
    new SmoothIndicatorSphere3D<T, T, true>(Vector<T,3> (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>()
                 && !IGNORE_WARNINGS ) {
    OstreamManager clout(std::cout, "creatorSphere3D");
    clout << "WARNING: A rotation matrix is provided but is not necessary for a sphere." << std::endl;
  }
 
  setResolvedObject<T,PARTICLETYPE,true>(particleSystem, idxParticle, idxSurface,
                                         position, density, Vector<T,3>(0.), velocity);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setResolvedTriangle2D()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::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.) )

Set resolved cuboid for existing particle but new surface.

Set resolved triangle 2D with given suface

Definition at line 176 of file particleCreatorFunctions2D.h.

{
  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);
}

References setResolvedObject(), and olb::particles::ParticleSystem< T, PARTICLETYPE >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

setSubgridEulerRotationSpheroid() [1/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setSubgridEulerRotationSpheroid	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		Vector< T, 3 >	eul_ang = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	ang_velocity = Vector<T,3> (0.,0.,0.),
		int	label = 0 )

Definition at line 657 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  using namespace access;
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  particles::dynamics::initializeParticle<T,PARTICLETYPE>(
    particleSystem.get().data(), idxParticle);
  //Set values
  T beta = length/diameter;
  T a = diameter/2.;
  T mass = 4./3.*M_PI*a*a*a*beta*density;//
  //T mass = 2*M_PI*a*a*a*beta*density;//cylinder
  Vector<T,3> mom_of_in (((1+beta*beta)*a*a)/5.*mass,((1+beta*beta)*a*a)/5.*mass, 2.*a*a/5.*mass);
   //Vector<T,3> mom_of_in (((1./4.+1./6.*beta*beta)*a*a)*mass,((1./4.+1./6.*beta*beta)*a*a)*mass, a*a/2.*mass);//cylinder
 
  Vector<T,3> abg0 (beta*beta/(beta*beta-1)+beta/(2*util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))),
  beta*beta/(beta*beta-1)+beta/(2*util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))),
 (-2)/(beta*beta-1)-beta/(util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))));
 
  auto particle = particleSystem.get( idxParticle );
    particle.template setField<NUMERICPROPERTIES,ABG0> (abg0);
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<PHYSPROPERTIES,MASS>( mass );
  particle.template setField<NUMERICPROPERTIES,MOMENT_OF_INERTIA>( mom_of_in );
  particle.template setField<PHYSPROPERTIES,DENSITY>( density );
  particle.template setField<NUMERICPROPERTIES,ROT_MATRIX>(eler::computeTransformMatrixFromEulAng<T>(eul_ang));
  particle.template setField<NUMERICPROPERTIES,QUATERNION>( eler::computeEulQuatFromEulAng<T>(eul_ang) );
  particle.template setField<NUMERICPROPERTIES,PARAQUATERNION> (eler::getParaquaternion(particle.template getField<NUMERICPROPERTIES,QUATERNION>()));
  particle.template setField<NUMERICPROPERTIES,ANG_VELOCITY> (ang_velocity);
  particle.template setField<NUMERICPROPERTIES, ORIENTATION> (eler::rotate(eler::inverseTransformMatrix(particle.template getField<NUMERICPROPERTIES,ROT_MATRIX>()), Vector<T,3>(0.,0.,1.)));
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,RADIUS>( a );//equal to semi_minor_axis
  Vector<T,3> scaling(beta*a,a,a);//semi axis saved, for whole dimensions multiply 2x
  particle.template setField<NUMERICPROPERTIES,SCALING>( scaling); //used for visualisation in Paraview
  Vector<T,9> dyadic(0.);
  dyadic[0] = (16.*(beta*beta-1))/((2*beta*beta-3)*olb::util::log(beta+olb::util::sqrt(beta*beta-1))/(olb::util::sqrt(beta*beta-1))+beta);
  dyadic[4] = dyadic[0];
  dyadic[8] = (8.*(beta*beta-1))/((2*beta*beta-1)*olb::util::log(beta+olb::util::sqrt(beta*beta-1))/(olb::util::sqrt(beta*beta-1))-beta);
  particle.template setField<NUMERICPROPERTIES,TRANSLATIONAL_DYADIC>( dyadic );
  particle.template setField<NUMERICPROPERTIES,BETA> (beta);
  particle.template setField<NUMERICPROPERTIES,LABEL> (label);
 
  if constexpr ( providesActive(particle) ){
    particle.template setField<DYNBEHAVIOUR,ACTIVE>( true );
  }
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::particles::dynamics::initializeParticle(), olb::util::log(), M_PI, olb::util::pow(), and olb::util::sqrt().

Here is the call graph for this function:

setSubgridEulerRotationSpheroid() [2/2]

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setSubgridEulerRotationSpheroid	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, 3 > &	position,
		T	length,
		T	diameter,
		T	density = 1.,
		Vector< T, 4 >	quaternion = Vector<T,4> (0.,0.,0.,1.),
		Vector< T, 3 >	velocity = Vector<T,3> (0.,0.,0.),
		Vector< T, 3 >	ang_velocity = Vector<T,3> (0.,0.,0.),
		int	label = 0 )

EULER ROTATION SPHEROIDS.

Set new particle from quaternion

Definition at line 599 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  using namespace access;
 
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  particles::dynamics::initializeParticle<T,PARTICLETYPE>(
    particleSystem.get().data(), idxParticle);
  //Set values
  T beta = length/diameter;
  T a = diameter/2.;
  T mass = 4./3.*M_PI*a*a*a*beta*density;//spheroid
  //T mass = 2*M_PI*a*a*a*beta*density;//cylinder
  Vector<T,3> mom_of_in (((1+beta*beta)*a*a)/5.*mass,((1+beta*beta)*a*a)/5.*mass, 2.*a*a/5.*mass);//spheroid
   //Vector<T,3> mom_of_in (((1./4.+1./6.*beta*beta)*a*a)*mass,((1./4.+1./6.*beta*beta)*a*a)*mass, a*a/2.*mass);//cylinder
 
  Vector<T,3> abg0 (beta*beta/(beta*beta-1)+beta/(2*util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))),
  beta*beta/(beta*beta-1)+beta/(2*util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))),
 (-2)/(beta*beta-1)-beta/(util::pow(beta*beta-1,1.5))*util::log((beta- util::sqrt(beta*beta-1))/(beta+util::sqrt(beta*beta-1))));
 
  auto particle = particleSystem.get( idxParticle );
  particle.template setField<NUMERICPROPERTIES,ABG0> (abg0);
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<PHYSPROPERTIES,MASS>( mass );
  particle.template setField<NUMERICPROPERTIES,MOMENT_OF_INERTIA>( mom_of_in );
  particle.template setField<PHYSPROPERTIES,DENSITY>( density );
  eler::qnormalize(quaternion);
  particle.template setField<NUMERICPROPERTIES,ROT_MATRIX>(eler::computeTransformMatrixFromEulQuat<T>(quaternion));
  particle.template setField<NUMERICPROPERTIES,QUATERNION>( quaternion );
  particle.template setField<NUMERICPROPERTIES,PARAQUATERNION> (eler::getParaquaternion(particle.template getField<NUMERICPROPERTIES,QUATERNION>()));
  particle.template setField<NUMERICPROPERTIES,ANG_VELOCITY> (ang_velocity);
  particle.template setField<NUMERICPROPERTIES, ORIENTATION> (eler::rotate(eler::inverseTransformMatrix(particle.template getField<NUMERICPROPERTIES,ROT_MATRIX>()), Vector<T,3>(0.,0.,1.)));
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,RADIUS>( a );//equal to semi_minor_axis
  Vector<T,3> scaling(beta*a,a,a);
  particle.template setField<NUMERICPROPERTIES,SCALING>( scaling); //used for visualisation in Paraview
  Vector<T,9> dyadic(0.);
  dyadic[0] = (16.*(beta*beta-1))/((2*beta*beta-3)*olb::util::log(beta+olb::util::sqrt(beta*beta-1))/(olb::util::sqrt(beta*beta-1))+beta);
  dyadic[4] = dyadic[0];
  dyadic[8] = (8.*(beta*beta-1))/((2*beta*beta-1)*olb::util::log(beta+olb::util::sqrt(beta*beta-1))/(olb::util::sqrt(beta*beta-1))-beta);
  particle.template setField<NUMERICPROPERTIES,TRANSLATIONAL_DYADIC>( dyadic );
  particle.template setField<NUMERICPROPERTIES,BETA> (beta);
  particle.template setField<NUMERICPROPERTIES,LABEL> (label);
 
  if constexpr ( providesActive(particle) ){
    particle.template setField<DYNBEHAVIOUR,ACTIVE>( true );
  }
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), olb::particles::dynamics::initializeParticle(), olb::util::log(), M_PI, olb::util::pow(), and olb::util::sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

setSubgridHaiderLevenspielObject()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setSubgridHaiderLevenspielObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	sphericity,
		T	mass,
		T	density,
		const Vector< T, PARTICLETYPE::d > &	velocity,
		T	lengthP = 1.,
		T	diameterP = 1. )

Set new particle.

Definition at line 374 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  using namespace access;
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  particles::dynamics::initializeParticle<T,PARTICLETYPE>(
    particleSystem.get().data(), idxParticle);
 
  //Set values
  auto particle = particleSystem.get( idxParticle );
  using namespace Haider_Levenspiel;
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<PHYSPROPERTIES,MASS>( mass );
  particle.template setField<PHYSPROPERTIES,DENSITY>( density );
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,RADIUS>( radius );
  particle.template setField<NUMERICPROPERTIES, A> (util::exp(2.3288-6.4581*sphericity + 2.4486*sphericity*sphericity));
  particle.template setField<NUMERICPROPERTIES, B> (0.0964 + 0.5565*sphericity);
  particle.template setField<NUMERICPROPERTIES, C> (util::exp(4.905-13.8944*sphericity + 18.4222*sphericity*sphericity-10.2599*sphericity*sphericity*sphericity));
  particle.template setField<NUMERICPROPERTIES, D> (util::exp(1.4681+12.2584*sphericity-20.7322*sphericity*sphericity+15.8855*sphericity*sphericity*sphericity));
  if constexpr ( providesActive(particle) ){
    particle.template setField<DYNBEHAVIOUR,ACTIVE>( true );
  }
  T beta = lengthP/diameterP;
  T a = diameterP/2.;
  Vector<T,3> scaling(beta*a,a,a);
  particle.template setField<NUMERICPROPERTIES,SCALING>( scaling); //used for visualisation in Paraview
 
}

References olb::util::exp(), olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), and olb::particles::dynamics::initializeParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

setSubgridObject()

template<typename T , typename PARTICLETYPE >

Particle< T, PARTICLETYPE > olb::particles::creators::setSubgridObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	density,
		const Vector< T, PARTICLETYPE::d > &	velocity,
		T	shapeFactor = T{1} )

Set new particle (and return particle object)

Return new particle object

Definition at line 125 of file particleCreatorHelperFunctions.h.

                   {1})
{
  using namespace descriptors;
  using namespace access;
  constexpr unsigned D = PARTICLETYPE::d;
  constexpr unsigned Drot = utilities::dimensions::convert<PARTICLETYPE::d>::rotation;
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  particles::dynamics::initializeParticle<T,PARTICLETYPE>(
    particleSystem.get().data(), idxParticle);
 
  //Set values
  auto particle = particleSystem.get( idxParticle );
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,RADIUS>( radius );
  access::setDensity(particle, density, shapeFactor);
 
  //Calculate moment of inertia and mass
  Vector<T,Drot> momentOfInertia;
  T mass = access::getMass(particle, shapeFactor);
 
  //Calculate moment of inertia and mass
  if constexpr(D==3) {
    momentOfInertia = Vector<T,Drot>(2./5.*mass*radius*radius);
  } else {
    momentOfInertia[0] = 0.5*mass*radius*radius;
  }
 
  particle.template setField<PHYSPROPERTIES,MOFI>( utilities::dimensions::convert<D>::serialize_rotation(momentOfInertia) );
 
  return particle;
}

Here is the caller graph for this function:

setSubgridTranCongObject()

template<typename T , typename PARTICLETYPE >

void olb::particles::creators::setSubgridTranCongObject	(	ParticleSystem< T, PARTICLETYPE > &	particleSystem,
		std::size_t	idxParticle,
		const Vector< T, PARTICLETYPE::d > &	position,
		T	radius,
		T	c,
		T	A_p,
		T	dA_dnn,
		T	mass,
		T	density,
		const Vector< T, PARTICLETYPE::d > &	velocity )

Set new particle Tran Cong.

Definition at line 490 of file particleCreatorFunctions3D.h.

{
  using namespace descriptors;
  using namespace access;
 
  //Initialize fields (Seems to be necessary for clang-1000.10.44.4 but not for gcc)
  particles::dynamics::initializeParticle<T,PARTICLETYPE>(
    particleSystem.get().data(), idxParticle);
  //Set values
  auto particle = particleSystem.get( idxParticle );
  particle.template setField<GENERAL,POSITION>( position );
  particle.template setField<PHYSPROPERTIES,MASS>( mass );
  particle.template setField<PHYSPROPERTIES,DENSITY>( density );
  particle.template setField<MOBILITY,VELOCITY>( velocity );
  particle.template setField<PHYSPROPERTIES,RADIUS>( radius );
 particle.template setField <NUMERICPROPERTIES,CIRCULARITY> (c);
 particle.template setField <NUMERICPROPERTIES,PROJECTED_SURFACE> (A_p);
 particle.template setField <NUMERICPROPERTIES,DA_DN> (dA_dnn);
 
  if constexpr ( providesActive(particle) ){
    particle.template setField<DYNBEHAVIOUR,ACTIVE>( true );
  }
}

References olb::particles::ParticleSystem< T, PARTICLETYPE >::get(), and olb::particles::dynamics::initializeParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

updateParticlePositions()

template<typename T , typename PARTICLETYPE >

std::vector< SpawnData< T, PARTICLETYPE::d > > olb::particles::creators::updateParticlePositions	(	std::vector< SpawnData< T, PARTICLETYPE::d > >	spawnData,
		XParticleSystem< T, PARTICLETYPE > &	particleSystem,
		MPI_Comm	particleCreatorComm = MPI_COMM_WORLD )

Updates particle positions so that they can be easily written to a txt file with the function above.

Definition at line 541 of file particleCreatorFunctions.h.

{
  using namespace descriptors;
 
#ifdef PARALLEL_MODE_MPI
  // Prepare a set of destination ranks from all other ranks
  // -> every rank will know the position
  auto& cuboidDecomposition = particleSystem.getSuperStructure().getCuboidDecomposition();
  auto& loadBalancer   = particleSystem.getSuperStructure().getLoadBalancer();
  std::set<int> destRanksSet;
  for (int iC = 0; iC < cuboidDecomposition.size(); ++iC) {
    int rank = loadBalancer.rank(iC);
    if (rank != singleton::mpi().getRank()) {
      destRanksSet.insert(rank);
    }
  }
 
  // Preparations
  std::multimap<int, std::unique_ptr<std::uint8_t[]>> dataMap;
  using GENERAL_EVAL =
      typename PARTICLETYPE ::template derivedField<descriptors::GENERAL>;
  using POSITION_EVAL =
      typename GENERAL_EVAL ::template derivedField<descriptors::POSITION>;
  using SURFACE_EVAL =
      typename PARTICLETYPE ::template derivedField<descriptors::SURFACE>;
  using ANGLE_EVAL =
      typename SURFACE_EVAL ::template derivedField<descriptors::ANGLE>;
 
  FieldArrayD<T, PARTICLETYPE, Platform::CPU_SISD, descriptors::ID> fieldID(1);
  FieldArrayD<T, PARTICLETYPE, Platform::CPU_SISD, POSITION_EVAL> fieldPosition(
      1);
  FieldArrayD<T, PARTICLETYPE, Platform::CPU_SISD, ANGLE_EVAL> fieldAngle(1);
 
  auto communicatableID       = ConcreteCommunicatable(fieldID);
  auto communicatablePosition = ConcreteCommunicatable(fieldPosition);
  auto communicatableAngle    = ConcreteCommunicatable(fieldAngle);
  const std::vector<unsigned int> indices {0};
  const std::size_t               serialSize = communicatableID.size(indices) +
                                 communicatablePosition.size(indices) +
                                 communicatableAngle.size(indices);
 
  // Obtain data for communication
  communication::forParticlesInSuperParticleSystem<
      T, PARTICLETYPE,
      conditions::valid_particle_centres //only consider center for resolved
      >(particleSystem, [&](Particle<T, PARTICLETYPE>&       particle,
                            ParticleSystem<T, PARTICLETYPE>& bParticleSystem,
                            int                              globiC) {
    fieldID.setField(0, particle.template getField<PARALLELIZATION, ID>());
    fieldPosition.setField(0, access::getPosition(particle));
    fieldAngle.setField(0, access::getAngle(particle));
    spawnData[fieldID.getField(0)].position = fieldPosition.getField(0);
    spawnData[fieldID.getField(0)].angleInDegree =
        util::radianToDegree(fieldAngle.getField(0));
    for (const int destRank : destRanksSet) {
      std::unique_ptr<std::uint8_t[]> buffer(new std::uint8_t[serialSize] {});
      std::uint8_t*                   bufferRaw = buffer.get();
      std::size_t serialIdx = communicatableID.serialize(indices, bufferRaw);
      serialIdx +=
          communicatablePosition.serialize(indices, &bufferRaw[serialIdx]);
      serialIdx +=
          communicatableAngle.serialize(indices, &bufferRaw[serialIdx]);
      dataMap.insert(std::make_pair(destRank, std::move(buffer)));
    }
  });
 
  //Create non blocking mpi helper
  singleton::MpiNonBlockingHelper mpiNbHelper;
 
  std::map<int, std::vector<std::uint8_t>> rankDataMapSorted;
  communication::fillSendBuffer(dataMap, rankDataMapSorted, serialSize);
 
  // Send mapped data
  communication::sendMappedData(rankDataMapSorted, destRanksSet, serialSize,
                                particleCreatorComm, mpiNbHelper);
 
  // Receive positions from all other ranks
  communication::receiveAndExecuteForData(
      destRanksSet, serialSize, particleCreatorComm, mpiNbHelper,
      [&](int rankOrig, std::uint8_t* buffer) {
        std::size_t serialIdx = communicatableID.deserialize(indices, buffer);
        serialIdx +=
            communicatablePosition.deserialize(indices, &buffer[serialIdx]);
        serialIdx +=
            communicatableAngle.deserialize(indices, &buffer[serialIdx]);
 
        spawnData[fieldID.getField(0)].position = fieldPosition.getField(0);
        spawnData[fieldID.getField(0)].angleInDegree =
            util::radianToDegree(fieldAngle.getField(0));
      });
 
#else
  for (int i = 0; i < particleSystem.size(); ++i) {
    spawnData[i].position = access::getPosition(particleSystem.get(i));
    spawnData[i].angleInDegree =
        util::radianToDegree(access::getAngle(particleSystem.get(i)));
  }
#endif
 
  return spawnData;
}

References olb::particles::communication::fillSendBuffer(), olb::particles::communication::forParticlesInSuperParticleSystem(), olb::particles::access::getAngle(), olb::FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD >::getField(), olb::particles::access::getPosition(), olb::singleton::mpi(), olb::util::radianToDegree(), olb::particles::communication::receiveAndExecuteForData(), olb::particles::communication::sendMappedData(), and olb::FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD >::setField().

Here is the call graph for this function:

Here is the caller graph for this function: