PHengLEI-NCCR/API/Geometry/include/Geo_Interpoint.h

414 lines
16 KiB
C
Raw Normal View History

2024-10-14 09:32:17 +08:00
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// PPPPP H H EEEEE N N GGGGG L EEEEE III +
// P P H H E NN N G L E I +
// PPPPP HHHHH EEEEE N N N G GG L EEEEE I +
// P H H E N N N G G L E I +
// P H H EEEEE N N GGGGG LLLLL EEEEE III +
//------------------------------------------------------------------------+
// Platform for Hybrid Engineering Simulation of Flows +
// China Aerodynamics Research and Development Center +
// (C) Copyright, Since 2010 +
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//! @file Geo_Interpoint.h
//! @brief Interpoint information for multi-zone grid.
//! @author Wan Yunbo.
//! @email wanyb11@163.com
//! @date 2019-11-30
#pragma once
#include <vector>
#include "Precision.h"
#include "LIB_Macro.h"
#include "Data_ParamFieldSuite.h"
namespace PHSPACE
{
//! @brief patched-interpoint class for one neighor zone.
class InterpointPatch
{
private:
//! The index of the current zone.
int zoneID;
//! The index of the neighbor zone.
int zoneIndexOfNeighbor;
//! The number of patched-interpoint in the neighbor zone which linked to current zone.
int pointNumberOfPatch;
//! Interpoint index in the CURRENT zone, using in receiving.
int *pointIndexForReceive;
//! Interpoint index in the TARGET zone, using in sending.
int *pointIndexForSend;
private:
//! Store the data for sending to other zones.
Data_ParamFieldSuite *dataStorageSend;
//! Store the data for receiving from other zones.
Data_ParamFieldSuite *dataStorageReceive;
public:
//! Construct function for class InterpointPatch.
InterpointPatch();
//! Copy construct function for class InterpointPatch.
InterpointPatch(const InterpointPatch &interPatchIn);
//! Destructor, free memory.
~InterpointPatch();
public:
//! Get the interpoint index in the target zone.
//! @param[out] pointIndexForReceive interpoint index for receiving in current zone.
int * GetPointIndexForReceive() const;
//! Set the interpoint index in the target zone.
//! @param[in] pointIndexForReceive interpoint index for receiving in current zone.
void SetPointIndexForReceive(int *pointIndexForReceive);
//! Get the interpoint number in the target zone.
//! @param[out] pointIndexForSend interpoint index for sending in current zone.
int * GetPointIndexForSend() const;
//! Set the interpoint number in the target zone.
//! @param[in] pointIndexForSend interpoint index for sending in current zone.
void SetPointIndexForSend(int *pointIndexForSend);
//! Get the number of patched-interpoint in the neighbor zone.
//! @param[out] pointNumberOfPatch The number of patched-interpoint in the neighbor zone.
int GetNumberOfPoint() const;
//! Get the number of patched-interpoint in the neighbor zone.
//! @param[in] pointNumberOfPatch The number of patched-interpoint in the neighbor zone.
void SetNumberOfPoint(int pointNumberOfPatch);
//! Get the zone index of the neighbor zone.
//! @param[out] zoneIndexOfNeighbor the zone index of the neighbor zone.
int GetZoneIndexOfNeighbor() const;
//! Set the zone index of the neighbor zone.
//! @param[in] zoneIndexOfNeighbor the zone index of the neighbor zone.
void SetZoneIndexOfNeighbor(int zoneIndexOfNeighbor);
//! Get the zone index of the current zone.
//! @param[out] zoneID The index of the current zone.
int GetZoneID() const;
//! Allocate the memory for sending and receiving data.
void AllocateData();
};
class Grid;
//! @brief InterpointInformation: inter-point information, similar with the interface information,
//! which is used to store the inter-point connection information between neighbor zones.
class InterpointInformation
{
private:
//! Number of interpoints.
int numberOfInterpoints;
//! Number of neighbor zones.
int numberOfNeighbor;
//! Neighbor zone index of the interpoint in current zone.
int *interPoint2ZoneID;
//! Interpoint index in neighbor zone of the interpoint in current zone.
int *interPoint2InterPointID;
//! Global point index in current zone of the interpoint in current zone.
int *interPoint2GlobalPoint;
//! Total cell numbers of the interpoint in computing node value, is not node2cell.
int *cellNumberOfInterPoint;
//! Total zones of the interpoint belongs to.
int *totalZonesOfInterPoint;
//! Label of the interpoint,if =1 ,the InterPoint is needed in computing node value.if =0,
//! it is not needed in computing node value.
int *labelOfInterPoint;
//! Parent grid of the current grid, using in multi-grid method.
Grid *parent;
//! Data storage for sending.
Data_ParamFieldSuite *dataForSend;
//! Data storage for receiving.
Data_ParamFieldSuite *dataForReceive;
//! The number of patched-interpoint in the neighbor zone which linked to current zone.
InterpointPatch **interPointPatch;
public:
//! Construct function for class InterpointInformation.
InterpointInformation();
//! Copy Construct function for class InterpointInfo.
//! @param[out] infoIn an object of class InterpointInfo.
InterpointInformation(const InterpointInformation &infoIn);
//! Copy Construct function for class InterpointInformation.
//! @param[in] numberOfInterpoints Number of interpoints.
//! @param[in] parent Parent grid of the current grid.
InterpointInformation(int numberOfInterpoints, Grid *parent = 0);
//! Destructor, free memory.
~InterpointInformation();
public:
//! Get the number of interpoints.
//! @param[out] interPoint2ZoneID Neighbor zone index of the interpoint.
int * GetInterPoint2ZoneID() const;
//! Get interpoint index in neighbor zone.
//! @param[out] interPoint2InterPointID interpoint index in neighbor zone.
int * GetInterPoint2InterPointID() const;
//! Get global point index in current zone.
//! @param[out] interPoint2GlobalPoint Global point index in current zone.
int * GetInterPoint2GlobalPoint() const;
//! Get the total cell numbers of the interpoint.
//! @param[out] cellNumberOfInterPoint total cell numbers of the interpoint.
int * GetCellNumberOfInterPoint() const;
//! Get the total zones of the interpoint.
//! @param[out] totalZonesOfInterPoint Total zones of the interpoint.
int * GetTotalZonesOfInterPoint() const;
//! Get the label of the interpoint.
//! @param[out] labelOfInterPoint Label of the interpoint.
int * GetLabelOfInterPoint() const;
//! Get the neighbor zone index of iNeighbor, iNeighbor among in [0, numberOfNeighbor].
//! @param[in] iNeighbor the i-th neighbor for interpoint of this zone.
//! @param[out] the zone index of the i-th neighbor.
int GetZoneIndexOfNeighbor(int iNeighbor) const;
//! Get the point index of iNeighbor for receiving.
//! @param[in] iNeighbor the i-th neighbor for interpoint of this zone.
//! @param[out] the point index of iNeighbor for receiving.
int * GetPointIndexForReceive(int iNeighbor) const;
//! Get the point index of iNeighbor for sending.
//! @param[in] iNeighbor the i-th neighbor for interpoint of this zone.
//! @param[out] the point index of iNeighbor for sending.
int * GetPointIndexForSend(int iNeighbor) const;
//! Get the send data storage of the i-th data.
//! @param[in] istore the ID the sending data storage.
//! @param[out]dataForSend[istore] the send data storage of the i-th data.
Data_ParamFieldSuite * GetSendDataStorage(int istore) const;
//! Get the receive data storage of the i-th data.
//! @param[in] istore the ID the receiving data storage.
//! @param[out] dataForSend[istore] the receive data storage of the i-th data.
Data_ParamFieldSuite * GetReceiveDataStorage(int istore) const;
//! Set the number of interpoints.
//! @param[in] numberOfInterpoints Number of interpoints.
void SetNumberOfInterpoints(int numberOfInterpoints);
//! Get the number of interpoints.
//! @param[out] numberOfInterpoints Number of interpoints.
int GetNumberOfInterpoints() const;
//! Set the number of Neighbor for interpoint.
//! @param[in] numberOfNeighbor Number of neighbor zones.
void SetNumberOfNeighbor(int numberOfNeighbor);
//! Get the number of Neighbor for interpoint.
//! @param[out] numberOfNeighbor Number of neighbor zones.
int GetNumberOfNeighbor() const;
//! get the index of Neighbor zone.
//! @param[in] zone zone Index.
//! @param[out] the i-th index.
int FindIthNeighbor(int zone);
//! Compute the point index of iNeighbor for sending.
//! @param[in] iNeighbor the i-th neighbor for interpoint of this zone.
//! @param[out] the point index of iNeighbor for sending.
int * ComputePointIndexForSend(int iNeighbor);
//! Fill the point index of iNeighbor for sending to zone.
//! @param[in] zone the zone Index for sending to.
//! @param[in] pointIndexForSendIn point index for sending to zone.
void FillPointIndexForSend(int zone, int *pointIndexForSendIn);
//! Get the number of patched-interpoint.
//! @param[out] interPointPatch the number of patched-interpoint.
InterpointPatch ** GetInterpointPatch() const;
//! Get the patched-interpoint of the ith neighbor zone.
//! @param[in] iNeighbor the i-th neighbor zone.
//! @param[out] interPointPatch the patched-interpoint of the i-th neighbor zone.
InterpointPatch * GetInterpointPatch(int iNeighbor) const;
//! Find the neighbor zone for interpoint.
void FindNeighbors();
//! Init the neighbor zone for interpoint.
void InitNeighbors();
//! Init the i-th neighbor zone for interpoint.
//! @param[in] iNeighbor the i-th neighbor zone.
void InitNeighbors(int iNeighbor);
//! Allocate the memory for the neighbors for interpoint.
void AllocateNeighborInfo();
//! Allocate the memory for the neighbors sending or receive of the interpoint.
//! @param[in] iNeighbor the i-th neighbor zone.
void AllocateSendReceive(int iNeighbor);
//! Get the number of the interpoint with the i-th neighbor.
//! @param[in] iNeighbor the i-th neighbor zone.
int GetNumberOfInterpointsForNeighbor(int iNeighbor) const;
//! compute the point index for receive interpoint in current zone.
//! @param[in] iNeighbor the i-th neighbor zone.
void ComputePointIndexForReceive(int iNeighbor);
//! Compute the number of the interpoint for the i-th neighbor.
//! @param[in] iNeighbor the i-th neighbor zone.
int ComputeNumberOfInterpointsForNeighbor(int iNeighbor);
//! Compute the number of the neighbors for this zone.
//! @param[in] zoneFlag array to store the neighbor zones.
int ComputeNumberOfNeighbor(int *zoneFlag);
//! Resize the number of new interpoints according to the new number of inter points.
//! @param[in] numberOfNewInterpoints the number of new interpoints in this zone.
void ReSize(int numberOfNewInterpoints);
//! Set the neighbor of this interpoint found or not.
//! @param[in] data array to store true or false.
void SetIsNeighborInterpointFound(bool *data);
//! Get the neighbor of this interpoint found or not.
//! @param[out] isNeighborInterpointFound Is the neighbor interpoint has been found.
bool * GetIsNeighborInterpointFound();
private:
//! Is the neighbor interpoint has been found.
//! This is used during partition only.
bool *isNeighborInterpointFound;
};
//! Interpoint variable fields
//! Store the interpoint variable for multi-zone grid, using for Parallel communication.
class InterpointFields
{
private:
//! List of interpoint field variable names.
vector<string> variableNames;
//! List of interpoint field variable types.
vector<int> variableTypes;
//! List of interpoint field variable dimensions.
//! eg. 1D/2D array, dimension is equal to '1' or '2'.
vector<int> variableDimensions;
//! Interpoint information.
InterpointInformation *interpointInformation;
//! Solver ID.
vector<int> solverIndex;
public:
//! Construct function.
//! @param[in] interpointInformationIn an object of class InterpointInformation.
InterpointFields(InterpointInformation *interpointInformationIn);
//! Destructor, free memory.
~InterpointFields();
public:
//! Get the number of variables.
//! @param[out] the number of variables.
uint_t Size();
//! Get the dimension of the i-th data.
//! @param[in]iData data index.
//! @param[out] the dimension of the i-th data.
int GetDimension(const int iData);
//! Get the name of the i-th data.
//! @param[in]iData data index.
//! @param[out] the name of the i-th data.
string & GetName(const int iData);
//! Get the solver index of the i-th data.
//! @param[in]iData data index.
//! @param[out] the solver index of the i-th data.
int GetSolverIndex(const int iData);
//! Register the data fields according to the name, type and dimensional.
//! @param[in] name data fields name.
//! @param[in] type data fields type.
//! @param[in] dimesion data fields dimesion.
//! @param[in] solverID data fields solverID.
void RegisterField(const string &name, const int type, const int dimesion, const int solverID);
//! Free the store for interpoint.
void FreeInterpointVariable();
//! Get the sending variable according to the name and the ghost layers.
//! @param[in] name data fields name.
//! @param[in] IDOfGhostLayer the ID of ghost layers..
//! @param[out] the sending variable.
template<typename T>
T ** GetSendVariable(const string &name, const int IDOfGhostLayer);
//! Get the sending variable according to the name and the ghost layers.
//! @param[in] name data fields name.
//! @param[in] IDOfGhostLayer the ID of ghost layers..
//! @param[out] the receiving variable.
template<typename T>
T ** GetReceiveVariable(const string &name, const int IDOfGhostLayer);
private:
//! Allocate the memory for variable according to the name type and dimesion.
//! @param[in] name data fields name.
//! @param[in] type data fields type.
//! @param[in] dimesion data fields dimesion.
//! @param[out] datastore the data store for all variables needing communicating.
void AllocateInterpointVariable(const string &name, const int type, const int dimesion, Data_ParamFieldSuite *datastore);
//! Free the memory for all variables.
//! @param[in] datastore the data store for all variables needing communicating.
void FreeInterpointVariable(Data_ParamFieldSuite *datastore);
};
//! @brief store the interpoint value.\n
class InterpointDataProxy
{
private:
//! The vector to store the interpoint data for sending or receiving.
vector<RDouble **> vdata;
//! The vector to store the interpoint data dimension for sending or receiving.
vector<int> vdim;
public:
//! Construct function for class InterpointDataProxy.
InterpointDataProxy();
//! Destructor, free memory
~InterpointDataProxy();
public:
//! Get the vector of the interpoint data.
//! @param[out] vdata vector of the interpoint data.
vector<RDouble **> & GetVectorData();
//! Get the vector of the interpoint data dimension.
//! @param[out] vdim the vector of the interpoint data dimension.
vector<int> & GetVectorDimension();
};
#include "Geo_Interpoint.hxx"
}