particles.cpph

Go to the documentation of this file.

#include "tarch/la/VectorVectorOperations.h"
#include "toolbox/particles/assignmentchecks/TracingAPI.h"
#include "peano4/utils/Loop.h"
 
#include "peano4/datamanagement/VertexMarker.h"
#include "peano4/datamanagement/CellMarker.h"
 
 
#include "internal.h"
 
 
template <typename Iterator>
Iterator toolbox::particles::particleIsDuplicate(
  const typename Iterator::value_type& particle,
  Iterator                             begin,
  const Iterator&                      end
) {
  static tarch::logging::Log _log("toolbox::particles");
  while (begin != end) {
    if (tarch::la::equals(
          (*begin)->getX(),
          particle->getX(),
          SpatialDuplicateTolerance
        )) {
      logDebug(
        "particleIsDuplicate(...)",
        "particles "
          << particle->toString() << " and " << (*begin)->toString()
          << " are the same"
      );
      return begin;
    }
    begin++;
  }
  return begin;
}
 
 
template <typename Particle>
bool toolbox::particles::particleWillStayWithinComputationalDomain(
  const Particle&                              particle,
  const tarch::la::Vector<Dimensions, double>& domainOffset,
  const tarch::la::Vector<Dimensions, double>& domainWidth
) {
  return particle.getParallelState() == Particle::ParallelState::Local
         and tarch::la::allGreaterEquals(particle.getX(), domainOffset)
         and tarch::la::
           allSmallerEquals(particle.getX(), domainOffset + domainWidth);
}
 
 
template <typename Particle, typename ParticleSet>
void toolbox::particles::insertParticlesIntoCell(
  const peano4::datamanagement::CellMarker&              marker,
  const std::vector<Particle*>&                          newParticles,
  peano4::datamanagement::VertexEnumerator<ParticleSet>& fineGridVertices,
  int                                                    spacetreeId
) {
  for (auto& p : newParticles) {
    insertParticleIntoCell(marker, p, fineGridVertices);
  }
}
 
 
void toolbox::particles::updateContainedInAdjacentCellProperty(
  const peano4::datamanagement::CellMarker&  marker,
  const std::bitset<Dimensions>&             assignedVertex,
  auto&                                      particle
) {
  const tarch::la::Vector< Dimensions, double >  vertexPositionOfAssignedVertex =
    marker.getOffset()
    +
    tarch::la::multiplyComponents(
      tarch::la::Vector< Dimensions, double >(assignedVertex),
      marker.h()
    );
  updateContainedInAdjacentCellProperty(
    vertexPositionOfAssignedVertex,
    marker.h(),
    particle
  );
}
 
 
void toolbox::particles::updateContainedInAdjacentCellProperty(
  const peano4::datamanagement::VertexMarker&  marker,
  auto&                                        particle
) {
  updateContainedInAdjacentCellProperty(
    marker.x(),
    marker.h(),
    particle
  );
}
 
 
void toolbox::particles::updateContainedInAdjacentCellProperty(
  const tarch::la::Vector< Dimensions, double >&  x,
  const tarch::la::Vector< Dimensions, double >&  h,
  auto&                                           particle
) {
  std::bitset<TwoPowerD>    result = 0;
 
  dfor2(k)
    tarch::la::Vector< Dimensions, double >  adjacentCellCentre =
      x - 0.5 * h
      +
      tarch::la::multiplyComponents(
        tarch::la::convertScalar< double >(k),
        h
      );
 
    result[kScalar] = peano4::datamanagement::CellMarker::isContained(
      particle.getX(),
      adjacentCellCentre,
      h,
      toolbox::particles::internal::relativeGrabOwnershipSpatialSortingTolerance(h) * tarch::la::NUMERICAL_ZERO_DIFFERENCE
    );
  enddforx
 
  particle.setContainedInAdjacentCell( result );
}
 
 
template <typename Particle, typename ParticleSet>
void toolbox::particles::insertParticleIntoCell(
  const peano4::datamanagement::CellMarker&              marker,
  Particle*                                              newParticle,
  peano4::datamanagement::VertexEnumerator<ParticleSet>& fineGridVertices,
  int                                                    spacetreeId
) {
  static tarch::logging::Log _log("toolbox::particles");
  std::bitset<Dimensions>    targetVertex;
  for (int d = 0; d < Dimensions; d++) {
    assertion4(
      tarch::la::greaterEquals(
        newParticle->getX()(d),
        marker.x()(d) - marker.h()(d) / 2.0
      ),
      marker.toString(),
      newParticle->toString(),
      marker.x()(d) - marker.h()(d) / 2.0,
      d
    );
    assertion4(
      tarch::la::smallerEquals(
        newParticle->getX()(d),
        marker.x()(d) + marker.h()(d) / 2.0
      ),
      marker.toString(),
      newParticle->toString(),
      marker.x()(d) + marker.h()(d) / 2.0,
      d
    );
    targetVertex[d] = newParticle->getX()(d) > marker.x()(d);
  }
 
  assertion3(
    tarch::la::
      smaller(2.0 * newParticle->getSearchRadius(), tarch::la::min(marker.h())),
    marker.toString(),
    newParticle->toString(),
    spacetreeId
  );
 
  newParticle->setParallelState(Particle::ParallelState::Local);
  newParticle->setCellH(marker.h());
  updateContainedInAdjacentCellProperty( marker, targetVertex, *newParticle );
 
  const int linearisedTargetVertex = targetVertex.to_ulong();
 
  logDebug(
    "insertParticleIntoCell(...)",
    "assign particle "
      << newParticle->toString() << " to vertex " << linearisedTargetVertex
      << " in cell " << marker.toString() << " (vertex="
      << fineGridVertices(targetVertex.to_ulong()).toString() << ")"
  );
  fineGridVertices(linearisedTargetVertex).addParticle(newParticle);
 
#if PeanoDebug > 0
  int partID = newParticle->getPartid();
#else
  int partID = -1;
#endif
 
  tarch::la::Vector<Dimensions, double>
    vertexX = marker.x() - 0.5 * marker.h()
              + tarch::la::multiplyComponents(
                tarch::la::Vector<Dimensions, double>(targetVertex),
                marker.h()
              );
 
  toolbox::particles::assignmentchecks::assignParticleToVertex(
    toolbox::particles::assignmentchecks::pruneTypeName<Particle>(),
    newParticle->getX(),
    partID,
    true, // is always local, we set that a few lines above
    vertexX,
    marker.h(), // vertexH
    spacetreeId,
    "toolbox::particles::insertParticleIntoCell()",
    vertexX,
    marker.h(),
    true // particle is new
  );
}