TestIntervals.C

Go to the documentation of this file.

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

void TestIntervalBasic(ix::test::results &serialUnitResults) {
      
      size_t Nx = 100;
      size_t Ny = 100;
      size_t Nz = 100;

      
      std::vector<size_t> NX(3,100);
      pcpp::IndexIntervalType globalExtent;
      globalExtent.InitSimple(NX);

      bool initSimple(globalExtent[0].first  == 0  &&
                      globalExtent[1].first  == 0  &&
                      globalExtent[2].first  == 0  &&
                      globalExtent[0].second == 99 &&
                      globalExtent[1].second == 99 &&
                      globalExtent[2].second == 99 &&
                      globalExtent.NNodes() == 1000000);
      
      serialUnitResults.UpdateResult("PCPP:Interval:SimpleInit",initSimple);
      
      size_t numX = 10;
      size_t numLeftOver = 0;
      
      size_t firstXIndex = 0;
      size_t lastXIndex  = 9;

      size_t numNodesLocal  = 100000;
      size_t numNodesGlobal = 1000000;

      std::vector<size_t> flatExtent;
      flatExtent.resize(6,0);
      flatExtent[0] = firstXIndex;
      flatExtent[1] = lastXIndex;
      flatExtent[3] = flatExtent[5] = 99;
      
      pcpp::IndexIntervalType localExtent(flatExtent);

      bool flatConstructor = true;
      if(localExtent.size() != 3)
        flatConstructor = false;
      if(!(localExtent[0].first  == firstXIndex &&
           localExtent[0].second == lastXIndex  &&
           localExtent[1].first  == 0           &&
           localExtent[2].first  == 0           &&
           localExtent[1].second == 99          &&
           localExtent[2].second == 99))
        flatConstructor = false;

      bool copyConstructor = true;
      pcpp::IndexIntervalType copyExtent(localExtent);
      if(copyExtent != localExtent)
        copyConstructor = false;

      bool nodeCount = true;
      if(copyExtent.NNodes() != numNodesLocal)
        nodeCount = false;

  
      bool overlapWorks = true;
      pcpp::IndexIntervalType overlapExtent(localExtent.Overlap(copyExtent));
      if(overlapExtent != copyExtent)
        overlapWorks = false;
      
      std::vector<size_t> disparateStart(3,100);
      std::vector<size_t> disparateNum(3,100);
      bool startSizeConstructor = true;
      pcpp::IndexIntervalType disparateExtent(disparateStart,disparateNum);
      if(!(disparateExtent[0].first  == 100 &&
           disparateExtent[1].first  == 100 &&
           disparateExtent[2].first  == 100 &&
           disparateExtent[0].second == 199 &&
           disparateExtent[1].second == 199 &&
           disparateExtent[2].second == 199))
        startSizeConstructor = false;

      bool noOverlapWorks = true;
      pcpp::IndexIntervalType zeroOverlapExtent(localExtent.Overlap(disparateExtent));
      if(!zeroOverlapExtent.empty())
        noOverlapWorks = false;
                
      std::vector<size_t> simpleSizes(3,10);
      simpleSizes[1] = 1000;
      simpleSizes[2] = 1000;
      zeroOverlapExtent.InitSimple(simpleSizes);
            
      pcpp::IndexIntervalType overlapExtent2(localExtent.Overlap(zeroOverlapExtent));
      if(overlapExtent2 != localExtent)
        overlapWorks = false;

      
      simpleSizes[1] = 10;
      simpleSizes[2] = 10;
      zeroOverlapExtent.InitSimple(simpleSizes);
      overlapExtent2.Copy(localExtent.Overlap(zeroOverlapExtent));
      bool copyWorks(overlapExtent2 == localExtent.Overlap(zeroOverlapExtent));

      if(overlapExtent2.NNodes() != 1000)
        overlapWorks = false;
      if(overlapExtent2 != zeroOverlapExtent)
        overlapWorks = false;
      
      std::vector<size_t> overlapIndices;
      globalExtent.GetFlatIndices(overlapExtent2,overlapIndices);
      bool overlapFlatIndices(overlapIndices.size() == 1000);
      if(!(overlapIndices[0]  == 0 &&
           overlapIndices[9]  == 9   &&
           overlapIndices[10] == 100 &&
           overlapIndices[19] == 109 &&
           overlapIndices[999] == 90909))
        overlapFlatIndices = false;
      
      

      std::vector<size_t> testSize(3,10);
      std::vector<size_t> testStart1(3,10);
      pcpp::IndexIntervalType smallCube1(testStart1,testSize);
      std::vector<size_t> testStart2(3,15);
      pcpp::IndexIntervalType smallCube2(testStart2,testSize);
      pcpp::IndexIntervalType cubeOverlap12(smallCube1.Overlap(smallCube2));
      pcpp::IndexIntervalType cubeOverlap21(smallCube2.Overlap(smallCube1));
      if(cubeOverlap12 != cubeOverlap21)
        overlapWorks = false;
      if(!(cubeOverlap12[0].first  == 15 &&
           cubeOverlap12[1].first  == 15 && 
           cubeOverlap12[2].first  == 15 &&
           cubeOverlap12[0].second == 19 &&
           cubeOverlap12[1].second == 19 &&
           cubeOverlap12[2].second == 19))
        overlapWorks = false;
      std::vector<size_t> flatIndices1;
      std::vector<size_t> flatIndices2;
      smallCube1.GetFlatIndices(cubeOverlap12,flatIndices1);
      smallCube2.GetFlatIndices(cubeOverlap12,flatIndices2);
      if(flatIndices1.size() != 125 ||
         flatIndices2.size() != 125)
        overlapFlatIndices = false;
      std::vector<size_t>::iterator f1It = flatIndices1.begin(); 
      for(size_t k = 15;k < 20;k++){
        size_t zInd = k - 10;
        for(size_t j = 15;j < 20;j++){
          size_t yInd = j - 10;
          for(size_t i = 15;i < 20;i++){
            size_t xInd = i - 10;
            size_t linearIndex = zInd*100 + yInd*10 + xInd;
            if(*f1It++ != linearIndex)
              overlapFlatIndices = false;
          }
        }
      }
      std::vector<size_t>::iterator f2It = flatIndices2.begin();
      for(size_t k = 15;k < 20;k++){
        size_t zInd = k - 15;
        for(size_t j = 15;j < 20;j++){
          size_t yInd = j - 15;
          for(size_t i = 15;i < 20;i++){
            size_t xInd = i - 15;
            size_t linearIndex = zInd*100 + yInd*10 + xInd;
            if(*f2It++ != linearIndex)
              overlapFlatIndices = false;
          }
        }
      }
      
      std::vector<size_t> tinySize(3,4);
      std::vector<size_t> tinyStart1(3,0);
      pcpp::IndexIntervalType tinyCube1(tinyStart1,tinySize);

      std::vector<size_t> tinyStart2(3,10);
      tinyStart2[0] = 0;
      pcpp::IndexIntervalType tinyCube2(tinyStart2,tinySize);
      pcpp::IndexIntervalType tinyOverlap(tinyCube1.Overlap(tinyCube2));
      if(!tinyOverlap.empty())
        overlapWorks = false;

      bool overlap2DWorks = true;
      std::vector<size_t> tinyStart3(3,0);
      tinyStart3[0] = 3;
      pcpp::IndexIntervalType tinyCube3(tinyStart3,tinySize);
      pcpp::IndexIntervalType overlap2D(tinyCube1.Overlap(tinyCube3));
      std::vector<size_t> flatIndices2D;
      tinyCube1.GetFlatIndices(overlap2D,flatIndices2D);
      if(flatIndices2D.size() != 16)
        overlap2DWorks = false;
      std::vector<size_t>::iterator ind2DIt = flatIndices2D.begin();
      for(size_t k = 0;k < 4;k++){
        size_t zInd = k * 16;
        for(size_t j = 0;j < 4;j++){
          size_t yInd = j * 4;
          size_t linearIndex = zInd + yInd + 3;
          if(*ind2DIt++ != linearIndex)
            overlap2DWorks = false;
        }
      }

      bool overlap1DWorks = true;
      std::vector<size_t> tinyStart4(3,3);
      tinyStart4[2] = 0;
      pcpp::IndexIntervalType tinyCube4(tinyStart4,tinySize);
      pcpp::IndexIntervalType overlap1D(tinyCube1.Overlap(tinyCube4));
      std::vector<size_t> flatIndices1D;
      tinyCube1.GetFlatIndices(overlap1D,flatIndices1D);
      std::vector<size_t>::iterator ind1DIt = flatIndices1D.begin();
      if(flatIndices1D.size() != 4)
        overlap1DWorks = false;
      for(size_t k = 0;k < 4;k++){
        size_t zInd = k * 16;
        size_t linearIndex = zInd + 15;
          if(*ind1DIt++ != linearIndex)
            overlap1DWorks = false;
      }
     
      
      bool overlap0DWorks = true;
      std::vector<size_t> tinyStart5(3,3);
      pcpp::IndexIntervalType tinyCube5(tinyStart5,tinySize);
      pcpp::IndexIntervalType overlap0D(tinyCube1.Overlap(tinyCube5));
      std::vector<size_t> flatIndices0D;
      tinyCube1.GetFlatIndices(overlap0D,flatIndices0D);
      if(flatIndices0D.size() != 1)
        overlap0DWorks = false;
      if(flatIndices0D[0] != 63)
        overlap0DWorks = false;

      serialUnitResults.UpdateResult("PCPP:Interval:FlatConstructor",flatConstructor);
      serialUnitResults.UpdateResult("PCPP:Interval:CopyConstructor",copyConstructor);
      serialUnitResults.UpdateResult("PCPP:Interval:StartSizeConstructor",startSizeConstructor);
      serialUnitResults.UpdateResult("PCPP:Interval:Copy",copyWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:NodeCount",nodeCount);
      serialUnitResults.UpdateResult("PCPP:Interval:Overlap",overlapWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:2DOverlap",overlap2DWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:1DOverlap",overlap1DWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:0DOverlap",overlap0DWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:NoOverlap",noOverlapWorks);
      serialUnitResults.UpdateResult("PCPP:Interval:FlatIndices",overlapFlatIndices);
      
      std::vector<size_t> part1Start(3,0);
      std::vector<size_t> part1Size(3,8);
      part1Size[2] = 1;
      pcpp::IndexIntervalType part1Extent(part1Start,part1Size);
      std::vector<size_t> part2Start(3,8);
      part2Start[2] = 0;
      pcpp::IndexIntervalType part4Extent(part2Start,part1Size); 
      part2Start[1] = 0;
      pcpp::IndexIntervalType part2Extent(part2Start,part1Size);
      part1Size[1] = 3;
      pcpp::IndexIntervalType part6Extent(part2Start,part1Size);
      part2Start[0] = 0;
      part2Start[1] = 8;
      pcpp::IndexIntervalType part3Extent(part2Start,part1Size);
      part2Start[1] = 16;
      pcpp::IndexIntervalType part5Extent(part2Start,part1Size);
      std::cout << "Part1: ";
      part1Extent.PrettyPrint(std::cout);
      std::cout << std::endl << "Part2: ";
      part2Extent.PrettyPrint(std::cout);
      std::cout << std::endl << "Part3: ";
      part3Extent.PrettyPrint(std::cout);
      std::cout << std::endl << "Part4: ";
      part4Extent.PrettyPrint(std::cout);
      std::cout << std::endl << "Part5: ";
      part5Extent.PrettyPrint(std::cout);
      std::cout << std::endl;
      
      bool neighborWorks = true;
      pcpp::IndexIntervalType nbrExtent;
      nbrExtent = part1Extent.Neighboring(part2Extent,1);
      std::cout << "Nbr(1,2): ";
      nbrExtent.PrettyPrint(std::cout);
      std::cout << std::endl;
      if(nbrExtent != part2Extent)
        neighborWorks = false;
      nbrExtent = part1Extent.Neighboring(part3Extent,1);
      if(nbrExtent != part3Extent)
        neighborWorks = false;
      std::cout << "Nbr(1,3): ";
      nbrExtent.PrettyPrint(std::cout);
      std::cout << std::endl;
      nbrExtent = part1Extent.Neighboring(part4Extent,1);
      if(!nbrExtent.empty())
        neighborWorks = false;
      nbrExtent = part1Extent.Neighboring(part5Extent,1);
      if(!nbrExtent.empty())
        neighborWorks = false;
      nbrExtent = part1Extent.Neighboring(part1Extent,1);
      if(!nbrExtent.empty())
        neighborWorks = false;
      nbrExtent = part1Extent.Neighboring(part6Extent,1);
      if(nbrExtent != part6Extent)
        neighborWorks = false;
      
      serialUnitResults.UpdateResult("PCPP:Interval::Neighboring",neighborWorks);
}