-// $Id: AliEmcalTriggerMaker.cxx 64593 2013-10-18 10:23:58Z loizides $
//
// Class to make array of trigger patch objects in AOD/ESD events.
+// The input for the process are:
+// - AliCaloTrigger objects from ESS/AOD, which contain raw trigger information
+// - the CaloCells, which contain offline/FEE information
+//
+// The output is a list of AliEmcalTriggerPatchInfo objects which is stored in ESD/AOD (Use event->FindListObject to get them) with three types of trigger patches:
+// 1) Online trigger info
+// 2) Trigger info based on the offline FEE ADCs (SimpleOffline)
+// 3) The highest gamma and jet patch in the event, even if it does
+// not pass the threshold (RecalcJet and RecalcGamma); with two versions
+// a) based on the online trigger information
+// b) based offline FEE information
+// The different types of patches are distinguished by bitflags according
+// to the enum AliEmcalTriggerPatchInfo::TriggerMakerBits and
+// EMCAL/AliEmcalTriggerTypes.h
//
// Author: J.Kral
#include <TClonesArray.h>
using namespace std;
+const TString AliEmcalTriggerMaker::fgkTriggerTypeNames[5] = {"EJE", "EGA", "EL0", "REJE", "REGA"};
//________________________________________________________________________
AliEmcalTriggerMaker::AliEmcalTriggerMaker() :
AliAnalysisTaskEmcal("AliEmcalTriggerMaker",kFALSE),
fRunTriggerType[kTMEMCalJet] = kTRUE;
fRunTriggerType[kTMEMCalGamma] = kTRUE;
fRunTriggerType[kTMEMCalLevel0] = kTRUE;
+ fRunTriggerType[kTMEMCalRecalcJet] = kTRUE;
+ fRunTriggerType[kTMEMCalRecalcGamma] = kTRUE;
memset(fThresholdConstants, 0, sizeof(Int_t) * 12);
memset(fPatchADCSimple, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
memset(fPatchADC, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
fRunTriggerType[kTMEMCalJet] = kTRUE;
fRunTriggerType[kTMEMCalGamma] = kTRUE;
fRunTriggerType[kTMEMCalLevel0] = kTRUE;
+ fRunTriggerType[kTMEMCalRecalcJet] = kTRUE;
+ fRunTriggerType[kTMEMCalRecalcGamma] = kTRUE;
memset(fThresholdConstants, 0, sizeof(Int_t) * 12);
memset(fPatchADCSimple, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
memset(fPatchADC, 0, sizeof(Int_t) * kPatchCols * kPatchRows);
if(fDoQA && fOutput){
fQAHistos = new THistManager("TriggerQA");
- TString trtypenames[3] = {"EJE", "EGA", "EL0"};
- for(int itype = 0; itype < 3; itype++){
- fQAHistos->CreateTH2(Form("RCPos%s", trtypenames[itype].Data()), Form("Lower edge position of %s patches (col-row)", trtypenames[itype].Data()), 48, -0.5, 47.5, 64, -0.5, 63.5);
- fQAHistos->CreateTH2(Form("EPCentPos%s", trtypenames[itype].Data()), Form("Center position of the %s trigger patches", trtypenames[itype].Data()), 20, -0.8, 0.8, 100., 1., 4.);
- fQAHistos->CreateTH2(Form("PatchADCvsE%s", trtypenames[itype].Data()), Form("Patch ADC value for trigger type %s", trtypenames[itype].Data()), 200, 0., 200, 200, 0., 200);
+ for(int itype = 0; itype < 5; itype++){
+ fQAHistos->CreateTH2(Form("RCPos%s", fgkTriggerTypeNames[itype].Data()), Form("Lower edge position of %s patches (col-row)", fgkTriggerTypeNames[itype].Data()), 48, -0.5, 47.5, 64, -0.5, 63.5);
+ fQAHistos->CreateTH2(Form("EPCentPos%s", fgkTriggerTypeNames[itype].Data()), Form("Center position of the %s trigger patches", fgkTriggerTypeNames[itype].Data()), 20, -0.8, 0.8, 100, 1., 4.);
+ fQAHistos->CreateTH2(Form("PatchADCvsE%s", fgkTriggerTypeNames[itype].Data()), Form("Patch ADC value for trigger type %s", fgkTriggerTypeNames[itype].Data()), 200, 0., 200, 200, 0., 200);
}
fQAHistos->CreateTH1("triggerBitsAll", "Trigger bits for all incoming patches", 64, -0.5, 63.5);
fQAHistos->CreateTH1("triggerBitsSel", "Trigger bits for reconstructed patches", 64, -0.5, 63.5);
Bool_t isOfflineSimple=0;
while (NextTrigger(isOfflineSimple)) {
// process jet
- if(fRunTriggerType[kTMEMCalJet]){
+ if(fRunTriggerType[kTMEMCalJet]){
trigger = ProcessPatch(kTMEMCalJet, isOfflineSimple);
// save main jet triggers in event
if (trigger != 0) {
triggerMainLevel0 = trigger;
}
}
+
+ // Recalculated triggers (max patches without threshold)
+ if(fRunTriggerType[kTMEMCalRecalcJet])
+ ProcessPatch(kTMEMCalRecalcJet, isOfflineSimple);
+ if(fRunTriggerType[kTMEMCalRecalcGamma])
+ ProcessPatch(kTMEMCalRecalcGamma, isOfflineSimple);
} // triggers
// mark the most energetic patch as main
if (triggerMainJet != 0) {
Int_t tBits = triggerMainJet->GetTriggerBits();
// main trigger flag
- tBits = tBits | ( 1 << 24 );
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kMainTriggerBitNum );
triggerMainJet->SetTriggerBits( tBits );
}
if (triggerMainJetSimple != 0) {
Int_t tBits = triggerMainJetSimple->GetTriggerBits();
// main trigger flag
- tBits = tBits | ( 1 << 24 );
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kMainTriggerBitNum );
triggerMainJetSimple->SetTriggerBits(tBits);
}
if (triggerMainGamma != 0) {
Int_t tBits = triggerMainGamma->GetTriggerBits();
// main trigger flag
- tBits = tBits | ( 1 << 24 );
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kMainTriggerBitNum );
triggerMainGamma->SetTriggerBits( tBits );
}
if (triggerMainGammaSimple != 0) {
Int_t tBits = triggerMainGammaSimple->GetTriggerBits();
// main trigger flag
- tBits = tBits | ( 1 << 24 );
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kMainTriggerBitNum );
triggerMainGammaSimple->SetTriggerBits( tBits );
}
if(triggerMainLevel0){
Int_t tBits = triggerMainLevel0->GetTriggerBits();
// main trigger flag
- tBits |= (1 << 24);
+ tBits |= (1 << AliEmcalTriggerPatchInfo::kMainTriggerBitNum);
triggerMainLevel0->SetTriggerBits(tBits);
}
} // there are some triggers
if ((type == kTMEMCalJet && !IsEJE( tBits )) ||
(type == kTMEMCalGamma && !IsEGA( tBits )) ||
- (type == kTMEMCalLevel0 && !(CheckForL0(*fCaloTriggers))))
+ (type == kTMEMCalLevel0 && !(CheckForL0(*fCaloTriggers))) ||
+ (type == kTMEMCalRecalcJet && (tBits & (1 << AliEmcalTriggerPatchInfo::kRecalcJetBitNum))==0) ||
+ (type == kTMEMCalRecalcGamma && (tBits & (1 << AliEmcalTriggerPatchInfo::kRecalcGammaBitNum))==0) )
return 0;
- TString trtypenames[3] = {"EJE", "EGA", "EL0"}; // For QA
-
// save primary vertex in vector
TVector3 vertex;
vertex.SetXYZ(fVertex[0], fVertex[1], fVertex[2]);
// sum the available energy in the 32/32 window of cells
// step over trigger channels and get all the corresponding cells
// make CM
- Double_t amp = 0;
- Int_t cmiCol = 0;
- Int_t cmiRow = 0;
+ Float_t amp = 0;
+ Float_t cmiCol = 0;
+ Float_t cmiRow = 0;
Int_t adcAmp = 0;
- int nfastor = (type == kTMEMCalJet) ? 16 : 2; // 32x32 cell window for L1 Jet trigger, 4x4 for L1 Gamma or L0 trigger
+ Double_t adcOfflineAmp = 0;
+ int nfastor = (type == kTMEMCalJet || type == kTMEMCalRecalcJet) ? 16 : 2; // 32x32 cell window for L1 Jet trigger, 4x4 for L1 Gamma or L0 trigger
for (Int_t i = 0; i < nfastor; ++i) {
for (Int_t j = 0; j < nfastor; ++j) {
// get the 4 cells composing the trigger channel
fGeom->GetCellIndexFromFastORIndex(absId, cellAbsId);
// add amplitudes and find patch edges
for (Int_t k = 0; k < 4; ++k) {
- Double_t ca = fCaloCells->GetCellAmplitude(cellAbsId[k]);
+ Float_t ca = fCaloCells->GetCellAmplitude(cellAbsId[k]);
//fGeom->GetGlobal(cellAbsId[k], cellCoor);
amp += ca;
- cmiCol += ca*(Double_t)i;
- cmiRow += ca*(Double_t)j;
+ cmiCol += ca*(Float_t)i;
+ cmiRow += ca*(Float_t)j;
}
// add the STU ADCs in the patch (in case of L1) or the TRU Amplitude (in case of L0)
- if (!isOfflineSimple )
- if(type == kTMEMCalLevel0){
- adcAmp += fPatchADC[globCol+i][globRow+j] * 4; // precision loss in case of global integer field
- } else
- adcAmp += fPatchADC[globCol+i][globRow+j];
- else
- adcAmp += fPatchADCSimple[globCol+i][globRow+j];
+
+ if(type == kTMEMCalLevel0){
+ adcAmp += fPatchADC[globCol+i][globRow+j] * 4; // precision loss in case of global integer field
+ } else
+ adcAmp += fPatchADC[globCol+i][globRow+j];
+
+ adcOfflineAmp += fPatchADCSimple[globCol+i][globRow+j];
}
}
Int_t posOffset=-1;
switch(type){
case kTMEMCalJet:
+ case kTMEMCalRecalcJet:
posOffset = 15;
break;
case kTMEMCalGamma:
+ case kTMEMCalRecalcGamma:
posOffset = 1;
break;
case kTMEMCalLevel0:
// picking two diagonally closest cells from the patches
switch(type){
case kTMEMCalJet:
+ case kTMEMCalRecalcJet:
posOffset = 7;
break;
case kTMEMCalGamma:
+ case kTMEMCalRecalcGamma:
posOffset = 0;
break;
case kTMEMCalLevel0:
switch(type){
case kTMEMCalJet:
+ case kTMEMCalRecalcJet:
posOffset = 8;
break;
case kTMEMCalGamma:
+ case kTMEMCalRecalcGamma:
posOffset = 1;
break;
case kTMEMCalLevel0:
1 << (fTriggerBitConfig->GetJetLowBit()) | 1 << (fTriggerBitConfig->GetJetHighBit()) | 1 << (fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaLowBit()) |
1 << (fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaHighBit()) | 1 << (fTriggerBitConfig->GetGammaLowBit()) | 1 << (fTriggerBitConfig->GetGammaHighBit()));
break;
+ default: // recalculated patches don't need any action
+ break;
};
// save the trigger object
trigger->SetEdge1(edge1, amp);
trigger->SetEdge2(edge2, amp);
trigger->SetADCAmp(adcAmp);
+ trigger->SetADCOfflineAmp(Int_t(adcOfflineAmp));
trigger->SetTriggerBits(tBits);
trigger->SetOffSet(offSet);
trigger->SetEdgeCell(globCol*2, globRow*2); // from triggers to cells
if(fDoQA){
- fQAHistos->FillTH2(Form("RCPos%s", trtypenames[type].Data()), globCol, globRow);
- fQAHistos->FillTH2(Form("EPCentPos%s", trtypenames[type].Data()), centerGeo.Eta(), centerGeo.Phi());
- fQAHistos->FillTH2(Form("PatchADCvsE%s", trtypenames[type].Data()), adcAmp, trigger->GetPatchE());
+ fQAHistos->FillTH2(Form("RCPos%s", fgkTriggerTypeNames[type].Data()), globCol, globRow);
+ fQAHistos->FillTH2(Form("EPCentPos%s", fgkTriggerTypeNames[type].Data()), centerGeo.Eta(), centerGeo.Phi());
+ fQAHistos->FillTH2(Form("PatchADCvsE%s", fgkTriggerTypeNames[type].Data()), adcAmp, trigger->GetPatchE());
// Redo checking of found trigger bits after masking of unwanted triggers
for(unsigned int ibit = 0; ibit < sizeof(tBits)*8; ibit++) {
if(tBits & (1 << ibit)){
//________________________________________________________________________
void AliEmcalTriggerMaker::RunSimpleOfflineTrigger()
{
- // Runs a simple offline trigger algorithm.
+ // Runs a simple algorithm to calculate patch energies based on
+ // the offline/FEE ADC values (useOffline = kTRUE) or
+ // the online/trigger values (useOffline = kFALSE.
+ //
// It creates separate patches for jet and gamma triggers
// on the same positions (different from STU reconstruction behavior)
- // TODO:: change to merge
- TArrayI tBitsArray, rowArray, colArray;
-
- // 0 thresholds = no processing
- if (fCaloTriggerSetupOut->GetThresholdJetLowSimple() == 0 &&
- fCaloTriggerSetupOut->GetThresholdJetHighSimple() == 0 )
- return;
+ TArrayI tBitsArray(4), rowArray(4), colArray(4);
+ // First entries are for recalculated patches
+
+ tBitsArray[0] = 1 << AliEmcalTriggerPatchInfo::kRecalcJetBitNum;
+ colArray[0] = -1;
+ rowArray[0] = -1;
+
+ tBitsArray[1] = 1 << AliEmcalTriggerPatchInfo::kRecalcJetBitNum | 1 << AliEmcalTriggerPatchInfo::kSimpleOfflineBitNum;
+ colArray[1] = -1;
+ rowArray[1] = -1;
+
+ tBitsArray[2] = 1 << AliEmcalTriggerPatchInfo::kRecalcGammaBitNum;
+ colArray[2] = -1;
+ rowArray[2] = -1;
+
+ tBitsArray[3] = 1 << AliEmcalTriggerPatchInfo::kRecalcGammaBitNum | 1 << AliEmcalTriggerPatchInfo::kSimpleOfflineBitNum;
+ colArray[3] = -1;
+ rowArray[3] = -1;
+
+ Int_t maxPatchADCoffline = -1;
+ Int_t maxPatchADC = -1;
// run the trigger algo, stepping by 8 towers (= 4 trigger channels)
Int_t maxCol = 48;
Int_t maxRow = fGeom->GetNTotalTRU()*2;
for (Int_t i = 0; i < (maxCol-16); i += 4) {
for (Int_t j = 0; j < (maxRow-16); j += 4) {
+ Int_t tSumOffline = 0;
Int_t tSum = 0;
Int_t tBits = 0;
// window
- for (Int_t k = 0; k < 16; ++k)
- for (Int_t l = 0; l < 16; ++l)
- tSum += (ULong64_t)fPatchADCSimple[i+k][j+l];
-
+ for (Int_t k = 0; k < 16; ++k) {
+ for (Int_t l = 0; l < 16; ++l) {
+ tSumOffline += (ULong64_t)fPatchADCSimple[i+k][j+l];
+ tSum += (ULong64_t)fPatchADC[i+k][j+l];
+ }
+ }
+
+ if (tSum > maxPatchADC) { // Mark highest Jet patch
+ maxPatchADC = tSum;
+ colArray[0] = i;
+ rowArray[0] = j;
+ }
+
+ if (tSumOffline > maxPatchADCoffline) { // Mark highest Jet patch
+ maxPatchADCoffline = tSumOffline;
+ colArray[1] = i;
+ rowArray[1] = j;
+ }
+
// check thresholds
- if (tSum > fCaloTriggerSetupOut->GetThresholdJetLowSimple())
- tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetJetLowBit() ));
- if (tSum > fCaloTriggerSetupOut->GetThresholdJetHighSimple())
- tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetJetHighBit() ));
+ if (tSumOffline > fCaloTriggerSetupOut->GetThresholdJetLowSimple())
+ tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetJetLowBit() ));
+ if (tSumOffline > fCaloTriggerSetupOut->GetThresholdJetHighSimple())
+ tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetJetHighBit() ));
// add trigger values
if (tBits != 0) {
- // add offline bit
- tBits = tBits | ( 1 << 25 );
- tBitsArray.Set( tBitsArray.GetSize() + 1 );
- colArray.Set( colArray.GetSize() + 1 );
- rowArray.Set( rowArray.GetSize() + 1 );
- tBitsArray[tBitsArray.GetSize()-1] = tBits;
- colArray[colArray.GetSize()-1] = i;
- rowArray[rowArray.GetSize()-1] = j;
+ // add offline bit
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kSimpleOfflineBitNum );
+ tBitsArray.Set( tBitsArray.GetSize() + 1 );
+ colArray.Set( colArray.GetSize() + 1 );
+ rowArray.Set( rowArray.GetSize() + 1 );
+ tBitsArray[tBitsArray.GetSize()-1] = tBits;
+ colArray[colArray.GetSize()-1] = i;
+ rowArray[rowArray.GetSize()-1] = j;
}
}
} // trigger algo
// 4x4 trigger algo, stepping by 2 towers (= 1 trigger channel)
+ maxPatchADC = -1;
+ maxPatchADCoffline = -1;
+
for (Int_t i = 0; i < (maxCol-2); ++i) {
for (Int_t j = 0; j < (maxRow-2); ++j) {
Int_t tSum = 0;
+ Int_t tSumOffline = 0;
Int_t tBits = 0;
// window
- for (Int_t k = 0; k < 2; ++k)
- for (Int_t l = 0; l < 2; ++l)
- tSum += (ULong64_t)fPatchADCSimple[i+k][j+l];
-
+ for (Int_t k = 0; k < 2; ++k) {
+ for (Int_t l = 0; l < 2; ++l) {
+ tSumOffline += (ULong64_t)fPatchADCSimple[i+k][j+l];
+ tSum += (ULong64_t)fPatchADC[i+k][j+l];
+ }
+ }
+
+ if (tSum > maxPatchADC) { // Mark highest Gamma patch
+ maxPatchADC = tSum;
+ colArray[2] = i;
+ rowArray[2] = j;
+ }
+ if (tSumOffline > maxPatchADCoffline) { // Mark highest Gamma patch
+ maxPatchADCoffline = tSumOffline;
+ colArray[3] = i;
+ rowArray[3] = j;
+ }
+
// check thresholds
- if (tSum > fCaloTriggerSetupOut->GetThresholdGammaLowSimple())
- tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaLowBit() ));
- if (tSum > fCaloTriggerSetupOut->GetThresholdGammaHighSimple())
- tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaHighBit() ));
+ if (tSumOffline > fCaloTriggerSetupOut->GetThresholdGammaLowSimple())
+ tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaLowBit() ));
+ if (tSumOffline > fCaloTriggerSetupOut->GetThresholdGammaHighSimple())
+ tBits = tBits | ( 1 << ( fTriggerBitConfig->GetTriggerTypesEnd() + fTriggerBitConfig->GetGammaHighBit() ));
// add trigger values
if (tBits != 0) {
- // add offline bit
- tBits = tBits | ( 1 << 25 );
- tBitsArray.Set( tBitsArray.GetSize() + 1 );
- colArray.Set( colArray.GetSize() + 1 );
- rowArray.Set( rowArray.GetSize() + 1 );
- tBitsArray[tBitsArray.GetSize()-1] = tBits;
- colArray[colArray.GetSize()-1] = i;
- rowArray[rowArray.GetSize()-1] = j;
+ // add offline bit
+ tBits = tBits | ( 1 << AliEmcalTriggerPatchInfo::kSimpleOfflineBitNum );
+ tBitsArray.Set( tBitsArray.GetSize() + 1 );
+ colArray.Set( colArray.GetSize() + 1 );
+ rowArray.Set( rowArray.GetSize() + 1 );
+ tBitsArray[tBitsArray.GetSize()-1] = tBits;
+ colArray[colArray.GetSize()-1] = i;
+ rowArray[rowArray.GetSize()-1] = j;
}
}
} // trigger algo
AliEmcalTriggerPatchInfo &operator=(const AliEmcalTriggerPatchInfo &p);
virtual ~AliEmcalTriggerPatchInfo();
+ enum TriggerMakerBits_t {
+ kRecalcJetBitNum = 22,
+ kRecalcGammaBitNum = 23,
+ kMainTriggerBitNum = 24,
+ kSimpleOfflineBitNum = 25
+ };
+ // The lower bits in fTriggerBits are defined in EMCAL/AliEmcalTriggerTypes.h
Double_t GetPhiGeo() const { return fCenterGeo.Phi(); }
Double_t GetPhiCM() const { return fCenterMass.Phi(); }
Double_t GetEtaMax() const { return fEdge1.Eta(); }
Double_t GetPatchE() const { return fCenterGeo.E(); }
Int_t GetADCAmp() const { return fADCAmp; }
+ Int_t GetADCOfflineAmp() const { return fADCOfflineAmp; }
Double_t GetADCAmpGeVRough() const { return (Double_t)fADCAmp * kEMCL1ADCtoGeV; }
Int_t GetTriggerBits() const { return fTriggerBits; }
Int_t GetEdgeCellX() const { return fEdgeCell[0]; }
Int_t GetEdgeCellY() const { return fEdgeCell[1]; }
void GetCellIndices( AliEMCALGeometry *geom, TArrayI *cells );
- Bool_t IsLevel0() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetLevel0Bit()))&(!(fTriggerBits >> 25))&1); }
- Bool_t IsJetLow() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetLowBit()))&(!(fTriggerBits >> 25))&1); }
- Bool_t IsJetHigh() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetHighBit()))&(!(fTriggerBits >> 25))&1); }
- Bool_t IsGammaLow() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaLowBit()))&(!(fTriggerBits >> 25))&1); }
- Bool_t IsGammaHigh() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaHighBit()))&(!(fTriggerBits >> 25))&1); }
- Bool_t IsMainTrigger() const { return (Bool_t)((fTriggerBits >> 24)&(!(fTriggerBits >> 25))&1); }
- Bool_t IsJetLowSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetLowBit()))&(fTriggerBits >> 25)&1); }
- Bool_t IsJetHighSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetHighBit()))&(fTriggerBits >> 25)&1); }
- Bool_t IsGammaLowSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaLowBit()))&(fTriggerBits >> 25)&1); }
- Bool_t IsGammaHighSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaHighBit()))&(fTriggerBits >> 25)&1); }
- Bool_t IsMainTriggerSimple() const { return (Bool_t)((fTriggerBits >> 24)&(fTriggerBits >> 25)&1); }
- Bool_t IsOfflineSimple() const { return (Bool_t)((fTriggerBits >> 25)&1); }
+ Bool_t IsLevel0() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetLevel0Bit()))&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsJetLow() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetLowBit()))&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsJetHigh() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetHighBit()))&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsGammaLow() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaLowBit()))&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsGammaHigh() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaHighBit()))&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsMainTrigger() const { return (Bool_t)((fTriggerBits >> kMainTriggerBitNum)&(!(fTriggerBits >> kSimpleOfflineBitNum))&1); }
+ Bool_t IsJetLowSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetLowBit()))&(fTriggerBits >> kSimpleOfflineBitNum)&1); }
+ Bool_t IsJetHighSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetJetHighBit()))&(fTriggerBits >> kSimpleOfflineBitNum)&1); }
+ Bool_t IsGammaLowSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaLowBit()))&(fTriggerBits >> kSimpleOfflineBitNum)&1); }
+ Bool_t IsGammaHighSimple() const { return (Bool_t)((fTriggerBits >> (fOffSet + fTriggerBitConfig.GetGammaHighBit()))&(fTriggerBits >> kSimpleOfflineBitNum)&1); }
+ Bool_t IsMainTriggerSimple() const { return (Bool_t)((fTriggerBits >> kMainTriggerBitNum)&(fTriggerBits >> kSimpleOfflineBitNum)&1); }
+ Bool_t IsOfflineSimple() const { return (Bool_t)((fTriggerBits >> kSimpleOfflineBitNum)&1); }
void SetCenterGeo( TVector3 &v, Double_t e ) { SetLorentzVector( fCenterGeo, v, e ); }
void SetCenterGeo( TLorentzVector &v ) { fCenterGeo = v; }
void SetEdge2( TLorentzVector &v ) { fEdge2 = v; }
void SetEdge2( TVector3 &v, Double_t e ) { SetLorentzVector( fEdge2, v, e ); }
void SetADCAmp( Int_t a ) { fADCAmp = a; }
+ void SetADCOfflineAmp( Int_t a ) { fADCOfflineAmp = a; }
void SetEdgeCell( Int_t x, Int_t y ) { fEdgeCell[0] = x; fEdgeCell[1] = y; }
void SetLorentzVector( TLorentzVector &lv, TVector3 &v, Double_t e );
TLorentzVector fCenterMass; // CM
TLorentzVector fEdge1; // max eta/ min phi edge
TLorentzVector fEdge2; // min eta/ max phi edge
- Int_t fADCAmp; // online ADC amplitude
- Int_t fTriggerBits; //trigger bit mask
+ Int_t fADCAmp; // online (trigger) ADC amplitude
+ Int_t fADCOfflineAmp; // offline (FEE) ADC amplitude
+ Int_t fTriggerBits; // trigger bit mask, see definitions in AliEmcalTriggerType and TriggerMakerBits_t (above)
Int_t fEdgeCell[2]; // cell "bottom lower" edge (min phi, max eta)
Int_t fOffSet; // offset of bit (different in data and MC)
AliEmcalTriggerBitConfig fTriggerBitConfig; // Trigger bit configuration
- ClassDef(AliEmcalTriggerPatchInfo, 5) // Emcal particle class
+ ClassDef(AliEmcalTriggerPatchInfo, 6) // Emcal particle class
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff