+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
-
-// Last update: Nov. 5th 2013
+//-------------------------------------------------------------------------
+// Container class for ESD AD data
+// Author: Brigitte Cheynis & Cvetan Cheshkov
+//-------------------------------------------------------------------------
#include "AliESDAD.h"
+#include "AliLog.h"
ClassImp(AliESDAD)
-AliESDAD::AliESDAD():TObject()
-{
- //Default constructor
- for(Int_t i=0;i<16;i++)
- {
- fADCellID[i] = 0;
- }
+//__________________________________________________________________________
+AliESDAD::AliESDAD()
+ :AliVAD(),
+ fBBtriggerADA(0),
+ fBGtriggerADA(0),
+ fBBtriggerADC(0),
+ fBGtriggerADC(0),
+ fADATime(-1024),
+ fADCTime(-1024),
+ fADATimeError(0),
+ fADCTimeError(0),
+ fADADecision(kADInvalid),
+ fADCDecision(kADInvalid),
+ fTriggerChargeA(0),
+ fTriggerChargeC(0),
+ fTriggerBits(0)
+{
+ // Default constructor
+ for(Int_t j=0; j<16; j++){
+ fMultiplicity[j] = 0.0;
+ fAdc[j] = 0.0;
+ fTime[j] = 0.0;
+ fWidth[j] = 0.0;
+ fBBFlag[j]= kFALSE;
+ fBGFlag[j]= kFALSE;
+ }
}
-
+//__________________________________________________________________________
AliESDAD::AliESDAD(const AliESDAD &o)
- :TObject(o)
-
-{
- //Default constructor
- for(Int_t i=0;i<16;i++)
- {
- fADCellID[i] = o.fADCellID[i];
- }
+ :AliVAD(o),
+ fBBtriggerADA(o.fBBtriggerADA),
+ fBGtriggerADA(o.fBGtriggerADA),
+ fBBtriggerADC(o.fBBtriggerADC),
+ fBGtriggerADC(o.fBGtriggerADC),
+ fADATime(o.fADATime),
+ fADCTime(o.fADCTime),
+ fADATimeError(o.fADATimeError),
+ fADCTimeError(o.fADCTimeError),
+ fADADecision(o.fADADecision),
+ fADCDecision(o.fADCDecision),
+ fTriggerChargeA(o.fTriggerChargeA),
+ fTriggerChargeC(o.fTriggerChargeC),
+ fTriggerBits(o.fTriggerBits)
+{
+ // Default constructor
+ for(Int_t j=0; j<16; j++) {
+ fMultiplicity[j] = o.fMultiplicity[j];
+ fAdc[j] = o.fAdc[j];
+ fTime[j] = o.fTime[j];
+ fWidth[j] = o.fWidth[j];
+ fBBFlag[j] = o.fBBFlag[j];
+ fBGFlag[j] = o.fBGFlag[j];
+ }
}
-
-AliESDAD::AliESDAD(Bool_t* MADBitCell):TObject()
+//__________________________________________________________________________
+AliESDAD::AliESDAD(UInt_t BBtriggerADA, UInt_t BGtriggerADA,
+ UInt_t BBtriggerADC, UInt_t BGtriggerADC,
+ Float_t *Multiplicity, Float_t *Adc,
+ Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag)
+ :AliVAD(),
+ fBBtriggerADA(BBtriggerADA),
+ fBGtriggerADA(BGtriggerADA),
+ fBBtriggerADC(BBtriggerADC),
+ fBGtriggerADC(BGtriggerADC),
+ fADATime(-1024),
+ fADCTime(-1024),
+ fADATimeError(0),
+ fADCTimeError(0),
+ fADADecision(kADInvalid),
+ fADCDecision(kADInvalid),
+ fTriggerChargeA(0),
+ fTriggerChargeC(0),
+ fTriggerBits(0)
{
-
- //Constructor
-
- for(Int_t i=0;i<16;i++)
- {
- fADCellID[i] = MADBitCell[i];
- }
+ // Constructor
+ for(Int_t j=0; j<16; j++) {
+ fMultiplicity[j] = Multiplicity[j];
+ fAdc[j] = Adc[j];
+ fTime[j] = Time[j];
+ fWidth[j] = Width[j];
+ fBBFlag[j] = BBFlag[j];
+ fBGFlag[j] = BGFlag[j];
+ }
}
+//__________________________________________________________________________
AliESDAD& AliESDAD::operator=(const AliESDAD& o)
{
-// Copy Constructor
- if(this==&o)return *this;
- TObject::operator=(o);
- // Assignment operator
- for(Int_t i=0; i<16; i++)
- {
- fADCellID[i] = o.fADCellID[i];
- }
-
- return *this;
-}
+ if(this==&o) return *this;
+ AliVAD::operator=(o);
+ // Assignment operator
+ fBBtriggerADA=o.fBBtriggerADA;
+ fBGtriggerADA=o.fBGtriggerADA;
+ fBBtriggerADC=o.fBBtriggerADC;
+ fBGtriggerADC=o.fBGtriggerADC;
+ fADATime = o.fADATime;
+ fADCTime = o.fADCTime;
+ fADATimeError = o.fADATimeError;
+ fADCTimeError = o.fADCTimeError;
+ fADADecision = o.fADADecision;
+ fADCDecision = o.fADCDecision;
+ fTriggerChargeA = o.fTriggerChargeA;
+ fTriggerChargeC = o.fTriggerChargeC;
+ fTriggerBits = o.fTriggerBits;
-Bool_t AliESDAD::GetADCell(Int_t i) const
-{
- return fADCellID[i];
+ for(Int_t j=0; j<16; j++) {
+ fMultiplicity[j] = o.fMultiplicity[j];
+ fAdc[j] = o.fAdc[j];
+ fTime[j] = o.fTime[j];
+ fWidth[j] = o.fWidth[j];
+ fBBFlag[j] = o.fBBFlag[j];
+ fBGFlag[j] = o.fBGFlag[j];
+ }
+ return *this;
}
+//______________________________________________________________________________
void AliESDAD::Copy(TObject &obj) const {
// this overwrites the virtual TOBject::Copy()
}
+//__________________________________________________________________________
+Short_t AliESDAD::GetNbPMADA() const
+{
+ // Returns the number of
+ // fired PM in ADA
+ Short_t n=0;
+ for(Int_t i=8;i<16;i++)
+ if (fMultiplicity[i]>0) n++;
+ return n;
+}
+
+//__________________________________________________________________________
+Short_t AliESDAD::GetNbPMADC() const
+{
+ // Returns the number of
+ // fired PM in ADC
+ Short_t n=0;
+ for(Int_t i=0;i<8;i++)
+ if (fMultiplicity[i]>0) n++;
+ return n;
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetMTotADA() const
+{
+ // returns total multiplicity
+ // in ADA
+ Float_t mul=0.0;
+ for(Int_t i=8;i<16;i++)
+ mul+= fMultiplicity[i];
+ return mul;
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetMTotADC() const
+{
+ // returns total multiplicity
+ // in ADC
+ Float_t mul=0.0;
+ for(Int_t i=0;i<8;i++)
+ mul+= fMultiplicity[i];
+ return mul;
+}
+
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetMultiplicity(Int_t i) const
+
+{
+ // returns multiplicity in a
+ // given cell of AD
+ if (OutOfRange(i, "AliESDAD::GetMultiplicity:",16)) return -1;
+ return fMultiplicity[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetMultiplicityADA(Int_t i) const
+
+{
+ // returns multiplicity in a
+ // given cell of ADA
+ if (OutOfRange(i, "AliESDAD::GetMultiplicityADA:",8)) return -1;
+ return fMultiplicity[8+i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetMultiplicityADC(Int_t i) const
+
+{
+ // returns multiplicity in a
+ // given cell of ADC
+ if (OutOfRange(i, "AliESDAD::GetMultiplicityADC:",8)) return -1;
+ return fMultiplicity[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetAdc(Int_t i) const
+
+{
+ // returns ADC charge in a
+ // given cell of AD
+ if (OutOfRange(i, "AliESDAD::GetAdc:",16)) return -1;
+ return fAdc[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetAdcADA(Int_t i) const
+
+{
+ // returns ADC charge in a
+ // given cell of ADA
+ if (OutOfRange(i, "AliESDAD::GetAdcADA:",8)) return -1;
+ return fAdc[8+i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetAdcADC(Int_t i) const
+
+{
+ // returns ADC charge in a
+ // given cell of ADC
+ if (OutOfRange(i, "AliESDAD::GetAdcADC:",8)) return -1;
+ return fAdc[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetTime(Int_t i) const
+
+{
+ // returns leading time measured by TDC
+ // in a given cell of AD
+ if (OutOfRange(i, "AliESDAD::GetTime:",16)) return -1;
+ return fTime[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetTimeADA(Int_t i) const
+
+{
+ // returns leading time measured by TDC
+ // in a given cell of ADA
+ if (OutOfRange(i, "AliESDAD::GetTimeADA:",8)) return -1;
+ return fTime[8+i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetTimeADC(Int_t i) const
+
+{
+ // returns leading time measured by TDC
+ // in a given cell of ADC
+ if (OutOfRange(i, "AliESDAD::GetTimeADC:",8)) return -1;
+ return fTime[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetWidth(Int_t i) const
+
+{
+ // returns time signal width
+ // in a given cell of AD
+ if (OutOfRange(i, "AliESDAD::GetWidth:",16)) return -1;
+ return fWidth[i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetWidthADA(Int_t i) const
+
+{
+ // returns time signal width
+ // in a given cell of ADA
+ if (OutOfRange(i, "AliESDAD::GetWidthADA:",8)) return -1;
+ return fWidth[8+i];
+}
+
+//__________________________________________________________________________
+Float_t AliESDAD::GetWidthADC(Int_t i) const
+{
+ // returns time signal width
+ // in a given cell of ADC
+ if (OutOfRange(i, "AliESDAD::GetWidthADC:",8)) return -1;
+ return fWidth[i];
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::BBTriggerADA(Int_t i) const
+{
+ // returns offline beam-beam flags in ADA
+ // one bit per cell
+ if (OutOfRange(i, "AliESDAD:::BBTriggerADA",8)) return kFALSE;
+ UInt_t test = 1;
+ return ( fBBtriggerADA & (test << i) ? kTRUE : kFALSE );
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::BGTriggerADA(Int_t i) const
+{
+ // returns offline beam-gas flags in ADA
+ // one bit per cell
+ if (OutOfRange(i, "AliESDAD:::BGTriggerADA",8)) return kFALSE;
+ UInt_t test = 1;
+ return ( fBGtriggerADA & (test << i) ? kTRUE : kFALSE );
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::BBTriggerADC(Int_t i) const
+{
+ // returns offline beam-beam flags in ADC
+ // one bit per cell
+ if (OutOfRange(i, "AliESDAD:::BBTriggerADC",8)) return kFALSE;
+ UInt_t test = 1;
+ return ( fBBtriggerADC & (test << i) ? kTRUE : kFALSE );
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::BGTriggerADC(Int_t i) const
+{
+ // returns offline beam-gasflags in ADC
+ // one bit per cell
+ if (OutOfRange(i, "AliESDAD:::BGTriggerADC",8)) return kFALSE;
+ UInt_t test = 1;
+ return ( fBGtriggerADC & (test << i) ? kTRUE : kFALSE );
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::GetBBFlag(Int_t i) const
+
+{
+ // returns online beam-beam flag in AD
+ // one boolean per cell
+ if (OutOfRange(i, "AliESDAD::GetBBFlag:",16)) return kFALSE;
+ return fBBFlag[i];
+}
+
+//__________________________________________________________________________
+Bool_t AliESDAD::GetBGFlag(Int_t i) const
+
+{
+ // returns online beam-gas flag in AD
+ // one boolean per cell
+ if (OutOfRange(i, "AliESDAD::GetBGFlag:",16)) return kFALSE;
+ return fBGFlag[i];
+}
-#ifndef AliESDAD_H
-#define AliESDAD_H
+#ifndef ALIESDAD_H
+#define ALIESDAD_H
-#include <TObject.h>
-// Send comments to:
-// Mario Rodriguez <mrodriguez@fis.cinvestav.mx>
+//-------------------------------------------------------------------------
+// Container class for ESD AD data
+// Author: Brigitte Cheynis & Cvetan Cheshkov
+//-------------------------------------------------------------------------
-class AliESDAD : public TObject
-{
+#include <AliVAD.h>
- public:
+class AliESDAD : public AliVAD
+{
+public:
AliESDAD();
- AliESDAD(const AliESDAD&);
- AliESDAD(Bool_t *ADBitCell);
+ AliESDAD(const AliESDAD&o);
+ AliESDAD(UInt_t BBtriggerADA, UInt_t BGtriggerADA,
+ UInt_t BBtriggerADC, UInt_t BGtriggerADC,
+ Float_t *Multiplicity, Float_t *Adc,
+ Float_t *Time, Float_t *Width, Bool_t *BBFlag, Bool_t *BGFlag);
+ void Copy(TObject &obj) const;
+
virtual ~AliESDAD() {};
- virtual void Copy(TObject &) const;
- // We define the "setters" for AD
- // fake bit pattern, but enought to MC studies
- void SetADBitCell(Bool_t ADBitCell[16]){for (Int_t i=0;i<16;i++){fADCellID[i]=ADBitCell[i];}}
+ // Setters
+ void SetBBtriggerADA(UInt_t BBtrigger) {fBBtriggerADA=BBtrigger;}
+ void SetBGtriggerADA(UInt_t BGtrigger) {fBGtriggerADA=BGtrigger;}
+ void SetBBtriggerADC(UInt_t BBtrigger) {fBBtriggerADC=BBtrigger;}
+ void SetBGtriggerADC(UInt_t BGtrigger) {fBGtriggerADC=BGtrigger;}
+ void SetMultiplicity(Float_t Multiplicity[16])
+ {for(Int_t i=0;i<16;i++) fMultiplicity[i]=Multiplicity[i];}
+ void SetADC(Float_t adc[16])
+ {for(Int_t i=0;i<16;i++) fAdc[i]=adc[i];}
+ void SetTime(Float_t time[16])
+ {for(Int_t i=0;i<16;i++) fTime[i]=time[i];}
+ void SetWidth(Float_t width[16])
+ {for(Int_t i=0;i<16;i++) fWidth[i]=width[i];}
+ void SetBBFlag(Bool_t BBFlag[16])
+ {for(Int_t i=0;i<16;i++) fBBFlag[i]=BBFlag[i];}
+ void SetBGFlag(Bool_t BGFlag[16])
+ {for(Int_t i=0;i<16;i++) fBGFlag[i]=BGFlag[i];}
- // Getters
- Bool_t GetADCell(Int_t i) const;
- AliESDAD &operator=(const AliESDAD& source);
+ void SetADATime(Float_t time) {fADATime = time;}
+ void SetADCTime(Float_t time) {fADCTime = time;}
+ void SetADATimeError(Float_t err) {fADATimeError = err;}
+ void SetADCTimeError(Float_t err) {fADCTimeError = err;}
+
+ void SetADADecision(Decision des) {fADADecision = des;}
+ void SetADCDecision(Decision des) {fADCDecision = des;}
+
+ void SetTriggerChargeA(UShort_t chargeA) {fTriggerChargeA = chargeA;}
+ void SetTriggerChargeC(UShort_t chargeC) {fTriggerChargeC = chargeC;}
+ void SetTriggerBits(UShort_t triggerBits) {fTriggerBits = triggerBits;}
+
+ // Getters
+ virtual Short_t GetNbPMADA() const;
+ virtual Short_t GetNbPMADC() const;
+ virtual Float_t GetMTotADA() const;
+ virtual Float_t GetMTotADC() const;
+
+ virtual Float_t GetMultiplicity(Int_t i) const;
+ virtual Float_t GetMultiplicityADA(Int_t i) const;
+ virtual Float_t GetMultiplicityADC(Int_t i) const;
+ virtual Float_t GetAdc(Int_t i) const;
+ virtual Float_t GetAdcADA(Int_t i) const;
+ virtual Float_t GetAdcADC(Int_t i) const;
+ virtual Float_t GetTime(Int_t i) const;
+ virtual Float_t GetTimeADA(Int_t i) const;
+ virtual Float_t GetTimeADC(Int_t i) const;
+ virtual Float_t GetWidth(Int_t i) const;
+ virtual Float_t GetWidthADA(Int_t i) const;
+ virtual Float_t GetWidthADC(Int_t i) const;
+ virtual Bool_t BBTriggerADA(Int_t i) const;
+ virtual Bool_t BGTriggerADA(Int_t i) const;
+ virtual Bool_t BBTriggerADC(Int_t i) const;
+ virtual Bool_t BGTriggerADC(Int_t i) const;
+ virtual Bool_t GetBBFlag(Int_t i) const;
+ virtual Bool_t GetBGFlag(Int_t i) const;
+
+ virtual Float_t GetADATime() const { return fADATime; }
+ virtual Float_t GetADCTime() const { return fADCTime; }
+ virtual Float_t GetADATimeError() const { return fADATimeError; }
+ virtual Float_t GetADCTimeError() const { return fADCTimeError; }
+
+ virtual Decision GetADADecision() const { return fADADecision; }
+ virtual Decision GetADCDecision() const { return fADCDecision; }
+
+ virtual UShort_t GetTriggerChargeA() const { return fTriggerChargeA; }
+ virtual UShort_t GetTriggerChargeC() const { return fTriggerChargeC; }
+ virtual UShort_t GetTriggerBits() const { return fTriggerBits; }
- protected:
+ AliESDAD &operator=(const AliESDAD& source);
+
+protected:
+
+ UInt_t fBBtriggerADA; // bit mask for Beam-Beam trigger in ADA
+ UInt_t fBGtriggerADA; // bit mask for Beam-Gas trigger in ADA
+ UInt_t fBBtriggerADC; // bit mask for Beam-Beam trigger in ADC
+ UInt_t fBGtriggerADC; // bit mask for Beam-Gas trigger in ADC
+
+ Float_t fMultiplicity[16]; // multiplicity for each channel
+ Float_t fAdc[16]; // adc for each channel
+ Float_t fTime[16]; // time for each channel
+ Float_t fWidth[16]; // time width for each channel
+ Bool_t fBBFlag[16]; // BB Flags from Online AD Electronics
+ Bool_t fBGFlag[16]; // BG Flags from Online AD Electronics
+
+ Float_t fADATime; // Average time in ADA
+ Float_t fADCTime; // Average time in ADC
+ Float_t fADATimeError; // Error in the average time in ADA
+ Float_t fADCTimeError; // Error in the average time in ADC
- Bool_t fADCellID[16]; // Array with the AD's bitpattern
+ Decision fADADecision; // ADA final decision based on average time of channels
+ Decision fADCDecision; // ADC final decision based on average time of channels
- ClassDef(AliESDAD, 1)
+ UShort_t fTriggerChargeA; // Sum of the trigger (clock=10) charge on A side
+ UShort_t fTriggerChargeC; // Sum of the trigger (clock=10) charge on C side
+ UShort_t fTriggerBits; // AD trigger bits as defined in the firmware
+ ClassDef(AliESDAD,10)
};
#endif
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This is a class for containing all the AD DDL raw data
+/// It is written to the ESD-friend file
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliESDADfriend.h"
+
+ClassImp(AliESDADfriend)
+
+//_____________________________________________________________________________
+AliESDADfriend::AliESDADfriend():
+ TObject(),
+ fTrigger(0),
+ fTriggerMask(0)
+{
+ // default constructor
+ for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+ fScalers[iScaler] = 0;
+
+ for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+ fBBScalers[iChannel] = 0;
+ fBGScalers[iChannel] = 0;
+
+ for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+ fADC[iChannel][iEv] = 0.0;
+ fIsInt[iChannel][iEv] = kFALSE;
+ fIsBB[iChannel][iEv] = kFALSE;
+ fIsBG[iChannel][iEv] = kFALSE;
+ }
+ fTime[iChannel] = 0.0;
+ fWidth[iChannel] = 0.0;
+ }
+}
+
+//_____________________________________________________________________________
+AliESDADfriend::~AliESDADfriend()
+{
+ // destructor
+}
+
+//_____________________________________________________________________________
+AliESDADfriend::AliESDADfriend(const AliESDADfriend& adfriend):
+ TObject(adfriend),
+ fTrigger(adfriend.fTrigger),
+ fTriggerMask(adfriend.fTriggerMask)
+{
+ // copy constructor
+ for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+ fScalers[iScaler] = adfriend.fScalers[iScaler];
+
+ for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+ fBBScalers[iChannel] = adfriend.fBBScalers[iChannel];
+ fBGScalers[iChannel] = adfriend.fBGScalers[iChannel];
+
+ for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+ fADC[iChannel][iEv] = adfriend.fADC[iChannel][iEv];
+ fIsInt[iChannel][iEv] = adfriend.fIsInt[iChannel][iEv];
+ fIsBB[iChannel][iEv] = adfriend.fIsBB[iChannel][iEv];
+ fIsBG[iChannel][iEv] = adfriend.fIsBG[iChannel][iEv];
+ }
+ fTime[iChannel] = adfriend.fTime[iChannel];
+ fWidth[iChannel] = adfriend.fWidth[iChannel];
+ }
+}
+
+//_____________________________________________________________________________
+AliESDADfriend& AliESDADfriend::operator = (const AliESDADfriend& adfriend)
+{
+ // assignment operator
+ if(&adfriend == this) return *this;
+ TObject::operator=(adfriend);
+
+ fTrigger = adfriend.fTrigger;
+ fTriggerMask = adfriend.fTriggerMask;
+
+ for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+ fScalers[iScaler] = adfriend.fScalers[iScaler];
+
+ for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+ fBBScalers[iChannel] = adfriend.fBBScalers[iChannel];
+ fBGScalers[iChannel] = adfriend.fBGScalers[iChannel];
+
+ for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+ fADC[iChannel][iEv] = adfriend.fADC[iChannel][iEv];
+ fIsInt[iChannel][iEv] = adfriend.fIsInt[iChannel][iEv];
+ fIsBB[iChannel][iEv] = adfriend.fIsBB[iChannel][iEv];
+ fIsBG[iChannel][iEv] = adfriend.fIsBG[iChannel][iEv];
+ }
+ fTime[iChannel] = adfriend.fTime[iChannel];
+ fWidth[iChannel] = adfriend.fWidth[iChannel];
+ }
+
+ return *this;
+}
+
+void AliESDADfriend::Reset()
+{
+ // Reset the contents of the object
+ fTrigger = 0;
+ fTriggerMask = 0;
+
+ for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+ fScalers[iScaler] = 0;
+
+ for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+ fBBScalers[iChannel] = 0;
+ fBGScalers[iChannel] = 0;
+
+ for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+ fADC[iChannel][iEv] = 0.0;
+ fIsInt[iChannel][iEv] = kFALSE;
+ fIsBB[iChannel][iEv] = kFALSE;
+ fIsBG[iChannel][iEv] = kFALSE;
+ }
+ fTime[iChannel] = 0.0;
+ fWidth[iChannel] = 0.0;
+ }
+
+}
--- /dev/null
+#ifndef ALIESDADFRIEND_H
+#define ALIESDADFRIEND_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This is a class for containing all the AD DDL raw data
+/// It is written to the ESD-friend file
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+
+class AliESDADfriend: public TObject {
+ public :
+ AliESDADfriend();
+ virtual ~AliESDADfriend();
+
+ AliESDADfriend(const AliESDADfriend& adfriend);
+ AliESDADfriend& operator = (const AliESDADfriend& adfriend);
+
+ void Reset();
+
+// Getters of various scalers and Minimum Bias flags :
+
+ ULong64_t GetBBScalers(Int_t channel) const
+ { return fBBScalers[channel]; }
+ ULong64_t GetBGScalers(Int_t channel) const
+ { return fBGScalers[channel]; }
+ UInt_t GetTriggerScalers(Int_t num_scaler) const
+ { return fScalers[num_scaler]; }
+
+
+// Getters of ADC signals, ADC pedestals, time information and corresponding flags :
+
+ Float_t GetADC(Int_t channel) const
+ { return fADC[channel][kNEvOfInt/2]; }
+ Float_t GetPedestal(Int_t channel, Int_t event) const
+ { return fADC[channel][event]; }
+ Bool_t GetIntegratorFlag(Int_t channel, Int_t event) const
+ { return fIsInt[channel][event]; }
+ Bool_t GetBBFlag(Int_t channel, Int_t event) const
+ { return fIsBB[channel][event]; }
+ Bool_t GetBGFlag(Int_t channel, Int_t event) const
+ { return fIsBG[channel][event]; }
+ Float_t GetTime(Int_t channel) const
+ { return fTime[channel]; }
+ Float_t GetWidth(Int_t channel) const
+ { return fWidth[channel]; }
+
+ // Setters
+ void SetBBScalers(Int_t channel, ULong64_t scalers)
+ { fBBScalers[channel] = scalers; }
+ void SetBGScalers(Int_t channel, ULong64_t scalers)
+ { fBGScalers[channel] = scalers; }
+ void SetTriggerScalers(Int_t num_scaler, UInt_t scaler)
+ { fScalers[num_scaler] = scaler; }
+
+ void SetPedestal(Int_t channel, Int_t event, Float_t adc)
+ { fADC[channel][event] = adc; }
+ void SetIntegratorFlag(Int_t channel, Int_t event, Bool_t flag)
+ { fIsInt[channel][event] = flag; }
+ void SetBBFlag(Int_t channel, Int_t event, Bool_t flag)
+ { fIsBB[channel][event] = flag; }
+ void SetBGFlag(Int_t channel, Int_t event, Bool_t flag)
+ { fIsBG[channel][event] = flag; }
+ void SetTime(Int_t channel, Float_t time)
+ { fTime[channel] = time; }
+ void SetWidth(Int_t channel, Float_t width)
+ { fWidth[channel] = width; }
+
+ UShort_t GetTriggerInputs() const
+ { return fTrigger; }
+ UShort_t GetTriggerInputsMask() const
+ { return fTriggerMask; }
+ void SetTriggerInputs(UShort_t inputs)
+ { fTrigger = inputs; }
+ void SetTriggerInputsMask(UShort_t mask)
+ { fTriggerMask = mask; }
+
+ enum EESDADfriendParams {
+ kNChannels = 16, // number of electronic channels in AD (FEE numbering)
+ kNEvOfInt = 21, // number of events of interest
+ kNScalers = 16, // number of scalers
+ };
+
+ private:
+
+ ULong64_t fBBScalers[kNChannels]; // 'Beam-Beam' scalers for all channels
+ ULong64_t fBGScalers[kNChannels]; // 'Beam-Gas' scalers for all channels
+ UInt_t fScalers[kNScalers]; // Trigger scalers
+
+ Float_t fADC[kNChannels][kNEvOfInt]; // ADC counts for all channels and all events of interest
+ Bool_t fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels
+ Bool_t fIsBB[kNChannels][kNEvOfInt]; // 'Beam-Beam' flag for all channels
+ Bool_t fIsBG[kNChannels][kNEvOfInt]; // 'Beam-Gas' flag for all channels
+ Float_t fTime[kNChannels]; // leading time for all channels - from HPTDC - in nanoseconds
+ Float_t fWidth[kNChannels]; // pulse width for all channels - from HPTDC - in nanoseconds
+
+ UShort_t fTrigger; // AD trigger inputs
+ UShort_t fTriggerMask; // AD trigger inputs mask
+
+ ClassDef(AliESDADfriend, 2) // container class for AD DDL raw data
+};
+
+#endif
AliCascadeVertexer.cxx
AliESDACORDE.cxx
AliESDAD.cxx
+ AliESDADfriend.cxx
AliESDCaloCells.cxx
AliESDCaloCluster.cxx
AliESDCaloTrigger.cxx
#pragma link C++ class AliESDVZEROfriend+;
#pragma link C++ class AliESDTZEROfriend+;
+#pragma link C++ class AliESDADfriend+;
#pragma link C++ class AliESDHandler+;
#pragma link C++ class AliTrackerBase+;
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+//-------------------------------------------------------------------------
+// Base class for ESD and AOD AD data
+// Author: Michal Broz
+// michal.broz@cern.ch
+//-------------------------------------------------------------------------
+
+#include "AliVAD.h"
+#include "AliLog.h"
+
+ClassImp(AliVAD)
+
+//__________________________________________________________________________
+AliVAD::AliVAD(const AliVAD& source) :
+ TObject(source) { } // Copy constructor
+
+//__________________________________________________________________________
+AliVAD& AliVAD::operator=(const AliVAD& source)
+{
+ // Assignment operator
+ //
+ if (this!=&source) {
+ TObject::operator=(source);
+ }
+
+ return *this;
+}
+
+//__________________________________________________________________________
+Bool_t AliVAD::OutOfRange(Int_t i, const char* s, Int_t upper) const
+{
+ // checks if i is a valid index.
+ // s = name of calling method
+ if (i > upper || i < 0) {
+ AliInfo(Form("%s: Index %d out of range",s,i));
+ return kTRUE;
+ }
+ return kFALSE;
+}
+
--- /dev/null
+#ifndef ALIVAD_H
+#define ALIVAD_H
+
+//-------------------------------------------------------------------------
+// Base class for ESD and AOD AD data
+// Author: Michal Broz
+// Michal.Broz@cern.ch
+//-------------------------------------------------------------------------
+
+#include "TObject.h"
+#include "TMath.h"
+
+class AliVAD : public TObject
+{
+public:
+ AliVAD() { }
+ AliVAD(const AliVAD& source);
+ AliVAD &operator=(const AliVAD& source);
+
+ virtual ~AliVAD() { }
+
+ enum {
+ kCorrectedLeadingTime = BIT(14),
+ kTriggerBitsFilled = BIT(15),
+ kDecisionFilled = BIT(16),
+ kOnlineBitsFilled = BIT(17),
+ kCorrectedForSaturation = BIT(18),
+ kRobustMeanTime = BIT(19),
+ kTriggerChargeBitsFilled = BIT(20)
+ };
+ enum Decision { kADInvalid = -1, kADEmpty = 0, kADBB, kADBG, kADFake };
+ enum TriggerBits {
+ kBBAandBBC = 0,
+ kBBAorBBC = 1,
+ kBGAandBBC = 2,
+ kBGA = 3,
+ kBGCandBBA = 4,
+ kBGC = 5,
+ kCTA1andCTC1 = 6,
+ kCTA1orCTC1 = 7,
+ kCTA2andCTC2 = 8,
+ kCTA2orCTC2 = 9,
+ kMTAandMTC = 10,
+ kMTAorMTC = 11,
+ kBBA = 12,
+ kBBC = 13,
+ kBGAorBGC = 14,
+ kBGAandBBCorBGCandBBA = 15
+ };
+
+ virtual Short_t GetNbPMADA() const = 0;
+ virtual Short_t GetNbPMADC() const = 0;
+ virtual Float_t GetMTotADA() const = 0;
+ virtual Float_t GetMTotADC() const = 0;
+
+ virtual Float_t GetMultiplicity(Int_t i) const = 0;
+ virtual Float_t GetMultiplicityADA(Int_t i) const = 0;
+ virtual Float_t GetMultiplicityADC(Int_t i) const = 0;
+
+ virtual Bool_t BBTriggerADA(Int_t i) const = 0;
+ virtual Bool_t BGTriggerADA(Int_t i) const = 0;
+ virtual Bool_t BBTriggerADC(Int_t i) const = 0;
+ virtual Bool_t BGTriggerADC(Int_t i) const = 0;
+ virtual Bool_t GetBBFlag(Int_t i) const = 0;
+ virtual Bool_t GetBGFlag(Int_t i) const = 0;
+
+ virtual Float_t GetADATime() const = 0;
+ virtual Float_t GetADCTime() const = 0;
+
+ virtual Decision GetADADecision() const = 0;
+ virtual Decision GetADCDecision() const = 0;
+
+ virtual UShort_t GetTriggerChargeA() const = 0;
+ virtual UShort_t GetTriggerChargeC() const = 0;
+ virtual UShort_t GetTriggerBits() const = 0;
+
+protected:
+
+ Bool_t OutOfRange(Int_t i, const char *s, Int_t upper) const;
+
+ ClassDef(AliVAD,2)
+};
+
+#endif
AliTRDTKDInterpolator.cxx
AliTriggerScalers.cxx
AliTriggerScalersRecord.cxx
+ AliVAD.cxx
AliVAODHeader.cxx
AliVCaloCells.cxx
AliVCaloTrigger.cxx
#pragma link C++ class AliVCuts+;
#pragma link C++ class AliVVZERO+;
#pragma link C++ class AliVZDC+;
+#pragma link C++ class AliVAD+;
#pragma link C++ class AliCentrality+;
#pragma link C++ class AliEventplane+;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff