documentation
[u/mrichter/AliRoot.git] / HLT / BASE / util / AliHLTLoaderPublisherComponent.cxx
1 // @(#) $Id$
2
3 /**************************************************************************
4  * This file is property of and copyright by the ALICE HLT Project        * 
5  * ALICE Experiment at CERN, All rights reserved.                         *
6  *                                                                        *
7  * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8  *                  for The ALICE HLT Project.                            *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   AliHLTLoaderPublisherComponent.cxx
20     @author Matthias Richter
21     @date   
22     @brief  A general tree publisher component for the AliLoader.
23 */
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #include "AliHLTLoaderPublisherComponent.h"
32 #include "AliRunLoader.h"
33 #include "AliLoader.h"
34 #include "AliLog.h"
35 #include "TTree.h"
36
37 /** global instance for agent registration */
38 AliHLTLoaderPublisherComponent gAliHLTLoaderPublisherComponent;
39
40 /** ROOT macro for the implementation of ROOT specific class methods */
41 ClassImp(AliHLTLoaderPublisherComponent)
42
43 AliHLTLoaderPublisherComponent::AliHLTLoaderPublisherComponent()
44   :
45   fMaxSize(0),
46   fLoaderType(),
47   fTreeType("digits"),
48   fVerbose(kFALSE),
49   fDataType(kAliHLTAnyDataType),
50   fSpecification(0),
51   fpLoader(NULL)
52 {
53   // see header file for class documentation
54   // or
55   // refer to README to build package
56   // or
57   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
58 }
59
60 AliHLTLoaderPublisherComponent::~AliHLTLoaderPublisherComponent()
61 {
62   // see header file for class documentation
63 }
64
65 const char* AliHLTLoaderPublisherComponent::GetComponentID()
66 {
67   // see header file for class documentation
68   return "AliLoaderPublisher";
69 }
70
71 AliHLTComponentDataType AliHLTLoaderPublisherComponent::GetOutputDataType()
72 {
73   return fDataType;
74 }
75
76 void AliHLTLoaderPublisherComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
77 {
78   constBase=fMaxSize;
79   inputMultiplier=1;
80 }
81
82 AliHLTComponent* AliHLTLoaderPublisherComponent::Spawn()
83 {
84   // see header file for class documentation
85   return new AliHLTLoaderPublisherComponent;
86 }
87
88 int AliHLTLoaderPublisherComponent::DoInit( int argc, const char** argv )
89 {
90   // see header file for class documentation
91   int iResult=0;
92
93   // scan arguments
94   TString argument="";
95   int bMissingParam=0;
96   for (int i=0; i<argc && iResult>=0; i++) {
97     argument=argv[i];
98     if (argument.IsNull()) continue;
99
100     // -loader
101     if (argument.CompareTo("-loader")==0) {
102       if ((bMissingParam=(++i>=argc))) break;
103       fLoaderType=argv[i];
104
105       // -tree
106     } else if (argument.CompareTo("-tree")==0) {
107       if ((bMissingParam=(++i>=argc))) break;
108       fTreeType=argv[i];
109
110       // -verbose
111     } else if (argument.CompareTo("-verbose")==0) {
112       fVerbose=kTRUE;
113
114       // -datatype
115     } else if (argument.CompareTo("-datatype")==0) {
116       if ((bMissingParam=(++i>=argc))) break;
117       memcpy(&fDataType.fID, argv[i], TMath::Min(kAliHLTComponentDataTypefIDsize, (Int_t)strlen(argv[i])));
118       if ((bMissingParam=(++i>=argc))) break;
119       memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize, (Int_t)strlen(argv[i])));
120
121       // -dataspec
122     } else if (argument.CompareTo("-dataspec")==0) {
123       if ((bMissingParam=(++i>=argc))) break;
124       TString parameter(argv[i]);
125       parameter.Remove(TString::kLeading, ' '); // remove all blanks
126       if (parameter.IsDigit()) {
127         fSpecification=(AliHLTUInt32_t)parameter.Atoi();
128       } else if (parameter.BeginsWith("0x") &&
129                  parameter.Replace(0,2,"",0).IsHex()) {
130         sscanf(parameter.Data(),"%x", &fSpecification);
131       } else {
132         HLTError("wrong parameter for argument %s, number expected", argument.Data());
133         iResult=-EINVAL;
134       }
135     } else {
136       HLTError("unknown argument %s", argument.Data());
137       iResult=-EINVAL;
138     }
139   }
140   if (bMissingParam) {
141     HLTError("missing parameter for argument %s", argument.Data());
142     iResult=-EINVAL;
143   }
144
145   if (iResult<0) return iResult;
146
147   if (fLoaderType.IsNull()) {
148     AliErrorStream() << "loader type required, use \'-loader\' option" << endl;
149     return -EINVAL;
150   }
151
152   // fetch runLoader instance from interface
153   AliRunLoader* pRunLoader=GetRunLoader();
154   if (pRunLoader) {
155
156     // get the TPC loader
157     fpLoader=pRunLoader->GetLoader(fLoaderType.Data());
158     if (fpLoader) {
159       // prepare the loader
160       fpLoader->LoadDigits("read");
161
162       // scan trough all events and estimate the size of the digits
163       for (int i=0; i<pRunLoader->GetNumberOfEvents(); i++) {
164         pRunLoader->GetEvent(i);
165         TTree* pTree=GetTree();
166         if (pTree) {
167           int size=EstimateObjectSize(pTree);
168           if (size>fMaxSize) fMaxSize=size;
169           if (fVerbose) {
170             AliInfoStream() << "event " << i << " " 
171                             << fTreeType <<" size " << size 
172                             << " count " << pTree->GetEntries() << endl;
173           }
174         } else {
175           AliWarningStream() << "no " << fTreeType << " tree for event " << i << endl;
176         }
177       }
178     } else {
179       AliErrorStream() << "can not get loader of type " << fLoaderType << endl;
180       iResult=-EFAULT;
181     }    
182   } else {
183     AliErrorStream() << "can not get runLoader" << endl;
184     iResult=-EFAULT;
185   }
186   return iResult;
187 }
188
189 int AliHLTLoaderPublisherComponent::DoDeinit()
190 {
191   // see header file for class documentation
192   int iResult=0;
193   if (fpLoader) {
194     fpLoader->UnloadDigits();
195   }
196   fpLoader=NULL;
197   return iResult;
198 }
199
200 int AliHLTLoaderPublisherComponent::GetEvent(const AliHLTComponentEventData& /*evtData*/,
201                                              AliHLTComponentTriggerData& /*trigData*/)
202 {
203   // see header file for class documentation
204   int iResult=0;
205   // fetch runLoader instance from interface
206   AliRunLoader* pRunLoader=GetRunLoader();
207   if (pRunLoader && fpLoader) {
208     pRunLoader->GetEvent(GetEventCount());
209     TTree* pTree=GetTree();
210     if (pTree) {
211       PushBack(pTree, fDataType);
212     } else {
213       AliWarningStream() << "no " << fTreeType << " tree for event " << GetEventCount() << endl;
214     }
215   } else {
216     AliErrorStream() << "component not initialized" << endl;
217     iResult=-EFAULT;
218   }
219   return iResult;
220 }
221
222 TTree* AliHLTLoaderPublisherComponent::GetTree()
223 {
224   TTree* pTree=NULL;
225   if (fpLoader) {
226     if (fTreeType.CompareTo("digits")==0)
227       pTree=fpLoader->TreeD();
228     else if (fTreeType.CompareTo("clusters")==0) {
229       pTree=fpLoader->TreeR();
230     }
231   } else {
232   }
233   return pTree;
234 }