]>
Commit | Line | Data |
---|---|---|
187229ab | 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: Kenneth Aamodt * | |
8 | * Kalliopi Kanaki * | |
9 | * for The ALICE HLT Project. * | |
10 | * * | |
11 | * Permission to use, copy, modify and distribute this software and its * | |
12 | * documentation strictly for non-commercial purposes is hereby granted * | |
13 | * without fee, provided that the above copyright notice appears in all * | |
14 | * copies and that both the copyright notice and this permission notice * | |
15 | * appear in the supporting documentation. The authors make no claims * | |
16 | * about the suitability of this software for any purpose. It is * | |
17 | * provided "as is" without express or implied warranty. * | |
18 | **************************************************************************/ | |
19 | ||
20 | /** @file AliHLTTPCKryptonClusterFinderComponent.cxx | |
21 | @author Kenneth Aamodt, Kalliopi Kanaki | |
22 | @date | |
23 | @brief The TPC krypton cluster finder processing component | |
24 | */ | |
25 | ||
26 | // see header file for class documentation // | |
27 | // or // | |
28 | // refer to README to build package // | |
29 | // or // | |
30 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt // | |
31 | ||
32 | #if __GNUC__>= 3 | |
33 | using namespace std; | |
34 | #endif | |
35 | #include "AliHLTTPCKryptonClusterFinderComponent.h" | |
36 | #include "AliHLTTPCDigitReaderDecoder.h" | |
37 | #include "AliHLTTPCKryptonClusterFinder.h" | |
38 | #include "AliHLTTPCSpacePointData.h" | |
39 | #include "AliHLTTPCClusterDataFormat.h" | |
40 | #include "AliHLTTPCTransform.h" | |
41 | #include "AliHLTTPCClusters.h" | |
42 | #include "AliHLTTPCDefinitions.h" | |
43 | #include "AliCDBEntry.h" | |
44 | #include "AliCDBManager.h" | |
98034d0d | 45 | #include "TH1F.h" |
187229ab | 46 | |
47 | #include <cstdlib> | |
48 | #include <cerrno> | |
49 | #include "TString.h" | |
50 | #include "TObjString.h" | |
51 | #include <sys/time.h> | |
52 | ||
53 | AliHLTTPCKryptonClusterFinderComponent gAliHLTTPCKryptonClusterFinderComponent; | |
54 | ||
55 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
56 | ClassImp(AliHLTTPCKryptonClusterFinderComponent) | |
57 | ||
58 | AliHLTTPCKryptonClusterFinderComponent::AliHLTTPCKryptonClusterFinderComponent() | |
59 | : | |
98034d0d | 60 | fKryptonClusterFinder(NULL), |
b7625c4d | 61 | fReader(NULL), |
62 | fSpecification(0) | |
187229ab | 63 | { |
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 | AliHLTTPCKryptonClusterFinderComponent::~AliHLTTPCKryptonClusterFinderComponent() | |
72 | { | |
73 | // see header file for class documentation | |
74 | } | |
75 | ||
76 | // Public functions to implement AliHLTComponent's interface. | |
77 | // These functions are required for the registration process | |
78 | ||
79 | const char* AliHLTTPCKryptonClusterFinderComponent::GetComponentID() | |
80 | { | |
81 | // see header file for class documentation | |
82 | return "TPCKryptonClusterFinder"; | |
83 | } | |
84 | ||
85 | void AliHLTTPCKryptonClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) | |
86 | { | |
87 | // see header file for class documentation | |
88 | list.clear(); | |
89 | list.push_back( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC ); | |
90 | } | |
91 | ||
92 | AliHLTComponentDataType AliHLTTPCKryptonClusterFinderComponent::GetOutputDataType() | |
93 | { | |
94 | // see header file for class documentation | |
0efebbac | 95 | return kAliHLTMultipleDataType; |
96 | // return kAliHLTDataTypeHistogram; | |
187229ab | 97 | } |
98 | ||
99 | int AliHLTTPCKryptonClusterFinderComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) | |
100 | ||
101 | { | |
102 | // see header file for class documentation | |
103 | tgtList.clear(); | |
0efebbac | 104 | tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType); |
105 | tgtList.push_back(kAliHLTDataTypeHwAddr16); | |
187229ab | 106 | return tgtList.size(); |
107 | } | |
108 | ||
109 | void AliHLTTPCKryptonClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) | |
110 | { | |
111 | // see header file for class documentation | |
112 | // XXX TODO: Find more realistic values. | |
113 | constBase = 0; | |
b7625c4d | 114 | inputMultiplier = (100 * 0.4); |
187229ab | 115 | } |
116 | ||
117 | AliHLTComponent* AliHLTTPCKryptonClusterFinderComponent::Spawn() | |
118 | { | |
119 | // see header file for class documentation | |
120 | return new AliHLTTPCKryptonClusterFinderComponent(); | |
121 | } | |
122 | ||
123 | int AliHLTTPCKryptonClusterFinderComponent::DoInit( int argc, const char** argv ) | |
124 | { | |
125 | // see header file for class documentation | |
0efebbac | 126 | |
127 | // HLTFatal("Initializing the kryptonclusterfindercomponent"); | |
128 | ||
98034d0d | 129 | if ( fKryptonClusterFinder ) |
187229ab | 130 | return EINPROGRESS; |
131 | ||
98034d0d | 132 | fKryptonClusterFinder = new AliHLTTPCKryptonClusterFinder(); |
187229ab | 133 | |
134 | Int_t i = 0; | |
135 | ||
136 | while ( i < argc ) { | |
137 | ||
138 | //No arguments so far | |
139 | ||
140 | Logging(kHLTLogError, "HLT::TPCClusterFinder::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] ); | |
141 | return EINVAL; | |
142 | ||
143 | } | |
144 | ||
145 | fReader = new AliHLTTPCDigitReaderDecoder(); | |
98034d0d | 146 | fKryptonClusterFinder->SetReader(fReader); |
187229ab | 147 | |
148 | return 0; | |
149 | } | |
150 | ||
151 | int AliHLTTPCKryptonClusterFinderComponent::DoDeinit() | |
152 | { | |
153 | // see header file for class documentation | |
154 | ||
98034d0d | 155 | if ( fKryptonClusterFinder ) |
156 | delete fKryptonClusterFinder; | |
157 | fKryptonClusterFinder = NULL; | |
187229ab | 158 | |
159 | if ( fReader ) | |
160 | delete fReader; | |
161 | fReader = NULL; | |
162 | ||
163 | return 0; | |
164 | } | |
165 | ||
0efebbac | 166 | int AliHLTTPCKryptonClusterFinderComponent::DoEvent( const AliHLTComponentEventData& evtData, |
0e588049 | 167 | const AliHLTComponentBlockData* /*blocks*/, |
0efebbac | 168 | AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, |
169 | AliHLTUInt32_t& size, | |
170 | vector<AliHLTComponentBlockData>& outputBlocks ) | |
171 | { | |
187229ab | 172 | // see header file for class documentation |
173 | ||
0e588049 | 174 | if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )){ |
175 | size=0; | |
176 | return 0; | |
177 | } | |
b7625c4d | 178 | |
187229ab | 179 | // == init iter (pointer to datablock) |
180 | const AliHLTComponentBlockData* iter = NULL; | |
187229ab | 181 | |
a912b63b | 182 | Int_t slice, patch; |
187229ab | 183 | |
b7625c4d | 184 | unsigned long maxPoints = 0; |
98034d0d | 185 | |
0efebbac | 186 | AliHLTTPCClusterData* outPtr; |
187 | ||
188 | outPtr = (AliHLTTPCClusterData*)outputPtr; | |
189 | ||
b7625c4d | 190 | for (iter = GetFirstInputBlock(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){ |
187229ab | 191 | |
b7625c4d | 192 | HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", |
193 | evtData.fEventID, evtData.fEventID, | |
194 | DataType2Text(iter->fDataType).c_str(), | |
195 | DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str()); | |
187229ab | 196 | |
b7625c4d | 197 | if (iter->fDataType == AliHLTTPCDefinitions::fgkDDLPackedRawDataType && GetEventCount()<2){ |
198 | HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeDDLRaw)!", | |
199 | DataType2Text(AliHLTTPCDefinitions::fgkDDLPackedRawDataType).c_str(), | |
200 | DataType2Text(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC).c_str()); | |
201 | } | |
202 | ||
203 | if ( iter->fDataType != (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC) && | |
204 | iter->fDataType != AliHLTTPCDefinitions::fgkDDLPackedRawDataType ) continue; | |
187229ab | 205 | |
b7625c4d | 206 | fSpecification = iter->fSpecification; |
187229ab | 207 | |
b7625c4d | 208 | slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter ); |
209 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
187229ab | 210 | |
211 | ||
b7625c4d | 212 | fKryptonClusterFinder->SetPatch(patch); |
187229ab | 213 | |
a912b63b | 214 | fKryptonClusterFinder->InitSlice( slice, patch, maxPoints ); |
b7625c4d | 215 | |
0efebbac | 216 | fKryptonClusterFinder->SetOutputArray((AliHLTTPCSpacePointData*)outPtr->fSpacePoints); |
217 | ||
218 | fKryptonClusterFinder->SetMaxOutputSize(size-sizeof(AliHLTUInt32_t)); | |
219 | ||
b7625c4d | 220 | fKryptonClusterFinder->ReadDataUnsorted(iter->fPtr, iter->fSize); |
187229ab | 221 | |
b7625c4d | 222 | fKryptonClusterFinder->FindRowClusters(); |
98034d0d | 223 | |
b7625c4d | 224 | fKryptonClusterFinder->FindKryptonClusters(); |
0efebbac | 225 | |
226 | // if(fKryptonClusterFinder->GetNKryptonClusters()>0){ | |
227 | ||
228 | // HLTFatal("Number of kryptonClusters: %d",(Int_t)fKryptonClusterFinder->GetNKryptonClusters()); | |
229 | ||
230 | if (sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData)>=size) { | |
231 | HLTFatal("Buffer too small too add more spacepoints: %d of %d byte(s) already used",sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData) ,size); | |
232 | return -ENOSPC; | |
233 | } | |
234 | ||
235 | outPtr->fSpacePointCnt=fKryptonClusterFinder->GetNKryptonClusters(); | |
236 | ||
237 | AliHLTComponentBlockData bd; | |
238 | FillBlockData( bd ); | |
239 | bd.fOffset = 0; | |
240 | bd.fSize = sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData); | |
241 | bd.fSpecification = iter->fSpecification; | |
242 | bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType; | |
243 | outputBlocks.push_back( bd ); | |
244 | ||
245 | //adding the list of hardware addresses to the outpot buffer | |
246 | ||
247 | AliHLTUInt32_t dataOffsetBeforeHW=sizeof(AliHLTUInt32_t)+fKryptonClusterFinder->GetNKryptonClusters()*sizeof(AliHLTTPCSpacePointData); | |
248 | AliHLTUInt32_t sizeOfHWArray=fKryptonClusterFinder->fHWAddressVector.size()*sizeof(AliHLTUInt16_t); | |
249 | // cout<<"size of array: "<<sizeOfHWArray<<" number of entries"<<fKryptonClusterFinder->fHWAddressVector.size()<<endl; | |
250 | ||
251 | if (dataOffsetBeforeHW+sizeOfHWArray>=size){ | |
252 | HLTFatal("Buffer too small too add the HW address list: %d of %d byte(s) already used",dataOffsetBeforeHW+sizeOfHWArray ,size); | |
253 | return -ENOSPC; | |
254 | } | |
98034d0d | 255 | |
0efebbac | 256 | AliHLTUInt16_t *outputHWPtr=(AliHLTUInt16_t*)(outputPtr+dataOffsetBeforeHW); |
257 | for(UInt_t hw=0;hw<fKryptonClusterFinder->fHWAddressVector.size();hw++){ | |
258 | *outputHWPtr = fKryptonClusterFinder->fHWAddressVector[hw]; | |
259 | outputHWPtr++; | |
260 | } | |
261 | ||
262 | AliHLTComponentBlockData bdHW; | |
263 | FillBlockData( bdHW ); | |
264 | bdHW.fOffset = dataOffsetBeforeHW; | |
265 | bdHW.fSize = sizeOfHWArray; | |
266 | bdHW.fSpecification = iter->fSpecification; | |
267 | bdHW.fDataType = kAliHLTDataTypeHwAddr16; | |
268 | outputBlocks.push_back( bdHW ); | |
269 | ||
270 | size=dataOffsetBeforeHW+sizeOfHWArray; | |
271 | ||
272 | /* } | |
273 | else{ | |
274 | size=0; | |
275 | }*/ | |
5863c71a | 276 | fReader->Reset(); |
b7625c4d | 277 | } |
b7625c4d | 278 | return 0; |
279 | } | |
187229ab | 280 | |
b7625c4d | 281 | int AliHLTTPCKryptonClusterFinderComponent::Configure(const char* arguments) { |
282 | // see header file for class documentation | |
187229ab | 283 | |
b7625c4d | 284 | int iResult=0; |
285 | if (!arguments) return iResult; | |
286 | HLTInfo("parsing configuration string \'%s\'", arguments); | |
287 | /* | |
288 | TString allArgs=arguments; | |
289 | TString argument; | |
290 | int bMissingParam=0; | |
291 | ||
292 | TObjArray* pTokens=allArgs.Tokenize(" "); | |
293 | if (pTokens) { | |
294 | for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) { | |
295 | argument=((TObjString*)pTokens->At(i))->GetString(); | |
296 | if (argument.IsNull()) continue; | |
297 | ||
298 | if (argument.CompareTo("-apply-noisemap")==0) { | |
299 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
300 | HLTInfo("got \'-apply-noisemap\': %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
301 | ||
302 | } | |
303 | else if (argument.CompareTo("-plot-side-c")==0) { | |
304 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
305 | HLTInfo("got \'-plot-side-c\': %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
306 | ||
307 | } | |
308 | else if (argument.CompareTo("-plot-side-a")==0) { | |
309 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
310 | HLTInfo("got \'-plot-side-a\': %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
311 | ||
312 | } | |
313 | else { | |
314 | HLTError("unknown argument %s", argument.Data()); | |
315 | iResult=-EINVAL; | |
316 | break; | |
317 | } | |
318 | } // end for | |
187229ab | 319 | |
b7625c4d | 320 | delete pTokens; |
187229ab | 321 | |
b7625c4d | 322 | } // end if pTokens |
187229ab | 323 | |
b7625c4d | 324 | if (bMissingParam) { |
325 | HLTError("missing parameter for argument %s", argument.Data()); | |
326 | iResult=-EINVAL; | |
327 | } | |
328 | */ | |
329 | return iResult; | |
187229ab | 330 | } |
331 | ||
332 | int AliHLTTPCKryptonClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId) | |
333 | { | |
334 | // see header file for class documentation | |
335 | const char* path="HLT/ConfigTPC"; | |
336 | if (cdbEntry) path=cdbEntry; | |
337 | if (path) { | |
338 | HLTInfo("reconfigure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>"); | |
339 | AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/); | |
340 | if (pEntry) { | |
341 | TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject()); | |
342 | if (pString) { | |
343 | HLTInfo("received configuration object: %s", pString->GetString().Data()); | |
344 | } else { | |
345 | HLTError("configuration object \"%s\" has wrong type, required TObjString", path); | |
346 | } | |
347 | } else { | |
348 | HLTError("can not fetch object \"%s\" from CDB", path); | |
349 | } | |
350 | } | |
351 | return 0; | |
352 | } |