minor corrections in documentation and build system, bugfix in agent to return config...
[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 #include "AliHLTLoaderPublisherComponent.h"
26 #include "AliRunLoader.h"
27 #include "AliLoader.h"
28 #include "AliLog.h"
29 #include "TTree.h"
30
31 /** global instance for agent registration */
32 AliHLTLoaderPublisherComponent gAliHLTLoaderPublisherComponent;
33
34 /** ROOT macro for the implementation of ROOT specific class methods */
35 ClassImp(AliHLTLoaderPublisherComponent)
36
37 AliHLTLoaderPublisherComponent::AliHLTLoaderPublisherComponent()
38   :
39   fMaxSize(0),
40   fLoaderType(),
41   fTreeType("digits"),
42   fVerbose(kFALSE),
43   fDataType(kAliHLTAnyDataType),
44   fSpecification(0),
45   fpLoader(NULL)
46 {
47   // see header file 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 AliHLTLoaderPublisherComponent::AliHLTLoaderPublisherComponent(const AliHLTLoaderPublisherComponent&)
55   :
56   fMaxSize(0),
57   fLoaderType(),
58   fTreeType("digits"),
59   fVerbose(kFALSE),
60   fDataType(kAliHLTAnyDataType),
61   fSpecification(0),
62   fpLoader(NULL)
63 {
64   // see header file for class documentation
65 }
66
67 AliHLTLoaderPublisherComponent& AliHLTLoaderPublisherComponent::operator=(const AliHLTLoaderPublisherComponent&)
68 {
69   // see header file for class documentation
70   return *this;
71 }
72
73 AliHLTLoaderPublisherComponent::~AliHLTLoaderPublisherComponent()
74 {
75   // see header file for class documentation
76 }
77
78 const char* AliHLTLoaderPublisherComponent::GetComponentID()
79 {
80   // see header file for class documentation
81   return "AliLoaderPublisher";
82 }
83
84 AliHLTComponentDataType AliHLTLoaderPublisherComponent::GetOutputDataType()
85 {
86   return fDataType;
87 }
88
89 void AliHLTLoaderPublisherComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
90 {
91   constBase=fMaxSize;
92   inputMultiplier=1;
93 }
94
95 AliHLTComponent* AliHLTLoaderPublisherComponent::Spawn()
96 {
97   // see header file for class documentation
98   return new AliHLTLoaderPublisherComponent;
99 }
100
101 int AliHLTLoaderPublisherComponent::DoInit( int argc, const char** argv )
102 {
103   // see header file for class documentation
104   int iResult=0;
105
106   // scan arguments
107   TString argument="";
108   int bMissingParam=0;
109   for (int i=0; i<argc && iResult>=0; i++) {
110     argument=argv[i];
111     if (argument.IsNull()) continue;
112
113     // -loader
114     if (argument.CompareTo("-loader")==0) {
115       if ((bMissingParam=(++i>=argc))) break;
116       fLoaderType=argv[i];
117
118       // -tree
119     } else if (argument.CompareTo("-tree")==0) {
120       if ((bMissingParam=(++i>=argc))) break;
121       fTreeType=argv[i];
122
123       // -verbose
124     } else if (argument.CompareTo("-verbose")==0) {
125       fVerbose=kTRUE;
126
127       // -datatype
128     } else if (argument.CompareTo("-datatype")==0) {
129       if ((bMissingParam=(++i>=argc))) break;
130       memcpy(&fDataType.fID, argv[i], TMath::Min(kAliHLTComponentDataTypefIDsize, (Int_t)strlen(argv[i])));
131       if ((bMissingParam=(++i>=argc))) break;
132       memcpy(&fDataType.fOrigin, argv[i], TMath::Min(kAliHLTComponentDataTypefOriginSize, (Int_t)strlen(argv[i])));
133
134       // -dataspec
135     } else if (argument.CompareTo("-dataspec")==0) {
136       if ((bMissingParam=(++i>=argc))) break;
137       TString parameter(argv[i]);
138       parameter.Remove(TString::kLeading, ' '); // remove all blanks
139       if (parameter.IsDigit()) {
140         fSpecification=(AliHLTUInt32_t)parameter.Atoi();
141       } else if (parameter.BeginsWith("0x") &&
142                  parameter.Replace(0,2,"",0).IsHex()) {
143         sscanf(parameter.Data(),"%x", &fSpecification);
144       } else {
145         HLTError("wrong parameter for argument %s, number expected", argument.Data());
146         iResult=-EINVAL;
147       }
148     } else {
149       HLTError("unknown argument %s", argument.Data());
150       iResult=-EINVAL;
151     }
152   }
153   if (bMissingParam) {
154     HLTError("missing parameter for argument %s", argument.Data());
155     iResult=-EINVAL;
156   }
157
158   if (iResult<0) return iResult;
159
160   if (fLoaderType.IsNull()) {
161     HLTError("loader type required, use \'-loader\' option");
162     return -EINVAL;
163   }
164
165   // fetch runLoader instance from interface
166   AliRunLoader* pRunLoader=GetRunLoader();
167   if (pRunLoader) {
168
169     // get the TPC loader
170     fpLoader=pRunLoader->GetLoader(fLoaderType.Data());
171     if (fpLoader) {
172       // prepare the loader
173       fpLoader->LoadDigits("read");
174
175       // scan trough all events and estimate the size of the digits
176       for (int i=0; i<pRunLoader->GetNumberOfEvents(); i++) {
177         pRunLoader->GetEvent(i);
178         TTree* pTree=GetTree();
179         if (pTree) {
180           int size=EstimateObjectSize(pTree);
181           if (size>fMaxSize) fMaxSize=size;
182           if (fVerbose) {
183             AliInfoStream() << "event " << i << " " 
184                             << fTreeType <<" size " << size 
185                             << " count " << pTree->GetEntries() << endl;
186           }
187         } else {
188           AliWarningStream() << "no " << fTreeType << " tree for event " << i << endl;
189         }
190       }
191     } else {
192       AliErrorStream() << "can not get loader of type " << fLoaderType << endl;
193       iResult=-EFAULT;
194     }    
195   } else {
196     AliErrorStream() << "can not get runLoader" << endl;
197     iResult=-EFAULT;
198   }
199   return iResult;
200 }
201
202 int AliHLTLoaderPublisherComponent::DoDeinit()
203 {
204   // see header file for class documentation
205   int iResult=0;
206   if (fpLoader) {
207     fpLoader->UnloadDigits();
208   }
209   fpLoader=NULL;
210   return iResult;
211 }
212
213 int AliHLTLoaderPublisherComponent::GetEvent(const AliHLTComponentEventData& evtData,
214                                                  AliHLTComponentTriggerData& trigData)
215 {
216   // see header file for class documentation
217   int iResult=0;
218   // fetch runLoader instance from interface
219   AliRunLoader* pRunLoader=GetRunLoader();
220   if (pRunLoader && fpLoader) {
221     pRunLoader->GetEvent(GetEventCount());
222     TTree* pTree=GetTree();
223     if (pTree) {
224       PushBack(pTree, fDataType);
225     } else {
226       AliWarningStream() << "no " << fTreeType << " tree for event " << GetEventCount() << endl;
227     }
228   } else {
229     AliErrorStream() << "component not initialized" << endl;
230     iResult=-EFAULT;
231   }
232   return iResult;
233 }
234
235 TTree* AliHLTLoaderPublisherComponent::GetTree()
236 {
237   TTree* pTree=NULL;
238   if (fpLoader) {
239     if (fTreeType.CompareTo("digits")==0)
240       pTree=fpLoader->TreeD();
241     else if (fTreeType.CompareTo("clusters")==0) {
242       pTree=fpLoader->TreeR();
243     }
244   } else {
245   }
246   return pTree;
247 }