TestState.C

Go to the documentation of this file.

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

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

  bool defaultConstructor = true;
  simulation::state::base testState;
  if(testState.NumStateVar() != 0)
    defaultConstructor = false;
  if(!(testState.StateFieldIndices().empty()))
    defaultConstructor = false;
  if(!(testState.NumMeta() == 0))
    defaultConstructor = false;
  if(!(testState.NumData() == 0))
    defaultConstructor = false;

  int numFields = 4;
  int numStateFields = 2;
  int numStateVar = 4;

  bool addField = true;
  testState.AddField("simulationScalar",'s',1,8,"simunit");
  testState.AddField("gridScalar",'g',1,8,"gridunit");
  testState.AddField("nodeScalar",'n',1,8,"nodeunit");
  testState.AddField("nodeVector",'n',3,8,"nodeunit");

  std::vector<std::string> myStateFieldNames(numStateFields);
  myStateFieldNames[0] = "nodeScalar";
  myStateFieldNames[1] = "nodeVector";

  if(testState.NumMeta() != numFields)
    addField = false;
  if(testState.NumData() != 0)
    addField = false;

  bool statePrepare = true;
  testState.Prepare();
  if(testState.NumData() != numFields )
    statePrepare = false;
  for(int iField = 0;iField < numFields;iField++)
    if(!testState.FieldEmpty(iField))
      statePrepare = false;
  
  bool setFieldBuffer = true;
  std::vector<double> simScalarVec(1,-107.0);
  testState.SetFieldBuffer("simulationScalar",simScalarVec);
  double *bufPtr = &simScalarVec[0]; 
  simulation::state::base::DataBufferType 
    &simScalarField(testState.Field("simulationScalar"));
  double *simScalarData = simScalarField.Data<double>();
  std::vector<double> nodeScalarVec(1,0.0);
  testState.SetFieldBuffer("nodeScalar",nodeScalarVec);
  simulation::state::base::DataBufferType 
    &nodeScalarField(testState.Field("nodeScalar"));
  std::vector<double> nodeVectorVec(3,1.0);
  testState.SetFieldBuffer("nodeVector",nodeVectorVec);
  simulation::state::base::DataBufferType 
    &nodeVectorField(testState.Field("nodeVector"));

  double *nodeScalarPtr  = &nodeScalarVec[0];
  double *nodeVectorPtr  = &nodeVectorVec[0];
  double *stateScalarBuf =  nodeScalarField.Data<double>();
  double *stateVectorBuf =  nodeVectorField.Data<double>();
  if( simScalarData != bufPtr ||
      nodeScalarPtr != stateScalarBuf ||
      nodeVectorPtr != stateVectorBuf)
    setFieldBuffer = false;
  

  // Set state fields in various ways
  bool setStateFieldsByID = true;
  std::vector<int> stateFieldIDs(numStateFields,2);
  stateFieldIDs[1] = 3;
  int numAccepted = testState.SetStateFields(stateFieldIDs);
  if(numAccepted != numStateFields){
    std::cout << "Number of fields accepted != number of fields"
              << std::endl;
    setStateFieldsByID = false;
  }

  std::vector<std::string> stateFieldNames(testState.GetStateFieldNames());
  if(stateFieldNames != myStateFieldNames){
    std::cout << "State field names don't match." << std::endl;
    setStateFieldsByID = false;
    std::cout << "State names: " << std::endl;
    std::vector<std::string>::iterator nameIt = stateFieldNames.begin();
    std::vector<std::string>::iterator nameIt2 = myStateFieldNames.begin();
    while(nameIt != stateFieldNames.end())
      std::cout << "'" << *nameIt++  << "' != '" 
                << *nameIt2++ << "'" << std::endl;
  }
  // -- test if state field setting failed
  if(testState.NumStateFields() != numStateFields){
    std::cout << "Number of fields not right." << std::endl;
    setStateFieldsByID = false;
  }
  if(testState.NumStateVar() != numStateVar){
    std::cout << "Number of state variables not right." << std::endl;
    setStateFieldsByID = false;
  }
  if(stateFieldNames.size() != numStateFields){
    std::cout << "Number of state field names unright." << std::endl;
    setStateFieldsByID = false;
  }
  
  bool getStateFieldData = true;
  bool getStateDataByName = true;
  double *stateScalarFieldData  = testState.GetStateFieldData(0);
  double *stateVectorFieldData  = testState.GetStateFieldData(1);
  double *stateVectorFieldData2 = testState.GetStateFieldData("nodeVector"); 
  if(stateScalarFieldData != nodeScalarPtr)
    getStateFieldData = false;
  if(stateVectorFieldData != nodeVectorPtr)
    getStateFieldData = false;
  if(stateVectorFieldData2 != nodeVectorPtr)
    getStateDataByName = false;
  
  bool setStateFieldsByName = true;
  numAccepted = testState.SetStateFields(myStateFieldNames);
  if(numAccepted != numStateFields)
    setStateFieldsByName = false;
  stateFieldNames = testState.GetStateFieldNames();
  stateScalarFieldData = testState.GetStateFieldData(0);
  stateVectorFieldData = testState.GetStateFieldData(1);
  if(stateScalarFieldData != nodeScalarPtr)
    setStateFieldsByName = false;
  if(stateVectorFieldData != nodeVectorPtr)
    setStateFieldsByName = false;
  if(testState.NumStateFields() != numStateFields)
    setStateFieldsByName = false;
  if(testState.NumStateVar() != numStateVar)
    setStateFieldsByName = false;
  if(stateFieldNames.size() != numStateFields)
    setStateFieldsByName = false;
  if(stateFieldNames != myStateFieldNames)
    setStateFieldsByName = false;
  

  bool setStateFieldsByList = true;
  std::string nameList("nodeScalar nodeVector");
  numAccepted = testState.SetStateFields(nameList);
  if(numAccepted != numStateFields)
    setStateFieldsByList = false;
  stateFieldNames = testState.GetStateFieldNames();
  stateScalarFieldData = testState.GetStateFieldData(0);
  stateVectorFieldData = testState.GetStateFieldData(1);
  stateVectorFieldData2 = testState.GetStateFieldData("nodeVector");
  if(stateVectorFieldData2 != nodeVectorPtr)
    getStateDataByName = false;
  if(stateScalarFieldData != nodeScalarPtr)
    setStateFieldsByList = false;
  if(stateVectorFieldData != nodeVectorPtr)
    getStateFieldData = false;
  if(testState.NumStateFields() != numStateFields)
    setStateFieldsByList = false;
  if(testState.NumStateVar() != numStateVar)
    setStateFieldsByList = false;
  if(stateFieldNames.size() != numStateFields)
    setStateFieldsByList = false;
  if(stateFieldNames != myStateFieldNames)
    setStateFieldsByList = false;

  serialUnitResults.UpdateResult("State:DefaultConstructor",defaultConstructor);
  serialUnitResults.UpdateResult("State:AddField",addField);
  serialUnitResults.UpdateResult("State:Prepare",statePrepare);
  serialUnitResults.UpdateResult("State:SetFieldBuffer",setFieldBuffer);
  serialUnitResults.UpdateResult("State:SetStateFieldIDs",setStateFieldsByID);
  serialUnitResults.UpdateResult("State:SetStateFieldNames",setStateFieldsByName);
  serialUnitResults.UpdateResult("State:SetStateFieldList",setStateFieldsByList);
  serialUnitResults.UpdateResult("State:GetStateDataByID",getStateFieldData);
  serialUnitResults.UpdateResult("State:GetStateDataByName",getStateDataByName);

}

