KVIDGraph.h

/*
$Id: KVIDGraph.h,v 1.7 2009/04/28 09:07:47 franklan Exp $
$Revision: 1.7 $
$Date: 2009/04/28 09:07:47 $
*/
 
 
#ifndef __KVIDGRAPH_H
#define __KVIDGRAPH_H
 
#include "TCutG.h"
#include "KVNameValueList.h"
#include "KVIDentifier.h"
#include <RQ_OBJECT.h>
#include <TH2.h>
#include "KVIdentificationResult.h"
#include "KVNumberList.h"
#include "RVersion.h"
 
class TVirtualPad;
class KVIdentificationResult;
 
class KVIDGraph : public TCutG {
   friend class KVIDGridManager;
 
   RQ_OBJECT("KVIDGraph")
 
protected:
 
    Bool_t fOnlyZId;
    KVList fIdentifiers;
    KVList fCuts;
    KVList fInfoZones;
    Axis_t fXmin, fXmax;
    Axis_t fYmin, fYmax;
    KVNameValueList fPar;
    Double_t fLastScaleX;
    Double_t fLastScaleY;
    TVirtualPad* fPad;
    KVNumberList fRunList;
    TList fTelescopes;
    mutable TString fDyName;
    TString fPattern;
    Int_t fMassFormula;
    KVIDGraph* fLastSavedVersion;
    static Bool_t fAutoAddGridManager;
 
   Bool_t IsOnlyZId() const
   {
      return fOnlyZId;
   }
 
   void Scale(Double_t sx = -1, Double_t sy = -1);
   void init();
   virtual KVIDentifier* New(const Char_t*);
   virtual void ReadIdentifierFromAsciiFile(TString& name, TString& type, TString& cl, std::ifstream& gridfile);
   void WriteParameterListOfIDTelescopes();
   virtual void BackwardsCompatibilityFix();
 
   void MakeBestGuessForNewIDLineZandA(KVIDentifier* idline)
   {
 
      int zmax,amax;
      if(GetNumberOfIdentifiers())
      {
         SortIdentifiers();
         zmax = ((KVIDentifier*)GetIdentifiers()->Last())->GetZ();
         amax = ((KVIDentifier*)GetIdentifiers()->Last())->GetA();
      }
      else
      {
         zmax=!IsOnlyZId();
         amax=0;
      }
      if(IsOnlyZId())
         idline->SetZ(zmax+1);
      else
         idline->SetAandZ(amax+1,zmax);
   }
 
public:
   virtual void ReadFromAsciiFile(std::ifstream& gridfile);
   virtual void WriteToAsciiFile(std::ofstream& gridfile);
   virtual Bool_t AcceptIDForTest(const KVIdentificationResult& idr)
   {
 
      return idr.IDOK;
   }
   void AddParameter(char* Name, char* Value)
   {
      fPar.SetValue(Name, Value);
   }
 
   KVIDGraph();
   KVIDGraph(const KVIDGraph&);
   virtual ~KVIDGraph();
 
   void Copy(TObject&) const override;
   virtual void Identify(Double_t /*x*/, Double_t /*y*/, KVIdentificationResult*) const = 0;
   virtual void Initialize() = 0;
   virtual Bool_t IsIdentifiable(Double_t /*x*/, Double_t /*y*/, TString* rejected_by = nullptr) const;
   virtual void SetInfos(Double_t /*x*/, Double_t /*y*/, KVIdentificationResult* /*idr*/) const;
 
   static void SetAutoAdd(Bool_t yes = kTRUE)
   {
      fAutoAddGridManager = yes;
   }
   static Bool_t GetAutoAdd()
   {
      return fAutoAddGridManager;
   }
   void ClearListOfTelescopes()
   {
      fTelescopes.Clear();
   }
   KVIDGraph* GetLastSavedVersion() const
   {
      return fLastSavedVersion;
   }
   void RevertToLastSavedVersion();
   void UpdateLastSavedVersion();
 
   static KVIDGraph* MakeIDGraph(const Char_t*);
 
