FieldData.C

Go to the documentation of this file.

#include "FieldData.H"

namespace field {

  std::ostream &operator<<(std::ostream &Ostr,const field::databuffer &buf)
  {
    if(!buf._data_ptr)
      return(Ostr);
    std::ostringstream OStr;
    OStr << buf._number_of_items << " " << buf._item_size << std::endl;
    bool known_data_type = false;
    if(buf._item_size == 1){
      buf.OutputToStream<char>(OStr);
    }
    else if(buf._item_size == 2){
      buf.OutputToStream<short>(OStr);
    }
    else if(buf._item_size == 4){
      buf.OutputToStream<int>(OStr);
    }
    else if(buf._item_size == 8){
      buf.OutputToStream<double>(OStr);
    }
    else
      assert(known_data_type);
    Ostr << OStr.str();
    return(Ostr);
  };

  std::istream &operator>>(std::istream &Istr,field::databuffer &buf)
  {
    int in_nitems = 0;
    int in_size = 0;
    std::string line;
    while(line.empty())
      std::getline(Istr,line);
    std::istringstream IStr(line);
    IStr >> in_nitems;
    IStr >> in_size;
    int read_size = in_nitems * in_size;
    int expected_size = buf._number_of_items * buf._item_size;
    if(expected_size <= 0) {
      expected_size = read_size;
      buf._number_of_items = in_nitems;
      buf._item_size = in_size;
    }
    bool known_data_type = false;
    if(buf._data_ptr != NULL){
      if(expected_size != read_size){
        std::cout << "PC2::ERROR line      = " << line << std::endl
                  << "PC2::ERROR in_nitems = " << in_nitems << std::endl
                  << "PC2::ERROR in_size   = " << in_size << std::endl
                  << "PC2::ERROR read_size = " << read_size << std::endl
                  << "PC2::ERROR expected  = " << expected_size << std::endl;
        std::getline(Istr,line);
        std::cout << "PC2::ERROR next_line = " << line << std::endl;
      }
      assert(expected_size == read_size);
    }
    else 
      buf.Allocate(in_nitems,in_size);
    if(buf._item_size == 1)
      buf.ReadFromStream<char>(Istr);
    else if(buf._item_size == 2)
      buf.ReadFromStream<short>(Istr);
    else if(buf._item_size == 4)
      buf.ReadFromStream<int>(Istr);
    else if(buf._item_size == 8)
      buf.ReadFromStream<double>(Istr);
    else
      assert(known_data_type);
    return(Istr);
  };

  std::istream &operator>>(std::istream &IStr,field::metadata &md)
  {
    //    std::string line;
    //    std::getline(Istr,line);
    //    std::istringstream InStr(line);
    //    InStr >> name >> unit >> loc >> ncomp >> dsize;
    IStr >> md.name >> md.loc >> md.ncomp >> md.dsize >> md.unit;
    if(md.unit == "[NULL]")
      md.unit.erase();
    return(IStr);
  };

  std::ostream &operator<<(std::ostream &OStr,const field::metadata &md)
  {
    OStr << md.name << " " << md.loc << " " << md.ncomp << " " << md.dsize << " "
         << (md.unit.empty() ? "[NULL]" : md.unit);
    return(OStr);
  };


