Base class for reading and handling initial conditions for physics classes. More...

#include <generic_ic_handler.h>

Inheritance diagram for GRINS::GenericICHandler:

Collaboration diagram for GRINS::GenericICHandler:

Public Member Functions
	GenericICHandler (const std::string &physics_name, const GetPot &input)

virtual	~GenericICHandler ()

void	attach_initial_func (const libMesh::FunctionBase< libMesh::Number > &initial_val)

virtual void	read_ic_data (const GetPot &input, const std::string &id_str, const std::string &ic_str, const std::string &var_str, const std::string &value_str)

virtual void	init_ic_data (const libMesh::FEMSystem &system, libMesh::CompositeFunction< libMesh::Number > &all_ics)
	Override this method to initialize any system-dependent data. More...

virtual int	string_to_int (const std::string &bc_type_in) const

virtual void	init_ic_types (const libMesh::subdomain_id_type ic_id, const std::string &ic_id_string, const int ic_type, const std::string &ic_vars_string, const std::string &ic_value_string, const GetPot &input)

libMesh::FunctionBase< libMesh::Number > *	get_ic_func () const

Protected Types
enum	IC_BASE { PARSED = -2, CONSTANT }

Protected Attributes
libMesh::AutoPtr< libMesh::FunctionBase< libMesh::Number > >	_ic_func

std::string	_physics_name

std::vector< std::string >	_subfunction_variables

Detailed Description

Base class for reading and handling initial conditions for physics classes.

Definition at line 44 of file generic_ic_handler.h.

Member Enumeration Documentation

enum GRINS::ICHandlingBase::IC_BASE

protectedinherited

Enumerator
PARSED
CONSTANT

Definition at line 90 of file ic_handling_base.h.

90 { PARSED = -2,

91 CONSTANT };

GRINS::ICHandlingBase::PARSED

Definition: ic_handling_base.h:90

GRINS::ICHandlingBase::CONSTANT

Definition: ic_handling_base.h:91

Constructor & Destructor Documentation

GRINS::GenericICHandler::GenericICHandler	(	const std::string &	physics_name,
		const GetPot &	input
	)

Definition at line 52 of file generic_ic_handler.C.

References GRINS::ICHandlingBase::_physics_name, and GRINS::ICHandlingBase::read_ic_data().

     : ICHandlingBase( physics_name )
   {
     std::string id_str = "Physics/"+_physics_name+"/ic_ids";
     std::string bc_str = "Physics/"+_physics_name+"/ic_types";
     std::string var_str = "Physics/"+_physics_name+"/ic_variables";
     std::string val_str = "Physics/"+_physics_name+"/ic_values";
 
     this->read_ic_data( input, id_str, bc_str, var_str, val_str );
 
     return;
   }

GRINS::GenericICHandler::~GenericICHandler ( )

virtual

Definition at line 66 of file generic_ic_handler.C.

   {
     return;
   }

Member Function Documentation

void GRINS::ICHandlingBase::attach_initial_func ( const libMesh::FunctionBase< libMesh::Number > & initial_val )

inherited

Definition at line 65 of file ic_handling_base.C.

   {
     _ic_func = initial_val.clone();
   }

libMesh::FunctionBase< libMesh::Number > * GRINS::ICHandlingBase::get_ic_func ( ) const

inlineinherited

Definition at line 99 of file ic_handling_base.h.

References GRINS::ICHandlingBase::_ic_func.

Referenced by GRINS::ICHandlingBase::init_ic_data().

   {
     return _ic_func.get();
   }

void GRINS::ICHandlingBase::init_ic_data	(	const libMesh::FEMSystem &	system,
		libMesh::CompositeFunction< libMesh::Number > &	all_ics
	)

virtualinherited

Override this method to initialize any system-dependent data.

Override this method to, for example, cache a System variable number.

Definition at line 129 of file ic_handling_base.C.

References GRINS::ICHandlingBase::_subfunction_variables, and GRINS::ICHandlingBase::get_ic_func().

Referenced by GRINS::Physics::init_ics().

   {
     if (this->get_ic_func())
       {
         std::vector<unsigned int> index_map;
 
         libmesh_assert(_subfunction_variables.size());
 
         for (unsigned int i=0; i != _subfunction_variables.size();
              ++i)
           index_map.push_back
             (system.variable_number(_subfunction_variables[i]));
 
         all_ics.attach_subfunction(*this->get_ic_func(), index_map);
       }
   }

void GRINS::ICHandlingBase::init_ic_types	(	const libMesh::subdomain_id_type	ic_id,
		const std::string &	ic_id_string,
		const int	ic_type,
		const std::string &	ic_vars_string,
		const std::string &	ic_value_string,
		const GetPot &	input
	)

virtualinherited

Definition at line 169 of file ic_handling_base.C.

References GRINS::ICHandlingBase::_ic_func, GRINS::ICHandlingBase::_physics_name, GRINS::ICHandlingBase::_subfunction_variables, GRINS::ICHandlingBase::CONSTANT, GRINS::ICHandlingBase::PARSED, and GRINS::StringUtilities::split_string().

