source: src/comm/comm.hpp@ b51c3b

/**
 * @file   comm.hpp
 * @author Julian Iseringhausen <isering@ins.uni-bonn.de>
 * @date   Wed Jun 16 13:21:06 2010
 *
 * @brief  Base class for communication.
 *
 */

#ifndef COMM_HPP_
#define COMM_HPP_

#include <list>

#include "base/defs.hpp"
#include "base/index.hpp"
#include "base/object.hpp"
#include "base/particle.hpp"
#include "thirdparty/pugixml/pugixml.hpp"

namespace VMG
{

class DomainDecomposition;
class Grid;
class Multigrid;
class Stencil;

namespace Particle
{
class LinkedCellList;
}

class Comm : public Object
{
public:
  Comm(const Boundary& boundary, DomainDecomposition* domain_dec) :
    bound(boundary),
    dd(domain_dec),
    particle_grid(NULL),
    output_directory_is_created(false),
    output_count(0)
  {}

  virtual ~Comm();

  virtual Grid& GetCoarserGrid(Multigrid& multigrid) = 0;
  virtual Grid& GetFinerGrid(Multigrid& multigrid) = 0;
  Grid& GetParticleGrid();

  virtual void CommFromGhosts(Grid& grid) = 0;
  virtual void CommToGhosts(Grid& grid) = 0;
  virtual void CommSubgrid(Grid& grid_old, Grid& grid_new, const int& direction) = 0;
  virtual void CommAddSubgrid(Grid& grid_old, Grid& grid_new, const int& direction) = 0;

  virtual void CommToGhostsAsyncStart(Grid& grid) = 0;
  virtual void CommToGhostsAsyncFinish(Grid& grid) = 0;
  virtual void CommFromGhostsAsyncStart(Grid& grid) = 0;
  virtual void CommFromGhostsAsyncFinish(Grid& grid) = 0;

  virtual void CommParticles(const Grid& grid, std::list<Particle::Particle>& particles) = 0;
  virtual void CommParticlesBack(std::list<Particle::Particle>& particles) = 0;
  virtual void CommLCListToGhosts(Particle::LinkedCellList& lc) = 0;
  virtual void CommLCListFromGhosts(const Grid& grid, Particle::LinkedCellList& lc) = 0;

  virtual vmg_float GlobalSum(const vmg_float& value) {return value;}
  virtual vmg_float GlobalSumRoot(const vmg_float& value) {return value;}
  virtual void GlobalSumArray(vmg_float* array, const vmg_int& size) {}

  virtual vmg_int GlobalSum(const vmg_int& value) {return value;}
  virtual vmg_int GlobalSumRoot(const vmg_int& value) {return value;}
  virtual void GlobalSumArray(vmg_int* array, const vmg_int& size) {}

  virtual vmg_float GlobalMax(const vmg_float& value) {return value;}
  virtual vmg_float GlobalMaxRoot(const vmg_float& value) {return value;}
  virtual void GlobalMaxArray(vmg_float* array, const vmg_int& size) {}

  virtual vmg_int GlobalMax(const vmg_int& value) {return value;}
  virtual vmg_int GlobalMaxRoot(const vmg_int& value) {return value;}
  virtual void GlobalMaxArray(vmg_int* array, const vmg_int& size) {}

  virtual vmg_float LevelSum(const Grid& grid, const vmg_float& value) {return value;}
  virtual vmg_float LevelSumRoot(const Grid& grid, const vmg_float& value) {return value;}
  virtual void LevelSumArray(const Grid& grid,  vmg_float* array, const vmg_int& size) {}

  virtual vmg_int LevelSum(const Grid& grid, const vmg_int& value) {return value;}
  virtual vmg_int LevelSumRoot(const Grid& grid, const vmg_int& value) {return value;}
  virtual void LevelSumArray(const Grid& grid, vmg_int* array, const vmg_int& size) {}

  virtual void PrintString(const char* format, ...) = 0;
  virtual void PrintStringOnce(const char* format, ...) = 0;
  virtual void PrintXML(const std::string& filename, const std::string& xml_data) = 0;
  virtual void PrintXMLAll(const std::string& filename, const std::string& xml_data) = 0;
  virtual void PrintAllSettings() = 0;
  virtual void PrintGrid(Grid& grid, const char* information) = 0;
  virtual void PrintDefect(Grid& sol, Grid& rhs, const char* information) = 0;

  virtual void DebugPrintError(const Grid& sol, const char* information) {}
  virtual void DebugPrintErrorNorm(Grid& sol) {}
  virtual void DebugPrintGridStructure(Multigrid& multigrid) {}

  virtual int GlobalRank() const {return 0;}
  virtual int GlobalSize() const {return 1;}
  virtual Index GlobalPos() const {return Index(0);}
  virtual Index GlobalProcs() const {return Index(1);}

  virtual int Rank(const Grid& grid) const {return 0;}
  virtual int Size(const Grid& grid) const {return 1;}
  virtual Index Pos(const Grid& grid) const {return Index(0);}
  virtual Index Procs(const Grid& grid) const {return Index(1);}

  virtual void PostInit(Multigrid& sol, Multigrid& rhs) = 0;

  const Boundary& BoundaryConditions() const {return bound;}

  DomainDecomposition& GetDomainDecomposition() {return *dd;}

  vmg_float ComputeResidualNorm(Multigrid& sol, Multigrid& rhs);

protected:
  const std::string& OutputPath();
  int OutputCount() {return ++output_count;}

  Boundary bound;
  DomainDecomposition* dd;

private:
  virtual std::string CreateOutputDirectory() = 0;

  Grid* particle_grid;
  std::string output_path_str;
  bool output_directory_is_created;
  int output_count;
};

}

#endif /* COMM_HPP_ */