Domaine_ALE.h

/****************************************************************************
* 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.
*
*****************************************************************************/
 
#ifndef Domaine_ALE_included
#define Domaine_ALE_included
 
#include <ALE_MetricsUpdater.h>
#include <ALE_BeamCoupling.h>
#include <ALE_ProjectionManager.h>
#include <ALE_CheckpointManager.h>
 
#include <Champ_front_base.h>
#include <TRUSTLists.h>
#include <Champ_P1NC.h>
#include <Structural_dynamic_mesh_model.h>
#include <TRUST_Ref.h>
#include <Domaine.h>
 
class Equation_base;
 
/////////////////////////////////////////////////////////////////////////////
//    Classe Domaine_ALE
//
//    Central coordinator for the Arbitrary Lagrangian-Eulerian (ALE) domain.
//    Manages a deforming mesh through a pluggable motion model and delegates
//    specialized responsibilities to dedicated sub-components.
 
//   Domaine_ALE  (derives from Domaine)
//   │
//   ├── ALE_MetricsUpdater       geometric metric updates (VEF/EF/PolyMAC)
//   ├── ALE_BeamCoupling         beam model + fluid/structure force exchange
//   ├── ALE_ProjectionManager    ALE boundary projection + modal forces + Neumann BCs
//   └── ALE_CheckpointManager    save/restore additional state (binary + PDI)
//
//   Mesh motion strategy is selected at runtime via meshMotionModel_:
//     0 = Laplacian  (private methods laplacien / fill_laplacian_matrix / ...)
//     1 = Structural dynamics  (str_mesh_model)
//    -1 = Boundary-only (no interior propagation)
 
/////////////////////////////////////////////////////////////////////////////
 
class Domaine_ALE : public Domaine
{
  Declare_instanciable_sans_constructeur(Domaine_ALE);
 
public:
 
  Domaine_ALE();
  void clear() override;
 
  inline const double& get_dt()  const;
  void set_dt(double& dt) override;
 
  inline const DoubleTab& vitesse()        const;  // vertex mesh velocity
  inline       DoubleTab& vitesse_faces();          // face mesh velocity (writable)
  inline const DoubleTab& vitesse_faces()  const;
 
  void initialiser     (double temps, Domaine_dis_base&, Probleme_base&) override;
  void mettre_a_jour   (double temps, Domaine_dis_base&, Probleme_base&) override;
  void update_after_post(double temps) override;
  void validateTimeStep() override;
 
 
  void updateMetrics(Domaine_dis_base&, Probleme_base&);
 
  //==========================================================================
  // Mesh motion model
  //   -1 = boundary-only (no interior propagation)
  //    0 = Laplacian (default)
  //    1 = Structural dynamics
  //==========================================================================
  inline int getMeshMotionModel() const { return meshMotionModel_; }
 
  //==========================================================================
  // ICoCo coupling
  //==========================================================================
  int  getCouplingMethod();
  bool getCouplingMethod() const override;
  bool getUpdateTheGrid()  override;
  void setUpdateTheGrid(bool) override;
 
  //==========================================================================
  // Post-processing / field registry
  //==========================================================================
  using Domaine_base::creer_champ;
  void creer_champ(const Motcle&, const Probleme_base&) override;
  void get_noms_champs_postraitables(Noms& nom, Option opt = NONE) const override;
  const Champ_base& get_champ(const Motcle&) const override;
  bool has_champ(const Motcle& nom, OBS_PTR(Champ_base)& ref_champ) const override;
  bool has_champ(const Motcle& nom) const override;
  void update_post_fields(double temps, double dt);
 
  //==========================================================================
  // Save / restore  (delegates to checkpoint_manager_)
  //==========================================================================
  std::vector<YAML_data> data_a_sauvegarder(const Probleme_base&) const override;
  int save_additional_state   (Sortie&,       const Probleme_base&) const override;
  int restore_additional_state(Entree&,             Probleme_base&) override;
 
  // Helpers forwarded from checkpoint_manager_ (kept on Domaine_ALE for API compatibility)
  Nom       generate_field_tag(const Champ_Inc_base&, const Probleme_base&) const;
  YAML_data make_yaml         (const std::string&, int, const Probleme_base&) const;
  void      create_field      (OWN_PTR(Champ_Inc_base)&, const std::string&,
                               int, const Motcle&, const Probleme_base&) const;
 
  //==========================================================================
  // Volume / surface correction  (called by NS solver)
  //==========================================================================
  void ajouter_correctif_volumique(const DoubleTab&, const DoubleTab&,
                                   double, DoubleTab&) const override;
  void apply_old_to_new_volume_scaling(DoubleTab&, const Domaine_dis_base&) const override;
  const DoubleVect& old_volumes_entrelaces() const override;
  const DoubleVect& old_volumes()            const override;
 
  //==========================================================================
  // Lagrangian external velocity coupling
  //==========================================================================
  void associer_vitesse_lagrangienne(const Nom& nom_pb, const Nom& nom_champ);
 
