KVIDZAFromZGridMassHomogenizer.h

#pragma once
 
#include "KVBase.h"
#include "KVIDGridManager.h"
#include "KVIDZAFromZGrid.h"
 
class KVIDZAFromZGridMassHomogenizer : public KVBase
{
    KVIDGridManager theGrids;
    TFile theData;
 
   using mass_dist_stat_t = std::unordered_map<std::string,std::vector<std::string>>;
    std::map<int,mass_dist_stat_t> all_mass_ranges;
 
   std::unordered_map<std::string,int> theRunLists;
   std::optional<KVNumberList> currentRunList;
   bool has_multi_runlists() const { return theRunLists.size()>1; }
   void correct_masses_for_grid(const TString& grid_name, int Z, int deltaA,
                                const KVNameValueList& mass_fit_parameters);
   KVIDZAFromZGrid* GetGrid(TObject* obj)
   {
      auto gr = dynamic_cast<KVIDZAFromZGrid*>(obj);
      if(gr && (!has_multi_runlists() || (currentRunList && (!gr->HasRunList() || currentRunList->SubsetOf(gr->GetRuns())))))
         return gr;
      if(gr && has_multi_runlists() && currentRunList && gr->GetRuns().SubsetOf(*currentRunList))
      {
         KVError::Warning(this,"GetGrid",
                          "Check current runlist (%s): grid %s may be included several times (this version is for runs %s)",
                          currentRunList->AsString(), gr->GetName(), gr->GetRunList());
      }
      return nullptr;
   }
   void Analyse(KVIDZAFromZGrid* grid,double min_yield);
   void Analyse(const TString& gridname,double min_yield)
   {
      auto gr = GetGrid(gridname);
      Analyse(gr,min_yield);
   }
 
   public:
   KVIDZAFromZGridMassHomogenizer(const TString& gridfile, const TString& datafile);
 
   void SetCurrentRunList(const TString& runs)
   {
      currentRunList = KVNumberList(runs);
   }
   KVNumberList GetCurrentRunList() const
   {
      return currentRunList.value_or("");
   }
   void Analyse(double min_yield)
   {
 
      if(has_multi_runlists() && !currentRunList)
      {
         KVError::Error(this,"Analyse", "Grids have multiple runlists. You must choose the current runlist first:");
         for(auto& rl : theRunLists)
         {
            if(rl.first!="")
               KVError::Info(this, "Analyse",
                                " - %d grids are valid for runlist %s", rl.second, rl.first.c_str());
         }
         return;
      }
      for(auto obj : *theGrids.GetGrids())
      {
         Analyse(GetGrid(obj),min_yield);
      }
   }
   KVIDZAFromZGrid* GetGrid(const TString& gridname)
   {
      return GetGrid(theGrids.GetGrid(gridname));
   }
   void Print() const;
   void ShowFits(int Z, const std::string& alist);
   void CorrectMasses(int Z, const std::string& alist, int deltaA,
                      const KVNameValueList& mass_fit_parameters);
   void CorrectMassesForTelescope(int Z, const TString& idtel, int deltaA,
                                  const KVNameValueList& mass_fit_parameters);
   void Clear()
   {
      all_mass_ranges.clear();
   }
   void SaveGrids(const TString& filename);
 
   ClassDefOverride(KVIDZAFromZGridMassHomogenizer,0)
};