added proper handling of EMCAL calibration events
[u/mrichter/AliRoot.git] / HLT / EMCAL / AliHLTEMCALDigitMakerComponent.cxx
1  // $Id$
2
3  /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        *
5  * All rights reserved.                                                   *
6  *                                                                        *
7  * Primary Authors: Oystein Djuvsland                                     *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17 #include "AliHLTEMCALDigitMakerComponent.h"
18 #include "AliHLTCaloDigitMaker.h"
19 #include "AliHLTCaloDigitDataStruct.h"
20 #include "AliHLTCaloChannelDataHeaderStruct.h"
21 #include "AliHLTCaloChannelDataStruct.h"
22 #include "AliHLTEMCALMapper.h"
23 #include "AliHLTEMCALDefinitions.h"
24 #include "AliCaloCalibPedestal.h"
25 #include "AliEMCALCalibData.h"
26 #include "AliCDBEntry.h"
27 #include "AliCDBPath.h"
28 #include "AliCDBManager.h"
29 #include "AliRawDataHeader.h"
30 #include "TFile.h"
31 #include <sys/stat.h>
32 #include <sys/types.h>
33
34 //#include "AliHLTEMCALConstant.h"
35 #include "AliHLTCaloConstants.h"
36
37 using EMCAL::NZROWSMOD;
38 using EMCAL::NXCOLUMNSMOD;  
39 using CALO::HGLGFACTOR;
40
41 /** 
42  * @file   AliHLTEMCALDigitMakerComponent.cxx
43  * @author Oystein Djuvsland
44  * @date   
45  * @brief  A digit maker component for EMCAL HLT
46 */
47
48 // see below for class documentation
49 // or
50 // refer to README to build package
51 // or
52 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
53
54
55 ClassImp(AliHLTEMCALDigitMakerComponent)
56
57 AliHLTEMCALDigitMakerComponent gAliHLTEMCALDigitMakerComponent;
58
59 AliHLTEMCALDigitMakerComponent::AliHLTEMCALDigitMakerComponent() :
60   AliHLTCaloProcessor(),
61   //  AliHLTCaloConstantsHandler("EMCAL"),
62   fDigitMakerPtr(0),
63   fDigitContainerPtr(0),
64   fPedestalData(0),
65   fCalibData(0),
66   fBCMInitialised(true),
67   fGainsInitialised(true)
68 {
69   
70   //see header file for documentation
71 }
72
73
74 AliHLTEMCALDigitMakerComponent::~AliHLTEMCALDigitMakerComponent()
75 {
76   //see header file for documentation
77 }
78
79 int 
80 AliHLTEMCALDigitMakerComponent::Deinit()
81
82   //see header file for documentation
83   if(fDigitMakerPtr)
84     {
85       delete fDigitMakerPtr;
86       fDigitMakerPtr = 0;
87     }
88   return 0;
89 }
90
91 const char*
92 AliHLTEMCALDigitMakerComponent::GetComponentID()
93 {
94   //see header file for documentation
95   return "EmcalDigitMaker";
96 }
97
98
99 void
100 AliHLTEMCALDigitMakerComponent::GetInputDataTypes(vector<AliHLTComponentDataType>& list)
101
102   //see header file for documentation
103   list.clear();
104   list.push_back(AliHLTEMCALDefinitions::fgkChannelDataType);
105 }
106
107 AliHLTComponentDataType 
108 AliHLTEMCALDigitMakerComponent::GetOutputDataType()
109 {
110   //see header file for documentation
111 //  return AliHLTCaloDefinitions::fgkDigitDataType|kAliHLTDataOriginEMCAL;
112   return AliHLTEMCALDefinitions::fgkDigitDataType;
113 }
114
115
116 void 
117 AliHLTEMCALDigitMakerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
118 {
119   //see header file for documentation
120   constBase = 0;
121   inputMultiplier = (float)sizeof(AliHLTCaloDigitDataStruct)/sizeof(AliHLTCaloChannelDataStruct) + 1;
122 }
123
124
125
126 int 
127 AliHLTEMCALDigitMakerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
128                                         AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size,
129                                         std::vector<AliHLTComponentBlockData>& outputBlocks)
130 {
131
132         //patch in order to skip calib events
133   const AliRawDataHeader* cdh = NULL;
134   ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true);
135         AliHLTUInt64_t triggerMask = cdh->GetTriggerClasses();
136         if(triggerMask == 0) return 0;
137
138
139   //see header file for documentation
140   UInt_t offset           = 0; 
141   UInt_t mysize           = 0;
142   Int_t digitCount        = 0;
143   Int_t ret               = 0;
144   
145   const AliHLTComponentBlockData* iter = 0; 
146   unsigned long ndx; 
147   
148   UInt_t specification = 0;
149   AliHLTCaloChannelDataHeaderStruct* tmpChannelData = 0;
150   
151   //  fDigitMakerPtr->SetDigitHeaderPtr(reinterpret_cast<AliHLTCaloDigitHeaderStruct*>(outputPtr));
152   
153   fDigitMakerPtr->SetDigitDataPtr(reinterpret_cast<AliHLTCaloDigitDataStruct*>(outputPtr));
154   
155   for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
156     {
157       iter = blocks+ndx;
158       
159       if(iter->fDataType != AliHLTEMCALDefinitions::fgkChannelDataType)
160         {
161           continue;
162         }
163       
164       Int_t module = 0;
165       
166       if(!fBCMInitialised)
167         {
168           AliHLTEMCALMapper mapper(iter->fSpecification);
169           module = mapper.GetModuleFromSpec(iter->fSpecification);
170           
171           if (module>=0) {
172           
173             for(Int_t x = 0; x < NXCOLUMNSMOD ; x++) // PTH  
174               for(Int_t z = 0; z <  NZROWSMOD ; z++) // PTH
175         // FR 
176                 fDigitMakerPtr->SetBadChannel(x, z, fPedestalData->IsBadChannel(module, z, x));
177             //delete fBadChannelMap;  
178             fBCMInitialised = true;
179           }
180           else 
181             HLTError("Error setting pedestal with module value of %d", module);
182           
183         }
184       
185       if(!fGainsInitialised)
186         {
187           
188           AliHLTEMCALMapper mapper(iter->fSpecification);
189           module = mapper.GetModuleFromSpec(iter->fSpecification);
190             
191             if (module>=0) {
192               
193               for(Int_t x = 0; x < NXCOLUMNSMOD; x++)   //PTH
194                 for(Int_t z = 0; z < NZROWSMOD; z++)   //PTH
195                   // FR setting gains 
196                   fDigitMakerPtr->SetGain(x, z, HGLGFACTOR, fCalibData->GetADCchannel(module, z, x));
197               
198               fGainsInitialised = true;
199             }
200             else
201               HLTError("Error setting gains with module value of %d", module);
202         }
203       
204       specification |= iter->fSpecification;
205       tmpChannelData = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(iter->fPtr);
206     
207       ret = fDigitMakerPtr->MakeDigits(tmpChannelData, size-(digitCount*sizeof(AliHLTCaloDigitDataStruct)));
208       
209       if(ret == -1) 
210         {
211           HLTError("Trying to write over buffer size");
212           return -ENOBUFS;
213         }
214       digitCount += ret; 
215     }
216   
217   mysize += digitCount*sizeof(AliHLTCaloDigitDataStruct);
218
219   HLTDebug("# of digits: %d, used memory size: %d, available size: %d", digitCount, mysize, size);
220
221   if(mysize > 0) 
222     {
223       AliHLTComponentBlockData bd;
224       FillBlockData( bd );
225       bd.fOffset = offset;
226       bd.fSize = mysize;
227       bd.fDataType = AliHLTEMCALDefinitions::fgkDigitDataType;
228       bd.fSpecification = specification;
229       outputBlocks.push_back(bd);
230     }
231
232   fDigitMakerPtr->Reset();
233
234   size = mysize; 
235
236   return 0;
237 }
238
239
240 int
241 AliHLTEMCALDigitMakerComponent::DoInit(int argc, const char** argv )
242 {
243   //see header file for documentation
244
245   fDigitMakerPtr = new AliHLTCaloDigitMaker("EMCAL");
246
247   AliHLTCaloMapper *mapper = new AliHLTEMCALMapper(2);
248   fDigitMakerPtr->SetMapper(mapper);
249   
250   for(int i = 0; i < argc; i++)
251     {
252       if(!strcmp("-lowgainfactor", argv[i]))
253         {
254           fDigitMakerPtr->SetGlobalLowGainFactor(atof(argv[i+1]));
255         }
256       if(!strcmp("-highgainfactor", argv[i]))
257         {
258           fDigitMakerPtr->SetGlobalHighGainFactor(atof(argv[i+1]));
259         }
260
261     }
262
263   
264   if (GetBCMFromCDB()) 
265     return -1;
266   
267   if (GetGainsFromCDB()) 
268     return -1; 
269
270   //GetBCMFromCDB();
271   //fDigitMakerPtr->SetDigitThreshold(2);
272
273   return 0;
274 }
275
276
277 int AliHLTEMCALDigitMakerComponent::GetBCMFromCDB()
278 {
279    // See header file for class documentation
280   fBCMInitialised = false;
281   //   HLTInfo("Getting bad channel map...");
282   AliCDBPath path("EMCAL","Calib","Pedestals");
283   if(path.GetPath())
284     {
285       //      HLTInfo("configure from entry %s", path.GetPath());
286       AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
287         if (pEntry) 
288         {
289             fPedestalData = (AliCaloCalibPedestal*)pEntry->GetObject();
290         }
291       else
292         {
293 //          HLTError("can not fetch object \"%s\" from CDB", path);
294             return -1;
295         }
296     }
297    if(!fPedestalData) 
298    {
299         return -1;
300    }
301
302    return 0;
303 }
304
305
306 int AliHLTEMCALDigitMakerComponent::GetGainsFromCDB()
307 {
308    // See header file for class documentation
309   fGainsInitialised = false;
310   //  HLTInfo("Getting bad channel map...");
311
312   AliCDBPath path("EMCAL","Calib","Data");
313   if(path.GetPath())
314     {
315       //      HLTInfo("configure from entry %s", path.GetPath());
316       AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
317         if (pEntry) 
318         {
319             fCalibData = (AliEMCALCalibData*)pEntry->GetObject();
320         }
321       else
322         {
323 //          HLTError("can not fetch object \"%s\" from CDB", path);
324             return -1;
325         }
326     }
327    if(!fCalibData) return -1;
328    return 0;
329 }
330
331
332 AliHLTComponent*
333 AliHLTEMCALDigitMakerComponent::Spawn()
334 {
335   //see header file for documentation
336   return new AliHLTEMCALDigitMakerComponent();
337 }