EulerianComm.h

Go to the documentation of this file.

// -*- C++ -*-
 
#if !defined(__elc_EulerianComm_h__)
#define __elc_EulerianComm_h__

// If we are debugging the whole elc package.
#if defined(DEBUG_elc) && !defined(DEBUG_EulerianComm)
#define DEBUG_EulerianComm
#endif

#ifdef DEBUG_EulerianComm
#ifndef DEBUG_ELComm
#define DEBUG_ELComm
#endif
#endif

#include "ELComm.h"

#if defined(ELC_USE_CPP_INTERFACE) && !defined(PT2PT_BBOX_USE_CPP_INTERFACE)
#define PT2PT_BBOX_USE_CPP_INTERFACE
#endif
#include "../concurrent/pt2pt_bbox.h"

#include "../ads/iterator/TrivialOutputIterator.h"
#include "../ads/functor/select.h"

#include "../geom/mesh/iss/set.h"

#include "../third-party/loki/TypeManip.h"

#include <set>
#include <map>

BEGIN_NAMESPACE_ELC



template<int N, typename T>
class EulerianComm :
  public ELComm<N,T> {
  //
  // Private types.
  //

private:

  typedef ELComm<N,T> Base;

  //
  // Protected types.
  //

protected:

  typedef typename Base::Number Number;
  typedef typename Base::Point Point;
  typedef typename Base::BBox BBox;
  typedef typename Base::MpiRequest MpiRequest;
  typedef typename Base::MpiStatus MpiStatus;
  typedef ads::FixedArray<N,int> IndexedFace;

  //
  // Using base members.
  //

protected:

  using Base::_comm;
  using Base::_mpiNumber;
  using Base::_vertexIdentifierStyle;

  using Base::TagPressures;

private:

  using Base::TagIdentifiers;
  using Base::TagPositions;
  using Base::TagVelocities;
  using Base::TagFaceData;

  //
  // Member data.
  //

protected:

#ifdef ELC_USE_CPP_INTERFACE
  MPI::Intracomm _eulerianCommunicator;
#else
  MPI_Comm _eulerianCommunicator;
#endif

  int _lagrangianRoot;

  std::vector<ads::Array<1,int> > _identifiers;
  std::vector<ads::Array<1,Point> > _positions;
  std::vector<ads::Array<1,Point> > _velocities;
  std::vector<ads::Array<1,IndexedFace> > _connectivities;
  std::vector<ads::Array<1,Number> > _pressures;


  std::map<int,int> _identifierToIndex;

  // CONTINUE: use something derived from an indexed simplex set instead.
  // That would facilitate interpolation.
  ads::Array<1,Point> _assembledPositions;
  ads::Array<1,Point> _assembledVelocities;
  ads::Array<1,IndexedFace> _assembledConnectivities;
  ads::Array<1,Number> _assembledPressures;

  concurrent::PtToPt2Grp1Dom<N, T, int, ads::FixedArray<3,int> > 
  _pointToPoint;

  std::vector<ads::FixedArray<3,int> > _lagrangianData;

  ads::Array<1,Point> _faceNormals;
  ads::Array<1,Point> _faceCentroids;

private:

  std::vector<MpiRequest> _identifierRequests;
  std::vector<MpiRequest> _positionRequests;
  std::vector<MpiRequest> _velocityRequests;
  std::vector<MpiRequest> _connectivityRequests;

  //
  // Not implemented.
  //

private:

  // Default constructor not implemented.
  EulerianComm();

  // Copy constructor not implemented.
  EulerianComm(const EulerianComm&);

  // Assignment operator not implemented.
  EulerianComm&
  operator=(const EulerianComm&);

public:

  //--------------------------------------------------------------------------
  // @{

#ifdef ELC_USE_CPP_INTERFACE

  EulerianComm(const MPI::Comm& comm, const MPI::Intracomm& eulerian, 
               const int lagrangianSize, const int lagrangianRoot,
               VertexIdentifierStyle vertexIdentifierStyle) :
    Base(comm, vertexIdentifierStyle),
    _eulerianCommunicator(eulerian.Dup()),
    _lagrangianRoot(lagrangianRoot),
    _pointToPoint(comm, eulerian, lagrangianSize, lagrangianRoot)
  {}
#else

  EulerianComm(const MPI_Comm comm, const MPI_Comm eulerian, 
               const int lagrangianSize, const int lagrangianRoot,
               VertexIdentifierStyle vertexIdentifierStyle) :
    Base(comm, vertexIdentifierStyle),
    _eulerianCommunicator(),
    _lagrangianRoot(lagrangianRoot),
    _pointToPoint(comm, eulerian, lagrangianSize, lagrangianRoot) {
    MPI_Comm_dup(eulerian, &_eulerianCommunicator);
  }
#endif

  virtual
  ~EulerianComm() {
#ifdef ELC_USE_CPP_INTERFACE
    _eulerianCommunicator.Free();
#else
    MPI_Comm_free(&_eulerianCommunicator);
#endif
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  int
  getNumberOfNodes() const {
    return _assembledPositions.size();
  }

  int
  getNumberOfFaces() const {
    return _assembledConnectivities.size();
  }

  const ads::Array<1,Point>&
  getPositions() const {
    return _assembledPositions;
  }

  const Number*
  getPositionsData() const {
    return reinterpret_cast<const Number*>(_assembledPositions.data());
  }

  const ads::Array<1,Point>&
  getVelocities() const {
    return _assembledVelocities;
  }

  const Number*
  getVelocitiesData() const {
    return reinterpret_cast<const Number*>(_assembledVelocities.data());
  }

  const ads::Array<1,IndexedFace>&
  getConnectivities() const {
    return _assembledConnectivities;
  }

  const int*
  getConnectivitiesData() const {
    return reinterpret_cast<const int*>(_assembledConnectivities.data());
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  const ads::Array<1,Point>&
  getFaceNormals() const {
    return _faceNormals;
  }

  const Number*
  getFaceNormalsData() const {
    return reinterpret_cast<const Number*>(_faceNormals.data());
  }

  const Point&
  getFaceNormal(const int n) const {
    return _faceNormals[n];
  }

  const Number*
  getFaceNormalData(const int n) const {
    return reinterpret_cast<const Number*>(_faceNormals[n].data());
  }

  const ads::Array<1,Point>&
  getFaceCentroids() const {
    return _faceCentroids;
  }

  const Number*
  getFaceCentroidsData() const {
    return reinterpret_cast<const Number*>(_faceCentroids.data());
  }

  const Point&
  getFaceCentroid(const int n) const {
    return _faceCentroids[n];
  }

  const Number*
  getFaceCentroidData(const int n) const {
    return reinterpret_cast<const Number*>(_faceCentroids[n].data());
  }

  // @}
  //--------------------------------------------------------------------------
  // @{

  ads::Array<1,Number>&
  getPressures() {
    return _assembledPressures;
  }

  Number*
  getPressuresData() {
    return reinterpret_cast<Number*>(_assembledPressures.data());
  }

  // @}
  //--------------------------------------------------------------------------
  // @{


  void
  receiveMesh(const BBox& domain);


  void
  receiveMesh(const Number* domain) {
    receive_mesh(BBox(domain));
  }


  void
  waitForMesh();



  virtual
  void
  sendPressure() = 0;


  virtual
  void
  waitForPressure() = 0;



  void
  computeFaceNormals();
  

  void
  computeFaceCentroids();
  

  virtual
  void
  initializePressure() = 0;

  // @}

private:

  void
  computeFaceNormal(const int n, Point* normal) const;

  void
  computeFaceCentroid(const int n, Point* centroid) const;

  void
  generateIdentifiers();

};


END_NAMESPACE_ELC

#define __elc_EulerianComm_ipp__
#include "EulerianComm.ipp"
#undef __elc_EulerianComm_ipp__

#endif

---