#include <CouplingCwipi.h>

Inheritance diagram for Nektar::SolverUtils::CouplingCwipi:

Public Member Functions
SOLVER_UTILS_EXPORT	CouplingCwipi (MultiRegions::ExpListSharedPtr field)

virtual SOLVER_UTILS_EXPORT	~CouplingCwipi ()

SOLVER_UTILS_EXPORT void	SendCallback (Array< OneD, Array< OneD, NekDouble > > &interpField, Array< OneD, Array< OneD, NekDouble > > &distCoords)

Public Member Functions inherited from Nektar::SolverUtils::Coupling
virtual SOLVER_UTILS_EXPORT	~Coupling ()

SOLVER_UTILS_EXPORT void	Init ()

SOLVER_UTILS_EXPORT const std::map< std::string, std::string >	GetConfig ()

SOLVER_UTILS_EXPORT std::vector< std::string >	GetSendFieldNames ()

SOLVER_UTILS_EXPORT std::vector< std::string >	GetRecvFieldNames ()

SOLVER_UTILS_EXPORT void	Finalize ()

SOLVER_UTILS_EXPORT void	Send (const int step, const NekDouble time, const Array< OneD, const Array< OneD, NekDouble > > &field, std::vector< std::string > &varNames)

SOLVER_UTILS_EXPORT void	Receive (const int step, const NekDouble time, Array< OneD, Array< OneD, NekDouble > > &field, std::vector< std::string > &varNames)

Static Public Member Functions
static CouplingSharedPtr	create (MultiRegions::ExpListSharedPtr field)
	Creates an instance of this class. More...

static SOLVER_UTILS_EXPORT void	InterpCallback (const int entities_dim, const int n_local_vertex, const int n_local_element, const int n_local_polhyedra, const int n_distant_point, const double local_coordinates[], const int local_connectivity_index[], const int local_connectivity[], const int local_polyhedra_face_index[], const int local_polyhedra_cell_to_face_connectivity[], const int local_polyhedra_face_connectivity_index[], const int local_polyhedra_face_connectivity[], const double distant_points_coordinates[], const int distant_points_location[], const float distant_points_distance[], const int distant_points_barycentric_coordinates_index[], const double distant_points_barycentric_coordinates[], const int stride, const cwipi_solver_type_t solver_type, const void local_field, void distant_field)

Static Public Attributes
static std::string	className

Protected Member Functions
virtual SOLVER_UTILS_EXPORT void	v_Init ()

virtual SOLVER_UTILS_EXPORT void	v_Send (const int step, const NekDouble time, const Array< OneD, const Array< OneD, NekDouble > > &field, std::vector< std::string > &varNames)

virtual SOLVER_UTILS_EXPORT void	v_Receive (const int step, const NekDouble time, Array< OneD, Array< OneD, NekDouble > > &field, std::vector< std::string > &varNames)

virtual SOLVER_UTILS_EXPORT void	v_Finalize ()

SOLVER_UTILS_EXPORT NekDouble	GetSendField (const int i, const int j) const

Protected Member Functions inherited from Nektar::SolverUtils::Coupling
SOLVER_UTILS_EXPORT	Coupling (MultiRegions::ExpListSharedPtr field)

SOLVER_UTILS_EXPORT std::vector< int >	GenerateVariableMapping (std::vector< std::string > &vars, std::vector< std::string > &transVars)

Protected Attributes
NekDouble	m_filtWidth

Array< OneD, Array< OneD, NekDouble > >	m_sendField

MultiRegions::ExpListSharedPtr	m_recvField

Array< OneD, Array< OneD, NekDouble > >	m_oldFields

Array< OneD, Array< OneD, NekDouble > >	m_newFields

int	m_sendHandle

int	m_recvHandle

int	m_sendTag

int	m_recvTag

int	m_lastSend

int	m_lastReceive

int	m_spacedim

int	m_nPoints

double *	m_points

double *	m_coords

int *	m_connecIdx

int *	m_connec

double *	m_rValsInterl

double *	m_sValsInterl

std::map< int, int >	m_vertMap

FieldUtils::InterpolatorSharedPtr	m_sendInterpolator

FieldUtils::InterpolatorSharedPtr	m_extrapInterpolator

Protected Attributes inherited from Nektar::SolverUtils::Coupling
std::string	m_couplingName

CouplingConfigMap	m_config

MultiRegions::ExpListSharedPtr	m_evalField

int	m_nSendVars

std::vector< std::string >	m_sendFieldNames

int	m_sendSteps

int	m_nRecvVars

std::vector< std::string >	m_recvFieldNames

int	m_recvSteps

Private Member Functions
void	ReadConfig (LibUtilities::SessionReaderSharedPtr session)

void	SetupReceive ()

void	SetupSend ()

void	SendComplete ()

void	ReceiveStart ()

void	ReceiveCwipi (const int step, const NekDouble time, Array< OneD, Array< OneD, NekDouble > > &field)

void	EvaluateFields (Array< OneD, Array< OneD, NekDouble > > interpField, Array< OneD, Array< OneD, NekDouble > > distCoords)

void	SetupSendInterpolation ()

void	AnnounceMesh ()

void	DumpRawFields (const NekDouble time, Array< OneD, Array< OneD, NekDouble > > rVals)

void	ExtrapolateFields (Array< OneD, Array< OneD, NekDouble > > &rVals, Array< OneD, int > &notLoc)

template<typename T >
void	AddElementsToMesh (T geom, int &coordsPos, int &connecPos, int &conidxPos)

Additional Inherited Members
Public Types inherited from Nektar::SolverUtils::Coupling
typedef std::map< std::string, std::string >	CouplingConfigMap

Detailed Description

Definition at line 51 of file CouplingCwipi.h.

Constructor & Destructor Documentation

◆ CouplingCwipi()

Nektar::SolverUtils::CouplingCwipi::CouplingCwipi ( MultiRegions::ExpListSharedPtr field )

Definition at line 128 of file CouplingCwipi.cpp.

References Nektar::SolverUtils::Coupling::m_config.

Referenced by create().

     : Coupling(field), m_sendHandle(-1), m_recvHandle(-1), m_lastSend(-1E6),
       m_lastReceive(-1E6), m_points(NULL), m_coords(NULL), m_connecIdx(NULL),
       m_connec(NULL), m_rValsInterl(NULL), m_sValsInterl(NULL)
 {
     // defaults
     m_config["GEOMTOL"]      = "0.1";
     m_config["LOCALNAME"]    = "nektar";
     m_config["REMOTENAME"]   = "precise";
     m_config["OVERSAMPLE"]   = "0";
     m_config["FILTERWIDTH"]  = "-1";
     m_config["DUMPRAW"]      = "0";
     m_config["SENDMETHOD"]   = "EVALUATE";
     m_config["NOTLOCMETHOD"] = "KEEP";
 }

◆ ~CouplingCwipi()

Nektar::SolverUtils::CouplingCwipi::~CouplingCwipi ( )

virtual

Definition at line 238 of file CouplingCwipi.cpp.

References m_connec, m_connecIdx, m_coords, m_points, m_rValsInterl, and m_sValsInterl.

Referenced by create().

 {
     free(m_coords);
     free(m_points);
     free(m_connec);
     free(m_connecIdx);
     free(m_rValsInterl);
     free(m_sValsInterl);
 }

Member Function Documentation

