df49f0649e939bde24a118c66a777c1eb49c8777
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONTriggerReconstructor.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        * 
3  * All rights reserved.                                                   *
4  *                                                                        *
5  * Primary Authors:                                                       *
6  *   Indranil Das <indra.das@saha.ac.in>                                  *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          * 
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /* $Id$ */
18
19 /**********************************************************************
20  Created on : 16/05/2007
21  Purpose    : This class is supposed to read the tracker DDL files and 
22               give the output AliHLTMUONTriggerRecordStruct
23  Author     : Indranil Das, HEP Division, SINP
24  Email      : indra.das@saha.ac.in | indra.ehep@gmail.com
25 **********************************************************************/
26
27 ///*
28 //
29 //  The TrigRec class is designed to deal the rawdata inputfiles to findout the 
30 //  the reconstructed hits at the trigger DDL. The output is send to the output block for further 
31 //  processing.
32 //
33 //  Author : Indranil Das ( indra.das@saha.ac.in || indra.ehep@gmail.com )
34 // 
35 //*/
36
37 #if __GNUC__ >= 3
38 using namespace std;
39 #endif
40
41 #include <vector>
42
43 #include "TObjArray.h"
44
45 #include "AliHLTMUONTriggerReconstructor.h"
46
47 #include "AliMUONTriggerCrate.h"
48 #include "AliMUONLocalTriggerBoard.h"
49 #include "AliMUONTriggerCircuit.h"
50
51 #include "AliMpPad.h"
52 #include "AliMpVSegmentation.h"
53 #include "AliMpSegmentation.h"
54 #include "AliMpDDLStore.h"
55
56
57 const int AliHLTMUONTriggerReconstructor::fgkDetectorId = 0xB00;
58 const int AliHLTMUONTriggerReconstructor::fgkDDLOffSet = 20 ;
59 const int AliHLTMUONTriggerReconstructor::fgkNofDDL = 2 ;
60
61 const int AliHLTMUONTriggerReconstructor::fgkDDLHeaderSize = 8;
62
63 const int AliHLTMUONTriggerReconstructor::fgkEvenLutSize =  5208448+ 1;
64 const int AliHLTMUONTriggerReconstructor::fgkOddLutSize = 5058432 + 1;
65
66 const int AliHLTMUONTriggerReconstructor::fgkLutLine = 10496;
67
68 const int AliHLTMUONTriggerReconstructor::fgkMinIdManuChannel[2] = {1638400, 1720320};
69 const int AliHLTMUONTriggerReconstructor::fgkMaxIdManuChannel[2] = {6846848, 6778752};
70
71 const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[3] = {8.5, 17.0, 25.5};
72 const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[2] = {25.5, 34.0};
73
74 const int AliHLTMUONTriggerReconstructor::fgkDetElem = 9*4 ; // 9 detele per half chamber
75
76 AliHLTMUONTriggerReconstructor::AliHLTMUONTriggerReconstructor() :
77   fPadData(NULL),
78   fLookUpTableData(NULL),
79   fRecPoints(NULL),
80   fRecPointsCount(NULL),
81   fMaxRecPointsCount(0),
82   fDigitPerDDL(0),
83   fNofFiredDetElem(0),
84   fMaxFiredPerDetElem(NULL),
85   fDetManuChannelIdList(NULL),
86   fCentralChargeB(NULL),
87   fCentralChargeNB(NULL),
88   fDDLId(0),
89   fIdOffSet(0),
90   fCrateManager(NULL)
91 {
92   // ctor 
93   
94   if(AliHLTMUONTriggerReconstructor::fgkEvenLutSize > AliHLTMUONTriggerReconstructor::fgkOddLutSize){
95     fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkEvenLutSize];
96   }
97   else{
98     fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkOddLutSize];
99   }
100
101   fMaxFiredPerDetElem = new int[fgkDetElem] ;
102
103   fCrateManager = new AliMUONTriggerCrateStore();   
104   fCrateManager->ReadFromFile();
105
106   bzero(fGetIdTotalData,104*64*2*sizeof(int));
107 }
108
109
110 AliHLTMUONTriggerReconstructor::~AliHLTMUONTriggerReconstructor()
111 {
112   // dtor
113
114   //HLTError("\nEnd of Run\n");
115
116   delete []fPadData;
117   delete []fLookUpTableData;
118   delete fCrateManager ;
119   delete []fMaxFiredPerDetElem;
120 }
121
122 bool AliHLTMUONTriggerReconstructor::LoadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookUpTableData, int lookUpTableId)
123 {
124   if(lookUpTableId<fgkDDLOffSet || lookUpTableId>= fgkDDLOffSet + fgkNofDDL){
125     HLTError("DDL number is out of range (must be %d<=iDDL<%d)",fgkDDLOffSet,fgkDDLOffSet+fgkNofDDL);
126     return false;
127   }
128   
129   fDDLId = lookUpTableId;
130
131   int lutSize = ((lookUpTableId%2)==0) ? fgkEvenLutSize : fgkOddLutSize ;
132   int nofLutLine = fgkLutLine ;
133   fIdOffSet = fgkMinIdManuChannel[lookUpTableId%2];
134
135   int detManuChannelId;
136
137   fLookUpTableData = new AliHLTMUONHitReconstructor::DHLTLut[lutSize];
138
139   fLookUpTableData[0].fIdManuChannel = 0;
140   fLookUpTableData[0].fIX = 0 ;
141   fLookUpTableData[0].fIY = 0 ;
142   fLookUpTableData[0].fRealX = 0.0 ;
143   fLookUpTableData[0].fRealY = 0.0 ;
144   fLookUpTableData[0].fRealZ = 0.0 ;
145   fLookUpTableData[0].fPlane = -1 ;
146   fLookUpTableData[0].fPcbZone = -1 ;
147
148   for(int i=0; i<nofLutLine; i++){
149
150     detManuChannelId = lookUpTableData[i].fIdManuChannel - fIdOffSet + 1;
151     fLookUpTableData[detManuChannelId].fIdManuChannel = lookUpTableData[i].fIdManuChannel - fIdOffSet;
152     fLookUpTableData[detManuChannelId].fIX = lookUpTableData[i].fIX ;
153     fLookUpTableData[detManuChannelId].fIY = lookUpTableData[i].fIY ;
154     fLookUpTableData[detManuChannelId].fRealX = lookUpTableData[i].fRealX ;
155     fLookUpTableData[detManuChannelId].fRealY = lookUpTableData[i].fRealY ;
156     fLookUpTableData[detManuChannelId].fRealZ = lookUpTableData[i].fRealZ ;
157     fLookUpTableData[detManuChannelId].fPcbZone = lookUpTableData[i].fPcbZone ;
158     fLookUpTableData[detManuChannelId].fPlane = lookUpTableData[i].fPlane ;
159   }
160   return true;
161
162   return true;
163 }
164
165 bool AliHLTMUONTriggerReconstructor::Run(int *rawData, int *rawDataSize, AliHLTMUONTriggerRecordStruct trigRecord[], int *nofTrigRec)
166 {
167
168   fRecPoints = &trigRecord[0];
169   fMaxRecPointsCount = *nofTrigRec;
170   fRecPointsCount = nofTrigRec;
171   *fRecPointsCount = 0;
172
173   fPadData[0].fDetElemId = 0;
174   fPadData[0].fBuspatchId = 0;
175   fPadData[0].fIdManuChannel = 0;
176   fPadData[0].fIX = 0 ;
177   fPadData[0].fIY = 0 ;
178   fPadData[0].fRealX = 0.0 ;
179   fPadData[0].fRealY = 0.0 ;
180   fPadData[0].fRealZ = 0.0 ;
181   fPadData[0].fPlane = -1 ;
182   fPadData[0].fPcbZone = -1 ;
183   fPadData[0].fCharge = 0 ;
184   
185   if(!ReadDDL(rawData,rawDataSize)){
186     HLTError("Failed to read the complete DDL file\n");
187     return false;
188   }
189
190   if(!FindTrigHits()){
191     HLTError("Failed to generate RecHits\n");
192     return false;
193   }
194     
195   return true;
196 }
197
198
199 bool AliHLTMUONTriggerReconstructor::ReadDDL(int *rawData, int *rawDataSize)
200 {
201
202   vector<AliHLTMUONHitReconstructor::DHLTPad> padList;
203   int idManuChannel ;
204   
205   int index = 0;
206   int dataCount = 0;
207   fNofFiredDetElem = 0;
208   int detElemId = 0 ;
209   int prevDetElemId = 0 ;
210
211   fDetManuChannelIdList = new int[(*rawDataSize)];
212
213 #ifdef DEBUG
214   int globalcard_data_occurance = (rawData[index]>>10)&0x1; //Set to 1 if global info present in DDL else set to 0 
215   int version = (rawData[index]>>12)&0xFF; // software version
216   int serial_number =  (rawData[index]>>20)&0xF; // serial number set to 0xF 
217 #endif
218   int phys_trig_occur = (rawData[index]>>30)&0x1; // 1 for physics trigger, 0 for software trigger
219   
220   // Values not set
221 //   int regional_structure = (rawData[index])&0xFF ; 
222 //   int DAQ_interfaced = (rawData[index]>>8)&0x1;
223 //   int central_or_LTU = (rawData[index]>>9)&0x1;
224 //   int VME_trigger = (rawData[index]>>11)&0x1;
225 //   int DARC_type =  (rawData[index]>>24)&0x3;
226 //   int dimuon_ZDC = (rawData[index]>>27)&0x3;
227 //   int MBZ = (rawData[index]>>31)&0x1;
228
229   HLTDebug("globalcard_data_occurance  %d, version  %d, serial_number  %d, phys_trig_occur  %d",
230          globalcard_data_occurance,version,serial_number,phys_trig_occur);
231
232   if(!phys_trig_occur) // for software trigger
233     index += 8 ;// corresponding to scalar words
234   
235   index += 1 ; // To skip the separator 0xDEADFACE
236   
237   index += 4 ; // corresponding to global input
238   
239   index += 1 ; // reaches to global output
240   
241   if((fDDLId - AliHLTMUONTriggerReconstructor::fgkDDLOffSet) == 0){ //if globalData is present in DDL 0 (presummed may be changed)
242 #ifdef DEBUG
243     int singleLpt = rawData[index] & 0x1;
244     int singleHpt = (rawData[index] >> 1) & 0x1;
245     
246     int pairUnlikeLpt = (rawData[index] >> 4)  & 0x1;
247     int pairUnlikeHpt = (rawData[index] >> 5)  & 0x1;
248     
249     int pairLikeLpt = (rawData[index] >> 2)  & 0x1;
250     int pairLikeHpt = (rawData[index] >> 3)  & 0x1;
251 #endif // DEBUG
252
253     HLTDebug("singleLpt : %x, singleHpt : %x, pairUnlikeLpt : %x, pairUnlikeHpt : %x, pairLikeLpt : %x, pairLikeHpt : %x",
254              singleLpt,singleHpt,pairUnlikeLpt,pairUnlikeHpt,pairLikeLpt,pairLikeHpt);
255   }
256
257   if(!phys_trig_occur)
258     index += 10 ;// corresponds to scalar words
259   
260   index += 1; // separator 0xDEADBEEF 
261
262   for (int iReg = 0; iReg < 8; iReg++) {
263     index += 1; // DARC Status Word
264     index += 1; // Regeional Word
265     //int reg_output = rawData[index] & 0xFF;
266     int reg_phys_trig_occur = ( rawData[index] >> 31) & 0x1;
267 //     int reg_version;// = ;
268 //     int reg_Id ;//= ;
269 //     int reg_serial_number;// = ;
270     
271     index += 2; // 2 words for regional input
272     
273     index += 1; // L0 counter
274     
275     if(!reg_phys_trig_occur)
276       index += 10;
277     
278     index += 1 ; // end of Regeonal header
279     
280     AliMUONTriggerCrate* crate = fCrateManager->Crate((fDDLId - AliHLTMUONTriggerReconstructor::fgkDDLOffSet), iReg);
281     TObjArray *boards = crate->Boards();
282
283
284     for(int iLoc = 0; iLoc < 16 ; iLoc++){
285
286       int iLocIndex = index ;      
287
288       int locId = (rawData[index+5] >> 19) &  0xF ;
289       
290       AliMUONLocalTriggerBoard* localBoard = (AliMUONLocalTriggerBoard*)boards->At(locId + 1);
291       int iLocCard = localBoard->GetNumber();
292
293       int dec = (rawData[index+5] >> 15) & 0xF;
294       //int triggY = (rawData[index+5] >> 14) & 0x1 ;
295       //int sign = (rawData[index+5] >> 9) & 0x1;
296       //int loDev = (rawData[index+5] >> 5) & 0xF ;
297       //int triggX = (loDev >> 4 & 0x1 ) && !(loDev & 0xF) ;
298
299
300 //       HLTDebug(" \n",
301 //             iLocCard,locId);
302
303 //      index += 5;
304
305       if(iLocCard > 0){
306         if( dec != 0x9 ){ // check for Dec
307
308           index += 1;
309           short X1_pattern = rawData[index] & 0xFFFF; 
310           short X2_pattern = (rawData[index] >> 16) & 0xFFFF; 
311           index += 1; 
312           short X3_pattern = rawData[index] & 0xFFFF; 
313           short X4_pattern = (rawData[index] >> 16) & 0xFFFF; 
314           
315           index += 1;
316           short Y1_pattern = rawData[index] & 0xFFFF; 
317           short Y2_pattern = (rawData[index] >> 16) & 0xFFFF; 
318           index += 1; 
319           short Y3_pattern = rawData[index] & 0xFFFF; 
320           short Y4_pattern = (rawData[index] >> 16) & 0xFFFF; 
321           
322           TArrayS xyPattern[2];
323           xyPattern[0].Set(4);
324           xyPattern[1].Set(4);
325           
326           xyPattern[0].AddAt(X1_pattern,0);
327           xyPattern[0].AddAt(X2_pattern,1);
328           xyPattern[0].AddAt(X3_pattern,2);
329           xyPattern[0].AddAt(X4_pattern,3);
330           
331           xyPattern[1].AddAt(Y1_pattern,0);
332           xyPattern[1].AddAt(Y2_pattern,1);
333           xyPattern[1].AddAt(Y3_pattern,2);
334           xyPattern[1].AddAt(Y4_pattern,3);
335           
336           HLTDebug("iLocCard : %d, locId : %d, X : %x, %x, %x, %x .... Y : %x, %x, %x, %x\n",
337                    iLocCard,locId,X1_pattern,X2_pattern,X3_pattern,X4_pattern,
338                    Y1_pattern,Y2_pattern,Y3_pattern,Y4_pattern);
339         
340           index += 1 ; // skipping the last word though it is important
341           
342           padList.clear() ;
343           if( Pattern2Pad(iLocCard, xyPattern, padList) ) {
344
345             for (UInt_t iEntry = 0; iEntry < padList.size(); iEntry++) {
346               
347               AliHLTMUONHitReconstructor::DHLTPad dPad = padList[iEntry];
348               
349               detElemId = dPad.fDetElemId;
350               int idetElemId = (detElemId)%1000;
351               idetElemId &= 0x1FF ;
352               int iPlane = dPad.fPlane & 0x1 ;
353               int iX = dPad.fIX & 0x7F ;
354               int iY = dPad.fIY & 0x3F ;
355               
356               idManuChannel &= 0x0;
357               idManuChannel = (idManuChannel|idetElemId)<<1;  
358               idManuChannel = (idManuChannel|iPlane)<<7;  
359               idManuChannel = (idManuChannel|iX)<<6 ;
360               idManuChannel |= iY ;
361               idManuChannel -= fIdOffSet ;
362               
363               fPadData[idManuChannel].fDetElemId = dPad.fDetElemId;
364               fPadData[idManuChannel].fIdManuChannel = idManuChannel;
365               fPadData[idManuChannel].fIX = fLookUpTableData[idManuChannel+1].fIX;
366               fPadData[idManuChannel].fIY = fLookUpTableData[idManuChannel+1].fIY;
367               fPadData[idManuChannel].fRealX = fLookUpTableData[idManuChannel+1].fRealX;
368               fPadData[idManuChannel].fRealY = fLookUpTableData[idManuChannel+1].fRealY;
369               fPadData[idManuChannel].fRealZ = fLookUpTableData[idManuChannel+1].fRealZ;
370               fPadData[idManuChannel].fPcbZone = fLookUpTableData[idManuChannel+1].fPcbZone;
371               fPadData[idManuChannel].fPlane = fLookUpTableData[idManuChannel+1].fPlane;
372
373               fDetManuChannelIdList[dataCount] = idManuChannel;
374               if(detElemId != prevDetElemId){
375                 if(fNofFiredDetElem>0){
376                   fMaxFiredPerDetElem[fNofFiredDetElem-1] = dataCount;
377                 }
378                 fNofFiredDetElem++;
379                 prevDetElemId = detElemId ;
380               } // if detelem condn
381               dataCount ++;
382
383 //            printf("detelemId : %d, plane : %d, IX : %d, IY : %d realX : %f, realY : %f , realZ %f\n",
384 //                   dPad.fDetElemId,dPad.fPlane,dPad.fIX,dPad.fIY,
385 //                   fPadData[idManuChannel].fRealX,fPadData[idManuChannel].fRealY,fPadData[idManuChannel].fRealZ);
386               
387             }// for loop of entry
388
389           }//pattern2pad 
390           
391       }// Dec Condn
392
393       }// iLocCard > 0
394
395       if(!reg_phys_trig_occur)
396         index += 45;
397         
398       index += 1; // end of local Data
399       HLTDebug("iReg %d, iLoc %d, iLocCard : %d, locId : %d, trigY %x, triggX %x, loDev %x, dec %x, sign %x,rawData : %x",
400                iReg,iLoc,iLocCard,locId,triggY,triggX,loDev,dec,sign, rawData[index]);
401
402       index = iLocIndex + 6 ;
403       
404 //       delete localBoard;
405
406     }// iLoc loop
407   
408 //     delete crate;
409 //     delete boards;
410     }// iReg Loop
411
412 //   fDigitPerDDL = dataCount;
413 //   fMaxFiredPerDetElem[fNofFiredDetElem-1] = dataCount;
414   
415
416   return true;
417 }
418
419 bool AliHLTMUONTriggerReconstructor::Pattern2Pad(int nBoard, TArrayS* xyPattern, vector<AliHLTMUONHitReconstructor::DHLTPad>& padList)
420 {
421
422   Int_t detElemId;
423   Int_t previousDetElemId[4] = {0};
424   Int_t previousBoard[4] = {0};
425
426
427   // loop over x1-4 and y1-4
428   for(Int_t iChamber = 0; iChamber < 4; ++iChamber){
429     for(Int_t iCath = 0; iCath < 2; ++iCath){
430       //int index = 0;  
431       Int_t pattern = (Int_t)xyPattern[iCath].At(iChamber); 
432       if (!pattern) continue;
433       
434       // get detElemId
435       /*
436       AliMUONTriggerCircuit triggerCircuit;
437       AliMUONLocalTriggerBoard* localBoard = fCrateManager->LocalBoard(nBoard);
438       detElemId = triggerCircuit.DetElemId(iChamber+10, localBoard->GetName());//FIXME +/-10 (should be ok with new mapping)
439       */
440       AliMpDDLStore* ddlStore = AliMpDDLStore::Instance();
441       if (ddlStore != NULL) continue;
442       AliMpLocalBoard* localBoard = ddlStore->GetLocalBoard(nBoard);
443       if (localBoard == NULL) continue;
444       detElemId = localBoard->GetDEIdByChamber(iChamber);
445
446
447       if(iCath == 1){ // FIXME should find a more elegant way
448         // Don't save twice the same digit
449         // (since strips in non bending plane can cross several boards)
450         Int_t prevDetElemId = previousDetElemId[iChamber];
451         Int_t prevBoard = previousBoard[iChamber];
452         previousDetElemId[iChamber] = detElemId;
453         previousBoard[iChamber] = nBoard;
454
455         if(detElemId == prevDetElemId){
456           if(nBoard-prevBoard==1) continue;
457         }
458       }
459
460       const AliMpVSegmentation* seg 
461         = AliMpSegmentation::Instance()
462           ->GetMpSegmentation(detElemId, AliMp::GetCathodType(iCath));  
463
464       // loop over the 16 bits of pattern
465       for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
466         
467         if ((pattern >> ibitxy) & 0x1) {
468           
469           //Int_t temp = (pattern >> ibitxy) & 0x1 ;
470           // not quite sure about this
471           Int_t offset = 0;
472           if (iCath && localBoard->GetSwitch(6)) offset = -8;
473
474           AliMpPad pad = seg->PadByLocation(AliMpIntPair(nBoard,ibitxy+offset),kTRUE);
475
476           AliHLTMUONHitReconstructor::DHLTPad dPad;
477           if (!pad.IsValid()) {
478             //AliWarning(Form("No pad for detElemId: %d, nboard %d, ibitxy: %d\n",
479             //      detElemId, nBoard, ibitxy));
480             continue ;
481           } // 
482
483           Int_t padX = pad.GetIndices().GetFirst();
484           Int_t padY = pad.GetIndices().GetSecond();
485           // file digit
486           dPad.fIX = padX ;
487           dPad.fIY = padY ;
488           dPad.fPlane = iCath ;
489           dPad.fDetElemId = detElemId ;
490           //printf("nBoard : %d, detElemId : %d, chamber %d, iCath %d, ibitxy %d, pattern %d, switch %d, offset %d, temp %x, padX : %d, padY: %d\n",nBoard,detElemId,iChamber,iCath,ibitxy,pattern,localBoard->GetSwitch(6), offset, temp,padX,padY);
491           //dPad.fDetElemId = detElemId ;
492
493           padList.push_back(dPad);
494         
495         }// xyPattern
496       }// ibitxy
497 //       delete localBoard;
498     }// cath
499   } // ichamber
500
501   return true;
502 }
503
504 bool AliHLTMUONTriggerReconstructor::FindTrigHits() 
505 {
506   for(int iDet=0; iDet<fNofFiredDetElem ; iDet++){
507     
508     if(iDet>0)
509       MergeTrigHits(fMaxFiredPerDetElem[iDet-1],fMaxFiredPerDetElem[iDet]);
510     else
511       MergeTrigHits(0,fMaxFiredPerDetElem[iDet]);
512
513     
514 //     if(iDet==0)
515 //       for(int i=0;i<fMaxFiredPerDetElem[iDet];i++)
516 //      fGetIdTotalData[fPadData[fDetManuChannelIdList[i]].fIX][fPadData[fDetManuChannelIdList[i]].fIY][fPadData[fDetManuChannelIdList[i]].fPlane] = 0;
517 //     else
518 //       for(int i=fMaxFiredPerDetElem[iDet-1];i<fMaxFiredPerDetElem[iDet];i++)
519 //      fGetIdTotalData[fPadData[fDetManuChannelIdList[i]].fIX][fPadData[fDetManuChannelIdList[i]].fIY][fPadData[fDetManuChannelIdList[i]].fPlane] = 0;
520
521   }// loop over detection element
522     
523   //for(int iPad=fDataPerDetElem[i];iPad<fDataPerDetElem[i+1];iPad++){
524   for(int iPad=0;iPad<fDigitPerDDL;iPad++){
525 //     fGetIdTotalData[fPadData[fDetManuChannelIdList[iPad]].fIX][fPadData[fDetManuChannelIdList[iPad]].fIY][fPadData[fDetManuChannelIdList[iPad]].fPlane] = 0;
526     fPadData[fDetManuChannelIdList[iPad]].fDetElemId = 0;
527     fPadData[fDetManuChannelIdList[iPad]].fBuspatchId = 0;
528     fPadData[fDetManuChannelIdList[iPad]].fIdManuChannel = 0;
529     fPadData[fDetManuChannelIdList[iPad]].fIX = 0 ;
530     fPadData[fDetManuChannelIdList[iPad]].fIY = 0 ;
531     fPadData[fDetManuChannelIdList[iPad]].fRealX = 0.0 ;
532     fPadData[fDetManuChannelIdList[iPad]].fRealY = 0.0 ;
533     fPadData[fDetManuChannelIdList[iPad]].fRealZ = 0.0 ;
534     fPadData[fDetManuChannelIdList[iPad]].fPlane = -1 ;
535     fPadData[fDetManuChannelIdList[iPad]].fPcbZone = -1 ;
536     fPadData[fDetManuChannelIdList[iPad]].fCharge = 0 ;
537   }  
538   
539   for(int i=0;i<fgkDetElem;i++)
540     fMaxFiredPerDetElem[i] = 0;
541
542   delete []fDetManuChannelIdList;
543
544   return true;
545 }
546
547 bool AliHLTMUONTriggerReconstructor::MergeTrigHits(int minPadId, int maxPadId)
548 {
549   int idManuChannelB, idManuChannelNB;
550   float halfPadLengthX,halfPadLengthY;
551   float diffX,diffY;
552
553   for(int iPad=minPadId;iPad<maxPadId;iPad++){
554     idManuChannelB   = fDetManuChannelIdList[iPad];
555     //printf("idManuChannelB : %d, fPadData[idManuChannelB].fPlane : %d\n",idManuChannelB,fPadData[idManuChannelB].fPlane);
556     if(fPadData[idManuChannelB].fPlane == 0){
557       
558       halfPadLengthX = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[fPadData[idManuChannelB].fPcbZone] ;
559
560       for(int iPad=minPadId;iPad<maxPadId;iPad++){
561         idManuChannelNB   = fDetManuChannelIdList[iPad];
562         if(fPadData[idManuChannelNB].fPlane == 1){
563           
564           halfPadLengthY = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[fPadData[idManuChannelNB].fPcbZone] ;
565           
566           if(fabsf(fPadData[idManuChannelNB].fRealX) > fabsf(fPadData[idManuChannelB].fRealX))
567             diffX = fabsf(fPadData[idManuChannelNB].fRealX) - fabsf(fPadData[idManuChannelB].fRealX);
568           else
569             diffX = fabsf(fPadData[idManuChannelB].fRealX) - fabsf(fPadData[idManuChannelNB].fRealX) ;
570
571           
572           if(fabsf(fPadData[idManuChannelNB].fRealY) > fabsf(fPadData[idManuChannelB].fRealY))
573             diffY = fabsf(fPadData[idManuChannelNB].fRealY) - fabsf(fPadData[idManuChannelB].fRealY);
574           else
575             diffY = fabsf(fPadData[idManuChannelB].fRealY) - fabsf(fPadData[idManuChannelNB].fRealY) ;
576           //printf("diffX %f,  halfPadLengthX %f,  diffY  %f, halfPadLengthY  %f\n",diffX,halfPadLengthX,diffY,halfPadLengthY);
577
578           if(diffX < halfPadLengthX + 1.0 && diffY < halfPadLengthY + 1.0 ){// added redundancy of 1.0 cm due to the pb of geometrical segmentation 
579
580             AliHLTMUONRecHitStruct hit;
581             hit.fX = fPadData[idManuChannelNB].fRealX;
582             hit.fY = fPadData[idManuChannelNB].fRealY;
583             hit.fZ = fPadData[idManuChannelNB].fRealZ;
584
585             int ichamber = int((fPadData[idManuChannelB].fDetElemId - 1000)/100);
586             ichamber--;
587             fRecPoints[(*fRecPointsCount)].fHit[ichamber] = hit;
588             
589             (*fRecPointsCount)++;
590             if((*fRecPointsCount) == fMaxRecPointsCount){
591               printf("Nof RecHit (i.e. %d) exceeds the max nof RecHit limit %d\n",(*fRecPointsCount),fMaxRecPointsCount);
592               return false;
593             }
594
595             printf("ichamber : %d, detelem : %d, x %f, y %f, z %f\n",ichamber,fPadData[idManuChannelB].fDetElemId,fPadData[idManuChannelNB].fRealX,
596                    fPadData[idManuChannelB].fRealY,fPadData[idManuChannelB].fRealZ);
597           }
598           
599           
600           
601
602         }//condn for non-bending plane
603       }//for loop for non-bending plane
604
605     }// condn for bending plane
606   }// for loop for bending plane
607
608   return true;
609 }
610