Corrige_flux_FT_base.h

/****************************************************************************
* Copyright (c) 2024, 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 Corrige_flux_FT_base_included
#define Corrige_flux_FT_base_included
 
#include <MonofluidVar.h>
#include <IJK_Field_vector.h>
#include <Boundary_Conditions_Thermique.h>
#include <Domaine_IJK.h>
#include <Objet_U.h>
#include <Parser.h>
#include <IJK_Interfaces.h>
#include <IJK_Lata_writer.h>
#include <Intersection_Interface_ijk.h>
#include <Ouvrir_fichier.h>
#include <TRUST_Ref.h>
#include <ParcoursIJKDir.h>
#include <IJK_One_Dimensional_Subproblems.h>
 
class Probleme_FTD_IJK_base;
 
/*! @brief : class Corrige_flux_FT
 * API pour modifier un champ de flux à partir de donnees à l'interface. Cette
 * classe est abstraite, elle est vouée à être héritée pour être adaptée aux
 * différents cas / conditions aux limites. Par ex sur la température pour
 * imposer la continuité de lda grad T à l'interface. Mais ça pourrait être
 * pareil pour la vitesse pour imposer la continuité tangentielle et normale
 * dans le cas sans changement de phase, ou pour imposer la bonne différence de
 * vitesse normale dans le cas du changement de phase.
 */
 
class Corrige_flux_FT_base : public Objet_U
{
  Declare_base( Corrige_flux_FT_base ) ;
public:
  virtual void initialize(const Domaine_IJK& dom,
                          const IJK_Field_double& field,
                          const IJK_Interfaces& interfaces,
                          const Probleme_FTD_IJK_base& ijk_ft,
                          Intersection_Interface_ijk_face& intersection_ijk_face,
                          Intersection_Interface_ijk_cell& intersection_ijk_cell);
 
  virtual void initialize_with_subproblems(const Domaine_IJK& splitting,
                                           const IJK_Field_double& field,
                                           const IJK_Interfaces& interfaces,
                                           const Probleme_FTD_IJK_base& ijk_ft,
                                           Intersection_Interface_ijk_face& intersection_ijk_face,
                                           Intersection_Interface_ijk_cell& intersection_ijk_cell,
                                           IJK_One_Dimensional_Subproblems& thermal_local_subproblems);
 
  virtual void set_fluxes_feedback_params(const int discrete_integral, const int levels) { ; };
 
  void set_physical_parameters(const double rhocpl,
                               const double rhocpv,
                               const double ldal,
                               const double ldav);
 
  virtual void set_convection_diffusion_correction(const int& convective_flux_correction, const int& diffusive_flux_correction) { ; };
  /*
   * On va calculer sur la grille IJ du layer k_layer tous les flux a proximite de
   * l'interface. On remplace les flux donnes en entree par ces flux la.
   */
  virtual void corrige_flux_faceIJ(IJK_Field_local_double *const flux,
                                   const int k_layer, const int dir)=0;
 
  virtual void corrige_flux_diff_faceIJ(IJK_Field_local_double *const flux,
                                        const int k_layer, const int dir) { ; };
 
  virtual void correct_flux_spherical(Simd_double& a,
                                      Simd_double& b,
                                      const int& i,
                                      const int& j,
                                      const int& k_layer,
                                      const int dir) { ; };
 
  virtual void update_intersections() { ; };
  virtual void update()=0;
 
  virtual void calcul_temperature_flux_interface(const IJK_Field_double& temperature, const double ldal, const double ldav,
                                                 const double dist, const DoubleTab& positions, const DoubleTab& normale,
                                                 ArrOfDouble& temperature_interp, ArrOfDouble& flux_normal_interp,
                                                 ArrOfDouble& temp_liqu, ArrOfDouble& temp_vap, DoubleTab& coo_liqu,
                                                 DoubleTab& coo_vap) const = 0 ;
 
 
  virtual void compute_temperature_cell_centre(IJK_Field_double& temperature) const { ; };
  virtual void set_zero_temperature_increment(IJK_Field_double& d_temperature) const { ; };
 
  virtual void compute_thermal_convective_fluxes(const int& last_flux) { ; };
  virtual void compute_thermal_diffusive_fluxes(const int& last_flux) { ; };
  virtual void complete_thermal_fluxes_face_centre(const int& fluxes_correction_conservations) { ; };
 
  virtual void set_convection_negligible(const int& convection_negligible) { ; };
  virtual void set_diffusion_negligible(const int& diffusion_negligible) { ; };
  virtual void clean() { ; };
  virtual void compute_ijk_pure_faces_indices() { ; };
  virtual void sort_ijk_intersections_subproblems_indices_by_k_layers() { ; };
 
  virtual void set_debug(const int& debug) { ; };
  virtual void set_distance_cell_faces_from_lrs(const int& distance_cell_faces_from_lrs) { ; };
  virtual void set_correction_cell_neighbours(const int& correct_temperature_cell_neighbours,
                                              const int& neighbours_colinearity_weighting,
                                              const int& keep_max_flux_correction,
                                              const int& smooth_temperature_field) { ; };
  virtual void set_cell_faces_neighbours_corrected_bool(IJK_Field_vector3_int& cell_faces_neighbours_corrected_bool) { ; };
  virtual void set_eulerian_normal_vectors_ns_normed(const IJK_Field_vector3_double * eulerian_normal_vectors_ns_normed) { ; };
 
