#include <average_nusselt_number.h>

Inheritance diagram for GRINS::AverageNusseltNumber:

Collaboration diagram for GRINS::AverageNusseltNumber:

Public Member Functions
	AverageNusseltNumber (const std::string &qoi_name)

virtual	~AverageNusseltNumber ()

virtual QoIBase *	clone () const
	Clone this QoI. More...

virtual bool	assemble_on_interior () const
	Does the QoI need an element interior assembly loop? More...

virtual bool	assemble_on_sides () const
	Does the QoI need a domain boundary assembly loop? More...

virtual void	side_qoi (AssemblyContext &context, const unsigned int qoi_index)
	Compute the qoi value on the domain boundary. More...

virtual void	side_qoi_derivative (AssemblyContext &context, const unsigned int qoi_index)
	Compute the qoi derivative with respect to the solution on the domain boundary. More...

virtual void	init (const GetPot &input, const MultiphysicsSystem &system, unsigned int qoi_num)
	Method to allow QoI to cache any system information needed for QoI calculation, for example, solution variable indices. More...

virtual void	init_context (AssemblyContext &context)

Public Member Functions inherited from GRINS::QoIBase
	QoIBase (const std::string &qoi_name)

virtual	~QoIBase ()

virtual void	element_qoi (AssemblyContext &context, const unsigned int qoi_index)
	Compute the qoi value for element interiors. More...

virtual void	element_qoi_derivative (AssemblyContext &context, const unsigned int qoi_index)
	Compute the qoi derivative with respect to the solution on element interiors. More...

virtual void	parallel_op (const libMesh::Parallel::Communicator &communicator, libMesh::Number &sys_qoi, libMesh::Number &local_qoi)
	Call the parallel operation for this QoI and cache the value. More...

virtual void	thread_join (libMesh::Number &qoi, const libMesh::Number &other_qoi)
	Call the operation to accumulate this QoI from multiple threads. More...

virtual void	output_qoi (std::ostream &out) const
	Basic output for computed QoI's. More...

libMesh::Number	value () const
	Returns the current QoI value. More...

const std::string &	name () const
	Returns the name of this QoI. More...

Public Member Functions inherited from GRINS::ParameterUser
	ParameterUser (const std::string &user_name)

virtual	~ParameterUser ()

virtual void	set_parameter (libMesh::Number &param_variable, const GetPot &input, const std::string &param_name, libMesh::Number param_default)
	Each subclass can simultaneously read a parameter value from. More...

virtual void	set_parameter (libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...

virtual void	set_parameter (libMesh::ParsedFEMFunction< libMesh::Number > &func, const GetPot &input, const std::string &func_param_name, const std::string &param_default)
	Each subclass can simultaneously read a parsed function from. More...

virtual void	move_parameter (const libMesh::Number &old_parameter, libMesh::Number &new_parameter)
	When cloning an object, we need to update parameter pointers. More...

virtual void	move_parameter (const libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &old_func, libMesh::ParsedFunction< libMesh::Number, libMesh::Gradient > &new_func)
	When cloning an object, we need to update parameter pointers. More...

virtual void	move_parameter (const libMesh::ParsedFEMFunction< libMesh::Number > &old_func, libMesh::ParsedFEMFunction< libMesh::Number > &new_func)
	When cloning an object, we need to update parameter pointers. More...

virtual void	register_parameter (const std::string &param_name, libMesh::ParameterMultiAccessor< libMesh::Number > &param_pointer) const
	Each subclass will register its copy of an independent. More...

Protected Member Functions
void	parse_thermal_conductivity (const GetPot &input)

Protected Attributes
libMesh::Real	_k
	Thermal conductivity. More...

VariableIndex	_T_var
	Temperature variable index. More...

std::set< libMesh::boundary_id_type >	_bc_ids
	List of boundary ids for which we want to compute this QoI. More...

libMesh::Real	_scaling
	Scaling constant. More...

Protected Attributes inherited from GRINS::QoIBase
std::string	_qoi_name

libMesh::Number	_qoi_value

Private Member Functions
	AverageNusseltNumber ()

Additional Inherited Members
Static Public Attributes inherited from GRINS::ParameterUser
static std::string	zero_vector_function = std::string("{0}")
	A parseable function string with LIBMESH_DIM components, all 0. More...

Detailed Description

Definition at line 35 of file average_nusselt_number.h.

Constructor & Destructor Documentation

GRINS::AverageNusseltNumber::AverageNusseltNumber ( const std::string & qoi_name )

Definition at line 41 of file average_nusselt_number.C.

     : QoIBase(qoi_name)
   {
     return;
   }

GRINS::AverageNusseltNumber::~AverageNusseltNumber ( )

virtual

Definition at line 47 of file average_nusselt_number.C.

   {
     return;
   }

GRINS::AverageNusseltNumber::AverageNusseltNumber ( )

private

Referenced by clone().

Member Function Documentation

bool GRINS::AverageNusseltNumber::assemble_on_interior ( ) const

inlinevirtual

Does the QoI need an element interior assembly loop?

This is pure virtual to force to user to specify.

Implements GRINS::QoIBase.

Definition at line 84 of file average_nusselt_number.h.

   {
     return false;
   }

bool GRINS::AverageNusseltNumber::assemble_on_sides ( ) const

inlinevirtual

Does the QoI need a domain boundary assembly loop?

This is pure virtual to force to user to specify.

Implements GRINS::QoIBase.

Definition at line 90 of file average_nusselt_number.h.

   {
     return true;
   }

QoIBase * GRINS::AverageNusseltNumber::clone ( ) const

virtual

Clone this QoI.

We return a raw pointer, but it is expected for the user to take ownership and delete the object when done.

Implements GRINS::QoIBase.

Definition at line 52 of file average_nusselt_number.C.

References _k, _scaling, AverageNusseltNumber(), and GRINS::ParameterUser::move_parameter().

   {
     AverageNusseltNumber *returnval = new AverageNusseltNumber( *this );
     returnval->move_parameter(_k, returnval->_k);
     returnval->move_parameter(_scaling, returnval->_scaling);
     return returnval;
   }

void GRINS::AverageNusseltNumber::init	(	const GetPot &	input,
		const MultiphysicsSystem &	system,
		unsigned int	qoi_num
	)

virtual

Method to allow QoI to cache any system information needed for QoI calculation, for example, solution variable indices.

Reimplemented from GRINS::QoIBase.

Definition at line 61 of file average_nusselt_number.C.

References GRINS::T_var_name_default.

   {
     this->parse_thermal_conductivity(input);
 
     this->set_parameter
       ( _scaling, input, "QoI/NusseltNumber/scaling", 1.0 );
 
     if( this->_k < 0.0 )
       {
         std::cerr << "Error: thermal conductivity for AverageNusseltNumber must be positive." << std::endl
                   << "Found k = " << _k << std::endl;
         libmesh_error();
       }
 
     // Read boundary ids for which we want to compute
     int num_bcs =  input.vector_variable_size("QoI/NusseltNumber/bc_ids");
 
     if( num_bcs <= 0 )
       {
         std::cerr << "Error: Must specify at least one boundary id to compute"
                   << " average Nusselt number." << std::endl
                   << "Found: " << num_bcs << std::endl;
         libmesh_error();
       }
 
     for( int i = 0; i < num_bcs; i++ )
       {
         _bc_ids.insert( input("QoI/NusseltNumber/bc_ids", -1, i ) );
       }
 
     // Grab temperature variable index
     std::string T_var_name = input( "Physics/VariableNames/Temperature",
                                     T_var_name_default );
 
     this->_T_var = system.variable_number(T_var_name);
 
     return;
   }

void GRINS::AverageNusseltNumber::init_context ( AssemblyContext & context )

virtual

Reimplemented from GRINS::QoIBase.

Definition at line 102 of file average_nusselt_number.C.

References _T_var.

   {
     libMesh::FEBase* T_fe;
 
     context.get_side_fe<libMesh::Real>(this->_T_var, T_fe);
 
     T_fe->get_dphi();
     T_fe->get_JxW();
 
     return;
   }

void GRINS::AverageNusseltNumber::parse_thermal_conductivity ( const GetPot & input )

protected

Definition at line 204 of file average_nusselt_number.C.

References _k, GRINS::MaterialsParsing::dep_input_warning(), GRINS::MaterialsParsing::duplicate_input_test(), and GRINS::ParameterUser::set_parameter().

   {
     std::string material = input("QoI/NusseltNumber/material", "NoMaterial!");
 
     MaterialsParsing::duplicate_input_test(input,
                                                "Materials/"+material+"/ThermalConductivity/value",
                                                "QoI/NusseltNumber/thermal_conductivity");
 
     // Parse the old version
     if( input.have_variable("QoI/NusseltNumber/thermal_conductivity") )
       {
         MaterialsParsing::dep_input_warning( "QoI/NusseltNumber/thermal_conductivity",
                                              "ThermalConductivity/value" );
 
         this->set_parameter
           ( _k, input, "QoI/NusseltNumber/thermal_conductivity", -1.0 );
       }
     // Parse new version
     else if( input.have_variable("Materials/"+material+"/ThermalConductivity/value") )
       {
         // This is currently only valid for constant thermal conductivity models
         if( input("Materials/"+material+"/ThermalConductivity/model", "DIE!")
             != std::string("constant") )
           {
             libmesh_error_msg("ERROR: Only constant ThermalConductivity model supported in NusseltNumber!");
           }
 
         this->set_parameter
           ( _k, input, "Materials/"+material+"/ThermalConductivity/value", -1.0 );
       }
     else
       libmesh_error_msg("ERROR: Could not find valid thermal conducitivity value!");
 
     // thermal conducivity should be positive
     if( _k <= 0.0 )
       libmesh_error_msg("ERROR: Detected non-positive thermal conductivity!");
   }

void GRINS::AverageNusseltNumber::side_qoi	(	AssemblyContext &	context,
		const unsigned int	qoi_index
	)

virtual

Compute the qoi value on the domain boundary.

Override this method if your QoI is defined on the domain boundary

Reimplemented from GRINS::QoIBase.

Definition at line 114 of file average_nusselt_number.C.

References _bc_ids, _k, _scaling, and _T_var.

   {
     bool on_correct_side = false;
 
     for (std::set<libMesh::boundary_id_type>::const_iterator id =
          _bc_ids.begin(); id != _bc_ids.end(); id++ )
       if( context.has_side_boundary_id( (*id) ) )
         {
           on_correct_side = true;
           break;
         }
 
     if (!on_correct_side)
       return;
 
     libMesh::FEBase* side_fe;
     context.get_side_fe<libMesh::Real>(this->_T_var, side_fe);
 
     const std::vector<libMesh::Real> &JxW = side_fe->get_JxW();
 
     const std::vector<libMesh::Point>& normals = side_fe->get_normals();
 
     unsigned int n_qpoints = context.get_side_qrule().n_points();
 
     libMesh::Number& qoi = context.get_qois()[qoi_index];
 
     // Loop over quadrature points
 
     for (unsigned int qp = 0; qp != n_qpoints; qp++)
       {
         // Get the solution value at the quadrature point
         libMesh::Gradient grad_T = 0.0;
         context.side_gradient(this->_T_var, qp, grad_T);
 
         // Update the elemental increment dR for each qp
         qoi += (this->_scaling)*(this->_k)*(grad_T*normals[qp])*JxW[qp];
 
       } // quadrature loop
   }

void GRINS::AverageNusseltNumber::side_qoi_derivative	(	AssemblyContext &	context,
		const unsigned int	qoi_index
	)

virtual

Compute the qoi derivative with respect to the solution on the domain boundary.

Override this method if your QoI is defined on the domain boundary

Reimplemented from GRINS::QoIBase.

Definition at line 155 of file average_nusselt_number.C.

References _bc_ids, _k, _scaling, and _T_var.

   {
 
     for( std::set<libMesh::boundary_id_type>::const_iterator id = _bc_ids.begin();
          id != _bc_ids.end(); id++ )
       {
         if( context.has_side_boundary_id( (*id) ) )
           {
             libMesh::FEBase* T_side_fe;
             context.get_side_fe<libMesh::Real>(this->_T_var, T_side_fe);
 
             const std::vector<libMesh::Real> &JxW = T_side_fe->get_JxW();
             
             const std::vector<libMesh::Point>& normals = T_side_fe->get_normals();
 
             unsigned int n_qpoints = context.get_side_qrule().n_points();
             
             const unsigned int n_T_dofs = context.get_dof_indices(_T_var).size();
 
             const std::vector<std::vector<libMesh::Gradient> >& T_gradphi = T_side_fe->get_dphi();
 
             libMesh::DenseSubVector<libMesh::Number>& dQ_dT =
               context.get_qoi_derivatives(qoi_index, _T_var);
 
             // Loop over quadrature points  
             for (unsigned int qp = 0; qp != n_qpoints; qp++)
               {
                 // Get the solution value at the quadrature point
                 libMesh::Gradient grad_T = 0.0; 
                 context.side_gradient(this->_T_var, qp, grad_T);
                 
                 // Update the elemental increment dR for each qp
                 //qoi += (this->_scaling)*(this->_k)*(grad_T*normals[qp])*JxW[qp];
 
                 for( unsigned int i = 0; i != n_T_dofs; i++ )
                   {
                     dQ_dT(i) += _scaling*_k*T_gradphi[i][qp]*normals[qp]*JxW[qp];
                   }
 
               } // quadrature loop
 
           } // end check on boundary id
 
       }
 
     return;
   }