KVIDZAFromZGridBatchMassCorrector.cpp

#include "KVIDZAFromZGridBatchMassCorrector.h"
#include "KVIDZAFromZGrid.h"
#include "KVIDZAFromZGridMassCorrector.h"
#include "KVGaussFitMassModifier.h"
#include "KVMultiGaussIsotopeFit.h"
 
 
 
KVIDZAFromZGridBatchMassCorrector::KVIDZAFromZGridBatchMassCorrector(const TString& ref_grids_file, const TString& bad_grids_file,
                                                                     const TString& bad_grids_id_map_file
      )
   : reference_id_maps{bad_grids_id_map_file}
{
   // \param[in] ref_grids_file name/path to file containing 'reference' grids
   // \param[in] bad_grids_file name/path to file containing grids to be corrected wrt 'reference' grids
   // \param[in] bad_grids_id_map_file name/path to file containing 2d identification maps for the 'bad' (to be corrected) grids
 
   KVIDGraph::SetAutoAdd(false);
   if(reference_grids.ReadAsciiFile(ref_grids_file))
   {
      reference_grids.AddLastReadGrids();
      reference_grids.SetName(ref_grids_file);
      KVError::Info(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Read %d reference grids from file %s",
                    reference_grids.GetGrids()->GetEntries(),
                    reference_grids.GetName());
   }
   else
      KVError::Error(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Could not read file %s",
                    ref_grids_file.Data());
 
   if(grids_to_correct.ReadAsciiFile(bad_grids_file))
   {
      grids_to_correct.AddLastReadGrids();
      grids_to_correct.SetName(bad_grids_file);
      KVError::Info(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Read %d grids to correct from file %s",
                    grids_to_correct.GetGrids()->GetEntries(),
                    grids_to_correct.GetName());
   }
   else
      KVError::Error(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Could not read file %s",
                     bad_grids_file.Data());
}
 
 
 
 
KVIDZAFromZGridBatchMassCorrector::KVIDZAFromZGridBatchMassCorrector(const TString& ref_grids_file, const TString& ref_id_map_file)
   : reference_id_maps{ref_id_map_file}
{
   // \param[in] ref_grids_file name/path to file containing 'reference' grids
   // \param[in] ref_id_map_file name/path to file containing 2d identification maps for the 'reference' grids
 
   KVIDGraph::SetAutoAdd(false);
   if(reference_grids.ReadAsciiFile(ref_grids_file))
   {
      reference_grids.AddLastReadGrids();
      reference_grids.SetName(ref_grids_file);
      KVError::Info(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Read %d reference grids from file %s",
                    reference_grids.GetGrids()->GetEntries(),
                    reference_grids.GetName());
   }
   else
      KVError::Error(this, "KVIDZAFromZGridBatchMassCorrector",
                    "Could not read file %s",
                    ref_grids_file.Data());
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::CorrectGrid(KVIDZAFromZGrid* bad_grid,
                                                    std::function<KVString (const KVString&)> deduce_ref_grid_name_from_bad_grid_name,
                                                    const KVNameValueList& mass_fit_parameters, double min_yield_cutoff,
                                                    std::function<KVString (const KVString&)> deduce_bad_histo_name)
{
   KVError::Info(this, "CorrectGrid", "Treating grid : %s", bad_grid->GetName());
 
   // deduce name of reference grid
   auto ref_grid_name = deduce_ref_grid_name_from_bad_grid_name(bad_grid->GetName());
 
   // get reference grid
   KVIDZAFromZGrid* ref_grid = dynamic_cast<KVIDZAFromZGrid*>(reference_grids.GetGrid(ref_grid_name));
   if(!ref_grid)
   {
      KVError::Info(this, "CorrectGrids",
                    "No reference grid %s in file %s to compare with grid %s",
                    ref_grid_name.Data(), reference_grids.GetName(), bad_grid->GetName());
      return;
   }
 
   CorrectGridToReference(bad_grid, ref_grid, mass_fit_parameters, min_yield_cutoff, deduce_bad_histo_name);
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::CorrectGridToReference(KVIDZAFromZGrid* bad_grid, KVIDZAFromZGrid* ref_grid, const KVNameValueList& mass_fit_parameters, double min_yield_cutoff, std::function<KVString (const KVString&)> deduce_bad_histo_name)
{
   // determine & apply corrections for grid
   KVIDZAFromZGridMassCorrector toto(ref_grid, bad_grid);
   auto Correct = toto.DetermineMassCorrections(min_yield_cutoff);
   if(Correct.size())
   {
      if(apply_corrections)
      {
         // find & linearize histo for new fit
         auto h2d = dynamic_cast<TH2*>(reference_id_maps.Get(deduce_bad_histo_name(bad_grid->GetName())));
         if(!h2d)
         {
            KVError::Warning(this, "CorrectGrids",
                             "No reference idmap with name %s found for bad grid %s",
                             deduce_bad_histo_name(bad_grid->GetName()).Data(),bad_grid->GetName());
            return;
         }
         auto h = bad_grid->LinearizeHistoToPID(h2d,100);
         toto.ApplyCorrections(Correct, h, mass_fit_parameters);
      }
      else
         toto.ApplyCorrections(Correct, nullptr, mass_fit_parameters);
   }
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::CorrectGridToReference(const TString& bad_grid_name, const TString& ref_grid_name, const KVNameValueList& mass_fit_parameters, double min_yield_cutoff, std::function<KVString (const KVString&)> deduce_bad_histo_name)
{
   auto bad_grid = dynamic_cast<KVIDZAFromZGrid*>(grids_to_correct.GetGrid(bad_grid_name));
   if(!bad_grid)
   {
      KVError::Info(this, "CorrectGridToReference",
                    "No grid %s defined in file %s",
                    bad_grid_name.Data(), grids_to_correct.GetName());
      return;
   }
   KVIDZAFromZGrid* ref_grid = dynamic_cast<KVIDZAFromZGrid*>(reference_grids.GetGrid(ref_grid_name));
   if(!ref_grid)
   {
      KVError::Info(this, "CorrectGridToReference",
                    "No reference grid %s in file %s to compare with grid %s",
                    ref_grid_name.Data(), reference_grids.GetName(), bad_grid->GetName());
      return;
   }
   CorrectGridToReference(bad_grid,ref_grid,mass_fit_parameters,min_yield_cutoff,deduce_bad_histo_name);
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::CorrectGrid(const TString& bad_grid_name,
                                                    std::function<KVString (const KVString&)> deduce_ref_grid_name_from_bad_grid_name,
                                                    const KVNameValueList& mass_fit_parameters, double min_yield_cutoff,
                                                    std::function<KVString (const KVString&)> deduce_bad_histo_name)
{
   auto bad_grid = dynamic_cast<KVIDZAFromZGrid*>(grids_to_correct.GetGrid(bad_grid_name));
   if(!bad_grid)
   {
      KVError::Info(this, "CorrectGrid",
                    "No grid %s defined in file %s",
                    bad_grid_name.Data(), grids_to_correct.GetName());
      return;
   }
   CorrectGrid(bad_grid,deduce_ref_grid_name_from_bad_grid_name,mass_fit_parameters,min_yield_cutoff,deduce_bad_histo_name);
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::CorrectGrids(std::function<KVString(const KVString&)> deduce_ref_grid_name_from_bad_grid_name,
                                                     const KVNameValueList& mass_fit_parameters,
                                                     double min_yield_cutoff,
                                                     std::function<KVString(const KVString&)> deduce_bad_histo_name
                                                     )
{
   // loop over all grids to correct
   TIter nxt_grid(grids_to_correct.GetGrids());
   KVIDZAFromZGrid* bad_grid;
   while( (bad_grid = (KVIDZAFromZGrid*)nxt_grid()) )
   {
      CorrectGrid(bad_grid,deduce_ref_grid_name_from_bad_grid_name,mass_fit_parameters,min_yield_cutoff,deduce_bad_histo_name);
   }
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::SaveCorrectedGrids(const TString& filename)
{
   grids_to_correct.WriteAsciiFile(filename);
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::RefitAllReferenceGridsToData(const KVNameValueList& mass_fit_params)
{
   // \warning Only use this method if you used the KVIDZAFromZGridBatchMassCorrector() constructor with 2 arguments: the path
   // to the file containing grids to be refitted, and the path to the ROOT file containing the data to be used for the fits.
   TIter nxt_grid(reference_grids.GetGrids());
   KVIDZAFromZGrid* gr;
   while( (gr = (KVIDZAFromZGrid*)nxt_grid()) )
   {
      RefitReferenceGridToData(gr->GetName(),mass_fit_params);
   }
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::RefitReferenceGridToData(const TString&  ref_grid_name, const KVNameValueList& mass_fit_params)
{
   auto gr = (KVIDZAFromZGrid*)reference_grids.GetGrid(ref_grid_name);
   KVError::Info(this,"RefitAllReferenceGridsToData", "Grid %s", gr->GetName());
   gr->Initialize();
   if(!gr->GetFits() || gr->GetFits()->IsEmpty())
      return;
   auto hdata = (TH2*)reference_id_maps.Get(gr->GetName());//assume data hist has same name as grid!
   if(!hdata)
      return;
   auto pid_dist = gr->LinearizeHistoToPID(hdata,100);
   gr->GetFits()->ls();
   KVNumberList zfits;
   TIter nxt_fit(gr->GetFits());
   KVMultiGaussIsotopeFit* mgf;
   while( (mgf = (KVMultiGaussIsotopeFit*)nxt_fit()) )
   {
      zfits.Add(mgf->GetZ());
   }
   for(auto z : zfits)
   {
      KVError::Info(this,"RefitReferenceGridToData", "...Z=%d", z);
      KVGaussFitMassModifier gfmm(gr, z);
      gfmm.Modify(0, pid_dist, mass_fit_params);
   }
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::SaveReferenceGrids(const TString& filename)
{
   reference_grids.WriteAsciiFile(filename);
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::DrawReferenceFit(const TString& grid_name, Int_t Z) const
{
   auto grid = (KVIDZAFromZGrid*)reference_grids.GetGrid(grid_name);
   if(!grid)
   {
      KVError::Error(this, "DrawReferenceFit", "No grid with name %s", grid_name.Data());
      return;
   }
   auto fit = grid->GetMultiGaussFit(Z);
   if(!fit)
   {
      KVError::Error(this, "DrawReferenceFit", "No fit for Z=%d in grid %s", Z, grid_name.Data());
      return;
   }
   fit->DrawFitWithGaussians();
}
 
 
 
 
void KVIDZAFromZGridBatchMassCorrector::DrawOtherFit(const TString& grid_name, Int_t Z) const
{
   auto grid = (KVIDZAFromZGrid*)grids_to_correct.GetGrid(grid_name);
   if(!grid)
   {
      KVError::Error(this, "DrawOtherFit", "No grid with name %s", grid_name.Data());
      return;
   }
   auto fit = grid->GetMultiGaussFit(Z);
   if(!fit)
   {
      KVError::Error(this, "DrawOtherFit", "No fit for Z=%d in grid %s", Z, grid_name.Data());
      return;
   }
   fit->DrawFitWithGaussians();
}
 
 
ClassImp(KVIDZAFromZGridBatchMassCorrector)