  // ///
  // /// @brief Configures field data
  // /// 
  // /// This routine reads the field data configuration out of the plascomConfig
  // /// configuration object and populates the plascomSimulationInfo.metaData
  // /// which stores the metadata for all the field data.
  // int plascom2::ConfigureFieldData()
  // {
  //   FunctionEntry("ConfigFieldData");
  //   int error = 0;
  //   std::ostringstream Ostr;
  //   std::string solutionKey("Solution:");
  //   std::vector<std::string> fieldNames(plascomConfig.GetValueVector<std::string>("Solution:Fields"));
  //   if(fieldNames.empty()){
  //     FunctionExit("ConfigFieldData");
  //     return(0);
  //   }
  //   std::vector<std::string>::iterator fieldIt = fieldNames.begin();
  //   while(fieldIt != fieldNames.end()){
  //     std::string fieldName(*fieldIt++);
  //     std::string fieldKey(solutionKey+fieldName+std::string(":"));
  //     std::string fieldUnits = plascomConfig.GetValue<std::string>(fieldKey+"Units");
  //     int numComponents = plascomConfig.GetValue<int>(fieldKey+"Components");
  //     int dataSize = plascomConfig.GetValue<int>(fieldKey+"DataSize");
  //     std::string fieldLocation = plascomConfig.GetValue<std::string>(fieldKey+"Location");
  //     if(dataSize <= 0 || dataSize > 8){
  //       std::ostringstream errOut;
  //       errOut << "ConfigureSolution:Warning: invalid data size for "
  //              << fieldName << ", defaulting to double(8)." << std::endl;
  //       ErrOut(errOut.str());
  //       dataSize = 8; // default to double data
  //     }
  //     if(numComponents <= 0)
  //       numComponents = 1; // default to scalar field
  //     if(fieldLocation.empty())
  //       fieldLocation = "n";
  //     if(fieldLocation.size() != 1)
  //       fieldLocation = fieldLocation.substr(0,1);
  //     fieldLocation[0] = std::tolower(fieldLocation[0]);
  //     if(fieldLocation != "n" && fieldLocation != "c" &&
  //        fieldLocation != "m" && fieldLocation != "s"){
  //       std::ostringstream errOut;
  //       errOut << "ConfigureSolution:Warning: invalid solution location for "
  //              << fieldName << ", defaulting to nodes." << std::endl;
  //       ErrOut(errOut.str());
  //       fieldLocation = "n";
  //     }
  //     plascomSimulationInfo.metaData.AddField(fieldName,fieldLocation[0],numComponents,dataSize,fieldUnits);
  //   }
  //   StdOut(ReportSimulationMetaData(plascomSimulationInfo.metaData),2);
  //   FunctionExit("ConfigFieldData");
  //   return(error);
  // }

  // ///
  // /// @brief Create main data & solution storage buffers
  // /// 
  // /// This function looks at the configured field data, 
  // /// separates the configured fields into simulation-wide
  // /// or grid-bound data, and then allocates data buffers
  // /// to store the data. Each field buffer is contiguous,
  // /// and is independent of storage policy.
  // int plascom2::CreateFieldDataBuffers()
  // {

  //   FunctionEntry("CreateFieldBuffers");
  //   if(computeProcess){
  //     pcpp::simulation::solutionmetadata &solnMeta(plascomSimulationInfo.metaData);
  //     pcpp::geometry::domaininfo domainInfo(plascomDomain.Info());
  //     std::vector<std::string>::iterator geomNameIt = domainInfo.geometryNames.begin();
  //     pcpp::geometry::domain::iterator domIt = plascomDomain.begin();
    
  //     // separate into simulation-wide data vs. grid-bound data
  //     pcpp::simulation::solutionmetadata simulationDataMeta;
  //     pcpp::simulation::solutionmetadata gridDataMeta;
  //     pcpp::simulation::solutionmetadata::iterator metaIt = solnMeta.begin();
  //     while(metaIt != solnMeta.end()){
  //       pcpp::simulation::fieldmetadata &fieldMeta(*metaIt++);
  //       if(fieldMeta.loc == 's')
  //         simulationDataMeta.push_back(fieldMeta);
  //       else
  //         gridDataMeta.push_back(fieldMeta);
  //     }
    
  //     // Create simulation-wide data
  //     simulationData.Meta().Copy(simulationDataMeta);
  //     simulationData.Create();
    
  //     // Iterate through the grids and create grid-bound data
  //     while(domIt != plascomDomain.end()){
  //       int gridIndex = domIt - plascomDomain.begin();
  //       std::string geomName(*geomNameIt++);
  //       pcpp::geometry::grid &currentGrid(*domIt++);
  //       pcpp::geometry::gridinfo &gridInfo(currentGrid.Info());
  //       pcpp::simulation::topologyinfo &gridTopo(gridTopology[gridIndex]);
      
  //       std::vector<int> &gridSize(gridInfo.globalSize);
  //       std::vector<int> &localSize(gridInfo.localSize);
  //       std::vector<int> &localStart(gridInfo.localStart);
  //       int gridDimension = gridInfo.numDimensions;
      
