BrethertonElement< ELEMENT > Class Template Reference

Inheritance diagram for BrethertonElement< ELEMENT >:

Public Types
typedef void(*	InflowFctPt) (const Vector< double > &x, Vector< double > &veloc)

Public Member Functions
	BrethertonElement ()
	Constructor: Call the constructor of the underlying element. More...
void	activate_inflow_dependency_on_external_data (const Vector< Data * > &inflow_ext_data, const unsigned &inflow_boundary, InflowFctPt inflow_fct_pt)
void	assign_local_eqn_numbers (const bool &store_local_dof_pt)
void	get_jacobian (Vector< double > &residuals, DenseMatrix< double > &jacobian)

Private Member Functions
void	reassign_inflow ()

Private Attributes
Vector< Data * >	Inflow_ext_data
	Storage for the external Data that affects the inflow. More...
DenseMatrix< int >	Inflow_ext_data_eqn
unsigned	Inflow_boundary
	Number of the inflow boundary in the global mesh. More...
InflowFctPt	Inflow_fct_pt

Detailed Description

template<class ELEMENT>
class BrethertonElement< ELEMENT >

"Bretherton element" is a fluid element (of type ELEMENT) for which the (inflow) velocity at those nodes that are located on a specified Mesh boundary is prescribed by Dirichlet boundary conditions. The key is that prescribed velocity profile can be a function of some external Data – this dependency must be taken into account when computing the element's Jacobian matrix.

This element type is useful, for instance, in the Bretherton problem, where the parabolic "inflow" profile is a function of the film thickness (represented by Spine heights) at the "outflow".

Member Typedef Documentation

InflowFctPt

template<class ELEMENT >

typedef void(* BrethertonElement< ELEMENT >::InflowFctPt) (const Vector< double > &x, Vector< double > &veloc)

Typedef for pointer (global) function that specifies the the inflow

Constructor & Destructor Documentation

BrethertonElement()

template<class ELEMENT >

BrethertonElement< ELEMENT >::BrethertonElement ( )

inline

Constructor: Call the constructor of the underlying element.

: ELEMENT() {}

Member Function Documentation

activate_inflow_dependency_on_external_data()

template<class ELEMENT >

void BrethertonElement< ELEMENT >::activate_inflow_dependency_on_external_data ( const Vector< Data * > &  inflow_ext_data, const unsigned &  inflow_boundary, InflowFctPt  inflow_fct_pt  )

inline

Activate the dependency of the "inflow" on the external data. Pass the vector of pointers to the external Data that affects the inflow, the id of the boundary on which the inflow condition is to be applied and the function pointer to to the global function that defines the inflow

  {
   // Copy data that affects the inflow
   unsigned n_ext=inflow_ext_data.size();
   Inflow_ext_data.resize(n_ext);
   for (unsigned i=0;i<n_ext;i++)
    {
     Inflow_ext_data[i]=inflow_ext_data[i];
    }
   // Set inflow boundary
   Inflow_boundary=inflow_boundary;
   // Set fct pointer to inflow condition
   Inflow_fct_pt=inflow_fct_pt;
  }

References i.

assign_local_eqn_numbers()

template<class ELEMENT >

void BrethertonElement< ELEMENT >::assign_local_eqn_numbers ( const bool &  store_local_dof_pt )

inline

Overload assign local equation numbers: Add the dependency on the external Data that affects the inflow profile

  {
   // Call the element's local equation numbering procedure first
   ELEMENT::assign_local_eqn_numbers(store_local_dof_pt);
   
   // Now add the equation numbers for the Data that affects the inflow
   // profile
   
   // Number of local equations so far
   unsigned local_eqn_count = this->ndof();
   
   // Find out max. number of values stored at all Data values 
   // that affect the inflow
   unsigned max_nvalue=0;
   unsigned n_ext=Inflow_ext_data.size();
   for (unsigned i=0;i<n_ext;i++)
    {
     // The external Data:
     Data* data_pt=Inflow_ext_data[i];
     // Number of values
     unsigned n_val=data_pt->nvalue();
     if (n_val>max_nvalue) max_nvalue=n_val;
    }
 
   // Allocate sufficient storage
   Inflow_ext_data_eqn.resize(n_ext,max_nvalue);
   
   //A local queue to store the global equation numbers
   std::deque<unsigned long> global_eqn_number_queue;
 
   // Loop over external Data that affect the "inflow"
   for (unsigned i=0;i<n_ext;i++)
    {
     // The external Data:
     Data* data_pt=Inflow_ext_data[i];
     
     // Loop over number of values:
     unsigned n_val=data_pt->nvalue();
     for (unsigned ival=0;ival<n_val;ival++)
      {
 
       // Is it free or pinned?
       long eqn_number=data_pt->eqn_number(ival);
       if (eqn_number>=0)
        {
         // Add global equation number to local storage
         global_eqn_number_queue.push_back(eqn_number);
         // Store local equation number associated with this external dof
         Inflow_ext_data_eqn(i,ival)=local_eqn_count;
         // Increment counter for local dofs
         local_eqn_count++;
        }
       else
        {
         Inflow_ext_data_eqn(i,ival)=-1;
        }
      }
    }
   
   //Now add our global equations numbers to the internal element storage
   this->add_global_eqn_numbers(global_eqn_number_queue, 
                                GeneralisedElement::Dof_pt_deque);
  }

