Postraitements.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 <Postraitements.h>
#include <Postraitement.h>
#include <unordered_set>
 
Implemente_instanciable(Postraitements,"Postraitements|Post_processings",LIST(OWN_PTR(Postraitement_base)));
// XD postraitements listobj postraitements INHERITS_BRACE un_postraitement NO_COMMA Keyword to use several results
// XD_CONT files. List of objects of post-processing (with name).
 
// XD type_postraitement_ft_lata objet_lecture nul NO_BRACE not_set
// XD attr type chaine(into=["postraitement_ft_lata","postraitement_ftd"]) type REQ not_set
// XD attr nom chaine nom REQ Name of the post-processing.
// XD attr bloc bloc_lecture bloc REQ not_set
 
// XD un_postraitement_spec objet_lecture nul NO_BRACE An object of post-processing (with type +name).
// XD attr type_un_post type_un_post type_un_post OPT not_set
// XD attr type_postraitement_ft_lata type_postraitement_ft_lata type_postraitement_ft_lata OPT not_set
 
// XD liste_post listobj liste_post INHERITS_BRACE un_postraitement_spec NO_COMMA Keyword to use several results files.
// XD_CONT List of objects of post-processing (with name)
 
// XD liste_post_ok listobj liste_post_ok INHERITS_BRACE nom_postraitement NO_COMMA Keyword to use several results
// XD_CONT files. List of objects of post-processing (with name)
 
Entree& Postraitements::readOn(Entree& s)
{
  Process::exit("Postraitements::readOn should not be used");
  return s;
}
 
Sortie& Postraitements::printOn(Sortie& s) const
{
  for (const auto& itr : *this)
    {
      const Postraitement_base& post = itr.valeur(); // valeur() because OWN_PTR
      s << post;
    }
  return s;
}
 
// Reading of post-processing objects from the TRUST data set.
// Within the problem, the syntax is as follows:
//
// ------------- Syntax 1: A single standard post-processing object
//                         (historical syntax)
// Lire pb {
//   ... (the equations)
//   ...
//   Postraitement {
//     ...            (read via readOn of Postraitement_std)
//   }
//
// ------------- Syntax 2: Several standard post-processing objects
//                         (historical syntax)
// Lire pb {
//   ... (the equations)
//   ...
//   Postraitements {
//     nom_postraitement_1 {                   note: arbitrary name
//       ...            (read via readOn of Postraitement_std)
//     }
//     nom_postraitement_2 {
//       ...            (read via readOn of Postraitement_std)
//     }
//     ...
//   }
// ------------- Syntax 3: Standard or non-standard post-processing objects
//               (to use the standard post-processing, set
//                type_postraitement = "Postraitement_std")
//
// Lire pb {
//   ... (the equations)
//   ...
//   Liste_Postraitements {
//     type_postraitement nom_postraitement {
//                      (type_postraitement is the name of a type derived
//                       from Postraitement_base, e.g. Postraitement)
//       ...            (read via readOn of the requested type)
//     }
//     type_postraitement nom_postraitement {
//       ...            (read via readOn of the requested type)
//     }
//     ...
//   }
//
// Reading starts with the keyword Postraitement, Postraitements,
// or Liste_postraitement, and continues until the last closing brace (inclusive).
 
// Returns 1 if motlu is recognised (a post-processing block was read),
//         0 otherwise.
 