void TestStateOperations(ix::test::results &serialUnitResults) {
  
  using namespace operators;
  
  typedef simulation::state::base StateType;

  // Create the fields in the state object
  StateType testState1;
  StateType testState2;
  testState1.AddField("b1",'n',1,8,"simunit");
  testState1.AddField("b2",'n',1,8,"simunit");
  testState1.AddField("b3",'n',1,8,"simunit");
  testState1.AddField("b4",'n',3,8,"simunit");
  testState2.AddField("b1",'n',1,8,"simunit");
  testState2.AddField("b2",'n',1,8,"simunit");
  testState2.AddField("b3",'n',1,8,"simunit");
  testState2.AddField("b4",'n',3,8,"simunit");
  testState1.Prepare();
  testState2.Prepare();

  // Set the state data buffers
  std::vector<double> buffer10(2,0);
  std::vector<double> buffer11(2,1);
  std::vector<double> buffer12(2,2);
  std::vector<double> vector1(6,32);
  for(int ivec = 3;ivec < 6;ivec++)
    vector1[ivec] = 64;
  std::vector<double> buffer20(2,4);
  std::vector<double> buffer21(2,8);
  std::vector<double> buffer22(2,16);
  std::vector<double> vector2(6,128);
  for(int ivec = 3;ivec < 6;ivec++)
    vector2[ivec] = 256;

  testState1.SetFieldBuffer("b1",buffer10);
  testState1.SetFieldBuffer("b2",buffer11);
  testState1.SetFieldBuffer("b3",buffer12);
  testState1.SetFieldBuffer("b4",vector1);
  testState2.SetFieldBuffer("b1",buffer20);
  testState2.SetFieldBuffer("b2",buffer21);
  testState2.SetFieldBuffer("b3",buffer22);
  testState2.SetFieldBuffer("b4",vector2);

  // Tell the states which of their fields
  // are state variables
  std::vector<int> stateFieldIndices(4,0);
  stateFieldIndices[1] = 1;
  stateFieldIndices[2] = 2;
  stateFieldIndices[3] = 3;
  testState1.SetStateFields(stateFieldIndices);
  testState2.SetStateFields(stateFieldIndices);

  // Test aX + Y (result in Y)
  bool axpy_works = true;
  AXPY(1.0,testState1,testState2);
  if(buffer20[0] != 4    || buffer20[1] !=  4   ||
     buffer21[0] != 9    || buffer21[1] !=  9   ||
     buffer22[0] != 18   || buffer22[1] != 18   ||
     vector2[0]  != 160  || vector2[1]  != 160  ||
     vector2[2]  != 160  || vector2[3]  != 320  ||
     vector2[4]  != 320  || vector2[5]  != 320)
    axpy_works = false;

  bool zero_works = true;
  Zero(testState2);
  if(buffer20[0] != 0  || buffer20[1] !=  0 ||
     buffer21[0] != 0  || buffer21[1] !=  0 ||
     buffer22[0] != 0  || buffer22[1] !=  0 ||
     vector2[0]  != 0  || vector2[1]  !=  0 ||
     vector2[2]  != 0  || vector2[3]  !=  0 ||
     vector2[4]  != 0  || vector2[5]  !=  0)
    zero_works = false;

  bool assignment_works = false;
  Assign(testState1,testState2); 

  // Note that assignment necessarily dissociates the 
  // target state from the previous buffer and allocates
  // a new one. After assignment, the new values are copied
  // back into the local vector.
  double *b1Buf = testState2.Field("b1").Data<double>();
  double *b2Buf = testState2.Field("b2").Data<double>();
  double *b3Buf = testState2.Field("b3").Data<double>();
  double *b4Buf = testState2.Field("b4").Data<double>();
  buffer20.assign(b1Buf,b1Buf+2);
  buffer21.assign(b2Buf,b2Buf+2);
  buffer22.assign(b3Buf,b3Buf+2);
  vector2.assign(b4Buf,b4Buf+6);
  if(buffer20 == buffer10 &&
     buffer21 == buffer11 &&
     buffer22 == buffer12 &&
     vector2  == vector1)
    assignment_works = true;

      
  bool scalarMultiply_works = false;
  StateType testState3(2.0*testState1);
  b1Buf = testState3.Field("b1").Data<double>();
  b2Buf = testState3.Field("b2").Data<double>();
  b3Buf = testState3.Field("b3").Data<double>();
  b4Buf = testState3.Field("b4").Data<double>();
  buffer20.assign(b1Buf,b1Buf+2);
  buffer21.assign(b2Buf,b2Buf+2);
  buffer22.assign(b3Buf,b3Buf+2);     
  vector2.assign(b4Buf,b4Buf+6);
  if(buffer20[0] == 2.0*buffer10[0] &&
     buffer20[1] == 2.0*buffer10[1] &&
     buffer21[0] == 2.0*buffer11[0] &&
     buffer21[1] == 2.0*buffer11[1] &&
     buffer22[0] == 2.0*buffer12[0] &&
     buffer22[1] == 2.0*buffer12[1] &&
     vector2[0]  == 2.0*vector1[0]  &&
     vector2[1]  == 2.0*vector1[1]  &&
     vector2[2]  == 2.0*vector1[2]  &&
     vector2[3]  == 2.0*vector1[3]  &&
     vector2[4]  == 2.0*vector1[4]  &&
     vector2[5]  == 2.0*vector1[5])
    scalarMultiply_works = true;

  bool sum_works = false;
  StateType testState4(Sum(testState3,testState1));
  b1Buf = testState4.Field("b1").Data<double>();
  b2Buf = testState4.Field("b2").Data<double>();
  b3Buf = testState4.Field("b3").Data<double>();
  b4Buf = testState4.Field("b4").Data<double>();
  buffer20.assign(b1Buf,b1Buf+2);
  buffer21.assign(b2Buf,b2Buf+2);
  buffer22.assign(b3Buf,b3Buf+2);     
  vector2.assign(b4Buf,b4Buf+6);
  if(buffer20[0] == 3.0*buffer10[0] &&
     buffer20[1] == 3.0*buffer10[1] &&
     buffer21[0] == 3.0*buffer11[0] &&
     buffer21[1] == 3.0*buffer11[1] &&
     buffer22[0] == 3.0*buffer12[0] &&
     buffer22[1] == 3.0*buffer12[1] &&
     vector2[0]  == 3.0*vector1[0]  &&
     vector2[1]  == 3.0*vector1[1]  &&
     vector2[2]  == 3.0*vector1[2]  &&
     vector2[3]  == 3.0*vector1[3]  &&
     vector2[4]  == 3.0*vector1[4]  &&
     vector2[5]  == 3.0*vector1[5])
    sum_works = true;


  bool difference_works = false;
  StateType testState5(Difference(testState3,testState4));
  b1Buf = testState5.Field("b1").Data<double>();
  b2Buf = testState5.Field("b2").Data<double>();
  b3Buf = testState5.Field("b3").Data<double>();
  b4Buf = testState5.Field("b4").Data<double>();
  buffer20.assign(b1Buf,b1Buf+2);
  buffer21.assign(b2Buf,b2Buf+2);
  buffer22.assign(b3Buf,b3Buf+2);     
  vector2.assign(b4Buf,b4Buf+6);
  if(buffer20[0] == buffer10[0] &&
     buffer20[1] == buffer10[1] &&
     buffer21[0] == buffer11[0] &&
     buffer21[1] == buffer11[1] &&
     buffer22[0] == buffer12[0] &&
     buffer22[1] == buffer12[1] &&
     vector2[0]  == vector1[0]  &&
     vector2[1]  == vector1[1]  &&
     vector2[2]  == vector1[2]  &&
     vector2[3]  == vector1[3]  &&
     vector2[4]  == vector1[4]  &&
     vector2[5]  == vector1[5])
    difference_works = true;

  serialUnitResults.UpdateResult("State:AXPY",axpy_works);
  serialUnitResults.UpdateResult("State:Zero",zero_works);
  serialUnitResults.UpdateResult("State:Assignment",assignment_works);
  serialUnitResults.UpdateResult("State:ScalarMultiply",scalarMultiply_works);
  serialUnitResults.UpdateResult("State:Sum",sum_works);
  serialUnitResults.UpdateResult("State:Difference",difference_works);

}

