KVIsoscaling.h

Go to the documentation of this file.

#ifndef __KVISOSCALING_H
#define __KVISOSCALING_H
 
#include <vector>
#include <utility>
 
#include "KVNumberList.h"
#include "KVList.h"
#include "KVHashList.h"
 
#include "TMultiGraph.h"
 
class KVIsoscaling : public TObject {
public:
 
   KVIsoscaling()
   {
      fhlist_lnR21N_.SetOwner(kTRUE);
      fhlist_lnR21N_all_.SetOwner(kTRUE);
      fhlist_fit_.SetOwner(kTRUE);
      fhlist_csymT_.SetOwner(kTRUE);
      fhlist_yields_.SetOwner(kTRUE);
      fhlist_delta_.SetOwner(kTRUE);
      fhlist_alpha_.SetOwner(kTRUE);
      fhlist_alpha_delta_.SetOwner(kTRUE);
 
      ftol_  = 2.5;
 
      fdebug_ = kFALSE;
   }
 
   Bool_t ReadYieldsFile(Int_t system, const Char_t* file_path);
 
   void TestGaussianApprox(Int_t system1, Int_t system2, Int_t zz, Double_t tol); //use to test the effect of the rms tolerance for the given system combination and charge, return reduced chisquare
   void BuildLnR21vsNPlots(Int_t system1, Int_t system2);
 
   void FitLnR21vsNPlots(Int_t system1, Int_t system2, Option_t* option = "MNVR", Option_t* gooption = "goff");
 
   void DrawAlphavsNFits(Int_t system1, Int_t system2);
   void DrawLnR21vsNFits(Int_t system1, Int_t system2);
   void BuildAlphaPlot(Int_t system1, Int_t system2, Int_t mcolor, Int_t mstyle, Bool_t draw = kFALSE);
   void BuildDeltaZA2Plot(Int_t system1, Int_t system2, Int_t mcolor, Int_t mstyle, Bool_t draw = kFALSE);
   void BuildCsymOverTPlot(Int_t system1, Int_t system2, Int_t mcolor, Int_t mstyle, Bool_t draw = kFALSE);
   void BuildAlphavsDeltaPlot(Int_t system1, Int_t system2, Int_t mcolor, Int_t mstyle, Bool_t draw = kFALSE);
   void CreateCsymOverTMultiGraph(TMultiGraph* mgr);
   void SaveResultsROOT(const Char_t* file_name = "./isoscaling_output_file.root");
   void SaveResultsASCII(const Char_t* file_name = "./isoscaling_output_file.txt");
 
   Int_t   GetNSystems()
   {
      return int(fvec_sys_.size());
   }
   Bool_t  GetAMean(Int_t system, Int_t zz, Float_t& meanA, Float_t& meanA_err);
   Bool_t  GetAlpha(Int_t system1, Int_t system2, Int_t zz, Float_t& alpha, Float_t& alpha_err);
   Bool_t  GetDeltaZA2(Int_t system1, Int_t system2, Int_t zz, Float_t& denum, Float_t& denum_err, Bool_t debug);
   Bool_t  GetCsymOverT(Int_t system1, Int_t system2, Int_t zz, Float_t& csymT, Float_t& csymT_err, Bool_t debug);
   Int_t   FindZFromAmean(Int_t system, Int_t aa);
   Double_t GetRMSTolerance()
   {
      return ftol_;
   }
 
   std::vector<Int_t>    GetZVector(Int_t system)
   {
      return fvec_sys_z_.at(GetSystemPos(system));
   }
   std::vector<Int_t>    GetAVector(Int_t system, Int_t zz);        //return the vector of A for a given (system, Z) combination
   std::vector<Float_t>  GetYieldVector(Int_t system, Int_t zz);    //return the vector of yields for a given (system, Z) combination
   std::vector<Float_t>  GetYieldErrVector(Int_t system, Int_t zz); //return the vector of A for a given (system, Z) combination
   std::vector<Float_t>  GetAMeanVector(Int_t system)
   {
      return fvec_sys_z_meanA_.at(GetSystemPos(system));
   }
   std::vector<Float_t>  GetAMeanErrVector(Int_t system)
   {
      return fvec_sys_z_meanerrA_.at(GetSystemPos(system));
   }
 
