void DataContainer::Allocate() { // Check that memory has not been allocated if (m_pAllocatedMemory != NULL) { _EXCEPTIONT("Attempting Allocate() on attached DataContainer"); } // Allocate memory as one contiguous chunk size_t sTotalByteSize = GetTotalByteSize(); m_pAllocatedMemory = reinterpret_cast<unsigned char*>(malloc(sTotalByteSize)); if (m_pAllocatedMemory == NULL) { _EXCEPTIONT("Out of memory"); } // Initialize allocated memory to zero memset(m_pAllocatedMemory, 0, sTotalByteSize); // Assign memory to DataChunks unsigned char * pAccumulated = m_pAllocatedMemory; for (size_t i = 0; i < m_vecDataChunks.size(); i++) { DataChunk * pDataChunk = reinterpret_cast<DataChunk*>(m_vecDataChunks[i]); pDataChunk->AttachToData( reinterpret_cast<void *>(pAccumulated)); #pragma message "Alignment may be an issue here on 32-bit systems" pAccumulated += pDataChunk->GetByteSize(); } }
void GridCartesianGLL::ApplyDefaultPatchLayout( int nPatchCount ) { // Verify patch count is positive if (nPatchCount < 1) { _EXCEPTIONT("nPatchCount must be a positive integer"); } // Verify no Patches have been previously added if (m_nInitializedPatchBoxes != 0) { _EXCEPTIONT("ApplyDefaultPatchLayout() must be called on an empty Grid"); } // Determine number of usable processors int nProcsPerDirection = nPatchCount; int nDistributedPatches = nProcsPerDirection; // Determine arrangement of elements on processors if (GetABaseResolution() % nProcsPerDirection != 0) { _EXCEPTIONT("\n(UNIMPLEMENTED) Currently elements must be " "equally divided among processors."); } int nElementsPerDirection = GetABaseResolution() / nProcsPerDirection; DataArray1D<int> iBoxBegin(nProcsPerDirection + 1); iBoxBegin[0] = 0; for (int n = 1; n < nProcsPerDirection; n++) { iBoxBegin[n] = n * nElementsPerDirection; } iBoxBegin[nProcsPerDirection] = GetABaseResolution(); // Single panel 0 implementation (Cartesian Grid) // Rectangular alpha-wise patches that span all of the beta direction // (as many as there are processors available) for (int i = 0; i < nProcsPerDirection; i++) { // Patch strips that span beta m_aPatchBoxes[i] = PatchBox( 0, 0, m_model.GetHaloElements(), m_nHorizontalOrder * iBoxBegin[i], m_nHorizontalOrder * iBoxBegin[i+1], 0, m_nHorizontalOrder * GetBBaseResolution()); } m_nInitializedPatchBoxes = nProcsPerDirection; }
void LoadMetaDataFile( const std::string & strInputMeta, DataMatrix3D<int> & dataGLLNodes, DataMatrix3D<double> & dataGLLJacobian ) { NcFile ncMeta(strInputMeta.c_str(), NcFile::ReadOnly); NcDim * dimNp = ncMeta.get_dim("np"); if (dimNp == NULL) { _EXCEPTIONT("Dimension \"np\" missing from metadata file"); } NcDim * dimNelem = ncMeta.get_dim("nelem"); if (dimNelem == NULL) { _EXCEPTIONT("Dimension \"nelem\" missing from metadata file"); } NcVar * varGLLNodes = ncMeta.get_var("GLLnodes"); if (dimNelem == NULL) { _EXCEPTIONT("Variable \"GLLnodes\" missing from metadata file"); } NcVar * varGLLJacobian = ncMeta.get_var("J"); if (dimNelem == NULL) { _EXCEPTIONT("Variable \"J\" missing from metadata file"); } int nP = dimNp->size(); int nElem = dimNelem->size(); DataMatrix3D<int> dataGLLNodes_tmp; DataMatrix3D<double> dataGLLJacobian_tmp; dataGLLNodes.Initialize(nP, nP, nElem); dataGLLJacobian.Initialize(nP, nP, nElem); dataGLLNodes_tmp.Initialize(nP, nP, nElem); dataGLLJacobian_tmp.Initialize(nP, nP, nElem); varGLLNodes->get(&(dataGLLNodes_tmp[0][0][0]), nP, nP, nElem); varGLLJacobian->get(&(dataGLLJacobian_tmp[0][0][0]), nP, nP, nElem); for (int i = 0; i < nP; i++) { for (int j = 0; j < nP; j++) { for (int k = 0; k < nElem; k++) { dataGLLNodes[i][j][k] = dataGLLNodes_tmp[j][i][k]; dataGLLJacobian[i][j][k] = dataGLLJacobian_tmp[j][i][k]; } } } }
/// <summary> /// Calculate eta at the given point via Newton iteration. The /// geopotential and temperature at this point are also returned via /// command-line parameters. /// </summary> double EtaFromRLL( const PhysicalConstants &phys, double dZp, double dXp, double dYp, double & dGeopotential, double & dTemperature ) const { const int MaxIterations = 50; const double InitialEta = 1.0e-5; const double Convergence = 1.0e-13; // Buffer variables double dEta = InitialEta; double dNewEta; double dF; double dDiffF; // Iterate until convergence is achieved int i = 0; for (; i < MaxIterations; i++) { CalculateGeopotentialTemperature( phys, dEta, dXp, dYp, dGeopotential, dTemperature); dF = - phys.GetG() * dZp + dGeopotential; dDiffF = - phys.GetR() / dEta * dTemperature; dNewEta = dEta - dF / dDiffF; if (fabs(dEta - dNewEta) < Convergence) { return dNewEta; } dEta = dNewEta; } // Check for convergence failure if (i == MaxIterations) { _EXCEPTIONT("Maximum number of iterations exceeded."); } if ((dEta > 1.0) || (dEta < 0.0)) { _EXCEPTIONT("Invalid Eta value"); } return dEta; }
void KesslerPhysics::Initialize( const Time & timeStart ) { // Indices of EquationSet variables const int UIx = 0; const int VIx = 1; const int TIx = 2; const int WIx = 3; const int RIx = 4; // Get a copy of the GLL grid Grid * pGrid = m_model.GetGrid(); // Check position of variables if (pGrid->GetVarLocation(TIx) == DataLocation_REdge) { _EXCEPTIONT("Not implemented for --vstagger CPH, use --vstagger LOR"); } int ndim=pGrid->GetRElements(); qv.Allocate(ndim); qc.Allocate(ndim); qr.Allocate(ndim); t.Allocate(ndim); rho.Allocate(ndim); zc.Allocate(ndim); pk.Allocate(ndim); }
void GridPatchCartesianGLL::InitializeDataLocal() { // Allocate data GridPatch::InitializeDataLocal(); // Physical constants const PhysicalConstants & phys = m_grid.GetModel().GetPhysicalConstants(); // Initialize the longitude and latitude at each node for (int i = 0; i < m_box.GetATotalWidth(); i++) { for (int j = 0; j < m_box.GetBTotalWidth(); j++) { // Longitude and latitude directly from box m_dataLon[i][j] = m_box.GetANode(i); m_dataLat[i][j] = m_box.GetBNode(j); //m_dataCoriolisF[i][j] = 0.0; } } // Set the scale height for the decay of topography features m_dSL = 10.0 * m_dTopoHeight; if (m_dSL >= m_grid.GetZtop()) { _EXCEPTIONT("Coordinate scale height exceeds model top."); } //std::cout << m_box.GetATotalWidth() << " " << m_box.GetBTotalWidth() << "\n"; }
void Grid::SetParameters( int nRElements, int nMaxPatchCount, int nABaseResolution, int nBBaseResolution, int nRefinementRatio, VerticalStaggering eVerticalDiscretization, VerticalStaggering eVerticalStaggering ) { if (!m_dcGridParameters.IsAttached()) { _EXCEPTIONT("DefineParameters() must be called before SetParameters()"); } // Default GridParameters values m_nMaxPatchCount = nMaxPatchCount; m_nRElements = nRElements; m_iGridStamp = 0; m_eVerticalDiscretization = eVerticalDiscretization; m_eVerticalStaggering = eVerticalStaggering; m_nABaseResolution = nABaseResolution; m_nBBaseResolution = nBBaseResolution; m_nRefinementRatio = nRefinementRatio; m_dReferenceLength = 1.0; m_dZtop = 1.0; m_fHasReferenceState = false; m_fHasRayleighFriction = false; // Set boundary conditions for (int i = 0; i < 4; i++) { m_eBoundaryCondition[i] = BoundaryCondition_Default; } }
void ExchangeBufferRegistry::Send() { #ifdef TEMPEST_MPIOMP if (m_fActiveAsyncSend) { _EXCEPTIONT("Attempting to Send() with active asynchronous sends"); } for (int p = 0; p < m_vecProcessors.size(); p++) { MPI_Isend( m_vecSendBuffers[p], m_vecBufferSize[p], MPI_BYTE, m_vecProcessors[p], 0, MPI_COMM_WORLD, &(m_vecSendRequest[p])); /* int nRank; MPI_Comm_rank(MPI_COMM_WORLD, &nRank); printf("On %i sending %i bytes to %i\n", nRank, m_vecBufferSize[p], m_vecProcessors[p]); */ } // Activate m_fActiveAsyncSend = true; #endif }
void GridPatchCSGLL::ComputeVorticityDivergence( int iDataIndex ) { // Physical constants const PhysicalConstants & phys = m_grid.GetModel().GetPhysicalConstants(); // Working data DataArray4D<double> & dataState = GetDataState(iDataIndex, DataLocation_Node); if (dataState.GetSize(0) < 2) { _EXCEPTIONT( "Insufficient components for vorticity calculation"); } // Get the alpha and beta components of vorticity DataArray3D<double> dataUa; dataUa.SetSize( dataState.GetSize(1), dataState.GetSize(2), dataState.GetSize(3)); DataArray3D<double> dataUb; dataUb.SetSize( dataState.GetSize(1), dataState.GetSize(2), dataState.GetSize(3)); dataUa.AttachToData(&(dataState[0][0][0][0])); dataUb.AttachToData(&(dataState[1][0][0][0])); // Compute the radial component of the curl of the velocity field ComputeCurlAndDiv(dataUa, dataUb); }
void Grid::DefineParameters() { if (m_dcGridParameters.IsAttached()) { _EXCEPTIONT("Attempting to recall DefineParameters"); } #pragma message "May have to modify DataContainer to incorporate padding for DataChunks" // Four lateral boundaries (rectangular mesh) m_eBoundaryCondition.SetSize(4); // Initialize the GridParameters DataContainer m_dcGridParameters.PushDataChunk(&m_nMaxPatchCount); m_dcGridParameters.PushDataChunk(&m_nRElements); m_dcGridParameters.PushDataChunk(&m_iGridStamp); m_dcGridParameters.PushDataChunk(&m_eVerticalDiscretization); m_dcGridParameters.PushDataChunk(&m_eVerticalStaggering); m_dcGridParameters.PushDataChunk(&m_nABaseResolution); m_dcGridParameters.PushDataChunk(&m_nBBaseResolution); m_dcGridParameters.PushDataChunk(&m_nRefinementRatio); m_dcGridParameters.PushDataChunk(&m_eBoundaryCondition); m_dcGridParameters.PushDataChunk(&m_dReferenceLength); m_dcGridParameters.PushDataChunk(&m_dZtop); m_dcGridParameters.PushDataChunk(&m_fHasReferenceState); m_dcGridParameters.PushDataChunk(&m_fHasRayleighFriction); m_dcGridParameters.Allocate(); }
int Grid::GetTotalNodeCount( DataLocation loc ) const { // Total number of nodes over all patches of grid int nTotalNodes = 0; // Loop over all patches and obtain total node count for (int n = 0; n < m_aPatchBoxes.GetRows(); n++) { const PatchBox & box = GetPatchBox(n); int nPatchNodes; if (loc == DataLocation_Node) { nPatchNodes = box.GetTotalNodes() * GetRElements(); } else if (loc == DataLocation_REdge) { nPatchNodes = box.GetTotalNodes() * (GetRElements() + 1); } else { _EXCEPTIONT("Invalid location"); } nTotalNodes += nPatchNodes; } return nTotalNodes; }
void CubedSphereTrans::XYZFromXYP( double dXX, double dYY, int np, double &xx, double &yy, double &zz ) { // X, Y, Z coordinates in the local panel-centric coordinate system double sx, sy, sz; // Convert to Cartesian coordinates sz = 1.0 / sqrt(1.0 + dXX * dXX + dYY * dYY); sx = sz * dXX; sy = sz * dYY; // Rotate panel-centroid Cartesian coordinates to global // Cartesian coordinates. switch(np) { case 0: yy = sx; zz = sy; xx = sz; break; case 1: xx = -sx; zz = sy; yy = sz; break; case 2: yy = -sx; zz = sy; xx = -sz; break; case 3: xx = sx; zz = sy; yy = -sz; break; case 4: yy = sx; xx = -sy; zz = sz; break; case 5: yy = sx; xx = sy; zz = -sz; break; default: _EXCEPTIONT("Invalid panel id"); } }
void Grid::ConvertReferenceToPatchCoord( const DataArray1D<double> & dXReference, const DataArray1D<double> & dYReference, DataArray1D<double> & dAlpha, DataArray1D<double> & dBeta, DataArray1D<int> & iPatch ) const { _EXCEPTIONT("Unimplemented."); }
void GridCartesianGLL::GetOpposingDirection( int ixPanelSrc, int ixPanelDest, Direction dir, Direction & dirOpposing, bool & fSwitchParallel, bool & fSwitchPerpendicular ) const { if ((ixPanelSrc < 0) || (ixPanelSrc > 5)) { _EXCEPTIONT("Invalid value for ixPanelSrc: Out of range"); } if ((ixPanelDest < 0) || (ixPanelDest > 5)) { _EXCEPTIONT("Invalid value for ixPanelDest: Out of range"); } // Get the opposing direction for Cartesian panels Source = Destination if (ixPanelDest != ixPanelSrc) { _EXCEPTIONT("ERROR: Soure and Destination panels must be equal!"); } if (dir == Direction_Right) { dirOpposing = Direction_Left; } else if (dir == Direction_Top) { dirOpposing = Direction_Bottom; } else if (dir == Direction_Left) { dirOpposing = Direction_Right; } else if (dir == Direction_Bottom) { dirOpposing = Direction_Top; } else if (dir == Direction_TopRight) { dirOpposing = Direction_BottomLeft; } else if (dir == Direction_TopLeft) { dirOpposing = Direction_BottomRight; } else if (dir == Direction_BottomLeft) { dirOpposing = Direction_TopRight; } else if (dir == Direction_BottomRight) { dirOpposing = Direction_TopLeft; } // Do not switch directions across this edge fSwitchParallel = false; fSwitchPerpendicular = false; }
void Grid::EvaluateVerticalStretchF( double dREta, double & dREtaStretch, double & dDxREtaStretch ) { if (m_pVerticalStretchF == NULL) { _EXCEPTIONT("No VerticalStretchFunction defined in Grid"); } (*m_pVerticalStretchF)(dREta, dREtaStretch, dDxREtaStretch); }
void Grid::SetBoundaryCondition( Direction eDir, BoundaryCondition eBoundaryCondition ) { int iDir = static_cast<int>(eDir); if ((iDir < 0) || (iDir > 3)) { _EXCEPTIONT("Invalid Direction specified"); } m_eBoundaryCondition[iDir] = eBoundaryCondition; }
void Grid::RegisterExchangeBuffer( int ixSourcePatch, int ixTargetPatch, Direction dir ) { const PatchBox & box = GetPatchBox(ixSourcePatch); // First patch coordinate index int ixFirst; int ixSecond; if ((dir == Direction_Right) || (dir == Direction_Left) ) { ixFirst = box.GetBInteriorBegin(); ixSecond = box.GetBInteriorEnd(); } else if ( (dir == Direction_Top) || (dir == Direction_Bottom) ) { ixFirst = box.GetAInteriorBegin(); ixSecond = box.GetAInteriorEnd(); } else if (dir == Direction_TopRight) { ixFirst = box.GetAInteriorEnd()-1; ixSecond = box.GetBInteriorEnd()-1; } else if (dir == Direction_TopLeft) { ixFirst = box.GetAInteriorBegin(); ixSecond = box.GetBInteriorEnd()-1; } else if (dir == Direction_BottomLeft) { ixFirst = box.GetAInteriorBegin(); ixSecond = box.GetBInteriorBegin(); } else if (dir == Direction_BottomRight) { ixFirst = box.GetAInteriorEnd()-1; ixSecond = box.GetBInteriorBegin(); } else { _EXCEPTIONT("Invalid direction"); } // Exterior connect RegisterExchangeBuffer( ixSourcePatch, ixTargetPatch, dir, ixFirst, ixSecond); }
int TimestepSchemeStrang::GetSubStepCount() const { HorizontalDynamics * pHorizontalDynamics = m_model.GetHorizontalDynamics(); if (pHorizontalDynamics == NULL) { _EXCEPTIONT("HorizontalDynamics has not been initialized"); } int nHorizontalDynamicsSubSteps = pHorizontalDynamics->GetSubStepAfterSubCycleCount(); return (m_nExplicitSubSteps + nHorizontalDynamicsSubSteps + 1); }
bool OutputManagerComposite::OpenFile( const std::string & strFileName ) { #ifdef USE_MPI // Determine processor rank int nRank; MPI_Comm_rank(MPI_COMM_WORLD, &nRank); // Open file at root if (nRank == 0) { // Check for existing file if (m_ofsActiveOutput.is_open()) { _EXCEPTIONT("Restart file already open"); } // Open new binary output stream std::string strRestartFileName = strFileName + ".restart.dat"; m_ofsActiveOutput.open( strRestartFileName.c_str(), std::ios::binary | std::ios::out); if (!m_ofsActiveOutput) { _EXCEPTION1("Error opening output file \"%s\"", strRestartFileName.c_str()); } } // Wait for all processes to complete MPI_Barrier(MPI_COMM_WORLD); return true; #else _EXCEPTIONT("Not implemented without USE_MPI"); #endif }
void ExchangeBufferRegistry::Register( const ExchangeBuffer & exbuf ) { #ifdef TEMPEST_MPIOMP int nRank; MPI_Comm_rank(MPI_COMM_WORLD, &nRank); if (exbuf.m_ixSourceProcessor != nRank) { _EXCEPTIONT("ExchangeBuffer must be local"); } #endif // Add the ExchangeBuffer to the registry m_vecRegistry.push_back(exbuf); }
void GridCartesianGLL::DefineParameters() { if (m_dcGridParameters.IsAttached()) { _EXCEPTIONT("Attempting to recall SetParameters"); } // Set the dimension of the Cartesian domain m_dGDim.SetSize(6); // Add parameters for GridCartesianGLL m_dcGridParameters.PushDataChunk(&m_dGDim); m_dcGridParameters.PushDataChunk(&m_dRefLat); // Call up the stack GridGLL::DefineParameters(); }
void ExchangeBuffer::Reset() { if (m_dSendBuffer.GetByteSize() < sizeof(MessageHeader)) { _EXCEPTION1("Invalid ExchangeBuffer send buffer (%i)", m_dSendBuffer.GetByteSize()); } if (sizeof(MessageHeader) % sizeof(double) != 0) { _EXCEPTIONT("sizeof(MessageHeader) % sizeof(double) != 0"); } // Store ExchangeBuffer::MessageHeader GetSendMessageHeader((MessageHeader *)(&(m_dSendBuffer[0]))); // Set read and write indices to just beyond the MessageHeader m_ixRecvBuffer = sizeof(MessageHeader) / sizeof(double); m_ixSendBuffer = sizeof(MessageHeader) / sizeof(double); }
double GridSpacingGaussLobattoRepeated::GetEdge(int ix) const { int ixElement = (ix / m_nOrder); int ixSubElement = (ix % m_nOrder); if (ix < 0) { ixElement = ixElement - 1; ixSubElement = m_nOrder + ixSubElement; } if (ixSubElement >= m_nOrder) { _EXCEPTIONT("Logic error"); } return (m_dZeroCoord + m_dDeltaElement * static_cast<double>(ixElement) + m_dG[ixSubElement]); }
double GridSpacingGaussLobatto::GetNode(int ix) const { int ixElement = (ix / (m_nOrder - 1)); int ixSubElement = (ix % (m_nOrder - 1)); // Case of a negative index if (ix < 0) { ixElement = ixElement - 1; ixSubElement = m_nOrder + ixSubElement; } if (ixSubElement >= m_nOrder) { _EXCEPTIONT("Logic error"); } return (m_dZeroCoord + m_dDeltaElement * static_cast<double>(ixElement) + m_dG[ixSubElement]); }
size_t DataContainer::GetTotalByteSize() const { // Get the accumulated size of all DataChunks size_t sAccumulated = 0; for (size_t i = 0; i < m_vecDataChunks.size(); i++) { DataChunk * pDataChunk = reinterpret_cast<DataChunk*>(m_vecDataChunks[i]); // Verify byte alignment size_t sByteSize = pDataChunk->GetByteSize(); if (sByteSize % sizeof(size_t) != 0) { _EXCEPTIONT("Misaligned array detected in DataContainer"); } sAccumulated += sByteSize; } return sAccumulated; }
void CopyNcVarAttributes( NcVar * varIn, NcVar * varOut ) { for (int a = 0; a < varIn->num_atts(); a++) { NcAtt * att = varIn->get_att(a); long num_vals = att->num_vals(); NcValues * pValues = att->values(); if (att->type() == ncByte) { varOut->add_att(att->name(), num_vals, (const ncbyte*)(pValues->base())); } else if (att->type() == ncChar) { varOut->add_att(att->name(), num_vals, (const char*)(pValues->base())); } else if (att->type() == ncShort) { varOut->add_att(att->name(), num_vals, (const short*)(pValues->base())); } else if (att->type() == ncInt) { varOut->add_att(att->name(), num_vals, (const int*)(pValues->base())); } else if (att->type() == ncFloat) { varOut->add_att(att->name(), num_vals, (const float*)(pValues->base())); } else if (att->type() == ncDouble) { varOut->add_att(att->name(), num_vals, (const double*)(pValues->base())); } else { _EXCEPTIONT("Invalid attribute type"); } delete pValues; } }
double LegendrePolynomial::DerivativeExtendedRoot( int nDegree, int nRoot ) { if ((nRoot >= (nDegree + 1)) || (nRoot < 0)) { _EXCEPTIONT("Invalid root."); } // First root is -1 if (nRoot == 0) { return -1.0; // Last root is 1 } else if (nRoot == nDegree) { return 1.0; // Otherwise handle interior roots } else { return DerivativeRoot(nDegree, nRoot - 1); } }
void Grid::InitializeDataLocal() { if (m_dcGridPatchData.IsAttached()) { _EXCEPTIONT("Attempting to call InitializeDataLocal on" " initialized Grid"); } // Number of components int nComponents = m_model.GetEquationSet().GetComponents(); // Set the size of all DataArray objects m_aPatchBoxes.SetSize(m_nMaxPatchCount); m_dREtaLevels.SetSize(m_nRElements); m_dREtaInterfaces.SetSize(m_nRElements+1); m_dREtaLevelsNormArea.SetSize(m_nRElements); m_dREtaInterfacesNormArea.SetSize(m_nRElements+1); m_dREtaStretchLevels.SetSize(m_nRElements); m_dREtaStretchInterfaces.SetSize(m_nRElements+1); m_vecVarLocation.SetSize(nComponents); m_vecVarIndex.SetSize(nComponents); m_vecVarsAtLocation.SetSize((size_t)DataLocation_Count); // Initialize the GridData DataContainer m_dcGridPatchData.PushDataChunk(&m_nInitializedPatchBoxes); m_dcGridPatchData.PushDataChunk(&m_aPatchBoxes); m_dcGridPatchData.PushDataChunk(&m_dREtaLevels); m_dcGridPatchData.PushDataChunk(&m_dREtaInterfaces); m_dcGridPatchData.PushDataChunk(&m_dREtaLevelsNormArea); m_dcGridPatchData.PushDataChunk(&m_dREtaInterfacesNormArea); m_dcGridPatchData.PushDataChunk(&m_dREtaStretchLevels); m_dcGridPatchData.PushDataChunk(&m_dREtaStretchInterfaces); m_dcGridPatchData.PushDataChunk(&m_vecVarLocation); m_dcGridPatchData.PushDataChunk(&m_vecVarIndex); m_dcGridPatchData.PushDataChunk(&m_vecVarsAtLocation); m_dcGridPatchData.Allocate(); // Default GridData values m_nInitializedPatchBoxes = 0; }
void ExteriorNeighbor::Send() { // Send the data const GridPatch & patch = m_pConnect->GetGridPatch(); const Grid & grid = patch.GetGrid(); int ixPatch = patch.GetPatchIndex(); int iProcessor = grid.GetPatch(m_ixNeighbor)->GetProcessor(); // Tag if (m_ixNeighbor >= (2 << 12)) { _EXCEPTIONT("Maximum neighbor index exceeded."); } int nTag = (ixPatch << 16) + (m_ixNeighbor << 4) + (int)(m_dirOpposite); #pragma message "Move MPI_TAG processing to Connectivity" MPI_Isend( &(m_vecSendBuffer[0]), m_ixSendBuffer, MPI_DOUBLE, iProcessor, nTag, MPI_COMM_WORLD, &m_reqSend); /* MPI_Send( &(m_vecSendBuffer[0]), m_ixSendBuffer, MPI_DOUBLE, iProcessor, nTag, MPI_COMM_WORLD); */ }
void DataContainer::AttachTo( unsigned char * pAllocatedMemory ) { if (m_pAllocatedMemory != NULL) { _EXCEPTIONT("Attempting AttachTo() on attached DataContainer"); } m_fOwnsData = false; m_pAllocatedMemory = pAllocatedMemory; // Assign memory to DataChunks unsigned char * pAccumulated = m_pAllocatedMemory; for (size_t i = 0; i < m_vecDataChunks.size(); i++) { DataChunk * pDataChunk = reinterpret_cast<DataChunk *>(m_vecDataChunks[i]); pDataChunk->AttachToData( reinterpret_cast<void *>(pAccumulated)); pAccumulated += pDataChunk->GetByteSize(); } }