make AliVVevent abstract (=0)
[u/mrichter/AliRoot.git] / HLT / global / AliHLTGlobalHistoCollector.cxx
1
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: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
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   AliHLTGlobalHistoCollector.cxx
19     @author Kalliopi Kanaki
20     @date   
21     @brief  The Histogram Handler component
22 */
23
24 #include "AliHLTGlobalHistoCollector.h"
25 #include "AliCDBEntry.h"
26 #include "AliCDBManager.h"
27 #include "TString.h"
28 #include "TObjArray.h"
29 #include "TObjString.h"
30 #include "TH1.h"
31 #include "TTimeStamp.h"
32 #include "TSystem.h"
33
34 using namespace std;
35
36 ClassImp(AliHLTGlobalHistoCollector) //ROOT macro for the implementation of ROOT specific class methods
37
38   AliHLTGlobalHistoCollector::AliHLTGlobalHistoCollector()
39     :    
40     fUID(0),
41     fStore(),
42     fBenchmark("GlobalHistoCollector")
43 {
44   // see header file for class documentation
45   // or
46   // refer to README to build package
47   // or
48   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
49 }
50
51 AliHLTGlobalHistoCollector::~AliHLTGlobalHistoCollector() { 
52   // see header file for class documentation
53   Clear();
54 }
55
56
57
58 // Public functions to implement AliHLTComponent's interface.
59 // These functions are required for the registration process
60
61 const char* AliHLTGlobalHistoCollector::GetComponentID() 
62
63   // see header file for class documentation
64   return "GlobalHistoCollector";
65 }
66
67 void AliHLTGlobalHistoCollector::GetInputDataTypes( vector<AliHLTComponentDataType>& list) 
68
69   // see header file for class documentation
70
71   list.clear(); 
72   list.push_back( kAliHLTAllDataTypes );
73 }
74
75 AliHLTComponentDataType AliHLTGlobalHistoCollector::GetOutputDataType() 
76
77   // see header file for class documentation
78   return kAliHLTAllDataTypes;
79 }
80
81
82 void AliHLTGlobalHistoCollector::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) 
83
84   // see header file for class documentation
85   constBase=0;
86   inputMultiplier=1.0;
87 }
88
89 AliHLTComponent* AliHLTGlobalHistoCollector::Spawn() 
90
91   // see header file for class documentation
92   return new AliHLTGlobalHistoCollector();
93 }
94         
95 int AliHLTGlobalHistoCollector::DoInit( int argc, const char** argv ) 
96
97   // see header file for class documentation
98
99   Clear(); 
100   fBenchmark.Reset();
101   fBenchmark.SetTimer(0,"total");
102   fBenchmark.SetTimer(1,"merging");
103
104   int iResult=0;
105   
106   TString configuration="";
107   TString argument="";
108   for (int j=0; j<argc && iResult>=0; j++) {
109     
110     argument=argv[j];
111     if (!configuration.IsNull()) configuration+=" ";
112     configuration+=argument;    
113   }
114    
115   if (!configuration.IsNull()) {
116     iResult=Configure(configuration.Data());
117   } else {
118     iResult=Reconfigure(NULL, NULL);
119   }
120   fUID = 0;
121   return iResult;
122 }
123
124
125 int AliHLTGlobalHistoCollector::DoDeinit() 
126
127   // see header file for class documentation 
128     
129   Clear();
130   fUID = 0;
131   return 0;
132 }
133
134 int AliHLTGlobalHistoCollector::Configure(const char* arguments) 
135
136   // see header file for class documentation
137   
138   int iResult=0;
139   if (!arguments) return iResult;
140   HLTInfo("parsing configuration string \'%s\'", arguments);
141
142   TString allArgs=arguments;
143   TString argument;
144   int bMissingParam=0;
145
146   TObjArray* pTokens=allArgs.Tokenize(" ");
147   if (pTokens) {
148     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
149       argument=((TObjString*)pTokens->At(i))->GetString();
150       if (argument.IsNull()) continue;
151      
152       //if (argument.CompareTo("-sum-noise-histograms")==0) {
153       //fNoiseHistograms = kTRUE;
154       //HLTInfo("got \'-sum-noise-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
155       //else 
156       {
157         HLTError("unknown argument %s", argument.Data());
158         iResult=-EINVAL;
159         break;
160       }
161     } // end for
162     
163     delete pTokens;
164   
165   } // end if pTokens
166   
167   if (bMissingParam) {
168     HLTError("missing parameter for argument %s", argument.Data());
169     iResult=-EINVAL;
170   }
171   return iResult;
172 }
173
174
175 int AliHLTGlobalHistoCollector::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) { 
176   // see header file for class documentation
177   
178   return 0; // no CDB entry exist
179   /*
180   int iResult=0;  
181   const char* path="HLT/ConfigGlobal/GlobalHistoCollector";
182   const char* defaultNotify="";
183   if (cdbEntry) {
184     path=cdbEntry;
185     defaultNotify=" (default)";
186   }
187   
188   if (path) {
189     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
190     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);
191     if (pEntry) {
192       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
193       if (pString) {
194         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
195         iResult=Configure(pString->GetString().Data());
196       } else {
197         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
198       }
199     } else {
200       HLTError("cannot fetch object \"%s\" from CDB", path);
201     }
202   }
203   return iResult;
204 */
205 }
206
207
208 void AliHLTGlobalHistoCollector::Clear() 
209
210   // reset the store
211
212   for( unsigned int i=0; i<fStore.size(); i++ ){
213     for( unsigned int j=0; j<fStore[i].fInstances.size(); j++ ){
214       delete fStore[i].fInstances[j].fObject;
215     }
216     delete fStore[i].fMergedObject;
217   }
218   fStore.clear();
219 }
220
221
222
223
224 int AliHLTGlobalHistoCollector::DoEvent(const AliHLTComponentEventData & evtData, AliHLTComponentTriggerData& /*trigData*/)
225 {
226   // see header file for class documentation
227   //cout<<"\n\nDoEvent called"<<endl;
228
229   if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
230
231   fBenchmark.StartNewEvent();
232   fBenchmark.Start(0);
233
234   if( fUID == 0 ){
235     TTimeStamp t;
236     fUID = ( gSystem->GetPid() + t.GetNanoSec())*10 + evtData.fEventID;
237   }
238
239   for( const AliHLTComponentBlockData *i= GetFirstInputBlock(); i!=NULL; i=GetNextInputBlock() ){
240     fBenchmark.AddInput(i->fSize);
241   }
242
243   const TObject *iter = NULL;
244   for(iter = GetFirstInputObject(); iter != NULL; iter = GetNextInputObject()){
245             
246     if( !iter->InheritsFrom(TH1::Class()) 
247         && !iter->InheritsFrom(TSeqCollection::Class()) ) continue;
248
249     //cout<<"received object "<<iter->GetName()<<" with id="<<GetSpecification(iter)<<endl;
250
251     //search for the base entry, if not exist then create a new entry   
252
253     int iColl = -1;
254     for( unsigned int i=0; i<fStore.size(); i++ ){
255       if( fStore[i].fHLTDataType != GetDataType(iter) ) continue;
256       if( fStore[i].fInstances.size()<1 ) continue; 
257       TObject * obj = fStore[i].fInstances[0].fObject;
258       if( !obj ) continue;
259       if( TString(obj->GetName()).CompareTo(iter->GetName())==0){
260         iColl = i;
261         break;
262       }
263     }
264     //cout<<"Collection found: "<<iColl<<endl;
265     if( iColl<0 ){
266       AliHLTGlobalHCCollection c;
267       c.fHLTDataType = GetDataType(iter);
268       c.fMergedObject = 0;
269       c.fNeedToMerge = 1;
270       fStore.push_back(c);
271       iColl = fStore.size()-1;
272     }else{
273       fStore[iColl].fNeedToMerge = 1;
274     }
275
276     // search for the specific entry, if not exist then create a new one
277     
278     AliHLTGlobalHCCollection &c = fStore[iColl];
279    
280     int iSpec=-1;
281     for( unsigned int i=0; i<c.fInstances.size(); i++ ){
282       AliHLTGlobalHCInstance &inst = c.fInstances[i];
283       if( inst.fHLTSpecification == GetSpecification(iter) ){
284         iSpec = i;
285         break;
286       }
287     }
288     //cout<<"Instance found:"<<iSpec<<endl;
289     if( iSpec<0 ){
290       AliHLTGlobalHCInstance inst;
291       inst.fHLTSpecification = GetSpecification(iter);
292       inst.fObject = 0;
293       c.fInstances.push_back(inst);
294       iSpec = c.fInstances.size()-1;      
295     }else{
296       delete c.fInstances[iSpec].fObject;
297     }
298
299     c.fInstances[iSpec].fObject = iter->Clone();
300     
301     //cout<<"index = "<<iColl<<","<<iSpec<<endl;
302
303   } // end for loop over input blocks
304
305   fBenchmark.Start(1);
306  
307   
308   // merge histos 
309
310   for( unsigned int iColl = 0; iColl<fStore.size(); iColl++){
311     AliHLTGlobalHCCollection &c = fStore[iColl];
312     if( !c.fNeedToMerge && c.fMergedObject ) continue;
313     if( c.fInstances.size() <1 ) continue;
314     delete c.fMergedObject;
315     c.fMergedObject = c.fInstances[0].fObject->Clone();
316     TList l;
317     for( unsigned int i=1; i<c.fInstances.size(); i++ ){
318       l.Add(c.fInstances[i].fObject);
319     }
320
321     if( c.fMergedObject->InheritsFrom(TH1::Class()) ){
322       TH1 *histo = dynamic_cast<TH1*>(c.fMergedObject);
323       if( histo ) histo->Merge(&l);
324     }
325     else if( c.fMergedObject->InheritsFrom(TSeqCollection::Class()) ){
326       TSeqCollection *list = dynamic_cast<TSeqCollection*>(c.fMergedObject);
327       if( list ) list->Merge(&l);
328     }    
329     c.fNeedToMerge = 0;
330   }
331   fBenchmark.Stop(1);
332  
333   // send output 
334
335   for( unsigned int i=0; i<fStore.size(); i++ ){
336     if( fStore[i].fMergedObject ){
337       PushBack((TObject*) fStore[i].fMergedObject, fStore[i].fHLTDataType, fUID );
338       fBenchmark.AddOutput(GetLastObjectSize());
339     }
340   }
341
342   fBenchmark.Stop(0);
343   HLTInfo(fBenchmark.GetStatistics());
344
345   return 0;
346 }
347