Removing useless flag.
[u/mrichter/AliRoot.git] / PHOS / AliPHOSTrigger.cxx
CommitLineData
25354ff4 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15/* $Id$ */
25354ff4 16
17//_________________________________________________________________________
25354ff4 18// Class for trigger analysis.
59264fa6 19// Digits are grouped in TRU's (Trigger Units). A TRU consist of 16x28
20// crystals ordered fNTRUPhi x fNTRUZ. The algorithm searches all possible
dab66d03 21// 2x2 and nxn (n multiple of 2) crystal combinations per each TRU, adding the
22// digits amplitude and finding the maximum. If found, look if it is isolated.
64df000d 23// Maxima are transformed in ADC time samples. Each time bin is compared to the trigger
24// threshold until it is larger and then, triggers are set. Thresholds need to be fixed.
bb38a8fc 25// Usage:
26//
27// //Inside the event loop
dab66d03 28// AliPHOSTrigger *tr = new AliPHOSTrigger();//Init Trigger
59264fa6 29// tr->SetL0Threshold(100);
bb38a8fc 30// tr->SetL1JetLowPtThreshold(1000);
dab66d03 31// tr->SetL1JetMediumPtThreshold(10000);
bb38a8fc 32// tr->SetL1JetHighPtThreshold(20000);
64df000d 33// ....
bb38a8fc 34// tr->Trigger(); //Execute Trigger
64df000d 35// tr->Print(""); //Print data members after calculation.
36//
bb38a8fc 37//
25354ff4 38//*-- Author: Gustavo Conesa & Yves Schutz (IFIC, CERN)
39//////////////////////////////////////////////////////////////////////////////
40
41
42// --- ROOT system ---
bfae5a5d 43#include "TMath.h"
25354ff4 44
45// --- ALIROOT system ---
bfae5a5d 46#include "AliConfig.h"
59264fa6 47#include "AliPHOS.h"
25354ff4 48#include "AliPHOSTrigger.h"
49#include "AliPHOSGeometry.h"
bfae5a5d 50#include "AliPHOSDigit.h"
51#include "AliPHOSLoader.h"
431a9211 52#include "AliPHOSPulseGenerator.h"
b165f59d 53#include "AliTriggerInput.h"
dab66d03 54
25354ff4 55
56ClassImp(AliPHOSTrigger)
57
b165f59d 58//______________________________________________________________________
59AliPHOSTrigger::AliPHOSTrigger()
59264fa6 60 : AliTriggerDetector(),
3663622c 61 f2x2MaxAmp(-1), f2x2CrystalPhi(-1), f2x2CrystalEta(-1), f2x2SM(0),
0b2ec9f7 62 fnxnMaxAmp(-1), fnxnCrystalPhi(-1), fnxnCrystalEta(-1), fnxnSM(0),
63 fADCValuesHighnxn(0), fADCValuesLownxn(0),
3663622c 64 fADCValuesHigh2x2(0), fADCValuesLow2x2(0), fDigitsList(0),
6483babc 65 fAmptrus(0), fAmpmods(0), fTimeRtrus(0),
dab66d03 66 fL0Threshold(50), fL1JetLowPtThreshold(200), fL1JetMediumPtThreshold(500),
67 fL1JetHighPtThreshold(1000),
64df000d 68 fNTRU(8), fNTRUZ(2), fNTRUPhi(4),
69 fNCrystalsPhi(16),
70 fNCrystalsZ(28),
71 fPatchSize(1), fIsolPatchSize(1),
72 f2x2AmpOutOfPatch(-1), fnxnAmpOutOfPatch(-1),
73 f2x2AmpOutOfPatchThres(2), fnxnAmpOutOfPatchThres(2), //2 GeV out of patch
74 fIs2x2Isol(kFALSE), fIsnxnIsol(kFALSE),
552c2d0e 75 fSimulation(kTRUE), fIsolateInModule(kTRUE)
25354ff4 76{
b165f59d 77 //ctor
0b2ec9f7 78 fADCValuesHighnxn = 0x0; //new Int_t[fTimeBins];
79 fADCValuesLownxn = 0x0; //new Int_t[fTimeBins];
59264fa6 80 fADCValuesHigh2x2 = 0x0; //new Int_t[fTimeBins];
81 fADCValuesLow2x2 = 0x0; //new Int_t[fTimeBins];
82
59264fa6 83 SetName("PHOS");
84 CreateInputs();
85
6483babc 86 fAmptrus = new TClonesArray("TMatrixD",1000);
87 fAmpmods = new TClonesArray("TMatrixD",1000);
88 fTimeRtrus = new TClonesArray("TMatrixD",1000);
25354ff4 89}
90
91//____________________________________________________________________________
3663622c 92AliPHOSTrigger::AliPHOSTrigger(const AliPHOSTrigger & trig) :
93 AliTriggerDetector(trig),
94 f2x2MaxAmp(trig.f2x2MaxAmp),
95 f2x2CrystalPhi(trig.f2x2CrystalPhi),
96 f2x2CrystalEta(trig.f2x2CrystalEta),
97 f2x2SM(trig.f2x2SM),
0b2ec9f7 98 fnxnMaxAmp(trig.fnxnMaxAmp),
99 fnxnCrystalPhi(trig.fnxnCrystalPhi),
100 fnxnCrystalEta(trig.fnxnCrystalEta),
101 fnxnSM(trig.fnxnSM),
102 fADCValuesHighnxn(trig.fADCValuesHighnxn),
103 fADCValuesLownxn(trig.fADCValuesLownxn),
3663622c 104 fADCValuesHigh2x2(trig.fADCValuesHigh2x2),
105 fADCValuesLow2x2(trig.fADCValuesLow2x2),
106 fDigitsList(trig.fDigitsList),
6483babc 107 fAmptrus(trig.fAmptrus), fAmpmods(trig.fAmpmods), fTimeRtrus(trig.fTimeRtrus),
3663622c 108 fL0Threshold(trig.fL0Threshold),
109 fL1JetLowPtThreshold(trig.fL1JetLowPtThreshold),
dab66d03 110 fL1JetMediumPtThreshold(trig.fL1JetMediumPtThreshold),
3663622c 111 fL1JetHighPtThreshold(trig.fL1JetHighPtThreshold),
112 fNTRU(trig.fNTRU),
113 fNTRUZ(trig.fNTRUZ),
114 fNTRUPhi(trig.fNTRUPhi),
64df000d 115 fNCrystalsPhi(trig.fNCrystalsPhi),
116 fNCrystalsZ(trig. fNCrystalsZ),
117 fPatchSize(trig.fPatchSize),
118 fIsolPatchSize(trig.fIsolPatchSize),
119 f2x2AmpOutOfPatch(trig.f2x2AmpOutOfPatch),
120 fnxnAmpOutOfPatch(trig.fnxnAmpOutOfPatch),
121 f2x2AmpOutOfPatchThres(trig.f2x2AmpOutOfPatchThres),
122 fnxnAmpOutOfPatchThres(trig.fnxnAmpOutOfPatchThres),
123 fIs2x2Isol(trig.fIs2x2Isol),
124 fIsnxnIsol(trig.fIsnxnIsol),
dab66d03 125 fSimulation(trig.fSimulation),
126 fIsolateInModule(trig.fIsolateInModule)
25354ff4 127{
25354ff4 128 // cpy ctor
25354ff4 129}
130
bfae5a5d 131//_________________________________________________________________________
316c6cd9 132AliPHOSTrigger::~AliPHOSTrigger()
133{
134 // dtor
135
136 if(fADCValuesHighnxn)delete [] fADCValuesHighnxn;
137 if(fADCValuesLownxn)delete [] fADCValuesLownxn;
138 if(fADCValuesHigh2x2)delete [] fADCValuesHigh2x2;
139 if(fADCValuesLow2x2)delete [] fADCValuesLow2x2;
140 // fDigitsList is now ours...
6483babc 141 if(fAmptrus) { fAmptrus->Delete() ; delete fAmptrus ; }
142 if(fAmpmods) { fAmpmods->Delete() ; delete fAmpmods ; }
143 if(fTimeRtrus) { fTimeRtrus->Delete(); delete fTimeRtrus; }
316c6cd9 144}
145
59264fa6 146//_________________________________________________________________________
3663622c 147AliPHOSTrigger & AliPHOSTrigger::operator = (const AliPHOSTrigger &)
148{
149 Fatal("operator =", "no implemented");
150 return *this;
151}
152
b165f59d 153void AliPHOSTrigger::CreateInputs()
154{
155 // inputs
156
157 // Do not create inputs again!!
158 if( fInputs.GetEntriesFast() > 0 ) return;
572b6f20 159
160 TString name = GetName();
b165f59d 161
22d1e468 162 fInputs.AddLast( new AliTriggerInput( "0PH0", name, 0 ) );
572b6f20 163 fInputs.AddLast( new AliTriggerInput( "PHOS_JetHPt_L1",name, 1 ) );
164 fInputs.AddLast( new AliTriggerInput( "PHOS_JetMPt_L1",name, 1 ) );
165 fInputs.AddLast( new AliTriggerInput( "PHOS_JetLPt_L1",name, 1 ) );
b165f59d 166
167}
168
25354ff4 169//____________________________________________________________________________
6483babc 170void AliPHOSTrigger::FillTRU(const TClonesArray * digits, const AliPHOSGeometry * geom) const {
25354ff4 171
59264fa6 172 //Orders digits ampitudes list and times in fNTRU TRUs (28x16 crystals)
173 //per module. Each TRU is a TMatrixD, and they are kept in TClonesArrays.
174 //In a module, the number of TRU in phi is fNTRUPhi, and the number of
dab66d03 175 //TRU in eta is fNTRUZ. Also fill a matrix with all amplitudes in module for isolation studies.
25354ff4 176
bb38a8fc 177 //Check data members
178
179 if(fNTRUZ*fNTRUPhi != fNTRU)
180 Error("FillTRU"," Wrong number of TRUS per Z or Phi");
25354ff4 181
59264fa6 182 //Initilize and declare variables
183 Int_t nModules = geom->GetNModules();
59264fa6 184 Int_t relid[4] ;
185 Float_t amp = -1;
186 Float_t timeR = -1;
187 Int_t id = -1;
25354ff4 188
59264fa6 189 //List of TRU matrices initialized to 0.
2ff6837e 190 for(Int_t k = 0; k < fNTRU*nModules ; k++){
7b12cb6a 191 TMatrixD amptrus(fNCrystalsPhi,fNCrystalsZ) ;
192 TMatrixD timeRtrus(fNCrystalsPhi,fNCrystalsZ) ;
64df000d 193 for(Int_t i = 0; i < fNCrystalsPhi; i++){
194 for(Int_t j = 0; j < fNCrystalsZ; j++){
7b12cb6a 195 amptrus(i,j) = 0.0;
196 timeRtrus(i,j) = 0.0;
59264fa6 197 }
198 }
6483babc 199 new((*fAmptrus)[k]) TMatrixD(amptrus) ;
200 new((*fTimeRtrus)[k]) TMatrixD(timeRtrus) ;
552c2d0e 201 }
202
203 //List of Modules matrices initialized to 0.
204 Int_t nmodphi = geom->GetNPhi();
205 Int_t nmodz = geom->GetNZ();
206
207 for(Int_t k = 0; k < nModules ; k++){
7b12cb6a 208 TMatrixD ampmods(nmodphi,nmodz) ;
552c2d0e 209 for(Int_t i = 0; i < nmodphi; i++){
210 for(Int_t j = 0; j < nmodz; j++){
7b12cb6a 211 ampmods(i,j) = 0.0;
552c2d0e 212 }
213 }
6483babc 214 new((*fAmpmods)[k]) TMatrixD(ampmods) ;
25354ff4 215 }
216
217 AliPHOSDigit * dig ;
59264fa6 218
bb38a8fc 219 //Digits loop to fill TRU matrices with amplitudes.
25354ff4 220 for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
221
59264fa6 222 dig = static_cast<AliPHOSDigit *>(digits->At(idig)) ;
0b2ec9f7 223 amp = dig->GetEnergy() ; // Energy of the digit
59264fa6 224 id = dig->GetId() ; // Id label of the cell
225 timeR = dig->GetTimeR() ; // Earliest time of the digit
226 geom->AbsToRelNumbering(id, relid) ;
bb38a8fc 227 //Transform digit number into 4 numbers
25354ff4 228 //relid[0] = module
229 //relid[1] = EMC (0) or CPV (-1)
230 //relid[2] = row <= 64 (fNPhi)
231 //relid[3] = column <= 56 (fNZ)
232
bb38a8fc 233 if(relid[1] == 0){//Not CPV, Only EMC digits
552c2d0e 234 //############# TRU ###################
59264fa6 235 //Check to which TRU in the supermodule belongs the crystal.
bb38a8fc 236 //Supermodules are divided in a TRU matrix of dimension
237 //(fNTRUPhi,fNTRUZ).
64df000d 238 //Each TRU is a crystal matrix of dimension (fNCrystalsPhi,fNCrystalsZ)
25354ff4 239
bb38a8fc 240 //First calculate the row and column in the supermodule
59264fa6 241 //of the TRU to which the crystal belongs.
64df000d 242 Int_t col = (relid[3]-1)/fNCrystalsZ+1;
243 Int_t row = (relid[2]-1)/fNCrystalsPhi+1;
59264fa6 244
245 //Calculate label number of the TRU
246 Int_t itru = (row-1) + (col-1)*fNTRUPhi + (relid[0]-1)*fNTRU ;
2ff6837e 247
59264fa6 248 //Fill TRU matrix with crystal values
09828f52 249 TMatrixD * amptrus = static_cast<TMatrixD *>(fAmptrus ->At(itru)) ;
250 TMatrixD * timeRtrus = static_cast<TMatrixD *>(fTimeRtrus->At(itru)) ;
2ff6837e 251
59264fa6 252 //Calculate row and column of the crystal inside the TRU with number itru
64df000d 253 Int_t irow = (relid[2]-1) - (row-1) * fNCrystalsPhi;
254 Int_t icol = (relid[3]-1) - (col-1) * fNCrystalsZ;
59264fa6 255
256 (*amptrus)(irow,icol) = amp ;
257 (*timeRtrus)(irow,icol) = timeR ;
552c2d0e 258
dab66d03 259 //####################MODULE MATRIX ##################
09828f52 260 TMatrixD * ampmods = static_cast<TMatrixD *>(fAmpmods->At(relid[0]-1)) ;
552c2d0e 261 (*ampmods)(relid[2]-1,relid[3]-1) = amp ;
25354ff4 262 }
263 }
25354ff4 264}
265
59264fa6 266//______________________________________________________________________
8368e0ee 267void AliPHOSTrigger::GetCrystalPhiEtaIndexInModuleFromTRUIndex(Int_t itru, Int_t iphitru, Int_t ietatru,Int_t &iphiMod,Int_t &ietaMod) const
59264fa6 268{
269 // This method transforms the (eta,phi) index of a crystals in a
270 // TRU matrix into Super Module (eta,phi) index.
271
272 // Calculate in which row and column in which the TRU are
273 // ordered in the SM
274 Int_t col = itru/ fNTRUPhi + 1;
275 Int_t row = itru - (col-1)*fNTRUPhi + 1;
276
277 //Calculate the (eta,phi) index in SM
59264fa6 278
64df000d 279 iphiMod = fNCrystalsPhi*(row-1) + iphitru + 1 ;
dab66d03 280 ietaMod = fNCrystalsZ*(col-1) + ietatru + 1 ;
59264fa6 281
282}
64df000d 283
284//____________________________________________________________________________
6483babc 285Bool_t AliPHOSTrigger::IsPatchIsolated(Int_t iPatchType, const Int_t imod, const Int_t mtru, const Float_t maxamp, const Int_t maxphi, const Int_t maxeta) {
64df000d 286
287 //Calculate if the maximum patch found is isolated, find amplitude around maximum (2x2 or nxn) patch,
288 //inside isolation patch . iPatchType = 0 means calculation for 2x2 patch,
289 //iPatchType = 1 means calculation for nxn patch.
290 //In the next table there is an example of the different options of patch size and isolation patch size:
291 // Patch Size (fPatchSize)
292 // 0 1 2
293 // fIsolPatchSize 2x2 (not overlap) 4x4 (overlapped) 6x6(overlapped) ...
294 // 1 4x4 8x8 10x10
295 // 2 6x6 12x12 14x14
296 // 3 8x8 16x16 18x18
297
298 Bool_t b = kFALSE;
299 Float_t amp = 0;
300
552c2d0e 301 //Get matrix of TRU or Module with maximum amplitude patch.
64df000d 302 Int_t itru = mtru+imod*fNTRU ; //number of tru, min 0 max 8*5.
552c2d0e 303 TMatrixD * ampmatrix = 0x0;
304 Int_t colborder = 0;
305 Int_t rowborder = 0;
306
307 if(fIsolateInModule){
09828f52 308 ampmatrix = static_cast<TMatrixD *>(fAmpmods->At(imod)) ;
552c2d0e 309 rowborder = fNCrystalsPhi*fNTRUPhi;
310 colborder = fNCrystalsZ*fNTRUZ;
311 AliDebug(2,"Isolate trigger in Module");
312 }
313 else{
09828f52 314 ampmatrix = static_cast<TMatrixD *>(fAmptrus->At(itru)) ;
552c2d0e 315 rowborder = fNCrystalsPhi;
316 colborder = fNCrystalsZ;
317 AliDebug(2,"Isolate trigger in TRU");
318 }
319
64df000d 320 //Define patch cells
321 Int_t isolcells = fIsolPatchSize*(1+iPatchType);
322 Int_t ipatchcells = 2*(1+fPatchSize*iPatchType);
552c2d0e 323 Int_t minrow = maxphi - isolcells;
324 Int_t mincol = maxeta - isolcells;
325 Int_t maxrow = maxphi + isolcells + ipatchcells;
326 Int_t maxcol = maxeta + isolcells + ipatchcells;
64df000d 327
328 AliDebug(2,Form("Number of added Isol Cells %d, Patch Size %d",isolcells, ipatchcells));
329 AliDebug(2,Form("Patch: minrow %d, maxrow %d, mincol %d, maxcol %d",minrow,maxrow,mincol,maxcol));
552c2d0e 330
331 if(minrow < 0 || mincol < 0 || maxrow > rowborder || maxcol > colborder){
dab66d03 332 AliDebug(1,Form("Out of Module/TRU range, cannot isolate patch"));
64df000d 333 return kFALSE;
334 }
335
336 //Add amplitudes in all isolation patch
337 for(Int_t irow = minrow ; irow < maxrow; irow ++)
338 for(Int_t icol = mincol ; icol < maxcol ; icol ++)
552c2d0e 339 amp += (*ampmatrix)(irow,icol);
64df000d 340
552c2d0e 341 AliDebug(2,Form("Type %d, Maximum amplitude %f, patch+isol square %f",iPatchType, maxamp, amp));
64df000d 342
24331838 343 if(amp < maxamp){
552c2d0e 344 AliError(Form("Bad sum: Type %d, Maximum amplitude %f, patch+isol square %f",iPatchType, maxamp, amp));
64df000d 345 return kFALSE;
346 }
347 else
552c2d0e 348 amp-=maxamp; //Calculate energy in isolation patch that do not comes from maximum patch.
64df000d 349
552c2d0e 350 AliDebug(2, Form("Maximum amplitude %f, Out of patch %f",maxamp, amp));
64df000d 351
352 //Fill isolation amplitude data member and say if patch is isolated.
353 if(iPatchType == 0){ //2x2 case
354 f2x2AmpOutOfPatch = amp;
355 if(amp < f2x2AmpOutOfPatchThres)
356 b=kTRUE;
357 }
358 else if(iPatchType == 1){ //nxn case
359 fnxnAmpOutOfPatch = amp;
360 if(amp < fnxnAmpOutOfPatchThres)
361 b=kTRUE;
362 }
363
364 return b;
365
366}
367
368
25354ff4 369//____________________________________________________________________________
6483babc 370void AliPHOSTrigger::MakeSlidingCell(const Int_t imod, TMatrixD &ampmax2, TMatrixD &ampmaxn)
371{
0b2ec9f7 372 //Sums energy of all possible 2x2 (L0) and nxn (L1) crystals per each TRU.
59264fa6 373 //Fast signal in the experiment is given by 2x2 crystals,
374 //for this reason we loop inside the TRU crystals by 2.
25354ff4 375
59264fa6 376 //Declare and initialize varibles
59264fa6 377 Float_t amp2 = 0 ;
0b2ec9f7 378 Float_t ampn = 0 ;
379 for(Int_t i = 0; i < 4; i++){
59264fa6 380 for(Int_t j = 0; j < fNTRU; j++){
7b12cb6a 381 ampmax2(i,j) = -1;
382 ampmaxn(i,j) = -1;
59264fa6 383 }
384 }
25354ff4 385
59264fa6 386 //Create matrix that will contain 2x2 amplitude sums
0b2ec9f7 387 //used to calculate the nxn sums
7b12cb6a 388 TMatrixD tru2x2(fNCrystalsPhi/2,fNCrystalsZ/2) ;
64df000d 389 for(Int_t i = 0; i < fNCrystalsPhi/2; i++)
390 for(Int_t j = 0; j < fNCrystalsZ/2; j++)
7b12cb6a 391 tru2x2(i,j) = -1.;
59264fa6 392
25354ff4 393 //Loop over all TRUS in a module
64df000d 394 for(Int_t itru = 0 + imod * fNTRU ; itru < (imod+1)*fNTRU ; itru++){
09828f52 395 TMatrixD * amptru = static_cast<TMatrixD *>(fAmptrus ->At(itru)) ;
396 TMatrixD * timeRtru = static_cast<TMatrixD *>(fTimeRtrus->At(itru)) ;
64df000d 397 Int_t mtru = itru-imod*fNTRU ; //Number of TRU in Module
59264fa6 398
399 //Sliding 2x2, add 2x2 amplitudes (NOT OVERLAP)
64df000d 400 for(Int_t irow = 0 ; irow < fNCrystalsPhi; irow += 2){
401 for(Int_t icol = 0 ; icol < fNCrystalsZ ; icol += 2){
59264fa6 402 amp2 = (*amptru)(irow,icol)+(*amptru)(irow+1,icol)+
403 (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
0b2ec9f7 404 //Fill new matrix with added 2x2 crystals for use in nxn sums
7b12cb6a 405 tru2x2(irow/2,icol/2) = amp2 ;
59264fa6 406 //Select 2x2 maximum sums to select L0
7b12cb6a 407 if(amp2 > ampmax2(0,mtru)){
408 ampmax2(0,mtru) = amp2 ;
409 ampmax2(1,mtru) = irow;
410 ampmax2(2,mtru) = icol;
25354ff4 411 }
25354ff4 412 }
413 }
2ff6837e 414
59264fa6 415 //Find most recent time in the selected 2x2 cell
7b12cb6a 416 ampmax2(3,mtru) = 1 ;
417 Int_t row2 = static_cast <Int_t> (ampmax2(1,mtru));
418 Int_t col2 = static_cast <Int_t> (ampmax2(2,mtru));
59264fa6 419 for(Int_t i = 0; i<2; i++){
420 for(Int_t j = 0; j<2; j++){
421 if((*amptru)(row2+i,col2+j) > 0 && (*timeRtru)(row2+i,col2+j)> 0){
7b12cb6a 422 if((*timeRtru)(row2+i,col2+j) < ampmax2(3,mtru) )
423 ampmax2(3,mtru) = (*timeRtru)(row2+i,col2+j);
59264fa6 424 }
425 }
426 }
2ff6837e 427
0b2ec9f7 428 //Sliding nxn, add nxn amplitudes (OVERLAP)
429 if(fPatchSize > 0){
64df000d 430 for(Int_t irow = 0 ; irow < fNCrystalsPhi/2; irow++){
431 for(Int_t icol = 0 ; icol < fNCrystalsZ/2 ; icol++){
0b2ec9f7 432 ampn = 0;
64df000d 433 if( (irow+fPatchSize) < fNCrystalsPhi/2 && (icol+fPatchSize) < fNCrystalsZ/2){//Avoid exit the TRU
0b2ec9f7 434 for(Int_t i = 0 ; i <= fPatchSize ; i++)
435 for(Int_t j = 0 ; j <= fPatchSize ; j++)
7b12cb6a 436 ampn += tru2x2(irow+i,icol+j);
0b2ec9f7 437 //Select nxn maximum sums to select L1
7b12cb6a 438 if(ampn > ampmaxn(0,mtru)){
439 ampmaxn(0,mtru) = ampn ;
440 ampmaxn(1,mtru) = irow*2;
441 ampmaxn(2,mtru) = icol*2;
0b2ec9f7 442 }
59264fa6 443 }
444 }
445 }
0b2ec9f7 446
447 //Find most recent time in selected nxn cell
7b12cb6a 448 ampmaxn(3,mtru) = 1 ;
449 Int_t rown = static_cast <Int_t> (ampmaxn(1,mtru));
450 Int_t coln = static_cast <Int_t> (ampmaxn(2,mtru));
0b2ec9f7 451 for(Int_t i = 0; i<4*fPatchSize; i++){
452 for(Int_t j = 0; j<4*fPatchSize; j++){
64df000d 453 if( (rown+i) < fNCrystalsPhi && (coln+j) < fNCrystalsZ/2){//Avoid exit the TRU
0b2ec9f7 454 if((*amptru)(rown+i,coln+j) > 0 && (*timeRtru)(rown+i,coln+j)> 0){
7b12cb6a 455 if((*timeRtru)(rown+i,coln+j) < ampmaxn(3,mtru) )
456 ampmaxn(3,mtru) = (*timeRtru)(rown+i,coln+j);
0b2ec9f7 457 }
458 }
59264fa6 459 }
460 }
461 }
0b2ec9f7 462 else {
7b12cb6a 463 ampmaxn(0,mtru) = ampmax2(0,mtru);
464 ampmaxn(1,mtru) = ampmax2(1,mtru);
465 ampmaxn(2,mtru) = ampmax2(2,mtru);
466 ampmaxn(3,mtru) = ampmax2(3,mtru);
0b2ec9f7 467 }
25354ff4 468 }
25354ff4 469}
64df000d 470
471
25354ff4 472//____________________________________________________________________________
473void AliPHOSTrigger::Print(const Option_t * opt) const
474{
475
476 //Prints main parameters
477
478 if(! opt)
479 return;
b165f59d 480 AliTriggerInput* in = 0x0 ;
25354ff4 481
59264fa6 482 printf( " Maximum Amplitude after Sliding Crystal, \n") ;
483 printf( " -2x2 crystals sum (not overlapped): %10.2f, in Super Module %d\n",
484 f2x2MaxAmp,f2x2SM) ;
485 printf( " -2x2 from row %d to row %d and from column %d to column %d\n", f2x2CrystalPhi, f2x2CrystalPhi+2, f2x2CrystalEta, f2x2CrystalEta+2) ;
64df000d 486 printf( " -2x2 Isolation Patch %d x %d, Amplitude out of 2x2 patch is %f, threshold %f, Isolated? %d \n",
487 2*fIsolPatchSize+2, 2*fIsolPatchSize+2, f2x2AmpOutOfPatch, f2x2AmpOutOfPatchThres,static_cast<Int_t> (fIs2x2Isol)) ;
0b2ec9f7 488 if(fPatchSize > 0){
64df000d 489 printf( " Patch Size, n x n: %d x %d cells\n",2*(fPatchSize+1), 2*(fPatchSize+1));
0b2ec9f7 490 printf( " -nxn crystals sum (overlapped) : %10.2f, in Super Module %d\n",
491 fnxnMaxAmp,fnxnSM) ;
dab66d03 492 printf( " -nxn from row %d to row %d and from column %d to column %d\n", fnxnCrystalPhi, fnxnCrystalPhi+4*fPatchSize, fnxnCrystalEta, fnxnCrystalEta+4*fPatchSize) ;
64df000d 493 printf( " -nxn Isolation Patch %d x %d, Amplitude out of nxn patch is %f, threshold %f, Isolated? %d \n",
494 4*fIsolPatchSize+2*(fPatchSize+1),4*fIsolPatchSize+2*(fPatchSize+1) , fnxnAmpOutOfPatch, fnxnAmpOutOfPatchThres,static_cast<Int_t> (fIsnxnIsol) ) ;
0b2ec9f7 495 }
552c2d0e 496
497 printf( " Isolate in Module? %d\n",
498 fIsolateInModule) ;
499
59264fa6 500 printf( " Threshold for LO %10.1f\n",
501 fL0Threshold) ;
502
503 printf( " Threshold for LO %10.2f\n", fL0Threshold) ;
22d1e468 504 in = (AliTriggerInput*)fInputs.FindObject( "0PH0" );
b165f59d 505 if(in->GetValue())
59264fa6 506 printf( " *** PHOS LO is set ***\n") ;
507
508 printf( " Jet Low Pt Threshold for L1 %10.2f\n", fL1JetLowPtThreshold) ;
509 in = (AliTriggerInput*)fInputs.FindObject( "PHOS_JetLPt_L1" );
66f9b73c 510 if(in->GetValue())
59264fa6 511 printf( " *** PHOS Jet Low Pt for L1 is set ***\n") ;
66f9b73c 512
dab66d03 513 printf( " Jet Medium Pt Threshold for L1 %10.2f\n", fL1JetMediumPtThreshold) ;
514 in = (AliTriggerInput*)fInputs.FindObject( "PHOS_JetMPt_L1" );
515 if(in->GetValue())
516 printf( " *** PHOS Jet Medium Pt for L1 is set ***\n") ;
517
59264fa6 518 printf( " Jet High Pt Threshold for L1 %10.2f\n", fL1JetHighPtThreshold) ;
519 in = (AliTriggerInput*) fInputs.FindObject( "PHOS_JetHPt_L1" );
b165f59d 520 if(in->GetValue())
59264fa6 521 printf( " *** PHOS Jet High Pt for L1 is set ***\n") ;
dab66d03 522
59264fa6 523}
b165f59d 524
59264fa6 525//____________________________________________________________________________
6483babc 526void AliPHOSTrigger::SetTriggers(const Int_t iMod, const TMatrixD & ampmax2, const TMatrixD & ampmaxn)
59264fa6 527{
0b2ec9f7 528 //Checks the 2x2 and nxn maximum amplitude per each TRU and compares
64df000d 529 //with the different L0 and L1 triggers thresholds. It finds if maximum amplitudes are isolated.
59264fa6 530
531 //Initialize variables
532 Float_t max2[] = {-1,-1,-1,-1} ;
0b2ec9f7 533 Float_t maxn[] = {-1,-1,-1,-1} ;
64df000d 534 Int_t mtru2 = -1 ;
535 Int_t mtrun = -1 ;
59264fa6 536
537
538 //Find maximum summed amplitude of all the TRU
539 //in a Module
540 for(Int_t i = 0 ; i < fNTRU ; i++){
7b12cb6a 541 if(max2[0] < ampmax2(0,i) ){
542 max2[0] = ampmax2(0,i) ; // 2x2 summed max amplitude
543 max2[1] = ampmax2(1,i) ; // corresponding phi position in TRU
544 max2[2] = ampmax2(2,i) ; // corresponding eta position in TRU
545 max2[3] = ampmax2(3,i) ; // corresponding most recent time
64df000d 546 mtru2 = i ; // TRU number in module
59264fa6 547 }
7b12cb6a 548 if(maxn[0] < ampmaxn(0,i) ){
549 maxn[0] = ampmaxn(0,i) ; // nxn summed max amplitude
550 maxn[1] = ampmaxn(1,i) ; // corresponding phi position in TRU
551 maxn[2] = ampmaxn(2,i) ; // corresponding eta position in TRU
552 maxn[3] = ampmaxn(3,i) ; // corresponding most recent time
64df000d 553 mtrun = i ; // TRU number in module
59264fa6 554 }
555 }
556
557 //Set max amplitude if larger than in other Modules
558 Float_t maxtimeR2 = -1 ;
0b2ec9f7 559 Float_t maxtimeRn = -1 ;
431a9211 560 // Create a shaper pulse object
ec24419a 561 AliPHOSPulseGenerator pulse ;
562 Int_t nTimeBins = pulse.GetRawFormatTimeBins() ;
59264fa6 563
564 //Set max 2x2 amplitude and select L0 trigger
565 if(max2[0] > f2x2MaxAmp ){
566 f2x2MaxAmp = max2[0] ;
567 f2x2SM = iMod ;
568 maxtimeR2 = max2[3] ;
64df000d 569 GetCrystalPhiEtaIndexInModuleFromTRUIndex(mtru2,
431a9211 570 static_cast<Int_t>(max2[1]),
571 static_cast<Int_t>(max2[2]),
64df000d 572 f2x2CrystalPhi,f2x2CrystalEta) ;
59264fa6 573
64df000d 574 //Isolated patch?
552c2d0e 575 if(fIsolateInModule)
6483babc 576 fIs2x2Isol = IsPatchIsolated(0, iMod, mtru2, f2x2MaxAmp, f2x2CrystalPhi,f2x2CrystalEta) ;
552c2d0e 577 else
6483babc 578 fIs2x2Isol = IsPatchIsolated(0, iMod, mtru2, f2x2MaxAmp, static_cast<Int_t>(max2[1]), static_cast<Int_t>(max2[2])) ;
64df000d 579
59264fa6 580 //Transform digit amplitude in Raw Samples
563bea42 581 if (fADCValuesLow2x2 == 0) {
582 fADCValuesLow2x2 = new Int_t[nTimeBins];
563bea42 583 }
316c6cd9 584 if(!fADCValuesHigh2x2) fADCValuesHigh2x2 = new Int_t[nTimeBins];
585
59264fa6 586
ec24419a 587 pulse.SetAmplitude(f2x2MaxAmp);
588 pulse.SetTZero(maxtimeR2);
589 pulse.MakeSamples();
590 pulse.GetSamples(fADCValuesHigh2x2, fADCValuesLow2x2) ;
59264fa6 591
592 //Set Trigger Inputs, compare ADC time bins until threshold is attained
593 //Set L0
594 for(Int_t i = 0 ; i < nTimeBins ; i++){
431a9211 595 if(fADCValuesHigh2x2[i] >= fL0Threshold || fADCValuesLow2x2[i] >= fL0Threshold) {
22d1e468 596 SetInput("0PH0") ;
59264fa6 597 break;
598 }
599 }
59264fa6 600 }
601
0b2ec9f7 602 //Set max nxn amplitude and select L1 triggers
64df000d 603 if(maxn[0] > fnxnMaxAmp && fPatchSize > 0){
0b2ec9f7 604 fnxnMaxAmp = maxn[0] ;
605 fnxnSM = iMod ;
606 maxtimeRn = maxn[3] ;
64df000d 607 GetCrystalPhiEtaIndexInModuleFromTRUIndex(mtrun,
431a9211 608 static_cast<Int_t>(maxn[1]),
609 static_cast<Int_t>(maxn[2]),
64df000d 610 fnxnCrystalPhi,fnxnCrystalEta) ;
59264fa6 611
64df000d 612 //Isolated patch?
552c2d0e 613 if(fIsolateInModule)
6483babc 614 fIsnxnIsol = IsPatchIsolated(1, iMod, mtrun, fnxnMaxAmp, fnxnCrystalPhi, fnxnCrystalEta) ;
552c2d0e 615 else
6483babc 616 fIsnxnIsol = IsPatchIsolated(1, iMod, mtrun, fnxnMaxAmp, static_cast<Int_t>(maxn[1]), static_cast<Int_t>(maxn[2])) ;
64df000d 617
59264fa6 618 //Transform digit amplitude in Raw Samples
563bea42 619 if (fADCValuesHighnxn == 0) {
620 fADCValuesHighnxn = new Int_t[nTimeBins];
621 fADCValuesLownxn = new Int_t[nTimeBins];
622 }
431a9211 623
3c98f2c0 624 pulse.SetAmplitude(fnxnMaxAmp);
625 pulse.SetTZero(maxtimeRn);
ec24419a 626 pulse.MakeSamples();
627 pulse.GetSamples(fADCValuesHighnxn, fADCValuesLownxn) ;
59264fa6 628
629 //Set Trigger Inputs, compare ADC time bins until threshold is attained
630 //SetL1 Low
631 for(Int_t i = 0 ; i < nTimeBins ; i++){
0b2ec9f7 632 if(fADCValuesHighnxn[i] >= fL1JetLowPtThreshold || fADCValuesLownxn[i] >= fL1JetLowPtThreshold){
59264fa6 633 SetInput("PHOS_JetLPt_L1") ;
634 break;
635 }
636 }
dab66d03 637 //SetL1 Medium
638 for(Int_t i = 0 ; i < nTimeBins ; i++){
639 if(fADCValuesHighnxn[i] >= fL1JetMediumPtThreshold || fADCValuesLownxn[i] >= fL1JetMediumPtThreshold){
640 SetInput("PHOS_JetMPt_L1") ;
641 break;
642 }
643 }
59264fa6 644 //SetL1 High
645 for(Int_t i = 0 ; i < nTimeBins ; i++){
0b2ec9f7 646 if(fADCValuesHighnxn[i] >= fL1JetHighPtThreshold || fADCValuesLownxn[i] >= fL1JetHighPtThreshold){
59264fa6 647 SetInput("PHOS_JetHPt_L1") ;
648 break;
649 }
650 }
59264fa6 651 }
25354ff4 652}
653
654//____________________________________________________________________________
bfae5a5d 655void AliPHOSTrigger::Trigger(TClonesArray *digits)
25354ff4 656{
59264fa6 657 //Main Method to select triggers.
25354ff4 658
bfae5a5d 659 fDigitsList = digits;
660 DoIt() ;
ec24419a 661}
662
663//____________________________________________________________________________
bfae5a5d 664void AliPHOSTrigger::DoIt()
ec24419a 665{
666 // does the trigger job
667
33c3c91a 668 AliRunLoader* rl = AliRunLoader::Instance() ;
09828f52 669 AliPHOSLoader * phosLoader = static_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
ec24419a 670
6c8cd883 671 // Get PHOS Geometry object
672 AliPHOSGeometry *geom;
673 if (!(geom = AliPHOSGeometry::GetInstance()))
674 geom = AliPHOSGeometry::GetInstance("IHEP","");
59264fa6 675
676 //Define parameters
677 Int_t nModules = geom->GetNModules();
64df000d 678 fNCrystalsPhi = geom->GetNPhi()/fNTRUPhi ;// 64/4=16
679 fNCrystalsZ = geom->GetNZ()/fNTRUZ ;// 56/2=28
59264fa6 680
681 //Intialize data members each time the trigger is called in event loop
682 f2x2MaxAmp = -1; f2x2CrystalPhi = -1; f2x2CrystalEta = -1;
0b2ec9f7 683 fnxnMaxAmp = -1; fnxnCrystalPhi = -1; fnxnCrystalEta = -1;
59264fa6 684
685 //Take the digits list if simulation
686 if(fSimulation)
bfae5a5d 687 fDigitsList = phosLoader->Digits() ;
59264fa6 688
689 if(!fDigitsList)
690 AliFatal("Digits not found !") ;
66f9b73c 691
59264fa6 692 //Fill TRU Matrix
6483babc 693// TClonesArray * amptrus = new TClonesArray("TMatrixD",1000);
694// TClonesArray * ampmods = new TClonesArray("TMatrixD",1000);
695// TClonesArray * timeRtrus = new TClonesArray("TMatrixD",1000);
696 FillTRU(fDigitsList,geom) ;
59264fa6 697
698 //Do Crystal Sliding and select Trigger
699 //Initialize varible that will contain maximum amplitudes and
700 //its corresponding cell position in eta and phi, and time.
7b12cb6a 701 TMatrixD ampmax2(4,fNTRU) ;
702 TMatrixD ampmaxn(4,fNTRU) ;
59264fa6 703
64df000d 704 for(Int_t imod = 0 ; imod < nModules ; imod++) {
705
0b2ec9f7 706 //Do 2x2 and nxn sums, select maximums.
6483babc 707 MakeSlidingCell(imod, ampmax2, ampmaxn);
59264fa6 708 //Set the trigger
6483babc 709 SetTriggers(imod,ampmax2,ampmaxn) ;
59264fa6 710 }
64df000d 711
6483babc 712 fAmptrus->Delete();
713// delete amptrus; amptrus=0;
714 fAmpmods->Delete();
715// delete ampmods; ampmods=0;
716 fTimeRtrus->Delete();
717// delete timeRtrus; timeRtrus=0;
64df000d 718 //Print();
719
25354ff4 720}