Simpler.cpp

/****************************************************************************
* Copyright (c) 2026, CEA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
 
#include <Simpler.h>
#include <Navier_Stokes_std.h>
#include <EChaine.h>
#include <Debog.h>
#include <Matrice_Bloc.h>
#include <Assembleur_base.h>
#include <Schema_Temps_base.h>
#include <TRUSTTrav.h>
 
#include <Probleme_base.h>
 
Implemente_instanciable(Simpler,"Simpler",Simple);
// XD simpler solveur_implicite_base simpler BRACE Simpler method for incompressible systems.
// XD attr seuil_convergence_implicite floattant seuil_convergence_implicite REQ Keyword to set the value of the
// XD_CONT convergence criteria for the resolution of the implicit system build to solve either the Navier_Stokes
// XD_CONT equation (only for Simple and Simpler algorithms) or a scalar equation. It is adviced to use the default
// XD_CONT value (1e6) to solve the implicit system only once by time step. This value must be decreased when a coupling
// XD_CONT between problems is considered.
// XD attr seuil_convergence_solveur floattant seuil_convergence_solveur OPT value of the convergence criteria for the
// XD_CONT resolution of the implicit system build by solving several times per time step the Navier_Stokes equation and
// XD_CONT the scalar equations if any. This value MUST be used when a coupling between problems is considered (should
// XD_CONT be set to a value typically of 0.1 or 0.01).
// XD attr seuil_generation_solveur floattant seuil_generation_solveur OPT Option to create a GMRES solver and use vrel
// XD_CONT as the convergence threshold (implicit linear system Ax=B will be solved if residual error ||Ax-B|| is lesser
// XD_CONT than vrel).
// XD attr seuil_verification_solveur floattant seuil_verification_solveur OPT Option to check if residual error
// XD_CONT ||Ax-B|| is lesser than vrel after the implicit linear system Ax=B has been solved.
// XD attr seuil_test_preliminaire_solveur floattant seuil_test_preliminaire_solveur OPT Option to decide if the
// XD_CONT implicit linear system Ax=B should be solved by checking if the residual error ||Ax-B|| is bigger than vrel.
// XD attr solveur solveur_sys_base solveur OPT Method (different from the default one, Gmres with diagonal
// XD_CONT preconditioning) to solve the linear system.
// XD attr no_qdm rien no_qdm OPT Keyword to not solve qdm equation (and turbulence models of these equation).
// XD attr nb_it_max entier nb_it_max OPT Keyword to set the maximum iterations number for the Gmres.
// XD attr controle_residu rien controle_residu OPT Keyword of Boolean type (by default 0). If set to 1, the convergence
// XD_CONT occurs if the residu suddenly increases.
 
 
Sortie& Simpler::printOn(Sortie& os ) const
{
  return Simple::printOn(os);
}
 
Entree& Simpler::readOn(Entree& is )
{
  return Simple::readOn(is);
}
 
// calcul D correction_en_vitesse= E current + resu )
// avec D diagonale de la matrice et E = D-matrice =-(matrice-D)
int inverser_par_diagonale(const Matrice_Morse& matrice,const DoubleTrav& resu,const DoubleTab& current,DoubleTrav& correction_en_vitesse)
{
  const auto& tab1 = matrice.get_tab1();
  const auto& tab2 = matrice.get_tab2();
  const auto& coeff = matrice.get_coeff();
 
  int deux_entrees=0;
  int nb_comp=1;
  if (resu.nb_dim()==2)
    {
      deux_entrees=1;
      nb_comp=resu.dimension(1);
    }
  ConstDoubleTab_parts part(correction_en_vitesse);
  int nb_ligne_reel=part[0].dimension(0);
  // Determine U^
  if (deux_entrees==0)
    {
      for(int i=0; i<nb_ligne_reel; i++)
        {
          for(int j=0; j<nb_comp; j++)
            {
              double t=resu(i);
              for (auto k=tab1(i*nb_comp+j); k<tab1(i*nb_comp+j+1)-1; k++)
                t -= coeff(k)*current(tab2(k)-1);
 
              correction_en_vitesse(i) = t/matrice(i*nb_comp+j,i*nb_comp+j);
            }
        }
      // verif
      // test
      if (0)
        for(int i=0; i<nb_ligne_reel; i++)
          {
            for (int j=0; j<nb_comp; j++)
              {
                int ii=i*nb_comp+j;
                double tmp=resu(i);
                for (int k = 0; k<matrice.nb_colonnes(); k++)
                  if ((k/nb_comp)!=i)
                    {
                      if (matrice(ii,k))
                        tmp -= matrice(ii,k)*current((k/nb_comp));
                    }
 
                double test=tmp/matrice(ii,ii);
                if (!est_egal(test,correction_en_vitesse(i),1e-5))
                  {
                    Cerr<<i<<" "<<j<<" "<<resu(i)<<finl;
                    Cerr<<test<<" ici "<<correction_en_vitesse(i)-test<<finl;
                    return -1;
                  }
              }
          }
    }
 
  else
    {
      for(int i=0; i<nb_ligne_reel; i++)
        {
          for(int j=0; j<nb_comp; j++)
            {
              double t=resu(i,j);
              for (auto k=tab1(i*nb_comp+j); k<tab1(i*nb_comp+j+1)-1; k++)
                {
                  int i1 = (tab2(k)-1)/nb_comp;
                  int j1 = (tab2(k)-1)-i1*nb_comp;
                  t -= coeff(k)*current(i1,j1);
                }
              const double diagonal_coefficient = matrice(i*nb_comp+j,i*nb_comp+j);
              assert(diagonal_coefficient!=0);
              correction_en_vitesse(i,j) = t/diagonal_coefficient;
            }
        }
      // test
      if (0)
        {
          Cerr<<"milieu"<<finl;
          DoubleTrav corr2(correction_en_vitesse);
          matrice.multvect(current,corr2);
          for(int i=0; i<nb_ligne_reel; i++)
            {
              for (int j=0; j<nb_comp; j++)
                {
                  int ii = i*nb_comp+j;
                  corr2(i,j) = (resu(i,j)-corr2(i,j)+matrice(ii,ii)*current(i,j))/matrice(ii,ii);
                  double test = corr2(i,j);
                  if (!est_egal(test,correction_en_vitesse(i,j)))
                    {
                      Cerr<<i<<" "<<j<<" "<<resu(i,j)<<finl;
                      Cerr<<test<<" ici "<<correction_en_vitesse(i,j)<<" "<<current(i,j)<<" "<<matrice(ii,ii) <<finl;
                      return -1;
                    }
                }
            }
          Cerr<<"fin"<<finl;
        }
    }
  correction_en_vitesse.echange_espace_virtuel();
  return 0;
}
 
 
//Entree : Uk-1 ; Pk-1
//Sortie Uk ; Pk
//k designe une iteration
 
void Simpler::iterer_NS(Equation_base& eqn,DoubleTab& current,DoubleTab& pression,double dt,Matrice_Morse& matrice,double seuil_resol,DoubleTrav& secmem,int nb_ite,int& converge, int& ok)
{
  if (eqn.probleme().is_dilatable())
    {
      Cerr<<" Simpler cannot be used with a quasi-compressible fluid."<<finl;
      Cerr<<__FILE__<<(int)__LINE__<<" non code" <<finl;
      exit();
    }
 
  Parametre_implicite& param = get_and_set_parametre_implicite(eqn);
  SolveurSys& le_solveur_ = param.solveur();
 
  Navier_Stokes_std& eqnNS = ref_cast(Navier_Stokes_std,eqn);
  eqnNS.reassembler_pression_si_necessaire();
  DoubleTrav gradP(current);
  DoubleTrav correction_en_pression(pression);
  DoubleTrav correction_en_vitesse(current);
  DoubleTrav resu(current);
 
  //int deux_entrees = 0;
  //if (current.nb_dim()==2) deux_entrees = 1;
  Operateur_Grad& gradient = eqnNS.operateur_gradient();
  Operateur_Div& divergence = eqnNS.operateur_divergence();
 
  //  int nb_comp = 1;
  //int nb_dim = current.nb_dim();
 
  //if (nb_dim==2)
  //  nb_comp = current.dimension(1);
 
  //Construction de matrice et resu
  //matrice = A[Uk-1] = M/dt + CONV +DIFF
  //resu =  A[Uk-1]Uk-1 -(A[Uk-1]Uk-1-Ss) + Sv -BtPk-1
  gradient.calculer(pression,gradP);
  if (eqnNS.has_interface_blocs()) /* si assembler_blocs est disponible */
    eqnNS.assembler_blocs_avec_inertie({{ "vitesse", &matrice }}, resu);
  else
    {
      resu -= gradP;
      eqnNS.assembler_avec_inertie(matrice,current,resu);
    }
 
  le_solveur_->reinit();
 
  //Resolution du systeme : D[Uk-1]UPk = E[Uk-1]Uk-1 + Sv + Ss -BtPk-1 + (M/dt)Uk-1
  //matrice = A[Uk-1] = D - E avec D partie diagonale de A
  //correction_en_vitesse = UPk ; current = Uk-1 ; resu = Sv + Ss -BtPk-1
  int status = inverser_par_diagonale(matrice,resu,current,correction_en_vitesse);
  if (status!=0) exit();
  Debog::verifier("Simpler::iterer_NS correction_en_vitesse",correction_en_vitesse);
 
  //Construction de matrice_en_pression_2 = BD-1Bt[Uk-1]
  Matrice& matrice_en_pression_2 = eqnNS.matrice_pression();
  assembler_matrice_pression_implicite(eqnNS,matrice,matrice_en_pression_2);
  SolveurSys& solveur_pression_ = eqnNS.solveur_pression();
  solveur_pression_->reinit();
 
  //Calcul de BUPk
  divergence.calculer(correction_en_vitesse,secmem);
  secmem *= -1;
  secmem.echange_espace_virtuel();
  if (nb_ite==1)
    eqnNS.assembleur_pression()->modifier_secmem(secmem);
 
  //Resolution du systeme (BD-1Bt)P*_k = BUPk
  //correction_en_pression = P*_k ; secmem = BUPk
  solveur_pression_.resoudre_systeme(matrice_en_pression_2.valeur(),
                                     secmem,correction_en_pression);
 
  //Calcul de Pk = Pk-1 + P*_k
  operator_add(pression, correction_en_pression, VECT_ALL_ITEMS);
 
  eqnNS.assembleur_pression()->modifier_solution(pression);
 
  //Calcul de Bt P*_k et ajustement de resu a -Bt Pk
  gradient->multvect(correction_en_pression,gradP);
  resu -= gradP;
  resu.echange_espace_virtuel();
  Debog::verifier("Simpler::iterer_NS resu",resu);
 
  //Resolution du systeme : A[Uk-1]U*_k = -BtPk + Sv + Ss + (M/dt)Uk-1
  //current = U*_k ; resu = A[Uk-1]Uk-1 - (A[Uk-1]Uk-1-Ss) + Sv -BtPk + (M/dt)Uk-1
  le_solveur_.resoudre_systeme(matrice,resu,current);
 
  //Calcul de BU*_k
  divergence.calculer(current,secmem);
  secmem *= -1;
  secmem.echange_espace_virtuel();
  Debog::verifier("Simpler::iterer_NS secmem",secmem);
 
  //Resolution du systeme (BD-1Bt)P'k = BU*_k
  //correction_en_pression = P'k ; secmem = BU*_k
  correction_en_pression = 0;
  solveur_pression_.resoudre_systeme(matrice_en_pression_2.valeur(),
                                     secmem,correction_en_pression);
 
  //Resolution du systeme D[Uk-1](Uk-U*_k) = -BtP'k
  //correction_en_vitesse = U'k = Uk-U*_k ; correction_en_pression = P'k
  calculer_correction_en_vitesse(correction_en_pression,gradP,correction_en_vitesse,matrice,gradient);
 
  if (0)
    {
      Cerr<<" rr "<<mp_max_abs_vect(secmem)<<finl;
      //Cerr<<secmem<<finl;
      secmem*=-1;
      divergence.ajouter(correction_en_vitesse, secmem);
      Cerr<<" rr2 "<<mp_max_abs_vect(secmem)<<finl;
 
    }
 
  //Calcul de Uk = U*_k + U'k
  current += correction_en_vitesse;
  current.echange_espace_virtuel();
  Debog::verifier("Simpler::iterer_NS current",current);
 
  if (0)
    {
      divergence.calculer(current, secmem);
      Cerr<<" apresdiv "<<mp_max_abs_vect(secmem)<<finl;;
    }
 
}