[u/mrichter/AliRoot.git] / STEER / AliRunTag.h

#ifndef ALIRUNTAG_H
#define ALIRUNTAG_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */


/* $Id$ */

//-------------------------------------------------------------------------
//                          Class AliRunTag
//   This is the class to deal with the tags for the run level
//
//    Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
//-------------------------------------------------------------------------

#include <TObject.h>
#include <TString.h>
#include <TClonesArray.h>
#include "AliLHCTag.h"
#include "AliDetectorTag.h"
#include "AliFileTag.h"
#include "AliQA.h"

class AliEventTag;
//class AliDetectorTag;


//___________________________________________________________________________
class AliRunTag : public TObject {
 public:
  AliRunTag();
  virtual ~AliRunTag();
  AliRunTag(const AliRunTag& qa) ;   
  AliRunTag& operator = (const AliRunTag& tag) ;
  //____________________________________________________//
  void SetRunId(Int_t Pid) {fAliceRunId = Pid;}
  void SetMagneticField(Float_t Pmag) {fAliceMagneticField = Pmag;}
  void SetDipoleField(Float_t Pmag) {fAliceDipoleField = Pmag;}
  void SetRunStartTime(Int_t Pt0) {fAliceRunStartTime = Pt0;}
  void SetRunStopTime(Int_t Pt1) {fAliceRunStopTime = Pt1;}
  void SetAlirootVersion(TString v) {fAlirootVersion = v;}
  void SetRootVersion(TString v) {fRootVersion = v;}
  void SetGeant3Version(TString v) {fGeant3Version = v;}
  void SetLHCPeriod(TString v) {fLHCPeriod = v; }
  void SetReconstructionPass(TString v) {fRecPass = v; }
  void SetProductionName(TString v) {fProductionName = v; }
  void SetRunValidation(Bool_t val) {fAliceRunValidated = val; }
  void SetRunQuality(Int_t Pn) {fAliceRunGlobalQuality = Pn;}
  void SetBeamEnergy(Float_t PE) {fAliceBeamEnergy = PE;}
  void SetBeamType(TString Ptype) {fAliceBeamType = Ptype;}
  void SetCalibVersion(Int_t Pn) {fAliceCalibrationVersion = Pn;}
  void SetDataType(Int_t i) {fAliceDataType = i;}
/*   void SetNEvents(Int_t Pn) { fNumEvents = Pn; } */
  void SetBeamTriggers(ULong_t bt) { fBeamTriggers = bt; }
  void SetCollisionTriggers(ULong_t ct) { fCollisionTriggers = ct; }
  void SetEmptyTriggers(ULong_t et) {fEmptyTriggers = et; }
  void SetASideTriggers(ULong_t at) {fASideTriggers = at; }
  void SetCSideTriggers(ULong_t ct) {fCSideTriggers = ct; }
  void SetHMTriggers(ULong_t ht) {fHMTriggers = ht; }
  void SetMuonTriggers(ULong_t mt) {fMuonTriggers = mt; }
  void SetCollisionRate(Float_t rate) {fCollisionRate = rate; }
  void SetMeanVertex(Float_t mv) {fMeanVertex = mv; }
  void SetVertexQuality(Float_t vq) {fVertexQuality = vq; }
  void SetLHCTag(Float_t Plumin, TString type);
  void SetDetectorTag(UInt_t mask, UInt_t maskReco=0);
  void SetQA(const AliQA &qa) { fQA=qa; }  	
  void SetQAArray(ULong_t * qa, Int_t qalength) ; 
  void SetEventSpecies(Bool_t * es, Int_t eslength) ;
  void AddEventTag(const AliEventTag &t);
  void Clear(const char * opt = "");
  void AddFileTag(AliFileTag *t);

  void SetActiveTriggerClasses(TString str) { fActiveTriggerClasses = str; }

  void CopyStandardContent(AliRunTag *oldtag);
  void UpdateFromRunTable(AliRunTag *tabtag);

