oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM > Class Template Reference

#include <womersley_elements.h>

Inheritance diagram for oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >:

Public Types
typedef double(*	PrescribedVolumeFluxFctPt) (const double &time)

Public Member Functions
	WomersleyImpedanceTubeBase (const double &length, PrescribedVolumeFluxFctPt prescribed_volume_flux_fct_pt)
	WomersleyImpedanceTubeBase (const double &length, Mesh *navier_stokes_outflow_mesh_pt)
double &	p_out ()
	Access fct to outlet pressure. More...
virtual Mesh *	build_mesh_and_apply_boundary_conditions (TimeStepper *time_stepper_pt)=0
void	setup ()
void	setup (double *re_st_pt, const double &dt, const double &q_initial, TimeStepper *time_stepper_pt=0)
WomersleyProblem< ELEMENT, DIM > *	womersley_problem_pt ()
	Access to underlying Womersley problem. More...
void	shift_time_values (const double &dt)
double	total_volume_flux_into_impedance_tube ()
void	get_response (double &p_in, double &dp_in_dq)
Public Member Functions inherited from oomph::TemplateFreeWomersleyImpedanceTubeBase
	TemplateFreeWomersleyImpedanceTubeBase ()
	Empty constructor. More...
virtual	~TemplateFreeWomersleyImpedanceTubeBase ()
	Empty virtual destructor. More...

Protected Member Functions
void	precompute_aux_integrals ()

Protected Attributes
double	Length
	Length of the tube. More...
double	Dp_in_dq
double *	Current_volume_flux_pt
WomersleyProblem< ELEMENT, DIM > *	Womersley_problem_pt
double	P_out
	Outlet pressure. More...
PrescribedVolumeFluxFctPt	Prescribed_volume_flux_fct_pt
	Pointer to function that specifies the prescribed volume flux. More...
Mesh *	Navier_stokes_outflow_mesh_pt
std::map< unsigned, double > *	Aux_integral_pt

Private Attributes
bool	Using_flux_control_elements

Additional Inherited Members
Static Public Attributes inherited from oomph::TemplateFreeWomersleyImpedanceTubeBase
static double	Zero = 0.0
	Zero! More...

Detailed Description

template<class ELEMENT, unsigned DIM>
class oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// Base class for Womersley impedance tube. Allows the computation of the inlet pressure p_in into a uniform tube of specified length that is assumed to convey fully-developed, but time-dependent flow with a presribed instantaneous flow rate, q. Also computes the derivative dp_in/dq required when this is used to determine impedance-type outlet boundary conditions in a Navier-Stokes computation.

Member Typedef Documentation

PrescribedVolumeFluxFctPt

template<class ELEMENT , unsigned DIM>

typedef double(* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::PrescribedVolumeFluxFctPt) (const double &time)

Function pointer to fct that prescribes volume flux q=fct(t) – mainly used for validation purposes.

Constructor & Destructor Documentation

WomersleyImpedanceTubeBase() [1/2]

template<class ELEMENT , unsigned DIM>

oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::WomersleyImpedanceTubeBase ( const double &  length, PrescribedVolumeFluxFctPt  prescribed_volume_flux_fct_pt  )

inline

Constructor: Specify length of tube and pointer to function that specifies the prescribed volume flux. Outlet pressure is set to zero.

      : Length(length),
        P_out(0.0),
        Prescribed_volume_flux_fct_pt(prescribed_volume_flux_fct_pt),
        Navier_stokes_outflow_mesh_pt(0)
    {
      // Initialise currently prescribed flux
      Current_volume_flux_pt = new double(0.0);
 
      // Auxiliary integral isn't used if flux isn't prescribed
      // via outflow through NavierStokesImpedanceTractionElements
      Aux_integral_pt = 0;
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Aux_integral_pt, and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Current_volume_flux_pt.

WomersleyImpedanceTubeBase() [2/2]

template<class ELEMENT , unsigned DIM>

oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::WomersleyImpedanceTubeBase ( const double &  length, Mesh *  navier_stokes_outflow_mesh_pt  )

inline

Constructor: Specify length of tube and the pointer to the mesh of either NavierStokesImpedanceTractionElements or NavierStokesFluxControlElements that are attached to the outflow cross-section of a (higher-dimensional) Navier Stokes mesh and provide the inflow into the ImpedanceTube. Outlet pressure is set to zero.

      : Length(length),
        P_out(0.0),
        Prescribed_volume_flux_fct_pt(0),
        Navier_stokes_outflow_mesh_pt(navier_stokes_outflow_mesh_pt)
    {
      // Initialise currently prescribed flux
      Current_volume_flux_pt = new double(0.0);
 
      // Initialise flag to record if NavierStokesFluxControlElement
      // or NavierStokesImpedanceTractionElement elements are being used
      Using_flux_control_elements = true;
 
      // Attempt to cast 1st element to NavierStokesImpedanceTractionElementBase
      if (dynamic_cast<NavierStokesImpedanceTractionElementBase*>(
            navier_stokes_outflow_mesh_pt->element_pt(0)))
      {
        Using_flux_control_elements = false;
 
        // Create map used to store the non-zero entries of the
        // auxiliary integral, containing the derivative of the total
        // volume flux through the outflow boundary of the (higher-dimensional)
        // Navier-Stokes mesh w.r.t. to the discrete (global) (velocity)
        // degrees of freedom.
        Aux_integral_pt = new std::map<unsigned, double>;
 
        // Pass pointer to Navier_stokes_outflow_mesh_pt to the Navier
        // Stokes traction elements
        unsigned nelem = navier_stokes_outflow_mesh_pt->nelement();
        for (unsigned e = 0; e < nelem; e++)
        {
          NavierStokesImpedanceTractionElementBase* el_pt =
            dynamic_cast<NavierStokesImpedanceTractionElementBase*>(
              navier_stokes_outflow_mesh_pt->element_pt(e));
 
          // Pass the mesh of all NavierStokesImpedanceTractionElements to
          // each NavierStokesImpedanceTractionElements in that mesh
          // and treat nodes in that mesh that are not part of the element
          // itself as external data (since they affect the total volume
          // flux and therefore the traction onto the element).
          el_pt->set_external_data_from_navier_stokes_outflow_mesh(
            navier_stokes_outflow_mesh_pt);
        }
      }
#ifdef PARANOID
      // Test to make sure the elements in the mesh are valid
      else
      {
        if (!dynamic_cast<TemplateFreeNavierStokesFluxControlElementBase*>(
              navier_stokes_outflow_mesh_pt->element_pt(0)))
        {
          std::ostringstream error_message;
          error_message
            << "WomersleyImpedanceTubeBase requires a Navier-Stokes\n"
            << "outflow mesh of elements which inherit from either\n"
            << "TemplateFreeNavierStokesFluxControlElementBase or\n"
            << "NavierStokesImpedanceTractionElementBase.\n";
          throw OomphLibError(error_message.str(),
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
        }
      }
#endif
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Aux_integral_pt, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Current_volume_flux_pt, e(), oomph::Mesh::element_pt(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::NavierStokesImpedanceTractionElementBase::set_external_data_from_navier_stokes_outflow_mesh(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Using_flux_control_elements.

Member Function Documentation

build_mesh_and_apply_boundary_conditions()

template<class ELEMENT , unsigned DIM>

virtual Mesh* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::build_mesh_and_apply_boundary_conditions ( TimeStepper *  time_stepper_pt )

pure virtual

Pure virtual function in which the user of a derived class must create the mesh of WomersleyElements (of the type specified by the class's template argument) and apply the boundary conditions. The Womersley elements use the timestepper specified as the input argument.

Implemented in oomph::WomersleyOutflowImpedanceTube< ELEMENT, DIM >, oomph::WomersleyOutflowImpedanceTube< QWomersleyElement< 1, 3 >, 1 >, and RectangularWomersleyImpedanceTube< ELEMENT >.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup().

get_response()

template<class ELEMENT , unsigned DIM>

void oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response ( double &  p_in, double &  dp_in_dq  )

inlinevirtual

Compute inlet pressure, p_in, required to achieve the currently imposed, instantaneous volume flux q prescribed by total_volume_flux_into_impedance_tube(), and its derivative, dp_in/dq.

Implements oomph::TemplateFreeWomersleyImpedanceTubeBase.

    {
      // Set currently imposed flux
      *Current_volume_flux_pt = total_volume_flux_into_impedance_tube();
 
      // Do a Newton solve to compute the pressure gradient
      // required to achieve the imposed instantaneous flow rate
      Womersley_problem_pt->newton_solve();
 
      // Compute inflow pressure based on computed pressure gradient,
      // the length of tube, and the outlet pressure
      p_in =
        -Womersley_problem_pt->pressure_gradient_data_pt()->value(0) * Length +
        P_out;
 
      // Return pre-computed value  for dp_in/dq
      dp_in_dq = Dp_in_dq;
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Current_volume_flux_pt, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Dp_in_dq, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Length, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::P_out, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt.

Referenced by run_impedance_tube(), and run_navier_stokes_outflow().

p_out()

template<class ELEMENT , unsigned DIM>

double& oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::p_out ( )

inline

Access fct to outlet pressure.

    {
      return P_out;
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::P_out.

precompute_aux_integrals()

template<class ELEMENT , unsigned DIM>

void oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::precompute_aux_integrals ( )

inlineprotected

Precompute auxiliary integrals required for the computation of the Jacobian in the NavierStokesImpedanceTractionElement. Also pass the pointer to the pre-computed integrals to the elements in the Navier_stokes_outflow_mesh_pt so they can refer to it.

    {
      // Loop over all elements
      unsigned nelem = Navier_stokes_outflow_mesh_pt->nelement();
      for (unsigned e = 0; e < nelem; e++)
      {
        NavierStokesImpedanceTractionElementBase* el_pt =
          dynamic_cast<NavierStokesImpedanceTractionElementBase*>(
            Navier_stokes_outflow_mesh_pt->element_pt(e));
 
        // Add the element's contribution
        el_pt->add_element_contribution_to_aux_integral(Aux_integral_pt);
 
        // Tell the elements who's setting their flow resistance
        el_pt->set_impedance_tube_pt(this);
      }
 
      // Pass pointer to Aux_integral to the elements so they can
      // use it in the computation of the Jacobian
      for (unsigned e = 0; e < nelem; e++)
      {
        NavierStokesImpedanceTractionElementBase* el_pt =
          dynamic_cast<NavierStokesImpedanceTractionElementBase*>(
            Navier_stokes_outflow_mesh_pt->element_pt(e));
 
        // Pass pointer to elements
        el_pt->set_aux_integral_pt(Aux_integral_pt);
      }
    }

References oomph::NavierStokesImpedanceTractionElementBase::add_element_contribution_to_aux_integral(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Aux_integral_pt, e(), oomph::Mesh::element_pt(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Navier_stokes_outflow_mesh_pt, oomph::Mesh::nelement(), oomph::NavierStokesImpedanceTractionElementBase::set_aux_integral_pt(), and oomph::NavierStokesImpedanceTractionElementBase::set_impedance_tube_pt().

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup().

setup() [1/2]

template<class ELEMENT , unsigned DIM>

void oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup ( )

inline

Set up the Womersley tubes so that a subsequent call to get_response(...) computes the inlet pressure for the currently prescribed instantaneous flow rate. Steady version!

    {
      // Dummy parameters
      double* re_st_pt = &Zero;
      double dt = 0.0;
      double q_initial = 0;
      TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper;
      setup(re_st_pt, dt, q_initial, time_stepper_pt);
    }

References oomph::Mesh::Default_TimeStepper, and oomph::TemplateFreeWomersleyImpedanceTubeBase::Zero.

setup() [2/2]

template<class ELEMENT , unsigned DIM>

void oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup ( double *  re_st_pt, const double &  dt, const double &  q_initial, TimeStepper *  time_stepper_pt = 0  )

inline

Set up the Womersley tubes so that a subsequent call to get_response(...) computes the inlet pressure for the currently prescribed instantaneous flow rate, assuming that at all previous times the tube conveyed steady, fully-developed flow with flowrate q_initial. dt specifies the timestep for the subsequent time integration. Specify: Womersley number, (constant) timestep, the initial volume flux (from which the subsequent impulsive start is performed) and, optionally the pointer to the timestepper to be used in the Womersley elements (defaults to BDF<2>).

By default, we do want to suppress the output from the Newton solver

    {
      // Create timestepper if none specified so far
      if (time_stepper_pt == 0)
      {
        time_stepper_pt = new BDF<2>;
      }
 
      // Build mesh and apply bcs
      Mesh* my_mesh_pt =
        build_mesh_and_apply_boundary_conditions(time_stepper_pt);
 
      // Build problem
      Womersley_problem_pt = new WomersleyProblem<ELEMENT, DIM>(
        re_st_pt, Current_volume_flux_pt, time_stepper_pt, my_mesh_pt);
 
      Womersley_problem_pt->disable_info_in_newton_solve();
      oomph_info << "NOTE: We're suppressing timings etc from \n"
                 << "      Newton solver in WomersleyImpedanceTubeBase. "
                 << std::endl;
 
      // Precompute the auxiliary integrals for the Navier-Stokes
      // impedance traction elements (if they're used to specify the inflow
      if ((!Using_flux_control_elements) &&
          (Navier_stokes_outflow_mesh_pt != 0))
      {
        precompute_aux_integrals();
      }
 
      // Initialise timestep -- also sets the weights for all timesteppers
      // in the problem.
      Womersley_problem_pt->initialise_dt(dt);
 
      // Set currently imposed flux
      *Current_volume_flux_pt = q_initial;
 
      // Assign steady initial solution for this flux
      Womersley_problem_pt->steady_newton_solve();
 
      // Allow for resolve
      Womersley_problem_pt->linear_solver_pt()->enable_resolve();
 
      // Re-use Jacobian
      Womersley_problem_pt->enable_jacobian_reuse();
 
      // Shut up
      Womersley_problem_pt->linear_solver_pt()->disable_doc_time();
 
      // Do a dummy solve with time-dependent terms switched on
      // to generate (and store) the Jacobian. (We're not using
      // a Newton solve because the initial residual may be zero
      // in which case the Jacobian would never be computed!)
      unsigned n_dof = Womersley_problem_pt->ndof();
 
      // Local scope to make sure dx goes out of scope
      {
        DoubleVector dx;
        Womersley_problem_pt->linear_solver_pt()->solve(Womersley_problem_pt,
                                                        dx);
      }
 
 
      // Pre-compute derivative of p_in w.r.t. q
 
      // Setup vector of derivatives of residuals & unknowns w.r.t. Q
      LinearAlgebraDistribution dist(
        Womersley_problem_pt->communicator_pt(), n_dof, false);
      DoubleVector drdq(&dist, 0.0);
      DoubleVector dxdq(&dist, 0.0);
 
      // What's the global equation number of the equation that
      // determines the pressure gradient
      unsigned g_eqn =
        Womersley_problem_pt->pressure_gradient_data_pt()->eqn_number(0);
 
      // Derivative of volume constraint residual w.r.t. prescribed
      // instantaenous volume flux (in ImposeFluxForWomersleyElement)
      drdq[g_eqn] = -1.0;
 
      // Solve for derivatives of unknowns in Womersley problem, w.r.t.
      // instantaenous volume flux (in ImposeFluxForWomersleyElement)
      Womersley_problem_pt->linear_solver_pt()->resolve(drdq, dxdq);
 
      // Rate of change of inflow pressure w.r.t to instantaneous
      // volume flux
      Dp_in_dq = dxdq[g_eqn] * Length;
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::build_mesh_and_apply_boundary_conditions(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Current_volume_flux_pt, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Dp_in_dq, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Length, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Navier_stokes_outflow_mesh_pt, oomph::oomph_info, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::precompute_aux_integrals(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Using_flux_control_elements, and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt.

shift_time_values()

template<class ELEMENT , unsigned DIM>

void oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::shift_time_values ( const double &  dt )

inline

Shift history values to allow coputation of next timestep. Note: When used with a full Navier-Stokes problem this function must be called in actions_before_implicit_timestep()

    {
      // Shift the history values in the Womersley problem
      Womersley_problem_pt->shift_time_values();
 
      // Advance global time and set current value of dt
      Womersley_problem_pt->time_pt()->time() += dt;
      Womersley_problem_pt->time_pt()->dt() = dt;
 
      // Find out how many timesteppers there are
      unsigned n_time_steppers = Womersley_problem_pt->ntime_stepper();
 
      // Loop over them all and set the weights
      for (unsigned i = 0; i < n_time_steppers; i++)
      {
        Womersley_problem_pt->time_stepper_pt(i)->set_weights();
      }
    }

References i, and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt.

Referenced by run_impedance_tube(), and run_navier_stokes_outflow().

total_volume_flux_into_impedance_tube()

template<class ELEMENT , unsigned DIM>

double oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube ( )

inline

Compute total current volume flux into the "impedance tube" that provides the flow resistance (flux is either obtained from the function that specifies it externally or by by adding up the flux through all NavierStokesImpedanceTractionElements in the mesh pointed to by the Navier_stokes_outflow_mesh_pt.

    {
      if (Prescribed_volume_flux_fct_pt != 0)
      {
        return Prescribed_volume_flux_fct_pt(
          Womersley_problem_pt->time_pt()->time());
      }
      else
      {
        unsigned nelem = Navier_stokes_outflow_mesh_pt->nelement();
        double flux = 0.0;
        if (Using_flux_control_elements)
        {
          for (unsigned e = 0; e < nelem; e++)
          {
            flux +=
              dynamic_cast<TemplateFreeNavierStokesFluxControlElementBase*>(
                Navier_stokes_outflow_mesh_pt->element_pt(e))
                ->get_volume_flux();
          }
        }
        else
        {
          for (unsigned e = 0; e < nelem; e++)
          {
            flux += dynamic_cast<NavierStokesImpedanceTractionElementBase*>(
                      Navier_stokes_outflow_mesh_pt->element_pt(e))
                      ->get_volume_flux();
          }
        }
        return flux;
      }
    }

References e(), oomph::Mesh::element_pt(), ProblemParameters::flux(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Navier_stokes_outflow_mesh_pt, oomph::Mesh::nelement(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Prescribed_volume_flux_fct_pt, oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Using_flux_control_elements, and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response().

womersley_problem_pt()

template<class ELEMENT , unsigned DIM>

WomersleyProblem<ELEMENT, DIM>* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::womersley_problem_pt ( )

inline

Access to underlying Womersley problem.

    {
      return Womersley_problem_pt;
    }

References oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt.

Referenced by run_impedance_tube(), and run_navier_stokes_outflow().

Member Data Documentation

Aux_integral_pt

template<class ELEMENT , unsigned DIM>

std::map<unsigned, double>* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Aux_integral_pt

protected

Pointer to auxiliary integral, containing the derivative of the total volume flux through the outflow boundary of the (higher-dimensional) Navier-Stokes mesh w.r.t. to the discrete (global) (velocity) degrees of freedom.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::precompute_aux_integrals(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::WomersleyImpedanceTubeBase().

Current_volume_flux_pt

template<class ELEMENT , unsigned DIM>

double* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Current_volume_flux_pt

protected

Pointer to double that specifies the currently imposed instantaneous volume flux into the impedance tube. This is used to communicate with the Womersley elements which require access to the flux via a pointer to a double.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::WomersleyImpedanceTubeBase().

Dp_in_dq

template<class ELEMENT , unsigned DIM>

double oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Dp_in_dq

protected

Derivative of inflow pressure w.r.t. instantaenous volume flux (Note: Can be pre-computed)

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup().

Length

template<class ELEMENT , unsigned DIM>

double oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Length

protected

Length of the tube.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup().

Navier_stokes_outflow_mesh_pt

template<class ELEMENT , unsigned DIM>

Mesh* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Navier_stokes_outflow_mesh_pt

protected

Pointer to the mesh of NavierStokesImpedanceTractionElements that are attached to the outflow cross-section of the higher-dimensional Navier Stokes mesh and provide the inflow into the Impedance tube.

Referenced by oomph::WomersleyOutflowImpedanceTube< ELEMENT, DIM >::build_mesh_and_apply_boundary_conditions(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::precompute_aux_integrals(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube().

P_out

template<class ELEMENT , unsigned DIM>

double oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::P_out

protected

Outlet pressure.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::p_out().

Prescribed_volume_flux_fct_pt

template<class ELEMENT , unsigned DIM>

PrescribedVolumeFluxFctPt oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Prescribed_volume_flux_fct_pt

protected

Pointer to function that specifies the prescribed volume flux.

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube().

Using_flux_control_elements

template<class ELEMENT , unsigned DIM>

bool oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Using_flux_control_elements

private

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::WomersleyImpedanceTubeBase().

Womersley_problem_pt

template<class ELEMENT , unsigned DIM>

WomersleyProblem<ELEMENT, DIM>* oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::Womersley_problem_pt

protected

Pointer to Womersley problem that determines the pressure gradient along the tube

Referenced by oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::get_response(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::setup(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::shift_time_values(), oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::total_volume_flux_into_impedance_tube(), and oomph::WomersleyImpedanceTubeBase< ELEMENT, DIM >::womersley_problem_pt().

---

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

• womersley_elements.h