KVIDentifier.h

/*
$Id: KVIDentifier.h,v 1.7 2009/04/20 10:01:58 ebonnet Exp $
$Revision: 1.7 $
$Date: 2009/04/20 10:01:58 $
*/
 
 
#ifndef __KVIDENTIFIER_H
#define __KVIDENTIFIER_H
 
#include "Riostream.h"
#include "TCutG.h"
#include "KVNucleus.h"
#include "RVersion.h"
 
class TF1;
class KVIDGraph;
 
class KVIDentifier : public TCutG {
   friend class KVIDGraph;
 
protected:
    KVIDGraph* fParent;
    KVNucleus fIon;
    Bool_t fGridOnlyZId;
 
    Int_t fZ;
    Int_t fA;
    Int_t fMassFormula;
 
   virtual void WriteAsciiFile_extras(std::ofstream&, const Char_t* /*name_prefix*/ = "") {}
 
   virtual void ReadAsciiFile_extras(std::ifstream&) {}
   virtual void SetNameFromNucleus()
   {
      SetName(Form("Z=%d A=%d", GetZ(), GetA()));
   }
 
private:
   void init();
 
public:
   KVIDentifier();
   KVIDentifier(const KVIDentifier&);
   KVIDentifier(const TCutG&);
   KVIDentifier(const TGraph&);
   virtual ~KVIDentifier();
 
   KVIDGraph*  GetParent()     const;
   void        SetParent(KVIDGraph*);
 
   Int_t Compare(const TObject*) const override;
   void Copy(TObject& obj) const override;
 
   virtual void WriteAsciiFile(std::ofstream&, const Char_t* name_prefix = "");
   virtual void ReadAsciiFile(std::ifstream&);
 
   virtual Int_t GetID() const
   {
      return 0;
   }
   virtual Int_t GetA() const
   {
      return fIon.GetA();
   }
   virtual Int_t GetZ() const
   {
      return fIon.GetZ();
   }
   virtual void SetZ(Int_t ztnum)
   {
      fIon.SetZ(ztnum);
      SetNameFromNucleus();
   } // *MENU={Hierarchy="SetNucleus.../Z"}*
   virtual void SetA(Int_t atnum)
   {
      fIon.SetA(atnum);
      SetNameFromNucleus();
   }  // *MENU={Hierarchy="SetNucleus.../A"}*
   virtual void SetAandZ(Int_t atnum, Int_t ztnum)
   {
      fIon.SetZ(ztnum);
      fIon.SetA(atnum);
      SetNameFromNucleus();
   }  // *MENU={Hierarchy="SetNucleus.../A and Z"}* *ARGS={atnum=>fA,ztnum=>fZ}
   virtual void SetOnlyZId(Bool_t onlyz = kTRUE)
   {
      fGridOnlyZId = onlyz;
   };
   virtual Bool_t OnlyZId()const
   {
      return fGridOnlyZId;
   }
   virtual void SetMassFormula(Int_t mf)
   {
      if (OnlyZId()) {
         fIon.SetMassFormula(mf);
         fMassFormula = mf;
         SetNameFromNucleus();
      }
   }   // *SUBMENU={Hierarchy="SetNucleus.../Mass Formula"}*
   virtual Int_t GetMassFormula()const
   {
      return fIon.GetMassFormula();
   }
 
   virtual Bool_t TestPoint(Double_t /*x*/, Double_t /*y*/)
   {
 
      AbstractMethod("TestMethod(Double_t x, Double_t y");
      return kFALSE;
   }
 
   void CopyGraph(TGraph*);
   void CopyGraph(const TGraph&);
 
   void Scale(Double_t sx = -1, Double_t sy = -1);
   void Scale(TF1* sx, TF1* sy);
 
   void Print(Option_t* opt) const override;
 
   virtual void WaitForPrimitive();
 
   void ExtendLine(Double_t, Option_t* Direction = ""); // *MENU={Hierarchy="Modify Line.../ExtendLine"}*
   void ExtendLine(bool fromBeginning, Double_t Limit, Option_t* Direction);
 
   void      SetMaximum(Double_t maximum = -1111) override
   {
      TGraph::SetMaximum(maximum);
   };
   void      SetMinimum(Double_t minimum = -1111) override
   {
      TGraph::SetMinimum(minimum);
   };
   void      SetTitle(const char* title = "") override
   {
      TGraph::SetTitle(title);
   };
   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     SetName(const char* name) override;
   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);
   };
   virtual void        CloneScaleStore(Int_t newzt, Int_t newat, Double_t dy = 0., Double_t sx = 1., Double_t sy = 1.); // *MENU* *ARGS={newat=>fA,newzt=>fZ}
   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();
   };
 
   Int_t         InsertPoint() override; // *MENU={Hierarchy="Modify Line.../InsertPoint"}*
   virtual Int_t         AddPointAtTheEnd(); // *MENU={Hierarchy="Modify Line.../AddPointAtTheEnd"}*
   virtual Int_t         RemoveFirstPoint(); // *MENU={Hierarchy="Modify Line.../RemoveFirstPoint"}*
   virtual Int_t         RemoveLastPoint(); // *MENU={Hierarchy="Modify Line.../RemoveLastPoint"}*
   virtual Int_t         IncreaseNumberOfPoints(); // *MENU*
   virtual Int_t         DecreaseNumberOfPoints(); // *MENU*
   virtual Int_t         SortPoints(Bool_t ascending = kTRUE); // *MENU*
   virtual Int_t         ContinueDrawing(); // *MENU={Hierarchy="Modify Line.../ContinueDrawing"}*
   virtual void         ChechHierarchy(KVIDentifier* gr);
   virtual Int_t         RemovePoint() override; // *MENU={Hierarchy="Modify Line.../RemovePoint"}*
   virtual Int_t         RemovePoint(Int_t i) override
   {
      return TCutG::RemovePoint(i);
   }
 
   virtual Int_t         InsertSmoothPoint(); // *MENU*
 
 
   virtual Double_t GetPID() const;
 
   ClassDefOverride(KVIDentifier, 2) //Base class for graphical cuts used in particle identification
};
 
#endif