  //==========================================================================
  // Surface extraction on a deformable moving boundary
  //==========================================================================
  inline const IntTab& les_elems_extrait_surf_reference() const;
  inline void          set_les_elems_extrait_surf_reference(const IntTab&);
  inline bool          extrait_surf_dom_deformable() const;
  inline void          set_extrait_surf_dom_deformable(bool);
  void                 update_coord_dom_extrait_surface();
 
  //==========================================================================
  // Input reading helpers  (called during data-file parsing)
  //==========================================================================
  void reading_vit_bords_ALE                  (Entree& is);
  void reading_solver_moving_mesh_ALE         (Entree& is);
  void reading_beam_model                     (Entree& is);
  void reading_projection_ALE_boundary        (Entree& is);
  void reading_ALE_Neumann_BC_for_grid_problem(Entree& is);
  void reading_structural_dynamic_mesh_model  (Entree& is);
 
  //==========================================================================
  // Face velocity computation
  //==========================================================================
  DoubleTab& calculer_vitesse_faces(DoubleTab&, int, int, IntTab&);
 
  //==========================================================================
  // Beam accessors  (forwarded to beam_coupling_)
  //==========================================================================
  const DoubleTab& getBeamDisplacement(const int&, const int&) const;
  const DoubleTab& getBeamRotation    (const int&, const int&) const;
  DoubleTab&       getBeamVelocity    (const int&, const double& tps, const double& dt);
  const int&       getBeamNbModes     (const int&) const;
  const int&       getBeamNbPlanes    (const int&) const;
  const Nom&       getBeamName        (const int&) const;
  const int&       getBeamNbBeam      ()           const;
  const int&       getBeamLongitudinalAxis  (const int&)           const;
  const int&       getBeamBendingDirection  (const int&, const int&) const;
  void             computeFluidForceOnBeam  (const int&);
  double           computeDtBeam            (Domaine_dis_base&, const int&);
 
  DoubleTab interpolationOnThe3DSurface  (const int&, const double& x, const double& y,
                                          const double& z, const DoubleTab& u,
                                          const DoubleTab& R) const;
  double    interpolationPhiOnThe3DSurface(const int&, const double& x, const double& y,
                                           const double& z, const int& comp,
                                           const DoubleTab& u) const;
 
  //==========================================================================
  // Structural dynamics accessors  (forwarded to str_mesh_model)
  //==========================================================================
  const DoubleVect& getMeshPbPressure ()   const;
  const DoubleVect& getMeshPbVonMises ()   const;
  const DoubleTab&  getMeshPbForceFace()   const;
  const DoubleTab&  getMeshDisplacement()  const;
  const DoubleTab&  getMeshVelocity    ()  const;
  const DoubleTab&  getMeshAcceleration()  const;
  const DoubleTab&  getMeshPosition    ()  const;
  const DoubleTab&  getMeshReferenceConfiguration ()  const;
  const DoubleTab&  getMeshTransformationGradient ()  const;
  const DoubleTab&  getMeshStress      ()  const;
  const int&        getMeshReferenceConfigurationNbComp() const;
  const int&        getMeshTransformationGradientNbComp() const;
  const int&        getMeshStressNbComp()  const;
 
  void resumptionCoords(DoubleTab&);
  void resumptionStructuralDynamicsMesh(double, DoubleTab&, DoubleTab&, DoubleTab&,
                                        DoubleTab&, DoubleTab&, DoubleTab&, DoubleTab&);
 
  void update_ALE_projection(double, Nom&, Champ_front_ALE_projection&, int);
  void update_ALE_projection(const double);
 
 
  Equation_base&       getEquation();
  const Equation_base& getEquation() const;
 
 
  // Access to the champs_compris registry
  inline Champs_compris& get_champs_compris() { return champs_compris_; }
 
  // True when restarting from a checkpoint
  inline bool is_resumption() const { return resumption != 0; }
 
  // ALE moving boundary list .
  inline int          get_nb_bords_ALE()                const { return nb_bords_ALE; }
  inline const Bords& get_bords_ALE()                    const { return les_bords_ALE; }
 
protected:
 
  double     dt_ = 0.;
  DoubleTab  ALE_mesh_velocity;   // vertex mesh velocity (nb_som x dim)
  DoubleTab  vf;                  // face mesh velocity
  IntTab     som_faces_bords;
  SolveurSys solv;                // linear solver for Laplacian mesh motion
 
  int resumption = 0;             // 1 if restarting from checkpoint
 
  TRUST_Vector<OWN_PTR(Champ_front_base)> les_champs_front;
  int   nb_bords_ALE = 0;
  Bords les_bords_ALE;
 
  mutable OBS_PTR(Equation_base) eq; // lazy-initialized reference to first equation
 
  //==========================================================================
  // Structural dynamics mesh model  (active when meshMotionModel_ == 1)
  //==========================================================================
  Structural_dynamic_mesh_model str_mesh_model;
 
