virtual void Test__ElasticBeam3D_LoadFunction ( ResultsType &  result )

inlinevirtual

Definition at line 871 of file ElmerModuleDriverTest.H.

References TestingObject< ResultsType >::GetInputData(), and TestingObject< ResultsType >::streamdiff().

Referenced by TestingObject< ResultsType >::RunTest().

                                                                      {
      std::cout << "Running Test__ElasticBeam3D_LoadFunction" << std::endl; 
 
      int IntDir;
      std::string OrgDir, TestDir;
      bool ItAllWorks = true;

      // Getting Input data********************************************************
      //***************************************************************************
      
      //Call GetInputData to copy input test data to temp directory for running tests.
      std::string suffix = "/share/Testing/test_data/ElasticBeam3D_LoadFunction";

      //Make path for directory to run the test in.
      TestDir = IRAD::Sys::CWD() + "/ElasticBeam3D_TestData";
      IntDir = GetInputData(suffix, TestDir);

      //Check if GetInputData exited correctly.
      if(IntDir != 0){
        std::cout << "ElasticBeam3D_LoadFunction Error: GetInputData call failed."
                  << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      //Check if TestDir directory (from GetInputData) exists in current directory
      if(!IRAD::Sys::FILEEXISTS(TestDir)){
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not find directory, "
                  << TestDir << ", for running tests." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      //Save original directory name for later
      OrgDir = IRAD::Sys::CWD();

      //Change directories to TestDir directory for running 
      IntDir = IRAD::Sys::ChDir(TestDir);
      if(IntDir == -1){
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not change directories to "
                  << TestDir << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      //load Elmer module**********************************************************
      //***************************************************************************
      COM_LOAD_MODULE_STATIC_DYNAMIC( ElmerCSC, "Window1");
   
      bool load_unload = true;

      //Get Winodw handle
      int h=COM_get_window_handle("Window1");
      if(h <= 0){
        std::cout << " After loading, COM_get_window_handle(\"Window1\") returns "
                  << h << std::endl;
        load_unload=false;
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not get window handle."
                  << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      // Get Initialize function handle and call Function
      int init_handle = COM_get_function_handle("Window1.Initialize");
      bool init_func = (init_handle > 0);
      int init_runs = 0;
      int verb=3;
      std::cout << "init = " << init_handle << std::endl;
      if(init_handle){
        //Call the function
        COM_call_function(init_handle, &init_runs, &verb);
      }
      else{
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not get function handle."
                  << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      // Check load registration & initialization
      double* Loads = NULL;
      int LoadsSize = 0;
      bool loadsRegistered = true, loadsInitialized = true;
      // Get the FSI mesh from the structures solver
      COM_get_array("Window1.Loads",11,&Loads);
      if(Loads){
        COM_get_size("Window1.Loads",11,&LoadsSize);
        std::cout << "Loads not NULL" << std::endl;
        std::cout << "LoadsSize = " << LoadsSize << std::endl;
        // check the values
        for(int i=0; i < LoadsSize; i++){
          for(int j=0; j < 3; j++){
            if(fabs(Loads[i*3 + j]) > 1.0e-12){
               std::cout << "Loads were not intialized to 0.0!" << std::endl;
              result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
              return;
            }
          }
        }
      }
      else{
        std::cout << "Loads are NULL" << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      // Get TimeStepper function handle and call Function

      int runs_handle = COM_get_function_handle("Window1.Run");
      bool runs_func = (runs_handle > 0);
      bool DispCorrect = true;
      int runs_runs = 0;
      double time1 =  1.0;
      double* Disp = NULL;
      std::cout << "runs = " << runs_handle << std::endl;
      if(runs_handle){
        //Call the run function for Time1
        if(Loads){
           std::cout << "Changing load values" << std::endl;
           for(int i=0; i < LoadsSize; i++){
              Loads[i*3 + 1] = -4.0e5;
              for(int j=0; j < 3; j++){
                 std::cout << Loads[i*3 + j] << " ";
              }
              std::cout << std::endl;
           }
        }
        COM_call_function(runs_handle, &runs_runs, &time1);
      }
      else{
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not get function handle."
                  << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      // Get Finalize function handle and call Function
      int final_handle = COM_get_function_handle("Window1.Finalize");
      bool final_func = (final_handle > 0);
      int final_runs = 0;
      std::cout << "final = " << final_handle << std::endl;
      if(final_handle){
        //Call the function
        COM_call_function(final_handle, &final_runs);
      }
      else{
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not get function handle."
                  << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

     
      // Compare the output file with an archived output file
      std::ifstream Inf, InfComp;
      std::stringstream ss;
      std::string word, line;

      Inf.open("case.ep");
      InfComp.open("case.ep_check");

      std::getline(Inf,line);
      std::getline(Inf,line);
      std::getline(InfComp,line);
      std::getline(InfComp,line);

      bool LoadWorks = true; 
      int diffReturn = -1; 
 
      diffReturn = streamdiff(Inf, InfComp, &ss);

      if(diffReturn){
        std::cout << "ElasticBeam3D_LoadFunction Error: case.ep "
                  << "case.ep_check differ!" << std::endl;
        std::cout << ss.str() << std::endl;
        if(ss.str() != " ")
          LoadWorks = false;
      }
  
      std::cout << "LoadWorks = " << LoadWorks << std::endl; 
      result.UpdateResult("ElasticBeam3D_LoadFunction:Works",LoadWorks);

      //Unload Elmer module********************************************************
      //***************************************************************************
      COM_UNLOAD_MODULE_STATIC_DYNAMIC( ElmerCSC , "Window1");

      //Make sure module unloaded
      h=COM_get_window_handle("Window1");
      if(h > 0){
        std::cout << "After unloading, COM_get_window_handle(\"Window1\") returns "
                  << h << std::endl;
        load_unload=false;
        std::cout << "ElasticBeam3D_LoadFunction Error: Did not properly unload module."
                  << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      //Change directories out of TestDir directory back to original directory
      IntDir = IRAD::Sys::ChDir(OrgDir);
      if(IntDir == -1){
        std::cout << "ElasticBeam3D_LoadFunction Error: Could not change directories to "
                  << OrgDir << "." << std::endl;
        result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", false);
        return;
      }

      result.UpdateResult("ElasticBeam3D_LoadFunction:Runs", true);

    }

Here is the call graph for this function:

Here is the caller graph for this function: