d1/db1/channel__with__leaflet__domain_8h_source.html

 // LIC// ====================================================================

 // LIC// This file forms part of oomph-lib, the object-oriented,

 // LIC// multi-physics finite-element library, available

 // LIC// at http://www.oomph-lib.org.

 // LIC//

 // LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel

 // LIC//

 // LIC// This library is free software; you can redistribute it and/or

 // LIC// modify it under the terms of the GNU Lesser General Public

 // LIC// License as published by the Free Software Foundation; either

 // LIC// version 2.1 of the License, or (at your option) any later version.

 // LIC//

 // LIC// This library is distributed in the hope that it will be useful,

 // LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of

 // LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 // LIC// Lesser General Public License for more details.

 // LIC//

 // LIC// You should have received a copy of the GNU Lesser General Public

 // LIC// License along with this library; if not, write to the Free Software

 // LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 // LIC// 02110-1301  USA.

 // LIC//

 // LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.

 // LIC//

 // LIC//====================================================================

 #ifndef OOMPH_CHANNEL_WITH_LEAFLET_DOMAIN_HEADER

 #define OOMPH_CHANNEL_WITH_LEAFLET_DOMAIN_HEADER


 // Generic includes

 #include "../generic/geom_objects.h"

 #include "../generic/domain.h"

 #include "../generic/macro_element.h"


 namespace oomph

 {

   //===========================================================

   //===========================================================

   class ChannelWithLeafletDomain : public Domain

   {

   public:

     ChannelWithLeafletDomain(GeomObject* leaflet_pt,

                              const double& lleft,

                              const double& lright,

                              const double& hleaflet,

                              const double& htot,

                              const unsigned& nleft,

                              const unsigned& nright,

                              const unsigned& ny1,

                              const unsigned& ny2)

     {

       // Copy assignments into private storage

       Lleft = lleft;

       Lright = lright;

       Hleaflet = hleaflet;

       Htot = htot;

       Nleft = nleft;

       Nright = nright;

       Ny1 = ny1;

       Ny2 = ny2;

       Leaflet_pt = leaflet_pt;


       // Store origin of leaflet for fast reference

       Vector<double> zeta(1);

       zeta[0] = 0.0;

       Vector<double> r(2);

       Leaflet_pt->position(zeta, r);

       X_0 = r[0];


       // Number of macro elements

       unsigned nmacro = (Ny1 + Ny2) * (Nleft + Nright);

       Macro_element_pt.resize(nmacro);


       // Build the 2D macro elements

       for (unsigned i = 0; i < nmacro; i++)

       {

         Macro_element_pt[i] = new QMacroElement<2>(this, i);

       }

     }


     ~ChannelWithLeafletDomain() {}


     double htot()

     {

       return Htot;

     }


     double hleaflet()

     {

       return Hleaflet;

     }


     double lleft()

     {

       return Lleft;

     }


     double lright()

     {

       return Lright;

     }


     GeomObject*& leaflet_pt()

     {

       return Leaflet_pt;

     };


     void macro_element_boundary(const unsigned& t,

                                 const unsigned& imacro,

                                 const unsigned& idirect,

                                 const Vector<double>& zeta,

                                 Vector<double>& r);


   protected:

     void macro_bound_I_N(const unsigned& t,

                          const Vector<double>& zeta,

                          Vector<double>& r,

                          const unsigned& i,

                          const unsigned& j);


     void macro_bound_I_S(const unsigned& t,

                          const Vector<double>& zeta,

                          Vector<double>& r,

                          const unsigned& i,

                          const unsigned& j);


     void macro_bound_I_W(const unsigned& t,

                          const Vector<double>& zeta,

                          Vector<double>& r,

                          const unsigned& i,

                          const unsigned& j);


     void macro_bound_I_E(const unsigned& t,

                          const Vector<double>& zeta,

                          Vector<double>& r,

                          const unsigned& i,

                          const unsigned& j);


     void macro_bound_II_N(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_II_S(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_II_W(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_II_E(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_III_N(const unsigned& t,

                            const Vector<double>& zeta,

                            Vector<double>& r,

                            const unsigned& i,

                            const unsigned& j);


     void macro_bound_III_S(const unsigned& t,

                            const Vector<double>& zeta,

                            Vector<double>& r,

                            const unsigned& i,

                            const unsigned& j);


     void macro_bound_III_W(const unsigned& t,

                            const Vector<double>& zeta,

                            Vector<double>& r,

                            const unsigned& i,

                            const unsigned& j);


     void macro_bound_III_E(const unsigned& t,

                            const Vector<double>& zeta,

                            Vector<double>& r,

                            const unsigned& i,

                            const unsigned& j);


     void macro_bound_IV_N(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_IV_S(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_IV_W(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);


     void macro_bound_IV_E(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r,

                           const unsigned& i,

                           const unsigned& j);

     void slanted_bound_up(const unsigned& t,

                           const Vector<double>& zeta,

                           Vector<double>& r);


     double Lright;


     double Lleft;


     double Hleaflet;


     double Htot;


     unsigned Nright;


     unsigned Nleft;


     unsigned Ny1;


     unsigned Ny2;


     double X_0;


     GeomObject* Leaflet_pt;

   };


   //===================================================================

   //===================================================================

   void ChannelWithLeafletDomain::macro_element_boundary(

     const unsigned& t,

     const unsigned& imacro,

     const unsigned& idirect,

     const Vector<double>& zeta,

     Vector<double>& r)

   {

 #ifdef WARN_ABOUT_SUBTLY_CHANGED_OOMPH_INTERFACES

     // Warn about time argument being moved to the front

     OomphLibWarning(

       "Order of function arguments has changed between versions 0.8 and 0.85",

       "ChannelWithLeafletDomain::macro_element_boundary(...)",

       OOMPH_EXCEPTION_LOCATION);

 #endif


     using namespace QuadTreeNames;


     // Number of the line and of the colum in the whole domain

     // Beware : iline starts on zero

     unsigned iline = int(floor(double(imacro) / double(Nleft + Nright)));

     unsigned icol = imacro % (Nright + Nleft);


     // Number of the line and of the colum in the part considered

     unsigned i, j;


     // Left low part of the domain : Part I

     //------------------------------------

     if ((iline < Ny1) && (icol < Nleft))

     {

       i = iline;

       j = icol;


       switch (idirect)

       {

         case N:

           macro_bound_I_N(t, zeta, r, i, j);

           break;

         case S:

           macro_bound_I_S(t, zeta, r, i, j);

           break;

         case W:

           macro_bound_I_W(t, zeta, r, i, j);

           break;

         case E:

           macro_bound_I_E(t, zeta, r, i, j);

           break;

       }

     }

     // Right low part of the domain : Part II

     //--------------------------------------

     else if ((iline < Ny1) && (icol >= Nleft))

     {

       i = iline;

       j = icol - Nleft;


       switch (idirect)

       {

         case N:

           macro_bound_II_N(t, zeta, r, i, j);

           break;

         case S:

           macro_bound_II_S(t, zeta, r, i, j);

           break;

         case W:

           macro_bound_II_W(t, zeta, r, i, j);

           break;

         case E:

           macro_bound_II_E(t, zeta, r, i, j);

           break;

       }

     }

     // Left upper part of the domain : Part III

     //----------------------------------------

     else if ((iline >= Ny1) && (icol < Nleft))

     {

       i = iline - Ny1;

       j = icol;


       switch (idirect)

       {

         case N:

           macro_bound_III_N(t, zeta, r, i, j);

           break;

         case S:

           macro_bound_III_S(t, zeta, r, i, j);

           break;

         case W:

           macro_bound_III_W(t, zeta, r, i, j);

           break;

         case E:

           macro_bound_III_E(t, zeta, r, i, j);

           break;

       }

     }

     // Right upper part of the domain : Part IV

     //-----------------------------------------

     else if ((iline >= Ny1) && (icol >= Nleft))

     {

       i = iline - Ny1;

       j = icol - Nleft;


       switch (idirect)

       {

         case N:

           macro_bound_IV_N(t, zeta, r, i, j);

           break;

         case S:

           macro_bound_IV_S(t, zeta, r, i, j);

           break;

         case W:

           macro_bound_IV_W(t, zeta, r, i, j);

           break;

         case E:

           macro_bound_IV_E(t, zeta, r, i, j);

           break;

       }

     }

   }


   // Helper functions for region I (lower left region)


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_I_E(const unsigned& t,

                                                  const Vector<double>& zeta,

                                                  Vector<double>& r,

                                                  const unsigned& i,

                                                  const unsigned& j)

   {

     // Find x,y on the wall corresponding to the position of the macro element


     // xi_wall varies from xi0 to xi1 on the wall

     double xi0, xi1;

     xi0 = double(i) * Hleaflet / double(Ny1);

     xi1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> xi_wall(1);

     xi_wall[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_wall(2);

     Leaflet_pt->position(t, xi_wall, r_wall);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * Hleaflet / double(Ny1);

     y1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> r_vert(2);

     r_vert[0] = -Lleft + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in -Lleft and value 1 on the wall.

     double s = double(j + 1) / double(Nleft);


     r[0] = r_vert[0] + s * (r_wall[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_wall[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_I_W(const unsigned& t,

                                                  const Vector<double>& zeta,

                                                  Vector<double>& r,

                                                  const unsigned& i,

                                                  const unsigned& j)

   {

     // Find x,y on the wall corresponding to the position of the macro element


     // xi_wall varies from xi0 to xi1 on the wall

     double xi0, xi1;

     xi0 = double(i) * Hleaflet / double(Ny1);

     xi1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> xi_wall(1);

     xi_wall[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_wall(2);

     Leaflet_pt->position(t, xi_wall, r_wall);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * Hleaflet / double(Ny1);

     y1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> r_vert(2);

     r_vert[0] = -Lleft + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in -Lleft and value 1 on the wall.

     double s = double(j) / double(Nleft);


     r[0] = r_vert[0] + s * (r_wall[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_wall[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_I_N(const unsigned& t,

                                                  const Vector<double>& zeta,

                                                  Vector<double>& r,

                                                  const unsigned& i,

                                                  const unsigned& j)

   {

     // Find the coordinates of the two corners of the north boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = 1;

     macro_bound_I_W(t, xi, r_left, i, j);

     macro_bound_I_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_I_S(const unsigned& t,

                                                  const Vector<double>& zeta,

                                                  Vector<double>& r,

                                                  const unsigned& i,

                                                  const unsigned& j)

   {

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = -1.0;

     macro_bound_I_W(t, xi, r_left, i, j);

     macro_bound_I_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   // Helper functions for region II (lower right region)


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_II_E(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)


   {

     // Find x,y on the wall corresponding to the position of the macro element


     // xi_wall varies from xi0 to xi1 on the wall

     double xi0, xi1;

     xi0 = double(i) * Hleaflet / double(Ny1);

     xi1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> xi_wall(1);

     xi_wall[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_wall(2);

     Leaflet_pt->position(t, xi_wall, r_wall);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * Hleaflet / double(Ny1);

     y1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> r_vert(2);

     r_vert[0] = Lright + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in Lright and value 1 on the wall.

     double s = double(Nright - j - 1) / double(Nright); /***Change****/


     r[0] = r_vert[0] + s * (r_wall[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_wall[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_II_W(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Abscissa of the origin of the boudary east


     // Find x,y on the wall corresponding to the position of the macro element


     // xi_wall varies from xi0 to xi1 on the wall

     double xi0, xi1;

     xi0 = double(i) * Hleaflet / double(Ny1);

     xi1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> xi_wall(1);

     xi_wall[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_wall(2);

     Leaflet_pt->position(t, xi_wall, r_wall);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * Hleaflet / double(Ny1);

     y1 = double(i + 1) * Hleaflet / double(Ny1);


     Vector<double> r_vert(2);

     r_vert[0] = Lright + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in -Lleft and value 1 on the wall.

     double s = double(Nright - j) / double(Nright); /***Change****/


     // Final expression of r

     r[0] = r_vert[0] + s * (r_wall[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_wall[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_II_N(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find the coordinates of the two corners of the north boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = 1;

     macro_bound_II_W(t, xi, r_left, i, j);

     macro_bound_II_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_II_S(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find the coordinates of the two corners of the south boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = -1.0;

     macro_bound_II_W(t, xi, r_left, i, j);

     macro_bound_II_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   // Helper functions for region III (upper left region)


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::slanted_bound_up(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r)

   {

     // Coordinates of the point on the boundary beetween the upper

     // and the lower part, in the same column, at the east.

     Vector<double> xi(1);

     xi[0] = Hleaflet;


     Vector<double> r_join(2);


     Leaflet_pt->position(t, xi, r_join);


     r[0] = r_join[0] + zeta[0] * (X_0 - r_join[0]);

     r[1] = r_join[1] + zeta[0] * (Htot - r_join[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_III_E(const unsigned& t,

                                                    const Vector<double>& zeta,

                                                    Vector<double>& r,

                                                    const unsigned& i,

                                                    const unsigned& j)

   {

     // Find x,y on the slanted straight line (SSL) corresponding to

     // the position of the macro element


     // xi_line varies from xi0 to xi1 on the SSL

     double xi0, xi1;

     xi0 = double(i) / double(Ny2);

     xi1 = double(i + 1) / double(Ny2);


     Vector<double> xi_line(1);

     xi_line[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_line(2);

     slanted_bound_up(t, xi_line, r_line);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     y1 = double(i + 1) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     ;


     Vector<double> r_vert(2);

     r_vert[0] = -Lleft + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in Lright and value 1 on the wall.

     double s = double(j + 1) / double(Nleft); /***Change****/


     r[0] = r_vert[0] + s * (r_line[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_line[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_III_W(const unsigned& t,

                                                    const Vector<double>& zeta,

                                                    Vector<double>& r,

                                                    const unsigned& i,

                                                    const unsigned& j)

   {

     // Find x,y on the slanted straight line (SSL) corresponding to

     // the position of the macro element


     // xi_line varies from xi0 to xi1 on the SSL

     double xi0, xi1;

     xi0 = double(i) / double(Ny2);

     xi1 = double(i + 1) / double(Ny2);


     Vector<double> xi_line(1);

     xi_line[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_line(2);

     slanted_bound_up(t, xi_line, r_line);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     y1 = double(i + 1) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     ;


     Vector<double> r_vert(2);

     r_vert[0] = -Lleft + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in Lright and value 1 on the wall.

     double s = double(j) / double(Nleft); /***Change****/


     // Final expression of r

     r[0] = r_vert[0] + s * (r_line[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_line[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_III_N(const unsigned& t,

                                                    const Vector<double>& zeta,

                                                    Vector<double>& r,

                                                    const unsigned& i,

                                                    const unsigned& j)

   {

     // Find the coordinates of the two corners of the north boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = 1;

     macro_bound_III_W(t, xi, r_left, i, j);

     macro_bound_III_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_III_S(const unsigned& t,

                                                    const Vector<double>& zeta,

                                                    Vector<double>& r,

                                                    const unsigned& i,

                                                    const unsigned& j)

   {

     // Find the coordinates of the two corners of the south boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = -1;

     macro_bound_III_W(t, xi, r_left, i, j);

     macro_bound_III_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   // Helper functions for region IV (upper right region)


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_IV_E(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find x,y on the slanted straight line (SSL) corresponding to

     // the position of the macro element


     // xi_line varies from xi0 to xi1 on the SSL

     double xi0, xi1;

     xi0 = double(i) / double(Ny2);

     xi1 = double(i + 1) / double(Ny2);


     Vector<double> xi_line(1);

     xi_line[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_line(2);

     slanted_bound_up(t, xi_line, r_line);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // the vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     y1 = double(i + 1) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     ;


     Vector<double> r_vert(2);

     r_vert[0] = Lright + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in Lright and value 1 on the wall.

     double s = double(Nright - j - 1) / double(Nright); /***Change****/


     // Final expression of r

     r[0] = r_vert[0] + s * (r_line[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_line[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_IV_W(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find x,y on the slanted straight line (SSL) corresponding to

     // the position of the macro element


     // xi_line varies from xi0 to xi1 on the SSL

     double xi0, xi1;

     xi0 = double(i) / double(Ny2);

     xi1 = double(i + 1) / double(Ny2);


     Vector<double> xi_line(1);

     xi_line[0] = xi0 + (1.0 + zeta[0]) / 2.0 * (xi1 - xi0);


     Vector<double> r_line(2);

     slanted_bound_up(t, xi_line, r_line);


     // Find x,y on a vertical line corresponding

     // to the position of the macro element


     // The vertical line goes from y0 to y1

     double y0, y1;

     y0 = double(i) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     y1 = double(i + 1) * (Htot - Hleaflet) / double(Ny2) + Hleaflet;

     ;


     Vector<double> r_vert(2);

     r_vert[0] = Lright + X_0;

     r_vert[1] = y0 + (1.0 + zeta[0]) / 2.0 * (y1 - y0);


     // Parameter with value 0 in Lright and value 1 on the wall.

     double s = double(Nright - j) / double(Nright); /***Change****/


     // Final expression of r

     r[0] = r_vert[0] + s * (r_line[0] - r_vert[0]);

     r[1] = r_vert[1] + s * (r_line[1] - r_vert[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_IV_N(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find the coordinates of the two corners of the north boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = 1;

     macro_bound_IV_W(t, xi, r_left, i, j);

     macro_bound_IV_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


   //=====================================================================

   //=====================================================================

   void ChannelWithLeafletDomain::macro_bound_IV_S(const unsigned& t,

                                                   const Vector<double>& zeta,

                                                   Vector<double>& r,

                                                   const unsigned& i,

                                                   const unsigned& j)

   {

     // Find the coordinates of the two corners of the south boundary

     Vector<double> xi(1);

     Vector<double> r_left(2);

     Vector<double> r_right(2);

     xi[0] = -1;

     macro_bound_IV_W(t, xi, r_left, i, j);

     macro_bound_IV_E(t, xi, r_right, i, j);


     // Connect those two points with a straight line

     r[0] = r_left[0] + (1.0 + zeta[0]) / 2.0 * (r_right[0] - r_left[0]);

     r[1] = r_left[1] + (1.0 + zeta[0]) / 2.0 * (r_right[1] - r_left[1]);

   }


 } // namespace oomph


 #endif

i
int i
Definition: BiCGSTAB_step_by_step.cpp:9

double

oomph::ChannelWithLeafletDomain
Definition: channel_with_leaflet_domain.h:42

oomph::ChannelWithLeafletDomain::macro_bound_IV_S
void macro_bound_IV_S(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:974

oomph::ChannelWithLeafletDomain::macro_bound_III_W
void macro_bound_III_W(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:763

oomph::ChannelWithLeafletDomain::Leaflet_pt
GeomObject * Leaflet_pt
Pointer to leaflet.
Definition: channel_with_leaflet_domain.h:278

oomph::ChannelWithLeafletDomain::macro_bound_I_N
void macro_bound_I_N(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:501

oomph::ChannelWithLeafletDomain::Lleft
double Lleft
Length of the domain to the left of the leaflet.
Definition: channel_with_leaflet_domain.h:253

oomph::ChannelWithLeafletDomain::Nright
unsigned Nright
Number of macro element columnns to the right of the leaflet.
Definition: channel_with_leaflet_domain.h:262

oomph::ChannelWithLeafletDomain::macro_bound_II_N
void macro_bound_II_N(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:643

oomph::ChannelWithLeafletDomain::Ny2
unsigned Ny2
Number of macro element rows above the leaflet.
Definition: channel_with_leaflet_domain.h:271

oomph::ChannelWithLeafletDomain::macro_bound_I_W
void macro_bound_I_W(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:458

oomph::ChannelWithLeafletDomain::X_0
double X_0
Definition: channel_with_leaflet_domain.h:275

oomph::ChannelWithLeafletDomain::macro_bound_IV_E
void macro_bound_IV_E(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:861

oomph::ChannelWithLeafletDomain::macro_bound_I_S
void macro_bound_I_S(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:524

oomph::ChannelWithLeafletDomain::Ny1
unsigned Ny1
Number of macro element rows up to the end of the leaflet.
Definition: channel_with_leaflet_domain.h:268

oomph::ChannelWithLeafletDomain::lleft
double lleft()
Length of domain to the left of leaflet.
Definition: channel_with_leaflet_domain.h:107

oomph::ChannelWithLeafletDomain::macro_bound_II_S
void macro_bound_II_S(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:666

oomph::ChannelWithLeafletDomain::Lright
double Lright
Length of the domain to the right of the leaflet.
Definition: channel_with_leaflet_domain.h:250

oomph::ChannelWithLeafletDomain::ChannelWithLeafletDomain
ChannelWithLeafletDomain(GeomObject *leaflet_pt, const double &lleft, const double &lright, const double &hleaflet, const double &htot, const unsigned &nleft, const unsigned &nright, const unsigned &ny1, const unsigned &ny2)
Definition: channel_with_leaflet_domain.h:52

oomph::ChannelWithLeafletDomain::Hleaflet
double Hleaflet
Lagrangian coordinate at end of leaflet.
Definition: channel_with_leaflet_domain.h:256

oomph::ChannelWithLeafletDomain::~ChannelWithLeafletDomain
~ChannelWithLeafletDomain()
Destructor: Empty; cleanup done in base class.
Definition: channel_with_leaflet_domain.h:92

oomph::ChannelWithLeafletDomain::macro_bound_III_N
void macro_bound_III_N(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:808

oomph::ChannelWithLeafletDomain::macro_bound_II_E
void macro_bound_II_E(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:554

oomph::ChannelWithLeafletDomain::leaflet_pt
GeomObject *& leaflet_pt()
Pointer to the wall.
Definition: channel_with_leaflet_domain.h:119

oomph::ChannelWithLeafletDomain::slanted_bound_up
void slanted_bound_up(const unsigned &t, const Vector< double > &zeta, Vector< double > &r)
Helper function.
Definition: channel_with_leaflet_domain.h:697

oomph::ChannelWithLeafletDomain::macro_bound_III_S
void macro_bound_III_S(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:831

oomph::ChannelWithLeafletDomain::htot
double htot()
Total height of domain (width of channel)
Definition: channel_with_leaflet_domain.h:95

oomph::ChannelWithLeafletDomain::macro_bound_IV_W
void macro_bound_IV_W(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:906

oomph::ChannelWithLeafletDomain::macro_bound_I_E
void macro_bound_I_E(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:415

oomph::ChannelWithLeafletDomain::Nleft
unsigned Nleft
Number of macro element columns to the left of the leaflet.
Definition: channel_with_leaflet_domain.h:265

oomph::ChannelWithLeafletDomain::Htot
double Htot
Total width of the channel.
Definition: channel_with_leaflet_domain.h:259

oomph::ChannelWithLeafletDomain::macro_element_boundary
void macro_element_boundary(const unsigned &t, const unsigned &imacro, const unsigned &idirect, const Vector< double > &zeta, Vector< double > &r)
Parametrisation of macro element boundaries.
Definition: channel_with_leaflet_domain.h:285

oomph::ChannelWithLeafletDomain::macro_bound_IV_N
void macro_bound_IV_N(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:951

oomph::ChannelWithLeafletDomain::lright
double lright()
Length of domain to the right of leaflet.
Definition: channel_with_leaflet_domain.h:113

oomph::ChannelWithLeafletDomain::macro_bound_III_E
void macro_bound_III_E(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:718

oomph::ChannelWithLeafletDomain::hleaflet
double hleaflet()
Height of leaflet.
Definition: channel_with_leaflet_domain.h:101

oomph::ChannelWithLeafletDomain::macro_bound_II_W
void macro_bound_II_W(const unsigned &t, const Vector< double > &zeta, Vector< double > &r, const unsigned &i, const unsigned &j)
Helper function.
Definition: channel_with_leaflet_domain.h:598

oomph::Domain
Definition: domain.h:67

oomph::Domain::Macro_element_pt
Vector< MacroElement * > Macro_element_pt
Vector of pointers to macro elements.
Definition: domain.h:301

oomph::GeomObject
Definition: geom_objects.h:101

oomph::GeomObject::position
virtual void position(const Vector< double > &zeta, Vector< double > &r) const =0
Parametrised position on object at current time: r(zeta).

oomph::OomphLibWarning
Definition: oomph_definitions.h:267

oomph::QMacroElement< 2 >
Definition: macro_element.h:279

oomph::Vector< double >

N
@ N
Definition: constructor.cpp:22

s
RealScalar s
Definition: level1_cplx_impl.h:130

int
return int(ret)+1

Eigen::bfloat16_impl::floor
EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC bfloat16 floor(const bfloat16 &a)
Definition: BFloat16.h:643

Eigen::zeta
EIGEN_STRONG_INLINE const Eigen::CwiseBinaryOp< Eigen::internal::scalar_zeta_op< typename DerivedX::Scalar >, const DerivedX, const DerivedQ > zeta(const Eigen::ArrayBase< DerivedX > &x, const Eigen::ArrayBase< DerivedQ > &q)
Definition: SpecialFunctionsArrayAPI.h:152

Global_Physical_Variables::E
double E
Elastic modulus.
Definition: TwenteMeshGluing.cpp:68

UniformPSDSelfTest.r
r
Definition: UniformPSDSelfTest.py:20

oomph::QuadTreeNames::S
@ S
Definition: quadtree.h:62

oomph::QuadTreeNames::W
@ W
Definition: quadtree.h:63

oomph
DRAIG: Change all instances of (SPATIAL_DIM) to (DIM-1).
Definition: AnisotropicHookean.h:10

plotPSD.t
t
Definition: plotPSD.py:36

OOMPH_EXCEPTION_LOCATION
#define OOMPH_EXCEPTION_LOCATION
Definition: oomph_definitions.h:61

j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2