Line data Source code
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: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de *
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 AliHLTTPCClusterTransformationComponent.cxx
19 : @author Sergey Gorbunov
20 : @date
21 : @brief
22 : */
23 :
24 : #include "AliHLTTPCClusterTransformationComponent.h"
25 : #include "AliHLTTPCClusterTransformation.h"
26 : #include "AliHLTTPCDefinitions.h"
27 : #include "AliHLTTPCGeometry.h"
28 : #include "AliHLTTPCRawCluster.h"
29 : #include "AliHLTTPCClusterDataFormat.h"
30 : #include "AliHLTErrorGuard.h"
31 : #include "AliHLTTPCFastTransformObject.h"
32 : #include "AliGRPManager.h"
33 : #include "AliGRPObject.h"
34 : #include "AliDAQ.h"
35 :
36 : #include "AliCDBManager.h"
37 : #include "AliCDBEntry.h"
38 : #include "AliTPCcalibDB.h"
39 :
40 : #include "TMath.h"
41 : #include "TObjString.h"
42 : #include <cstdlib>
43 : #include <cerrno>
44 : #include <sys/time.h>
45 :
46 : using namespace std;
47 :
48 6 : ClassImp(AliHLTTPCClusterTransformationComponent) //ROOT macro for the implementation of ROOT specific class methods
49 :
50 : const char* AliHLTTPCClusterTransformationComponent::fgkOCDBEntryClusterTransformation="HLT/ConfigTPC/TPCClusterTransformation";
51 :
52 6 : AliHLTTPCClusterTransformation AliHLTTPCClusterTransformationComponent::fgTransform;
53 : Bool_t AliHLTTPCClusterTransformationComponent::fgTimeInitialisedFromEvent = 0;
54 :
55 3 : AliHLTTPCClusterTransformationComponent::AliHLTTPCClusterTransformationComponent()
56 : :
57 3 : fOfflineMode(0),
58 3 : fInitializeByObjectInDoEvent(0),
59 3 : fInitialized(0),
60 3 : fTPCPresent(0),
61 3 : fDataId(kFALSE),
62 3 : fBenchmark("ClusterTransformation")
63 15 : {
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 3 : fBenchmark.Reset();
71 3 : fBenchmark.SetTimer(0,"total");
72 6 : }
73 :
74 : AliHLTTPCClusterTransformationComponent::~AliHLTTPCClusterTransformationComponent()
75 18 : {
76 : // destructor
77 9 : }
78 :
79 : const char* AliHLTTPCClusterTransformationComponent::GetComponentID() {
80 : // see header file for class documentation
81 :
82 390 : return "TPCClusterTransformation";
83 : }
84 :
85 : void AliHLTTPCClusterTransformationComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
86 : // see header file for class documentation
87 :
88 0 : list.clear();
89 0 : list.push_back( AliHLTTPCDefinitions::fgkRawClustersDataType | kAliHLTDataOriginTPC );
90 0 : list.push_back( AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC );
91 0 : list.push_back( AliHLTTPCDefinitions::fgkTPCFastTransformDataObjectDataType | kAliHLTDataOriginTPC );
92 0 : }
93 :
94 : AliHLTComponentDataType AliHLTTPCClusterTransformationComponent::GetOutputDataType() {
95 : // see header file for class documentation
96 :
97 0 : return kAliHLTMultipleDataType;
98 : }
99 :
100 : int AliHLTTPCClusterTransformationComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
101 : // see header file for class documentation
102 :
103 0 : tgtList.clear();
104 0 : tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType| kAliHLTDataOriginTPC);
105 0 : tgtList.push_back(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC );
106 0 : return tgtList.size();
107 : }
108 :
109 : void AliHLTTPCClusterTransformationComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
110 : // see header file for class documentation
111 0 : constBase = 0;
112 0 : inputMultiplier = 2.5;
113 0 : }
114 :
115 : AliHLTComponent* AliHLTTPCClusterTransformationComponent::Spawn() {
116 : // see header file for class documentation
117 :
118 0 : return new AliHLTTPCClusterTransformationComponent();
119 0 : }
120 :
121 : int AliHLTTPCClusterTransformationComponent::DoInit( int argc, const char** argv )
122 : {
123 : // see header file for class documentation
124 :
125 : int iResult=0;
126 : //!! iResult = ConfigureFromCDBTObjString(fgkOCDBEntryClusterTransformation);
127 :
128 0 : AliGRPManager mgr;
129 0 : mgr.ReadGRPEntry();
130 0 : fTPCPresent = ((mgr.GetGRPData()->GetDetectorMask() & AliDAQ::kTPC) != 0);
131 :
132 0 : if (!fTPCPresent) return(iResult);
133 :
134 0 : fOfflineMode = 0;
135 :
136 0 : if (iResult>=0 && argc>0)
137 0 : iResult=ConfigureFromArgumentString(argc, argv);
138 :
139 0 : AliTPCcalibDB *calib=AliTPCcalibDB::Instance();
140 0 : if(!calib){
141 0 : HLTError("AliTPCcalibDB does not exist");
142 0 : return -ENOENT;
143 : }
144 0 : calib->SetRun(GetRunNo());
145 0 : calib->UpdateRunInformations(GetRunNo());
146 :
147 0 : if( !fgTransform.IsInitialised() ){
148 0 : TStopwatch timer;
149 0 : timer.Start();
150 : int err = 0;
151 0 : if ( fInitializeByObjectInDoEvent == 1 ) {
152 0 : HLTInfo( "Cluster Transformation will initialize on the fly in DoEvent loop via FastTransformation Data Object, skipping initialization." );
153 : }
154 0 : else if( fOfflineMode ) {
155 0 : err = fgTransform.Init( GetBz(), GetTimeStamp() );
156 0 : fInitialized = true;
157 0 : } else {
158 : const char* defaultNotify = "";
159 : const char* cdbEntry = "HLT/ConfigTPC/TPCFastTransform";
160 : defaultNotify = " (default)";
161 : const char* chainId = 0;
162 :
163 0 : HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
164 0 : AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());
165 0 : if ( !pEntry ) {
166 0 : HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
167 0 : return -EINVAL;
168 : }
169 0 : const AliHLTTPCFastTransformObject *configObj = dynamic_cast<const AliHLTTPCFastTransformObject *>( pEntry->GetObject() );
170 :
171 0 : if ( !configObj ) {
172 0 : HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
173 0 : return -EINVAL;
174 : }
175 :
176 0 : HLTInfo( "received configuration object." );
177 0 : fgTransform.Init( *configObj );
178 0 : fInitialized = true;
179 0 : }
180 0 : timer.Stop();
181 0 : HLTInfo("Initialization time: %f / %f", timer.CpuTime(), timer.RealTime());
182 0 : if( err!=0 ){
183 0 : HLTError(Form("Cannot retrieve offline transform from AliTPCcalibDB, AliHLTTPCClusterTransformation returns %d",err));
184 0 : return -ENOENT;
185 : }
186 0 : }
187 :
188 0 : fDataId = kFALSE;
189 :
190 0 : return iResult;
191 0 : } // end DoInit()
192 :
193 : int AliHLTTPCClusterTransformationComponent::DoDeinit() {
194 : // see header file for class documentation
195 0 : if (fInitialized) fgTransform.DeInit();
196 0 : fInitialized = false;
197 0 : return 0;
198 : }
199 :
200 : int AliHLTTPCClusterTransformationComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) {
201 : // see header file for class documentation
202 0 : fDataId = kFALSE;
203 0 : return 0;//!! ConfigureFromCDBTObjString(fgkOCDBEntryClusterTransformation);
204 : }
205 :
206 : int AliHLTTPCClusterTransformationComponent::ScanConfigurationArgument(int argc, const char** argv){
207 :
208 : // see header file for class documentation
209 :
210 0 : if (argc<=0) return 0;
211 : int iRet = 0;
212 0 : for( int i=0; i<argc; i++ ){
213 0 : TString argument=argv[i];
214 0 : if (argument.CompareTo("-change-dataId")==0){
215 : HLTDebug("Change data ID received.");
216 0 : fDataId = kTRUE;
217 0 : iRet++;
218 0 : } else if (argument.CompareTo("-offline-mode")==0){
219 0 : fOfflineMode = 1;
220 : HLTDebug("Offline mode set.");
221 0 : iRet++;
222 0 : } else if (argument.CompareTo("-initialize-on-the-fly")==0){
223 0 : fInitializeByObjectInDoEvent = 1;
224 : HLTDebug("Initialize on the fly mode set.");
225 0 : iRet++;
226 0 : } else if (argument.CompareTo("-update-object-on-the-fly")==0){
227 0 : fInitializeByObjectInDoEvent = 2;
228 : HLTDebug("Initialize object at startup and update on the fly mode set.");
229 0 : iRet++;
230 0 : } else {
231 : iRet = -EINVAL;
232 0 : HLTError("Unknown argument %s",argv[i]);
233 : }
234 0 : }
235 : return iRet;
236 0 : }
237 :
238 :
239 : int AliHLTTPCClusterTransformationComponent::DoEvent(const AliHLTComponentEventData& evtData,
240 : const AliHLTComponentBlockData* blocks,
241 : AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr,
242 : AliHLTUInt32_t& size,
243 : vector<AliHLTComponentBlockData>& outputBlocks ){
244 : // see header file for class documentation
245 :
246 0 : UInt_t maxOutSize = size;
247 0 : size = 0;
248 : int iResult = 0;
249 :
250 0 : if (!fTPCPresent) return iResult;
251 :
252 0 : if (fInitializeByObjectInDoEvent)
253 : {
254 : //Check first whether there is a new FastTransformation object
255 0 : for ( const TObject *iter = GetFirstInputObject(AliHLTTPCDefinitions::fgkTPCFastTransformDataObjectDataType); iter != NULL; iter = GetNextInputObject() )
256 : {
257 0 : const AliHLTTPCFastTransformObject *configObj = dynamic_cast<const AliHLTTPCFastTransformObject *>(const_cast<TObject*>( iter ) );
258 :
259 0 : if (!configObj)
260 : {
261 0 : HLTError( "Error getting configuration object" );
262 0 : return -EINVAL;
263 : }
264 0 : if (fInitialized)
265 : {
266 0 : HLTInfo("Received updated cluster transformation map with new calibration");
267 0 : fgTransform.DeInit();
268 0 : }
269 : else
270 : {
271 0 : HLTInfo("Received initial cluster transformation map");
272 : }
273 :
274 0 : HLTInfo( "received configuration object." );
275 0 : if (fgTransform.Init( *configObj ))
276 : {
277 0 : HLTError("Failed on-the-fly-initialization of transformation map. Error: %s", fgTransform.GetLastError());
278 0 : return(-1);
279 : }
280 0 : fInitialized = true;
281 0 : break;
282 : }
283 : }
284 :
285 0 : if(!IsDataEvent()) return 0;
286 :
287 0 : if( !fgTransform.IsInitialised() ){
288 0 : HLTError(" TPC Transformation is not initialised ");
289 0 : return -ENOENT;
290 : }
291 :
292 0 : fBenchmark.StartNewEvent();
293 0 : fBenchmark.Start(0);
294 :
295 : // Initialise the transformation here once more for the case of off-line reprocessing
296 0 : if( fInitializeByObjectInDoEvent != 1 && fOfflineMode && !fgTimeInitialisedFromEvent ){
297 0 : Long_t currentTime = static_cast<AliHLTUInt32_t>(time(NULL));
298 0 : Long_t eventTimeStamp = GetTimeStamp();
299 0 : if( TMath::Abs( fgTransform.GetCurrentTimeStamp() - eventTimeStamp )>60 &&
300 0 : TMath::Abs( currentTime - eventTimeStamp)>60*60*5 ){
301 0 : int err = fgTransform.SetCurrentTimeStamp( eventTimeStamp );
302 0 : if( err!=0 ){
303 0 : HLTError(Form("Cannot set time stamp, AliHLTTPCClusterTransformation returns %d",err));
304 0 : return -ENOENT;
305 : }
306 0 : }
307 0 : fgTimeInitialisedFromEvent = 1;
308 0 : }
309 :
310 0 : for( unsigned long ndx=0; ndx<evtData.fBlockCnt; ndx++ ){
311 :
312 0 : const AliHLTComponentBlockData *iter = blocks+ndx;
313 :
314 0 : fBenchmark.AddInput(iter->fSize);
315 :
316 : HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s or $s",
317 : evtData.fEventID, evtData.fEventID,
318 : DataType2Text( iter->fDataType).c_str(),
319 : DataType2Text(AliHLTTPCDefinitions::fgkRawClustersDataType).c_str(), DataType2Text(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo).c_str());
320 :
321 0 : if(iter->fDataType == (AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC) ){
322 : // simply forward MC labels
323 :
324 0 : if( size+iter->fSize > maxOutSize ){
325 0 : HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+iter->fSize);
326 : iResult = -ENOSPC;
327 0 : break;
328 : }
329 :
330 0 : memcpy( outputPtr, iter->fPtr, iter->fSize );
331 :
332 0 : AliHLTComponentBlockData bd;
333 0 : FillBlockData( bd );
334 0 : bd.fOffset = size;
335 0 : bd.fSize = iter->fSize;
336 0 : bd.fSpecification = iter->fSpecification;
337 0 : bd.fDataType = iter->fDataType;
338 0 : outputBlocks.push_back( bd );
339 0 : fBenchmark.AddOutput(bd.fSize);
340 0 : size += bd.fSize;
341 0 : outputPtr += bd.fSize;
342 : continue;
343 0 : }
344 :
345 0 : if(iter->fDataType != (AliHLTTPCDefinitions::fgkRawClustersDataType | kAliHLTDataOriginTPC)) continue;
346 :
347 0 : UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
348 0 : UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
349 :
350 : float padpitch=1.0;
351 0 : if ((int)minPartition<AliHLTTPCGeometry::GetNRowLow())
352 0 : padpitch=AliHLTTPCGeometry::GetPadPitchWidthLow();
353 : else
354 0 : padpitch=AliHLTTPCGeometry::GetPadPitchWidthUp();
355 0 : float zwidth=AliHLTTPCGeometry::GetZWidth();
356 :
357 0 : fBenchmark.SetName(Form("ClusterTransform slice %d patch %d",minSlice,minPartition));
358 :
359 : HLTDebug("minSlice: %d, minPartition: %d", minSlice, minPartition);
360 :
361 0 : AliHLTTPCRawClusterData* rawClusters = (AliHLTTPCRawClusterData*)(iter->fPtr);
362 0 : if( !rawClusters ) continue;
363 :
364 0 : AliHLTTPCClusterData* outPtr = (AliHLTTPCClusterData*)outputPtr;
365 0 : outPtr->fSpacePointCnt=0;
366 :
367 0 : long maxPoints = ((long)maxOutSize-size-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
368 :
369 0 : if( rawClusters->fCount > maxPoints ){
370 0 : HLTWarning("No more space to add clusters, exiting!");
371 : iResult = -ENOSPC;
372 0 : break;
373 : }
374 :
375 0 : for( UInt_t icl=0; icl<rawClusters->fCount; icl++){
376 :
377 0 : const AliHLTTPCRawCluster &cl = rawClusters->fClusters[icl];
378 :
379 0 : AliHLTTPCSpacePointData& c=outPtr->fSpacePoints[outPtr->fSpacePointCnt];
380 0 : int padrow=cl.GetPadRow();
381 0 : if (padrow<0) {
382 : // something wrong here, padrow is stored in the cluster header
383 : // word which has bit pattern 0x3 in bits bit 30 and 31 which was
384 : // not recognized
385 0 : ALIHLTERRORGUARD(1, "can not read cluster header word");
386 0 : break;
387 : }
388 0 : padrow+=AliHLTTPCGeometry::GetFirstRow(minPartition);
389 0 : AliHLTUInt32_t charge=cl.GetCharge();
390 :
391 0 : float pad=cl.GetPad();
392 0 : float time=cl.GetTime();
393 0 : float sigmaY2=cl.GetSigmaPad2();
394 0 : float sigmaZ2=cl.GetSigmaTime2();
395 0 : sigmaY2*=padpitch*padpitch;
396 0 : sigmaZ2*=zwidth*zwidth;
397 0 : c.SetPad( cl.GetPad() );
398 0 : c.SetTime( cl.GetTime() );
399 0 : c.SetPadRow(padrow);
400 0 : c.SetCharge(charge);
401 0 : c.SetSigmaY2(sigmaY2);
402 0 : c.SetSigmaZ2(sigmaZ2);
403 0 : c.SetQMax(cl.GetQMax());
404 0 : Float_t xyz[3];
405 0 : int err = fgTransform.Transform( minSlice, padrow, pad, time, xyz );
406 0 : if( err!=0 ){
407 0 : HLTWarning(Form("Cannot transform the cluster, AliHLTTPCClusterTransformation returns error %d, %s",err, fgTransform.GetLastError()));
408 0 : continue;
409 : }
410 0 : c.SetX(xyz[0]);
411 0 : c.SetY(xyz[1]);
412 0 : c.SetZ(xyz[2]);
413 :
414 : // set the cluster ID so that the cluster dump printout is the same for FCF and SCF
415 0 : c.SetID( minSlice, minPartition, outPtr->fSpacePointCnt );
416 :
417 : HLTDebug("Cluster number %d: %f, Y: %f, Z: %f, charge: %d \n", outPtr->fSpacePointCnt, c.GetX(), c.GetY(), c.GetZ(), (UInt_t)c.GetCharge());
418 :
419 0 : outPtr->fSpacePointCnt++;
420 0 : } // end of loop over clusters
421 :
422 : HLTDebug("Number of found clusters: %d", outPtr->fSpacePointCnt);
423 :
424 0 : UInt_t mysize = sizeof(AliHLTTPCClusterData) + sizeof(AliHLTTPCSpacePointData)*outPtr->fSpacePointCnt;
425 :
426 0 : AliHLTComponentBlockData bd;
427 0 : FillBlockData( bd );
428 0 : bd.fOffset = size;
429 0 : bd.fSize = mysize;
430 0 : bd.fSpecification = iter->fSpecification;
431 0 : if(fDataId==kFALSE) bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
432 0 : else bd.fDataType = AliHLTTPCDefinitions::fgkAlterClustersDataType;
433 :
434 : //HLTDebug("datatype: %s", DataType2Text(bd.fDataType).c_str());
435 :
436 0 : outputBlocks.push_back( bd );
437 :
438 0 : fBenchmark.AddOutput(bd.fSize);
439 0 : size += mysize;
440 0 : outputPtr += mysize;
441 :
442 0 : } // end of loop over data blocks
443 :
444 0 : fBenchmark.Stop(0);
445 0 : HLTInfo(fBenchmark.GetStatistics());
446 :
447 0 : return iResult;
448 0 : } // end DoEvent()
449 :
450 :
451 :
452 : void AliHLTTPCClusterTransformationComponent::GetOCDBObjectDescription( TMap* const targetMap)
453 : {
454 : // Get a list of OCDB object description needed for the particular component
455 0 : if (!targetMap) return;
456 :
457 : // OCDB entries for component arguments
458 :
459 : //!! targetMap->Add(new TObjString(fgkOCDBEntryClusterTransformation), new TObjString("component argument for the charge threshold"));
460 :
461 : // OCDB entries to be fetched by the TAXI (access via the AliTPCcalibDB class)
462 0 : targetMap->Add(new TObjString("TPC/Calib/Parameters"), new TObjString("unknown content"));
463 0 : targetMap->Add(new TObjString("TPC/Calib/TimeDrift"), new TObjString("drift velocity calibration"));
464 0 : targetMap->Add(new TObjString("TPC/Calib/TimeGain"), new TObjString("time gain calibration"));
465 0 : targetMap->Add(new TObjString("TPC/Calib/Temperature"), new TObjString("temperature map"));
466 0 : targetMap->Add(new TObjString("TPC/Calib/PadGainFactor"), new TObjString("gain factor pad by pad"));
467 0 : targetMap->Add(new TObjString("TPC/Calib/ClusterParam"), new TObjString("cluster parameters"));
468 0 : targetMap->Add(new TObjString("TPC/Calib/Correction"), new TObjString("coreection"));
469 0 : targetMap->Add(new TObjString("TPC/Calib/RecoParam"), new TObjString("reconstruction parameters"));
470 :
471 : // OCDB entries needed to be fetched by the Pendolino
472 0 : targetMap->Add(new TObjString("TPC/Calib/AltroConfig"), new TObjString("contains the altro config, e.g. info about the L0 trigger timing"));
473 0 : targetMap->Add(new TObjString("GRP/CTP/CTPtiming"), new TObjString("content used in the cluster coordinate transformation in relation to the L0 trigger timing"));
474 :
475 : // OCDB entries necessary for replaying data on the HLT cluster
476 0 : targetMap->Add(new TObjString("GRP/GRP/Data"), new TObjString("contains magnetic field info"));
477 :
478 : // OCDB entries needed to suppress fatals/errors/warnings during reconstruction
479 0 : targetMap->Add(new TObjString("TPC/Calib/Distortion"), new TObjString("distortion map"));
480 0 : targetMap->Add(new TObjString("TPC/Calib/GainFactorDedx"), new TObjString("gain factor dedx"));
481 0 : targetMap->Add(new TObjString("TPC/Calib/PadTime0"), new TObjString("time0 offset pad by pad"));
482 0 : targetMap->Add(new TObjString("TPC/Calib/PadNoise"), new TObjString("pad noise values"));
483 0 : targetMap->Add(new TObjString("TPC/Calib/Pedestals"), new TObjString("pedestal info"));
484 0 : targetMap->Add(new TObjString("TPC/Calib/Pulser"), new TObjString("pulser info"));
485 0 : targetMap->Add(new TObjString("TPC/Calib/CE"), new TObjString("CE laser calibration result"));
486 0 : targetMap->Add(new TObjString("TPC/Calib/Raw"), new TObjString("unknown content"));
487 0 : targetMap->Add(new TObjString("TPC/Calib/QA"), new TObjString("not important"));
488 0 : targetMap->Add(new TObjString("TPC/Calib/Mapping"), new TObjString("unknown content"));
489 0 : targetMap->Add(new TObjString("TPC/Calib/Goofie"), new TObjString("Goofie values, not used at the moment (05.03.2010)"));
490 0 : targetMap->Add(new TObjString("TPC/Calib/HighVoltage"), new TObjString("high voltage values, not used"));
491 0 : targetMap->Add(new TObjString("TPC/Calib/Ref"), new TObjString("unknown content"));
492 0 : }
|