   void FindAxisLimits();
   using TCutG::Scale;
   void Scale(TF1* sx, TF1* sy);
 
   KVIDentifier* GetIdentifier(Int_t Z, Int_t A) const;
   void RemoveIdentifier(KVIDentifier*);
   void RemoveCut(KVIDentifier*);
   void RemoveInfo(KVIDentifier*);
 
   TVirtualPad* GetPad() const
   {
      return fPad;
   }
 
   void ReadAsciiFile(const Char_t* filename);
   void AddIDTelescopes(const TList*);
   void     SetName(const char* name) override
   {
      TNamed::SetName(name); /*Modified()*/;
   } // *MENU*
   void Clear(Option_t* opt = "") override; //  *MENU*
   void SetXVariable(const char* v)
   {
      SetVarX(v);
      Modified();
   } //  *MENU={Hierarchy="Set.../X Variable"}* *ARGS={v=>fVarX}
   void SetYVariable(const char* v)
   {
      SetVarY(v);
      Modified();
   } //  *MENU={Hierarchy="Set.../Y Variable"}* *ARGS={v=>fVarY}
   void SetRunList(const char* runlist)
   {
      SetRuns(KVNumberList(runlist));
   }  // *MENU={Hierarchy="Set.../List of Runs"}*
   virtual void SetOnlyZId(Bool_t yes = kTRUE);
   void SetMassFormula(Int_t);// *SUBMENU={Hierarchy="Set.../Mass Formula"}*
   void WriteAsciiFile(const Char_t* filename); // *MENU*
   void SetXScaleFactor(Double_t = 0); //  *MENU={Hierarchy="Scale.../X Scale Factor"}*
   void SetYScaleFactor(Double_t = 0);//  *MENU={Hierarchy="Scale.../Y Scale Factor"}*
   void          SetEditable(Bool_t editable = kTRUE) override; // *TOGGLE* *GETTER=GetEditable
 
   virtual Bool_t HasMassIDCapability() const
   {
      return !IsOnlyZId();
   }
 
   virtual void SetMassIDCapability(Bool_t yes = kTRUE)
   {
      SetOnlyZId(!yes);
   } //  *TOGGLE={Hierarchy="A and Z Identification"}* *GETTER=HasMassIDCapability
 
   void Draw(Option_t* opt = "") override;  //  *MENU={Hierarchy="View.../Draw"}*
   void UnDraw(); //  *MENU={Hierarchy="View.../UnDraw"}*
   void ResetDraw();// *MENU={Hierarchy="View.../ResetDraw"}*
   void SetLineColor(Color_t lcolor) override
   {
      fIdentifiers.Execute("SetLineColor", Form("%d", (Int_t) lcolor));
      fCuts.Execute("SetLineColor", Form("%d", (Int_t) lcolor));
      fInfoZones.Execute("SetLineColor", Form("%d", (Int_t) lcolor));
      Modified();
   } // *MENU={Hierarchy="View.../SetLinecolor"}*
   void SetLineStyle(Style_t lstyle) override
   {
      fIdentifiers.Execute("SetLineStyle", Form("%d", (Int_t) lstyle));
      fCuts.Execute("SetLineStyle", Form("%d", (Int_t) lstyle));
      fInfoZones.Execute("SetLineStyle", Form("%d", (Int_t) lstyle));
      Modified();
   } // *MENU={Hierarchy="View.../SetLineStyle"}*
   void SetLineWidth(Width_t lwidth) override
   {
      fIdentifiers.Execute("SetLineWidth", Form("%d", (Int_t) lwidth));
      fCuts.Execute("SetLineWidth", Form("%d", (Int_t) lwidth));
      fInfoZones.Execute("SetLineWidth", Form("%d", (Int_t) lwidth));
      Modified();
   } // *MENU={Hierarchy="View.../SetLineWidth"}*
 
   void ExtendBeginningAllIdentLines(Double_t, Option_t* = "");// *MENU*
   void ExtendEndAllIdentLines(Double_t, Option_t* = "");// *MENU*
 