◆ AddElementsToMesh()

template<typename T >

void Nektar::SolverUtils::CouplingCwipi::AddElementsToMesh	(	T	geom,
		int &	coordsPos,
		int &	connecPos,
		int &	conidxPos
	)

private

Definition at line 553 of file CouplingCwipi.cpp.

References m_connec, m_connecIdx, m_coords, and m_vertMap.

Referenced by AnnounceMesh(), and GetSendField().

 {
     // helper variables
     Array<OneD, NekDouble> x(3);
     SpatialDomains::PointGeomSharedPtr vert;
     int vertID;
 
     int kNverts = T::mapped_type::element_type::kNverts;
 
     // iterate over all elements
     for (auto it = geom.begin(); it != geom.end(); it++)
     {
         //  iterate over the elements vertices
         for (int j = 0; j < kNverts; ++j)
         {
             vert   = it->second->GetVertex(j);
             vertID = vert->GetVid();
 
             // check if we already stored the vertex
             if (m_vertMap.count(vertID) == 0)
             {
                 //  store the vertex
                 vert->GetCoords(x[0], x[1], x[2]);
                 m_coords[3 * coordsPos + 0] = double(x[0]);
                 m_coords[3 * coordsPos + 1] = double(x[1]);
                 m_coords[3 * coordsPos + 2] = double(x[2]);
 
                 // store the vertex position in the m_coords array
                 m_vertMap[vertID] = coordsPos;
                 coordsPos++;
             }
 
             m_connec[connecPos] = m_vertMap[vertID] + 1;
             connecPos++;
         }
 
         m_connecIdx[conidxPos + 1] = m_connecIdx[conidxPos] + kNverts;
         conidxPos++;
     }
 }

◆ AnnounceMesh()

void Nektar::SolverUtils::CouplingCwipi::AnnounceMesh ( )

private

Definition at line 467 of file CouplingCwipi.cpp.

References AddElementsToMesh(), ASSERTL1, m_connec, m_connecIdx, m_coords, Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, and m_spacedim.

Referenced by GetSendField(), and v_Init().

 {
     SpatialDomains::MeshGraphSharedPtr graph = m_evalField->GetGraph();
 
     // get Elements
     SpatialDomains::SegGeomMap seggeom;
     SpatialDomains::TriGeomMap trigeom;
     SpatialDomains::QuadGeomMap quadgeom;
     SpatialDomains::TetGeomMap tetgeom;
     SpatialDomains::PyrGeomMap pyrgeom;
     SpatialDomains::PrismGeomMap prismgeom;
     SpatialDomains::HexGeomMap hexgeom;
     if (m_spacedim == 1)
     {
         seggeom = graph->GetAllSegGeoms();
     }
     else if (m_spacedim == 2)
     {
         trigeom  = graph->GetAllTriGeoms();
         quadgeom = graph->GetAllQuadGeoms();
     }
     else if (m_spacedim == 3)
     {
         tetgeom   = graph->GetAllTetGeoms();
         pyrgeom   = graph->GetAllPyrGeoms();
         prismgeom = graph->GetAllPrismGeoms();
         hexgeom   = graph->GetAllHexGeoms();
     };
 
     int nVerts = graph->GetNvertices();
     int nElts  = seggeom.size() + trigeom.size() + quadgeom.size() +
                 tetgeom.size() + pyrgeom.size() + prismgeom.size() +
                 hexgeom.size();
 
     // allocate CWIPI arrays
     m_coords = (double *)malloc(sizeof(double) * 3 * nVerts);
     ASSERTL1(m_coords != NULL, "malloc failed for m_coords");
     int tmp = 2 * seggeom.size() + 3 * trigeom.size() + 4 * quadgeom.size() +
               4 * tetgeom.size() + 5 * pyrgeom.size() + 6 * prismgeom.size() +
               8 * hexgeom.size();
     m_connec = (int *)malloc(sizeof(int) * tmp);
     ASSERTL1(m_connec != NULL, "malloc failed for m_connec");
     m_connecIdx = (int *)malloc(sizeof(int) * (nElts + 1));
     ASSERTL1(m_connecIdx != NULL, "malloc failed for m_connecIdx");
 
     m_connecIdx[0] = 0;
     int coordsPos  = 0;
     int connecPos  = 0;
     int conidxPos  = 0;
 
     AddElementsToMesh(seggeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(trigeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(quadgeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(tetgeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(pyrgeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(prismgeom, coordsPos, connecPos, conidxPos);
     AddElementsToMesh(hexgeom, coordsPos, connecPos, conidxPos);
 
     // output the mesh in tecplot format. If this works, CWIPI will be able
     // to process it, too
     /*
     cout << "VARIABLES = \"X\", \"Y\", \"Z\", \"U\"" <<  endl;
     cout << "ZONE NODES=" <<  nVerts << ",ELEMENTS=" <<  nElts;
     cout << ",DATAPACKING=POINT, ZONETYPE=FETETRAHEDRON" <<  endl;
     for (int i = 0; i < nVerts; ++i)
     {
         cout << m_coords[3*i + 0] << " " << m_coords[3*i + 1] << " ";
         cout << m_coords[3*i + 2] << " " <<  1.0 << endl;
     }
     for (int i = 0; i < nElts; ++i)
     {
         cout << m_connec[i*4 + 0] << " " << m_connec[i*4 + 1] << " ";
         cout << m_connec[i*4 + 2] <<  " " <<  m_connec[i*4 + 3] <<  endl;
     }
     */
 
     cwipi_define_mesh(
         m_couplingName.c_str(), nVerts, nElts, m_coords, m_connecIdx, m_connec);
 }

◆ create()

static CouplingSharedPtr Nektar::SolverUtils::CouplingCwipi::create ( MultiRegions::ExpListSharedPtr field )

inlinestatic

Creates an instance of this class.

Definition at line 58 of file CouplingCwipi.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), CouplingCwipi(), Nektar::SolverUtils::CouplingSharedPtr, InterpCallback(), CellMLToNektar.cellml_metadata::p, SendCallback(), SOLVER_UTILS_EXPORT, and ~CouplingCwipi().

     {
         CouplingSharedPtr p =
             MemoryManager<CouplingCwipi>::AllocateSharedPtr(field);
         p->Init();
         return p;
     }

◆ DumpRawFields()

void Nektar::SolverUtils::CouplingCwipi::DumpRawFields	(	const NekDouble	time,
		Array< OneD, Array< OneD, NekDouble > >	rVals
	)

private

Definition at line 1085 of file CouplingCwipi.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), CellMLToNektar.pycml::format, Nektar::SolverUtils::Coupling::m_config, Nektar::SolverUtils::Coupling::m_evalField, Nektar::SolverUtils::Coupling::m_nRecvVars, m_recvField, Nektar::SolverUtils::Coupling::m_recvFieldNames, m_spacedim, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by GetSendField(), and ReceiveCwipi().

 {
     LibUtilities::Timer timer1;
     timer1.Start();
 
 #if (defined _WIN32 && _MSC_VER < 1900)
     // We need this to make sure boost::format has always
     // two digits in the exponents of Scientific notation.
     unsigned int old_exponent_format;
     old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT);
     filename            = boost::str(boost::format(filename) % m_time);
     _set_output_format(old_exponent_format);
 #else
     std::string filename =
         boost::str(boost::format(m_config["DUMPRAW"]) % time);
 #endif
 
     Array<OneD, Array<OneD, NekDouble> > tmp(m_nRecvVars + m_spacedim);
     for (int i = 0; i < 3; ++i)
     {
         tmp[i] = Array<OneD, NekDouble>(m_recvField->GetTotPoints(), 0.0);
     }
     m_recvField->GetCoords(tmp[0], tmp[1], tmp[2]);
 
     for (int i = 0; i < m_nRecvVars; ++i)
     {
         tmp[m_spacedim + i] = rVals[i];
     }
 
     LibUtilities::CsvIO csvIO(m_evalField->GetSession()->GetComm());
     LibUtilities::PtsFieldSharedPtr rvPts =
         MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
             m_spacedim, m_recvFieldNames, tmp);
     csvIO.Write(filename, rvPts);
 
     timer1.Stop();
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cout << "DumpRawFields total time: " << timer1.TimePerTest(1) << endl;
     }
 }

