KVIDZAFromZGrid.h

 
#ifndef __KVIDZAFROMZGRID_H
#define __KVIDZAFROMZGRID_H
 
#include "KVIDZAGrid.h"
#include "KVList.h"
#include "KVUniqueNameList.h"
#include "KVIdentificationResult.h"
#include "KVMultiGaussIsotopeFit.h"
 
 
class interval;
class interval_set;
 
class KVIDZAFromZGrid : public KVIDZAGrid {
 
   void check_pidranges_and_massfits();
 
public:
   enum PIDType {
      kNone,
      kPeackType,
      kIntType
   };
 
protected:
   Bool_t fPIDRange;
   KVNumberList fPIDRangeZList;
    KVList fTables;
    KVUniqueNameList fFits;
 
   Bool_t fIgnoreMassID;
 
   int is_inside(double pid) const;
 
public:
   KVIDZAFromZGrid();
   ROOT_COPY_CTOR(KVIDZAFromZGrid, KVIDZAGrid)
   ROOT_COPY_ASSIGN_OP(KVIDZAFromZGrid)
 
   void Copy(TObject& obj) const override;
 
   void ReadFromAsciiFile(std::ifstream& gridfile) override;
   void WriteToAsciiFile(std::ofstream& gridfile) override;
 
   void Identify(Double_t x, Double_t y, KVIdentificationResult*) const override;
   virtual double DeduceAfromPID(KVIdentificationResult* idr) const;
   void LoadPIDRanges();
   void ResetPIDRanges();
   void ReloadPIDRanges();
   interval_set* GetIntervalSet(int zint) const;
   const KVList* GetIntervalSets() const
   {
      return &fTables;
   }
   void AddIntervalSet(interval_set*);
   void RemoveIntervalSet(int zint);
   void RemoveIntervalSet(interval_set*);
 
   void PrintPIDLimits();
   void ClearPIDIntervals();
   void ExportToGrid();
 
   void Initialize() override;
 
   Bool_t HasMassIDCapability() const override
   {
 
      return (fPIDRange || fTables.GetEntries()) && !fIgnoreMassID;
   }
   void SetOnlyZId(Bool_t /*yes*/ = kTRUE) override
   {
 
      KVIDZAGrid::SetOnlyZId(true);
   }
 
   bool MassIdentificationFromMultiGaussFit(KVMultiGaussIsotopeFit*, KVIdentificationResult*) const;
   KVMultiGaussIsotopeFit* GetMultiGaussFit(int z) const
   {
      return (KVMultiGaussIsotopeFit*)fFits.FindObject(Form("MultiGaussIsotopeFit_Z=%d", z));
   }
 
   ClassDefOverride(KVIDZAFromZGrid, 3) //Compute Z and A only from Z lines...
};
 
 
 
class interval: public TNamed {
   int fType;
   int fZ;
   int fA;
 
   double fPID;
   double fPIDMin;
   double fPIDmax;
 
public:
   void Copy(TObject& o) const override
   {
      TNamed::Copy(o);
      interval& i = dynamic_cast<interval&>(o);
      i.fType = fType;
      i.fZ = fZ;
      i.fA = fA;
      i.fPID = fPID;
      i.fPIDMin = fPIDMin;
      i.fPIDmax = fPIDmax;
   }
   ROOT_DEF_CTOR(interval, TNamed)
   ROOT_COPY_CTOR(interval, TNamed)
   ROOT_COPY_ASSIGN_OP(interval)
   interval(int zz, int aa, double pid, double pidmin = -1., double pidmax = -1.)
   {
      fZ = zz;
      fA = aa;
      fPID = pid;
      fPIDMin = pidmin;
      fPIDmax = pidmax;
      SetName(Form("%d_%d", zz, aa));
   }
   bool is_inside(double pid)
   {
      if (pid > fPIDMin && pid < fPIDmax) return kTRUE;
      return kFALSE;
   }
   bool is_left_of(double pid)
   {
      return (fPIDmax < pid);
   }
   bool is_right_of(double pid)
   {
      return (fPIDMin > pid);
   }
 
   int    GetA()
   {
      return fA;
   }
   int    GetZ()
   {
      return fZ;
   }
   double GetPID()
   {
      return fPID;
   }
   double GetPIDmin()
   {
      return fPIDMin;
   }
   double GetPIDmax()
   {
      return fPIDmax;
   }
 
   void SetA(int aa)
   {
      fA = aa;
   }
   void SetZ(int zz)
   {
      fZ = zz;
   }
   bool SetPID(double pid)
   {
      fPID = pid;
      if (fPIDMin > 0 && fPIDmax > 0) {
         if (pid >= fPIDMin && pid <= fPIDmax) return true;
         return false;
      }
      return true;
   }
   void SetPIDmin(double pidmin)
   {
      fPIDMin = pidmin;
   }
   void SetPIDmax(double pidmax)
   {
      fPIDmax = pidmax;
   }
 
 
   ClassDefOverride(interval, 1) //
};
 
class interval_set: public TNamed {
public:
   int fType;
   int fZ;
   KVList fIntervals;
   Int_t  fNPIDs;
   TGraph fPIDs;
 
   void Copy(TObject& o) const override
   {
      TNamed::Copy(o);
      interval_set& i = dynamic_cast<interval_set&>(o);
      i.fType = fType;
      i.fZ = fZ;
      fIntervals.Copy(i.fIntervals);
      i.fNPIDs = fNPIDs;
    i.fPIDs = fPIDs;
   }
   ROOT_DEF_CTOR(interval_set, TNamed)
   ROOT_COPY_CTOR(interval_set, TNamed)
   ROOT_COPY_ASSIGN_OP(interval_set)
   int GetZ()
   {
      return fZ;
   }
   int GetNPID()
   {
      return fIntervals.GetSize();
   }
   KVList* GetIntervals()
   {
      return &fIntervals;
   }
   TString GetListOfMasses();
 
   interval_set(int zz, int type);
   void   add(int aa, double pid, double pidmin = -1., double pidmax = -1.);
   double eval(KVIdentificationResult* idr);
   bool is_inside(double pid);
   bool is_above(double pid);
 
   ClassDefOverride(interval_set, 1) //
};
 
 
 
 
 
#endif