   Double_t GetXScaleFactor();
   Double_t GetYScaleFactor();
   void Add(TString, KVIDentifier*);
   KVIDentifier* Add(TString, TString);
   virtual void DrawAndAdd(const Char_t* type = "ID", const Char_t* classname = "KVIDentifier");
   void Print(Option_t* opt = "") const override;
 
   static KVIDGraph* AddGraphs(KVIDGraph* g1, Int_t id1_min, Int_t id1_max,
                               KVIDGraph* g2, Int_t id2_min, Int_t id2_max);
   void SetRuns(const KVNumberList& nl);
 
   const Char_t* GetName() const override;
   virtual void WriteAsciiFile_WP(Int_t version = -1); //WP means with pattern
   virtual void ReadAsciiFile_WP(Int_t version = -1); //WP means with pattern
   virtual Int_t CheckVersion(Int_t version);
   virtual Bool_t ExistVersion(Int_t version)
   {
      if (version != -1) return (version == CheckVersion(version));
      else return (version != -1);
   }
   void SetPattern(TString pattern)
   {
      pattern.ReplaceAll(".", "_");
      fPattern = pattern;
   }
   TString GetPattern(void)
   {
      return fPattern;
   }
 
   const TList* GetIDTelescopes() const
   {
      return &fTelescopes;
   };
   void Increment(Float_t x)  // *SIGNAL*
   {
      Emit("Increment(Float_t)", x);
   }
   void Modified() // *SIGNAL*
   {
      Emit("Modified()");
   }
 
   const KVNumberList& GetRuns() const
   {
      return fRunList;
   }
   const Char_t* GetRunList() const
   {
      return (const char*)fRunList;
   }
   KVIDentifier* GetIdentifierAt(Int_t index) const
   {
      return (KVIDentifier*)fIdentifiers.At(index);
   }
   KVIDentifier* GetIdentifier(const Char_t* name) const
   {
      return (KVIDentifier*)fIdentifiers.FindObject(name);
   }
   KVIDentifier* GetCut(const Char_t* name) const
   {
      return (KVIDentifier*)fCuts.FindObject(name);
   }
   KVIDentifier* GetInfo(const Char_t* name) const
   {
      return (KVIDentifier*)fInfoZones.FindObject(name);
   }
   const KVNameValueList* GetParameters() const
   {
      return &fPar;
   }
   KVNameValueList* GetParameters()
   {
      return &fPar;
   }
   const KVList* GetIdentifiers() const
   {
      return &fIdentifiers;
   }
   KVList* GetIdentifiers()
   {
      return &fIdentifiers;
   }
   const KVList* GetCuts() const
   {
      return &fCuts;
   }
   KVList* GetCuts()
   {
      return &fCuts;
   }
   const KVList* GetInfos() const
   {
      return &fInfoZones;
   }
   KVList* GetInfos()
   {
      return &fInfoZones;
   }
   Int_t GetNumberOfIdentifiers() const
   {
      return fIdentifiers.GetSize();
   }
   Int_t GetNumberOfCuts() const
   {
      return fCuts.GetSize();
   }
   Int_t GetNumberOfInfos() const
   {
      return fInfoZones.GetSize();
   }
   virtual void AddIdentifier(KVIDentifier* id)
   {
      fIdentifiers.Add(id);
      id->SetParent(this);
      id->SetVarX(GetVarX());
      id->SetVarY(GetVarY());
      id->SetOnlyZId(IsOnlyZId());
      if (IsOnlyZId()) id->SetMassFormula(GetMassFormula());
   }
   virtual void AddCut(KVIDentifier* cut)
   {
      cut->SetLineColor(kRed);
      cut->SetParent(this);
      fCuts.Add(cut);
      cut->SetVarX(GetVarX());
      cut->SetVarY(GetVarY());
      cut->SetBit(kMustCleanup);
   }
   virtual void AddInfo(KVIDentifier* info)
   {
      info->SetLineColor(kBlue);
      info->SetParent(this);
      fInfoZones.Add(info);
      info->SetVarX(GetVarX());
      info->SetVarY(GetVarY());
      info->SetBit(kMustCleanup);
   }
   void SortIdentifiers()
   {
      fIdentifiers.Sort();
   }
   Bool_t IsSorted() const
   {
      return fIdentifiers.IsSorted();
   }
   Axis_t GetXmin() const
   {
      return fXmin;
   }
   Axis_t GetYmin() const
   {
      return fYmin;
   }
   Axis_t GetXmax() const
   {
      return fXmax;
   }
   Axis_t GetYmax() const
   {
      return fYmax;
   }
   virtual Int_t GetQualityCode() const
   {
      return 0;
   }
   void AddIDTelescope(KVBase* t)
   {
 
      fTelescopes.Add(t);
      Modified();
   }
   void RemoveIDTelescope(KVBase* t)
   {
 
      fTelescopes.Remove(t);
      Modified();
   }
   Bool_t HandlesIDTelescope(KVBase* t) const
   {
 
      return fTelescopes.Contains(t);
   }
   const Char_t* GetIDTelescopeLabel() const
   {
 
      KVBase* id = (KVBase*)fTelescopes.First();
      return (id ? id->GetLabel() : "");
   }
   Int_t GetMassFormula() const
   {
      return fMassFormula;
   }
   void ResetPad();
   void ClearPad(TVirtualPad*);
   TVirtualPad* IsDrawn() const
   {
      return fPad;
   }
   virtual void TestIdentification(TH2F* data, KVHashList& histos, KVNameValueList& histo_names);
 
   const Char_t* GetNamesOfIDTelescopes() const;
   void SetNamesOfIDTelescopes(const TString&);
 
   void      SetMaximum(Double_t maximum = -1111) override
   {
      TGraph::SetMaximum(maximum);
   }
   void      SetMinimum(Double_t minimum = -1111) override
   {
      TGraph::SetMinimum(minimum);
   }
   void      FitPanel() override
   {
      TGraph::FitPanel();
   }
   void      DrawPanel() override
   {
      TGraph::DrawPanel();
   }
 
   TFitResultPtr Fit(const char* formula, Option_t* option = "", Option_t* goption = "", Axis_t xmin = 0, Axis_t xmax = 0) override
   {
      return TGraph::Fit(formula, option, goption, xmin, xmax);
   }
   TFitResultPtr Fit(TF1* f1, Option_t* option = "", Option_t* goption = "", Axis_t xmin = 0, Axis_t xmax = 0) override
   {
      return TGraph::Fit(f1, option, goption, xmin, xmax);
   }
 
   void        Delete(Option_t* option = "") override
   {
      TGraph::Delete(option);
   }
   void        DrawClass() const override
   {
      TGraph::DrawClass();
   }
   TObject*    DrawClone(Option_t* option = "") const override
   {
      return TGraph::DrawClone(option);
   }
   void        Dump() const override
   {
      TGraph::Dump();
   }
   void        Inspect() const override
   {
      TGraph::Inspect();
   }
   void        SaveAs(const char* filename = "", Option_t* option = "") const override
   {
      TGraph::SaveAs(filename, option);
   }
   void        SetDrawOption(Option_t* option = "") override
   {
      TGraph::SetDrawOption(option);
   }
   void        SetLineAttributes() override
   {
      TGraph::SetLineAttributes();
   }
   void        SetFillAttributes() override
   {
      TGraph::SetFillAttributes();
   }
   void        SetMarkerAttributes() override
   {
      TGraph::SetMarkerAttributes();
   }
   void         SetVarX(const char* v) override
   {
      TCutG::SetVarX(v);
   }
   void         SetVarY(const char* v) override
   {
      TCutG::SetVarY(v);
   }
   Int_t         InsertPoint() override
   {
      return TCutG::InsertPoint();
   }
   Int_t         RemovePoint() override
   {
      return TCutG::RemovePoint();
   }
   Int_t         RemovePoint(Int_t i) override
   {
      return TCutG::RemovePoint(i);
   }
 
   ClassDefOverride(KVIDGraph, 2) //Base class for particle identification in a 2D map
};
 
#endif