ParticleSpecies.h

Go to the documentation of this file.

// This file is part of the ExaParty project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include "tarch/logging/Log.h"
#include "tarch/multicore/Lock.h"
 
#ifdef Parallel
#include "tarch/mpi/mpi.h"
#include "tarch/mpi/Rank.h"
#include "tarch/services/Service.h"
#include "tarch/services/ServiceRepository.h"
#endif
 
namespace exaparty {
  class ParticleSpecies;
} // namespace exaparty
 
class exaparty::ParticleSpecies {
private:
  static tarch::logging::Log                _log;
  static tarch::multicore::BooleanSemaphore _semaphore;
 
  double _minTimeStepSize;
  double _maxTimeStepSize;
 
  double _minTimeStamp;
  double _maxTimeStamp;
 
  double _minSearchRadius;
  double _maxSearchRadius;
 
  double _minVelocity;
  double _maxVelocity;
 
  bool _rerunPreviousGridSweep;
 
public:
  inline ParticleSpecies() : _minTimeStepSize(std::numeric_limits<double>::max()),
    _maxTimeStepSize(0.0),
    _minTimeStamp(0.0), // std::numeric_limits<double>::max()
    _maxTimeStamp(0.0),
    _minSearchRadius(std::numeric_limits<double>::max()),
    _maxSearchRadius(0.0),
    _minVelocity(std::numeric_limits<double>::max()),
    _maxVelocity(0.0),
    _rerunPreviousGridSweep(false) {}
 
  ParticleSpecies(const ParticleSpecies& copy) = delete;
 
  inline double getMinTimeStepSize() const {
    return _minTimeStepSize;
  }
 
  inline double getMaxTimeStepSize() const {
    return _maxTimeStepSize;
  }
 
  inline double getMinTimeStamp() const {
    return _minTimeStamp;
  }
 
  inline double getMaxTimeStamp() const {
    return _maxTimeStamp;
  }
 
  inline double getMinSearchRadius() const {
    return _minSearchRadius;
  }
 
  inline double getMaxSearchRadius() const {
    return _maxSearchRadius;
  }
 
  inline double getMinVelocity() const {
    return _minVelocity;
  }
 
  inline double getMaxVelocity() const {
    return _maxVelocity;
  }
 
  inline bool rerunPreviousGridSweep() const { return _rerunPreviousGridSweep; }
 
  inline void clearRerunPreviousGridSweepFlag() { _rerunPreviousGridSweep = false; }
 
  inline void setRerunPreviousGridSweep() {
    tarch::multicore::Lock lock(_semaphore);
    _rerunPreviousGridSweep = true;
  }
 
  inline void setTimeStamp(double t, bool reduceInsteadOfOverwrite = true) {
    setTimeStamp(t, t, reduceInsteadOfOverwrite);
  }
 
  inline void setTimeStamp(double tMin, double tMax, bool reduceInsteadOfOverwrite = true) {
    tarch::multicore::Lock lock(_semaphore);
    if (reduceInsteadOfOverwrite) {
      _minTimeStamp = std::min(_minTimeStamp, tMin);
      _maxTimeStamp = std::max(_maxTimeStamp, tMax);
    } else {
      _minTimeStamp = tMin;
      _maxTimeStamp = tMax;
    }
  }
 
  inline void setTimeStepSize(double dt, bool reduceInsteadOfOverwrite = true) {
    setTimeStepSize(dt, dt, reduceInsteadOfOverwrite);
  }
 
  inline void setTimeStepSize(double dtMin, double dtMax, bool reduceInsteadOfOverwrite = true) {
    tarch::multicore::Lock lock(_semaphore);
    if (reduceInsteadOfOverwrite) {
      _minTimeStepSize = std::min(_minTimeStepSize, dtMin);
      _maxTimeStepSize = std::max(_maxTimeStepSize, dtMax);
    } else {
      _minTimeStepSize = dtMin;
      _maxTimeStepSize = dtMax;
    }
  }
 
