#include <AliTriggerAnalysis.h>
#include <AliLog.h>
+#include <AliAnalysisManager.h>
#include <AliESDEvent.h>
fHistFMDC(0),
fHistFMDSingle(0),
fHistFMDSum(0),
+ fHistT0(0),
fTriggerClasses(0),
fMC(kFALSE),
fEsdTrackCuts(0),
fHistFMDSum = 0;
}
+ if (fHistT0)
+ {
+ delete fHistT0;
+ fHistT0 = 0;
+ }
+
if (fTriggerClasses)
{
fTriggerClasses->DeleteAll();
fHistZDC = new TH1F("fHistZDC", "ZDC;trigger bits;events", 8, -1.5, 6.5);
fHistTDCZDC = new TH1F("fHistTDCZDC", "ZDC;TDC bits;events", 32, -0.5, 32-0.5);
fHistTimeZDC = new TH2F("fHistTimeZDC", "ZDC;TDC timing A+C vs C-A; events", 120,-30,30,120,-600,-540);
- fHistTimeCorrZDC = new TH2F("fHistTimeCorrZDC", "ZDC;Corrected TDC timing A+C vs C-A; events", 120,-30,30,120,-100,-40);
+ fHistTimeCorrZDC = new TH2F("fHistTimeCorrZDC", "ZDC;Corrected TDC timing A+C vs C-A; events", 120,-30,30,260,-100,30);
// TODO check limits
fHistFMDA = new TH1F("fHistFMDA", "FMDA;combinations above threshold;events", 102, -1.5, 100.5);
fHistFMDC = new TH1F("fHistFMDC", "FMDC;combinations above threshold;events", 102, -1.5, 100.5);
fHistFMDSingle = new TH1F("fHistFMDSingle", "FMD single;multiplicity value;counts", 1000, 0, 10);
fHistFMDSum = new TH1F("fHistFMDSum", "FMD sum;multiplicity value;counts", 1000, 0, 10);
+ fHistT0 = new TH1F("fHistT0", "T0;time (ns);events", 100, -25, 25);
fTriggerClasses = new TMap;
fTriggerClasses->SetOwner();
case kZDC : str = "ZDC"; break;
case kZDCA : str = "ZDC A"; break;
case kZDCC : str = "ZDC C"; break;
+ case kZNA : str = "ZN A"; break;
+ case kZNC : str = "ZN C"; break;
+ case kZNABG : str = "ZN A BG"; break;
+ case kZNCBG : str = "ZN C BG"; break;
case kFMDA : str = "FMD A"; break;
case kFMDC : str = "FMD C"; break;
case kFPANY : str = "SPD GFO | V0 | ZDC | FMD"; break;
case kZDCTDCA : str = "ZDC TDC A"; break;
case kZDCTDCC : str = "ZDC TDC C"; break;
case kZDCTime : str = "ZDC Time Cut"; break;
+ case kCentral : str = "V0 Central"; break;
+ case kSemiCentral : str = "V0 Semi-central"; break;
+ case kEMCAL : str = "EMCAL"; break;
default: str = ""; break;
}
decision = 1;
break;
}
+ case kT0:
+ {
+ if (T0Trigger(aEsd, !offline) == kT0BB)
+ decision = 1;
+ break;
+ }
+ case kT0BG:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (T0Trigger(aEsd, !offline) == kT0DecBG)
+ decision = 1;
+ break;
+ }
+ case kT0Pileup:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (T0Trigger(aEsd, !offline) == kT0DecPileup)
+ decision = 1;
+ break;
+ }
case kZDCA:
{
if (!offline)
decision = 1;
break;
}
+ case kZNA:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (ZDCTDCTrigger(aEsd,kASide,kTRUE,kFALSE,kFALSE))
+ decision = 1;
+ break;
+ }
+ case kZNC:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (ZDCTDCTrigger(aEsd,kCSide,kTRUE,kFALSE,kFALSE))
+ decision = 1;
+ break;
+ }
+ case kZNABG:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (ZDCTimeBGTrigger(aEsd,kASide))
+ decision = 1;
+ break;
+ }
+ case kZNCBG:
+ {
+ if (!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (ZDCTimeBGTrigger(aEsd,kCSide))
+ decision = 1;
+ break;
+ }
case kFMDA:
{
if (!offline)
AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
return IsLaserWarmUpTPCEvent(aEsd);
}
+ case kCentral:
+ {
+ if (offline)
+ AliFatal(Form("Offline trigger not available for trigger %d - use centrality selection", triggerNoFlags));
+ if (aEsd->GetVZEROData()) {
+ if (aEsd->GetVZEROData()->TestBit(AliESDVZERO::kTriggerChargeBitsFilled)) {
+ if (aEsd->GetVZEROData()->GetTriggerBits() & (1<<AliESDVZERO::kCTA2andCTC2))
+ decision = kTRUE;
+ }
+ else
+ AliWarning("V0 centrality trigger bits were not filled!");
+ }
+ break;
+ }
+ case kSemiCentral:
+ {
+ if (offline)
+ AliFatal(Form("Offline trigger not available for trigger %d - use centrality selection", triggerNoFlags));
+ if (aEsd->GetVZEROData()) {
+ if (aEsd->GetVZEROData()->TestBit(AliESDVZERO::kTriggerChargeBitsFilled)) {
+ if (aEsd->GetVZEROData()->GetTriggerBits() & (1<<AliESDVZERO::kCTA1andCTC1))
+ decision = kTRUE;
+ }
+ else
+ AliWarning("V0 centrality trigger bits were not filled!");
+ }
+ break;
+ }
+ case kEMCAL:
+ {
+ if(!offline)
+ AliFatal(Form("Online trigger not available for trigger %d", triggerNoFlags));
+ if (EMCALCellsTrigger(aEsd))
+ decision = kTRUE;
+ break;
+ }
default:
{
AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
decision = kTRUE;
break;
}
+ case kZNA:
+ {
+ if (ZDCTDCTrigger(aEsd,kASide,kTRUE,kFALSE,kFALSE))
+ decision = kTRUE;
+ break;
+ }
+ case kZNC:
+ {
+ if (ZDCTDCTrigger(aEsd,kCSide,kTRUE,kFALSE,kFALSE))
+ decision = kTRUE;
+ break;
+ }
+ case kZNABG:
+ {
+ if (ZDCTimeBGTrigger(aEsd,kASide))
+ decision = kTRUE;
+ break;
+ }
+ case kZNCBG:
+ {
+ if (ZDCTimeBGTrigger(aEsd,kCSide))
+ decision = kTRUE;
+ break;
+ }
case kFMDA:
{
if (FMDTrigger(aEsd, kASide))
break;
}
- default:
+ case kEMCAL:
{
+ if (EMCALCellsTrigger(aEsd))
+ decision = kTRUE;
+ break;
+ }
+ default:
+ {
AliFatal(Form("Trigger type %d not implemented", triggerNoFlags));
}
}
V0Trigger(aEsd, kASide, kFALSE, kTRUE);
V0Trigger(aEsd, kCSide, kFALSE, kTRUE);
+ T0Trigger(aEsd, kFALSE, kTRUE);
ZDCTDCTrigger(aEsd,kASide,kFALSE,kFALSE,kTRUE);
ZDCTimeTrigger(aEsd,kTRUE);
IsSPDClusterVsTrackletBG(aEsd, kTRUE);
static UInt_t zpa = 0x02;
static UInt_t zna = 0x01;
- fHistZDC->Fill(1, quality & zna);
- fHistZDC->Fill(2, quality & zpa);
- fHistZDC->Fill(3, quality & zem2);
- fHistZDC->Fill(4, quality & zem1);
- fHistZDC->Fill(5, quality & znc);
- fHistZDC->Fill(6, quality & zpc);
+ fHistZDC->Fill(1, (quality & zna) ? 1 : 0);
+ fHistZDC->Fill(2, (quality & zpa) ? 1 : 0);
+ fHistZDC->Fill(3, (quality & zem2) ? 1 : 0);
+ fHistZDC->Fill(4, (quality & zem1) ? 1 : 0);
+ fHistZDC->Fill(5, (quality & znc) ? 1 : 0);
+ fHistZDC->Fill(6, (quality & zpc) ? 1 : 0);
}
else
{
return zdcAccept;
}
+Bool_t AliTriggerAnalysis::ZDCTimeBGTrigger(const AliESDEvent *aEsd, AliceSide side) const
+{
+ // This method implements a selection
+ // based on the timing in of zdcN
+ // It can be used in order to flag background
+ // ** So far only implemented for the 2012 pA run **
+
+ if(fMC) return kFALSE;
+
+ AliESDZDC *zdcData = aEsd->GetESDZDC();
+ Bool_t zna = kFALSE;
+ Bool_t znc = kFALSE;
+
+ Float_t tdcC=999, tdcCcorr=999, tdcA=999, tdcAcorr=999;
+ for(Int_t i = 0; i < 4; ++i) {
+ if (zdcData->GetZDCTDCData(10,i) != 0) {
+ znc = kTRUE;
+ tdcC = 0.025*(zdcData->GetZDCTDCData(10,i)-zdcData->GetZDCTDCData(14,i));
+ tdcCcorr = zdcData->GetZDCTDCCorrected(10,i);
+ }
+ }
+ for(Int_t j = 0; j < 4; ++j) {
+ if (zdcData->GetZDCTDCData(12,j) != 0) {
+ zna = kTRUE;
+ tdcA = 0.025*(zdcData->GetZDCTDCData(12,j)-zdcData->GetZDCTDCData(14,j));
+ tdcAcorr = zdcData->GetZDCTDCCorrected(12,j);
+ }
+ }
+
+ const Int_t runNumber = aEsd->GetRunNumber();
+ if(runNumber<188124 || runNumber>188374){
+ AliError(Form(" ZN BG time cut not implemented for run %d",runNumber));
+ return kFALSE;
+ }
+
+ Bool_t znabg = (zna && (TMath::Abs(tdcAcorr)>2.0));
+ Bool_t zncbg = (znc && (TMath::Abs(tdcCcorr)>5.0));
+
+ // Printf("Checking ZN background (time) for run %d, A = %d, time=%2.2f, C = %d, time=%2.2f",runNumber,(Int_t)zna,tdcAcorr,(Int_t)znc,tdcCcorr);
+ // Printf("Checking ZN background (time) for run %d, A-BG = %d, C-BG = %d",runNumber,(Int_t)znabg,(Int_t)zncbg);
+
+ if (side == kASide) return znabg;
+ if (side == kCSide) return zncbg;
+ return kFALSE;
+}
+
Bool_t AliTriggerAnalysis::ZDCTrigger(const AliESDEvent* aEsd, AliceSide side) const
{
// Returns if ZDC triggered
TObject* obj;
// collections of all histograms
- const Int_t nHists = 13;
+ const Int_t nHists = 14;
TList collections[nHists];
Int_t count = 0;
collections[n++].Add(entry->fHistBitsSPD);
collections[n++].Add(entry->fHistFiredBitsSPD);
collections[n++].Add(entry->fHistSPDClsVsTrk);
+ collections[n++].Add(entry->fHistT0);
// merge fTriggerClasses
TIterator* iter2 = entry->fTriggerClasses->MakeIterator();
fHistBitsSPD->Merge(&collections[n++]);
fHistFiredBitsSPD->Merge(&collections[n++]);
fHistSPDClsVsTrk->Merge(&collections[n++]);
+ fHistT0->Merge(&collections[n++]);
delete iter;
return count+1;
else Printf("Cannot save fHistFMDSum");
if (fSPDGFOEfficiency) fSPDGFOEfficiency->Write("fSPDGFOEfficiency");
if (fHistSPDClsVsTrk) fHistSPDClsVsTrk->Write("fHistSPDClsVsTrk");
+ if (fHistT0) fHistT0->Write("fHistT0");
+
// else Printf("Cannot save fSPDGFOEfficiency");
fTriggerClasses->Write("fTriggerClasses", TObject::kSingleKey);
}
+//----------------------------------------------------------------------------------------------------
+AliTriggerAnalysis::T0Decision AliTriggerAnalysis::T0Trigger(const AliESDEvent* aEsd, Bool_t online, Bool_t fillHists)
+{
+ // Returns the T0 TVDC trigger decision
+ //
+ // argument 'online' is used as a switch between online and offline trigger algorithms
+ // in online mode return 0TVX
+ // in offline mode in addition check pile-up and background :
+ // pile-up readed from ESD: check if TVDC (0TVX module name) has more 1 hit;
+ // backgroud flag readed from ESD : check in given time interval OrA and OrC were correct but TVDC not
+ //
+ // Based on an algorithm by Alla Maevskaya
+
+ const AliESDTZERO* esdT0 = aEsd->GetESDTZERO();
+ if (!esdT0)
+ {
+ AliError("AliESDTZERO not available");
+ return kT0Invalid;
+ }
+ //???? AliDebug(2,Form("In T0Trigger: %f %f",esdV0->GetV0ATime(),esdV0->GetV0CTime()));
+ Float_t tvdc[5] ;
+ for (Int_t ii=0; ii<5; ii++)
+ tvdc[ii] = esdT0->GetTVDC(ii);
+ Int_t trig=esdT0->GetT0Trig();
+ // cout<<" T0 trig "<<trig<<endl;
+
+ if(fillHists) fHistT0->Fill(tvdc[0]);
+
+ if (online) {
+ if(trig&1) return kT0BB;
+ }
+ else {
+
+ if (esdT0->GetPileupFlag()) return kT0DecPileup;
+ if (esdT0->GetBackgroundFlag()) return kT0DecBG;
+ if (tvdc[0]>-5 && tvdc[0]<5 && tvdc[0] != 0) return kT0BB;
+ }
+
+ if (fMC)
+ if( esdT0->GetT0zVertex()>-12.3 && esdT0->GetT0zVertex() < 10.3) return kT0BB;
+
+ return kT0Empty;
+}
+
+//----------------------------------------------------------------------------------------------------
+Bool_t AliTriggerAnalysis::EMCALCellsTrigger(const AliESDEvent *aEsd)
+{
+ //
+ // Returns the EMCAL trigger decision
+ // so far only implemented for LHC11a data
+ // see http://alisoft.cern.ch/viewvc/trunk/PWGGA/EMCALTasks/AliEmcalPhysicsSelection.cxx?view=markup&root=AliRoot Revision 56136
+ //
+
+ Bool_t isFired = kTRUE;
+ const Int_t runNumber = aEsd->GetRunNumber();
+
+ /*
+ // Load EMCAL branches from the manager
+ AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
+ am->LoadBranch("EMCALCells.");
+ am->LoadBranch("CaloClusters");
+ */
+
+ // Get EMCAL cells
+ AliVCaloCells *cells = aEsd->GetEMCALCells();
+ const Short_t nCells = cells->GetNumberOfCells();
+
+ // count cells above threshold per sm
+ Int_t nCellCount[10] = {0,0,0,0,0,0,0,0,0,0};
+ for(Int_t iCell=0; iCell<nCells; ++iCell) {
+ Short_t cellId = cells->GetCellNumber(iCell);
+ Double_t cellE = cells->GetCellAmplitude(cellId);
+ Int_t sm = cellId / (24*48);
+ if (cellE>0.1)
+ ++nCellCount[sm];
+ }
+
+ // Trigger decision for LHC11a
+ Bool_t isLedEvent = kFALSE;
+ if ((runNumber>=144871) && (runNumber<=146860)) {
+ if (nCellCount[4] > 100)
+ isLedEvent = kTRUE;
+ else {
+ if ((runNumber>=146858) && (runNumber<=146860)) {
+ if (nCellCount[3]>=35)
+ isLedEvent = kTRUE;
+ }
+ }
+ }
+
+ if (isLedEvent) {
+ isFired = kFALSE;
+ }
+
+ return isFired;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff