#include <CouplingCwipi.h>

Inheritance diagram for Nektar::SolverUtils::CouplingCwipi:

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

SOLVER_UTILS_EXPORT	~CouplingCwipi () override

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
SOLVER_UTILS_EXPORT void	v_Init () override

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) override

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

SOLVER_UTILS_EXPORT void	v_Finalize () override

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)

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)=0

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

virtual SOLVER_UTILS_EXPORT void	v_Finalize ()

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

std::shared_ptr< FieldUtils::Interpolator< std::vector< MultiRegions::ExpListSharedPtr > > >	m_sendInterpolator

std::shared_ptr< FieldUtils::Interpolator< std::vector< MultiRegions::ExpListSharedPtr > > >	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 49 of file CouplingCwipi.h.

Constructor & Destructor Documentation

◆ CouplingCwipi()

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

Definition at line 107 of file CouplingCwipi.cpp.

    : Coupling(field), m_sendHandle(-1), m_recvHandle(-1), m_lastSend(-1E6),
      m_lastReceive(-1E6), m_points(nullptr), m_coords(nullptr),
      m_connecIdx(nullptr), m_connec(nullptr), m_rValsInterl(nullptr),
      m_sValsInterl(nullptr)
{
    // 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";
}

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

◆ ~CouplingCwipi()

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

override

Definition at line 214 of file CouplingCwipi.cpp.

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

References m_connec, m_connecIdx, m_coords, m_points, m_rValsInterl, and 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 496 of file CouplingCwipi.cpp.

{
    // 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++;
    }
}

References m_connec, m_connecIdx, m_coords, and m_vertMap.

Referenced by AnnounceMesh().

◆ AnnounceMesh()

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

private

Definition at line 410 of file CouplingCwipi.cpp.

{
    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 != nullptr, "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 != nullptr, "malloc failed for m_connec");
    m_connecIdx = (int *)malloc(sizeof(int) * (nElts + 1));
    ASSERTL1(m_connecIdx != nullptr, "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);
}

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

Referenced by v_Init().

◆ create()

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

inlinestatic

Creates an instance of this class.

Definition at line 56 of file CouplingCwipi.h.

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

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::SolverUtils::CouplingSharedPtr, FilterPython_Function::field, and CellMLToNektar.cellml_metadata::p.

◆ DumpRawFields()

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

private

Definition at line 1020 of file CouplingCwipi.cpp.

{
    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;
    }
}

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(), Nektar::LibUtilities::Timer::TimePerTest(), and Nektar::LibUtilities::CsvIO::Write().

Referenced by ReceiveCwipi().

◆ EvaluateFields()

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

private

Definition at line 321 of file CouplingCwipi.cpp.

{
    int nOutPts = distCoords.size();
 
    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;
        }
    }
}

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

Referenced by SendCallback().

◆ ExtrapolateFields()

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

private

Definition at line 894 of file CouplingCwipi.cpp.

{
    LibUtilities::Timer timer1, timer2;
    timer1.Start();
 
    int totvars = 3 + m_nRecvVars;
    int nNotLoc = notLoc.size();
    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<
                std::vector<MultiRegions::ExpListSharedPtr>>>::
                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;
    }
}

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 ReceiveCwipi().

◆ GetSendField()

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

inlineprotected

Definition at line 141 of file CouplingCwipi.h.

    {
        return m_sendField[i][j];
    }

References m_sendField.

◆ 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 60 of file CouplingCwipi.cpp.

{
    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.size() == stride, "size mismatch");
    ASSERTL0(interpField[0].size() == 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];
        }
    }
}

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

Referenced by SetupSend().

◆ ReadConfig()

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

private

Definition at line 224 of file CouplingCwipi.cpp.

{
    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 = std::stod(m_config["FILTERWIDTH"]);
}

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

Referenced by v_Init().

◆ ReceiveCwipi()

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

private

Definition at line 717 of file CouplingCwipi.cpp.

{
    ASSERTL1(m_nRecvVars == field.size(), "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);
 
                StdRegions::ConstFactorMap factors;
                StdRegions::VarCoeffMap varcoeffs;
                MultiRegions::VarFactorsMap varfactors =
                    MultiRegions::NullVarFactorsMap;
 
                factors[StdRegions::eFactorLambda] = -m_filtWidth;
 
                // Set advection velocities
                StdRegions::VarCoeffType varcoefftypes[] = {
                    StdRegions::eVarCoeffVelX, StdRegions::eVarCoeffVelY,
                    StdRegions::eVarCoeffVelZ};
                for (int j = 0; j < m_spacedim; j++)
                {
                    varcoeffs[varcoefftypes[j]] = Velocity[j];
                }
 
                // 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_recvField->LinearAdvectionDiffusionReactionSolve(
                    forcing, tmpC, factors, varcoeffs, varfactors);
 
                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();
    }
}

References ASSERTL1, DumpRawFields(), Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eVarCoeffVelX, Nektar::StdRegions::eVarCoeffVelY, Nektar::StdRegions::eVarCoeffVelZ, ExtrapolateFields(), Nektar::VarcoeffHashingTest::factors, FilterPython_Function::field, 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, Nektar::MultiRegions::NullVarFactorsMap, ReceiveStart(), Nektar::LibUtilities::ReduceMax, Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by v_Receive().

◆ ReceiveStart()

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

private

Definition at line 642 of file CouplingCwipi.cpp.

{
    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;
    }
}

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 ReceiveCwipi(), and v_Init().

◆ SendCallback()

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

Definition at line 538 of file CouplingCwipi.cpp.

{
    ASSERTL0(interpField.size() == m_nSendVars, "size mismatch");
 
    for (int i = 0; i < m_nSendVars; ++i)
    {
        interpField[i] = Array<OneD, NekDouble>(distCoords.size());
    }
 
    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);
    }
}

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 SetupSend().