◆ EvaluateFields()

void Nektar::SolverUtils::CouplingCwipi::EvaluateFields	(	Array< OneD, Array< OneD, NekDouble > >	interpField,
		Array< OneD, Array< OneD, NekDouble > >	distCoords
	)

private

Definition at line 378 of file CouplingCwipi.cpp.

References ASSERTL0, Nektar::NekConstants::kNekZeroTol, Nektar::SolverUtils::Coupling::m_evalField, Nektar::SolverUtils::Coupling::m_nSendVars, m_sendField, and m_spacedim.

Referenced by GetSendField(), and SendCallback().

 {
     int nOutPts = distCoords.num_elements();
 
     Array<OneD, NekDouble> Lcoords(m_spacedim, 0.0);
     for (int i = 0; i < nOutPts; ++i)
     {
         // Obtain Element and LocalCoordinate to interpolate
         int elmtid    = -1;
         NekDouble tol = NekConstants::kNekZeroTol;
         while (elmtid < 0 && tol <= 1E3 * NekConstants::kNekZeroTol)
         {
             elmtid = m_evalField->GetExpIndex(distCoords[i], Lcoords, tol);
             tol *= 2;
         }
         if (tol > 2 * NekConstants::kNekZeroTol)
         {
             for (int j = 0; j < m_spacedim; ++j)
             {
                 if (Lcoords[j] < -1 - 0.75 * NekConstants::kNekZeroTol)
                 {
                     Lcoords[j] = -1;
                 }
                 if (Lcoords[j] > 1 + 0.75 * NekConstants::kNekZeroTol)
                 {
                     Lcoords[j] = 1;
                 }
             }
         }
 
         ASSERTL0(elmtid >= 0,
                  "no element found for (" +
                      boost::lexical_cast<string>(distCoords[i][0]) + ", " +
                      boost::lexical_cast<string>(distCoords[i][1]) + ", " +
                      boost::lexical_cast<string>(distCoords[i][2]) + ")");
 
         int offset = m_evalField->GetPhys_Offset(elmtid);
 
         for (int f = 0; f < m_nSendVars; ++f)
         {
             NekDouble value = m_evalField->GetExp(elmtid)->StdPhysEvaluate(
                 Lcoords, m_sendField[f] + offset);
 
             ASSERTL0(!(boost::math::isnan)(value), "new value is not a number");
             interpField[f][i] = value;
         }
     }
 }

◆ ExtrapolateFields()

void Nektar::SolverUtils::CouplingCwipi::ExtrapolateFields	(	Array< OneD, Array< OneD, NekDouble > > &	rVals,
		Array< OneD, int > &	notLoc
	)

private

Definition at line 959 of file CouplingCwipi.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eNearestNeighbour, Nektar::SolverUtils::Coupling::m_evalField, m_extrapInterpolator, m_nPoints, Nektar::SolverUtils::Coupling::m_nRecvVars, m_recvField, m_spacedim, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Nektar::LibUtilities::Timer::TimePerTest(), and Vmath::Zero().

Referenced by GetSendField(), and ReceiveCwipi().

 {
     LibUtilities::Timer timer1, timer2;
     timer1.Start();
 
     int totvars = 3 + m_nRecvVars;
     int nNotLoc = notLoc.num_elements();
     int nranks  = m_evalField->GetSession()->GetComm()->GetSize();
 
     Array<OneD, int> thisNLoc(1, m_nPoints - nNotLoc);
     Array<OneD, int> sizeMap(nranks);
     m_evalField->GetSession()->GetComm()->AllGather(thisNLoc, sizeMap);
 
     Array<OneD, int> offsetMap(nranks);
     offsetMap[0] = 0;
     for (int i = 1; i < nranks; ++i)
     {
         offsetMap[i] = offsetMap[i - 1] + sizeMap[i - 1];
     }
     int totNLoc = offsetMap[nranks - 1] + sizeMap[nranks - 1];
 
     Array<OneD, Array<OneD, NekDouble> > allVals(totvars);
     for (int i = 0; i < 3; ++i)
     {
         allVals[i] = Array<OneD, NekDouble>(m_nPoints);
     }
     m_recvField->GetCoords(allVals[0], allVals[1], allVals[2]);
 
     if (m_spacedim < 3)
     {
         Vmath::Zero(m_nPoints, allVals[2], 1);
     }
     if (m_spacedim < 2)
     {
         Vmath::Zero(m_nPoints, allVals[1], 1);
     }
 
     for (int i = 0; i < m_nRecvVars; ++i)
     {
         allVals[3 + i] = rVals[i];
     }
 
     Array<OneD, Array<OneD, NekDouble> > locatedVals(totvars);
     for (int i = 0; i < totvars; ++i)
     {
         locatedVals[i] = Array<OneD, NekDouble>(totNLoc, -42.0);
     }
 
     // only copy points from allVals to locatedVals that were located
     int offset = offsetMap[m_evalField->GetSession()->GetComm()->GetRank()];
     for (int i = 0, intPos = 0, locPos = 0; i < m_nPoints; ++i)
     {
         if (locPos < nNotLoc && notLoc[locPos] == i)
         {
             // do nothing
             locPos++;
         }
         else
         {
             for (int k = 0; k < totvars; ++k)
             {
                 locatedVals[k][offset + intPos] = allVals[k][i];
             }
             intPos++;
         }
     }
 
     // send all located points to all ranks. This is probably horribly expensive
     timer2.Start();
     for (int i = 0; i < totvars; ++i)
     {
         m_evalField->GetSession()->GetComm()->AllGatherv(
             locatedVals[i], sizeMap, offsetMap);
     }
     timer2.Stop();
 
     if (nNotLoc > 0)
     {
         LibUtilities::PtsFieldSharedPtr locatedPts =
             MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 3, locatedVals);
 
         Array<OneD, Array<OneD, NekDouble> > notLocVals(totvars);
         for (int j = 0; j < totvars; ++j)
         {
             notLocVals[j] = Array<OneD, NekDouble>(nNotLoc);
             for (int i = 0; i < nNotLoc; ++i)
             {
                 notLocVals[j][i] = allVals[j][notLoc[i]];
             }
         }
         LibUtilities::PtsFieldSharedPtr notlocPts =
             MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 3, notLocVals);
 
         // perform a nearest neighbour interpolation from locatedVals to the not
         // located rVals
         if (!m_extrapInterpolator)
         {
             m_extrapInterpolator =
                 MemoryManager<FieldUtils::Interpolator>::AllocateSharedPtr(
                     LibUtilities::eNearestNeighbour);
             m_extrapInterpolator->CalcWeights(locatedPts, notlocPts);
             m_extrapInterpolator->PrintStatistics();
         }
         m_extrapInterpolator->Interpolate(locatedPts, notlocPts);
 
         for (int j = 3; j < totvars; ++j)
         {
             for (int i = 0; i < nNotLoc; ++i)
             {
                 allVals[j][notLoc[i]] = notLocVals[j][i];
             }
         }
     }
 
     timer1.Stop();
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cout << "ExtrapolateFields total time: " << timer1.TimePerTest(1);
         cout << " (AllGathervI: " << timer2.TimePerTest(1) << ")" << endl;
     }
 }

◆ GetSendField()

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::CouplingCwipi::GetSendField	(	const int	i,
		const int	j
	)		const

inlineprotected

Definition at line 147 of file CouplingCwipi.h.

References AddElementsToMesh(), AnnounceMesh(), DumpRawFields(), EvaluateFields(), ExtrapolateFields(), ReadConfig(), ReceiveCwipi(), ReceiveStart(), SendComplete(), SetupReceive(), SetupSend(), and SetupSendInterpolation().

     {
         return m_sendField[i][j];
     }

◆ InterpCallback()

void Nektar::SolverUtils::CouplingCwipi::InterpCallback	(	const int	entities_dim,
		const int	n_local_vertex,
		const int	n_local_element,
		const int	n_local_polhyedra,
		const int	n_distant_point,
		const double	local_coordinates[],
		const int	local_connectivity_index[],
		const int	local_connectivity[],
		const int	local_polyhedra_face_index[],
		const int	local_polyhedra_cell_to_face_connectivity[],
		const int	local_polyhedra_face_connectivity_index[],
		const int	local_polyhedra_face_connectivity[],
		const double	distant_points_coordinates[],
		const int	distant_points_location[],
		const float	distant_points_distance[],
		const int	distant_points_barycentric_coordinates_index[],
		const double	distant_points_barycentric_coordinates[],
		const int	stride,
		const cwipi_solver_type_t	solver_type,
		const void *	local_field,
		void *	distant_field
	)

static

Definition at line 64 of file CouplingCwipi.cpp.

References ASSERTL0, and Nektar::SolverUtils::SendCallbackMap.

Referenced by create(), and SetupSend().

 {
     boost::ignore_unused(n_local_element, n_local_polyhedra, local_coordinates,
                          local_connectivity_index, local_connectivity,
                          local_polyhedra_face_index,
                          local_polyhedra_cell_to_face_connectivity,
                          local_polyhedra_face_connectivity_index,
                          local_polyhedra_face_connectivity,
                          distant_points_location,
                          distant_points_distance,
                          distant_points_barycentric_coordinates_index,
                          distant_points_barycentric_coordinates,
                          solver_type,
                          local_field);
 
     Array<OneD, Array<OneD, NekDouble> > interpField(stride);
 
     Array<OneD, Array<OneD, NekDouble> > distCoords(n_distant_point);
     for (int i = 0; i < n_distant_point; ++i)
     {
         distCoords[i] = Array<OneD, NekDouble>(3);
         for (int j = 0; j < 3; ++j)
         {
             distCoords[i][j] = distant_points_coordinates[3 * i + j];
         }
     }
 
     std::stringstream sst;
     sst << entities_dim << "," << n_local_vertex << "," << stride;
     SendCallbackMap[sst.str()](interpField, distCoords);
 
     ASSERTL0(interpField.num_elements() == stride, "size mismatch");
     ASSERTL0(interpField[0].num_elements() == n_distant_point, "size mismatch");
 
     for (int i = 0; i < n_distant_point; i++)
     {
         for (int j = 0; j < stride; ++j)
         {
             ((double *)distant_field)[i * stride + j] = interpField[j][i];
         }
     }
 }

◆ ReadConfig()

void Nektar::SolverUtils::CouplingCwipi::ReadConfig ( LibUtilities::SessionReaderSharedPtr session )

private

Definition at line 248 of file CouplingCwipi.cpp.

References ASSERTL0, Nektar::SolverUtils::Coupling::m_config, and m_filtWidth.

Referenced by GetSendField(), and v_Init().

 {
     ASSERTL0(session->DefinesElement("Nektar/Coupling"),
              "No Coupling config found");
 
     m_config["LOCALNAME"] = session->GetCmdLineArgument<std::string>("cwipi");
 
     TiXmlElement *vCoupling = session->GetElement("Nektar/Coupling");
     ASSERTL0(vCoupling, "Invalid Coupling config");
 
     m_filtWidth = boost::lexical_cast<NekDouble>(m_config["FILTERWIDTH"]);
 }

◆ ReceiveCwipi()

void Nektar::SolverUtils::CouplingCwipi::ReceiveCwipi	(	const int	step,
		const NekDouble	time,
		Array< OneD, Array< OneD, NekDouble > > &	field
	)

private

Definition at line 799 of file CouplingCwipi.cpp.

References ASSERTL1, DumpRawFields(), ExtrapolateFields(), Nektar::SolverUtils::Coupling::m_config, Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, m_filtWidth, m_lastReceive, m_nPoints, Nektar::SolverUtils::Coupling::m_nRecvVars, m_recvField, Nektar::SolverUtils::Coupling::m_recvFieldNames, m_recvHandle, Nektar::SolverUtils::Coupling::m_recvSteps, m_rValsInterl, m_spacedim, ReceiveStart(), Nektar::LibUtilities::ReduceMax, Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by GetSendField(), and v_Receive().

 {
     ASSERTL1(m_nRecvVars == field.num_elements(), "field size mismatch");
 
     if (m_nRecvVars < 1 || m_recvSteps < 1)
     {
         return;
     }
 
     if (step >= m_lastReceive + m_recvSteps)
     {
         m_lastReceive = step;
 
         if (m_evalField->GetComm()->GetRank() == 0 &&
             m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
         {
             cout << "waiting for receive at i = " << step << ", t = " << time
                  << endl;
         }
 
         LibUtilities::Timer timer1, timer2, timer3;
         timer1.Start();
 
         Array<OneD, NekDouble> tmpC(m_recvField->GetNcoeffs());
         Array<OneD, Array<OneD, NekDouble> > rVals(m_nRecvVars);
         for (int i = 0; i < m_nRecvVars; ++i)
         {
             rVals[i] = Array<OneD, NekDouble>(m_recvField->GetTotPoints());
         }
 
         timer2.Start();
         cwipi_wait_irecv(m_couplingName.c_str(), m_recvHandle);
         timer2.Stop();
 
         // set to -1 so we know we can start receiving again
         m_recvHandle = -1;
 
         int nNotLoc = cwipi_get_n_not_located_points(m_couplingName.c_str());
         Array<OneD, int> notLoc;
         if (nNotLoc != 0)
         {
             cout << "WARNING: relocating " << nNotLoc << " of " << m_nPoints
                  << " points" << endl;
 
             const int *tmp =
                 cwipi_get_not_located_points(m_couplingName.c_str());
             notLoc = Array<OneD, int>(nNotLoc);
             for (int i = 0; i < nNotLoc; ++i)
             {
                 notLoc[i] = tmp[i] - 1;
             }
 
             if (boost::to_upper_copy(m_config["NOTLOCMETHOD"]) == "KEEP")
             {
                 // interpolate from m_evalField to m_recvField
                 for (int i = 0; i < m_nRecvVars; ++i)
                 {
                     m_evalField->FwdTrans(field[i], tmpC);
                     m_recvField->BwdTrans(tmpC, rVals[i]);
                 }
             }
         }
 
         for (int i = 0, locPos = 0, intPos = 0; i < m_nPoints; ++i)
         {
             if (locPos < nNotLoc && notLoc[locPos] == i)
             {
                 // keep the original value of field[j][i]
                 locPos++;
             }
             else
             {
                 for (int j = 0; j < m_nRecvVars; ++j)
                 {
                     rVals[j][i] = m_rValsInterl[intPos * m_nRecvVars + j];
                 }
                 intPos++;
             }
         }
 
         if (boost::to_upper_copy(m_config["NOTLOCMETHOD"]) == "EXTRAPOLATE")
         {
             int doExtrapolate = 0;
             if (nNotLoc != 0)
             {
                 doExtrapolate = 1;
             }
             m_evalField->GetSession()->GetComm()->AllReduce(
                 doExtrapolate, LibUtilities::ReduceMax);
             if (doExtrapolate > 0)
             {
                 ExtrapolateFields(rVals, notLoc);
             }
         }
 
         if (m_config["DUMPRAW"] != "0")
         {
             DumpRawFields(time, rVals);
         }
 
         if (m_filtWidth > 0)
         {
             for (int i = 0; i < m_nRecvVars; ++i)
             {
                 timer3.Start();
 
                 Array<OneD, NekDouble> forcing(m_nPoints);
 
                 Array<OneD, Array<OneD, NekDouble> > Velocity(m_spacedim);
                 for (int j = 0; j < m_spacedim; ++j)
                 {
                     Velocity[j] = Array<OneD, NekDouble>(m_nPoints, 0.0);
                 }
 
                 Vmath::Smul(m_nPoints, -m_filtWidth, rVals[i], 1, forcing, 1);
 
                 // Note we are using the
                 // LinearAdvectionDiffusionReaction solver here
                 // instead of HelmSolve since m_filtWidth is negative and
                 // so matrices are not positive definite. Ideally
                 // should allow for negative m_filtWidth coefficient in
                 // HelmSolve
                 m_recvField->LinearAdvectionDiffusionReactionSolve(
                     Velocity, forcing, tmpC, -m_filtWidth);
 
                 m_evalField->BwdTrans(tmpC, field[i]);
                 timer3.Stop();
 
                 if (m_evalField->GetComm()->GetRank() == 0 &&
                     m_evalField->GetSession()->DefinesCmdLineArgument(
                         "verbose"))
                 {
                     cout << "Smoother time (" << m_recvFieldNames[i]
                          << "): " << timer3.TimePerTest(1) << endl;
                 }
             }
         }
         else
         {
             for (int i = 0; i < m_nRecvVars; ++i)
             {
                 m_recvField->FwdTrans(rVals[i], tmpC);
                 m_evalField->BwdTrans(tmpC, field[i]);
             }
         }
         timer1.Stop();
 
         if (m_evalField->GetComm()->GetRank() == 0 &&
             m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
         {
             cout << "Receive total time: " << timer1.TimePerTest(1) << ", ";
             cout << "Receive waiting time: " << timer2.TimePerTest(1) << endl;
         }
 
         ReceiveStart();
     }
 }

◆ ReceiveStart()

void Nektar::SolverUtils::CouplingCwipi::ReceiveStart ( )

private

Definition at line 709 of file CouplingCwipi.cpp.

References Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, Nektar::SolverUtils::Coupling::m_nRecvVars, m_recvHandle, m_recvTag, m_rValsInterl, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by GetSendField(), ReceiveCwipi(), and v_Init().

 {
     if (m_recvHandle >= 0)
     {
         return;
     }
 
     LibUtilities::Timer timer1;
     timer1.Start();
     // workaround a bug in cwipi: receiving_field_name should be const char* but
     // is char*
     char recFN[10];
     strcpy(recFN, "dummyName");
 
     cwipi_irecv(m_couplingName.c_str(),
                 "ex1",
                 m_recvTag,
                 m_nRecvVars,
                 0,
                 0.0,
                 recFN,
                 m_rValsInterl,
                 &m_recvHandle);
     timer1.Stop();
 
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cout << "Receive start time: " << timer1.TimePerTest(1) << endl;
     }
 }

◆ SendCallback()

void Nektar::SolverUtils::CouplingCwipi::SendCallback	(	Array< OneD, Array< OneD, NekDouble > > &	interpField,
		Array< OneD, Array< OneD, NekDouble > > &	distCoords
	)

Definition at line 597 of file CouplingCwipi.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, EvaluateFields(), Nektar::SolverUtils::Coupling::m_config, Nektar::SolverUtils::Coupling::m_nSendVars, m_sendField, m_sendInterpolator, and SetupSendInterpolation().

Referenced by create(), and SetupSend().

 {
     ASSERTL0(interpField.num_elements() == m_nSendVars, "size mismatch");
 
     for (int i = 0; i < m_nSendVars; ++i)
     {
         interpField[i] = Array<OneD, NekDouble>(distCoords.num_elements());
     }
 
     if (boost::to_upper_copy(m_config["SENDMETHOD"]) == "NEARESTNEIGHBOUR" ||
         boost::to_upper_copy(m_config["SENDMETHOD"]) == "SHEPARD")
     {
         if (!m_sendInterpolator)
         {
             SetupSendInterpolation();
         }
 
         LibUtilities::PtsFieldSharedPtr ptsIn =
             MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 0, m_sendField);
         LibUtilities::PtsFieldSharedPtr ptsOut =
             MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 0, interpField);
         m_sendInterpolator->Interpolate(ptsIn, ptsOut);
     }
     else
     {
         EvaluateFields(interpField, distCoords);
     }
 }

◆ SendComplete()

void Nektar::SolverUtils::CouplingCwipi::SendComplete ( )

private

Definition at line 687 of file CouplingCwipi.cpp.

References Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, m_sendHandle, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by GetSendField(), and v_Send().

 {
     if (m_sendHandle < 0)
     {
         return;
     }
 
     LibUtilities::Timer timer1;
     timer1.Start();
     cwipi_wait_issend(m_couplingName.c_str(), m_sendHandle);
     timer1.Stop();
 
     // set to -1 so we dont try finishing a send before a new one was started
     m_sendHandle = -1;
 
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cout << "Send waiting time: " << timer1.TimePerTest(1) << endl;
     }
 }

◆ SetupReceive()

void Nektar::SolverUtils::CouplingCwipi::SetupReceive ( )

private

Definition at line 261 of file CouplingCwipi.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::SolverUtils::Coupling::m_config, Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, m_newFields, m_nPoints, Nektar::SolverUtils::Coupling::m_nRecvVars, m_oldFields, m_points, m_recvField, m_rValsInterl, m_spacedim, and Nektar::SpatialDomains::MeshGraph::Read().

