oomph::FSI_functions Namespace Reference

Namespace for "global" FSI functions. More...

Functions
void	apply_no_slip_on_moving_wall (Node *node_pt)
template<class FLUID_ELEMENT , unsigned DIM_FLUID>
void	setup_fluid_load_info_for_solid_elements (Problem *problem_pt, Vector< unsigned > &boundary_in_fluid_mesh, Mesh *const &fluid_mesh_pt, Vector< Mesh * > &solid_mesh_pt, const unsigned &face=0)
template<class FLUID_ELEMENT , unsigned DIM_FLUID>
void	setup_fluid_load_info_for_solid_elements (Problem *problem_pt, const unsigned &boundary_in_fluid_mesh, Mesh *const &fluid_mesh_pt, Mesh *const &solid_mesh_pt, const unsigned &face=0)
template<class SOLID_ELEMENT , unsigned DIM_SOLID>
void	setup_solid_elements_for_displacement_bc (Problem *problem_pt, const Vector< unsigned > &b_solid_fsi, Mesh *const &solid_mesh_pt, Vector< Mesh * > &lagrange_multiplier_mesh_pt)
template<class SOLID_ELEMENT , unsigned DIM_SOLID>
void	setup_solid_elements_for_displacement_bc (Problem *problem_pt, const unsigned &b_solid_fsi, Mesh *const &solid_mesh_pt, Mesh *const &lagrange_multiplier_mesh_pt)
template<class NODE >
void	doc_fsi (Mesh *fluid_mesh_pt, SolidMesh *wall_mesh_pt, DocInfo &doc_info)

Variables
double	Strouhal_for_no_slip = 1.0

Detailed Description

Namespace for "global" FSI functions.

///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////

Function Documentation

apply_no_slip_on_moving_wall()

void oomph::FSI_functions::apply_no_slip_on_moving_wall

(

Node *

node_pt

)

Apply no-slip condition for N.St. on a moving wall node u = St dR/dt, where the Strouhal number St = a/(UT) is defined by FSI_functions::Strouhal_for_no_slip and is initialised to 1.0. Note: This requires the x,y,[z] velocity components to be stored in nodal values 0,1,[2]. This is the default for all currently existing Navier-Stokes elements. If you use any others, use this function at your own risk.

Apply no-slip condition for N.St. on a moving wall node, u = St dR/dt, where the Strouhal number St = a/(UT) is defined by FSI_functions::Strouhal_for_no_slip and is initialised to 1.0. Note: This requires the x,y,[z] velocity components to be stored in nodal values 0,1,[2]. This is the default for all currently existing Navier-Stokes elements. If you use any others, use this function at your own risk.

    {
      // Find out spatial dimension of node
      unsigned ndim = node_pt->ndim();
      // Assign velocity
      for (unsigned i = 0; i < ndim; i++)
      {
        node_pt->set_value(i,
                           Strouhal_for_no_slip * (node_pt->dposition_dt(i)));
      }
    }

References oomph::Node::dposition_dt(), i, oomph::Node::ndim(), oomph::Data::set_value(), and Strouhal_for_no_slip.

