two_d_unsteady_heat_2adapt_load_balance.cc File Reference

#include "generic.h"
#include "unsteady_heat.h"
#include "meshes/quarter_circle_sector_mesh.h"

Classes
class	MyEllipse
class	RefineableUnsteadyHeatProblem< ELEMENT >
	Unsteady heat problem in deformable ellipse domain. More...

Namespaces
	GlobalParameters
	Global parameters.

Functions
double	GlobalParameters::step_position (const double &time)
	Position of step (x-axis intercept) More...
void	GlobalParameters::get_exact_u (const double &time, const Vector< double > &x, Vector< double > &u)
	Exact solution as a Vector. More...
void	GlobalParameters::get_exact_u (const double &time, const Vector< double > &x, double &u)
	Exact solution as a scalar. More...
void	GlobalParameters::get_source (const double &time, const Vector< double > &x, double &source)
	Source function. More...
void	GlobalParameters::prescribed_flux_on_fixed_y_boundary (const double &time, const Vector< double > &x, double &flux)
	Flux required by the exact solution on a boundary on which y is fixed. More...
int	main (int argc, char *argv[])

Variables
std::string	GlobalParameters::Restart_file =""
	Name of restart file. More...
std::string	GlobalParameters::Partitioning_file =""
	Name of file specifying the partitioning of the problem. More...
double	GlobalParameters::Alpha =1.0
	Parameter for steepness of step. More...
double	GlobalParameters::Beta =1.0
	Parameter for amplitude of step translation. More...
double	GlobalParameters::Gamma = MathematicalConstants::Pi/4.0
	Parameter for timescale of step translation. More...
double	GlobalParameters::TanPhi =0.0
	Parameter for angle of step. More...

Function Documentation

main()

int main	(	int argc	,
		char *	argv[]
	)

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Demonstrate how to solve an unsteady heat problem in deformable domain with mesh adaptation.

