PCPPFieldData.C

Go to the documentation of this file.

#include "PCPPFieldData.H"

namespace pcpp {

  namespace field {
    
    std::ostream &operator<<(std::ostream &Ostr,const 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, 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, metadata &md)
    {
      IStr >> md.name >> md.loc >> md.ncomp >> md.dsize >> md.unit;
      if(md.unit == "[NULL]")
        md.unit.erase();
      return(IStr);
    };

    std::istream &operator>>(std::istream &IStr, metadataset &mdSet)
    {
      mdSet.resize(0);
      int numData = 0;
      IStr >> numData;
      for(int iData = 0;iData < numData;iData++){
        metadata md;
        IStr >> md;
        if(md.ncomp > 0 && md.dsize > 0 && !md.name.empty())
          mdSet.push_back(md);
      }
      return(IStr);
    };
    
    std::ostream &operator<<(std::ostream &OStr,const metadata &md)
    {
      OStr << md.name << " " << md.loc << " " << md.ncomp << " " << md.dsize << " "
           << (md.unit.empty() ? "[NULL]" : md.unit);
      return(OStr);
    };
    
    std::ostream &operator<<(std::ostream &OStr,const metadataset &mdSet)
    {
      metadataset::const_iterator mdIt = mdSet.begin();
      OStr << mdSet.size() << std::endl;
      while(mdIt != mdSet.end()){
        const metadata &md(*mdIt++);
        OStr << md << std::endl;
      }
      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);
    // }


  }
}