◆ SendComplete()

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

private

Definition at line 620 of file CouplingCwipi.cpp.

{
    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;
    }
}

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 v_Send().

◆ SetupReceive()

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

private

Definition at line 237 of file CouplingCwipi.cpp.

{
    int oversamp = boost::lexical_cast<int>(m_config["OVERSAMPLE"]);
 
    SpatialDomains::MeshGraphSharedPtr recvGraph =
        SpatialDomains::MeshGraphIO::Read(m_evalField->GetSession());
    recvGraph->SetExpansionInfoToPointOrder(
        oversamp + m_evalField->GetExp(0)->GetNumPoints(0));
 
    // TODO: DeclareCoeffPhysArrays
    m_recvField = MemoryManager<MultiRegions::ContField>::AllocateSharedPtr(
        m_evalField->GetSession(), recvGraph, "DefaultVar");
 
    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 != nullptr, "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 != nullptr, "malloc failed for m_rValsInterl");
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), 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::MeshGraphIO::Read().

Referenced by v_Init().

◆ SetupSend()

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

private

Definition at line 298 of file CouplingCwipi.cpp.

{
    // 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 != nullptr, "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);
}

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 v_Init().

◆ SetupSendInterpolation()

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

private

Definition at line 372 of file CouplingCwipi.cpp.

{
    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<std::vector<
        MultiRegions::ExpListSharedPtr>>>::AllocateSharedPtr(method);
    m_sendInterpolator->CalcWeights(locatPts, distPts);
    m_sendInterpolator->PrintStatistics();
}

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 SendCallback().

◆ v_Finalize()

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

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::Coupling.

Definition at line 490 of file CouplingCwipi.cpp.

{
    cwipi_delete_coupling(m_couplingName.c_str());
}

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

◆ v_Init()

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

overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::Coupling.

Definition at line 124 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              = std::stod(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
	)

overrideprotectedvirtual

Implements Nektar::SolverUtils::Coupling.

Definition at line 667 of file CouplingCwipi.cpp.

{
    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);
    }
}

References ASSERTL1, FilterPython_Function::field, 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().

◆ 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
	)

overrideprotectedvirtual

Implements Nektar::SolverUtils::Coupling.

Definition at line 571 of file CouplingCwipi.cpp.

{
    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;
        }
    }
}

References FilterPython_Function::field, 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().

Member Data Documentation

◆ className

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

static

Initial value:

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

Definition at line 53 of file CouplingCwipi.h.

◆ m_connec

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

protected

Definition at line 113 of file CouplingCwipi.h.

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

◆ m_connecIdx

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

protected

Definition at line 112 of file CouplingCwipi.h.

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

◆ m_coords

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

protected

Definition at line 111 of file CouplingCwipi.h.

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

◆ m_extrapInterpolator

std::shared_ptr< FieldUtils::Interpolator<std::vector<MultiRegions::ExpListSharedPtr> > > Nektar::SolverUtils::CouplingCwipi::m_extrapInterpolator

protected

Definition at line 125 of file CouplingCwipi.h.

Referenced by ExtrapolateFields().

◆ m_filtWidth

NekDouble Nektar::SolverUtils::CouplingCwipi::m_filtWidth

protected

Definition at line 90 of file CouplingCwipi.h.

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

◆ m_lastReceive

int Nektar::SolverUtils::CouplingCwipi::m_lastReceive

protected

Definition at line 106 of file CouplingCwipi.h.

Referenced by ReceiveCwipi(), and v_Receive().

◆ m_lastSend

int Nektar::SolverUtils::CouplingCwipi::m_lastSend

protected

Definition at line 105 of file CouplingCwipi.h.

Referenced by v_Send().

◆ m_newFields

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

protected

Definition at line 97 of file CouplingCwipi.h.

Referenced by SetupReceive(), and v_Receive().

◆ m_nPoints

int Nektar::SolverUtils::CouplingCwipi::m_nPoints

protected

Definition at line 109 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 96 of file CouplingCwipi.h.

Referenced by SetupReceive(), and v_Receive().

◆ m_points

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

protected

Definition at line 110 of file CouplingCwipi.h.

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

◆ m_recvField

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

protected

Definition at line 94 of file CouplingCwipi.h.

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

◆ m_recvHandle

int Nektar::SolverUtils::CouplingCwipi::m_recvHandle

protected

Definition at line 100 of file CouplingCwipi.h.

Referenced by ReceiveCwipi(), and ReceiveStart().

◆ m_recvTag

int Nektar::SolverUtils::CouplingCwipi::m_recvTag

protected

Definition at line 103 of file CouplingCwipi.h.

Referenced by ReceiveStart(), and v_Init().

◆ m_rValsInterl

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

protected

Definition at line 114 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 92 of file CouplingCwipi.h.

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

◆ m_sendHandle

int Nektar::SolverUtils::CouplingCwipi::m_sendHandle

protected

Definition at line 99 of file CouplingCwipi.h.

Referenced by SendComplete(), and v_Send().

◆ m_sendInterpolator

std::shared_ptr< FieldUtils::Interpolator<std::vector<MultiRegions::ExpListSharedPtr> > > Nektar::SolverUtils::CouplingCwipi::m_sendInterpolator

protected

Definition at line 121 of file CouplingCwipi.h.

Referenced by SendCallback(), and SetupSendInterpolation().

◆ m_sendTag

int Nektar::SolverUtils::CouplingCwipi::m_sendTag

protected

Definition at line 102 of file CouplingCwipi.h.

Referenced by v_Init(), and v_Send().

◆ m_spacedim

int Nektar::SolverUtils::CouplingCwipi::m_spacedim

protected

Definition at line 108 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 115 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 117 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