oomph::CommandLineArgs Namespace Reference

Namespace for command line arguments. More...

Classes
struct	ArgInfo
	Structure to store information on a command line argument. More...

Functions
void	setup (int argc, char **argv)
	Set values. More...
void	output ()
	Doc the command line arguments. More...
void	specify_command_line_flag (const std::string &command_line_flag, const std::string &doc)
	Specify possible argument-free command line flag. More...
void	specify_command_line_flag (const std::string &command_line_flag, double *arg_pt, const std::string &doc)
void	specify_command_line_flag (const std::string &command_line_flag, int *arg_pt, const std::string &doc)
void	specify_command_line_flag (const std::string &command_line_flag, unsigned *arg_pt, const std::string &doc)
void	specify_command_line_flag (const std::string &command_line_flag, std::string *arg_pt, const std::string &doc)
bool	command_line_flag_has_been_set (const std::string &flag)
void	doc_all_flags (std::ostream &outstream)
	Document the values of all flags (specified or not). More...
void	doc_specified_flags ()
	Document specified command line flags. More...
void	doc_available_flags ()
	Document available command line flags. More...
void	check_arg_index (const int &argc, const int &arg_index)
	Helper function to check if command line index is legal. More...
void	parse_and_assign (int argc, char *argv[], const bool &throw_on_unrecognised_args)
void	parse_and_assign (const bool &throw_on_unrecognised_args)

Variables
int	Argc
	Number of arguments + 1. More...
char **	Argv
	Arguments themselves. More...
std::map< std::string, ArgInfo< bool > >	Specified_command_line_flag
	Map to indicate an input flag as having been set. More...
std::map< std::string, ArgInfo< double > >	Specified_command_line_double_pt
	Map to associate an input flag with a double – specified via pointer. More...
std::map< std::string, ArgInfo< int > >	Specified_command_line_int_pt
	Map to associate an input flag with an int – specified via pointer. More...
std::map< std::string, ArgInfo< unsigned > >	Specified_command_line_unsigned_pt
	Map to associate an input flag with an unsigned – specified via pointer. More...
std::map< std::string, ArgInfo< std::string > >	Specified_command_line_string_pt
	Map to associate an input flag with a string – specified via pointer. More...

Detailed Description

Namespace for command line arguments.

Function Documentation

check_arg_index()

void oomph::CommandLineArgs::check_arg_index	(	const int &	argc,
		const int &	arg_index
	)

Helper function to check if command line index is legal.

    {
      if (arg_index >= argc)
      {
        output();
        doc_available_flags();
        std::stringstream error_stream;
        error_stream
          << "Tried to read more command line arguments than\n"
          << "specified. This tends to happen if a required argument\n"
          << "to a command line flag was omitted, e.g. by running \n\n"
          << "     ./a.out -some_double \n\n rather than\n\n"
          << "     ./a.out -some_double 1.23 \n\n"
          << "To aid the debugging I've output the available\n"
          << "command line arguments above.\n";
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
    }

References doc_available_flags(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and output().

Referenced by parse_and_assign().

command_line_flag_has_been_set()

bool oomph::CommandLineArgs::command_line_flag_has_been_set

(

const std::string &

flag

)

Check if command line flag has been set (value will have been assigned directly).

Check if specified flag has been set (the associated value will have been assigned directly)

    {
      for (std::map<std::string, ArgInfo<bool>>::iterator it =
             Specified_command_line_flag.begin();
           it != Specified_command_line_flag.end();
           it++)
      {
        if (it->first == flag)
        {
          return it->second.is_set;
        }
      }
 
      for (std::map<std::string, ArgInfo<double>>::iterator it =
             Specified_command_line_double_pt.begin();
           it != Specified_command_line_double_pt.end();
           it++)
      {
        if (it->first == flag)
        {
          return (it->second).is_set;
        }
      }
 
      for (std::map<std::string, ArgInfo<int>>::iterator it =
             Specified_command_line_int_pt.begin();
           it != Specified_command_line_int_pt.end();
           it++)
      {
        if (it->first == flag)
        {
          return (it->second).is_set;
        }
      }
 
      for (std::map<std::string, ArgInfo<unsigned>>::iterator it =
             Specified_command_line_unsigned_pt.begin();
           it != Specified_command_line_unsigned_pt.end();
           it++)
      {
        if (it->first == flag)
        {
          return (it->second).is_set;
        }
      }
 
      for (std::map<std::string, ArgInfo<std::string>>::iterator it =
             Specified_command_line_string_pt.begin();
           it != Specified_command_line_string_pt.end();
           it++)
      {
        if (it->first == flag)
        {
          return (it->second).is_set;
        }
      }
 
      return false;
    }

References Specified_command_line_double_pt, Specified_command_line_flag, Specified_command_line_int_pt, Specified_command_line_string_pt, Specified_command_line_unsigned_pt, and oomph::Global_string_for_annotation::string().

Referenced by FourierDecomposedHelmholtzProblem< ELEMENT >::actions_after_adapt(), FourierDecomposedHelmholtzProblem< ELEMENT >::actions_before_adapt(), SolarRadiationProblem< ELEMENT >::actions_before_implicit_timestep(), FourierDecomposedHelmholtzProblem< ELEMENT >::actions_before_newton_convergence_check(), SolarRadiationProblem< ELEMENT >::actions_before_newton_convergence_check(), AnnularDiskProblem< ELASTICITY_ELEMENT >::AnnularDiskProblem(), AxisymFvKProblem< ELEMENT >::AxisymFvKProblem(), ProblemParameters::boundary_accel_0(), ProblemParameters::boundary_accel_1(), ProblemParameters::boundary_d2fluxdt2_0(), ProblemParameters::boundary_d2fluxdt2_1(), ProblemParameters::boundary_dfluxdt_0(), ProblemParameters::boundary_dfluxdt_1(), ProblemParameters::boundary_displ_0(), ProblemParameters::boundary_displ_1(), ProblemParameters::boundary_flux_0(), ProblemParameters::boundary_flux_1(), ProblemParameters::boundary_pressure(), ProblemParameters::boundary_traction(), ProblemParameters::boundary_veloc_0(), ProblemParameters::boundary_veloc_1(), BubbleInChannelProblem< ELEMENT >::BubbleInChannelProblem(), AxiPoroProblem< ELEMENT, TIMESTEPPER >::complete_problem_setup(), UnsteadyHeatMeltProblem< ELEMENT >::complete_problem_setup(), UnsteadyHeatProblem< ELEMENT >::complete_problem_setup(), ElasticAnnulusProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), RingWithTRibProblem< ELASTICITY_ELEMENT >::complete_problem_setup(), UnsteadyHeatProblem< ELEMENT >::create_flux_elements(), StefanBoltzmannProblem< ELEMENT >::create_melt_elements(), StefanBoltzmannProblem< ELEMENT >::create_sb_elements(), AnnularDiskProblem< ELASTICITY_ELEMENT >::create_traction_elements(), AxisymmetricVibratingShellProblem< ELEMENT >::doc_solution(), VibratingShellProblem< ELEMENT >::doc_solution(), AxiPoroProblem< ELEMENT, TIMESTEPPER >::doc_solution(), TetmeshPoissonProblem< ELEMENT >::doc_solution(), UnsteadyHeatProblem< ELEMENT >::doc_solution(), DropInChannelProblem< ELEMENT >::DropInChannelProblem(), ProblemParameters::exact_soln(), FallingBlockProblem< ELEMENT >::FallingBlockProblem(), ProblemParameters::Fluid_body_force(), GlobalFct::get_residuals(), main(), MultiPoissonProblem< ELEMENT >::MultiPoissonProblem(), PrescribedBoundaryDisplacementProblem< ELEMENT >::PrescribedBoundaryDisplacementProblem(), RisingBubbleProblem< ELEMENT >::RisingBubbleProblem(), AxiPoroProblem< ELEMENT, TIMESTEPPER >::set_boundary_values(), AxiPoroProblem< ELEMENT, TIMESTEPPER >::set_initial_condition(), FSIChannelWithLeafletProblem< ELEMENT >::set_iterative_solver(), AxisymmetricVibratingShellProblem< ELEMENT >::set_nprev_for_extrapolation_of_strain_rate_for_all_elements(), VibratingShellProblem< ELEMENT >::set_nprev_for_extrapolation_of_strain_rate_for_all_elements(), ProblemParameters::Solid_body_force(), StefanBoltzmannProblem< ELEMENT >::StefanBoltzmannProblem(), TwoLayerInterfaceProblem< ELEMENT >::TwoLayerInterfaceProblem(), UnstructuredFluidProblem< ELEMENT >::UnstructuredFluidProblem(), and UnstructuredImmersedEllipseProblem< ELEMENT >::UnstructuredImmersedEllipseProblem().

doc_all_flags()

void oomph::CommandLineArgs::doc_all_flags

(

std::ostream &

outstream

)

Document the values of all flags (specified or not).

Document the values of all flags (specified or not)

    {
      for (std::map<std::string, ArgInfo<bool>>::iterator it =
             Specified_command_line_flag.begin();
           it != Specified_command_line_flag.end();
           it++)
      {
        outstream << it->first << " " << it->second.is_set << std::endl;
      }
      for (std::map<std::string, ArgInfo<double>>::iterator it =
             Specified_command_line_double_pt.begin();
           it != Specified_command_line_double_pt.end();
           it++)
      {
        outstream << it->first << " " << *(it->second.arg_pt) << std::endl;
      }
      for (std::map<std::string, ArgInfo<int>>::iterator it =
             Specified_command_line_int_pt.begin();
           it != Specified_command_line_int_pt.end();
           it++)
      {
        outstream << it->first << " " << *(it->second.arg_pt) << std::endl;
      }
      for (std::map<std::string, ArgInfo<unsigned>>::iterator it =
             Specified_command_line_unsigned_pt.begin();
           it != Specified_command_line_unsigned_pt.end();
           it++)
      {
        outstream << it->first << " " << *(it->second.arg_pt) << std::endl;
      }
      for (std::map<std::string, ArgInfo<std::string>>::iterator it =
             Specified_command_line_string_pt.begin();
           it != Specified_command_line_string_pt.end();
           it++)
      {
        // Quote blank strings, otherwise trying to parse the output in any way
        // will go wrong.
        std::string arg_string = *(it->second.arg_pt);
        if (arg_string == "")
        {
          arg_string = "\"\"";
        }
 
        outstream << it->first << " " << arg_string << std::endl;
      }
    }

References Specified_command_line_double_pt, Specified_command_line_flag, Specified_command_line_int_pt, Specified_command_line_string_pt, Specified_command_line_unsigned_pt, and oomph::Global_string_for_annotation::string().

Referenced by oomph::MyDocInfo::copy_args_string(), and main().

doc_available_flags()

void oomph::CommandLineArgs::doc_available_flags

(

)

Document available command line flags.

    {
      oomph_info << std::endl;
      oomph_info << "Available command line flags:\n";
      oomph_info << "-----------------------------\n";
 
      for (std::map<std::string, ArgInfo<bool>>::iterator it =
             Specified_command_line_flag.begin();
           it != Specified_command_line_flag.end();
           it++)
      {
        oomph_info << it->first << std::endl
                   << it->second.doc << std::endl
                   << std::endl;
      }
 
      for (std::map<std::string, ArgInfo<double>>::iterator it =
             Specified_command_line_double_pt.begin();
           it != Specified_command_line_double_pt.end();
           it++)
      {
        oomph_info << it->first << " <double> " << std::endl
                   << it->second.doc << std::endl
                   << std::endl;
      }
 
      for (std::map<std::string, ArgInfo<int>>::iterator it =
             Specified_command_line_int_pt.begin();
           it != Specified_command_line_int_pt.end();
           it++)
      {
        oomph_info << it->first << " <int> " << std::endl
                   << it->second.doc << std::endl
                   << std::endl;
      }
 
      for (std::map<std::string, ArgInfo<unsigned>>::iterator it =
             Specified_command_line_unsigned_pt.begin();
           it != Specified_command_line_unsigned_pt.end();
           it++)
      {
        oomph_info << it->first << " <unsigned> " << std::endl
                   << it->second.doc << std::endl
                   << std::endl;
      }
 
      for (std::map<std::string, ArgInfo<std::string>>::iterator it =
             Specified_command_line_string_pt.begin();
           it != Specified_command_line_string_pt.end();
           it++)
      {
        oomph_info << it->first << " <string> " << std::endl
                   << it->second.doc << std::endl
                   << std::endl;
      }
 
      oomph_info << std::endl;
    }

References oomph::oomph_info, Specified_command_line_double_pt, Specified_command_line_flag, Specified_command_line_int_pt, Specified_command_line_string_pt, Specified_command_line_unsigned_pt, and oomph::Global_string_for_annotation::string().

Referenced by check_arg_index(), GlobalFct::get_residuals(), main(), and parse_and_assign().

doc_specified_flags()

void oomph::CommandLineArgs::doc_specified_flags

(

)

Document specified command line flags.

    {
      oomph_info << std::endl;
      oomph_info << "Specified (and recognised) command line flags:\n";
      oomph_info << "----------------------------------------------\n";
 
      for (std::map<std::string, ArgInfo<bool>>::iterator it =
             Specified_command_line_flag.begin();
           it != Specified_command_line_flag.end();
           it++)
      {
        if (it->second.is_set)
        {
          oomph_info << it->first << std::endl;
        }
      }
 
      for (std::map<std::string, ArgInfo<double>>::iterator it =
             Specified_command_line_double_pt.begin();
           it != Specified_command_line_double_pt.end();
           it++)
      {
        if (it->second.is_set)
        {
          oomph_info << it->first << " " << *(it->second.arg_pt) << std::endl;
        }
      }
 
      for (std::map<std::string, ArgInfo<int>>::iterator it =
             Specified_command_line_int_pt.begin();
           it != Specified_command_line_int_pt.end();
           it++)
      {
        if (it->second.is_set)
        {
          oomph_info << it->first << " " << *(it->second.arg_pt) << std::endl;
        }
      }
 
      for (std::map<std::string, ArgInfo<unsigned>>::iterator it =
             Specified_command_line_unsigned_pt.begin();
           it != Specified_command_line_unsigned_pt.end();
           it++)
      {
        if (it->second.is_set)
        {
          oomph_info << it->first << " " << *(it->second.arg_pt) << std::endl;
        }
      }
 
      for (std::map<std::string, ArgInfo<std::string>>::iterator it =
             Specified_command_line_string_pt.begin();
           it != Specified_command_line_string_pt.end();
           it++)
      {
        if (it->second.is_set)
        {
          oomph_info << it->first << " " << *(it->second.arg_pt) << std::endl;
        }
      }
 
      oomph_info << std::endl;
    }

References oomph::oomph_info, Specified_command_line_double_pt, Specified_command_line_flag, Specified_command_line_int_pt, Specified_command_line_string_pt, Specified_command_line_unsigned_pt, and oomph::Global_string_for_annotation::string().

Referenced by main().

output()

void oomph::CommandLineArgs::output

(

)

Doc the command line arguments.

    {
      oomph_info << "You are running the program: " << CommandLineArgs::Argv[0]
                 << std::endl;
      oomph_info << "with the following command line args: " << std::endl;
      std::stringstream str;
      for (int i = 1; i < CommandLineArgs::Argc; i++)
      {
        str << CommandLineArgs::Argv[i] << " ";
      }
      oomph_info << str.str() << std::endl;
    }

References Argc, Argv, i, oomph::oomph_info, and compute_granudrum_aor::str.

Referenced by check_arg_index().

parse_and_assign() [1/2]

void oomph::CommandLineArgs::parse_and_assign

(

const bool &

throw_on_unrecognised_args

)

Parse previously specified command line, check for recognised flags and assign associated values

    {
      parse_and_assign(Argc, Argv, throw_on_unrecognised_args);
    }

References Argc, Argv, and parse_and_assign().

parse_and_assign() [2/2]

void oomph::CommandLineArgs::parse_and_assign	(	int	argc,
		char *	argv[],
		const bool &	throw_on_unrecognised_args
	)

Parse command line, check for recognised flags and assign associated values

    {
      // Keep looping over command line arguments
      int arg_index = 1;
      while (arg_index < argc)
      {
        bool found_match = false;
 
        if ((strcmp(argv[arg_index], "-help") == 0) ||
            (strcmp(argv[arg_index], "--help") == 0))
        {
          oomph_info
            << "NOTE: You entered --help or -help on the command line\n";
          oomph_info << "so I'm going to tell you about this code's\n";
          oomph_info << "available command line flags and then return.\n";
          doc_available_flags();
 
#ifdef OOMPH_HAS_MPI
          int flag;
          MPI_Initialized(&flag);
          if (flag != 0) MPI_Helpers::finalize();
#endif
          oomph_info << "Shutting down...\n";
          exit(0);
        }
 
 
        // Check if the flag has been previously specified as a simple argument
        // free command line argument
        for (std::map<std::string, ArgInfo<bool>>::iterator it =
               Specified_command_line_flag.begin();
             it != Specified_command_line_flag.end();
             it++)
        {
          if (it->first == argv[arg_index])
          {
            Specified_command_line_flag[argv[arg_index]].is_set = true;
            found_match = true;
            break;
          }
        }
 
        if (!found_match)
        {
          // Check if the flag has been previously specified as a
          // command line argument that specifies (and is followed by) a double
          for (std::map<std::string, ArgInfo<double>>::iterator it =
                 Specified_command_line_double_pt.begin();
               it != Specified_command_line_double_pt.end();
               it++)
          {
            if (it->first == argv[arg_index])
            {
              // Next command line argument specifies the double. Set it via
              // the pointer
              arg_index++;
              check_arg_index(argc, arg_index);
              it->second.is_set = true;
              *(it->second.arg_pt) = atof(argv[arg_index]);
              found_match = true;
              break;
            }
          }
        }
 
 
        if (!found_match)
        {
          // Check if the flag has been previously specified as a
          // command line argument that specifies (and is followed by) an int
          for (std::map<std::string, ArgInfo<int>>::iterator it =
                 Specified_command_line_int_pt.begin();
               it != Specified_command_line_int_pt.end();
               it++)
          {
            if (it->first == argv[arg_index])
            {
              // Next command line argument specifies the int. Set it via
              // the pointer
              arg_index++;
              check_arg_index(argc, arg_index);
              it->second.is_set = true;
              *(it->second.arg_pt) = atoi(argv[arg_index]);
              found_match = true;
              break;
            }
          }
        }
 
 
        if (!found_match)
        {
          // Check if the flag has been previously specified as a
          // command line argument that specifies (and is followed by) an
          // unsigned
          for (std::map<std::string, ArgInfo<unsigned>>::iterator it =
                 Specified_command_line_unsigned_pt.begin();
               it != Specified_command_line_unsigned_pt.end();
               it++)
          {
            if (it->first == argv[arg_index])
            {
              // Next command line argument specifies the unsigned. Set it via
              // the pointer
              arg_index++;
              check_arg_index(argc, arg_index);
              it->second.is_set = true;
              *(it->second.arg_pt) = unsigned(atoi(argv[arg_index]));
              found_match = true;
              break;
            }
          }
        }
 
 
        if (!found_match)
        {
          // Check if the flag has been previously specified as a
          // command line argument that specifies (and is followed by) a string
          for (std::map<std::string, ArgInfo<std::string>>::iterator it =
                 Specified_command_line_string_pt.begin();
               it != Specified_command_line_string_pt.end();
               it++)
          {
            if (it->first == argv[arg_index])
            {
              // Next command line argument specifies the string. Set it via
              // the pointer
              arg_index++;
              check_arg_index(argc, arg_index);
              it->second.is_set = true;
              *(it->second.arg_pt) = argv[arg_index];
              found_match = true;
              break;
            }
          }
        }
 
 
        // Oh dear, we still haven't found the argument in the list.
        // Maybe it was specified wrongly -- issue warning.
        if (!found_match)
        {
          // Construct the error message
          std::string error_message = "Command line argument\n\n";
          error_message += argv[arg_index];
          error_message += "\n\nwas not recognised. This may be legal\n";
          error_message += "but seems sufficiently suspicious to flag up.\n";
          error_message += "If it should have been recognised, make sure you\n";
          error_message += "used the right number of \"-\" signs...\n";
 
          if (throw_on_unrecognised_args)
          {
            error_message += "Throwing an error because you requested it with";
            error_message += " throw_on_unrecognised_args option.";
            throw OomphLibError(
              error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
          }
          else
          {
            // Create an Oomph Lib warning
            OomphLibWarning(
              error_message, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
          }
        }
 
 
        arg_index++;
      }
    }

References check_arg_index(), doc_available_flags(), oomph::MPI_Helpers::finalize(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Specified_command_line_double_pt, Specified_command_line_flag, Specified_command_line_int_pt, Specified_command_line_string_pt, Specified_command_line_unsigned_pt, and oomph::Global_string_for_annotation::string().

Referenced by main(), and parse_and_assign().

setup()

void oomph::CommandLineArgs::setup	(	int	argc,
		char **	argv
	)

Set values.

    {
      Argc = argc;
      Argv = argv;
    }

References Argc, and Argv.

Referenced by main().

specify_command_line_flag() [1/5]

void oomph::CommandLineArgs::specify_command_line_flag	(	const std::string &	command_line_flag,
		const std::string &	doc
	)

Specify possible argument-free command line flag.

    {
      Specified_command_line_flag[command_line_flag] =
        ArgInfo<bool>(false, 0, doc);
    }

References Specified_command_line_flag.

Referenced by main().

specify_command_line_flag() [2/5]

void oomph::CommandLineArgs::specify_command_line_flag	(	const std::string &	command_line_flag,
		double *	arg_pt,
		const std::string &	doc
	)

Specify possible command line flag that specifies a double, accessed via pointer

    {
      Specified_command_line_double_pt[command_line_flag] =
        ArgInfo<double>(false, arg_pt, doc);
    }

References Specified_command_line_double_pt.

specify_command_line_flag() [3/5]

void oomph::CommandLineArgs::specify_command_line_flag	(	const std::string &	command_line_flag,
		int *	arg_pt,
		const std::string &	doc
	)

Specify possible command line flag that specifies an int, accessed via pointer

    {
      Specified_command_line_int_pt[command_line_flag] =
        ArgInfo<int>(false, arg_pt, doc);
    }

References Specified_command_line_int_pt.

specify_command_line_flag() [4/5]

void oomph::CommandLineArgs::specify_command_line_flag	(	const std::string &	command_line_flag,
		std::string *	arg_pt,
		const std::string &	doc
	)

Specify possible command line flag that specifies a string, accessed via pointer

    {
      Specified_command_line_string_pt[command_line_flag] =
        ArgInfo<std::string>(false, arg_pt, doc);
    }

References Specified_command_line_string_pt.

specify_command_line_flag() [5/5]

void oomph::CommandLineArgs::specify_command_line_flag	(	const std::string &	command_line_flag,
		unsigned *	arg_pt,
		const std::string &	doc
	)

Specify possible command line flag that specifies an unsigned, accessed via pointer

    {
      Specified_command_line_unsigned_pt[command_line_flag] =
        ArgInfo<unsigned>(false, arg_pt, doc);
    }

References Specified_command_line_unsigned_pt.

Variable Documentation

Argc

int oomph::CommandLineArgs::Argc

Number of arguments + 1.

Referenced by DeformableFishPoissonProblem< ELEMENT >::DeformableFishPoissonProblem(), demo_elastic_fish_poisson(), demo_fish_poisson(), demo_smoothing_with_nonlinear_elasticity(), TestPoissonProblem< ELEMENT >::doc_solution(), FSICollapsibleChannelProblem< ELEMENT >::doc_solution(), FSIDrivenCavityProblem< ELEMENT >::doc_solution(), PoissonProblem< ELEMENT >::doc_solution(), EighthSpherePoissonProblem< ELEMENT >::doc_solution(), FSIRingProblem::dynamic_run(), EighthSpherePoissonProblem< ELEMENT >::EighthSpherePoissonProblem(), ElasticCollapsibleChannelMesh< ELEMENT >::ElasticCollapsibleChannelMesh(), ElasticRefineableCollapsibleChannelMesh< ELEMENT >::ElasticRefineableCollapsibleChannelMesh(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), main(), output(), StaticDiskCompressionProblem< ELEMENT >::parameter_study(), parse_and_assign(), print_stacktrace(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), SheetGlueProblem< ELEMENT >::run(), BlockCompressionProblem< ELEMENT >::run(), DiskShockWaveProblem< ELEMENT, TIMESTEPPER >::run(), ShellProblem< ELEMENT >::run_it(), run_it(), setup(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::steady_run(), LinearWaveProblem< ELEMENT, TIMESTEPPER >::unsteady_run(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::unsteady_run(), and OscEllipseProblem< ELEMENT, TIMESTEPPER >::unsteady_run().

Argv

char ** oomph::CommandLineArgs::Argv

Arguments themselves.

Referenced by main(), output(), parse_and_assign(), print_stacktrace(), ElasticRingProblem< ELEMENT >::set_initial_conditions(), and setup().

Specified_command_line_double_pt

std::map< std::string, ArgInfo< double > > oomph::CommandLineArgs::Specified_command_line_double_pt

Map to associate an input flag with a double – specified via pointer.

Referenced by command_line_flag_has_been_set(), doc_all_flags(), doc_available_flags(), doc_specified_flags(), parse_and_assign(), and specify_command_line_flag().

Specified_command_line_flag

std::map< std::string, ArgInfo< bool > > oomph::CommandLineArgs::Specified_command_line_flag

Map to indicate an input flag as having been set.

Referenced by command_line_flag_has_been_set(), doc_all_flags(), doc_available_flags(), doc_specified_flags(), parse_and_assign(), and specify_command_line_flag().

Specified_command_line_int_pt

std::map< std::string, ArgInfo< int > > oomph::CommandLineArgs::Specified_command_line_int_pt

Map to associate an input flag with an int – specified via pointer.

Referenced by command_line_flag_has_been_set(), doc_all_flags(), doc_available_flags(), doc_specified_flags(), parse_and_assign(), and specify_command_line_flag().

Specified_command_line_string_pt

std::map< std::string, ArgInfo< std::string > > oomph::CommandLineArgs::Specified_command_line_string_pt

Map to associate an input flag with a string – specified via pointer.

Referenced by command_line_flag_has_been_set(), doc_all_flags(), doc_available_flags(), doc_specified_flags(), parse_and_assign(), and specify_command_line_flag().

Specified_command_line_unsigned_pt

std::map< std::string, ArgInfo< unsigned > > oomph::CommandLineArgs::Specified_command_line_unsigned_pt

Map to associate an input flag with an unsigned – specified via pointer.

Referenced by command_line_flag_has_been_set(), doc_all_flags(), doc_available_flags(), doc_specified_flags(), parse_and_assign(), and specify_command_line_flag().