void TestStateMetaData(ix::test::results &serialUnitResults) 
{
  
};

void TestStateHandles(ix::test::results &serialUnitResults) 
{
  typedef simulation::state::base StateType;

  bool testFieldHandles = true;

  StateType testState1;
  StateType testState2;

  testState1.AddField("b1",'n',1,8,"simunit");
  testState1.AddField("b2",'n',2,8,"simunit");
  testState1.AddField("b3",'n',3,8,"simunit");
  testState1.AddField("b4",'n',4,8,"simunit");
  
  if(testState1.InitializeFieldHandles()){
    std::cout << "InitializeFieldHandles failed." << std::endl;
    testFieldHandles = false;
  }
  
  testState1.Create(100,0);
  
  int b1Handle = testState1.GetFieldHandle("b1");
  
  if(b1Handle < 0)
    testFieldHandles = false;
  if(b1Handle != 0)
    testFieldHandles = false;

  serialUnitResults.UpdateResult("State:GetFieldHandle",testFieldHandles);
  
  int dataIndex = testState1.GetDataIndex("b1");
  pcpp::field::dataset::DataBufferType &b1DataByIndex(testState1.Field(dataIndex));
  double *b1PtrByIndex = b1DataByIndex.Data<double>();

  bool getFieldDataByHandle = true;
  pcpp::field::dataset::DataBufferType &b1Data(testState1.GetFieldDataByHandle(b1Handle));
  double *b1PtrByHandle = b1Data.Data<double>();
  if(b1PtrByHandle != b1PtrByIndex)
    getFieldDataByHandle = false;

  serialUnitResults.UpdateResult("State:GetFieldDataByHandle",getFieldDataByHandle);

  bool getFieldMetaDataByHandle = true;
  const pcpp::field::dataset::MetaDataType &fieldMetaData
    (testState1.GetFieldMetaData(dataIndex));
  
  const pcpp::field::dataset::MetaDataType &fieldMetaDataByHandle
    (testState1.GetFieldMetaDataByHandle(b1Handle));
  
  if(fieldMetaData != fieldMetaDataByHandle)
    getFieldMetaDataByHandle = false;
  
  serialUnitResults.UpdateResult("State:GetFieldMetaDataByHandle",getFieldMetaDataByHandle);

  const std::string copyFields("b3 b4");
  testState2.Copy(testState1,copyFields);
  
  bool copyStateHandles = true;

  int b3Handle  = testState1.GetFieldHandle("b3");
  int b3Handle2 = testState2.GetFieldHandle("b3");
  dataIndex = testState2.GetDataIndex("b3");
  if(b3Handle != b3Handle2){
    copyStateHandles = false;
    std::cout << "B3 Handle      = " << b3Handle  << std::endl
              << "B3 Copy Handle = " << b3Handle2 << std::endl;
  }
  if(dataIndex != 0){
    copyStateHandles = false;
    std::cout << "Copied b3 index = " << dataIndex << std::endl;
  }
  
  
  serialUnitResults.UpdateResult("State:CopyStateHandles",copyStateHandles);
  

  return;
};