  //____________________________________________________//
  Int_t       GetRunId() const {return fAliceRunId;}
  Float_t     GetMagneticField() const {return fAliceMagneticField;}
  Float_t     GetDipoleField() const {return fAliceDipoleField;}
  Int_t       GetRunStartTime() const {return fAliceRunStartTime;}
  Int_t       GetRunStopTime() const {return fAliceRunStopTime;}
  const char* GetAlirootVersion() const {return fAlirootVersion.Data();}
  const char* GetRootVersion() const {return fRootVersion.Data();}
  const char* GetGeant3Version() const {return fGeant3Version.Data();}
  const char* GetLHCPeriod() const {return fLHCPeriod.Data();}
  const char* GetReconstructionPass() const {return fRecPass.Data();}
  const char* GetProductionName() const {return fProductionName.Data();}
  Bool_t      GetRunValidation() const {return fAliceRunValidated;}
  Int_t       GetRunQuality() const {return fAliceRunGlobalQuality;}
  Float_t     GetBeamEnergy() const {return fAliceBeamEnergy;}
  const char *GetBeamType() const {return fAliceBeamType.Data();}
  Int_t       GetCalibVersion() const {return fAliceCalibrationVersion;}
  Int_t       GetDataType() const {return fAliceDataType;}
  Int_t       GetNEvents() const;
  ULong_t     GetBeamTriggers() const {return fBeamTriggers;}
  ULong_t     GetCollisionTriggers() const {return fCollisionTriggers;}
  ULong_t     GetEmptyTriggers() const {return fEmptyTriggers;}
  ULong_t     GetASideTriggers() const {return fASideTriggers;}
  ULong_t     GetCSideTriggers() const {return fCSideTriggers;}
  ULong_t     GetHMTriggers() const {return fHMTriggers;}
  ULong_t     GetMuonTriggers() const {return fMuonTriggers;}
  Float_t     GetCollisionRate() const {return fCollisionRate;}
  Float_t     GetMeanVertex() const {return fMeanVertex;}
  Float_t     GetVertexQuality() const {return fVertexQuality;}
  AliLHCTag  *GetLHCTag() {return &fLHCTag; } 
  AliDetectorTag *GetDetectorTags() {return &fDetectorTag;}
  //  const TClonesArray *GetEventTags() const {return &fEventTag;}
  const AliEventTag* GetEventTag(int evt) const;
  AliFileTag *GetFileTagForEvent(int evt);
  Int_t       GetNFiles() const { return fFileTags.GetEntries(); }
  AliFileTag *GetFileTag(Int_t ifile) const {return (AliFileTag *) fFileTags.At(ifile);}
  const AliQA *GetQA() const {return &fQA;}
  ULong_t *  GetQAArray() const {return fQAArray;}	
  Int_t      GetQALength() const { return fQALength ; }
  Bool_t *   GetEventSpecies() const {return fEventSpecies;}	
  Int_t      GetESLength() const { return fESLength ; }
  Int_t      GetFileId(const char *guid);
  
  TString    GetActiveTriggerClasses() const {return fActiveTriggerClasses; }

  //____________________________________________________//
 private:
  Int_t        fAliceRunId;              //the run id
  Float_t      fAliceMagneticField;      //value of the magnetic field
  Float_t      fAliceDipoleField;        //value of the magnetic field in dipole
  Int_t        fAliceRunStartTime;       //run start date
  Int_t        fAliceRunStopTime;        //run stop date
  TString      fAlirootVersion;          //aliroot version
  TString      fRootVersion;             //root version
  TString      fGeant3Version;           //geant3 version
  TString      fLHCPeriod;               //datataking period
  TString      fRecPass;                 //Reconstruction pass number
  TString      fProductionName;          //production name
  Bool_t       fAliceRunValidated;       //validation script
  Int_t        fAliceRunGlobalQuality;   //validation script
  Float_t      fAliceBeamEnergy;         //beam energy cm
  TString      fAliceBeamType;           //run type (pp, AA, pA)
  Int_t        fAliceCalibrationVersion; //calibration version  
  Int_t        fAliceDataType;           //0: simulation -- 1: data  
/*   Int_t        fNumEvents;               //number of events per file */
  Int_t        fNumFiles;                //number of files in the run
  ULong_t      fBeamTriggers;            //number of beam triggers in run (CBEAMB)
  ULong_t      fCollisionTriggers;       //number of collision triggers in run (CINT1-B)
  ULong_t      fEmptyTriggers;           //number of empty triggers in run (CINT1-E)
  ULong_t      fASideTriggers;           //number of A-side triggers in run (CINT1-A)
  ULong_t      fCSideTriggers;           //number of C-side triggers in run (CINT1-C)
  ULong_t      fHMTriggers;              //number of High-Mult triggers
  ULong_t      fMuonTriggers;            //number of Muon Triggers
  Float_t      fCollisionRate;           //Average collision rate
  Float_t      fMeanVertex;              //mean vertex position
  Float_t      fVertexQuality;           //vertex quality
  Int_t        fNumDetectors;            //number of detector configs per file
  //  TClonesArray fEventTag;                //array with all event tags
  //  TClonesArray fFileTags;                //array of file tags
  //  AliFileTag **fFileTags;                //array of file tags
  TObjArray    fFileTags;                //array of file tags
  AliDetectorTag fDetectorTag;           //array with all the detector tags
  AliLHCTag    fLHCTag;                  //LHC tag object
  TString      fActiveTriggerClasses;    //Active trigger classes for run
  AliQA        fQA;                      //needed for backward compaibility
  Int_t        fQALength;                // Length of the fQA array  
  ULong_t *    fQAArray ;                //[fQALength] QA objects's data	
  Int_t        fESLength;                // Length of the Event Specie Length
  Bool_t *     fEventSpecies;            //[fESLength] EventSpecies in this run	
  

