doc/getfem_reference/getfem__fourth__order_8cc_source.html

 /*===========================================================================


  Copyright (C) 2009-2026 Yves Renard


  This file is a part of GetFEM


  GetFEM  is  free software;  you  can  redistribute  it  and/or modify it

  under  the  terms  of the  GNU  Lesser General Public License as published

  by  the  Free Software Foundation;  either version 3 of the License,  or

  (at your option) any later version along with the GCC Runtime Library

  Exception either version 3.1 or (at your option) any later version.

  This program  is  distributed  in  the  hope  that it will be useful,  but

  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

  or  FITNESS  FOR  A PARTICULAR PURPOSE.  See the GNU Lesser General Public

  License and GCC Runtime Library Exception for more details.

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

  along  with  this program. If not, see https://www.gnu.org/licenses/.


 ===========================================================================*/


 #include "getfem/getfem_fourth_order.h"

 #include "getfem/getfem_omp.h"


 namespace getfem {


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

   // Bilaplacian brick

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


   struct bilap_brick : public virtual_brick {


     virtual void asm_real_tangent_terms(const model &md, size_type ib,

                                         const model::varnamelist &vl,

                                         const model::varnamelist &dl,

                                         const model::mimlist &mims,

                                         model::real_matlist &matl,

                                         model::real_veclist &,

                                         model::real_veclist &,

                                         size_type region,

                                         build_version version) const {

       GMM_ASSERT1(matl.size() == 1,

                   "Bilaplacian brick has one and only one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Bilaplacian brick need one and only one mesh_im");

       GMM_ASSERT1(vl.size() == 1 && (dl.size() == 1 || dl.size() == 2),

                   "Wrong number of variables for bilaplacian brick");


       bool KL = (dl.size() == 2);


       bool recompute_matrix = !((version & model::BUILD_ON_DATA_CHANGE) != 0)

         || md.is_var_newer_than_brick(dl[0], ib);


       if (recompute_matrix) {


         const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

         const mesh &m = mf_u.linked_mesh();

         size_type Q = mf_u.get_qdim();

         GMM_ASSERT1(Q == 1, "Bilaplacian brick is only for a scalar field");

         const mesh_im &mim = *mims[0];

         mesh_region rg(region);

         m.intersect_with_mpi_region(rg);

         const mesh_fem *mf_data = md.pmesh_fem_of_variable(dl[0]);

         const model_real_plain_vector *data = &(md.real_variable(dl[0]));

         size_type sl = gmm::vect_size(*data);

         if (mf_data) sl = sl * mf_data->get_qdim() / mf_data->nb_dof();


         GMM_ASSERT1(sl == 1, "Bad format of bilaplacian coefficient");


         const mesh_fem *mf_data2 = 0;

         const model_real_plain_vector *data2 = 0;

         if (KL) {

           mf_data2 = md.pmesh_fem_of_variable(dl[1]);

           data2 = &(md.real_variable(dl[1]));

           size_type sl2 = gmm::vect_size(*data2);

           if (mf_data2) sl = sl * mf_data2->get_qdim() / mf_data2->nb_dof();

           GMM_ASSERT1(sl2 == 1, "Bad format of bilaplacian coefficient");

         }


         if (KL) {

           GMM_TRACE2("Stiffness matrix assembly of a bilaplacian term for a "

                      "Kirchhoff-Love plate");

         }

         else {

           GMM_TRACE2("Stiffness matrix assembly of a bilaplacian term");

         }


         gmm::clear(matl[0]);

         if (mf_data) {

           if (KL)

             asm_stiffness_matrix_for_bilaplacian_KL

               (matl[0], mim, mf_u, *mf_data,  *data, *data2, rg);

           else

             asm_stiffness_matrix_for_bilaplacian

               (matl[0], mim, mf_u, *mf_data,  *data, rg);

         } else {

           if (KL) {

             asm_stiffness_matrix_for_homogeneous_bilaplacian_KL

               (matl[0], mim, mf_u,  *data, *data2, rg);

           }

           else

             asm_stiffness_matrix_for_homogeneous_bilaplacian

               (matl[0], mim, mf_u,  *data, rg);

         }

       }

     }


     bilap_brick(void) {

       set_flags("Bilaplacian operator", true /* is linear*/,

                 true /* is symmetric */, true /* is coercive */,

                 true /* is real */, false /* is complex */);

     }


   };


   size_type add_bilaplacian_brick

   (model &md, const mesh_im &mim, const std::string &varname,

    const std::string &dataname,

    size_type region) {

     pbrick pbr = std::make_shared<bilap_brick>();

     model::termlist tl;

     tl.push_back(model::term_description(varname, varname, true));

     model::varnamelist dl(1, dataname);

     return md.add_brick(pbr, model::varnamelist(1, varname), dl, tl,

                         model::mimlist(1, &mim), region);

   }


   size_type add_bilaplacian_brick_KL

   (model &md, const mesh_im &mim, const std::string &varname,

    const std::string &dataname1, const std::string &dataname2,

    size_type region) {

     pbrick pbr = std::make_shared<bilap_brick>();

     model::termlist tl;

     tl.push_back(model::term_description(varname, varname, true));

     model::varnamelist dl(1, dataname1);

     dl.push_back(dataname2);

     return md.add_brick(pbr, model::varnamelist(1, varname), dl, tl,

                         model::mimlist(1, &mim), region);

   }


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

   //

   // Normal derivative source term brick

   //

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


   struct normal_derivative_source_term_brick : public virtual_brick {


     virtual void asm_real_tangent_terms(const model &md, size_type,

                                         const model::varnamelist &vl,

                                         const model::varnamelist &dl,

                                         const model::mimlist &mims,

                                         model::real_matlist &,

                                         model::real_veclist &vecl,

                                         model::real_veclist &,

                                         size_type region,

                                         build_version) const {

       GMM_ASSERT1(vecl.size() == 1,

                   "Normal derivative source term brick has one and only "

                   "one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Normal derivative source term brick need one and only "

                   "one mesh_im");

       GMM_ASSERT1(vl.size() == 1 && dl.size() == 1,

                   "Wrong number of variables for normal derivative "

                   "source term brick");


       const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

       const mesh_im &mim = *mims[0];

       const model_real_plain_vector &A = md.real_variable(dl[0]);

       const mesh_fem *mf_data = md.pmesh_fem_of_variable(dl[0]);

       mesh_region rg(region);

       mim.linked_mesh().intersect_with_mpi_region(rg);


       size_type s = gmm::vect_size(A);

       if (mf_data) s = s * mf_data->get_qdim() / mf_data->nb_dof();


       GMM_ASSERT1(s == mf_u.get_qdim()

                   || s == size_type(mf_u.get_qdim()*gmm::sqr(mf_u.linked_mesh().dim())),

                   dl[0] << ": bad format of normal derivative source term "

                   "data. Detected dimension is " << s << " should be "

                   << size_type(mf_u.get_qdim()));


       GMM_TRACE2("Normal derivative source term assembly");

       if (mf_data)

         asm_normal_derivative_source_term(vecl[0], mim, mf_u, *mf_data, A, rg);

       else

         asm_homogeneous_normal_derivative_source_term(vecl[0], mim, mf_u, A, rg);


     }


     virtual void asm_complex_tangent_terms(const model &md, size_type,

                                            const model::varnamelist &vl,

                                            const model::varnamelist &dl,

                                            const model::mimlist &mims,

                                            model::complex_matlist &,

                                            model::complex_veclist &vecl,

                                            model::complex_veclist &,

                                            size_type region,

                                            build_version) const {

       GMM_ASSERT1(vecl.size() == 1,

                   "Normal derivative source term brick has one and only "

                   "one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Normal derivative source term brick need one and only "

                   "one mesh_im");

       GMM_ASSERT1(vl.size() == 1 && dl.size() == 1,

                   "Wrong number of variables for normal derivative "

                   "source term brick");


       const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

       const mesh_im &mim = *mims[0];

       const model_complex_plain_vector &A = md.complex_variable(dl[0]);

       const mesh_fem *mf_data = md.pmesh_fem_of_variable(dl[0]);

       mesh_region rg(region);

       mim.linked_mesh().intersect_with_mpi_region(rg);


       size_type s = gmm::vect_size(A);

       if (mf_data) s = s * mf_data->get_qdim() / mf_data->nb_dof();


       GMM_ASSERT1(mf_u.get_qdim() == s,

                   dl[0] << ": bad format of normal derivative source term "

                   "data. Detected dimension is " << s << " should be "

                   << size_type(mf_u.get_qdim()));


       GMM_TRACE2("Normal derivative source term assembly");

       if (mf_data)

         asm_normal_derivative_source_term(vecl[0], mim, mf_u, *mf_data, A, rg);

       else

         asm_homogeneous_normal_derivative_source_term(vecl[0], mim, mf_u, A, rg);


     }


     normal_derivative_source_term_brick(void) {

       set_flags("Normal derivative source term", true /* is linear*/,

                 true /* is symmetric */, true /* is coercive */,

                 true /* is real */, true /* is complex */,

                 false /* compute each time */);

     }


   };


   size_type add_normal_derivative_source_term_brick

   (model &md, const mesh_im &mim, const std::string &varname,

    const std::string &dataname, size_type region) {

     pbrick pbr = std::make_shared<normal_derivative_source_term_brick>();

     model::termlist tl;

     tl.push_back(model::term_description(varname));

     model::varnamelist vdata(1, dataname);

     return md.add_brick(pbr, model::varnamelist(1, varname),

                         vdata, tl, model::mimlist(1, &mim), region);

   }


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

   //

   // K.L. source term brick

   //

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


   struct KL_source_term_brick : public virtual_brick {


     virtual void asm_real_tangent_terms(const model &md, size_type,

                                         const model::varnamelist &vl,

                                         const model::varnamelist &dl,

                                         const model::mimlist &mims,

                                         model::real_matlist &,

                                         model::real_veclist &vecl,

                                         model::real_veclist &,

                                         size_type region,

                                         build_version) const {

       GMM_ASSERT1(vecl.size() == 1,

                   "Kirchhoff Love source term brick has one and only "

                   "one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Kirchhoff Love source term brick need one and only "

                   "one mesh_im");

       GMM_ASSERT1(vl.size() == 1 && dl.size() == 2,

                   "Wrong number of variables for Kirchhoff Love "

                   "source term brick");


       const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

       const mesh_im &mim = *mims[0];

       const model_real_plain_vector &A = md.real_variable(dl[0]);

       const mesh_fem *mf_dataA = md.pmesh_fem_of_variable(dl[0]);

       const model_real_plain_vector &B = md.real_variable(dl[1]);

       const mesh_fem *mf_dataB = md.pmesh_fem_of_variable(dl[1]);

       size_type N = mf_u.linked_mesh().dim();

       mesh_region rg(region);

       mim.linked_mesh().intersect_with_mpi_region(rg);


       size_type s = gmm::vect_size(A);

       if (mf_dataA) s = s * mf_dataA->get_qdim() / mf_dataA->nb_dof();

       GMM_ASSERT1(mf_u.get_qdim() == 1 && s == N*N,

                   dl[0] << ": bad format of Kirchhoff Love Neumann term "

                   "data. Detected dimension is " << s << " should be "

                   << N*N);


       s = gmm::vect_size(B);

       if (mf_dataB) s = s * mf_dataB->get_qdim() / mf_dataB->nb_dof();

       GMM_ASSERT1(s == N,

                   dl[0] << ": bad format of Kirchhoff Love Neumann term "

                   "data. Detected dimension is " << s << " should be "

                   << N);


       GMM_TRACE2("Kirchhoff Love Neumann term assembly");

       if (mf_dataA)

         asm_neumann_KL_term(vecl[0], mim, mf_u, *mf_dataA, A, B, rg);

       else

         asm_neumann_KL_homogeneous_term(vecl[0], mim, mf_u, A, B, rg);


     }


     KL_source_term_brick(void) {

       set_flags("Kirchhoff Love Neumann term", true /* is linear*/,

                 true /* is symmetric */, true /* is coercive */,

                 true /* is real */, false /* is complex */,

                 false /* compute each time */);

     }


   };


   size_type add_Kirchhoff_Love_Neumann_term_brick

   (model &md, const mesh_im &mim, const std::string &varname,

    const std::string &dataname1, const std::string &dataname2,

    size_type region) {

     pbrick pbr = std::make_shared<KL_source_term_brick>();

     model::termlist tl;

     tl.push_back(model::term_description(varname));

     model::varnamelist vdata(1, dataname1);

     vdata.push_back(dataname2);

     return md.add_brick(pbr, model::varnamelist(1, varname),

                         vdata, tl, model::mimlist(1, &mim), region);

   }


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

   //

   // Normal derivative Dirichlet condition brick

   //

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

   // Two variables : with multipliers

   // One variable : penalization


   struct normal_derivative_Dirichlet_condition_brick : public virtual_brick {


     bool R_must_be_derivated;

     mutable getfem::omp_distribute<model_real_sparse_matrix> rB_th;

     mutable getfem::omp_distribute<model_real_plain_vector> rV_th;

     mutable getfem::omp_distribute<model_complex_sparse_matrix> cB_th;

     mutable getfem::omp_distribute<model_complex_plain_vector> cV_th;


     virtual void asm_real_tangent_terms(const model &md, size_type ib,

                                         const model::varnamelist &vl,

                                         const model::varnamelist &dl,

                                         const model::mimlist &mims,

                                         model::real_matlist &matl,

                                         model::real_veclist &vecl,

                                         model::real_veclist &,

                                         size_type region,

                                         build_version version) const {

       GMM_ASSERT1(vecl.size() == 1 && matl.size() == 1,

                   "Normal derivative Dirichlet condition brick has one and "

                   "only one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Normal derivative Dirichlet condition brick need one and "

                   "only one mesh_im");

       GMM_ASSERT1(vl.size() >= 1 && vl.size() <= 2 && dl.size() <= 2,

                   "Wrong number of variables for normal derivative Dirichlet "

                   "condition brick");


       model_real_sparse_matrix& rB = rB_th;

       model_real_plain_vector&  rV = rV_th;


       bool penalized = (vl.size() == 1);

       const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

       const mesh_fem &mf_mult = md.mesh_fem_of_variable(vl[vl.size()-1]);

       const mesh_im &mim = *mims[0];

       const model_real_plain_vector *A = 0, *COEFF = 0;

       const mesh_fem *mf_data = 0;

       bool recompute_matrix = !((version & model::BUILD_ON_DATA_CHANGE) != 0)

         || (penalized && md.is_var_newer_than_brick(dl[0], ib));


       if (penalized) {

         COEFF = &(md.real_variable(dl[0]));

         GMM_ASSERT1(gmm::vect_size(*COEFF) == 1,

                     "Data for coefficient should be a scalar");

       }


       size_type s = 0, ind = (penalized ? 1 : 0);

       if (dl.size() > ind) {

         A = &(md.real_variable(dl[ind]));

         mf_data = md.pmesh_fem_of_variable(dl[ind]);

         s = gmm::vect_size(*A);

         if (mf_data) s = s * mf_data->get_qdim() / mf_data->nb_dof();

         GMM_ASSERT1(s == mf_u.get_qdim() || s == mf_u.linked_mesh().dim(),

                     dl[ind] << ": bad format of normal derivative Dirichlet "

                     "data. Detected dimension is " << s << " should be "

                     << size_type(mf_u.get_qdim()) << " or "

                     << mf_u.linked_mesh().dim());

       }


       mesh_region rg(region);

       mim.linked_mesh().intersect_with_mpi_region(rg);


       if (recompute_matrix) {

         GMM_TRACE2("Mass term assembly for normal derivative Dirichlet "

                    "condition");

         if (penalized) {

           gmm::resize(rB, mf_mult.nb_dof(), mf_u.nb_dof());

           gmm::clear(rB);

           asm_normal_derivative_dirichlet_constraints

           (rB, vecl[0], mim, mf_u, mf_mult,

            *mf_data, *A, rg, R_must_be_derivated, ASMDIR_BUILDH);

         } else {

           gmm::clear(matl[0]);

           asm_normal_derivative_dirichlet_constraints

             (matl[0], vecl[0], mim, mf_u, mf_mult,

              *mf_data, *A, rg, R_must_be_derivated, ASMDIR_BUILDH);

         }


         if (penalized) {

           gmm::mult(gmm::transposed(rB), rB, matl[0]);

           gmm::scale(matl[0], gmm::abs((*COEFF)[0]));

         }

       }


       if (dl.size() > ind) {

         GMM_TRACE2("Source term assembly for normal derivative Dirichlet "

                    "condition");

         model_real_plain_vector *R = penalized ? &rV : &(vecl[0]);

         if (penalized) { gmm::resize(rV, mf_mult.nb_dof()); gmm::clear(rV); }


         if (mf_data) {

           if (!R_must_be_derivated) {

             if (s == mf_u.linked_mesh().dim())

               asm_normal_source_term(*R, mim, mf_mult, *mf_data, *A, rg);

             else

               asm_source_term(*R, mim, mf_mult, *mf_data, *A, rg);

           }

           else {

             asm_real_or_complex_1_param_vec

               (*R, mim, mf_mult, mf_data, *A, rg, "(Grad_A.Normal)*Test_u");

             // asm_real_or_complex_1_param

             //   (*R, mim, mf_mult, *mf_data, *A, rg,

             //    "R=data(#2); V(#1)+=comp(Base(#1).Grad(#2).Normal())(:,i,j,j).R(i)");

           }

         } else {

           GMM_ASSERT1(!R_must_be_derivated, "Incoherent situation");

           if (s == mf_u.linked_mesh().dim())

             asm_homogeneous_normal_source_term(*R, mim, mf_mult, *A, rg);

           else

             asm_homogeneous_source_term(*R, mim, mf_mult, *A, rg);

         }

         if (penalized) {

           gmm::mult(gmm::transposed(rB), rV, vecl[0]);

           gmm::scale(vecl[0], gmm::abs((*COEFF)[0]));

           rV = model_real_plain_vector();

         }

       }


     }


     virtual void asm_complex_tangent_terms(const model &md, size_type ib,

                                            const model::varnamelist &vl,

                                            const model::varnamelist &dl,

                                            const model::mimlist &mims,

                                            model::complex_matlist &matl,

                                            model::complex_veclist &vecl,

                                            model::complex_veclist &,

                                            size_type region,

                                            build_version version) const {

       GMM_ASSERT1(vecl.size() == 1 && matl.size() == 1,

                   "Normal derivative Dirichlet condition brick has one and "

                   "only one term");

       GMM_ASSERT1(mims.size() == 1,

                   "Normal derivative Dirichlet condition brick need one and "

                   "only one mesh_im");

       GMM_ASSERT1(vl.size() >= 1 && vl.size() <= 2 && dl.size() <= 2,

                   "Wrong number of variables for normal derivative Dirichlet "

                   "condition brick");


       model_complex_sparse_matrix& cB = cB_th;

       model_complex_plain_vector&  cV = cV_th;


       bool penalized = (vl.size() == 1);

       const mesh_fem &mf_u = md.mesh_fem_of_variable(vl[0]);

       const mesh_fem &mf_mult = md.mesh_fem_of_variable(vl[vl.size()-1]);

       const mesh_im &mim = *mims[0];

       const model_complex_plain_vector *A = 0, *COEFF = 0;

       const mesh_fem *mf_data = 0;

       bool recompute_matrix = !((version & model::BUILD_ON_DATA_CHANGE) != 0)

         || (penalized && md.is_var_newer_than_brick(dl[0], ib));


       if (penalized) {

         COEFF = &(md.complex_variable(dl[0]));

         GMM_ASSERT1(gmm::vect_size(*COEFF) == 1,

                     "Data for coefficient should be a scalar");

       }


       size_type s = 0, ind = (penalized ? 1 : 0);

       if (dl.size() > ind) {

         A = &(md.complex_variable(dl[ind]));

         mf_data = md.pmesh_fem_of_variable(dl[ind]);

         s = gmm::vect_size(*A);

         if (mf_data) s = s * mf_data->get_qdim() / mf_data->nb_dof();

         GMM_ASSERT1(s == mf_u.get_qdim() || s == mf_u.linked_mesh().dim(),

                     dl[ind] << ": bad format of normal derivative Dirichlet "

                     "data. Detected dimension is " << s << " should be "

                     << size_type(mf_u.get_qdim()) << " or "

                     << mf_u.linked_mesh().dim());

       }


       mesh_region rg(region);

       mim.linked_mesh().intersect_with_mpi_region(rg);


       if (recompute_matrix) {

         GMM_TRACE2("Mass term assembly for normal derivative Dirichlet "

                    "condition");

         if (penalized) {

           gmm::resize(cB, mf_mult.nb_dof(), mf_u.nb_dof());

           gmm::clear(cB);

           asm_normal_derivative_dirichlet_constraints

           (cB, vecl[0], mim, mf_u, mf_mult,

            *mf_data, *A, rg, R_must_be_derivated, ASMDIR_BUILDH);

         } else {

           gmm::clear(matl[0]);

           asm_normal_derivative_dirichlet_constraints

             (matl[0], vecl[0], mim, mf_u, mf_mult,

              *mf_data, *A, rg, R_must_be_derivated, ASMDIR_BUILDH);

         }


         if (penalized) {

           gmm::mult(gmm::transposed(cB), cB, matl[0]);

           gmm::scale(matl[0], gmm::abs((*COEFF)[0]));

         }

       }


       if (dl.size() > ind) {

         GMM_TRACE2("Source term assembly for normal derivative Dirichlet "

                    "condition");

         model_complex_plain_vector *R = penalized ? &cV : &(vecl[0]);

         if (penalized) { gmm::resize(cV, mf_mult.nb_dof()); gmm::clear(cV); }


         if (mf_data) {

           if (!R_must_be_derivated) {

             if (s == mf_u.linked_mesh().dim())

               asm_normal_source_term(*R, mim, mf_mult, *mf_data, *A, rg);

             else

               asm_source_term(*R, mim, mf_mult, *mf_data, *A, rg);

           }

           else {

             asm_real_or_complex_1_param_vec

               (*R, mim, mf_mult, mf_data, *A, rg, "(Grad_A.Normal)*Test_u");

             // asm_real_or_complex_1_param

             //   (*R, mim, mf_mult, *mf_data, *A, rg,

             //    "R=data(#2); V(#1)+=comp(Base(#1).Grad(#2).Normal())(:,i,j,j).R(i)");

           }

         } else {

           GMM_ASSERT1(!R_must_be_derivated, "Incoherent situation");

           if (s == mf_u.linked_mesh().dim())

             asm_homogeneous_normal_source_term(*R, mim, mf_mult, *A, rg);

           else

             asm_homogeneous_source_term(*R, mim, mf_mult, *A, rg);

         }

         if (penalized) {

           gmm::mult(gmm::transposed(cB), cV, vecl[0]);

           gmm::scale(vecl[0], gmm::abs((*COEFF)[0]));

           cV = model_complex_plain_vector();

         }

       }

     }


     normal_derivative_Dirichlet_condition_brick

     (bool penalized, bool R_must_be_derivated_) {

       R_must_be_derivated = R_must_be_derivated_;

       set_flags(penalized ?

                 "Normal derivative Dirichlet with penalization brick"

                 : "Normal derivative Dirichlet with multipliers brick",

                 true /* is linear*/,

                 true /* is symmetric */, penalized /* is coercive */,

                 true /* is real */, true /* is complex */,

                 false /* compute each time */);

     }

   };


   size_type add_normal_derivative_Dirichlet_condition_with_multipliers

   (model &md, const mesh_im &mim, const std::string &varname,

    const std::string &multname, size_type region,

    const std::string &dataname, bool R_must_be_derivated) {

     pbrick pbr = std::make_shared<normal_derivative_Dirichlet_condition_brick>(false, R_must_be_derivated);

     model::termlist tl;

     tl.push_back(model::term_description(multname, varname, true));

     model::varnamelist vl(1, varname);

     vl.push_back(multname);

     model::varnamelist dl;

     if (dataname.size()) dl.push_back(dataname);

     return md.add_brick(pbr, vl, dl, tl, model::mimlist(1, &mim), region);

   }


   size_type add_normal_derivative_Dirichlet_condition_with_multipliers

   (model &md, const mesh_im &mim, const std::string &varname,

    const mesh_fem &mf_mult, size_type region,

    const std::string &dataname, bool R_must_be_derivated) {

     std::string multname = md.new_name("mult_on_" + varname);

     md.add_multiplier(multname, mf_mult, varname);

     return add_normal_derivative_Dirichlet_condition_with_multipliers

       (md, mim, varname, multname, region, dataname, R_must_be_derivated);

   }


   size_type add_normal_derivative_Dirichlet_condition_with_multipliers

   (model &md, const mesh_im &mim, const std::string &varname,

    dim_type degree, size_type region,

    const std::string &dataname, bool R_must_be_derivated) {

     const mesh_fem &mf_u = md.mesh_fem_of_variable(varname);

     const mesh_fem &mf_mult = classical_mesh_fem(mf_u.linked_mesh(),

                                                  degree, mf_u.get_qdim());

     return add_normal_derivative_Dirichlet_condition_with_multipliers

       (md, mim, varname, mf_mult, region, dataname, R_must_be_derivated);

   }


   size_type add_normal_derivative_Dirichlet_condition_with_penalization

   (model &md, const mesh_im &mim, const std::string &varname,

    scalar_type penalisation_coeff, size_type region,

    const std::string &dataname, bool R_must_be_derivated) {

     std::string coeffname = md.new_name("penalization_on_" + varname);

     md.add_fixed_size_data(coeffname, 1);

     if (md.is_complex())

       md.set_complex_variable(coeffname)[0] = penalisation_coeff;

     else

       md.set_real_variable(coeffname)[0] = penalisation_coeff;

     pbrick pbr = std::make_shared<normal_derivative_Dirichlet_condition_brick>(true, R_must_be_derivated);

     model::termlist tl;

     tl.push_back(model::term_description(varname, varname, true));

     model::varnamelist vl(1, varname);

     model::varnamelist dl(1, coeffname);

     if (dataname.size()) dl.push_back(dataname);

     return md.add_brick(pbr, vl, dl, tl, model::mimlist(1, &mim), region);

   }


   // + changement du coeff de penalisation avec la fonction de Dirichelt standard.


 }  /* end of namespace getfem.                                             */