  virtual void set_correction_cell_faces_neighbours(const int& find_cell_neighbours_for_fluxes_spherical_correction,
                                                    const int& use_cell_neighbours_for_fluxes_spherical_correction,
                                                    const int& find_reachable_fluxes,
                                                    const int& use_reachable_fluxes,
                                                    const int& keep_first_reachable_fluxes,
                                                    const int& store_flux_operators_for_energy_balance) { ; };
  virtual void initialise_cell_neighbours_indices_to_correct() { ; };
  virtual void compute_cell_neighbours_faces_indices_for_spherical_correction(const int& n_iter_distance) { ; };
  virtual void compute_cell_neighbours_faces_indices_to_correct(IJK_Field_vector3_int& cell_faces_neighbours_corrected_bool,
                                                                IJK_Field_vector3_double& cell_faces_neighbours_corrected_velocity_temperature,
                                                                IJK_Field_vector3_double& cell_faces_neighbours_corrected_convective,
                                                                IJK_Field_vector3_double& cell_faces_neighbours_corrected_diffusive,
                                                                IJK_Field_vector3_double& neighbours_weighting_colinearity) { ; };
  virtual void compute_temperature_cell_centre_neighbours(IJK_Field_double& temperature_neighbours,
                                                          IJK_Field_int& neighbours_weighting,
                                                          IJK_Field_double& neighbours_weighting_colinearity) { ; };
  virtual void replace_temperature_cell_centre_neighbours(IJK_Field_double& temperature,
                                                          IJK_Field_double& temperature_neighbours,
                                                          IJK_Field_int& neighbours_weighting,
                                                          IJK_Field_double& neighbours_weighting_colinearity) const { ; };
 
  virtual void store_cell_faces_corrected(IJK_Field_vector3_int& cell_faces_corrected_bool,
                                          IJK_Field_vector3_double& cell_faces_corrected_convective,
                                          IJK_Field_vector3_double& cell_faces_corrected_diffusive) { ; };
  virtual void clear_vectors() { ; };
  virtual void compute_min_max_ijk_reachable_fluxes(const IJK_Field_vector3_int& cell_faces_neighbours_corrected_all_bool,
                                                    const IJK_Field_int& neighbours_temperature_to_correct,
                                                    IJK_Field_vector3_int& cell_faces_neighbours_corrected_min_max_bool,
                                                    const int& max_flux_per_dir,
                                                    const int& check_cell_center_neighbour,
                                                    const int& remove_external_neighbour_values,
                                                    IJK_Field_int& neighbours_temperature_to_correct_trimmed) { ; };
  virtual void compute_min_max_ijk_any_reachable_fluxes(const IJK_Field_vector3_int& cell_faces_neighbours_corrected_all_bool,
                                                        const IJK_Field_int& neighbours_temperature_to_correct,
                                                        IJK_Field_vector3_int& cell_faces_neighbours_corrected_min_max_bool,
                                                        const int& max_flux_per_dir,
                                                        const int& check_cell_center_neighbour,
                                                        const int& remove_external_neighbour_values,
                                                        IJK_Field_int& neighbours_temperature_to_correct_trimmed) { ; };
  virtual void replace_cell_neighbours_thermal_convective_diffusive_fluxes_faces(const IJK_Field_vector3_int& cell_faces_neighbours_corrected_min_max_bool,
                                                                                 const IJK_Field_vector3_int& cell_faces_neighbours_corrected_all_bool,
                                                                                 const IJK_Field_vector3_double& cell_faces_neighbours_fluxes_corrected,
                                                                                 const int& fluxes_type) { ; };
 
  virtual void set_temperature_fluxes_periodic_sharing_strategy_on_processors(const int& copy_fluxes_on_every_procs,
                                                                              const int& copy_temperature_on_every_procs) { ; };
 
protected:
  OBS_PTR(IJK_Interfaces) interfaces_;
  OBS_PTR(Domaine_IJK) domaine_;
  OBS_PTR(Probleme_FTD_IJK_base) ref_ijk_ft_;
  const IJK_Field_double *field_ = nullptr;
 
 
  double rhocp_l_= 0.;
  double rhocp_v_ = 0.;
  double lda_l_ = 0.;
  double lda_v_ = 0.;
 
  Intersection_Interface_ijk_face * intersection_ijk_face_ = nullptr;
  Intersection_Interface_ijk_cell * intersection_ijk_cell_ = nullptr;
  /*
   * TODO: mettre ces méthodes dans une petite classe pour parcourir
   * les trois directions.
   */
  bool test_if_stencil_inclut_bout_interface_liquide() const ;
  bool test_if_stencil_inclut_bout_interface_vapeur() const ;
  ParcoursIJKDir parcours_;
};
 
#endif /* Corrige_flux_FT_base_included */