Referenced by FSIChannelWithLeafletProblem< ELEMENT >::actions_after_adapt(), FSICollapsibleChannelProblem< ELEMENT >::actions_after_adapt(), FSIRingProblem::actions_after_adapt(), OscRingNStProblem< ELEMENT >::actions_after_adapt(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_adapt(), FSIChannelWithLeafletProblem< ELEMENT >::actions_after_distribute(), FSIRingProblem::actions_after_distribute(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_distribute(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_after_distribute(), ChannelWithLeafletProblem< ELEMENT >::actions_before_implicit_timestep(), CollapsibleChannelProblem< ELEMENT >::actions_before_implicit_timestep(), FlowAroundCylinderProblem< ELEMENT >::actions_before_implicit_timestep(), OscEllipseProblem< ELEMENT, TIMESTEPPER >::actions_before_implicit_timestep(), OscRingNStProblem< ELEMENT >::actions_before_implicit_timestep(), TurekNonFSIProblem< ELEMENT >::actions_before_implicit_timestep(), FSICollapsibleChannelProblem< ELEMENT >::actions_before_newton_convergence_check(), UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::actions_before_newton_convergence_check(), CollapsibleChannelProblem< ELEMENT >::actions_before_newton_convergence_check(), UnstructuredImmersedEllipseProblem< ELEMENT >::complete_problem_setup(), UnstructuredFluidProblem< ELEMENT >::complete_problem_setup(), OscRingNStProblem< ELEMENT >::finish_problem_setup(), FSIChannelWithLeafletProblem< ELEMENT >::FSIChannelWithLeafletProblem(), FSICollapsibleChannelProblem< ELEMENT >::FSICollapsibleChannelProblem(), FSIDrivenCavityProblem< ELEMENT >::FSIDrivenCavityProblem(), FSIRingProblem::FSIRingProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::generic_actions_after(), OscRingNStProblem< ELEMENT >::OscRingNStProblem(), PseudoElasticCollapsibleChannelProblem< FLUID_ELEMENT, SOLID_ELEMENT >::PseudoElasticCollapsibleChannelProblem(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and UnstructuredFSIProblem< FLUID_ELEMENT, SOLID_ELEMENT >::UnstructuredFSIProblem().

doc_fsi()

template<class NODE >

void oomph::FSI_functions::doc_fsi	(	Mesh *	fluid_mesh_pt,
		SolidMesh *	wall_mesh_pt,
		DocInfo &	doc_info
	)

Doc FSI:

1. Which Data values affect the traction onto the FSIWallElements and what type of Data is it stored in ([fluid-]nodes, internal Data [in fluid elements] or SolidNodes?
2. Which SolidNodes affect the node update of the fluid nodes?

Output is in tecplot readable form: Use fs1.mcr and fsi2.mcr (or straightforward modifications thereof), stored in doc/interaction/fsi_collapsible_channel/nondist_figures to process.

Pass pointer to fluid and solid meshes and pointer to the DocInfo object that specifies the directory and the overall step number. Template parameter specifies the type of node that is used to implement the node update strategy.

    {
      std::ofstream some_file;
      std::ostringstream filename;
 
      // Number of plot points
      unsigned npts;
      npts = 5;
 
      // Part 1: Doc which dofs affect the fluid traction on solid
      //==========================================================
 
      // Tecplot helpers
      Vector<std::string> label(3);
      label[0] = "X=";
      label[1] = "Y=";
      label[2] = "Z=";
 
      // Output fluid solution/mesh
      //---------------------------
      filename << doc_info.directory() << "/fsi_doc_fluid_mesh"
               << doc_info.number() << ".dat";
      some_file.open(filename.str().c_str());
      fluid_mesh_pt->output(some_file, npts);
      some_file.close();
 
 
      // Setup map that links the positional Data of SolidNodes with
      //------------------------------------------------------------
      // the nodes
      //----------
      std::map<Data*, Node*> solid_node_pt;
      unsigned nnod = wall_mesh_pt->nnode();
      for (unsigned j = 0; j < nnod; j++)
      {
        solid_node_pt[wall_mesh_pt->node_pt(j)->variable_position_pt()] =
          wall_mesh_pt->node_pt(j);
      }
 
 
      // Setup map that links the internal (pressure) Data of fluid elements
      // with
      //-------------------------------------------------------------------------
      // those fluid elements
      //---------------------
      std::map<Data*, FiniteElement*> internal_data_element_pt;
      unsigned nelemf = fluid_mesh_pt->nelement();
      for (unsigned e = 0; e < nelemf; e++)
      {
        unsigned ninternal = fluid_mesh_pt->element_pt(e)->ninternal_data();
        for (unsigned k = 0; k < ninternal; k++)
        {
          internal_data_element_pt[fluid_mesh_pt->element_pt(e)
                                     ->internal_data_pt(k)] =
            fluid_mesh_pt->finite_element_pt(e);
        }
      }
 
 
#ifdef OOMPH_HAS_MPI
      // External halo elements must also be included in this check
      std::set<int> procs = fluid_mesh_pt->external_halo_proc();
      for (std::set<int>::iterator it = procs.begin(); it != procs.end(); it++)
      {
        unsigned d = unsigned((*it));
        unsigned n_ext_halo_f = fluid_mesh_pt->nexternal_halo_element(d);
        for (unsigned e = 0; e < n_ext_halo_f; e++)
        {
          unsigned ninternal =
            fluid_mesh_pt->external_halo_element_pt(d, e)->ninternal_data();
          for (unsigned k = 0; k < ninternal; k++)
          {
            internal_data_element_pt[fluid_mesh_pt
                                       ->external_halo_element_pt(d, e)
                                       ->internal_data_pt(k)] =
              dynamic_cast<FiniteElement*>(
                fluid_mesh_pt->external_halo_element_pt(d, e));
          }
        }
      }
#endif
 
 
      // Loop over all wall elements
      //----------------------------
      unsigned nelem = wall_mesh_pt->nelement();
      for (unsigned e = 0; e < nelem; e++)
      {
        // Reset the string contents to be empty
        filename.str("");
        // Set the new filename
        filename << doc_info.directory() << "/fsi_doc_wall_element"
                 << doc_info.number() << "-" << e << ".dat";
        some_file.open(filename.str().c_str());
 
        // Get pointer to wall element
        FSIWallElement* el_pt =
          dynamic_cast<FSIWallElement*>(wall_mesh_pt->finite_element_pt(e));
 
#ifdef OOMPH_HAS_MPI
        // If it's a halo element then it will not have set an adjacent
        // fluid element so there's no point trying to output it!
        if (!el_pt->is_halo())
        {
#endif
 
          // Storage for local and global coords
          unsigned ndim_local = el_pt->dim();
          Vector<double> s(ndim_local);
          unsigned ndim_eulerian = el_pt->nodal_dimension();
          Vector<double> x(ndim_eulerian);
 
 
          // Map to indicate if the internal Data for a given
          // fluid element has been plotted already
          std::map<FiniteElement*, bool> element_internal_data_has_been_plotted;
 
          // Loop over Gauss points and doc their position
          //-----------------------------------------------
          unsigned nint = el_pt->integral_pt()->nweight();
          some_file << "ZONE I=" << nint << std::endl;
          for (unsigned i = 0; i < nint; i++)
          {
            for (unsigned j = 0; j < ndim_local; j++)
            {
              s[j] = el_pt->integral_pt()->knot(i, j);
            }
            el_pt->interpolated_x(s, x);
            for (unsigned j = 0; j < ndim_eulerian; j++)
            {
              some_file << x[j] << " ";
            }
            some_file << i << std::endl;
          }
 
 
          // Loop over Gauss points again to find corresponding points in fluid
          //--------------------------------------------------------------------
          // elements
          //---------
 
          // Loop over front and back if required: Get number of fluid-loaded
          // faces
          unsigned n_loaded_face = 2;
          if (el_pt->only_front_is_loaded_by_fluid()) n_loaded_face = 1;
 
          for (unsigned face = 0; face < n_loaded_face; face++)
          {
            some_file << "ZONE I=" << nint << std::endl;
            for (unsigned i = 0; i < nint; i++)
            {
              // Get corresponding fluid element
              FSIFluidElement* fluid_el_pt = dynamic_cast<FSIFluidElement*>(
                el_pt->external_element_pt(face, i));
 
              // Get local coordinates in fluid element by copy operation
              Vector<double> s_fluid(
                el_pt->external_element_local_coord(face, i));
 
              // Get Eulerian position in fluid element
              fluid_el_pt->interpolated_x(s_fluid, x);
              for (unsigned j = 0; j < ndim_eulerian; j++)
              {
                some_file << x[j] << " ";
              }
              some_file << i << std::endl;
            }
          }
 
 
          // Get the multiplicity of data that affects the load on this wall
          // element
          //------------------------------------------------------------------------
          std::map<Data*, unsigned> data_count;
          std::map<FiniteElement*, unsigned> internal_data_count;
          {
            Vector<Data*> external_interaction_field_data_pt(
              el_pt->external_interaction_field_data_pt());
            unsigned nexternal_interaction_field =
              external_interaction_field_data_pt.size();
            for (unsigned l = 0; l < nexternal_interaction_field; l++)
            {
              data_count[external_interaction_field_data_pt[l]]++;
              if (internal_data_element_pt
                    [external_interaction_field_data_pt[l]] != 0)
              {
                internal_data_count
                  [internal_data_element_pt
                     [external_interaction_field_data_pt[l]]]++;
              }
            }
          }
 
          {
            Vector<Data*> external_interaction_geometric_data_pt(
              el_pt->external_interaction_geometric_data_pt());
            unsigned nexternal_interaction_geom =
              external_interaction_geometric_data_pt.size();
            for (unsigned l = 0; l < nexternal_interaction_geom; l++)
            {
              data_count[external_interaction_geometric_data_pt[l]]++;
              if (internal_data_element_pt
                    [external_interaction_geometric_data_pt[l]] != 0)
              {
                internal_data_count
                  [internal_data_element_pt
                     [external_interaction_geometric_data_pt[l]]]++;
              }
            }
          }
 
          // Loop over unique data entries
          //------------------------------
          for (std::map<Data*, unsigned>::iterator it = data_count.begin();
               it != data_count.end();
               it++)
          {
            Data* unique_data_pt = it->first;
 
            // Try to cast to a Node
            //----------------------
            Node* node_pt = dynamic_cast<Node*>(unique_data_pt);
            if (node_pt == 0)
            {
              // Is it a solid node? NOTE: This query makes sense as we're
              //----------------------------------------------------------
              // checking for the SolidNode's *positional* Data, not for
              //--------------------------------------------------------
              // the SolidNode itself!
              //----------------------
              if (solid_node_pt[unique_data_pt] != 0)
              {
                some_file << "TEXT ";
                for (unsigned j = 0; j < ndim_eulerian; j++)
                {
                  some_file << label[j] << solid_node_pt[unique_data_pt]->x(j)
                            << " ";
                }
 
                some_file << "CS=GRID, HU=FRAME, H=2.5, AN=MIDCENTER, C=GREEN "
                          << "T=\"" << it->second << "\"" << std::endl;
              }
 
              // Is it internal (pressure) Data in a fluid element?
              //---------------------------------------------------
              else if (internal_data_element_pt[unique_data_pt] != 0)
              {
                if (!element_internal_data_has_been_plotted
                      [internal_data_element_pt[unique_data_pt]])
                {
                  some_file << "TEXT ";
                  // Pointer to fluid element that contains this internal data
                  FiniteElement* fluid_el_pt =
                    internal_data_element_pt[unique_data_pt];
 
                  // Get the plot coordinates in this element: centre + a bit of
                  // offset
                  double s_max = fluid_el_pt->s_max();
                  double s_min = fluid_el_pt->s_min();
                  Vector<double> s_fluid(ndim_eulerian);
                  Vector<double> x_fluid(ndim_eulerian);
                  for (unsigned k = 0; k < ndim_eulerian; k++)
                  {
                    s_fluid[k] = 0.5 * (s_max + s_min) + 0.1 * (s_max - s_min);
                  }
                  fluid_el_pt->interpolated_x(s_fluid, x_fluid);
                  for (unsigned j = 0; j < ndim_eulerian; j++)
                  {
                    some_file << label[j] << x_fluid[j] << " ";
                  }
 
                  some_file << "CS=GRID, HU=FRAME, H=2.5, AN=MIDCENTER, C=BLUE "
                            << "T=\"" << it->second
                            << "\""
                            // internal_data_count[fluid_el_pt]
                            << std::endl;
 
                  // Now we have plotted it....
                  element_internal_data_has_been_plotted
                    [internal_data_element_pt[unique_data_pt]] = true;
                }
              }
              else
              {
                std::ostringstream error_message;
                error_message
                  << "Data that affects the load on an FSIWallElement\n"
                  << "is neither a (fluid) Node, nor a SolidNode nor\n"
                  << "internal Data in a (fluid) element\n"
                  << "I don't think this should happen..." << std::endl;
                throw OomphLibError(error_message.str(),
                                    OOMPH_CURRENT_FUNCTION,
                                    OOMPH_EXCEPTION_LOCATION);
              }
            }
            // It must be a node then
            //-----------------------
            else
            {
              some_file << "TEXT ";
              for (unsigned j = 0; j < ndim_eulerian; j++)
              {
                some_file << label[j] << node_pt->x(j) << ", ";
              }
              some_file << "CS=GRID, HU=FRAME, H=2.5, AN=MIDCENTER, C=RED "
                        << "T=\"" << it->second << "\"" << std::endl;
            }
          }
 
#ifdef OOMPH_HAS_MPI
        } // end is_halo()
#endif
        some_file.close();
      }
 
      // Part 2: Doc which dofs affect the node update functions
      //========================================================
 
 
      // Counter for the number of nodes that are actually
      // affected by wall motion
      unsigned count = 0;
 
      // Loop over nodes in fluid mesh
      unsigned nnode_fluid = fluid_mesh_pt->nnode();
      for (unsigned j = 0; j < nnode_fluid; j++)
      {
        // Upcast node to appropriate type
        NODE* node_pt = dynamic_cast<NODE*>(fluid_mesh_pt->node_pt(j));
 
        unsigned ndim_eulerian = node_pt->ndim();
 
        // Cleart the filename
        filename.str("");
        filename << doc_info.directory() << "/fsi_doc_fluid_element"
                 << doc_info.number() << "-" << count << ".dat";
        some_file.open(filename.str().c_str());
        some_file << "ZONE" << std::endl;
        for (unsigned i = 0; i < ndim_eulerian; i++)
        {
          some_file << node_pt->x(i) << " ";
        }
        some_file << std::endl;
 
        // Extract geom objects that affect the nodal position
        Vector<GeomObject*> geom_obj_pt(node_pt->vector_geom_object_pt());
 
 
        // Get the multiplicity of data that affects this node
        //----------------------------------------------------
        std::map<Data*, unsigned> data_count;
        unsigned ngeom = geom_obj_pt.size();
        for (unsigned i = 0; i < ngeom; i++)
        {
          unsigned ngeom_dat = geom_obj_pt[i]->ngeom_data();
          for (unsigned k = 0; k < ngeom_dat; k++)
          {
            data_count[geom_obj_pt[i]->geom_data_pt(k)]++;
          }
        }
 
        // Haven't actually doced any dependcies for this node
        bool written_something = false;
 
        // Loop over unique data entries
        //------------------------------
        for (std::map<Data*, unsigned>::iterator it = data_count.begin();
             it != data_count.end();
             it++)
        {
          Data* unique_data_pt = it->first;
 
          // Is it a solid node?
          if (solid_node_pt[unique_data_pt] != 0)
          {
            some_file << "TEXT ";
            for (unsigned j = 0; j < ndim_eulerian; j++)
            {
              some_file << label[j] << solid_node_pt[unique_data_pt]->x(j)
                        << " ";
            }
 
            some_file << "CS=GRID, HU=FRAME, H=2.5, AN=MIDCENTER, C=GREEN "
                      << "T=\"" << unique_data_pt->nvalue() << "\""
                      << std::endl;
 
            // We've actually produced some output
            written_something = true;
          }
          // It's not a solid node --> ??
          else
          {
            std::ostringstream warn_message;
            warn_message
              << "Info: Position of a fluid node is affected by Data that"
              << "is not a SolidNode --> Can't plot this Data. \n\n"
              << "(You may also want to check if this is exepcted or likely "
                 "to\n"
              << "indicate a bug in your code...)" << std::endl;
            throw OomphLibWarning(warn_message.str(),
                                  "FSI_functions::doc_fsi()",
                                  OOMPH_EXCEPTION_LOCATION);
          }
        }
 
 
        some_file.close();
 
        // If we've written something for the last node, bump up
        // counter for file so we don't overwrite
        if (written_something) count++;
      }
 
    } // end_of_doc_fsi

References oomph::FiniteElement::dim(), oomph::DocInfo::directory(), e(), oomph::Mesh::element_pt(), oomph::ElementWithExternalElement::external_element_local_coord(), oomph::ElementWithExternalElement::external_element_pt(), oomph::ElementWithExternalElement::external_interaction_field_data_pt(), oomph::ElementWithExternalElement::external_interaction_geometric_data_pt(), MergeRestartFiles::filename, oomph::Mesh::finite_element_pt(), i, oomph::FiniteElement::integral_pt(), oomph::GeneralisedElement::internal_data_pt(), oomph::FiniteElement::interpolated_x(), j, k, oomph::Integral::knot(), UniformPSDSelfTest::label, oomph::Node::ndim(), oomph::Mesh::nelement(), oomph::GeneralisedElement::ninternal_data(), oomph::Mesh::nnode(), oomph::FiniteElement::nodal_dimension(), oomph::Mesh::node_pt(), oomph::SolidMesh::node_pt(), oomph::DocInfo::number(), oomph::Data::nvalue(), oomph::Integral::nweight(), oomph::FSIWallElement::only_front_is_loaded_by_fluid(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Mesh::output(), s, oomph::FiniteElement::s_max(), oomph::FiniteElement::s_min(), oomph::SolidNode::variable_position_pt(), plotDoE::x, and oomph::Node::x().

setup_fluid_load_info_for_solid_elements() [1/2]

template<class FLUID_ELEMENT , unsigned DIM_FLUID>

void oomph::FSI_functions::setup_fluid_load_info_for_solid_elements	(	Problem *	problem_pt,
		const unsigned &	boundary_in_fluid_mesh,
		Mesh *const &	fluid_mesh_pt,
		Mesh *const &	solid_mesh_pt,
		const unsigned &	face = 0
	)

Set up the information that the FSIWallElements in the specified solid mesh require to obtain the fluid loading from the adjacent fluid elements in the specified fluid mesh. The parameter b specifies the boundary in the fluid mesh that is adjacent to the solid mesh. The template parameters specify the type of the fluid element and their spatial dimension. The optional final argument, face, identifies the face of the FSIWallElements that is exposed to the fluid. face defaults to 0, indicating that the front is loaded along the specified fluid mesh boundary. Set it to 1 to set up the FSI lookup schemes for fluid loading along the "back" of the FSIWallElements. This routine uses the procedures in the Multi_domain_functions namespace to set up the interaction by locating the adjacent (source) elements for each integration point of each solid element

    {
      // Thin wrapper to multi-domain function
      Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh<
        FLUID_ELEMENT,
        DIM_FLUID>(
        problem_pt, boundary_in_fluid_mesh, fluid_mesh_pt, solid_mesh_pt, face);
    }

References FLUID_ELEMENT, and oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

setup_fluid_load_info_for_solid_elements() [2/2]

template<class FLUID_ELEMENT , unsigned DIM_FLUID>

void oomph::FSI_functions::setup_fluid_load_info_for_solid_elements	(	Problem *	problem_pt,
		Vector< unsigned > &	boundary_in_fluid_mesh,
		Mesh *const &	fluid_mesh_pt,
		Vector< Mesh * > &	solid_mesh_pt,
		const unsigned &	face = 0
	)

Set up the information that the FSIWallElements in the specified solid mesh require to obtain the fluid loading from the adjacent fluid elements in the specified fluid mesh. The parameter b specifies the boundary in the fluid mesh that is adjacent to the solid mesh. The template parameters specify the type of the fluid element and their spatial dimension. The optional final argument, face, identifies the face of the FSIWallElements that is exposed to the fluid. face defaults to 0, indicating that the front is loaded along the specified fluid mesh boundary. Set it to 1 to set up the FSI lookup schemes for fluid loading along the "back" of the FSIWallElements. This routine uses the procedures in the Multi_domain_functions namespace to set up the interaction by locating the adjacent (source) elements for each integration point of each solid element

This is the vector based version it works simultaneously on fluid fsi boundaries identified in the vector boundary_in_fluid_mesh and the corresponding solid meshes in solid_mesh_pt.

    {
      // Thin wrapper to multi-domain function
      Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh<
        FLUID_ELEMENT,
        DIM_FLUID>(
        problem_pt, boundary_in_fluid_mesh, fluid_mesh_pt, solid_mesh_pt, face);
    }

References FLUID_ELEMENT, and oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

setup_solid_elements_for_displacement_bc() [1/2]

template<class SOLID_ELEMENT , unsigned DIM_SOLID>

void oomph::FSI_functions::setup_solid_elements_for_displacement_bc	(	Problem *	problem_pt,
		const unsigned &	b_solid_fsi,
		Mesh *const &	solid_mesh_pt,
		Mesh *const &	lagrange_multiplier_mesh_pt
	)

Setup multi-domain interaction required for imposition of solid displacements onto the pseudo-solid fluid mesh by Lagrange multipliers: This function locates the bulk solid elements next to boundary b_solid_fsi (the FSI boundary) in the solid mesh pointed to by Solid_mesh_pt. The deformation of these elements drives the deformation of the pseudo-solid fluid mesh via the Lagrange multiplier elements stored in l lagrange_multiplier_mesh_pt. The template parameters specify the type of the bulk solid elements and their spatial dimension.

    {
      // Thin wrapper to multi-domain function
      Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh<
        SOLID_ELEMENT,
        DIM_SOLID>(
        problem_pt, b_solid_fsi, solid_mesh_pt, lagrange_multiplier_mesh_pt, 0);
    }

References oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

setup_solid_elements_for_displacement_bc() [2/2]

template<class SOLID_ELEMENT , unsigned DIM_SOLID>

void oomph::FSI_functions::setup_solid_elements_for_displacement_bc	(	Problem *	problem_pt,
		const Vector< unsigned > &	b_solid_fsi,
		Mesh *const &	solid_mesh_pt,
		Vector< Mesh * > &	lagrange_multiplier_mesh_pt
	)

Setup multi-domain interaction required for imposition of solid displacements onto the pseudo-solid fluid mesh by Lagrange multipliers: This function locates the bulk solid elements next to boundary b_solid_fsi (the FSI boundary) in the solid mesh pointed to by Solid_mesh_pt. The deformation of these elements drives the deformation of the pseudo-solid fluid mesh via the Lagrange multiplier elements stored in lagrange_multiplier_mesh_pt. The template parameters specify the type of the bulk solid elements and their spatial dimension.

This is the vector based version it works simultaneously on solid fsi boundaries identified in the vector b_solid_fsi and the corresponding Lagrange multiplier meshes in lagrange_multiplier_mesh_pt.

    {
      // Thin wrapper to multi-domain function
      Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh<
        SOLID_ELEMENT,
        DIM_SOLID>(
        problem_pt, b_solid_fsi, solid_mesh_pt, lagrange_multiplier_mesh_pt, 0);
    }

References oomph::Multi_domain_functions::setup_bulk_elements_adjacent_to_face_mesh().

Variable Documentation

Strouhal_for_no_slip

double oomph::FSI_functions::Strouhal_for_no_slip = 1.0

Strouhal number St = a/(UT) for application of no slip condition. Initialised to 1.0.

Referenced by apply_no_slip_on_moving_wall(), TurekProblem< FLUID_ELEMENT, SOLID_ELEMENT >::TurekProblem(), and FlowAroundCylinderProblem< ELEMENT >::unsteady_simulation().