Referenced by GetSendField(), and v_Init().

 {
     int oversamp = boost::lexical_cast<int>(m_config["OVERSAMPLE"]);
 
     SpatialDomains::MeshGraphSharedPtr recvGraph =
         SpatialDomains::MeshGraph::Read(m_evalField->GetSession());
     recvGraph->SetExpansionsToPointOrder(
         oversamp + m_evalField->GetExp(0)->GetNumPoints(0));
 
     // TODO: DeclareCoeffPhysArrays
     switch (m_spacedim)
     {
         case 1:
         {
             m_recvField =
                 MemoryManager<MultiRegions::ContField1D>::AllocateSharedPtr(
                     m_evalField->GetSession(), recvGraph, "DefaultVar");
             break;
         }
 
         case 2:
         {
 
             m_recvField =
                 MemoryManager<MultiRegions::ContField2D>::AllocateSharedPtr(
                     m_evalField->GetSession(), recvGraph);
             break;
         }
 
         case 3:
         {
 
             m_recvField =
                 MemoryManager<MultiRegions::ContField3D>::AllocateSharedPtr(
                     m_evalField->GetSession(), recvGraph);
             break;
         }
 
         default:
         {
             ASSERTL0(false, "Expansion dimension not recognised");
             break;
         }
     }
 
     m_oldFields = Array<OneD, Array<OneD, NekDouble> >(m_nRecvVars);
     m_newFields = Array<OneD, Array<OneD, NekDouble> >(m_nRecvVars);
     for (int i = 0; i < m_nRecvVars; ++i)
     {
         m_oldFields[i] = Array<OneD, NekDouble>(m_evalField->GetTotPoints());
         m_newFields[i] = Array<OneD, NekDouble>(m_evalField->GetTotPoints());
     }
 
     // define the quadrature points at which we want to receive data
     m_nPoints = m_recvField->GetTotPoints();
     Array<OneD, Array<OneD, NekDouble> > coords(3);
     coords[0] = Array<OneD, NekDouble>(m_nPoints);
     coords[1] = Array<OneD, NekDouble>(m_nPoints);
     coords[2] = Array<OneD, NekDouble>(m_nPoints);
     m_recvField->GetCoords(coords[0], coords[1], coords[2]);
 
     m_points = (double *)malloc(sizeof(double) * 3 * m_nPoints);
     ASSERTL1(m_points != NULL, "malloc failed for m_points");
 
     for (int i = 0; i < m_nPoints; ++i)
     {
         m_points[3 * i + 0] = double(coords[0][i]);
 
         if (m_spacedim > 1)
         {
             m_points[3 * i + 1] = double(coords[1][i]);
         }
         else
         {
             m_points[3 * i + 1] = 0.0;
         }
 
         if (m_spacedim > 2)
         {
             m_points[3 * i + 2] = double(coords[2][i]);
         }
         else
         {
             m_points[3 * i + 2] = 0.0;
         }
     }
 
     cwipi_set_points_to_locate(m_couplingName.c_str(), m_nPoints, m_points);
 
     m_rValsInterl = (double *)malloc(sizeof(double) * m_nPoints * m_nRecvVars);
     ASSERTL1(m_rValsInterl != NULL, "malloc failed for m_rValsInterl");
 }

◆ SetupSend()

void Nektar::SolverUtils::CouplingCwipi::SetupSend ( )

private

Definition at line 354 of file CouplingCwipi.cpp.

References ASSERTL1, InterpCallback(), Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, Nektar::SolverUtils::Coupling::m_nSendVars, m_spacedim, m_sValsInterl, SendCallback(), and Nektar::SolverUtils::SendCallbackMap.

Referenced by GetSendField(), and v_Init().

 {
     // this array is never used because of our send callback method
     m_sValsInterl = (double *)malloc(
         sizeof(double) * m_evalField->GetGraph()->GetNvertices() * m_nSendVars);
     ASSERTL1(m_sValsInterl != NULL, "malloc failed for m_sValsInterl");
     for (int i = 0; i < m_evalField->GetGraph()->GetNvertices() * m_nSendVars;
          ++i)
     {
         m_sValsInterl[i] = i;
     }
 
     // register this coupling as sender
     std::stringstream sst;
     sst << m_spacedim << "," << m_evalField->GetGraph()->GetNvertices() << ","
         << m_nSendVars;
     SendCallbackMap[sst.str()] = std::bind(&CouplingCwipi::SendCallback,
                                            this,
                                            std::placeholders::_1,
                                            std::placeholders::_2);
     cwipi_set_interpolation_function(m_couplingName.c_str(),
                                      CouplingCwipi::InterpCallback);
 }

◆ SetupSendInterpolation()

void Nektar::SolverUtils::CouplingCwipi::SetupSendInterpolation ( )

private

Definition at line 429 of file CouplingCwipi.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eNearestNeighbour, Nektar::LibUtilities::eShepard, Nektar::SolverUtils::Coupling::m_config, Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, and m_sendInterpolator.

Referenced by GetSendField(), and SendCallback().

 {
     const double *distCoords =
         cwipi_get_distant_coordinates(m_couplingName.c_str());
     int nPts = cwipi_get_n_distant_points(m_couplingName.c_str());
 
     Array<OneD, Array<OneD, NekDouble> > local(3);
     for (int i = 0; i < 3; ++i)
     {
         local[i] = Array<OneD, NekDouble>(m_evalField->GetTotPoints(), 0.0);
     }
     m_evalField->GetCoords(local[0], local[1], local[2]);
     LibUtilities::PtsFieldSharedPtr locatPts =
         MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(3, local);
 
     Array<OneD, Array<OneD, NekDouble> > dist(3);
     for (int i = 0; i < 3; ++i)
     {
         dist[i] = Array<OneD, NekDouble>(nPts);
         for (int j = 0; j < nPts; ++j)
         {
             dist[i][j] = distCoords[3 * j + i];
         }
     }
     LibUtilities::PtsFieldSharedPtr distPts =
         MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(3, dist);
 
     LibUtilities::InterpMethod method = LibUtilities::eNearestNeighbour;
     if (boost::to_upper_copy(m_config["SENDMETHOD"]) == "SHEPARD")
     {
         method = LibUtilities::eShepard;
     }
     m_sendInterpolator =
         MemoryManager<FieldUtils::Interpolator>::AllocateSharedPtr(method);
     m_sendInterpolator->CalcWeights(locatPts, distPts);
     m_sendInterpolator->PrintStatistics();
 }

◆ v_Finalize()

void Nektar::SolverUtils::CouplingCwipi::v_Finalize ( void )

protectedvirtual

Reimplemented from Nektar::SolverUtils::Coupling.

Definition at line 547 of file CouplingCwipi.cpp.

References Nektar::SolverUtils::Coupling::m_couplingName.

 {
     cwipi_delete_coupling(m_couplingName.c_str());
 }

◆ v_Init()

void Nektar::SolverUtils::CouplingCwipi::v_Init ( )

protectedvirtual

Reimplemented from Nektar::SolverUtils::Coupling.

