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