  //       bool gridOK = true;
  //       if(gridDimension == 0)
  //         gridOK = false;
  //       std::vector<int>::iterator gsIt = gridSize.begin();
  //       while(gsIt != gridSize.end())
  //         if(*gsIt++ == 0)
  //           gridOK = false;
  //       if(!gridOK){
  //         continue;
  //       }
  //       size_t numNodes = 1;
  //       size_t numCells = 1;
  //       std::vector<int>::iterator sizeIt = localSize.begin();
  //       while(sizeIt != localSize.end()){
  //         if(*sizeIt != 1)
  //           numCells *= (*sizeIt - 1);
  //         numNodes *= *sizeIt++;
  //       }
      
  //       std::ostringstream reportOut;
  //       reportOut << "Creating grid-bound data for " 
  //                 << currentGrid.Name() << " with "
  //                 << numNodes << " grid vertices, and " 
  //                 << numCells << " grid cells." << std::endl;
  //       StdOut(reportOut.str(),3);
  //       pcpp::simulation::solutiondata &currentSoln(currentGrid.Solution());
  //       pcpp::simulation::solutionmetadata &currentMeta(currentSoln.Meta());
  //       currentMeta.Copy(gridDataMeta);
  //       currentSoln.Create(numNodes,numCells);
      
  //       // Create buffers for the halo regions too
  //       std::vector<pcpp::IndexIntervalType> &haloExtents(gridTopo.haloExtents);
  //       std::vector<pcpp::simulation::solutiondata> &haloData(currentGrid.HaloData());
  //       haloData.resize(haloExtents.size());
  //       std::vector<pcpp::IndexIntervalType>::iterator haloIt = haloExtents.begin();
  //       while(haloIt != haloExtents.end()){
  //         int iDir = haloIt - haloExtents.begin();
  //         pcpp::IndexIntervalType haloExtent(*haloIt++);
  //         if(!haloExtent.empty()){
  //           std::ostringstream haloOut;
  //           haloOut << "Creating direction " << iDir 
  //                   << " halo data for region: ";
  //           haloExtent.PrettyPrint(haloOut);
  //           haloOut << std::endl;
  //           StdOut(haloOut.str(),3);
  //           int numHaloNodes = haloExtent.NNodes();
  //           haloData[iDir].Meta().Copy(gridDataMeta);
  //           haloData[iDir].Create(numHaloNodes);
  //         }  
  //       }
  //     }
  //   }
  //   FunctionExit("CreateFieldBuffers");
  //   return(0);
  // }


  // void plascom2::CreateSendData(const pcpp::simulation::solutionmetadata &solnMeta,
  //                               const pcpp::IndexIntervalType &gridExtent,
  //                               const std::vector<pcpp::RemoteCollisionType> &inCollision,
  //                               std::vector<pcpp::simulation::solutiondata> &bufferVec,
  //                               std::vector<std::vector<size_t> > &indexVec)
  // {
  //   if(inCollision.empty())
  //     return;
  //   int numCollisions = inCollision.size();
  //   bufferVec.resize(numCollisions);
  //   indexVec.resize(numCollisions);
  //   std::vector<pcpp::RemoteCollisionType>::const_iterator loopIt = inCollision.begin();
  //   while(loopIt != inCollision.end()){
  //     int dataIndex = loopIt - inCollision.begin();
  //     int remoteRank = loopIt->first;
  //     const pcpp::IndexIntervalType &commExtent(loopIt++->second);
  //     pcpp::simulation::solutiondata &commData(bufferVec[dataIndex]);
  //     std::vector<size_t> &commIndices(indexVec[dataIndex]);

  //     // Create the buffer to handle the communication
  //     commData.Meta().Copy(solnMeta);
  //     int nNodes = commExtent.NNodes();
  //     commData.Create(nNodes);
  //     // Figure out the indices required to feed the comm buffer from 
  //     // local grid-bound data
  //     gridExtent.GetFlatIndices(commExtent,commIndices);
  //     assert(commIndices.size() == nNodes);

  //     // Report to the user
  //     std::ostringstream Ostr;
  //     Ostr << "Creating buffer for send(" << remoteRank << "): ";
  //     commExtent.PrettyPrint(Ostr);
  //     Ostr << " " << nNodes  << " nodes." << std::endl;
  //     StdOut(Ostr.str(),3);
  //   }
  // };