int Postraitements::lire_postraitements(Entree& is, const Motcle& motlu, const Probleme_base& mon_pb)
{
  Motcles motcles(5);
  motcles[0] = "Postraitement|Post_processing";
  motcles[1] = "Postraitements|Post_processings";
  motcles[2] = "liste_postraitements";
  motcles[3] = "liste_de_postraitements";
  motcles[4] = "Postraitement_FT_Lata";
 
  const int lerang = motcles.search(motlu);
 
  // a cause du cas Liste_Postraitements (rang=2)
  //=> obligation de creer la liste de nom de fichier associes au post
  LIST(Nom) list_nom_post;
  int compteur = 0 ;
 
  if (lerang == 0)
    {
      // Create and read a single standard post-processing object
      OWN_PTR(Postraitement_base) & post = add( OWN_PTR(Postraitement_base)() );
      if (mon_pb.que_suis_je() == "Pb_STT")
        post.typer("Postraitement_STT");
      else if (mon_pb.que_suis_je().contient("_IJK"))
        post.typer("Postprocessing_IJK");
      else
        post.typer("Postraitement");
      post->associer_nom_et_pb_base("neant", mon_pb);
      is >> post.valeur();
 
      // XXX Elie Saikali : prevent any surprise in the future ...
      const Postraitement * z_post = dynamic_cast<const Postraitement*>(&(post.valeur()));
 
      if (z_post && z_post->format() == "cgns")
        cgns_post_file_names_.push_back(z_post->nom_fich().getString());
    }
  else if (lerang == 1 || lerang == 2 || lerang == 3 )
    {
      // Read a list
      // Read the opening brace
      //Nom post_which_contains_statistic("");
      Motcle motlu2;
      is >> motlu2;
      if (motlu2 != "{")
        {
          Cerr << "Error while reading the list of Postraitements," << finl;
          Cerr << " we expected a {" << finl;
          exit();
        }
      is >> motlu2;
      while (motlu2 != "}")
        {
          Motcle type, nom_du_post;
          switch (lerang)
            {
            case 1:
              {
                type = "Postraitement";
                nom_du_post = motlu2;
                break;
              }
            case 2:
              {
                Cerr<<" Warning liste_postraitements obsolete option" <<finl;
                // The first word is the type, the second is the name
                type = motlu2;
                is >> nom_du_post;
                break;
              }
            case 3:
              {
                nom_du_post = motlu2;
                is >> type ;
                break;
              }
            default:
              {
                Cerr<< "Error in Postraitements"<<finl;
                exit();
              }
            }
          list_nom_post.add_if_not(nom_du_post);
 
          OWN_PTR(Postraitement_base) & post = add( OWN_PTR(Postraitement_base)() );
          post.typer(type);
          post->associer_nom_et_pb_base(nom_du_post, mon_pb);
          is >> post.valeur();
 
          // XXX Elie Saikali : prevent any surprise in the future ...
          const Postraitement * z_post = dynamic_cast<const Postraitement*>(&(post.valeur()));
 
          if (z_post && z_post->format() == "cgns")
            cgns_post_file_names_.push_back(z_post->nom_fich().getString());
 
          /*
          // Check if statistic block is defined several times
          // Not supported yet cause, backup files will contains several
          // statistic blocks with same name BUT different contents -> error
          // We should change the .sauv format and generalize the statistic block name
          if (ref_cast(Postraitement,post.valeur()).stat_demande() || ref_cast(Postraitement,post.valeur()).stat_demande_definition_champs())
          {
            if (post_which_contains_statistic!="")
            {
               Cerr << "Several statistic blocks in a same problem is not supported yet." << finl;
               Cerr << "It seems you defined statistics in the post processing block " << nom_du_post << finl;
               Cerr << "whereas some statistics has been defined already the in the block " << post_which_contains_statistic << finl;
               Cerr << "Check your data file by regrouping statistics in a same prostprocessing block." << finl;
               exit();
            }
                  post_which_contains_statistic=nom_du_post;
                }
          */
          is >> motlu2;
          compteur++;
        }
 
      // Verification check to avoid data being overwritten during incremental saves.
      // Because of the Liste_Postraitements case, a list of file names associated with each post-processing object must be built.
      if (list_nom_post.size()!=compteur)
        {
          Cerr << "You can use the same name for the storing data file in two different blocks of post-processing" << finl;
          Cerr << "Check your datafile." << finl;
          exit();
        }
    }
  else if (lerang == 4) /* pour FT lata triocfd */
    {
      OWN_PTR(Postraitement_base) & post = add( OWN_PTR(Postraitement_base)() );
      post.typer("Postraitement_FT_Lata");
      post->associer_nom_et_pb_base("neant", mon_pb);
      is >> post.valeur();
    }
  else
    {
      return 0;
    }
  return 1;
}
 
void Postraitements::postraiter()
{
  for (auto& itr : *this)
    itr->postraiter(1); // Force post-processing
}
 
void Postraitements::traiter_postraitement()
{
  for (auto& itr : *this)
    itr->postraiter(0); // Post-process if the time interval has elapsed
}
 
void Postraitements::mettre_a_jour(double temps)
{
  for (auto& itr : *this)
    itr->mettre_a_jour(temps);
}
 
void Postraitements::resetTime(double t, const std::string dirname)
{
  for (auto& itr : *this)
    itr->resetTime(t, dirname);
}
 
void Postraitements::init()
{
  for (auto& itr : *this)
    itr->init();
}
 
void Postraitements::finir()
{
  for (auto& itr : *this)
    itr->finir();
}
 
int Postraitements::sauvegarder(Sortie& os) const
{
  int bytes = 0;
  for (const auto& itr : *this)
    bytes += itr->sauvegarder(os);
  return bytes;
}
 
int Postraitements::reprendre(Entree& is)
{
  for (auto& itr : *this)
    itr->reprendre(is);
  return 1;
}
 
void Postraitements::completer()
{
  // XXX Elie Saikali : CGNS duplicated file_names management ...
  if (cgns_post_file_names_.size() > 1)
    {
      // check & count if we have duplicated file names !
      std::unordered_map<std::string, int> file_name_counts;
      for (const auto &name : cgns_post_file_names_)
        file_name_counts[name]++;
 
      // chick if we have at least one duplicated names
      bool has_duplicates = false;
      for (const auto& name_to_count: file_name_counts)
        {
 
          const auto& count = name_to_count.second;
          if (count > 1)
            {
              has_duplicates = true;
              break;
            }
        }
 
      if (has_duplicates) // si has_duplicates => on renomme SEULEMENT les doublons !
        {
          std::unordered_map<std::string, int> current_occurrence; // detect what is the index of duplication : 1st ? 2nd ? ...
 
          for (auto &itr : *this)
            {
              Postraitement *z_post = dynamic_cast<Postraitement*>(&(itr.valeur()));
              if (!z_post || z_post->format() != "cgns")
                continue;
 
              const std::string file_name = z_post->nom_fich().getString();
 
              // only if duplicated ...
              if (file_name_counts[file_name] > 1)
                {
                  current_occurrence[file_name]++;
 
                  // dont change 1st file ...
                  if (current_occurrence[file_name] > 1)
                    z_post->modify_cgns_basenames_and_reinit(current_occurrence[file_name], file_name_counts[file_name]);
                }
            }
        }
    }
 
  // on complete les posts !
  for (auto& itr : *this)
    itr->completer();
}
 
void Postraitements::completer_sondes()
{
  for (auto& itr : *this)
    itr->completer_sondes();
}