Definition at line 144 of file CouplingCwipi.cpp.

 {
     Coupling::v_Init();
 
     ReadConfig(m_evalField->GetSession());
 
     cwipi_add_local_int_control_parameter("nSendVars", m_nSendVars);
     cwipi_add_local_int_control_parameter("nRecvVars", m_nRecvVars);
     cwipi_add_local_string_control_parameter(
         "recvFieldNames", m_config["RECEIVEVARIABLES"].c_str());
     cwipi_add_local_string_control_parameter("sendFieldNames",
                                              m_config["SENDVARIABLES"].c_str());
 
     // MPI_TAG_UB is guaranteed to be at least 32767, so we make
     // sure m_recvTag < 32767. Only caveat: m_recvTag is not guaranteed to be
     // unique.
     m_recvTag = boost::hash<std::string>()(m_couplingName +
                     m_config["REMOTENAME"] + m_config["LOCALNAME"]) % 32767;
 
     cwipi_add_local_int_control_parameter("receiveTag", m_recvTag);
 
     m_spacedim = m_evalField->GetGraph()->GetSpaceDimension();
 
     if (m_filtWidth > 0)
     {
         m_filtWidth = 2 * M_PI / m_filtWidth;
         m_filtWidth = m_filtWidth * m_filtWidth;
     }
 
     //  Init Coupling
     cwipi_solver_type_t solver_type = CWIPI_SOLVER_CELL_VERTEX;
     NekDouble geom_tol = boost::lexical_cast<NekDouble>(m_config["GEOMTOL"]);
     cwipi_create_coupling(m_couplingName.c_str(),
                           CWIPI_COUPLING_PARALLEL_WITH_PARTITIONING,
                           m_config["REMOTENAME"].c_str(),
                           m_spacedim,
                           geom_tol,
                           CWIPI_STATIC_MESH,
                           solver_type,
                           OUTPUT_FREQ,
                           "Ensight Gold",
                           "text");
     cwipi_synchronize_control_parameter(m_config["REMOTENAME"].c_str());
 
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cwipi_dump_application_properties();
     }
 
     m_sendTag = cwipi_get_distant_int_control_parameter(
         m_config["REMOTENAME"].c_str(), "receiveTag");
 
     if (cwipi_has_int_parameter(m_config["REMOTENAME"].c_str(), "nRecvVars"))
     {
         int remoteNRecvVars = cwipi_get_distant_int_control_parameter(
             m_config["REMOTENAME"].c_str(), "nRecvVars");
         ASSERTL0(remoteNRecvVars == m_nSendVars,
                  "Number of local send vars different to remote received vars");
     }
 
     if (cwipi_has_int_parameter(m_config["REMOTENAME"].c_str(), "nSendVars"))
     {
         int remoteNSendVars = cwipi_get_distant_int_control_parameter(
             m_config["REMOTENAME"].c_str(), "nSendVars");
         ASSERTL0(remoteNSendVars == m_nRecvVars,
                  "Number of local receive vars different to remote sent vars");
     }
 
     AnnounceMesh();
 
     if (m_nRecvVars > 0 && m_recvSteps > 0)
     {
         SetupReceive();
     }
 
     if (m_evalField->GetComm()->GetRank() == 0 &&
         m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
     {
         cout << "locating..." << endl;
     }
     cwipi_locate(m_couplingName.c_str());
 
     if (m_nSendVars > 0 && m_sendSteps > 0)
     {
         SetupSend();
     }
 
     if (m_nRecvVars > 0 && m_recvSteps > 0)
     {
         ReceiveStart();
     }
 }

◆ v_Receive()

void Nektar::SolverUtils::CouplingCwipi::v_Receive	(	const int	step,
		const NekDouble	time,
		Array< OneD, Array< OneD, NekDouble > > &	field,
		std::vector< std::string > &	varNames
	)

protectedvirtual

Implements Nektar::SolverUtils::Coupling.

Definition at line 741 of file CouplingCwipi.cpp.

References ASSERTL1, Nektar::SolverUtils::Coupling::GenerateVariableMapping(), Nektar::SolverUtils::Coupling::m_evalField, m_lastReceive, m_newFields, Nektar::SolverUtils::Coupling::m_nRecvVars, m_oldFields, Nektar::SolverUtils::Coupling::m_recvFieldNames, Nektar::SolverUtils::Coupling::m_recvSteps, ReceiveCwipi(), Vmath::Svtsvtp(), and Vmath::Vcopy().

 {
     if (m_nRecvVars < 1 || m_recvSteps < 1)
     {
         return;
     }
 
     Array<OneD, Array<OneD, NekDouble> > recvFields(m_nRecvVars);
     vector<int> recvVarsToVars =
         GenerateVariableMapping(varNames, m_recvFieldNames);
     ASSERTL1(m_nRecvVars == recvVarsToVars.size(), "field size mismatch");
     for (int i = 0; i < recvVarsToVars.size(); ++i)
     {
         recvFields[i] = field[recvVarsToVars[i]];
     }
 
     int nq = m_evalField->GetTotPoints();
 
     // make sure we have sensible data in old/new recvFields the first time this
     // method is called
     if (m_lastReceive < 0)
     {
         for (int i = 0; i < m_nRecvVars; ++i)
         {
             Vmath::Vcopy(nq, recvFields[i], 1, m_oldFields[i], 1);
             Vmath::Vcopy(nq, recvFields[i], 1, m_newFields[i], 1);
         }
     }
 
     if (step >= m_lastReceive + m_recvSteps)
     {
         for (int i = 0; i < m_nRecvVars; ++i)
         {
             Vmath::Vcopy(nq, m_newFields[i], 1, m_oldFields[i], 1);
         }
 
         ReceiveCwipi(step, time, m_newFields);
     }
 
     NekDouble fact =
         NekDouble(step - m_lastReceive + 1) / NekDouble(m_recvSteps);
     for (int i = 0; i < m_nRecvVars; ++i)
     {
         Vmath::Svtsvtp(nq,
                        fact,
                        m_newFields[i],
                        1,
                        (1 - fact),
                        m_oldFields[i],
                        1,
                        recvFields[i],
                        1);
     }
 }

◆ v_Send()

void Nektar::SolverUtils::CouplingCwipi::v_Send	(	const int	step,
		const NekDouble	time,
		const Array< OneD, const Array< OneD, NekDouble > > &	field,
		std::vector< std::string > &	varNames
	)

protectedvirtual

Implements Nektar::SolverUtils::Coupling.

Definition at line 630 of file CouplingCwipi.cpp.

