virtual void Test__TransferLoadsToStructures ( ResultsType &  result )

inlinevirtual

Test for TransferLoadsToStructures() function.

Definition at line 1226 of file ElmerFoamFSITest.H.

References TestingObject< ResultsType >::__helper(), TestingObject< ResultsType >::avgCoord(), TestingObject< ResultsType >::componentInterfaceNames, elmeragent::Coordinates(), TestingObject< ResultsType >::fsiCoupler, fsicoupling::getFluidAgent(), fsicoupling::getFluidIntName(), fsicoupling::getRunMode(), fsicoupling::getSimulationFinalTime(), fsicoupling::getSimulationTime(), fsicoupling::getSolidIntName(), fsicoupling::getStructureAgent(), TestingObject< ResultsType >::global, fsicoupling::Initialize(), agentbase::InitializeTimeStep(), openfoamagent::Run(), fsicoupling::SetRunMode(), fsicoupling::SetVerbLevel(), fsicoupling::TransferDisplacementsToFluid(), fsicoupling::TransferLoadsToStructures(), and TestingObject< ResultsType >::verblevel.

Referenced by TestingObject< ResultsType >::Process(), and TestingObject< ResultsType >::RunTest().

                                                                     {
    
      double time_final = 0.05;
      double timestep = 2.0e-3;
      int verblevel = 3;
      bool works = true;
      int IntDir;

      // Copying the SimpleStatic data using getinputdata() helper function.
      bool work =__helper();
      std::string fluidDir;
      std::string simStaticDir;
      fluidDir = IRAD::Sys::CWD() + "/SimpleStatic/fluid";
      simStaticDir = IRAD::Sys::CWD() + "/SimpleStatic";
      if(!(IRAD::Sys::FILEEXISTS(fluidDir)||(IRAD::Sys::FILEEXISTS(simStaticDir)))){
        std::cout << "SimpleStatic / fluid Folders do not exists!" << std::endl;
        works = false;           
        result.UpdateResult("fsiCoupler:Works",works);
        return; 
      }
      else{
        IntDir = IRAD::Sys::ChDir(simStaticDir);
        if(IntDir == -1){
          std::cout << "GetInputData Error: Could not change directory to " 
                    << fluidDir << ". Exiting (fail). " << std::endl;
          works = false;
          result.UpdateResult("fsiCoupler:Works",works);
        }
        std::system("chmod 755 Allclean Allrun AllrunPar makeLinks makeSerialLinks removeSerialLinks"); 
        std::system("./Allclean");
        std::system("./Allrun");
        IntDir = IRAD::Sys::ChDir(fluidDir);
        if(IntDir == -1){
          std::cout << "GetInputData Error: Could not change directory to " 
                    << fluidDir << ". Exiting (fail). " << std::endl;
          works = false;
          result.UpdateResult("fsiCoupler:Works",works);
        }
      }
      
      fsicoupling fsiCoupler(global); 
      std::string fluidSolverName("OpenFoamFSI");
      std::string solidSolverName("ElmerCSC");
      std::string transferServiceName("SurfX");
      std::string runMode("1");

      COM_load_module(fluidSolverName.c_str(),"FluidsComponentInterface");
      COM_load_module(solidSolverName.c_str(),"StructuresComponentInterface");
      COM_load_module("SurfUtil","SurfUtil");
      COM_load_module("Simpal","Simpal");
     
      std::vector<std::string> componentInterfaceNames;
      componentInterfaceNames.push_back("FluidsComponentInterface");
      componentInterfaceNames.push_back("StructuresComponentInterface");
      componentInterfaceNames.push_back("TransferInterface");
      componentInterfaceNames.push_back("SurfUtil");
      componentInterfaceNames.push_back("Simpal");
 
      fsiCoupler.SetRunMode(runMode);
      fsiCoupler.SetVerbLevel(verblevel);      
      fsiCoupler.Initialize(componentInterfaceNames, time_final, timestep);  

      // Mimicing FsiCoupler::run, intializing variables, etc.
      int innerCount = 0;
      int maxSubSteps = 1000;
      int dumpinterval = 1;
      int systemStep = 0;

 
          if(!(fsiCoupler.getRunMode())){
                fsiCoupler.TransferDisplacementsToFluid(fsiCoupler.getStructureAgent(),fsiCoupler.getFluidAgent());
          }
      double simultime = fsiCoupler.getSimulationTime();

     
      std::cout << "simultime is =" << simultime << std::endl;
      if(fsiCoupler.getRunMode() < 2){
        fsiCoupler.getFluidAgent()->InitializeTimeStep(simultime);
        fsiCoupler.getFluidAgent()->Run(fsiCoupler.getSimulationTime()+fsiCoupler.getSimulationFinalTime());
      }
     
      int * conn= NULL;
      int  connStride, connCap=0;
      COM_get_array( (fsiCoupler.getFluidIntName()+".:q4:").c_str(),101, &conn,&connStride,&connCap);
      std::cout << "connStride , connCap = " << connStride << ", " << connCap << std::endl;
      for (int i =0; i < connCap; i++){
         std::cout << "Conn Coordinates[" << i << "] = " << conn[4*i] << ", " << conn[4*i+1] << ", " << conn[4*i+2] << ", " << conn[4*i+3] << std::endl;
      }


     
      std::vector<double> cellCoordVec(connCap*3);
      std::vector<double> avgCoor(3);
      for(int i =0; i < connCap; i++){ 
                  
          avgCoor = avgCoord(conn[4*i]-1,conn[4*i+1]-1,conn[4*i+2]-1,conn[4*i+3]-1, fsiCoupler.getFluidAgent());
                  cellCoordVec[3*i] = avgCoor[0];
                  cellCoordVec[3*i+1] = avgCoor[1];
                  cellCoordVec[3*i+2] = avgCoor[2];
                  std::cout << "CellCoordVec[" << i << "] = " << cellCoordVec[3*i] << ", " << cellCoordVec[3*i+1] << ", " << cellCoordVec[3*i+2] << std::endl;
                  avgCoor.clear();
      }
 

      double * tractions;
      int stride = 0;
      int cap = 0;
      // Get the traction vector values for fluid domain.
          COM_get_array((fsiCoupler.getFluidIntName()+".traction").c_str(),101,&tractions,&stride,&cap);
      std::cout << "stride and cap = " << stride << "," << cap << std::endl;
      //traction becomes Ycoord * 3 + 2
      int isize = cap * stride ;
      for(int i = 0; i < isize/3 ; i++){
        //tractions[3*i+1] = 3*fsiCoupler.getFluidAgent()->Coordinates()[3*i+2]+2;
        //tractions[3*i+1] = fsiCoupler.getFluidAgent()->Coordinates()[3*i+2];
        //tractions[3*i+1] = 1;
        tractions[3*i+1] = cellCoordVec[3*i+2];
                std::cout << "tractions[" << i << "] = " << tractions[3*i] << ",  " << tractions[3*i+1] << ",  " << tractions[3*i+2] << ",  Coordinates are = " << cellCoordVec[3*i] << ", " << cellCoordVec[3*i+1] << ", " << cellCoordVec[3*i+2] <<  std::endl;
      }
 
      double * solidLoads1 = NULL;
      int solidLoadStride1 = 0;
      int solidLoadCap1 =0;
      // Get the load vector from solid domain
      COM_get_array((fsiCoupler.getSolidIntName()+".Loads").c_str(),11,&solidLoads1,&solidLoadStride1,&solidLoadCap1);
      int solidLoadSize1 = solidLoadCap1*solidLoadStride1;
      
      // Execute Transfer LoadsToStructures
      if(!fsiCoupler.getRunMode()) fsiCoupler.TransferLoadsToStructures(fsiCoupler.getFluidAgent(), fsiCoupler.getStructureAgent());
  
      double * solidLoads = NULL;
      int solidLoadStride = 0;
      int solidLoadCap =0;
      // Get the load vector from solid domain
      COM_get_array((fsiCoupler.getSolidIntName()+".Loads").c_str(),11,&solidLoads,&solidLoadStride,&solidLoadCap);
      int solidLoadSize = solidLoadCap*solidLoadStride;
      
      std::cout << "solidLoadCap = " << solidLoadCap << ", solidLoadStride = " << solidLoadStride << std::endl;
      for(int i = 0; i < solidLoadSize/3; i++){
        std::cout << "solidLoads(" << i <<") = " << solidLoads[3*i] << ", " << solidLoads[3*i+1] << ", " << solidLoads[3*i+2] << " Where coordinate is = " << fsiCoupler.getStructureAgent()->Coordinates()[3*i] << ", " << fsiCoupler.getStructureAgent()->Coordinates()[3*i+1] << ", " << fsiCoupler.getStructureAgent()->Coordinates()[3*i+2]  << std::endl;   
      }


      double totalTraction, totalLoad = 0;
      for(int i = 0; i < solidLoadSize; i++)  totalLoad += solidLoads[i];
      totalLoad = totalLoad/2;
      for(int i = 0; i < isize/3 ; i++) totalTraction +=tractions[3*i+1];   
      
      
      std::cout << "total loads = " << totalLoad << std::endl;
      std::cout << "total tractions = " << totalTraction << std::endl;
    
      // Using Error % = (Experimented value - Theoretical value) / Theoretical value
      double totalError = (totalLoad - totalTraction) / totalTraction;
      // If the error % is greater than 5%, let's call it a fail.
      std::cout << "total error = " << totalError << std::endl;
      if(totalError  >= .05) works = false;

      double maxError = 0;
      double errr = 0;
      for(int i = 0; i < isize/3 ; i++){
        for(int j = 0; j <= 9; j = j + 3){
          //std::cout << "tractions = " << tractions[3*i+1] << std::endl;
          //std::cout << "solidLoads = " << solidLoads[7*i+1-i+j] << std::endl;
          errr = std::abs( (  solidLoads[7*i+1-i+j] - tractions[3*i+1]) / tractions[3*i+1] );
          if(errr >= maxError){
            maxError = errr;
            std::cout << "maxError = " << maxError << std::endl;
            std::cout << "Happens at i,j = " << i << ", " << j << std::endl;
          }
        }
      }
      std::cout << "Max error = " << maxError << std::endl;
      result.UpdateResult("TransferLoadsToStructures:Works",works);
    }

Here is the call graph for this function:

Here is the caller graph for this function: