Updated macros for PHOS alignment calculation
[u/mrichter/AliRoot.git] / HLT / EMCAL / AliHLTEMCALCalibrationComponent.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
5  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
6  *          for The ALICE Off-line Project.                               *
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 /** @file   AliHLTEMCALCalibrationComponent.cxx
18     @author Mateusz Ploskon
19     @date   
20     @brief  A EMCALCalibration processing component for the HLT. */
21
22 #include "TTree.h"
23 #include "TFile.h"
24 #include "TBranch.h"
25
26 #include "AliHLTEMCALCalibrationComponent.h"
27 #include "AliHLTEMCALDefinitions.h"
28
29 #include "AliCDBManager.h"
30 #include "AliRawReaderMemory.h"
31
32 #include <cstdlib>
33 #include <cerrno>
34 #include <string>
35
36 using namespace std;
37
38 // this is a global object used for automatic component registration, do not use this
39 AliHLTEMCALCalibrationComponent gAliHLTEMCALCalibrationComponent;
40
41 ClassImp(AliHLTEMCALCalibrationComponent);
42    
43 AliHLTEMCALCalibrationComponent::AliHLTEMCALCalibrationComponent()
44   : AliHLTCalibrationProcessor()
45   , fOutputPercentage(100) // By default we copy to the output exactly what we got as input  
46   , fStrorageDBpath("local://$ALICE_ROOT/OCDB")
47   , fCDB(NULL)
48 {
49   // Default constructor
50 }
51
52 AliHLTEMCALCalibrationComponent::~AliHLTEMCALCalibrationComponent()
53 {
54   // Destructor
55   ;
56 }
57
58 const char* AliHLTEMCALCalibrationComponent::GetComponentID()
59 {
60   // Return the component ID const char *
61   return "EMCALCalibration"; // The ID of this component
62 }
63
64 void AliHLTEMCALCalibrationComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
65 {
66   // Get the list of input data
67   list.clear(); // We do not have any requirements for our input data type(s).
68   //list.push_back( AliHLTEMCALDefinitions::fgkDDLRawDataType );
69   list.push_back( AliHLTEMCALDefinitions::fgkClusterDataType );
70   //list.push_back( AliHLTEMCALDefinitions::fgkEMCALESDDataType );
71 }
72
73 AliHLTComponent_DataType AliHLTEMCALCalibrationComponent::GetOutputDataType()
74 {
75   // Get the output data type
76   return AliHLTEMCALDefinitions::fgkCalibrationDataType;
77 }
78
79 void AliHLTEMCALCalibrationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
80 {
81   // Get the output data size
82   constBase = 0;
83   inputMultiplier = ((double)fOutputPercentage)/100.0;
84 }
85
86 AliHLTComponent* AliHLTEMCALCalibrationComponent::Spawn()
87 {
88   // Spawn function, return new instance of this class
89   return new AliHLTEMCALCalibrationComponent;
90 };
91
92 Int_t AliHLTEMCALCalibrationComponent::ScanArgument( int argc, const char** argv )
93 {
94   // perform initialization. We check whether our relative output size is specified in the arguments.
95   fOutputPercentage = 100;
96   int i = 0;
97   char* cpErr;
98   while ( i < argc )
99     {
100       Logging( kHLTLogDebug, "HLT::EMCALCalibration::ScanArgument", "Arguments", "argv[%d] == %s", i, argv[i] );
101       if ( !strcmp( argv[i], "output_percentage" ) )
102         {
103           if ( i+1>=argc )
104             {
105               Logging(kHLTLogError, "HLT::EMCALCalibration::ScanArgument", "Missing Argument", "Missing output_percentage parameter");
106               return ENOTSUP;
107             }
108           Logging( kHLTLogDebug, "HLT::EMCALCalibration::ScanArgument", "Arguments", "argv[%d+1] == %s", i, argv[i+1] );
109           fOutputPercentage = strtoul( argv[i+1], &cpErr, 0 );
110           if ( *cpErr )
111             {
112               Logging(kHLTLogError, "HLT::EMCALCalibration::ScanArgument", "Wrong Argument", "Cannot convert output_percentage parameter '%s'", argv[i+1] );
113               return EINVAL;
114             }
115           Logging( kHLTLogInfo, "HLT::EMCALCalibration::ScanArgument", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
116           i += 2;
117           continue;
118         }
119
120       if ( strcmp( argv[i], "-cdb" ) == 0)
121         {
122           if ( i+1 >= argc )
123             {
124               Logging(kHLTLogError, "HLT::EMCALCalibration::ScanArgument", "Missing Argument", "Missing -cdb argument");
125               return ENOTSUP;         
126             }
127           fStrorageDBpath = argv[i+1];
128           Logging( kHLTLogInfo, "HLT::EMCALCalibration::ScanArgument", "DB storage set", "DB storage is %s", fStrorageDBpath.c_str() );   
129           i += 2;
130           continue;
131         }      
132
133       Logging(kHLTLogError, "HLT::EMCALCalibration::ScanArgument", "Unknown Option", "Unknown option '%s'", argv[i] );
134       return EINVAL;
135     }
136   return 0;
137 }
138
139 Int_t AliHLTEMCALCalibrationComponent::InitCalibration()
140 {
141   //init the calibration
142   fCDB = AliCDBManager::Instance();
143   if (!fCDB)
144     {
145       Logging(kHLTLogError, "HLT::EMCALCalibration::InitCalibration", "Could not get CDB instance", "fCDB 0x%x", fCDB);
146     }
147   else
148     {
149       fCDB->SetRun(0); // THIS HAS TO BE RETRIEVED !!!
150       fCDB->SetDefaultStorage(fStrorageDBpath.c_str());
151       Logging(kHLTLogDebug, "HLT::EMCALCalibration::InitCalibration", "CDB instance", "fCDB 0x%x", fCDB);
152     }
153   return 0;
154 }
155
156 Int_t AliHLTEMCALCalibrationComponent::DeinitCalibration()
157 {
158   // Deinitialization of the component
159   if (fCDB)
160     {
161       Logging( kHLTLogDebug, "HLT::EMCALCalibration::DeinitCalibration", "destroy", "fCDB");
162       fCDB->Destroy();
163       fCDB = 0;
164     }
165   return 0;
166 }
167
168 Int_t AliHLTEMCALCalibrationComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData)
169 {
170   // Process an event
171   // Logging( kHLTLogInfo, "HLT::EMCALCalibration::ProcessCalibration", "Output percentage set", "Output percentage set to %lu %%", fOutputPercentage );
172   Logging( kHLTLogDebug, "HLT::EMCALCalibration::ProcessCalibration", "BLOCKS", "NofBlocks %lu", evtData.fBlockCnt );
173   // Process an event
174   // unsigned long totalSize = 0;
175
176   // implement a usage of the following
177   //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
178   //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
179   //   void *triggerData = trigData.fData;
180   Logging( kHLTLogDebug, "HLT::EMCALCalibration::ProcessCalibration", "Trigger data received", 
181            "Struct size %d Data size %d Data location 0x%x", 
182            trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
183
184   // Loop over all input blocks in the event
185   int ibForce = 0;
186   TObject *tobjin = (TObject *)GetFirstInputObject(AliHLTEMCALDefinitions::fgkClusterDataType , "TTree", ibForce);
187   Logging( kHLTLogInfo, "HLT::EMCALCalibration::ProcessCalibration", "1stBLOCK", "Pointer = 0x%x", tobjin);
188   while (tobjin)
189     {
190       tobjin = (TObject *)GetNextInputObject( ibForce );
191       Logging( kHLTLogInfo, "HLT::EMCALCalibration::ProcessCalibration", "nextBLOCK", "Pointer = 0x%x", tobjin);
192     }
193
194   return 0;
195 }
196
197 Int_t AliHLTEMCALCalibrationComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
198 {
199   //Int_t PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, const char* pDDLNumber = "");
200   // what we will actually push depends on the calibration procedure
201   //ireturn = PushToFXS(object, "EMCAL ", "EMCALCalib", "1024 ");
202   Logging( kHLTLogDebug, "HLT::EMCALCalibration::ProcessCalibration", "Shipping data", 
203            "Nothing serious");
204   Int_t ireturn = 0;
205   return ireturn;
206 }