References Nektar::SolverUtils::Coupling::GenerateVariableMapping(), Nektar::SolverUtils::Coupling::m_couplingName, Nektar::SolverUtils::Coupling::m_evalField, m_lastSend, Nektar::SolverUtils::Coupling::m_nSendVars, m_sendField, Nektar::SolverUtils::Coupling::m_sendFieldNames, m_sendHandle, Nektar::SolverUtils::Coupling::m_sendSteps, m_sendTag, m_sValsInterl, SendComplete(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

 {
     if (m_nSendVars < 1 || m_sendSteps < 1)
     {
         return;
     }
 
     if (step >= m_lastSend + m_sendSteps)
     {
         SendComplete();
 
         m_lastSend = step;
 
         vector<int> sendVarsToVars =
             GenerateVariableMapping(varNames, m_sendFieldNames);
         m_sendField = Array<OneD, Array<OneD, NekDouble> >(m_nSendVars);
         for (int i = 0; i < sendVarsToVars.size(); ++i)
         {
             m_sendField[i] = field[sendVarsToVars[i]];
         }
 
         if (m_evalField->GetComm()->GetRank() == 0 &&
             m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
         {
             cout << "sending fields at i = " << step << ", t = " << time
                  << endl;
         }
 
         LibUtilities::Timer timer1;
         timer1.Start();
 
         char sendFN[10];
         strcpy(sendFN, "dummyName");
 
         cwipi_issend(m_couplingName.c_str(),
                      "ex1",
                      m_sendTag,
                      m_nSendVars,
                      step,
                      time,
                      sendFN,
                      m_sValsInterl,
                      &m_sendHandle);
         timer1.Stop();
 
         if (m_evalField->GetComm()->GetRank() == 0 &&
             m_evalField->GetSession()->DefinesCmdLineArgument("verbose"))
         {
             cout << "Send total time: " << timer1.TimePerTest(1) << endl;
         }
     }
 }

Member Data Documentation

◆ className

std::string Nektar::SolverUtils::CouplingCwipi::className

static

Initial value:

=
    GetCouplingFactory().RegisterCreatorFunction(
        "Cwipi", CouplingCwipi::create, "Cwipi Coupling")

Definition at line 55 of file CouplingCwipi.h.

◆ m_connec

int* Nektar::SolverUtils::CouplingCwipi::m_connec

protected

Definition at line 121 of file CouplingCwipi.h.

Referenced by AddElementsToMesh(), AnnounceMesh(), and ~CouplingCwipi().

◆ m_connecIdx

int* Nektar::SolverUtils::CouplingCwipi::m_connecIdx

protected

Definition at line 120 of file CouplingCwipi.h.

Referenced by AddElementsToMesh(), AnnounceMesh(), and ~CouplingCwipi().

◆ m_coords

double* Nektar::SolverUtils::CouplingCwipi::m_coords

protected

Definition at line 119 of file CouplingCwipi.h.

Referenced by AddElementsToMesh(), AnnounceMesh(), and ~CouplingCwipi().

◆ m_extrapInterpolator

FieldUtils::InterpolatorSharedPtr Nektar::SolverUtils::CouplingCwipi::m_extrapInterpolator

protected

Definition at line 129 of file CouplingCwipi.h.

Referenced by ExtrapolateFields().

◆ m_filtWidth

NekDouble Nektar::SolverUtils::CouplingCwipi::m_filtWidth

protected

Definition at line 98 of file CouplingCwipi.h.

Referenced by ReadConfig(), ReceiveCwipi(), and v_Init().

◆ m_lastReceive

int Nektar::SolverUtils::CouplingCwipi::m_lastReceive

protected

Definition at line 114 of file CouplingCwipi.h.

Referenced by ReceiveCwipi(), and v_Receive().

◆ m_lastSend

int Nektar::SolverUtils::CouplingCwipi::m_lastSend

protected

Definition at line 113 of file CouplingCwipi.h.

Referenced by v_Send().

◆ m_newFields

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::CouplingCwipi::m_newFields

protected

Definition at line 105 of file CouplingCwipi.h.

Referenced by SetupReceive(), and v_Receive().

◆ m_nPoints

int Nektar::SolverUtils::CouplingCwipi::m_nPoints

protected

Definition at line 117 of file CouplingCwipi.h.

Referenced by ExtrapolateFields(), ReceiveCwipi(), and SetupReceive().

◆ m_oldFields

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::CouplingCwipi::m_oldFields

protected

Definition at line 104 of file CouplingCwipi.h.

Referenced by SetupReceive(), and v_Receive().

◆ m_points

double* Nektar::SolverUtils::CouplingCwipi::m_points

protected

Definition at line 118 of file CouplingCwipi.h.

Referenced by SetupReceive(), and ~CouplingCwipi().

◆ m_recvField

MultiRegions::ExpListSharedPtr Nektar::SolverUtils::CouplingCwipi::m_recvField

protected

Definition at line 102 of file CouplingCwipi.h.

Referenced by DumpRawFields(), ExtrapolateFields(), ReceiveCwipi(), and SetupReceive().

◆ m_recvHandle

int Nektar::SolverUtils::CouplingCwipi::m_recvHandle

protected

Definition at line 108 of file CouplingCwipi.h.

Referenced by ReceiveCwipi(), and ReceiveStart().

◆ m_recvTag

int Nektar::SolverUtils::CouplingCwipi::m_recvTag

protected

Definition at line 111 of file CouplingCwipi.h.

Referenced by ReceiveStart(), and v_Init().

◆ m_rValsInterl

double* Nektar::SolverUtils::CouplingCwipi::m_rValsInterl

protected

Definition at line 122 of file CouplingCwipi.h.

Referenced by ReceiveCwipi(), ReceiveStart(), SetupReceive(), and ~CouplingCwipi().

◆ m_sendField

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::CouplingCwipi::m_sendField

protected

Definition at line 100 of file CouplingCwipi.h.

Referenced by EvaluateFields(), SendCallback(), and v_Send().

◆ m_sendHandle

int Nektar::SolverUtils::CouplingCwipi::m_sendHandle

protected

Definition at line 107 of file CouplingCwipi.h.

Referenced by SendComplete(), and v_Send().

◆ m_sendInterpolator

FieldUtils::InterpolatorSharedPtr Nektar::SolverUtils::CouplingCwipi::m_sendInterpolator

protected

Definition at line 127 of file CouplingCwipi.h.

Referenced by SendCallback(), and SetupSendInterpolation().

◆ m_sendTag

int Nektar::SolverUtils::CouplingCwipi::m_sendTag

protected

Definition at line 110 of file CouplingCwipi.h.

Referenced by v_Init(), and v_Send().

◆ m_spacedim

int Nektar::SolverUtils::CouplingCwipi::m_spacedim

protected

Definition at line 116 of file CouplingCwipi.h.

Referenced by AnnounceMesh(), DumpRawFields(), EvaluateFields(), ExtrapolateFields(), ReceiveCwipi(), SetupReceive(), SetupSend(), and v_Init().

◆ m_sValsInterl

double* Nektar::SolverUtils::CouplingCwipi::m_sValsInterl

protected

Definition at line 123 of file CouplingCwipi.h.

Referenced by SetupSend(), v_Send(), and ~CouplingCwipi().

◆ m_vertMap

std::map<int, int> Nektar::SolverUtils::CouplingCwipi::m_vertMap

protected

Definition at line 125 of file CouplingCwipi.h.

Referenced by AddElementsToMesh().

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CouplingCwipi()

◆ ~CouplingCwipi()

Member Function Documentation

◆ AddElementsToMesh()

◆ AnnounceMesh()

◆ create()

◆ DumpRawFields()

◆ EvaluateFields()

◆ ExtrapolateFields()

◆ GetSendField()

◆ InterpCallback()

◆ ReadConfig()

◆ ReceiveCwipi()

◆ ReceiveStart()

◆ SendCallback()

◆ SendComplete()

◆ SetupReceive()

◆ SetupSend()

◆ SetupSendInterpolation()

◆ v_Finalize()

◆ v_Init()

◆ v_Receive()

◆ v_Send()

Member Data Documentation

◆ className

◆ m_connec

◆ m_connecIdx

◆ m_coords

◆ m_extrapInterpolator

◆ m_filtWidth

◆ m_lastReceive

◆ m_lastSend

◆ m_newFields

◆ m_nPoints

◆ m_oldFields

◆ m_points

◆ m_recvField

◆ m_recvHandle

◆ m_recvTag

◆ m_rValsInterl

◆ m_sendField

◆ m_sendHandle

◆ m_sendInterpolator

◆ m_sendTag

◆ m_spacedim

◆ m_sValsInterl

◆ m_vertMap