LagrangianComm.h

Go to the documentation of this file.

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

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

#ifdef DEBUG_LagrangianComm
#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"

BEGIN_NAMESPACE_ELC



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

private:

  typedef ELComm<N,T> Base;

  //
  // Protected types.
  //

protected:

  typedef typename Base::Point Point;
  typedef typename Base::BBox BBox;
  typedef typename Base::MpiRequest MpiRequest;
  typedef typename Base::MpiStatus MpiStatus;

  //
  // Public types.
  //

public:

  typedef typename Base::Number Number;

  //
  // Using base members.
  //

private:

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

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

  //
  // Member data.
  //

private:

#ifdef ELC_USE_CPP_INTERFACE

  MPI::Intracomm _lagrangianCommunicator;
#else

  MPI_Comm _lagrangianCommunicator;
#endif

  int _eulerianRoot;

  std::vector<int> _eulerianProcessors;

  // Class for computing the point-to-point communication scheme.
  concurrent::PtToPt2Grp1Dom<N, T, ads::FixedArray<3,int>, int> 
  _pointToPoint;

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

  int _numNodes;
  int _numFaces;

  std::vector<ads::Array<1,Number> > _pressures;
  ads::Array<1,Number,false> _compositePressures;

  std::vector<MpiRequest> _pressureRequests;
  
  int _numPoints;

  //
  // Not implemented.
  //

private:

  // Default constructor not implemented.
  LagrangianComm();

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

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

public:

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

#ifdef ELC_USE_CPP_INTERFACE


  LagrangianComm(const MPI::Comm& comm, const MPI::Intracomm& lagrangian, 
                 const int eulerianSize, const int eulerianRoot,
                 VertexIdentifierStyle vertexIdentifierStyle) :
    Base(comm, vertexIdentifierStyle),
    _lagrangianCommunicator(lagrangian.Dup()),
    _eulerianRoot(eulerianRoot),
    _pointToPoint(comm, lagrangian, eulerianSize, eulerianRoot)
  {}
#else


  LagrangianComm(const MPI_Comm comm, const MPI_Comm lagrangian, 
                 const int eulerianSize, const int eulerianRoot,
                 VertexIdentifierStyle vertexIdentifierStyle) :
    Base(comm, vertexIdentifierStyle),
    _lagrangianCommunicator(),
    _eulerianRoot(eulerianRoot),
    _pointToPoint(comm, lagrangian, eulerianSize, eulerianRoot) {
    MPI_Comm_dup(lagrangian, &_lagrangianCommunicator);
  }
#endif

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

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

  // Disabled documentation for the identifiers parameter:
  // If the solid solver does not have this data, it should pass 0.
  // Then identifiers will be computed on the Lagrangian nodes.


  void
  sendMesh(const int numNodes, const void* identifiers, 
           const void* positions, const void* velocities,
           const int numFaces, const void* connectivities);

  void
  waitForMesh();

  void
  receivePressure(const int numPoints, void* pressures);

  void
  waitForPressure();

  // @}
};


END_NAMESPACE_ELC

#define __elc_LagrangianComm_ipp__
#include "LagrangianComm.ipp"
#undef __elc_LagrangianComm_ipp__

#endif

---