#include <TClonesArray.h>
#include <iostream>
+#include <bitset>
#include "AliLog.h"
#include "AliEmcalTriggerPatchInfo.h"
ULong64_t v0S, thresh;
Bool_t isOfflineSimple;
- AliEmcalTriggerPatchInfo *trigger, *triggerMainJet, *triggerMainGamma;
+ AliEmcalTriggerPatchInfo *trigger, *triggerMainJet, *triggerMainGamma, *triggerMainLevel0;
AliEmcalTriggerPatchInfo *triggerMainJetSimple, *triggerMainGammaSimple;
// delete patch array, clear setup object
// class is not empty
if( fCaloTriggers->GetEntries() > 0 || fSimpleOfflineTriggers->GetEntries() > 0 ){
-
fITrigger = 0;
triggerMainGamma = 0;
triggerMainJet = 0;
// go throuth the trigger channels, real first, then offline
while( NextTrigger( isOfflineSimple ) ){
-
// process jet
- trigger = ProcessPatch( 0, isOfflineSimple );
+ trigger = ProcessPatch( kTMEMCalJet, isOfflineSimple );
// save main jet triggers in event
if( trigger != 0 ){
}
// process gamma
- trigger = ProcessPatch( 1, isOfflineSimple );
+ trigger = ProcessPatch( kTMEMCalGamma, isOfflineSimple );
// save main gamma triggers in event
if( trigger != 0 ){
}
}
+ // level 0 triggers
+ trigger = ProcessPatch(kTMEMCalLevel0, isOfflineSimple);
+
+ // save main level0 trigger in the event
+ if(trigger){
+ if(!triggerMainLevel0) triggerMainLevel0 = trigger;
+ else if(triggerMainLevel0->GetPatchE() < trigger->GetPatchE()) triggerMainLevel0 = trigger;
+ }
+
// cout << " pi:" << trigger->GetPhiMin() << " px:" << trigger->GetPhiMax();
// cout << " pg:" << trigger->GetPhiGeo() << " " << (trigger->GetPhiMin()+trigger->GetPhiMax()) / 2.;
// cout << " pc:" << trigger->GetPhiCM();
tBits = tBits | ( 1 << 24 );
triggerMainGammaSimple->SetTriggerBits( tBits );
}
+ if(triggerMainLevel0){
+ tBits = triggerMainLevel0->GetTriggerBits();
+ // main trigger flag
+ tBits |= (1 << 24);
+ triggerMainLevel0->SetTriggerBits(tBits);
+ }
} // there are some triggers
}
//________________________________________________________________________
-AliEmcalTriggerPatchInfo* AliEmcalTriggerMaker::ProcessPatch( Int_t type, Bool_t isOfflineSimple ){
+AliEmcalTriggerPatchInfo* AliEmcalTriggerMaker::ProcessPatch( TriggerMakerTriggerType_t type, Bool_t isOfflineSimple ){
- Int_t globCol, globRow, tBits, cellAbsId[4];
+ Int_t globCol, globRow, tBits, cellAbsId[4], posOffset;
Int_t absId, adcAmp;
Int_t i, j, k, cmCol, cmRow, cmiCellCol, cmiCellRow;
Double_t amp, ca, cmiCol, cmiRow;
else
fSimpleOfflineTriggers->GetTriggerBits( tBits );
- if(( type == 0 && ! IsEJE( tBits )) || ( type == 1 && ! IsEGA( tBits )))
+ if(( type == kTMEMCalJet && ! IsEJE( tBits )) || ( type == kTMEMCalGamma && ! IsEGA( tBits )) || (type == kTMEMCalLevel0 && !IsLevel0(tBits)))
return 0;
// save primary vertex in vector
cmiCol = 0;
cmiRow = 0;
adcAmp = 0;
- if( IsEJE( tBits ) && type == 0 ){
+ if( IsEJE( tBits ) && type == kTMEMCalJet ){
for( i = 0; i < 16; i++ ){
for( j = 0; j < 16; j++ ){
// get the 4 cells composing the trigger channel
} // 32x32 cell window
}
- if( IsEGA( tBits ) && type == 1 ){
+ if( (IsEGA( tBits ) && type == kTMEMCalGamma) || (IsLevel0( tBits ) && type == kTMEMCalLevel0)){
for( i = 0; i < 2; i++ ){
for( j = 0; j < 2; j++ ){
// get the 4 cells composing the trigger channel
}
} // 4x4 cell window
}
+
if( amp == 0 ){
AliDebug(2,"EMCal trigger patch with 0 energy.");
return 0;
// get up right edge (eta min, phi max)
// get the absolute trigger ID
- if( type == 0 )
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+15, globRow+15, absId );
- else if( type == 1)
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+1, globRow+1, absId );
+ switch(type){
+ case kTMEMCalJet:
+ posOffset = 15;
+ break;
+ case kTMEMCalGamma:
+ posOffset = 1;
+ break;
+ case kTMEMCalLevel0:
+ posOffset = 1;
+ break;
+ };
+ fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+posOffset, globRow+posOffset, absId );
// convert to the 4 absId of the cells composing the trigger channel
fGeom->GetCellIndexFromFastORIndex( absId, cellAbsId );
// get the geometrical center as an average of two diagonally
// adjacent patches in the center
// picking two diagonally closest cells from the patches
- if( type == 0 )
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+7, globRow+7, absId );
- else if( type == 1 )
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol, globRow, absId );
+ switch(type){
+ case kTMEMCalJet:
+ posOffset = 7;
+ break;
+ case kTMEMCalGamma:
+ posOffset = 0;
+ break;
+ case kTMEMCalLevel0:
+ posOffset = 0;
+ break;
+ };
+ fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+posOffset, globRow+posOffset, absId );
+
fGeom->GetCellIndexFromFastORIndex( absId, cellAbsId );
fGeom->GetGlobal( cellAbsId[3], center1 );
- if( type == 0 )
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+8, globRow+8, absId );
- else if( type == 1 )
- fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+1, globRow+1, absId );
+ switch(type){
+ case kTMEMCalJet:
+ posOffset = 8;
+ break;
+ case kTMEMCalGamma:
+ posOffset = 1;
+ break;
+ case kTMEMCalLevel0:
+ posOffset = 1;
+ break;
+ };
+ fGeom->GetAbsFastORIndexFromPositionInEMCAL( globCol+posOffset, globRow+posOffset, absId );
fGeom->GetCellIndexFromFastORIndex( absId, cellAbsId );
fGeom->GetGlobal( cellAbsId[0], center2 );
edge2 -= vertex;
// fix tbits .. remove the unwanted type triggers
- if( type == 0 )
- tBits = tBits & ~( 1 << (kTriggerTypeEnd + kL1GammaLow) | 1 << (kTriggerTypeEnd + kL1GammaHigh) | 1 << (kL1GammaLow) | 1 << (kL1GammaHigh));
- else if( type == 1 )
- tBits = tBits & ~( 1 << (kTriggerTypeEnd + kL1JetLow) | 1 << (kTriggerTypeEnd + kL1JetHigh) | 1 << (kL1JetLow) | 1 << (kL1JetHigh));
+ // for Jet and Gamma triggers we remove also the level 0 bit since it will be stored in the level 0 patch
+ // for level 0 we remove all gamma and jet trigger bits
+ switch(type){
+ case kTMEMCalJet:
+ tBits = tBits & ~( 1 << (kTriggerTypeEnd + kL1GammaLow) | 1 << (kTriggerTypeEnd + kL1GammaHigh) | 1 << (kL1GammaLow) | 1 << (kL1GammaHigh) |
+ 1 << (kTriggerTypeEnd + kL0) | 1 << (kL0));
+ break;
+ case kTMEMCalGamma:
+ tBits = tBits & ~( 1 << (kTriggerTypeEnd + kL1JetLow) | 1 << (kTriggerTypeEnd + kL1JetHigh) | 1 << (kL1JetLow) | 1 << (kL1JetHigh) |
+ 1 << (kTriggerTypeEnd + kL0) | 1 << (kL0));
+ break;
+ case kTMEMCalLevel0:
+ tBits = tBits & ~( 1 << (kTriggerTypeEnd + kL1JetLow) | 1 << (kTriggerTypeEnd + kL1JetHigh) | 1 << (kL1JetLow) | 1 << (kL1JetHigh) |
+ 1 << (kTriggerTypeEnd + kL1GammaLow) | 1 << (kTriggerTypeEnd + kL1GammaHigh) | 1 << (kL1GammaLow) | 1 << (kL1GammaHigh));
+ break;
+ };
// save the trigger object
new ((*fCaloTriggersOut)[fITrigger])AliEmcalTriggerPatchInfo();
class AliEmcalTriggerMaker : public AliAnalysisTaskEmcal {
public:
+ enum TriggerMakerTriggerType_t{
+ kTMEMCalJet = 0,
+ kTMEMCalGamma = 1,
+ kTMEMCalLevel0 = 2
+ };
AliEmcalTriggerMaker();
AliEmcalTriggerMaker(const char *name);
virtual ~AliEmcalTriggerMaker();
void SetTriggerThresholdJetLow( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[2][0] = a; fThresholdConstants[2][1] = b; fThresholdConstants[2][2] = c; }
void SetTriggerThresholdJetHigh( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[0][0] = a; fThresholdConstants[0][1] = b; fThresholdConstants[0][2] = c; }
+ void SetTriggerThresholdGammaLow( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[3][0] = a; fThresholdConstants[3][1] = b; fThresholdConstants[3][2] = c; }
+ void SetTriggerThresholdGammaHigh( Int_t a, Int_t b, Int_t c ) { fThresholdConstants[3][0] = a; fThresholdConstants[1][1] = b; fThresholdConstants[1][2] = c; }
void SetV0InName(const char *name) { fV0InName = name; }
Bool_t IsEJE( Int_t tBits ) { if( tBits & ( 1 << (kTriggerTypeEnd + kL1JetLow) | 1 << (kTriggerTypeEnd + kL1JetHigh) | 1 << (kL1JetLow) | 1 << (kL1JetHigh) )) return kTRUE; else return kFALSE; }
Bool_t IsEGA( Int_t tBits ) { if( tBits & ( 1 << (kTriggerTypeEnd + kL1GammaLow) | 1 << (kTriggerTypeEnd + kL1GammaHigh) | 1 << (kL1GammaLow) | 1 << (kL1GammaHigh) )) return kTRUE; else return kFALSE; }
-
+ Bool_t IsLevel0( Int_t tBits ) { if( tBits & (1 << (kTriggerTypeEnd + kL0) | (1 << kL0))) return kTRUE; return kFALSE; }
protected:
TString fCaloTriggersOutName; // name of output track array
TString fCaloTriggerSetupOutName; // name of output track array
Double_t fPatchADCSimple[48][64]; //! patch map for simple offline trigger
Int_t fThresholdConstants[4][3]; // simple offline trigger thresholds constants
- Int_t fPatchADC[48][64]; //! ADC values map
+ Int_t fPatchADC[48][64]; //! ADC values map
Int_t fITrigger; //! trigger counter
private:
AliEmcalTriggerMaker &operator=(const AliEmcalTriggerMaker&); // not implemented
Bool_t NextTrigger( Bool_t &isOfflineSimple );
- AliEmcalTriggerPatchInfo* ProcessPatch( Int_t type, Bool_t isOfflineSimple );
+ AliEmcalTriggerPatchInfo* ProcessPatch( TriggerMakerTriggerType_t type, Bool_t isOfflineSimple );
ClassDef(AliEmcalTriggerMaker, 4); // Task to make array of EMCAL particle
};
#include "AliVTrack.h"
#include "AliVVertex.h"
+#include "AliEMCalTriggerPatchInfo.h"
#include "AliEMCalHistoContainer.h"
#include "AliEMCalPtTaskVTrackSelection.h"
#include "AliEMCalPtTaskTrackSelectionAOD.h"
AliParticleContainer *trackContainer = this->AddParticleContainer(trackContainerName.Data());
trackContainer->SetClassName("AliVTrack");
this->AddClusterContainer(clusterContainerName.Data());
+ this->SetCaloTriggerPatchInfoName("EmcalTriggers");
fHistos = new AliEMCalHistoContainer("PtEMCalTriggerHistograms");
fHistos->ReleaseOwner();
const TAxis *clusteraxes[4];
for(int iaxis = 0; iaxis < 4; ++iaxis) clusteraxes[iaxis] = hclusteraxes + iaxis;
try{
+ std::string patchnames[] = {"Level0", "JetHigh", "JetLow", "GammaHigh", "GammaLow"};
+ for(std::string * triggerpatch = patchnames; triggerpatch < patchnames + sizeof(patchnames)/sizeof(std::string); ++triggerpatch){
+ fHistos->CreateTH1(Form("Energy%s", triggerpatch->c_str()), Form("Patch energy for %s trigger patches", triggerpatch->c_str()), 100, 0., 100.);
+ fHistos->CreateTH1(Form("EnergyMain%s", triggerpatch->c_str()), Form("Patch energy for main %s trigger patches", triggerpatch->c_str()), 100, 0., 100.);
+ }
+
// Create histogram for MC-truth
fHistos->CreateTHnSparse("hMCtrueParticles", "Particle-based histogram for MC-true particles", 3, trackaxes);
for(std::map<std::string,std::string>::iterator it = triggerCombinations.begin(); it != triggerCombinations.end(); ++it){
fUseTriggersFromTriggerMaker = kTRUE;
}
+ // Loop over trigger patches, fill patch energy
+ AliEmcalTriggerPatchInfo *triggerpatch(NULL);
+ TIter patchIter(this->fTriggerPatchInfo);
+ while((triggerpatch = dynamic_cast<AliEmcalTriggerPatchInfo *>(patchIter()))){
+ if(triggerpatch->IsJetHigh()){
+ fHistos->FillTH1("EnergyJetHigh", triggerpatch->GetPatchE());
+ if(triggerpatch->IsMainTrigger())
+ fHistos->FillTH1("EnergyMainJetHigh", triggerpatch->GetPatchE());
+ }
+ if(triggerpatch->IsJetLow()){
+ fHistos->FillTH1("EnergyJetLow", triggerpatch->GetPatchE());
+ if(triggerpatch->IsMainTrigger())
+ fHistos->FillTH1("EnergyMainJetLow", triggerpatch->GetPatchE());
+ }
+ if(triggerpatch->IsGammaHigh()){
+ fHistos->FillTH1("EnergyGammaHigh", triggerpatch->GetPatchE());
+ if(triggerpatch->IsMainTrigger())
+ fHistos->FillTH1("EnergyMainGammaHigh", triggerpatch->GetPatchE());
+ }
+ if(triggerpatch->IsGammaLow()){
+ fHistos->FillTH1("EnergyGammaLow", triggerpatch->GetPatchE());
+ if(triggerpatch->IsMainTrigger())
+ fHistos->FillTH1("EnergyMainGammaLow", triggerpatch->GetPatchE());
+ }
+ if(triggerpatch->IsLevel0()){
+ fHistos->FillTH1("EnergyLevel0", triggerpatch->GetPatchE());
+ if(triggerpatch->IsMainTrigger())
+ fHistos->FillTH1("EnergyMainLevel0", triggerpatch->GetPatchE());
+ }
+ }
+
const AliVVertex *vtxTracks = fInputEvent->GetPrimaryVertex(),
*vtxSPD = GetSPDVertex();
if(!(vtxTracks && vtxSPD)) return false;