  //==========================================================================
  // Sub-components
  //==========================================================================
 
  // Geometric metric updates after mesh motion (VEF / EF / PolyMAC).
  ALE_MetricsUpdater metrics_updater_;
 
  // Beam mechanical model: fluid/structure force exchange and interpolation.
  ALE_BeamCoupling beam_coupling_;
 
  // ALE boundary projection: vibration modes, modal forces, Neumann BC list.
  ALE_ProjectionManager projection_manager_;
 
  // Checkpoint manager: save/restore ALE-specific state.
  ALE_CheckpointManager checkpoint_manager_;
 
  //==========================================================================
  // Mesh motion model selector
  //==========================================================================
  int meshMotionModel_ = 0;
 
  //==========================================================================
  // ICoCo coupling state
  //==========================================================================
  int  Coupling_ICoCo_method = -1;
  bool UpdateTheGrid = true;
 
  //==========================================================================
  // Surface extraction on a deformable moving boundary
  //==========================================================================
  IntTab les_elems_extrait_surf_reference_;
  bool   extrait_surf_dom_deformable_ = false;
 
  //==========================================================================
  // Post-processing fields
  //==========================================================================
  mutable Champs_compris  champs_compris_;
  OWN_PTR(Champ_Inc_base) ALEMeshVelocity_;
  OWN_PTR(Champ_Inc_base) ALEMeshTotalDisplacement_;
  OWN_PTR(Champ_Inc_base) ALEMeshStructuralPressure_;
  OWN_PTR(Champ_Inc_base) ALEMeshStructuralVonMises_;
  OWN_PTR(Champ_Inc_base) ALEMeshStructuralForces_;
 
private:
 
  //==========================================================================
  // Vertex velocity
  //==========================================================================
  void compute_vertex_velocities(double temps, const Probleme_base&);
  void remplir_vitesse_bord(const Probleme_base&, double temps, DoubleTab& vit_bords);
  void update_vertex_coordinates(double dt);
 
  //==========================================================================
  // Mesh motion models
  //==========================================================================
  void laplacien             (const Probleme_base&, const DoubleTab& vit_bords);
  void build_laplacian_matrix(const Domaine_VF&, const Domaine_Cl_dis_base&);
  void fill_laplacian_matrix (const Domaine_VF&, const Domaine_Cl_dis_base&);
  void laplacien_compute_vertex_velocity(const Domaine_VF&, const Domaine_Cl_dis_base&,
                                         const DoubleTab& vit_bords);
  void structural_dynamics   (const Probleme_base&, const DoubleTab& vit_bords, double temps);
 
  //==========================================================================
  // Setup / validation
  //==========================================================================
  void validate_ale_setup(const Probleme_base&) const;
  void build_lagrangian_vertex_mapping(const Probleme_base& pb_v, const Champ_base&);
  void check_external_vertex_velocity_compatibility(const DoubleTab&) const;
 
  //==========================================================================
  // Laplacian data
  //==========================================================================
  DoubleVect        laplacian_rhs_;
  Matrice_Morse_Sym laplacian_matrix_;
 
  //==========================================================================
  // Lagrangian external velocity coupling
  //==========================================================================
  IntVect external_vertex_id_for_ale_vertex_;
  bool    lagrangian_velocity_imposed_ = false;
  Nom     external_velocity_field_name_;
  Nom     external_pb_name_;
 
  //==========================================================================
  // Metric snapshots
  //==========================================================================
  DoubleVect volumes_old_;
  DoubleVect volumes_entrelaces_old_;
  DoubleTab  volumes_sommets_thilde_old_;
  DoubleTab  coord_old_;
};
 
 
inline const double& Domaine_ALE::get_dt() const { return dt_; }
 
inline const DoubleTab& Domaine_ALE::vitesse() const { return ALE_mesh_velocity; }
 
inline       DoubleTab& Domaine_ALE::vitesse_faces()       { return vf; }
inline const DoubleTab& Domaine_ALE::vitesse_faces() const { return vf; }
 
inline const IntTab& Domaine_ALE::les_elems_extrait_surf_reference() const
{ return les_elems_extrait_surf_reference_; }
 
inline void Domaine_ALE::set_les_elems_extrait_surf_reference(const IntTab& ref)
{ les_elems_extrait_surf_reference_ = ref; }
 
inline bool Domaine_ALE::extrait_surf_dom_deformable() const
{ return extrait_surf_dom_deformable_; }
 
inline void Domaine_ALE::set_extrait_surf_dom_deformable(bool def)
{ extrait_surf_dom_deformable_ = def; }
 
inline const DoubleVect& Domaine_ALE::old_volumes_entrelaces() const
{ return volumes_entrelaces_old_; }
 
inline const DoubleVect& Domaine_ALE::old_volumes() const
{ return volumes_old_; }
 
#endif /* Domaine_ALE_included */