e5f23f1be52a3e32dc708cb115d4d41796973464
[u/mrichter/AliRoot.git] / HLT / TPCLib / calibration / AliHLTTPCCalibCEComponent.cxx
1 // $Id$
2 /**************************************************************************
3  * This file is property of and copyright by the ALICE HLT Project        * 
4  * ALICE Experiment at CERN, All rights reserved.                         *
5  *                                                                        *
6  * Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
7  *                  for The ALICE HLT Project.                            *
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
18 /** @file   AliHLTTPCCalibCEComponent.cxx
19     @author Jochen Thaeder
20     @date   
21     @brief  A pedestal calibration component for the TPC.
22 */
23
24 // see header file for class documentation
25 // or
26 // refer to README to build package
27 // or
28 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt   
29
30 //#include "AliHLTTPCLogging.h"
31 #include "AliHLTTPCDefinitions.h"
32 //#include "AliHLTTPCTransform.h"
33
34 #include "AliHLTTPCCalibCEComponent.h"
35
36 //#include "AliRawDataHeader.h"
37 #include "AliRawReaderMemory.h"
38 #include "AliTPCRawStream.h"
39
40 #include "AliTPCCalibCE.h"
41
42 #include <cstdlib>
43 #include <cerrno>
44 #include "TString.h"
45
46 using namespace std;
47
48 /** ROOT macro for the implementation of ROOT specific class methods */
49 ClassImp(AliHLTTPCCalibCEComponent)
50
51 AliHLTTPCCalibCEComponent::AliHLTTPCCalibCEComponent()
52   :
53   fRawReader(NULL),
54   fRawStream(NULL),
55   fCalibCE(NULL),
56   // Note: initialization of min and max seems to be in the wrong order but is on
57   // purpose in order to work correctly with the conditional in DoEvent line 226
58   //  if ( patch < fMinPatch ) fMinPatch =  patch;
59   //  if ( patch > fMaxPatch ) fMaxPatch =  patch;
60   fMinPatch(5),
61   fMaxPatch(0),
62   fSpecification(0) ,
63   fEnableAnalysis(kFALSE) {
64   // see header file for class documentation
65   // or
66   // refer to README to build package
67   // or
68   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
69 }
70
71 AliHLTTPCCalibCEComponent::~AliHLTTPCCalibCEComponent() {
72   // see header file for class documentation
73 }
74
75 // Public functions to implement AliHLTComponent's interface.
76 // These functions are required for the registration process
77
78 const char* AliHLTTPCCalibCEComponent::GetComponentID() {
79   // see header file for class documentation
80
81   return "TPCCalibCE";
82 }
83
84 void AliHLTTPCCalibCEComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
85   // see header file for class documentation
86
87   list.clear(); 
88   list.push_back( AliHLTTPCDefinitions::fgkDDLPackedRawDataType );
89 }
90
91 AliHLTComponentDataType AliHLTTPCCalibCEComponent::GetOutputDataType() {
92   // see header file for class documentation
93
94   return AliHLTTPCDefinitions::fgkCalibCEDataType;
95 }
96
97 void AliHLTTPCCalibCEComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
98   // see header file for class documentation
99
100   // XXX TODO: Find more realistic values.  
101   constBase = 0;
102   inputMultiplier = (2.0);
103 }
104
105 AliHLTComponent* AliHLTTPCCalibCEComponent::Spawn() {
106   // see header file for class documentation
107
108   return new AliHLTTPCCalibCEComponent();
109 }  
110
111
112 Int_t AliHLTTPCCalibCEComponent::ScanArgument( Int_t argc, const char** argv ) {
113   // see header file for class documentation
114
115   Int_t iResult = 0;
116   TString argument = "";
117   TString parameter = "";
118
119   if ( !argc ) 
120     return -EINVAL;
121
122   argument = argv[iResult];
123   
124   if ( argument.IsNull() ) 
125     return -EINVAL;
126
127   // -rcuformat
128   if ( argument.CompareTo("-rcuformat") == 0 ) {
129
130     if ( ++iResult >= argc  ) {
131       iResult = -EPROTO;
132     }
133     else {
134       parameter = argv[1];
135       if ( parameter.CompareTo("old") == 0 ) {
136         HLTInfo( "RCU Format is set to old." );
137       }
138       else if ( parameter.CompareTo("new") == 0 ) {
139         HLTInfo( "RCU Format is set to new." );
140       }
141       else {
142         HLTError( "Cannot convert rcu format specifier '%s'.", argv[1] );
143         iResult = -EPROTO;
144       }
145     } 
146   }
147   else if ( argument.CompareTo("-enableanalysis") == 0 ) {
148     HLTInfo( "Analysis before shipping data to FXS enabled." );
149     fEnableAnalysis = kTRUE;
150   }
151   else {
152     iResult = -EINVAL;
153   }
154       
155   return iResult;
156 }
157
158 Int_t AliHLTTPCCalibCEComponent::InitCalibration() {
159   // see header file for class documentation
160     
161   // ** Create pedestal calibration
162   if ( fCalibCE )
163     return EINPROGRESS;
164   
165   fCalibCE = new AliTPCCalibCE();
166
167   // **  Create AliRoot Memory Reader
168   if (fRawReader)
169     return EINPROGRESS;
170
171   fRawReader = new AliRawReaderMemory();
172
173   return 0;
174 }
175
176 Int_t AliHLTTPCCalibCEComponent::DeinitCalibration() {
177   // see header file for class documentation
178
179   if ( fRawReader )
180     delete fRawReader;
181   fRawReader = NULL;
182
183   if ( fCalibCE )
184     delete fCalibCE;
185   fCalibCE = NULL;
186
187   return 0;
188 }
189
190 /*
191  * --- setter for rcuformat need in AliTPCCalibCE class
192  */
193 Int_t AliHLTTPCCalibCEComponent::ProcessCalibration( const AliHLTComponentEventData& /*evtData*/, 
194                                                            AliHLTComponentTriggerData& /*trigData*/ ) {
195   // see header file for class documentation
196   
197   const AliHLTComponentBlockData* iter = NULL;
198
199   AliHLTUInt8_t slice=0, patch=0;
200   Int_t ddlId = 0;
201     
202   // ** Loop over all input blocks and specify which data format should be read - only select Raw Data
203   iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC);
204   
205   while ( iter != NULL ) {
206     
207     // ** Print Debug output which data format was received
208     //    char tmp1[14], tmp2[14];
209     //    DataType2Text( iter->fDataType, tmp1 );
210     //    DataType2Text( AliHLTTPCDefinitions::fgkDDLPackedRawDataType, tmp2 );
211     //    HLTDebug ( "Event received - Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
212     //    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
213
214     // ** Get DDL ID in order to tell the memory reader which slice/patch to use
215     slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
216     patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
217
218     if (patch < 2) ddlId = 768 + (2 * slice) + patch;
219     else ddlId = 838 + (4*slice) + patch;
220
221     HLTDebug ( "Input Raw Data - Slice/Patch: %d/%d - EquipmentID : %d.", slice, patch, ddlId );
222
223     // ** Get min and max patch, used for output specification
224     if ( patch < fMinPatch ) fMinPatch =  patch;
225     if ( patch > fMaxPatch ) fMaxPatch =  patch;
226
227     // ** Init TPCRawStream
228     fRawReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
229     fRawReader->SetEquipmentID(ddlId);
230
231     fRawStream = new AliTPCRawStream( fRawReader );
232
233     // ** Process actual Pedestal Calibration - Fill histograms
234     fCalibCE->ProcessEvent( fRawStream );
235   
236     // ** Delete TPCRawStream
237     if ( fRawStream )
238       delete fRawStream;
239     fRawStream = NULL;    
240
241     // ** Get next input block, with the same specification as defined in GetFirstInputBlock()
242     iter = GetNextInputBlock();
243
244   } //  while ( iter != NULL ) {
245     
246   // ** Get output specification
247   fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, fMinPatch, fMaxPatch );
248
249   // ** PushBack data to shared memory ... 
250   PushBack( (TObject*) fCalibCE, AliHLTTPCDefinitions::fgkCalibCEDataType, fSpecification);
251   
252   return 0;
253 } // Int_t AliHLTTPCCalibCEComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
254
255
256 Int_t AliHLTTPCCalibCEComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, 
257                                                       AliHLTComponentTriggerData& /*trigData*/ ) {
258   // see header file for class documentation
259     
260   if ( fEnableAnalysis )
261     fCalibCE->Analyse();
262   
263   // ** PushBack data to FXS ...
264   PushToFXS( (TObject*) fCalibCE, "TPC", "CE" ) ;
265   
266   return 0;
267 } // Int_t AliHLTTPCCalibCEComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
268
269