  ClassDef(AliRunTag,9)  //(ClassName, ClassVersion)
};
//___________________________________________________________________________

#endif
Commit	Line	Data
f3a97c86	1	#ifndef ALIRUNTAG_H
	2	#define ALIRUNTAG_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6
	7	/* $Id$ */
	8
	9	//-------------------------------------------------------------------------
	10	// Class AliRunTag
	11	// This is the class to deal with the tags for the run level
	12	//
	13	// Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
	14	//-------------------------------------------------------------------------
	15
17a9d008	16	#include <TObject.h>
	17	#include <TString.h>
	18	#include <TClonesArray.h>
f3a97c86	19	#include "AliLHCTag.h"
c5caed45	20	#include "AliDetectorTag.h"
04cb11d4	21	#include "AliFileTag.h"
9ee5d033	22	#include "AliQA.h"
e16601cf	23
e16601cf	24	class AliEventTag;
c5caed45	25	//class AliDetectorTag;
f3a97c86	26
f3a97c86	27
bec9a2e7	28	//___________________________________________________________________________
bec9a2e7	29	class AliRunTag : public TObject {
f3a97c86	30	public:
	31	AliRunTag();
	32	virtual ~AliRunTag();
27293674	33	AliRunTag(const AliRunTag& qa) ;
27293674	34	AliRunTag& operator = (const AliRunTag& tag) ;
bec9a2e7	35	//____________________________________________________//
	36	void SetRunId(Int_t Pid) {fAliceRunId = Pid;}
	37	void SetMagneticField(Float_t Pmag) {fAliceMagneticField = Pmag;}
850d5792	38	void SetDipoleField(Float_t Pmag) {fAliceDipoleField = Pmag;}
bec9a2e7	39	void SetRunStartTime(Int_t Pt0) {fAliceRunStartTime = Pt0;}
	40	void SetRunStopTime(Int_t Pt1) {fAliceRunStopTime = Pt1;}
	41	void SetAlirootVersion(TString v) {fAlirootVersion = v;}
	42	void SetRootVersion(TString v) {fRootVersion = v;}
	43	void SetGeant3Version(TString v) {fGeant3Version = v;}
850d5792	44	void SetLHCPeriod(TString v) {fLHCPeriod = v; }
	45	void SetReconstructionPass(TString v) {fRecPass = v; }
	46	void SetProductionName(TString v) {fProductionName = v; }
04cb11d4	47	void SetRunValidation(Bool_t val) {fAliceRunValidated = val; }
04cb11d4	48	void SetRunQuality(Int_t Pn) {fAliceRunGlobalQuality = Pn;}
bec9a2e7	49	void SetBeamEnergy(Float_t PE) {fAliceBeamEnergy = PE;}
	50	void SetBeamType(TString Ptype) {fAliceBeamType = Ptype;}
	51	void SetCalibVersion(Int_t Pn) {fAliceCalibrationVersion = Pn;}
	52	void SetDataType(Int_t i) {fAliceDataType = i;}
04cb11d4	53	/* void SetNEvents(Int_t Pn) { fNumEvents = Pn; } */
	54	void SetBeamTriggers(ULong_t bt) { fBeamTriggers = bt; }
	55	void SetCollisionTriggers(ULong_t ct) { fCollisionTriggers = ct; }
	56	void SetEmptyTriggers(ULong_t et) {fEmptyTriggers = et; }
	57	void SetASideTriggers(ULong_t at) {fASideTriggers = at; }
	58	void SetCSideTriggers(ULong_t ct) {fCSideTriggers = ct; }
	59	void SetHMTriggers(ULong_t ht) {fHMTriggers = ht; }
	60	void SetMuonTriggers(ULong_t mt) {fMuonTriggers = mt; }
	61	void SetCollisionRate(Float_t rate) {fCollisionRate = rate; }
	62	void SetMeanVertex(Float_t mv) {fMeanVertex = mv; }
	63	void SetVertexQuality(Float_t vq) {fVertexQuality = vq; }
c5caed45	64	void SetLHCTag(Float_t Plumin, TString type);
3ace8f92	65	void SetDetectorTag(UInt_t mask, UInt_t maskReco=0);
9ee5d033	66	void SetQA(const AliQA &qa) { fQA=qa; }
9ee5d033	67	void SetQAArray(ULong_t * qa, Int_t qalength) ;
27293674	68	void SetEventSpecies(Bool_t * es, Int_t eslength) ;
bec9a2e7	69	void AddEventTag(const AliEventTag &t);
bec9a2e7	70	void Clear(const char * opt = "");
04cb11d4	71	void AddFileTag(AliFileTag *t);
	72
	73	void SetActiveTriggerClasses(TString str) { fActiveTriggerClasses = str; }
4c117ffd	74
4c117ffd	75	void CopyStandardContent(AliRunTag *oldtag);
04cb11d4	76	void UpdateFromRunTable(AliRunTag *tabtag);
04cb11d4	77
bec9a2e7	78	//____________________________________________________//
	79	Int_t GetRunId() const {return fAliceRunId;}
	80	Float_t GetMagneticField() const {return fAliceMagneticField;}
850d5792	81	Float_t GetDipoleField() const {return fAliceDipoleField;}
bec9a2e7	82	Int_t GetRunStartTime() const {return fAliceRunStartTime;}
	83	Int_t GetRunStopTime() const {return fAliceRunStopTime;}
	84	const char* GetAlirootVersion() const {return fAlirootVersion.Data();}
	85	const char* GetRootVersion() const {return fRootVersion.Data();}
	86	const char* GetGeant3Version() const {return fGeant3Version.Data();}
850d5792	87	const char* GetLHCPeriod() const {return fLHCPeriod.Data();}
	88	const char* GetReconstructionPass() const {return fRecPass.Data();}
	89	const char* GetProductionName() const {return fProductionName.Data();}
04cb11d4	90	Bool_t GetRunValidation() const {return fAliceRunValidated;}
04cb11d4	91	Int_t GetRunQuality() const {return fAliceRunGlobalQuality;}
bec9a2e7	92	Float_t GetBeamEnergy() const {return fAliceBeamEnergy;}
	93	const char *GetBeamType() const {return fAliceBeamType.Data();}
	94	Int_t GetCalibVersion() const {return fAliceCalibrationVersion;}
	95	Int_t GetDataType() const {return fAliceDataType;}
04cb11d4	96	Int_t GetNEvents() const;
	97	ULong_t GetBeamTriggers() const {return fBeamTriggers;}
	98	ULong_t GetCollisionTriggers() const {return fCollisionTriggers;}
	99	ULong_t GetEmptyTriggers() const {return fEmptyTriggers;}
	100	ULong_t GetASideTriggers() const {return fASideTriggers;}
	101	ULong_t GetCSideTriggers() const {return fCSideTriggers;}
	102	ULong_t GetHMTriggers() const {return fHMTriggers;}
	103	ULong_t GetMuonTriggers() const {return fMuonTriggers;}
	104	Float_t GetCollisionRate() const {return fCollisionRate;}
	105	Float_t GetMeanVertex() const {return fMeanVertex;}
	106	Float_t GetVertexQuality() const {return fVertexQuality;}
bec9a2e7	107	AliLHCTag *GetLHCTag() {return &fLHCTag; }
c5caed45	108	AliDetectorTag *GetDetectorTags() {return &fDetectorTag;}
04cb11d4	109	// const TClonesArray *GetEventTags() const {return &fEventTag;}
	110	const AliEventTag* GetEventTag(int evt) const;
	111	AliFileTag *GetFileTagForEvent(int evt);
	112	Int_t GetNFiles() const { return fFileTags.GetEntries(); }
	113	AliFileTag GetFileTag(Int_t ifile) const {return (AliFileTag ) fFileTags.At(ifile);}
9ee5d033	114	const AliQA *GetQA() const {return &fQA;}
9ee5d033	115	ULong_t * GetQAArray() const {return fQAArray;}
27293674	116	Int_t GetQALength() const { return fQALength ; }
	117	Bool_t * GetEventSpecies() const {return fEventSpecies;}
	118	Int_t GetESLength() const { return fESLength ; }
04cb11d4	119	Int_t GetFileId(const char *guid);
46af88be	120
04cb11d4	121	TString GetActiveTriggerClasses() const {return fActiveTriggerClasses; }
04cb11d4	122
bec9a2e7	123	//____________________________________________________//
e16601cf	124	private:
bec9a2e7	125	Int_t fAliceRunId; //the run id
bec9a2e7	126	Float_t fAliceMagneticField; //value of the magnetic field
850d5792	127	Float_t fAliceDipoleField; //value of the magnetic field in dipole
bec9a2e7	128	Int_t fAliceRunStartTime; //run start date
	129	Int_t fAliceRunStopTime; //run stop date
	130	TString fAlirootVersion; //aliroot version
	131	TString fRootVersion; //root version
	132	TString fGeant3Version; //geant3 version
850d5792	133	TString fLHCPeriod; //datataking period
	134	TString fRecPass; //Reconstruction pass number
	135	TString fProductionName; //production name
04cb11d4	136	Bool_t fAliceRunValidated; //validation script
04cb11d4	137	Int_t fAliceRunGlobalQuality; //validation script
bec9a2e7	138	Float_t fAliceBeamEnergy; //beam energy cm
	139	TString fAliceBeamType; //run type (pp, AA, pA)
	140	Int_t fAliceCalibrationVersion; //calibration version
	141	Int_t fAliceDataType; //0: simulation -- 1: data
04cb11d4	142	/* Int_t fNumEvents; //number of events per file */
	143	Int_t fNumFiles; //number of files in the run
	144	ULong_t fBeamTriggers; //number of beam triggers in run (CBEAMB)
	145	ULong_t fCollisionTriggers; //number of collision triggers in run (CINT1-B)
	146	ULong_t fEmptyTriggers; //number of empty triggers in run (CINT1-E)
	147	ULong_t fASideTriggers; //number of A-side triggers in run (CINT1-A)
	148	ULong_t fCSideTriggers; //number of C-side triggers in run (CINT1-C)
	149	ULong_t fHMTriggers; //number of High-Mult triggers
	150	ULong_t fMuonTriggers; //number of Muon Triggers
	151	Float_t fCollisionRate; //Average collision rate
	152	Float_t fMeanVertex; //mean vertex position
	153	Float_t fVertexQuality; //vertex quality
bec9a2e7	154	Int_t fNumDetectors; //number of detector configs per file
04cb11d4	155	// TClonesArray fEventTag; //array with all event tags
	156	// TClonesArray fFileTags; //array of file tags
	157	// AliFileTag **fFileTags; //array of file tags
	158	TObjArray fFileTags; //array of file tags
46af88be	159	AliDetectorTag fDetectorTag; //array with all the detector tags
bec9a2e7	160	AliLHCTag fLHCTag; //LHC tag object
04cb11d4	161	TString fActiveTriggerClasses; //Active trigger classes for run
9ee5d033	162	AliQA fQA; //needed for backward compaibility
27293674	163	Int_t fQALength; // Length of the fQA array
9ee5d033	164	ULong_t * fQAArray ; //[fQALength] QA objects's data
27293674	165	Int_t fESLength; // Length of the Event Specie Length
04cb11d4	166	Bool_t * fEventSpecies; //[fESLength] EventSpecies in this run
e16601cf	167
04cb11d4	168
04cb11d4	169	ClassDef(AliRunTag,9) //(ClassName, ClassVersion)
f3a97c86	170	};
bec9a2e7	171	//___________________________________________________________________________
f3a97c86	172
f3a97c86	173	#endif