References oomph::Data::eqn_number(), i, and oomph::Data::nvalue().

get_jacobian()

template<class ELEMENT >

void BrethertonElement< ELEMENT >::get_jacobian ( Vector< double > &  residuals, DenseMatrix< double > &  jacobian  )

inline

Overloaded Jacobian computation: Computes the Jacobian of the underlying element and then adds the FD operations to evaluate the derivatives w.r.t. the Data values that affect the inflow.

  {
   // Loop over Data values that affect the inflow
   unsigned n_ext=Inflow_ext_data.size();
 
   // Call "normal" jacobian first.
   ELEMENT::get_jacobian(residuals,jacobian);
   
   if (n_ext==0) return;
   
   // Get ready for FD operations
   Vector<double> residuals_plus(residuals.size());
   double fd_step=1.0e-8;
 
   // Loop over Data values that affect the inflow
   for (unsigned i=0;i<n_ext;i++)
    {
     // Get Data item
     Data* data_pt=Inflow_ext_data[i];
     
     // Loop over values
     unsigned n_val=data_pt->nvalue();
     for (unsigned ival=0;ival<n_val;ival++)
      {
       // Local equation number
       int local_eqn=Inflow_ext_data_eqn(i,ival);
       
       // Dof or pinned?
       if (local_eqn>=0)
        {
         //get pointer to the data value
         double *value_pt = data_pt->value_pt(ival);
 
         //Backup Data value
         double backup = *value_pt;
         
         // Do FD step
         *value_pt += fd_step;
         
         // Re-assign the inflow velocities for nodes in this element
         reassign_inflow();
         
                  
         // Fill in the relevant column in the Jacobian matrix
         unsigned n_dof = this->ndof();
         //Zero the residuals
         for(unsigned idof=0;idof<n_dof;idof++) {residuals_plus[idof] = 0.0;}
         // Re-compute the element residual
         this->get_residuals(residuals_plus);
 
         for(unsigned idof=0;idof<n_dof;idof++)
          {
           jacobian(idof,local_eqn)=
            (residuals_plus[idof]-residuals[idof])/fd_step;
          }
         
         //Reset spine height
         *value_pt = backup;
         
        }
       // Note: Re-assignment of inflow is done on the fly during next loop
      }
    }
   
   // Final re-assign for the inflow velocities for nodes in this element
   reassign_inflow();
   
  }

References GlobalFct::get_residuals(), i, oomph::Data::nvalue(), and oomph::Data::value_pt().

reassign_inflow()

template<class ELEMENT >

void BrethertonElement< ELEMENT >::reassign_inflow ( )

inlineprivate

For all nodes that are located on specified boundary re-assign the inflow velocity, using the function pointed to by the function pointer

  { 
   // Loop over all nodes in element -- if they are
   // on inflow boundary, re-assign their velocities
   Vector<double> x(2);
   Vector<double> veloc(2);
   unsigned n_nod = this->nnode();
   for (unsigned j=0;j<n_nod;j++)
    {
     Node* nod_pt = this->node_pt(j);
 
     if(nod_pt->is_on_boundary(Inflow_boundary))
      {
#ifdef PARANOID
           for (unsigned i=0;i<2;i++)
            {
             if (nod_pt->eqn_number(0)>=0)
              {
               std::ostringstream error_stream;
               error_stream 
                << "We're assigning a Dirichlet condition for the " 
                << i << "-th "
                << "velocity, even though it is not pinned!\n" 
                << "This can't be right! I'm bailing out..." 
                << std::endl;
 
               throw OomphLibError(error_stream.str(),
                                   OOMPH_CURRENT_FUNCTION,
                                   OOMPH_EXCEPTION_LOCATION);
              }
            }
#endif           
           // Get inflow profile 
           x[0]=nod_pt->x(0);
           x[1]=nod_pt->x(1);
           Inflow_fct_pt(x,veloc);
           nod_pt->set_value(0,veloc[0]);
           nod_pt->set_value(1,veloc[1]);
      }
    }
  }

References oomph::Data::eqn_number(), i, oomph::Node::is_on_boundary(), j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Data::set_value(), plotDoE::x, and oomph::Node::x().

Member Data Documentation

Inflow_boundary

template<class ELEMENT >

unsigned BrethertonElement< ELEMENT >::Inflow_boundary

private

Number of the inflow boundary in the global mesh.

Inflow_ext_data

template<class ELEMENT >

Vector<Data*> BrethertonElement< ELEMENT >::Inflow_ext_data

private

Storage for the external Data that affects the inflow.

Inflow_ext_data_eqn

template<class ELEMENT >

DenseMatrix<int> BrethertonElement< ELEMENT >::Inflow_ext_data_eqn

private

Storage for the local equation numbers associated the Data values that affect the inflow

Inflow_fct_pt

template<class ELEMENT >

InflowFctPt BrethertonElement< ELEMENT >::Inflow_fct_pt

private

Function pointer to the global function that specifies the inflow velocity profile on the global mesh boundary Inflow_boundary

---

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

• bretherton.cc