#include <simulation.h>

Collaboration diagram for GRINS::Simulation:

Public Member Functions
	Simulation (const GetPot &input, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

	Simulation (const GetPot &input, GetPot &command_line, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm LIBMESH_CAN_DEFAULT_TO_COMMWORLD)

virtual	~Simulation ()

void	run ()

void	print_sim_info ()

SharedPtr< libMesh::EquationSystems >	get_equation_system ()

MultiphysicsSystem *	get_multiphysics_system ()

const MultiphysicsSystem *	get_multiphysics_system () const

libMesh::Number	get_qoi_value (unsigned int qoi_index) const

const std::string &	get_multiphysics_system_name () const

Protected Member Functions
void	read_restart (const GetPot &input)

void	init_multiphysics_system (const GetPot &input)
	Helper function. More...

void	init_qois (const GetPot &input, SimulationBuilder &sim_builder)
	Helper function. More...

void	init_params (const GetPot &input, SimulationBuilder &sim_builder)
	Helper function. More...

void	init_restart (const GetPot &input, SimulationBuilder &sim_builder, const libMesh::Parallel::Communicator &comm)
	Helper function. More...

void	check_for_unused_vars (const GetPot &input, bool warning_only)
	Helper function. More...

bool	check_for_adjoint_solve (const GetPot &input) const
	Helper function. More...

void	init_adjoint_solve (const GetPot &input, bool output_adjoint)
	Helper function. More...

void	build_error_estimator (const GetPot &input)

Protected Attributes
SharedPtr< libMesh::UnstructuredMesh >	_mesh

SharedPtr< libMesh::EquationSystems >	_equation_system

SharedPtr< GRINS::Solver >	_solver

std::string	_system_name
	GRINS::Multiphysics system name. More...

GRINS::MultiphysicsSystem *	_multiphysics_system

SharedPtr< GRINS::Visualization >	_vis

SharedPtr< PostProcessedQuantities< libMesh::Real > >	_postprocessing

bool	_print_mesh_info

bool	_print_log_info

bool	_print_equation_system_info

bool	_print_perflog

bool	_print_qoi

bool	_print_scalars

bool	_output_vis

bool	_output_adjoint

bool	_output_residual

bool	_output_residual_sensitivities

bool	_output_solution_sensitivities

unsigned int	_timesteps_per_vis

unsigned int	_timesteps_per_perflog

ErrorEstimatorOptions	_error_estimator_options

SharedPtr< libMesh::ErrorEstimator >	_error_estimator

ParameterManager	_adjoint_parameters

ParameterManager	_forward_parameters

bool	_do_adjoint_solve

bool	_have_restart

Private Member Functions
	Simulation ()

Detailed Description

Definition at line 62 of file simulation.h.

Constructor & Destructor Documentation

GRINS::Simulation::Simulation	(	const GetPot &	input,
		SimulationBuilder &	sim_builder,
		const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD
	)

GRINS::Simulation::Simulation	(	const GetPot &	input,
		GetPot &	command_line,
		SimulationBuilder &	sim_builder,
		const libMesh::Parallel::Communicator &comm	LIBMESH_CAN_DEFAULT_TO_COMMWORLD
	)

virtual GRINS::Simulation::~Simulation ( )

inlinevirtual

Definition at line 77 of file simulation.h.

77 {};

GRINS::Simulation::Simulation ( )

private

Member Function Documentation

void GRINS::Simulation::build_error_estimator ( const GetPot & input )

protected

Definition at line 540 of file simulation.C.

References _error_estimator, _error_estimator_options, _multiphysics_system, GRINS::ErrorEstimatorOptions::estimator_type(), GRINS::ErrorEstimatorFactoryBase::set_estimator_options(), GRINS::FactoryWithGetPot< libMesh::ErrorEstimator >::set_getpot(), and GRINS::ErrorEstimatorFactoryBase::set_system().

   {
     std::string estimator_type = _error_estimator_options.estimator_type();
     if( estimator_type != std::string("none") )
       {
         ErrorEstimatorFactoryBase::set_getpot(input);
         ErrorEstimatorFactoryBase::set_system(*_multiphysics_system);
         ErrorEstimatorFactoryBase::set_estimator_options(_error_estimator_options);
         _error_estimator.reset( (ErrorEstimatorFactoryBase::build(estimator_type)).release() );
       }
   }

bool GRINS::Simulation::check_for_adjoint_solve ( const GetPot & input ) const

protected

Helper function.

Todo:: This option name WILL change at some point.

Definition at line 518 of file simulation.C.

References _adjoint_parameters, _error_estimator_options, GRINS::StrategiesParsing::do_adjoint_solve(), GRINS::ErrorEstimatorOptions::estimator_requires_adjoint(), GRINS::ErrorEstimatorOptions::estimator_type(), and GRINS::ParameterManager::parameter_vector.

Referenced by init_adjoint_solve().

   {
     std::string error_estimator = _error_estimator_options.estimator_type();
 
     bool do_adjoint_solve = false;
 
     // First check if the error estimator requires an adjoint solve
     if( _error_estimator_options.estimator_requires_adjoint() )
       do_adjoint_solve = true;
 
     // Next check if parameter sensitivies require an adjoint solve
     if ( _adjoint_parameters.parameter_vector.size() )
       do_adjoint_solve = true;
 
     // Now check if the user requested to do an adjoint solve regardless
     if( StrategiesParsing::do_adjoint_solve(input) )
       do_adjoint_solve = true;
 
     return do_adjoint_solve;
   }

void GRINS::Simulation::check_for_unused_vars	(	const GetPot &	input,
		bool	warning_only
	)

protected

Helper function.

Definition at line 265 of file simulation.C.

   {
     /* Everything should be set up now, so check if there's any unused variables
        in the input file. If so, then tell the user what they were and error out. */
     std::vector<std::string> unused_vars = input.unidentified_variables();
 
     bool unused_vars_detected = false;
 
     // String we use to check if there is a variable in the Materials section
     std::string mat_string = "Materials/";
 
     // If we do have unused variables, make sure they are in the Materials
     // section since we're allowing those to be present and not used.
     if( !unused_vars.empty() )
       {
         int n_total = unused_vars.size();
 
         int n_mats = 0;
 
         for( int v = 0; v < n_total; v++ )
             if( (unused_vars[v]).find(mat_string) != std::string::npos )
               n_mats += 1;
 
         libmesh_assert_greater_equal( n_total, n_mats );
 
         if( n_mats < n_total )
           unused_vars_detected = true;
       }
 
     if( unused_vars_detected )
       {
         libMesh::err << "==========================================================" << std::endl;
         if( warning_only )
           libMesh::err << "Warning: ";
         else
           libMesh::err << "Error: ";
 
         libMesh::err << "Found unused variables!" << std::endl;
 
         for( std::vector<std::string>::const_iterator it = unused_vars.begin();
              it != unused_vars.end(); ++it )
           {
             // Don't print out any unused Material variables, since we allow these
             if( (*it).find(mat_string) != std::string::npos )
               continue;
 
             libMesh::err << *it << std::endl;
           }
         libMesh::err << "==========================================================" << std::endl;
 
         if( !warning_only )
           libmesh_error();
       }
 
     return;
   }

SharedPtr< libMesh::EquationSystems > GRINS::Simulation::get_equation_system ( )

Definition at line 442 of file simulation.C.

References _equation_system.

   {
     return _equation_system;
   }

MultiphysicsSystem * GRINS::Simulation::get_multiphysics_system ( )

inline

Definition at line 185 of file simulation.h.

References _multiphysics_system.

   {
     return this->_multiphysics_system;
   }

const MultiphysicsSystem * GRINS::Simulation::get_multiphysics_system ( ) const

inline

Definition at line 178 of file simulation.h.

References _multiphysics_system.

   {
     return this->_multiphysics_system;
   }

const std::string & GRINS::Simulation::get_multiphysics_system_name ( ) const

inline

Definition at line 191 of file simulation.h.

References _system_name.

   {
     return this->_system_name;
   }

libMesh::Number GRINS::Simulation::get_qoi_value ( unsigned int qoi_index ) const

Definition at line 447 of file simulation.C.

References _multiphysics_system, and GRINS::CompositeQoI::get_qoi_value().

   {
     const CompositeQoI* qoi = libMesh::libmesh_cast_ptr<const CompositeQoI*>(this->_multiphysics_system->get_qoi());
     return qoi->get_qoi_value(qoi_index);
   }

void GRINS::Simulation::init_adjoint_solve	(	const GetPot &	input,
		bool	output_adjoint
	)

protected

Helper function.

Definition at line 495 of file simulation.C.

References _do_adjoint_solve, _multiphysics_system, and check_for_adjoint_solve().

   {
     // Check if we're doing an adjoint solve
     _do_adjoint_solve = this->check_for_adjoint_solve(input);
 
     const libMesh::DifferentiableQoI* raw_qoi = _multiphysics_system->get_qoi();
     const CompositeQoI* qoi = dynamic_cast<const CompositeQoI*>( raw_qoi );
 
     // If we are trying to do an adjoint solve without a QoI, that's an error
     // If there are no QoIs, the CompositeQoI never gets built and qoi will be NULL
     if( _do_adjoint_solve && !qoi )
       {
         libmesh_error_msg("Error: Adjoint solve requested, but no QoIs detected.");
       }
 
     /* If we are not doing an adjoint solve, but adjoint output was requested:
        that's an error. */
     if( !_do_adjoint_solve && output_adjoint )
       {
         libmesh_error_msg("Error: Adjoint output requested, but no adjoint solve requested.");
       }
   }

void GRINS::Simulation::init_multiphysics_system ( const GetPot & input )

protected

Helper function.

Definition at line 142 of file simulation.C.

References _equation_system, _multiphysics_system, _postprocessing, _print_log_info, _solver, GRINS::MultiphysicsSystem::attach_physics_list(), GRINS::PhysicsBuilder::build_physics_map(), GRINS::StrategiesParsing::extra_quadrature_order(), GRINS::MultiphysicsSystem::read_input_options(), and GRINS::MultiphysicsSystem::register_postprocessing_vars().

   {
     // Only print libMesh logging info if the user requests it
     libMesh::perflog.disable_logging();
     if( this->_print_log_info ) libMesh::perflog.enable_logging();
 
     PhysicsList physics_list = PhysicsBuilder::build_physics_map(input);
 
     _multiphysics_system->attach_physics_list( physics_list );
 
     _multiphysics_system->read_input_options( input );
 
     _multiphysics_system->register_postprocessing_vars( input, *(_postprocessing) );
 
     /* Postprocessing needs to be initialized before the solver since that's
        where equation_system gets init'ed */
     _postprocessing->initialize( *_multiphysics_system, *_equation_system );
 
     _solver->initialize( input, _equation_system, _multiphysics_system );
 
     // Useful for debugging
     if( input("screen-options/print_dof_constraints", false ) )
       {
         _multiphysics_system->get_dof_map().print_dof_constraints();
       }
 
     // This *must* be done after equation_system->init in order to get variable indices
     // Set any extra quadrature order the user requested. By default, is 0.
     _multiphysics_system->extra_quadrature_order = StrategiesParsing::extra_quadrature_order(input);
   }

void GRINS::Simulation::init_params	(	const GetPot &	input,
		SimulationBuilder &	sim_builder
	)

protected

Helper function.

Definition at line 196 of file simulation.C.

References _adjoint_parameters, _forward_parameters, _multiphysics_system, and GRINS::ParameterManager::initialize().

   {
     unsigned int n_adjoint_parameters =
       input.vector_variable_size("QoI/adjoint_sensitivity_parameters");
 
     unsigned int n_forward_parameters =
       input.vector_variable_size("QoI/forward_sensitivity_parameters");
 
     // If the user actually asks for parameter sensitivities, then we
     // set up the parameter vectors to use.
     if ( n_adjoint_parameters )
       {
         // If we're doing adjoint sensitivities, dq/dp only makes
         // sense if we have q
         CompositeQoI* qoi =
           libMesh::cast_ptr<CompositeQoI*>
             (this->_multiphysics_system->get_qoi());
 
         if (!qoi)
           {
             std::cout <<
               "Error: adjoint_sensitivity_parameters are specified but\n"
               << "no QoIs have been specified.\n" << std::endl;
             libmesh_error();
           }
 
         _adjoint_parameters.initialize
           (input, "QoI/adjoint_sensitivity_parameters",
            *this->_multiphysics_system, qoi);
       }
 
     if ( n_forward_parameters )
       {
         // If we're doing forward sensitivities, du/dp can make
         // sense even with no q defined
         CompositeQoI* qoi =
           dynamic_cast<CompositeQoI*>
             (this->_multiphysics_system->get_qoi());
 
         // dynamic_cast returns NULL if our QoI isn't a CompositeQoI;
         // i.e. if there were no QoIs that made us bother setting up
         // the CompositeQoI object.  Passing NULL tells
         // ParameterManager not to bother asking for qoi registration
         // of parameters.
 
         _forward_parameters.initialize
           (input, "QoI/forward_sensitivity_parameters",
            *this->_multiphysics_system, qoi);
       }
   }

void GRINS::Simulation::init_qois	(	const GetPot &	input,
		SimulationBuilder &	sim_builder
	)

protected

Helper function.

Definition at line 173 of file simulation.C.

References _multiphysics_system, _print_qoi, and GRINS::SimulationBuilder::build_qoi().

   {
     // If the user actually asks for a QoI, then we add it.
     SharedPtr<CompositeQoI> qois = sim_builder.build_qoi( input );
     if( qois->n_qois() > 0 )
       {
         // This *must* be done after equation_system->init in order to get variable indices
         qois->init(input, *_multiphysics_system );
 
         /* Note that we are effectively transfering ownership of the qoi pointer because
            it will be cloned in _multiphysics_system and all the calculations are done there. */
         _multiphysics_system->attach_qoi( qois.get() );
       }
     else if (_print_qoi)
       {
         std::cout << "Error: print_qoi is specified but\n" <<
           "no QoIs have been specified.\n" << std::endl;
         libmesh_error();
       }
 
     return;
   }

void GRINS::Simulation::init_restart	(	const GetPot &	input,
		SimulationBuilder &	sim_builder,
		const libMesh::Parallel::Communicator &	comm
	)

protected

Helper function.

Definition at line 249 of file simulation.C.

References _equation_system, _mesh, GRINS::MeshBuilder::do_mesh_refinement_from_input(), GRINS::SimulationBuilder::mesh_builder(), and read_restart().

   {
     this->read_restart( input );
 
     /* We do this here only if there's a restart file. Otherwise, this was done
        at mesh construction time */
     sim_builder.mesh_builder().do_mesh_refinement_from_input( input, comm, *_mesh );
 
     /* \todo Any way to tell if the mesh got refined so we don't unnecessarily
        call reinit()? */
     _equation_system->reinit();
 
     return;
   }

void GRINS::Simulation::print_sim_info ( )

Definition at line 431 of file simulation.C.

References _equation_system, _mesh, _print_equation_system_info, and _print_mesh_info.

Referenced by run().

   {
     // Print mesh info if the user wants it
     if( this->_print_mesh_info ) this->_mesh->print_info();
 
     // Print info if requested
     if( this->_print_equation_system_info ) this->_equation_system->print_info();
 
     return;
   }

void GRINS::Simulation::read_restart ( const GetPot & input )

protected

Definition at line 453 of file simulation.C.

References _equation_system, _have_restart, and GRINS::SimulationParsing::restart_file().

Referenced by init_restart().

   {
     const std::string restart_file = SimulationParsing::restart_file(input);
 
     // Most of this was pulled from FIN-S
     if (restart_file != "none")
       {
         std::cout << " ====== Restarting from " << restart_file << std::endl;
 
         // Must have correct file type to restart
         if (restart_file.rfind(".xdr") < restart_file.size())
           _equation_system->read(restart_file,GRINSEnums::DECODE,
                                  //libMesh::EquationSystems::READ_HEADER |  // Allow for thermochemistry upgrades
                                  libMesh::EquationSystems::READ_DATA |
                                  libMesh::EquationSystems::READ_ADDITIONAL_DATA);
 
         else if  (restart_file.rfind(".xda") < restart_file.size())
           _equation_system->read(restart_file,GRINSEnums::READ,
                                  //libMesh::EquationSystems::READ_HEADER |  // Allow for thermochemistry upgrades
                                  libMesh::EquationSystems::READ_DATA |
                                  libMesh::EquationSystems::READ_ADDITIONAL_DATA);
 
         else
           {
             std::cerr << "Error: Restart filename must have .xdr or .xda extension!" << std::endl;
             libmesh_error();
           }
 
         this->_have_restart = true;
 
         const std::string system_name = input("screen-options/system_name", "GRINS" );
 
         MultiphysicsSystem& system =
           _equation_system->get_system<MultiphysicsSystem>(system_name);
 
         // Update the old data
         system.update();
       }
 
     return;
   }

void GRINS::Simulation::run ( )

Definition at line 322 of file simulation.C.

Referenced by main(), and run().

   {
     this->print_sim_info();
 
     SolverContext context;
     context.system = _multiphysics_system;
     context.equation_system = _equation_system;
     context.vis = _vis;
     context.output_adjoint = _output_adjoint;
     context.timesteps_per_vis = _timesteps_per_vis;
     context.timesteps_per_perflog = _timesteps_per_perflog;
     context.output_vis = _output_vis;
     context.output_residual = _output_residual;
     context.output_residual_sensitivities = _output_residual_sensitivities;
     context.output_solution_sensitivities = _output_solution_sensitivities;
     context.print_scalars = _print_scalars;
     context.print_perflog = _print_log_info;
     context.postprocessing = _postprocessing;
     context.error_estimator = _error_estimator;
     context.print_qoi = _print_qoi;
     context.do_adjoint_solve = _do_adjoint_solve;
     context.have_restart = _have_restart;
 
     if (_output_residual_sensitivities &&
         !_forward_parameters.parameter_vector.size())
     {
       std::cout <<
         "Error: output_residual_sensitivities is specified but\n" <<
         "no forward sensitivity parameters have been specified.\n" <<
         std::endl;
       libmesh_error();
     }
 
     if (_output_solution_sensitivities &&
         !_forward_parameters.parameter_vector.size())
     {
       std::cout <<
         "Error: output_solution_sensitivities is specified but\n" <<
         "no forward sensitivity parameters have been specified.\n" <<
         std::endl;
       libmesh_error();
     }
 
     _solver->solve( context );
 
     if ( this->_print_qoi )
       {
         _multiphysics_system->assemble_qoi();
         const CompositeQoI* my_qoi = libMesh::libmesh_cast_ptr<const CompositeQoI*>(this->_multiphysics_system->get_qoi());
         my_qoi->output_qoi( std::cout );
       }
 
     if ( _adjoint_parameters.parameter_vector.size() )
       {
         // Default: "calculate sensitivities for all QoIs"
         libMesh::QoISet qois;
 
         const libMesh::ParameterVector & params =
           _adjoint_parameters.parameter_vector;
 
         libMesh::SensitivityData sensitivities
           (qois, *this->_multiphysics_system, params);
 
         _solver->adjoint_qoi_parameter_sensitivity
           (context, qois, params, sensitivities);
 
         std::cout << "Adjoint sensitivities:" << std::endl;
 
         for (unsigned int q=0;
              q != this->_multiphysics_system->qoi.size(); ++q)
           {
             for (unsigned int p=0; p != params.size(); ++p)
               {
                 std::cout << "dq" << q << "/dp" << p << " = " <<
                         sensitivities[q][p] << std::endl;
               }
           }
       }
 
     if ( _forward_parameters.parameter_vector.size() )
       {
         // Default: "calculate sensitivities for all QoIs"
         libMesh::QoISet qois;
 
         const libMesh::ParameterVector & params =
           _forward_parameters.parameter_vector;
 
         libMesh::SensitivityData sensitivities
           (qois, *this->_multiphysics_system, params);
 
         _solver->forward_qoi_parameter_sensitivity
           (context, qois, params, sensitivities);
 
         std::cout << "Forward sensitivities:" << std::endl;
 
         for (unsigned int q=0;
              q != this->_multiphysics_system->qoi.size(); ++q)
           {
             for (unsigned int p=0; p != params.size(); ++p)
               {
                 std::cout << "dq" << q << "/dp" << p << " = " <<
                         sensitivities[q][p] << std::endl;
               }
           }
       }
 
     return;
   }

Member Data Documentation

ParameterManager GRINS::Simulation::_adjoint_parameters

protected

Definition at line 161 of file simulation.h.

Referenced by check_for_adjoint_solve(), init_params(), and run().

bool GRINS::Simulation::_do_adjoint_solve

protected

Definition at line 166 of file simulation.h.

Referenced by init_adjoint_solve(), and run().

SharedPtr<libMesh::EquationSystems> GRINS::Simulation::_equation_system

protected

Definition at line 126 of file simulation.h.

Referenced by get_equation_system(), init_multiphysics_system(), init_restart(), print_sim_info(), read_restart(), and run().

SharedPtr<libMesh::ErrorEstimator> GRINS::Simulation::_error_estimator

protected

Definition at line 159 of file simulation.h.

Referenced by build_error_estimator(), and run().

ErrorEstimatorOptions GRINS::Simulation::_error_estimator_options

protected

Definition at line 158 of file simulation.h.

Referenced by build_error_estimator(), and check_for_adjoint_solve().

ParameterManager GRINS::Simulation::_forward_parameters

protected

Definition at line 163 of file simulation.h.

Referenced by init_params(), and run().

bool GRINS::Simulation::_have_restart

protected

Definition at line 168 of file simulation.h.

Referenced by read_restart(), and run().

SharedPtr<libMesh::UnstructuredMesh> GRINS::Simulation::_mesh

protected

Definition at line 124 of file simulation.h.

Referenced by init_restart(), and print_sim_info().

GRINS::MultiphysicsSystem* GRINS::Simulation::_multiphysics_system

protected

Definition at line 134 of file simulation.h.

Referenced by build_error_estimator(), get_multiphysics_system(), get_qoi_value(), init_adjoint_solve(), init_multiphysics_system(), init_params(), init_qois(), and run().

bool GRINS::Simulation::_output_adjoint

protected

Definition at line 150 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual

protected

Definition at line 151 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_residual_sensitivities

protected

Definition at line 152 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_solution_sensitivities

protected

Definition at line 153 of file simulation.h.

Referenced by run().

bool GRINS::Simulation::_output_vis

protected

Definition at line 149 of file simulation.h.

Referenced by run().

SharedPtr<PostProcessedQuantities<libMesh::Real> > GRINS::Simulation::_postprocessing

protected

Definition at line 138 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_equation_system_info

protected

Definition at line 143 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_log_info

protected

Definition at line 142 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

bool GRINS::Simulation::_print_mesh_info

protected

Definition at line 141 of file simulation.h.

Referenced by print_sim_info().

bool GRINS::Simulation::_print_perflog

protected

Definition at line 144 of file simulation.h.

bool GRINS::Simulation::_print_qoi

protected

Definition at line 145 of file simulation.h.

Referenced by init_qois(), and run().

bool GRINS::Simulation::_print_scalars

protected

Definition at line 146 of file simulation.h.

Referenced by run().

SharedPtr<GRINS::Solver> GRINS::Simulation::_solver

protected

Definition at line 128 of file simulation.h.

Referenced by init_multiphysics_system(), and run().

std::string GRINS::Simulation::_system_name

protected

GRINS::Multiphysics system name.

Definition at line 131 of file simulation.h.

Referenced by get_multiphysics_system_name().

unsigned int GRINS::Simulation::_timesteps_per_perflog

protected

Definition at line 156 of file simulation.h.

Referenced by run().

unsigned int GRINS::Simulation::_timesteps_per_vis

protected

Definition at line 155 of file simulation.h.

Referenced by run().

SharedPtr<GRINS::Visualization> GRINS::Simulation::_vis

protected

Definition at line 136 of file simulation.h.

Referenced by run().

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

src/solver/include/grins/simulation.h
src/solver/src/simulation.C

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation