GRINS::PressurePinning Class Reference

Class to hold typical boundary condition methods. More...

#include <pressure_pinning.h>

Public Member Functions
	PressurePinning (const GetPot &input, const std::string &physics_name)
	~PressurePinning ()
void	check_pin_location (const libMesh::MeshBase &mesh)
	Check the mesh to ensure pin location is found. More...
void	pin_value (libMesh::DiffContext &context, const bool request_jacobian, const GRINS::VariableIndex var, const double penalty=1.0)
	The idea here is to pin a variable to a particular value if there is a null space - e.g. More...

Private Attributes
libMesh::Number	_pin_value
	Value of pressure we wish to pin. More...
libMesh::Point	_pin_location
	Location we want to pin the pressure. More...
libMesh::dof_id_type	_pinned_elem_id
	Cache element id for element that contains _pin_location. More...

Detailed Description

Class to hold typical boundary condition methods.

This class holds functions to apply generic versions of Dirichlet and Neumann boundary conditions.

Definition at line 52 of file pressure_pinning.h.

Constructor & Destructor Documentation

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

Definition at line 42 of file pressure_pinning.C.

References _pin_location, and _pin_value.

    : _pinned_elem_id(libMesh::DofObject::invalid_id)
  {
    _pin_value = input("Physics/"+physics_name+"/pin_value", 0.0 );

    unsigned int pin_loc_dim = input.vector_variable_size("Physics/"+physics_name+"/pin_location");

    // If the user is specifying a pin_location, it had better be at least 2-dimensional
    if( pin_loc_dim > 0 && pin_loc_dim < 2 )
      {
        std::cerr << "Error: pressure pin location must be at least 2 dimensional"
                  << std::endl;
        libmesh_error();
      }

    _pin_location(0) = input("Physics/"+physics_name+"/pin_location", 0.0, 0 );

    if( pin_loc_dim > 1 )
      _pin_location(1) = input("Physics/"+physics_name+"/pin_location", 0.0, 1 );

    if( pin_loc_dim == 3 )
      _pin_location(2) = input("Physics/"+physics_name+"/pin_location", 0.0, 2 );

    return;
  }

GRINS::PressurePinning::~PressurePinning

(

)

Definition at line 69 of file pressure_pinning.C.

  {
    return;
  }

Member Function Documentation

void GRINS::PressurePinning::check_pin_location

(

const libMesh::MeshBase &

mesh

)

Check the mesh to ensure pin location is found.

If the pin location is found, we set _pin_location_found to true (for assertion later). If not found, we throw an error.

Definition at line 74 of file pressure_pinning.C.

References _pin_location, and _pinned_elem_id.

Referenced by GRINS::VariablePinning::auxiliary_init().

  {
    // We need to reset to invalid_id since this may not be the first time called
    _pinned_elem_id = libMesh::DofObject::invalid_id;

    libMesh::MeshBase::const_element_iterator el = mesh.active_local_elements_begin();
    const libMesh::MeshBase::const_element_iterator end_el = mesh.active_local_elements_end();

    for ( ; el != end_el; ++el)
      {
        const libMesh::Elem* elem = *el;

        if( elem->contains_point(_pin_location) )
          {
            _pinned_elem_id = elem->id();
            break;
          }
      }

    // If we found the point on one of the processors, then we need
    // to tell all the others. invalid_id is exceedingly large,
    // so if we found an element, that id should be the smallest
    mesh.comm().min( _pinned_elem_id );

    if( _pinned_elem_id == libMesh::DofObject::invalid_id )
      {
        libMesh::err << "ERROR: Could not locate point " << _pin_location
                     << " in mesh!" << std::endl;
        libmesh_error();
      }
  }

void GRINS::PressurePinning::pin_value	(	libMesh::DiffContext &	context,
		const bool	request_jacobian,
		const GRINS::VariableIndex	var,
		const double	penalty = 1.0
	)

The idea here is to pin a variable to a particular value if there is a null space - e.g.

pressure for IncompressibleNavierStokes.

Todo:

pin_location needs to be const. Currently a libMesh restriction.

Todo:

What the hell is the c.get_elem_solution_derivative() all about?

Definition at line 106 of file pressure_pinning.C.

References _pin_location, _pin_value, and _pinned_elem_id.

  {
    // Make sure we've called check_pin_location() and that pin location
    // is in the mesh somewhere
    libmesh_assert_not_equal_to( _pinned_elem_id, libMesh::DofObject::invalid_id );

    AssemblyContext &c = libMesh::cast_ref<AssemblyContext&>(context);

    if( c.get_elem().id() == _pinned_elem_id )
      {
        // This is redundant for vast majority of cases, but we trying to
        // be prepared for cases involving, e.g. mesh motion that we're not
        // currently handling.
        if( !c.get_elem().contains_point(_pin_location) )
          {
            libmesh_error_msg("ERROR: _pin_location not in the current element!");
          }

        libMesh::DenseSubVector<libMesh::Number> &F_var = c.get_elem_residual(var); // residual
        libMesh::DenseSubMatrix<libMesh::Number> &K_var = c.get_elem_jacobian(var, var); // jacobian

        // The number of local degrees of freedom in p variable.
        const unsigned int n_var_dofs = c.get_dof_indices(var).size();

        libMesh::Number var_value = c.point_value(var, _pin_location);

        libMesh::FEType fe_type = c.get_element_fe(var)->get_fe_type();

        libMesh::Point point_loc_in_masterelem =
          libMesh::FEInterface::inverse_map(c.get_dim(), fe_type, &c.get_elem(), _pin_location);

        std::vector<libMesh::Real> phi(n_var_dofs);

        for (unsigned int i=0; i != n_var_dofs; i++)
          phi[i] = libMesh::FEInterface::shape( c.get_dim(), fe_type, &c.get_elem(), i,
                                                point_loc_in_masterelem );

        for (unsigned int i=0; i != n_var_dofs; i++)
          {
            F_var(i) += penalty*(var_value - _pin_value)*phi[i];

            if (request_jacobian && c.get_elem_solution_derivative())
              {
                libmesh_assert (c.get_elem_solution_derivative() == 1.0);

                for (unsigned int j=0; j != n_var_dofs; j++)
                  K_var(i,j) += penalty*phi[i]*phi[j];

              } // End if request_jacobian
          } // End i loop
      } // End if pin_location

    return;
  }

Member Data Documentation

libMesh::Point GRINS::PressurePinning::_pin_location

private

Location we want to pin the pressure.

Definition at line 78 of file pressure_pinning.h.

Referenced by check_pin_location(), pin_value(), and PressurePinning().

libMesh::Number GRINS::PressurePinning::_pin_value

private

Value of pressure we wish to pin.

Definition at line 75 of file pressure_pinning.h.

Referenced by pin_value(), and PressurePinning().

libMesh::dof_id_type GRINS::PressurePinning::_pinned_elem_id

private

Cache element id for element that contains _pin_location.

We will initalize this to libMesh::DofObject::invalid_id and use that to check whether or not we located an element that contains the _pin_location.

Definition at line 84 of file pressure_pinning.h.

Referenced by check_pin_location(), and pin_value().

---

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

• src/boundary_conditions/include/grins/pressure_pinning.h
• src/boundary_conditions/src/pressure_pinning.C