getfem::mesh_fem
Describe a finite element method linked to a mesh.
Definition: getfem_mesh_fem.h:151

getfem::mesh_fem::get_qdim
virtual dim_type get_qdim() const
Return the Q dimension.
Definition: getfem_mesh_fem.h:315

getfem::mesh_fem::linked_mesh
const mesh & linked_mesh() const
Return a reference to the underlying mesh.
Definition: getfem_mesh_fem.h:282

getfem::mesh_im
Describe an integration method linked to a mesh.
Definition: getfem_mesh_im.h:46

getfem::model
`‘Model’' variables store the variables, the data and the description of a model.
Definition: getfem_models.h:114

getfem::model::add_fixed_size_data
void add_fixed_size_data(const std::string &name, size_type size, size_type niter=1)
Add a fixed size data to the model.
Definition: getfem_models.cc:761

getfem::model::add_brick
size_type add_brick(pbrick pbr, const varnamelist &varnames, const varnamelist &datanames, const termlist &terms, const mimlist &mims, size_type region)
Add a brick to the model.
Definition: getfem_models.cc:1031

getfem::model::mesh_fem_of_variable
const mesh_fem & mesh_fem_of_variable(const std::string &name) const
Gives the access to the mesh_fem of a variable if any.
Definition: getfem_models.cc:2888

getfem::model::add_multiplier
void add_multiplier(const std::string &name, const mesh_fem &mf, const std::string &primal_name, size_type niter=1)
Add a particular variable linked to a fem being a multiplier with respect to a primal variable.
Definition: getfem_models.cc:887

getfem::model::set_real_variable
model_real_plain_vector & set_real_variable(const std::string &name, size_type niter) const
Gives the write access to the vector value of a variable.
Definition: getfem_models.cc:3010

getfem::model::is_complex
bool is_complex() const
Boolean which says if the model deals with real or complex unknowns and data.
Definition: getfem_models.h:562

getfem::model::set_complex_variable
model_complex_plain_vector & set_complex_variable(const std::string &name, size_type niter) const
Gives the write access to the vector value of a variable.
Definition: getfem_models.cc:3038

getfem::model::new_name
std::string new_name(const std::string &name)
Gives a non already existing variable name begining by name.
Definition: getfem_models.cc:174

getfem::omp_distribute< model_real_sparse_matrix >

getfem_fourth_order.h
assembly procedures and bricks for fourth order pdes.

getfem_omp.h
Tools for multithreaded, OpenMP and Boost based parallelization.

gmm::clear
void clear(L &l)
clear (fill with zeros) a vector or matrix.
Definition: gmm_blas.h:58

gmm::resize
void resize(V &v, size_type n)
*‍/
Definition: gmm_blas.h:209

gmm::mult
void mult(const L1 &l1, const L2 &l2, L3 &l3)
*‍/
Definition: gmm_blas.h:1663

getfem::asm_stiffness_matrix_for_bilaplacian
void asm_stiffness_matrix_for_bilaplacian(const MAT &M, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT &A, const mesh_region &rg=mesh_region::all_convexes())
assembly of .
Definition: getfem_fourth_order.h:55

getfem::asm_source_term
void asm_source_term(const VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT2 &F, const mesh_region &rg=mesh_region::all_convexes())
source term (for both volumic sources and boundary (Neumann) sources).
Definition: getfem_assembling.h:876

getfem::asm_homogeneous_normal_source_term
void asm_homogeneous_normal_source_term(VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const VECT2 &F, const mesh_region &rg)
Homogeneous normal source term (for boundary (Neumann) condition).
Definition: getfem_assembling.h:918

getfem::asm_normal_derivative_dirichlet_constraints
void asm_normal_derivative_dirichlet_constraints(MAT &H, VECT1 &R, const mesh_im &mim, const mesh_fem &mf_u, const mesh_fem &mf_mult, const mesh_fem &mf_r, const VECT2 &r_data, const mesh_region &rg, bool R_must_be_derivated, int version)
Assembly of normal derivative Dirichlet constraints  in a weak form.
Definition: getfem_fourth_order.h:351

getfem::asm_normal_derivative_source_term
void asm_normal_derivative_source_term(VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT2 &F, const mesh_region &rg)
assembly of .
Definition: getfem_fourth_order.h:160

getfem::asm_normal_source_term
void asm_normal_source_term(VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const mesh_fem &mf_data, const VECT2 &F, const mesh_region &rg)
Normal source term (for boundary (Neumann) condition).
Definition: getfem_assembling.h:904

getfem::asm_homogeneous_source_term
void asm_homogeneous_source_term(const VECT1 &B, const mesh_im &mim, const mesh_fem &mf, const VECT2 &F, const mesh_region &rg=mesh_region::all_convexes())
source term (for both volumic sources and boundary (Neumann) sources).
Definition: getfem_assembling.h:892

bgeot::size_type
size_t size_type
used as the common size type in the library
Definition: bgeot_poly.h:48

getfem
GEneric Tool for Finite Element Methods.
Definition: getfem_accumulated_distro.h:46

getfem::add_bilaplacian_brick
size_type add_bilaplacian_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname, size_type region=size_type(-1))
Adds a bilaplacian brick on the variable varname and on the mesh region region.
Definition: getfem_fourth_order.cc:119

getfem::add_bilaplacian_brick_KL
size_type add_bilaplacian_brick_KL(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname1, const std::string &dataname2, size_type region=size_type(-1))
Adds a bilaplacian brick on the variable varname and on the mesh region region.
Definition: getfem_fourth_order.cc:131

getfem::add_normal_derivative_Dirichlet_condition_with_multipliers
size_type add_normal_derivative_Dirichlet_condition_with_multipliers(model &md, const mesh_im &mim, const std::string &varname, const std::string &multname, size_type region, const std::string &dataname=std::string(), bool R_must_be_derivated=false)
Adds a Dirichlet condition on the normal derivative of the variable varname and on the mesh region re...
Definition: getfem_fourth_order.cc:619

getfem::pbrick
std::shared_ptr< const virtual_brick > pbrick
type of pointer on a brick
Definition: getfem_models.h:48

getfem::classical_mesh_fem
const mesh_fem & classical_mesh_fem(const mesh &mesh, dim_type degree, dim_type qdim=1, bool complete=false)
Gives the descriptor of a classical finite element method of degree K on mesh.
Definition: getfem_mesh_fem.cc:860

getfem::add_normal_derivative_source_term_brick
size_type add_normal_derivative_source_term_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname, size_type region)
Adds a normal derivative source term brick :math:F = \int b.
Definition: getfem_fourth_order.cc:249

getfem::add_Kirchhoff_Love_Neumann_term_brick
size_type add_Kirchhoff_Love_Neumann_term_brick(model &md, const mesh_im &mim, const std::string &varname, const std::string &dataname1, const std::string &dataname2, size_type region)
Adds a Neumann term brick for Kirchhoff-Love model on the variable varname and the mesh region region...
Definition: getfem_fourth_order.cc:332

getfem::add_normal_derivative_Dirichlet_condition_with_penalization
size_type add_normal_derivative_Dirichlet_condition_with_penalization(model &md, const mesh_im &mim, const std::string &varname, scalar_type penalisation_coeff, size_type region, const std::string &dataname=std::string(), bool R_must_be_derivated=false)
Adds a Dirichlet condition on the normal derivative of the variable varname and on the mesh region re...
Definition: getfem_fourth_order.cc:655