TestProbe.C

Go to the documentation of this file.

#include "Testing.H"
#include "Simulation.H"

void TestProbe(ix::test::results &serialUnitResults){

  
  // ======= Set up some test data =======
  simulation::state::base testState1;
  simulation::state::base testState2;
  
  size_t numX = 10;
  size_t numY = 10;
  size_t numZ = 10;
  size_t numNodes = numX*numY*numZ;
  
  // unitless scalar test field at nodes
  testState1.AddField("U",'n',1,8,"");
  testState1.AddField("W",'n',1,8,"");
  testState2.AddField("Z",'n',2,8,"");
  
  // create buffer(s) for numNodes nodes , 0 cells 
  testState1.Create(1000,0);
  testState2.Create(1000,0);
  
  // testing data, init'd to 0.0
  std::vector<double> uVector(1000,0.0);
  std::vector<double> wVector(1000,0.0);
  std::vector<double> zVector(2000,0.0);
  // Replace state buffers with this local array 
  testState1.SetFieldBuffer("U",&uVector[0]);
  testState1.SetFieldBuffer("W",&wVector[0]);
  testState2.SetFieldBuffer("Z",&zVector[0]);
  
  // Initialize state data simply to node index
  for(size_t iNode = 0;iNode < numNodes;iNode++){
    uVector[iNode] = static_cast<double>(iNode);
    wVector[iNode] = static_cast<double>(iNode+numNodes);
    zVector[iNode] = static_cast<double>(iNode+2*numNodes);
    zVector[iNode+numNodes] = static_cast<double>(iNode+3*numNodes);
  }
  
  // Create grid Interval to define the shape of the data
  pcpp::IndexIntervalType gridInterval;
  std::vector<size_t> gridSize(3,0);
  gridSize[0]  = numX;
  gridSize[1]  = numY;
  gridSize[2]  = numZ;
  gridInterval.InitSimple(gridSize);
  
  // Create an interval for the probe - this will
  // indicate where the state should be probed
  pcpp::IndexIntervalType probeInterval;
  std::vector<size_t> probeStart(3,5);
  probeStart[0] = 0;
  std::vector<size_t> probeSize(3,1);
  probeSize[0] = 10;
  probeInterval.Init(probeStart,probeSize);
  
  std::vector<std::string> probeFieldNames;
  probeFieldNames.push_back("U");
  // ------------ Set up done ----------------

  // ======== Tests for probes ===============

  bool probeDefaultConstructor = true;
  simulation::state::probe myProbe;
  serialUnitResults.UpdateResult("Probe:DefaultConstructor",probeDefaultConstructor);
  
  // Tell the probe the shape of the data array
  myProbe.SetDataInterval(gridInterval);
  // Set the shape of the probe
  myProbe.SetProbeInterval(probeInterval);
  // Tell the probe which fields to probe
  myProbe.SetProbeFields(probeFieldNames);
  // Set the state to probe
  myProbe.SetState(testState1);
  
  bool probeWorks = true;
  std::ostringstream probeStream;
  int errorCode = myProbe.Probe(probeStream);
  if(errorCode){
    std::cout << "Probe returned error code: " << errorCode << std::endl;
    probeWorks = false;
  }
  if(!probeWorks)
    return;

  // The probeStream should now contain a string of values
  // that are the values of the state at the probe locations.
  // Check that this is true.
  bool probeScalarField = true;
  if(probeWorks){
    std::istringstream probeInStream(probeStream.str());
    // There is a more convenient way to do the loop below using Intervals. Check out the 
    // next test for an example.
    for(size_t probeZ = probeInterval[2].first;probeZ <= probeInterval[2].second;probeZ++){
      size_t zDataIndex = probeZ*numX*numY;
      for(size_t probeY = probeInterval[1].first;probeY <= probeInterval[1].second;probeY++){
        size_t yDataIndex = zDataIndex + probeY*numX;
        for(size_t probeX = probeInterval[0].first;probeX <= probeInterval[0].second;probeX++){
          size_t stateDataIndex = yDataIndex + probeX;
          double probeValue;
          probeInStream >> probeValue;
          if(probeValue != uVector[stateDataIndex])
            probeScalarField = false;
        }
      }
    }
  }
  pcpp::io::RenewStream(probeStream);
  if(!probeScalarField)
    return;
  serialUnitResults.UpdateResult("Probe:ProbeScalarField",probeScalarField);
  
  // This test will indicate both whether switching fields, and
  // probing vector fields work
  bool switchProbeField = true;
  bool probeVectorField = true;
  bool detectWrongField = true;

  // get the flat array indices for the probe data for more
  // convenient access than a triple nested loop
  std::vector<size_t> probeDataIndices;
  gridInterval.GetFlatIndices(probeInterval,probeDataIndices);
  size_t numProbeNodes = probeDataIndices.size();

  if(probeScalarField){
    // attempt to probe field U out of testState2, which has
    // only vector field Z.
    int errorCode = myProbe.Probe(testState2,probeStream);
    if(errorCode != 2)
      detectWrongField = false;
    // let's probe the correct field now (it's a vector field)
    probeFieldNames[0] = "Z";
    myProbe.SetProbeFields(probeFieldNames);
    errorCode = myProbe.Probe(probeStream);
    if(errorCode){
      switchProbeField = false;
      return;
    }
    serialUnitResults.UpdateResult("Probe:SwitchProbeField",switchProbeField);
    std::istringstream probeInStream(probeStream.str());
    for(size_t iNode = 0;iNode < numProbeNodes;iNode++){
      double probeComp1, probeComp2;
      size_t probeDataIndex = probeDataIndices[iNode];
      probeInStream >> probeComp1 >> probeComp2;
      if(probeComp1 != zVector[probeDataIndex] &&
         probeComp2 != zVector[probeDataIndex+numNodes])
        probeVectorField = false;
    }
    if(!probeVectorField)
      return;
    serialUnitResults.UpdateResult("Probe:ProbeVectorField",probeVectorField);
    pcpp::io::RenewStream(probeStream);
  }
  if(probeVectorField){
    bool probeMultipleFields = true;
    probeFieldNames[0] = "W";
    probeFieldNames.push_back("U");
    myProbe.SetProbeFields(probeFieldNames);
    errorCode = myProbe.Probe(testState1,probeStream);
    if(errorCode){
      std::cout << "Probe returned errorcode = " << errorCode << std::endl;
      probeMultipleFields = false;
      return;
    }
    std::istringstream probeInStream(probeStream.str());
    for(size_t iNode = 0;iNode < numProbeNodes;iNode++){
      double probeFieldW, probeFieldU;
      size_t probeDataIndex = probeDataIndices[iNode];
      probeInStream >> probeFieldW >> probeFieldU;
      if(probeFieldW != wVector[probeDataIndex] &&
         probeFieldU != uVector[probeDataIndex])
        probeMultipleFields = false;
    }
    if(!probeMultipleFields)
      return;
    serialUnitResults.UpdateResult("Probe:ProbeMultipleFields",probeMultipleFields);
    pcpp::io::RenewStream(probeStream);
  }
  serialUnitResults.UpdateResult("Probe:Works",probeWorks);
}