  inline void setVelocity(double vMin, double vMax, double rMin, double rMax) {
    tarch::multicore::Lock lock(_semaphore);
    _minVelocity     = std::min(_minVelocity, vMin);
    _maxVelocity     = std::max(_maxVelocity, vMax);
    _minSearchRadius = std::min(_minSearchRadius, rMin);
    _maxSearchRadius = std::max(_maxSearchRadius, rMax);
    logDebug("setVelocity()", vMin << "x" << vMax);
  }
 
  inline void startTimeStep() {}
 
  inline void finishTimeStep() {}
 
  inline void clearSearchRadius() {
    _minSearchRadius = std::numeric_limits<double>::max();
    _maxSearchRadius = 0.0;
  }
 
  inline void clearVelocity() {
    _minVelocity = std::numeric_limits<double>::max();
    _maxVelocity = 0.0;
  }
 
  inline void clearTimeStampAndTimeStepSize() {
    _minTimeStepSize = std::numeric_limits<double>::max();
    _maxTimeStepSize = 0.0;
 
    _minTimeStamp = std::numeric_limits<double>::max();
    _maxTimeStamp = 0.0;
  }
 
  inline void allReduce() {
#ifdef Parallel
 
    double localMinTimeStepSize = _minTimeStepSize;
    double localMaxTimeStepSize = _maxTimeStepSize;
 
    double localMinTimeStamp = _minTimeStamp;
    double localMaxTimeStamp = _maxTimeStamp;
 
    double localMinSearchRadius = _minSearchRadius;
    double localMaxSearchRadius = _maxSearchRadius;
 
    double localMinVelocity = _minVelocity;
    double localMaxVelocity = _maxVelocity;
 
    int localRerunPreviousGridSweep  = _rerunPreviousGridSweep ? 1 : 0;
    int globalRerunPreviousGridSweep = 0;
 
    tarch::mpi::Rank::getInstance()
      .allReduce(&localMinTimeStepSize, &_minTimeStepSize, 1, MPI_DOUBLE, MPI_MIN, [&]() -> void {
        tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
      });
    tarch::mpi::Rank::getInstance()
      .allReduce(&localMaxTimeStepSize, &_maxTimeStepSize, 1, MPI_DOUBLE, MPI_MAX, [&]() -> void {
        tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
      });
    tarch::mpi::Rank::getInstance().allReduce(&localMinTimeStamp, &_minTimeStamp, 1, MPI_DOUBLE, MPI_MIN, [&]() -> void {
      tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
    });
    tarch::mpi::Rank::getInstance().allReduce(&localMaxTimeStamp, &_maxTimeStamp, 1, MPI_DOUBLE, MPI_MAX, [&]() -> void {
      tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
    });
    tarch::mpi::Rank::getInstance()
      .allReduce(&localMinSearchRadius, &_minSearchRadius, 1, MPI_DOUBLE, MPI_MIN, [&]() -> void {
        tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
      });
    tarch::mpi::Rank::getInstance()
      .allReduce(&localMaxSearchRadius, &_maxSearchRadius, 1, MPI_DOUBLE, MPI_MAX, [&]() -> void {
        tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
      });
    tarch::mpi::Rank::getInstance().allReduce(&localMinVelocity, &_minVelocity, 1, MPI_DOUBLE, MPI_MIN, [&]() -> void {
      tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
    });
    tarch::mpi::Rank::getInstance().allReduce(&localMaxVelocity, &_maxVelocity, 1, MPI_DOUBLE, MPI_MAX, [&]() -> void {
      tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
    });
    tarch::mpi::Rank::getInstance()
      .allReduce(&localRerunPreviousGridSweep, &globalRerunPreviousGridSweep, 1, MPI_INT, MPI_SUM, [&]() -> void {
        tarch::services::ServiceRepository::getInstance().receiveDanglingMessages();
      });
    _rerunPreviousGridSweep = globalRerunPreviousGridSweep > 0;
 
#endif
  }
};