  // void plascom2::CreateRecvData(const pcpp::simulation::solutionmetadata &solnMeta,
  //                               const std::vector<pcpp::IndexIntervalType> &haloExtents,
  //                               const std::vector<pcpp::RemoteCollisionType> &inCollision,
  //                               std::vector<pcpp::simulation::solutiondata> &bufferVec,
  //                               std::vector<pcpp::CollisionIndicesType> &indexVec)
  // {
  //   if(inCollision.empty())
  //     return;
  //   int numCollisions = inCollision.size();
  //   bufferVec.resize(numCollisions);
  //   indexVec.resize(numCollisions);
  //   std::vector<pcpp::RemoteCollisionType>::const_iterator loopIt = inCollision.begin();
  //   while(loopIt != inCollision.end()){
  //     int dataIndex = loopIt - inCollision.begin();
  //     int remoteRank = loopIt->first;
  //     const pcpp::IndexIntervalType &commExtent(loopIt++->second);
  //     pcpp::simulation::solutiondata &commData(bufferVec[dataIndex]);
  //     pcpp::CollisionIndicesType &commIndices(indexVec[dataIndex]);
  //     pcpp::SizeVec &recvIndices(commIndices.second);
  //     int &haloIndex(commIndices.first);

  //     // Create the buffer to handle the communication
  //     commData.Meta().Copy(solnMeta);
  //     int nNodes = commExtent.NNodes();
  //     commData.Create(nNodes);
  //     // Figure out *which halo buffer* and the indices required to feed 
  //     // that halo buffer from the communication buffer.
  //     //
  //     // Since there is an array of collisions coming in, and we don't
  //     // know which collision lives with which halo, we have to loop 
  //     // through the halos and collide the communication extent with 
  //     // the halo extent to find out which halo each communication
  //     // buffer should feed.  This information along with an array of
  //     // flat indices are recorded in a persistent data structure that
  //     // is used to avoid having to do these collisions during 
  //     // time stepping.
  //     int numHalos = 0;
  //     std::vector<pcpp::IndexIntervalType>::const_iterator extentIt = haloExtents.begin();
  //     while(extentIt != haloExtents.end()){
  //       int hIndex = extentIt - haloExtents.begin();
  //       const pcpp::IndexIntervalType &haloExtent(*extentIt++);
  //       pcpp::IndexIntervalType haloCollision(haloExtent.Overlap(commExtent));
  //       if(!haloCollision.empty()){
  //             numHalos++;
  //             haloIndex = hIndex;
  //             haloExtent.GetFlatIndices(commExtent,recvIndices);
  //             assert(recvIndices.size() == nNodes);
  //       }
  //     }
  //     // each communication extent should collide
  //     // with one and only one halo
  //     assert(numHalos == 1);

  //     // Report to the user
  //     std::ostringstream Ostr;
  //     Ostr << "Creating buffer for recv(" << remoteRank << "): ";
  //     commExtent.PrettyPrint(Ostr);
  //     Ostr << " " << nNodes  << " nodes in the " 
  //          << haloIndex << " grid direction." << std::endl;
  //     StdOut(Ostr.str(),3);
  //   }

  // };

  // ///
  // /// @brief Create communication buffers for solution transfers
  // /// 
  // /// This function looks at the configured field data, 
  // /// separates the configured fields into simulation-wide
  // /// or grid-bound data, and then allocates data buffers
  // /// to store the data. Each field buffer is contiguous,
  // /// and is independent of storage policy.
  // int plascom2::CreateCommunicationBuffers()
  // {

  //   FunctionEntry("CreateCommBuffers");
  //   if(computeProcess){

  //     pcpp::geometry::domaininfo domainInfo(plascomDomain.Info());
  //     std::vector<std::string>::iterator geomNameIt = domainInfo.geometryNames.begin();
  //     pcpp::geometry::domain::iterator domIt = plascomDomain.begin();
  //     while(domIt != plascomDomain.end()){
      
  //       int gridIndex = domIt - plascomDomain.begin();
  //       std::string geomName(*geomNameIt++);
  //       pcpp::geometry::grid &currentGrid(*domIt++);
  //       pcpp::geometry::gridinfo &gridInfo(currentGrid.Info());
  //       if(gridInfo.numDimensions <= 0)
  //         continue;
  //       pcpp::simulation::topologyinfo &gridTopo(gridTopology[gridIndex]);
      