{
 
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::init(argc,argv);
#endif
 
 // Store command line arguments
 CommandLineArgs::setup(argc,argv);
 
 // Define possible command line arguments and parse the ones that
 // were actually specified
 
 // Name of restart file
 CommandLineArgs::specify_command_line_flag("--restart_file",
                                            &GlobalParameters::Restart_file);
 
 // Name of file that specifies the problem partitioning
 CommandLineArgs::specify_command_line_flag(
  "--partitioning_file",&GlobalParameters::Partitioning_file); 
 
 // Flag to indicate that we're doing a validation run
 CommandLineArgs::specify_command_line_flag("--validation_run");
 
 // Flag to indicate that we do load_balance first (before prune)
 CommandLineArgs::specify_command_line_flag("--load_balance_first");
 
 // Parse command line
 CommandLineArgs::parse_and_assign(); 
 
 // Doc what has actually been specified on the command line
 CommandLineArgs::doc_specified_flags();
 
 // Build problem: Pass pointer to source function and initial timestep
 RefineableUnsteadyHeatProblem<RefineableQUnsteadyHeatElement<2,3> >
  problem(&GlobalParameters::get_source);
 
 // Work out doc_info directory
 char doc_info_directory[100];
 if(CommandLineArgs::command_line_flag_has_been_set("--validation_run"))
  {
   //Validation run
   if(CommandLineArgs::command_line_flag_has_been_set("--load_balance_first"))
    {
     //Load balancing
     if(!CommandLineArgs::command_line_flag_has_been_set("--restart_file"))
      {
       //First run
       sprintf(doc_info_directory,"RESLT_load_balance_first_for_restart");
      }
     else
      {
       //Restarting
       //cout << GlobalParameters::Restart_file.c_str() << endl;
       char filename[100];
       sprintf(filename,"%s",GlobalParameters::Restart_file.c_str());
       char* step;
       step = strtok(filename,"/");
       step = strtok(NULL,"/");
       sprintf(doc_info_directory,"RESLT_load_balance_first_restarted_from_step_%s",step);
       //cout << doc_info_directory << endl;
       //exit(1);
      }
    }
   else
    {
     //Pruning
     if(!CommandLineArgs::command_line_flag_has_been_set("--restart_file"))
      {
       //First run
       sprintf(doc_info_directory,"RESLT_prune_first_for_restart");
      }
     else
      {
       //Restarting
       char filename[100];
       sprintf(filename,"%s",GlobalParameters::Restart_file.c_str());
       char* step;
       step = strtok(filename,"/");
       step = strtok(NULL,"/");
       sprintf(doc_info_directory,"RESLT_prune_first_restarted_from_step_%s",step);
      }
    }
  }
 else
  {
   sprintf(doc_info_directory,"RESLT");
  }
 
 // Set doc_info directory
 problem.doc_info().set_directory(doc_info_directory);
 
  // Switch off output modifier
 oomph_info.output_modifier_pt() = &default_output_modifier;
 
 // Define processor-labeled output file for all on-screen stuff
 std::ofstream output_stream;
 char filename[100];
 sprintf(filename,"%s/OUTPUT.%i",
         problem.doc_info().directory().c_str(),
         MPI_Helpers::communicator_pt()->my_rank());
 output_stream.open(filename);
 oomph_info.stream_pt() = &output_stream;
 OomphLibWarning::set_stream_pt(&output_stream);
 OomphLibError::set_stream_pt(&output_stream);  
 
 // Doc what has actually been specified on the command line
 CommandLineArgs::doc_specified_flags();
   
 // First timestep?
 bool first=true;
 
 // Max. number of spatial adaptations per timestep. Allow plenty
 // of adaptations at first timestep as the initial conditions
 // can be reset "exactly" from without any interpolation error.
 unsigned max_adapt=10; 
 
 // Set IC from analytical soln
 problem.set_initial_condition();
 
 // If restart: The first step isn't really the first step,
 // i.e. initial condition should not be re-set when 
 // adaptive refinement has been performed. Also, limit
 // the max. number of refinements per timestep to the
 // normal value straightaway.
 if (CommandLineArgs::command_line_flag_has_been_set("--restart_file"))
  {
   first=false;
   max_adapt=1;
  }
 
 
 // Prune first or load balance first?
 unsigned first_load_balance=9;
 unsigned second_load_balance=18;
 unsigned first_prune=4;
 unsigned second_prune=13;
 
 // Create storage for partitioning
 Vector<unsigned> element_partition;
 
 // No partitioning specified -- simply distribute problem and
 // record distribution in file to allow restart
 if (!CommandLineArgs::command_line_flag_has_been_set("--partitioning_file"))
  {
   oomph_info << "Distributing problem with METIS \n"
              << "Documenting partitioning in RESLT/partitioning.dat.\n";
   
   // Distribute
   element_partition=problem.distribute();
   
   // Write partition to disk
   std::ofstream output_file;
   char filename[100];
   sprintf(filename,"%s/partitioning.dat",problem.doc_info().directory().c_str());
   output_file.open(filename);
   unsigned n=element_partition.size();
   output_file << element_partition.size() << std::endl;
   for (unsigned e=0;e<n;e++)
    {
     output_file << element_partition[e] << std::endl;
    }
   output_file.close();
  }
 // Read in partitioning from disk using the specified file
 else 
  {
   
   oomph_info << "Distributing problem with partitioning \n"
              << "specified in: " << GlobalParameters::Partitioning_file 
              << std::endl;
   
   // Read in partitioning from disk: Name of partitioning file specified
   // as command line argument
   std::ifstream input_file;
   input_file.open(GlobalParameters::Partitioning_file.c_str());
   if (!input_file.is_open())
    {
     oomph_info << "Error opening input file\n";
     assert(false);
    }
   std::string input_string;
   unsigned n=0;
   if (getline(input_file,input_string,'\n'))
    {
     n=atoi(input_string.c_str());
    }
   else
    {
     oomph_info << "Reached end of file when reading partitioning file\n";
     assert(false);
    }
   element_partition.resize(n);
   for (unsigned e=0;e<n;e++)
    {
     if (getline(input_file,input_string,'\n'))
      {
       element_partition[e]=atoi(input_string.c_str());
      }
     else
      {
       oomph_info << "Reached end of file when reading partitioning file\n";
       assert(false);
      }
    }
   
   // Create storage for actually used partitioning
   Vector<unsigned> used_element_partition;
 
   // Now perform the distribution 
   used_element_partition=problem.distribute(element_partition);
 
 
   // Write used partition to disk
   std::ofstream output_file;
   char filename[100];
   sprintf(filename,"%s/partitioning.dat",problem.doc_info().directory().c_str());
   output_file.open(filename);
   unsigned n_used=used_element_partition.size();
   output_file << n_used << std::endl;
   for (unsigned e=0;e<n_used;e++)
    {
     output_file << used_element_partition[e] << std::endl;
    }
   output_file.close();
 
  }
 
 
 // Doc
 std::stringstream comment_stream0;
 comment_stream0 << "Distributed; Step " 
                 << problem.doc_info().number();
 problem.doc_solution(comment_stream0.str());
 oomph_info << "Finished distribution\n";
 
// Restart file specified via command line 
 if (CommandLineArgs::command_line_flag_has_been_set("--restart_file"))
  {
   problem.restart();
   oomph_info << "Finished restart\n";
  }
 
 // Initial timestep: Use the one used when setting up the initial
 // condition or the "suggested next dt" from the restarted run
 double dt=problem.next_dt();
 
 // Write header for trace file
 problem.write_trace_file_header();
 
 // Timestepping loop
 if (CommandLineArgs::command_line_flag_has_been_set("--validation_run"))
  {
   // Fake but repeatable load balancing for self-test
   problem.set_default_partition_in_load_balance();
  }
 
 
 // Keep solving...
 while (problem.doc_info().number()<22)  
  {
   
   oomph_info << "Doing solve\n";
   
   // Take timestep with temporal and spatial adaptivity
   double dt_new=
    problem.doubly_adaptive_unsteady_newton_solve(dt,problem.epsilon_t(),
                                                  max_adapt,first);
   oomph_info << "Suggested new dt: " << dt_new << std::endl;
   dt=dt_new;
   
   // Store for restart
   problem.next_dt()=dt;
   
   // Now we've done the first timestep -- don't re-set the IC
   // in subsequent steps
   first=false;
   
   // Reduce the number of spatial adaptations to one per 
   // timestep -- too scared that the interpolation error will 
   // wipe out any further gains...
   max_adapt=1;
   
   //Output solution
   std::stringstream comment_stream;
   comment_stream << "Step " << problem.doc_info().number();
   problem.doc_solution(comment_stream.str());
   
   // Prune
   if ((problem.doc_info().number()==first_prune)||
       (problem.doc_info().number()==second_prune))
    {
     std::stringstream comment_stream1;
     if ((problem.doc_info().number()==second_prune)||
         ((problem.doc_info().number()==first_prune)&&
          (!CommandLineArgs::command_line_flag_has_been_set(
            "--load_balance_first"))))
      {
       oomph_info << "Refining uniformly before pruning\n";
       problem.refine_uniformly();       
       comment_stream1 << "Uniform refinement; Step " 
                       << problem.doc_info().number();
      }
     else
      {
       comment_stream1 << "Skipped uniform refinement; Step " 
                       << problem.doc_info().number();
      }
     problem.doc_solution(comment_stream1.str());
 
     std::stringstream comment_stream2;
     if ((problem.doc_info().number()==second_prune+1)||
         ((problem.doc_info().number()==first_prune+1)&&
          (!CommandLineArgs::command_line_flag_has_been_set(
            "--load_balance_first"))))
      {
       oomph_info << "Pruning\n";
       problem.prune_halo_elements_and_nodes();
       comment_stream2 << "Pruned; Step " 
                       << problem.doc_info().number();
      }
     else
      {
       comment_stream2 << "Skipped prune; Step " 
                       << problem.doc_info().number();
      }
     problem.doc_solution(comment_stream2.str());
    }
   
   
   
   // Load balance?
   if ((problem.doc_info().number()==first_load_balance)||
       (problem.doc_info().number()==second_load_balance))
    {
     oomph_info << "\n\n\n LOAD BALANCING \n\n\n";
     
     // Load balance
     problem.load_balance(); 
     
     std::stringstream comment_stream3;
     comment_stream3 << "Load balanced; Step " 
                     << problem.doc_info().number();
     problem.doc_solution(comment_stream3.str());
     
     
     oomph_info << "\n\n\n DONE LOAD BALANCING \n\n\n";
    }
  }
 
 oomph_info << "Done\n";
#ifdef OOMPH_HAS_MPI
 MPI_Helpers::finalize();
#endif
 
}; // end of main

References assert, oomph::CommandLineArgs::command_line_flag_has_been_set(), oomph::default_output_modifier, oomph::CommandLineArgs::doc_specified_flags(), e(), MergeRestartFiles::filename, GlobalParameters::get_source(), n, oomph::oomph_info, oomph::OomphInfo::output_modifier_pt(), oomph::CommandLineArgs::parse_and_assign(), GlobalParameters::Partitioning_file, problem, GlobalParameters::Restart_file, Flag_definition::setup(), oomph::CommandLineArgs::specify_command_line_flag(), oomph::OomphInfo::stream_pt(), and oomph::Global_string_for_annotation::string().