ALL_LB.hpp

Go to the documentation of this file.

/*
Copyright 2018-2026 Rene Halver, Forschungszentrum Juelich GmbH, Germany
Copyright 2018-2026 Godehard Sutmann, Forschungszentrum Juelich GmbH, Germany
Copyright 2026-2026 Jonas Kroschewski, Forschungszentrum Juelich GmbH, Germany
 
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
 
1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
 
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
   other materials provided with the distribution.
 
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
   specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
 
#ifndef ALL_LB_HEADER_INCLUDED
#define ALL_LB_HEADER_INCLUDED
 
#include "ALL_Point.hpp"
#include <mpi.h>
#include <vector>
#include <iostream>
 
namespace ALL {

template <class T, class W> class LB {
public:
  LB(const int dim, const T g) : gamma(g) {
    // set allowed minimum size to zero
    setDimension(dim);
    minSize = std::vector<T>(dim, 0.0);
    periodicity.resize(dim);
    local_coords.resize(dim);
    global_dims.resize(dim);
    neighborVertices.resize(0);
  }

  virtual ~LB() = default;

  virtual void setup() = 0;

  virtual void balance(const int step) = 0;

  virtual std::vector<int> &getNeighbors() = 0;

  virtual void setVertices(const std::vector<Point<T>> &vertices_in) {
    // as a basic assumption the number of resulting vertices
    // is equal to the number of input vertices:
    // exceptions:
    //      VORONOI
    vertices = vertices_in;
    prevVertices = vertices_in;
  }

  virtual void setDimension(const int d) { 
    if (d != 3)
      throw InvalidArgumentException(
        __FILE__, __func__, __LINE__,
        "Currently only three dimensional vertices are supported.");
    else
        dimension = d; 
  }

  virtual int getDimension() { return dimension; }

  virtual void setGamma(const T g) { gamma = g; }

  virtual const T getGamma() { return gamma; }
  
  // method to set the automatic calculation of the correction value
  // @param[in] b the boolean to activate/deactivate automatic calculation
  virtual void setGammaAutoCalc(const bool b) { gammaAutoCalc = b; }

  virtual const bool getGammaAutoCalc() { return gammaAutoCalc; }

  virtual void setWork(const std::vector<W> &w) {
  for(const W& val : w) {
    if(std::isnan(val)){throw InvalidArgumentException(__FILE__, __func__, __LINE__, "NAN is not a valid value for work.");}
    if(std::isinf(val)){throw InvalidArgumentException(__FILE__, __func__, __LINE__, "inf is not a valid value for work.");}
  }
    work = w; 
  }

  virtual void setWork(const W w) {
    work.resize(1);
    work.at(0) = w;
  }

  virtual void setMinDomainSize(const std::vector<T> &minSize) {
    this->minSize = minSize;
  }

  virtual const std::vector<T> &getMinDomainSize() { return minSize; }

  virtual void setSysSize(const std::vector<T> &newSysSize) {
    sysSize = newSysSize;
  }

  virtual const std::vector<T> &getSysSize() { return sysSize; }

  virtual std::vector<W> &getWork() { return work; }

  virtual std::vector<Point<T>> &getVertices() { return vertices; }

  virtual std::vector<Point<T>> &getPrevVertices() { return prevVertices; };

  virtual void setCommunicator(const MPI_Comm comm) {
    // store communicator
    globalComm = comm;
    // get local rank within communicator
    MPI_Comm_rank(comm, &localRank);
  }

  int getNVertices() { return vertices.size(); }

  virtual void setAdditionalData(const void *data) = 0;

  virtual W getEstimatedEfficiency() = 0;

  double getEfficiency()
  {
    double localSum = 0.0;
    for (auto i = this->work.begin(); i < this->work.end(); ++i)
    {        
        localSum += *i;
    }        
    double globalMin;
    double globalMax;
    MPI_Allreduce(&localSum, &globalMin, 1, MPI_DOUBLE, MPI_MIN, this->globalComm);
    MPI_Allreduce(&localSum, &globalMax, 1, MPI_DOUBLE, MPI_MAX, this->globalComm);
    return (1.0 - (double)(globalMax - globalMin) / 
                  (double)(globalMax + globalMin));
  }
 

  std::vector<T> &getNeighborVertices() {
    return neighborVertices; }
 
protected:
  T gamma;
  bool gammaAutoCalc;
  int dimension;
  MPI_Comm globalComm;
  int localRank;
  std::vector<T> minSize;
  std::vector<T> sysSize;
  std::vector<W> work;
  std::vector<Point<T>> vertices;
  std::vector<Point<T>> prevVertices;
  std::vector<int> global_dims;
  std::vector<int> local_coords;
  std::vector<int> periodicity;
  std::vector<T> neighborVertices;
  void resizeVertices(const int newSize) { vertices.resize(newSize); }
 
};
 
}//namespace ALL
 
#endif // ALL_LB_HEADER_INCLUDED