  //       std::vector<int> &gridSize(gridInfo.globalSize);
  //       std::vector<int> &localSize(gridInfo.localSize);
  //       std::vector<int> &localStart(gridInfo.localStart);
  //       int gridDimension = gridSize.size();
  //       pcpp::IndexIntervalType gridExtent(localStart,localSize);
  //       std::vector<pcpp::IndexIntervalType> &haloExtents(gridTopo.haloExtents);

  //       std::ostringstream Ostr;
  //       // Ostr << "Grid Extent: ";
  //       // gridExtent.PrettyPrint(Ostr);
  //       // Ostr << std::endl
  //       //            << "Halo Extents:" << std::endl;
  //       // std::vector<pcpp::IndexIntervalType>::iterator haloIt = haloExtents.begin();
  //       // while(haloIt != haloExtents.end()){
  //       //         haloIt++->PrettyPrint(Ostr);
  //       //         Ostr << std::endl;
  //       // }
  //       // StdOut(Ostr.str(),3);
  //       // pcpp::io::RenewStream(Ostr);

  //       bool gridOK = true;
  //       if(gridDimension == 0)
  //         gridOK = false;
  //       std::vector<int>::iterator gsIt = gridSize.begin();
  //       while(gsIt != gridSize.end())
  //         if(*gsIt++ == 0)
  //           gridOK = false;
  //       if(!gridOK){
  //         continue;
  //       }
      
  //       int collisionExtentSize = gridDimension*2;
  //       int collisionCommSize   = collisionExtentSize+1;
      
  //       // computeCommunicator.Barrier();
  //       // std::cout << computeCommunicator.Rank() << " here grid "
  //       //                 << gridIndex << std::endl;
  //       // computeCommunicator.Barrier();

  //       std::vector<pcpp::RemoteCollisionType> &interComputeRecv(gridTopo.interComputeRecv[0]);
  //       std::vector<pcpp::RemoteCollisionType> &interComputeSend(gridTopo.interComputeSend[0]);
  //       std::vector<pcpp::RemoteCollisionType> &intraComputeRecv(gridTopo.intraComputeRecv[0]);
  //       std::vector<pcpp::RemoteCollisionType> &intraComputeSend(gridTopo.intraComputeSend[0]);
      
  //       pcpp::simulation::solutiondata &currentSoln(currentGrid.Solution());
  //       pcpp::simulation::solutionmetadata &currentMeta(currentSoln.Meta());
      
  //       // computeCommunicator.Barrier();
  //       // std::cout << computeCommunicator.Rank() << " preparing buffers." 
  //       //                 << std::endl;
  //       // computeCommunicator.Barrier();

  //       Ostr << "InterComputeSend Size: " << interComputeSend.size() << std::endl
  //                   << "IntraComputeSend Size: " << intraComputeSend.size() << std::endl;
  //       StdOut(Ostr.str(),3);
  //       pcpp::io::RenewStream(Ostr);      

  //       // computeCommunicator.Barrier();
  //       // std::cout << computeCommunicator.Rank() << " preparing buffers for real yo." 
  //       //                 << std::endl;
  //       // computeCommunicator.Barrier();


  //       //      computeCommunicator.Barrier();
  //       CreateSendData(currentMeta,gridExtent,intraComputeSend,
  //                      currentGrid.IntraSendData(),currentGrid.IntraSendIndices());
  //       CreateSendData(currentMeta,gridExtent,interComputeSend,
  //                      currentGrid.InterSendData(),currentGrid.InterSendIndices());

  //       Ostr << "InterComputeRecv Size: " << interComputeRecv.size() << std::endl
  //                  << "IntraComputeRecv Size: " << intraComputeRecv.size() << std::endl;
  //       StdOut(Ostr.str(),3);
  //       pcpp::io::RenewStream(Ostr);
  //       CreateRecvData(currentMeta,haloExtents,interComputeRecv,currentGrid.InterRecvData(),
  //                             currentGrid.InterRecvIndices());
  //       CreateRecvData(currentMeta,haloExtents,intraComputeRecv,currentGrid.IntraRecvData(),
  //                            currentGrid.IntraRecvIndices());
      
  //     }
  //   } 
  //   FunctionExit("CreateCommBuffers");
  //   return(0);
  // }


}