   KVHashList* GetLnR21vsNGraphList()
   {
      return &fhlist_lnR21N_;
   }
   KVHashList* GetLnR21vsNFitList()
   {
      return &fhlist_fit_;
   }
   KVHashList* GetAlphaPlots()
   {
      return &fhlist_alpha_;
   }
   KVHashList* GetDeltaZA2Plots()
   {
      return &fhlist_delta_;
   }
   KVHashList* GetAlphavsDeltaPlots()
   {
      return &fhlist_alpha_delta_;
   }
   KVHashList* GetCsymOverTPlots()
   {
      return &fhlist_csymT_;
   }
 
   KVNumberList* GetZNumberList(Int_t system)
   {
      return (KVNumberList*)(flist_z_.At(GetSystemPos(system)));
   }
   KVNumberList* GetANumberList(Int_t system, Int_t zz);
   KVNumberList GetSharedZNumberList(Int_t system1, Int_t system2);
   KVNumberList GetSharedANumberList(Int_t system1, Int_t system2, Int_t zz);
   KVList* GetAList()
   {
      return &flist_a_;
   }
 
   void PrintYieldsList();
   void PrintSystemsList();
 
   inline void SetVerbose(Bool_t debug)
   {
      fdebug_ = debug;
   }
 
   inline void SetRMSTolerance(Double_t tol)
   {
      ftol_ = tol;
   }
 
protected:
    Bool_t fdebug_;
    Double_t ftol_;
 
   void BuildGaussianPlots(Int_t system);
 
    std::vector<Int_t> fvec_sys_;
    std::vector< std::vector<Int_t> > fvec_sys_z_;
    std::vector< std::vector< std::vector<Int_t> > > fvec_sys_z_a_;
    std::vector< std::vector< std::vector<Float_t> > > fvec_sys_z_yields_;
    std::vector< std::vector< std::vector<Float_t> > > fvec_sys_z_yields_err_;
 
    std::vector< std::vector<Float_t> > fvec_sys_z_meanA_;
    std::vector< std::vector<Float_t> > fvec_sys_z_meanerrA_;
 
   std::vector< std::pair<Int_t, Int_t> > fvec_iso_pairs_;
 
    KVNumberList fnl_sys_;
    KVList flist_z_;
    KVList flist_a_;
    KVHashList fhlist_lnR21N_;
    KVHashList fhlist_lnR21N_all_;
    KVHashList fhlist_fit_;
    KVHashList fhlist_yields_;
    KVHashList fhlist_delta_;
    KVHashList fhlist_alpha_;
    KVHashList fhlist_alpha_delta_;
    KVHashList fhlist_csymT_;
 
   Int_t   GetSystemPos(Int_t system); // returns the system position in fvec_sys_
   Int_t   GetZPos(Int_t system, Int_t zz); // returns the position of the charge Z (for the provided system) in the vector
   Int_t   GetAPos(Int_t system, Int_t zz, Int_t aa);
 
   std::vector<Int_t>    GetAVectorFromPos(Int_t pos_system, Int_t pos_zz);        //return the vector of A from (system, zz) positions in corresponding vectors
   std::vector<Float_t>  GetYieldVectorFromPos(Int_t pos_system, Int_t pos_zz);    //return the vector of yields from (system, zz) positions in corresponding vectors
   std::vector<Float_t>  GetYieldErrVectorFromPos(Int_t pos_system, Int_t pos_zz); //return the vector of A from (system, zz) positions in corresponding vectors
 
   ClassDef(KVIsoscaling, 1) //KVClass
};
 
#endif