Referenced by GRINS::ICHandlingBase::read_ic_data().

   {
     StringUtilities::split_string(ic_vars_string, ":", _subfunction_variables);
 
     libmesh_assert(_subfunction_variables.size());
 
     switch(ic_type)
       {
       case(PARSED):
         {
           _ic_func = libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> >
             (new libMesh::ParsedFunction<libMesh::Number>(ic_value_string));
         }
         break;
 
       case(CONSTANT):
         {
           _ic_func = libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> >
             (new libMesh::ConstFunction<libMesh::Number>
               (StringUtilities::string_to_T<libMesh::Number>(ic_value_string)));
         }
         break;
 
       default:
         {
           std::cerr << "==========================================================" 
                     << "Error: Invalid IC type for " << _physics_name << std::endl
                     << "       Detected IC type was " << ic_type << std::endl
                     << "==========================================================" << std::endl;
           libmesh_error();
         }
       }
     return;
   }

void GRINS::ICHandlingBase::read_ic_data	(	const GetPot &	input,
		const std::string &	id_str,
		const std::string &	ic_str,
		const std::string &	var_str,
		const std::string &	value_str
	)

virtualinherited

Definition at line 70 of file ic_handling_base.C.

References GRINS::ICHandlingBase::init_ic_types(), and GRINS::ICHandlingBase::string_to_int().

Referenced by GenericICHandler().

   {
     int num_ids = input.vector_variable_size(id_str);
     int num_ics = input.vector_variable_size(ic_str);
     int num_vars = input.vector_variable_size(var_str);
     int num_values = input.vector_variable_size(value_str);
 
     if( num_ids != num_ics )
       {
         std::cerr << "Error: number of subdomain ids " << num_ids
                   << "must equal number of initial condition types " << num_ics
                   << std::endl;
         libmesh_error();
       }
 
     if( num_ids != num_vars )
       {
         std::cerr << "Error: number of subdomain ids " << num_ids
                   << "must equal number of variable name lists " << num_vars
                   << std::endl;
         libmesh_error();
       }
 
     if( num_ids != num_values )
       {
         std::cerr << "Error: number of subdomain ids " << num_ids
                   << "must equal number of initial condition values " << num_values
                   << std::endl;
         libmesh_error();
       }
 
     if( num_ids > 1 )
       {
         std::cerr << "Error: GRINS does not yet support per-subdomain initial conditions" << std::endl;
         libmesh_not_implemented();
       }
 
     for( int i = 0; i < num_ids; i++ )
       {
         int ic_id = input(id_str, -1, i );
         std::string ic_type_in = input(ic_str, "NULL", i );
         std::string ic_value_in = input(value_str, "NULL", i );
         std::string ic_vars_in = input(var_str, "NULL", i );
 
         int ic_type = this->string_to_int( ic_type_in );
 
         std::stringstream ss;
         ss << ic_id;
         std::string ic_id_string = ss.str();
 
         this->init_ic_types( ic_id, ic_id_string, ic_type, ic_vars_in, ic_value_in, input );
       }
 
     return;
   }

int GRINS::ICHandlingBase::string_to_int ( const std::string & bc_type_in ) const

virtualinherited

Definition at line 147 of file ic_handling_base.C.

References GRINS::ICHandlingBase::_physics_name, GRINS::ICHandlingBase::CONSTANT, and GRINS::ICHandlingBase::PARSED.

Referenced by GRINS::ICHandlingBase::read_ic_data().

   {
     int ic_type_out;
     if( ic_type_in == "parsed" )
       {
         ic_type_out = PARSED;
       }
     else if( ic_type_in == "constant" )
       {
         ic_type_out = CONSTANT;
       }
     else
       {
         std::cerr << "=========================================================="  << std::endl
                   << "Error: Invalid ic_type " << ic_type_in                       << std::endl
                   << "       Physics class is " << _physics_name                   << std::endl
                   << "=========================================================="  << std::endl;
         libmesh_error();
       }
     return ic_type_out;
   }

Member Data Documentation

libMesh::AutoPtr<libMesh::FunctionBase<libMesh::Number> > GRINS::ICHandlingBase::_ic_func

protectedinherited

Definition at line 86 of file ic_handling_base.h.

Referenced by GRINS::ICHandlingBase::get_ic_func(), and GRINS::ICHandlingBase::init_ic_types().

std::string GRINS::ICHandlingBase::_physics_name

protectedinherited

Definition at line 88 of file ic_handling_base.h.

Referenced by GenericICHandler(), GRINS::ICHandlingBase::init_ic_types(), and GRINS::ICHandlingBase::string_to_int().

std::vector<std::string> GRINS::ICHandlingBase::_subfunction_variables

protectedinherited

Definition at line 93 of file ic_handling_base.h.

Referenced by GRINS::ICHandlingBase::init_ic_data(), and GRINS::ICHandlingBase::init_ic_types().

The documentation for this class was generated from the following files:

src/ic_handling/include/grins/generic_ic_handler.h
src/ic_handling/src/generic_ic_handler.C

Public Member Functions

Protected Types

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation