Fixing memory handling of AliHLTMUONHitReconstructorComponent during error conditions...
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONHitReconstructor.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 //Author : Indranil Das, SINP, INDIA
21 //         Sukalyan Chattopadhyay, SINP, INDIA
22 //         
23 //Email :  indra.das@saha.ac.in
24 //         sukalyan.chattopadhyay@saha.ac.in 
25 //
26 // This class implements a hit reconstruction algorithm for the dimuon
27 // high level trigger.
28 // The algorithm finds 3 pad clusters by looking for unique pads with a charge
29 // above a certain threshold. A centre of gravity type calculation is applied
30 // to the three pads forming the cluster to find the hit's X or Y coordinate
31 // along the non-bending and bending planes individually.
32 // The sepperate X and Y coordinates are then merged to give the full coordinate
33 // of the hit.
34 /////////////////////////////////////////////////
35
36 #include "AliHLTMUONHitReconstructor.h"
37 #include "AliHLTMUONRecHitsBlockStruct.h"
38 #include <cstring>
39 #include <strings.h>
40
41
42 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDetectorId = 0xA00;
43 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDDLOffSet = 12;
44 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkNofDDL = 8;
45 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkDDLHeaderSize = 8;
46 const AliHLTInt32_t AliHLTMUONHitReconstructor::fgkLutLine = 59648 + 1;
47
48
49 AliHLTMUONHitReconstructor::AliHLTMUONHitReconstructor() :
50         AliHLTLogging(),
51         fHLTMUONDecoder(),
52         fkBlockHeaderSize(8),
53         fkDspHeaderSize(8),
54         fkBuspatchHeaderSize(4),
55         fDCCut(0),
56         fPadData(NULL),
57         fLookUpTableData(NULL),
58         fRecPoints(NULL),
59         fRecPointsCount(NULL),
60         fMaxRecPointsCount(0),
61         fCentralCountB(0),
62         fCentralCountNB(0),
63         fDigitPerDDL(0),
64         fCentralChargeB(NULL),
65         fCentralChargeNB(NULL),
66         fRecX(NULL),
67         fRecY(NULL),
68         fAvgChargeX(NULL),
69         fAvgChargeY(NULL),
70         fNofBChannel(NULL),
71         fNofNBChannel(NULL),
72         fNofFiredDetElem(0),
73         fIdToEntry()
74 {
75         /// Default constructor
76         
77         fkBlockHeaderSize    = 8;
78         fkDspHeaderSize      = 8;
79         fkBuspatchHeaderSize = 4;
80         
81         try
82         {
83                 fPadData = new AliHLTMUONPad[fgkLutLine];
84         }
85         catch (const std::bad_alloc&)
86         {
87                 HLTError("Dynamic memory allocation failed for fPadData in constructor.");
88                 throw;
89         }
90         
91         fPadData[0].fDetElemId = 0;
92         fPadData[0].fIX = 0 ;
93         fPadData[0].fIY = 0 ;
94         fPadData[0].fRealX = 0.0 ;
95         fPadData[0].fRealY = 0.0 ;
96         fPadData[0].fRealZ = 0.0 ;
97         fPadData[0].fHalfPadSize = 0.0 ;
98         fPadData[0].fPlane = -1 ;
99         fPadData[0].fCharge = 0 ;
100         
101         bzero(fGetIdTotalData, 336*237*2*sizeof(int));
102 }
103
104
105 AliHLTMUONHitReconstructor::~AliHLTMUONHitReconstructor()
106 {
107         /// Default destructor
108         
109         if (fPadData)
110         {
111                 delete [] fPadData;
112                 fPadData = NULL;
113         }
114 }
115
116
117 void AliHLTMUONHitReconstructor::SetLookUpTable(
118                 const AliHLTMUONHitRecoLutRow* lookupTable,
119                 const IdManuChannelToEntry* idToEntry
120         )
121 {
122         /// Sets the Lookup table (LUT) containing the position of each pad with
123         /// electronic channel associated with it. Also the appropriate manu
124         /// channel ID mapping to LUT row is also set.
125
126         assert( lookupTable != NULL );
127         assert( idToEntry != NULL );
128         
129         fIdToEntry = idToEntry;
130         fLookUpTableData = lookupTable;
131 }
132
133
134 bool AliHLTMUONHitReconstructor::Run(
135                 const AliHLTUInt32_t* rawData,
136                 AliHLTUInt32_t rawDataSize,
137                 AliHLTMUONRecHitStruct* recHit,
138                 AliHLTUInt32_t& nofHit
139         ) 
140 {
141   // main function called by HLTReconstructor to perform DHLT Hitreconstruction 
142
143   fRecPoints = recHit;
144   fMaxRecPointsCount = nofHit;
145   fRecPointsCount = &nofHit;
146   *fRecPointsCount = 0;
147   fDigitPerDDL = 0;
148
149   if (not DecodeDDL(rawData, rawDataSize)) {
150     // Dont need to log any message again. Already done so in DecodeDDL.
151     return false;
152   }
153
154   if (fDigitPerDDL == 1)
155   {
156     // There are no digits to process so stop here.
157     return true;
158   }
159
160   if (not FindRecHits()) {
161     HLTError("Failed to generate RecHits");
162     return false;
163   }
164
165   return true;
166 }
167
168
169 bool AliHLTMUONHitReconstructor::DecodeDDL(const AliHLTUInt32_t* rawData,AliHLTUInt32_t rawDataSize)
170 {
171   //function to decode Raw Data 
172
173   AliHLTMUONRawDecoder& handler = reinterpret_cast<AliHLTMUONRawDecoder&>(fHLTMUONDecoder.GetHandler());
174   UInt_t bufferSize = UInt_t(rawDataSize*sizeof(AliHLTUInt32_t));
175
176   handler.SetDCCut(fDCCut);
177   handler.SetPadData(fPadData);
178   handler.SetLookUpTable(fLookUpTableData);
179   handler.SetIdManuChannelToEntry(fIdToEntry);
180   handler.SetNofFiredDetElemId(fNofFiredDetElem);
181   handler.SetMaxFiredPerDetElem(fMaxFiredPerDetElem);
182  
183   if(!fHLTMUONDecoder.Decode(rawData,bufferSize))
184     return false;
185
186   fDigitPerDDL = handler.GetDataCount();
187   fMaxFiredPerDetElem[fNofFiredDetElem-1] = handler.GetDataCount();
188     
189   if(fDigitPerDDL == 1){
190     HLTInfo("An Empty DDL File found");
191   }
192     
193   return true;
194 }
195
196
197 bool AliHLTMUONHitReconstructor::FindRecHits()
198 {
199   // fuction that calls hit reconstruction detector element-wise.
200
201   assert( fCentralChargeB == NULL );
202   assert( fCentralChargeNB == NULL );
203   assert( fRecX == NULL );
204   assert( fRecY == NULL );
205   assert( fAvgChargeX == NULL );
206   assert( fAvgChargeY == NULL );
207   assert( fNofBChannel == NULL );
208   assert( fNofNBChannel == NULL );
209   
210   bool resultOk = false;
211
212   for(int iDet=0; iDet<fNofFiredDetElem ; iDet++)
213   {
214     fCentralCountB = 0;
215     fCentralCountNB = 0;
216
217     try
218     {
219       fCentralChargeB = new int[fMaxFiredPerDetElem[iDet]];
220       HLTDebug("Allocated fCentralChargeB with %d elements.", fMaxFiredPerDetElem[iDet]);
221       fCentralChargeNB = new int[fMaxFiredPerDetElem[iDet]];
222       HLTDebug("Allocated fCentralChargeNB with %d elements.", fMaxFiredPerDetElem[iDet]);
223       resultOk = true;
224     }
225     catch(const std::bad_alloc&)
226     {
227       HLTError("Dynamic memory allocation failed for fCentralChargeNB and fCentralChargeB");
228       resultOk = false;
229     }
230
231     // Continue processing, but check if everything is OK as we do, otherwise
232     // do not execute the next steps.
233     if (resultOk)
234     {
235       if(iDet>0)
236         FindCentralHits(fMaxFiredPerDetElem[iDet-1],fMaxFiredPerDetElem[iDet]);
237       else
238         // minimum value is 1 because dataCount in ReadDDL starts from 1 instead of 0;
239         FindCentralHits(1,fMaxFiredPerDetElem[iDet]);
240
241       try
242       {
243         fRecY = new float[fCentralCountB];
244         HLTDebug("Allocated fRecY with %d elements.", fCentralCountB);
245         fRecX = new float[fCentralCountNB];
246         HLTDebug("Allocated fRecX with %d elements.", fCentralCountNB);
247         fAvgChargeY = new float[fCentralCountB];
248         HLTDebug("Allocated fAvgChargeY with %d elements.", fCentralCountB);
249         fAvgChargeX = new float[fCentralCountNB];
250         HLTDebug("Allocated fAvgChargeX with %d elements.", fCentralCountNB);
251         fNofBChannel = new int[fCentralCountB];
252         HLTDebug("Allocated fNofBChannel with %d elements.", fCentralCountB);
253         fNofNBChannel = new int[fCentralCountNB];
254         HLTDebug("Allocated fNofNBChannel with %d elements.", fCentralCountNB);
255         resultOk = true;
256       }
257       catch(const std::bad_alloc&){
258         HLTError("Dynamic memory allocation failed for internal arrays.");
259         resultOk = false;
260       }
261     }
262
263     if (resultOk) RecXRecY();
264     if (resultOk)
265     {
266       resultOk = MergeRecHits();
267     }
268     if (resultOk)
269     {
270       if(iDet==0)
271         // minimum value in loop is 1 because dataCount in ReadDDL starts from 1 instead of 0;
272         for(int i=1;i<fMaxFiredPerDetElem[iDet];i++)
273           fGetIdTotalData[fPadData[i].fIX][fPadData[i].fIY][fPadData[i].fPlane] = 0;
274       else
275         for(int i=fMaxFiredPerDetElem[iDet-1];i<fMaxFiredPerDetElem[iDet];i++)
276           fGetIdTotalData[fPadData[i].fIX][fPadData[i].fIY][fPadData[i].fPlane] = 0;
277     }
278
279     // Make sure to release any memory that was allocated.
280     if (fCentralChargeB != NULL)
281     {
282       delete [] fCentralChargeB;
283       HLTDebug("Released fCentralChargeB array.");
284       fCentralChargeB = NULL;
285     }
286     if (fCentralChargeNB != NULL)
287     {
288       delete [] fCentralChargeNB;
289       HLTDebug("Released fCentralChargeNB array.");
290       fCentralChargeNB = NULL;
291     }
292     if (fRecX != NULL)
293     {
294       delete [] fRecX;
295       HLTDebug("Released fRecX array.");
296       fRecX = NULL;
297     }
298     if (fRecY != NULL)
299     {
300       delete [] fRecY;
301       HLTDebug("Released fRecY array.");
302       fRecY = NULL;
303     }
304     if (fAvgChargeX != NULL)
305     {
306       delete [] fAvgChargeX;
307       HLTDebug("Released fAvgChargeX array.");
308       fAvgChargeX = NULL;
309     }
310     if (fAvgChargeY != NULL)
311     {
312       delete [] fAvgChargeY;
313       HLTDebug("Released fAvgChargeY array.");
314       fAvgChargeY = NULL;
315     }
316     if (fNofBChannel != NULL)
317     {
318       delete [] fNofBChannel;
319       HLTDebug("Released fNofBChannel array.");
320       fNofBChannel = NULL;
321     }
322     if (fNofNBChannel != NULL)
323     {
324       delete [] fNofNBChannel;
325       HLTDebug("Released fNofNBChannel array.");
326       fNofNBChannel = NULL;
327     }
328   }
329
330   Clear();  // clear internal arrays.
331
332   return resultOk;
333 }
334
335
336 void AliHLTMUONHitReconstructor::FindCentralHits(int minPadId, int maxPadId)
337 {
338   // to find central hit associated with each cluster
339
340   assert( fCentralChargeB != NULL );
341   assert( fCentralChargeNB != NULL );
342
343   int b,nb;
344   int idManuChannelCentral;
345   bool hasFind;
346
347   for(int iPad=minPadId;iPad<maxPadId;iPad++){
348
349     fGetIdTotalData[fPadData[iPad].fIX]
350       [fPadData[iPad].fIY]
351       [fPadData[iPad].fPlane] = iPad ;
352     
353     if(fPadData[iPad].fPlane == 0 ){//&& fPadData[iPad].fIY > (0+1) && fPadData[iPad].fIY < (79 - 1)){
354       //if(fPadData[iPad].fIY > 0){
355       if(fCentralCountB>0){
356         hasFind = false;
357         for(b = 0;b<fCentralCountB;b++){
358           idManuChannelCentral = fCentralChargeB[b];
359           if(fPadData[iPad].fIX == fPadData[idManuChannelCentral].fIX
360              &&
361              (fPadData[iPad].fIY 
362               == fPadData[idManuChannelCentral].fIY + 1 
363               ||
364               fPadData[iPad].fIY 
365               == fPadData[idManuChannelCentral].fIY + 2 
366               ||
367               fPadData[iPad].fIY 
368               == fPadData[idManuChannelCentral].fIY - 2 
369               ||
370               fPadData[iPad].fIY 
371               == fPadData[idManuChannelCentral].fIY - 1)){
372             
373             hasFind = true;
374             if(fPadData[iPad].fCharge > fPadData[idManuChannelCentral].fCharge){
375               fCentralChargeB[b] = iPad;
376             }// if condn on pad charge
377           }// if condon on pad position
378         }// for loop over b
379         if(!hasFind){
380           fCentralChargeB[fCentralCountB] = iPad;
381           fCentralCountB++;
382         }
383       }
384       else{
385         fCentralChargeB[fCentralCountB] = iPad;
386         fCentralCountB++;
387       }// check the size of centralHitB
388       for(b = 0;b<fCentralCountB;b++){
389         idManuChannelCentral = fCentralChargeB[b];
390       }
391       //}// if cond on iY > 2 (to avoid edge value pb)
392     }// B/Nb checking
393     else{
394       if(fCentralCountNB>0){
395         hasFind = false;
396         for(nb = 0;nb<fCentralCountNB;nb++){
397           idManuChannelCentral = fCentralChargeNB[nb];
398           if(fPadData[iPad].fIY == fPadData[idManuChannelCentral].fIY
399              &&
400              (fPadData[iPad].fIX 
401               == fPadData[idManuChannelCentral].fIX + 1 
402               ||
403               fPadData[iPad].fIX
404               == fPadData[idManuChannelCentral].fIX + 2
405               ||
406               fPadData[iPad].fIX
407               == fPadData[idManuChannelCentral].fIX - 2
408               ||
409               fPadData[iPad].fIX
410               == fPadData[idManuChannelCentral].fIX - 1)){
411             
412             hasFind = true;       
413             if(fPadData[iPad].fCharge > fPadData[idManuChannelCentral].fCharge){
414               fCentralChargeNB[nb] = iPad;
415             }// if condn over to find higher charge
416           }// if condn over to find position
417         }// for loop over presently all nb values
418         if(!hasFind){
419           fCentralChargeNB[fCentralCountNB] = iPad;
420           fCentralCountNB++;
421         }
422       }// centralHitNB size test
423       else{
424         fCentralChargeNB[fCentralCountNB] = iPad;
425         fCentralCountNB++;
426       }// centralHitNB size test
427       
428     }// fill for bending and nonbending hit
429   }// detElemId loop
430
431 }
432
433
434 void AliHLTMUONHitReconstructor::RecXRecY()
435 {
436   // find reconstructed X and Y for each plane separately
437
438   assert( fRecX != NULL );
439   assert( fRecY != NULL );
440   assert( fAvgChargeX != NULL );
441   assert( fAvgChargeY != NULL );
442   assert( fNofBChannel != NULL );
443   assert( fNofNBChannel != NULL );
444
445   int b,nb;
446   int idCentral;
447   int idLower = 0;
448   int idUpper = 0;
449   int idRight = 0;
450   int idLeft = 0;
451   
452   for(b=0;b<fCentralCountB;b++){
453     idCentral = fCentralChargeB[b];
454
455     if(fPadData[idCentral].fIY==0)
456       idLower = 0;
457     else
458       idLower = fGetIdTotalData[fPadData[idCentral].fIX][fPadData[idCentral].fIY-1][0];
459
460     if(fPadData[idCentral].fIX==236)
461       idUpper = 0;
462     else
463       idUpper = fGetIdTotalData[fPadData[idCentral].fIX][fPadData[idCentral].fIY+1][0];
464
465
466     fRecY[b] = (fPadData[idCentral].fRealY*fPadData[idCentral].fCharge
467                +
468                 fPadData[idUpper].fRealY*fPadData[idUpper].fCharge
469                +
470                 fPadData[idLower].fRealY*fPadData[idLower].fCharge
471                 )/(fPadData[idCentral].fCharge + fPadData[idUpper].fCharge + fPadData[idLower].fCharge) ;
472     
473     fAvgChargeY[b] = (fPadData[idCentral].fCharge + fPadData[idUpper].fCharge + fPadData[idLower].fCharge)/3.0 ;
474     
475     fNofBChannel[b] = 0;
476     if(fPadData[idLower].fCharge>0)
477       fNofBChannel[b]++ ;
478     if(fPadData[idCentral].fCharge>0)
479       fNofBChannel[b]++ ;
480     if(fPadData[idUpper].fCharge>0)
481       fNofBChannel[b]++ ;
482
483     HLTDebug("lower : %d, middle : %d, upper : %d, nofChannel : %d",fPadData[idLower].fCharge,
484             fPadData[idCentral].fCharge,fPadData[idUpper].fCharge,fNofBChannel[b]);
485
486     HLTDebug("RecY[%d] : %f",b,fRecY[b]);
487   }
488       
489   for(nb=0;nb<fCentralCountNB;nb++){
490     idCentral = fCentralChargeNB[nb];
491
492     if(fPadData[idCentral].fIX==0)
493       idLeft = 0;
494     else
495       idLeft = fGetIdTotalData[fPadData[idCentral].fIX-1][fPadData[idCentral].fIY][1];
496     
497     if(fPadData[idCentral].fIX==335)
498       idRight = 0 ;
499     else
500       idRight = fGetIdTotalData[fPadData[idCentral].fIX+1][fPadData[idCentral].fIY][1];
501
502     fRecX[nb] = (fPadData[idCentral].fRealX*fPadData[idCentral].fCharge
503                  +
504                  fPadData[idRight].fRealX*fPadData[idRight].fCharge
505                  +
506                  fPadData[idLeft].fRealX*fPadData[idLeft].fCharge
507                  )/(fPadData[idCentral].fCharge + fPadData[idRight].fCharge + fPadData[idLeft].fCharge);
508     
509
510     fAvgChargeX[nb] = (fPadData[idCentral].fCharge + fPadData[idRight].fCharge + fPadData[idLeft].fCharge)/3.0 ;
511     
512     
513     fNofNBChannel[nb] = 0;
514     if(fPadData[idLeft].fCharge>0)
515       fNofNBChannel[nb]++ ;
516     if(fPadData[idCentral].fCharge>0)
517       fNofNBChannel[nb]++ ;
518     if(fPadData[idRight].fCharge>0)
519       fNofNBChannel[nb]++ ;
520
521     HLTDebug("left : %d, middle : %d, right : %d, nofChannel : %d",fPadData[idLeft].fCharge,
522             fPadData[idCentral].fCharge,fPadData[idRight].fCharge,fNofNBChannel[nb]);
523
524     HLTDebug("RecX[%d] : %f",nb,fRecX[nb]);
525
526   }
527 }
528
529
530 bool AliHLTMUONHitReconstructor::MergeRecHits()
531 {
532   // Merge reconstructed hits first over same plane then bending plane with non-bending plane
533
534   assert( fRecX != NULL );
535   assert( fRecY != NULL );
536   assert( fAvgChargeX != NULL );
537   assert( fAvgChargeY != NULL );
538   assert( fNofBChannel != NULL );
539   assert( fNofNBChannel != NULL );
540
541   int idCentralB,idCentralNB ;
542   float padCenterXB;
543   float padCenterYNB;
544   float diffX,diffY;
545   float halfPadLengthX,halfPadLengthY;
546
547   // MERGE Bending Plane hits, which are placed side by side
548   for(int i=0;i<fCentralCountB-1;i++){
549     if(fRecY[i] != 0.0){
550       for(int j=i+1;j<fCentralCountB;j++){
551                  
552         if(fCentralChargeB[i]==fCentralChargeB[j]){
553           fRecY[j] = 0.0;
554           continue;
555         }
556         else if(
557            (
558             fPadData[fCentralChargeB[i]].fIY == fPadData[fCentralChargeB[j]].fIY
559             )
560            &&
561            (
562             fPadData[fCentralChargeB[i]].fIX == fPadData[fCentralChargeB[j]].fIX + 1
563             ||
564             fPadData[fCentralChargeB[i]].fIX == fPadData[fCentralChargeB[j]].fIX - 1
565             )
566            &&
567            fRecY[j] != 0.0
568            &&
569            fRecY[i] != 0.0
570            ){
571
572           if(fAvgChargeY[i] > fAvgChargeY[j]){
573             fRecY[i] = (fRecY[i]*fAvgChargeY[i] + fRecY[j]*fAvgChargeY[j]
574                         )/(fAvgChargeY[i] + fAvgChargeY[j]);
575             fRecY[j] = 0.0;
576           }
577           else{
578             fRecY[j] = (fRecY[i]*fAvgChargeY[i] + fRecY[j]*fAvgChargeY[j]
579                         )/(fAvgChargeY[i] + fAvgChargeY[j]);
580             fRecY[i] = 0.0;
581
582           }// search for higher charge
583         }//pad position
584       }//j for loop
585     }//if fRecY[i] != 0.0
586   }// i for loop
587   
588   // MERGE Non Bending Plane hits, which are place side by side
589   for(int i=0;i<fCentralCountNB-1;i++){
590     if(fRecX[i] != 0.0){
591       for(int j=i+1;j<fCentralCountNB;j++){
592
593         if(fCentralChargeNB[i]==fCentralChargeNB[j]){
594           fRecX[j] = 0.0;
595           continue;
596         }
597         else if(
598            (
599             fPadData[fCentralChargeNB[i]].fIX == fPadData[fCentralChargeNB[j]].fIX
600             )
601            &&
602            (
603             fPadData[fCentralChargeNB[i]].fIY == fPadData[fCentralChargeNB[j]].fIY + 1
604             ||
605             fPadData[fCentralChargeNB[i]].fIY == fPadData[fCentralChargeNB[j]].fIY - 1
606             )
607            &&
608            fRecX[j] != 0.0
609            &&
610            fRecX[i] != 0.0
611            ){
612
613           if(fAvgChargeX[i] > fAvgChargeX[j]){
614             fRecX[i] = (fRecX[i]*fAvgChargeX[i] + fRecX[j]*fAvgChargeX[j]
615                        )/(fAvgChargeX[i] + fAvgChargeX[j]);
616             fRecX[j] = 0.0;
617           }
618           else{
619             fRecX[j] = (fRecX[i]*fAvgChargeX[i] + fRecX[j]*fAvgChargeX[j]
620                        )/(fAvgChargeX[i] + fAvgChargeX[j]);
621             fRecX[i] = 0.0;
622           }// search for higher charge
623         }//pad position
624       }//j for loop
625     }//if fRecX[i] != 0.0
626   }// i for loop
627
628   // Merge bending Plane hits with Non Bending
629   for(int b=0;b<fCentralCountB;b++){
630     if(fRecY[b]!=0.0){
631       idCentralB = fCentralChargeB[b];
632       padCenterXB = fPadData[idCentralB].fRealX; 
633       
634       halfPadLengthX = fPadData[idCentralB].fIY ;
635
636       for(int nb=0;nb<fCentralCountNB;nb++){
637         if(fRecX[nb]!=0.0){
638           idCentralNB = fCentralChargeNB[nb];
639
640           padCenterYNB = fPadData[idCentralNB].fRealY;
641
642           halfPadLengthY = fPadData[idCentralNB].fHalfPadSize ;
643
644           if(fabsf(fRecX[nb]) > fabsf(padCenterXB))
645             diffX = fabsf(fRecX[nb]) -  fabsf(padCenterXB);
646           else
647             diffX = fabsf(padCenterXB) -  fabsf(fRecX[nb]);
648           
649           if(fabsf(padCenterYNB)>fabsf(fRecY[b]))
650             diffY = fabsf(padCenterYNB) - fabsf(fRecY[b]);
651           else
652             diffY =  fabsf(fRecY[b]) - fabsf(padCenterYNB);
653
654           if(diffX < halfPadLengthX && diffY < halfPadLengthY ){//&& fPadData[idCentralB].fIY != 0){
655
656             if(fNofBChannel[b]==3)
657               fRecY[b] += 0.025*sin(12.0*(fRecY[b] - fPadData[idCentralB].fRealY)) ;
658             
659             fRecX[nb] += 0.075*sin(9.5*(fRecX[nb] - fPadData[idCentralNB].fRealX)) ;
660             
661             // First check that we have not overflowed the buffer.
662             if((*fRecPointsCount) == fMaxRecPointsCount){
663               HLTError("Number of RecHit (i.e. %d) exceeds the max number of RecHit limit %d.",(*fRecPointsCount),fMaxRecPointsCount);
664               return false;
665             }
666             
667             //fRecPoints[(*fRecPointsCount)].fId = idCentralB;
668             fRecPoints[(*fRecPointsCount)].fX = fRecX[nb];
669             fRecPoints[(*fRecPointsCount)].fY = fRecY[b];
670             fRecPoints[(*fRecPointsCount)].fZ = fPadData[idCentralB].fRealZ;
671 //          fRecPoints[(*fRecPointsCount)].fXCenter = fPadData[idCentralNB].fRealX;
672 //          fRecPoints[(*fRecPointsCount)].fYCenter = fPadData[idCentralB].fRealY;
673 //          fRecPoints[(*fRecPointsCount)].fNofBChannel = fNofBChannel[b];
674 //          fRecPoints[(*fRecPointsCount)].fNofNBChannel = fNofNBChannel[nb];
675 //          fRecPoints[(*fRecPointsCount)].fDetElemId = (AliHLTUInt32_t)fPadData[idCentralB].fDetElemId;
676             (*fRecPointsCount)++;
677           }//if lies wihtin 5.0 mm
678         }// condn over fRecX ! = 0.0
679       }// loop over NB side
680     }// condn on fRecY[b] !=  0.0
681   }// loop over B side;
682
683   return true;
684 }
685
686
687 void AliHLTMUONHitReconstructor::Clear()
688 {
689   // function to clear internal arrays.
690
691   for(int iPad=1;iPad<fDigitPerDDL;iPad++){
692     fGetIdTotalData[fPadData[iPad].fIX][fPadData[iPad].fIY][fPadData[iPad].fPlane] = 0;
693     fPadData[iPad].fDetElemId = 0;
694     fPadData[iPad].fIX = 0 ;
695     fPadData[iPad].fIY = 0 ;
696     fPadData[iPad].fRealX = 0.0 ;
697     fPadData[iPad].fRealY = 0.0 ;
698     fPadData[iPad].fRealZ = 0.0 ;
699     fPadData[iPad].fHalfPadSize = -1 ;
700     fPadData[iPad].fPlane = -1 ;
701     fPadData[iPad].fCharge = 0 ;
702   }  
703   
704   for(int i=0;i<13;i++)
705     fMaxFiredPerDetElem[i] = 0;
706 }
707
708
709 AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::AliHLTMUONRawDecoder() :
710         fBufferStart(NULL),
711         fBusPatchId(0),
712         fDCCut(0),
713         fPadData(NULL),
714         fLookUpTableData(NULL),
715         fNofFiredDetElem(NULL),
716         fMaxFiredPerDetElem(NULL),
717         fIdToEntry(),
718         fDataCount(1),
719         fPrevDetElemId(0),
720         fPadCharge(0),
721         fCharge(0.0),
722         fIdManuChannel(0x0),
723         fLutEntry(0)
724 {
725         // ctor
726 }
727
728
729 AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::~AliHLTMUONRawDecoder()
730 {
731         // dtor
732 }
733
734
735 void AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::OnNewBuffer(const void* buffer, UInt_t /*bufferSize*/)
736 {
737         /// Called for every new raw DDL data payload being processed.
738         /// Just clears internal counters.
739         /// \param buffer  The pointer to the raw data buffer.
740
741         assert( buffer != NULL );
742         fBufferStart = buffer;
743         // dataCount starts from 1 because the 0-th element of fPadData is used as null value.
744         fDataCount = 1;
745         *fNofFiredDetElem = 0;
746         fPrevDetElemId = 0 ;
747 };
748
749
750 void AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::OnError(ErrorCode code, const void* location)
751 {
752         /// Called if there was an error detected in the raw DDL data.
753         /// Logs an error message.
754         /// \param code  The error code describing the problem.
755         /// \param location  A pointer to the location in the raw data buffer
756         ///      where the problem was found.
757         
758         long bytepos = long(location) - long(fBufferStart) + sizeof(AliRawDataHeader);
759         HLTError("There is a problem with decoding the raw data. %s (Error code: %d, at byte %d)",
760                 ErrorCodeToMessage(code), code, bytepos
761         );
762 };
763
764
765 void AliHLTMUONHitReconstructor::AliHLTMUONRawDecoder::OnData(UInt_t dataWord, bool /*parityError*/)
766 {
767   //function to arrange the decoded Raw Data
768
769   fIdManuChannel = 0x0;
770   fIdManuChannel = (fIdManuChannel|fBusPatchId)<<17;
771   fIdManuChannel |= (dataWord >> 12) & 0x1FFFF;
772   
773   IdManuChannelToEntry& idToEntry = * const_cast<IdManuChannelToEntry*>(fIdToEntry);
774   fLutEntry = idToEntry[fIdManuChannel];
775   fPadCharge = int(((unsigned short)(dataWord & 0xFFF)) - fLookUpTableData[fLutEntry].fPed);
776   
777   fCharge = 0;    
778   if(fPadCharge > fDCCut && fPadCharge > 5.0*fLookUpTableData[fLutEntry].fSigma){  // (charge > 4) is due cut out the noise level                       
779       
780     fPadData[fDataCount].fDetElemId = fLookUpTableData[fLutEntry].fDetElemId;
781     fPadData[fDataCount].fIX = fLookUpTableData[fLutEntry].fIX;
782     fPadData[fDataCount].fIY = fLookUpTableData[fLutEntry].fIY;
783     fPadData[fDataCount].fRealX = fLookUpTableData[fLutEntry].fRealX;
784     fPadData[fDataCount].fRealY = fLookUpTableData[fLutEntry].fRealY;
785     fPadData[fDataCount].fRealZ = fLookUpTableData[fLutEntry].fRealZ;
786     fPadData[fDataCount].fHalfPadSize = fLookUpTableData[fLutEntry].fHalfPadSize;
787     fPadData[fDataCount].fPlane = fLookUpTableData[fLutEntry].fPlane;
788     
789     if ( fPadCharge < fLookUpTableData[fLutEntry].fThres ) {
790       fCharge = (fLookUpTableData[fLutEntry].fA0)*fPadCharge;
791     }else{
792       fCharge = (fLookUpTableData[fLutEntry].fA0)*(fLookUpTableData[fLutEntry].fThres) 
793         + (fLookUpTableData[fLutEntry].fA0)*(fPadCharge-fLookUpTableData[fLutEntry].fThres) 
794         + (fLookUpTableData[fLutEntry].fA1)*(fPadCharge-fLookUpTableData[fLutEntry].fThres)*(fPadCharge-fLookUpTableData[fLutEntry].fThres);
795     }
796     
797     fPadData[fDataCount].fCharge = fCharge;
798     
799     if(fLookUpTableData[fLutEntry].fDetElemId != fPrevDetElemId){
800       if((*fNofFiredDetElem)>0){
801         fMaxFiredPerDetElem[(*fNofFiredDetElem)-1] = fDataCount;
802       }
803       (*fNofFiredDetElem)++;
804       fPrevDetElemId =  fLookUpTableData[fLutEntry].fDetElemId ;
805     }
806     
807 //     HLTDebug("buspatch : %d, detele : %d, id : %d, manu : %d, channel : %d, iX : %d, iY: %d, (X,Y) : (%f, %f), charge : %d, padsize : %f, plane : %d",
808 //           fBusPatchId,fPadData[fDataCount].fDetElemId,
809 //           fIdManuChannel,((dataWord >> 18) & 0x7FF),((dataWord >> 12) & 0x3F),
810 //           fPadData[fDataCount].fIX,fPadData[fDataCount].fIY,
811 //           fPadData[fDataCount].fRealX,fPadData[fDataCount].fRealY,
812 //           fPadData[fDataCount].fCharge,fPadData[fDataCount].fHalfPadSize,fPadData[fDataCount].fPlane);
813     
814       fDataCount ++;
815   }// if charge is more than DC Cut limit condition
816   
817 }