// $Id$
-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
- * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
- * for The ALICE Off-line Project. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* *
+//* Primary Authors: *
+//* for The ALICE HLT Project. *
+//* *
+//* Permission to use, copy, modify and distribute this software and its *
+//* documentation strictly for non-commercial purposes is hereby granted *
+//* without fee, provided that the above copyright notice appears in all *
+//* copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************
/** @file AliHLTTRDClusterizerComponent.cxx
- @author Timm Steinbeck, Matthias Richter
+ @author Theodor Rascanu
@date
- @brief A TRDClusterizer processing component for the HLT. */
+ @brief A TRDClusterizer processing component for the HLT.
+*/
// see header file for class documentation //
// or //
#include "AliHLTTRDClusterizerComponent.h"
#include "AliHLTTRDDefinitions.h"
-#include "AliHLTTRDCluster.h"
+#include "AliHLTTRDClusterizer.h"
+#include "AliHLTTRDUtils.h"
#include "AliGeomManager.h"
#include "AliTRDReconstructor.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
-#include "AliHLTTRDClusterizer.h"
#include "AliTRDrecoParam.h"
-#include "AliTRDrawStreamBase.h"
+#include "AliTRDrawStream.h"
#include "AliTRDcluster.h"
#include "AliRawReaderMemory.h"
#ifdef HAVE_VALGRIND_CALLGRIND_H
#include <valgrind/callgrind.h>
#else
-#define CALLGRIND_START_INSTRUMENTATION do { } while (0)
-#define CALLGRIND_STOP_INSTRUMENTATION do { } while (0)
+#define CALLGRIND_START_INSTRUMENTATION (void)0
+#define CALLGRIND_STOP_INSTRUMENTATION (void)0
#endif
#include <cstdlib>
ClassImp(AliHLTTRDClusterizerComponent)
-AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent():
- AliHLTProcessor(),
- fOutputPercentage(500),
+AliHLTTRDClusterizerComponent::AliHLTTRDClusterizerComponent()
+: AliHLTProcessor(),
+ fOutputPercentage(100),
fOutputConst(0),
fClusterizer(NULL),
fRecoParam(NULL),
fyPosMethod(1),
fgeometryFileName(""),
fProcessTracklets(kFALSE),
- fOfflineMode(kFALSE),
- fHLTstreamer(kFALSE)
+ fHLTstreamer(kTRUE),
+ fTC(kFALSE),
+ fHLTflag(kTRUE),
+ fHighLevelOutput(kFALSE),
+ fEmulateHLTClusters(kFALSE)
{
// Default constructor
{
// Get the list of input data
list.clear(); // We do not have any requirements for our input data type(s).
- list.push_back( (kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD) );
+ list.push_back(kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTRD);
}
-AliHLTComponent_DataType AliHLTTRDClusterizerComponent::GetOutputDataType()
+AliHLTComponentDataType AliHLTTRDClusterizerComponent::GetOutputDataType()
{
// Get the output data type
return kAliHLTMultipleDataType;
{
// Get the output data size
constBase = fOutputConst;
- inputMultiplier = ((double)fOutputPercentage)/100.0;
+ inputMultiplier = ((double)fOutputPercentage)*4/100.0;
}
AliHLTComponent* AliHLTTRDClusterizerComponent::Spawn()
return -1;
}
+ if(iResult<0) return iResult;
+
fMemReader = new AliRawReaderMemory;
fClusterizer->SetReconstructor(fReconstructor);
fClusterizer->SetUseLabels(kFALSE);
if(fReconstructor->IsProcessingTracklets())
fOutputConst = fClusterizer->GetTrMemBlockSize();
- return 0;
+
+ return iResult;
}
int AliHLTTRDClusterizerComponent::DoDeinit()
fReconstructor->SetClusters(0x0);
delete fReconstructor;
fReconstructor = 0x0;
- return 0;
if (fRecoParam)
{
delete fRecoParam;
fRecoParam = 0;
}
+
+ return 0;
}
int AliHLTTRDClusterizerComponent::DoEvent( const AliHLTComponentEventData& evtData,
{
// Process an event
- if (evtData.fEventID == 1)
+#ifdef HAVE_VALGRIND_CALLGRIND_H
+ if (evtData.fEventID == 10)
CALLGRIND_START_INSTRUMENTATION;
+ if(GetFirstInputBlock(kAliHLTDataTypeEOR))
+ CALLGRIND_STOP_INSTRUMENTATION;
+#endif
+
+ if(!IsDataEvent())return 0;
+
HLTDebug( "NofBlocks %i", evtData.fBlockCnt );
// Process an event
AliHLTUInt32_t totalSize = 0, offset = 0;
block.fSize);
}
- // fMemReader->Reset();
+#ifndef NDEBUG
+ unsigned long constBase;
+ double inputMultiplier;
+ GetOutputDataSize(constBase,inputMultiplier);
+ if(size<(constBase+block.fSize*inputMultiplier)){
+ HLTWarning("Memory Block given might be too small: %i < %i; Event %Lu", size, constBase+block.fSize*inputMultiplier, evtData.fEventID);
+ }
+#endif
+
+ // fMemReader->Reset();
fMemReader->SetMemory((UChar_t*) block.fPtr, block.fSize);
AliHLTUInt32_t spec = block.fSpecification;
- Int_t id = 1024;
-
- for ( Int_t ii = 0; ii < 18 ; ii++ ) {
- if ( spec & 0x1 ) {
- id += ii;
- break;
- }
- spec = spec >> 1 ;
- }
+ Int_t id = AliHLTTRDUtils::GetSM(spec) + 1024;
- fMemReader->SetEquipmentID( id );
+ fMemReader->SetEquipmentID(id);
fClusterizer->SetMemBlock(outputPtr+offset);
- Bool_t iclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
- if (iclustered == kTRUE)
+ Bool_t bclustered = fClusterizer->Raw2ClustersChamber(fMemReader);
+ if(bclustered)
{
- HLTDebug( "Clustered successfully");
+ HLTDebug("Clustered successfully");
}
else
{
return -1;
}
- // put the tree into output
- //fcTree->Print();
-
AliHLTUInt32_t addedSize;
if(fReconstructor->IsProcessingTracklets()){
addedSize = fClusterizer->GetAddedTrSize();
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = addedSize;
- //bd.fSpecification = spec;
- bd.fSpecification = gkAliEventTypeData;
+ bd.fSpecification = block.fSpecification;
bd.fDataType = AliHLTTRDDefinitions::fgkMCMtrackletDataType;
outputBlocks.push_back( bd );
- HLTDebug( "BD fPtr 0x%x, fOffset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+ HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
}
offset = totalSize;
}
addedSize = fClusterizer->GetAddedClSize();
if (addedSize > 0){
- // Using low-level interface
- // with interface classes
+
+ Int_t* nTimeBins = (Int_t*)(outputPtr+offset+fClusterizer->GetAddedClSize());
+ *nTimeBins = fClusterizer->GetNTimeBins();
+ addedSize += sizeof(*nTimeBins);
+
totalSize += addedSize;
if ( totalSize > size )
{
totalSize, size );
return EMSGSIZE;
}
-
+
// Fill block
AliHLTComponentBlockData bd;
FillBlockData( bd );
bd.fOffset = offset;
bd.fSize = addedSize;
- //bd.fSpecification = spec;
- bd.fSpecification = gkAliEventTypeData;
+ bd.fSpecification = block.fSpecification;
bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType;
outputBlocks.push_back( bd );
- HLTDebug( "BD fPtr 0x%x, fOffset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
+ HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), spec);
offset = totalSize;
-
}
- else
+ else{
HLTDebug("Array of clusters is empty!");
+ }
}
fReconstructor->SetClusters(0x0);
return 0;
}
-void AliHLTTRDClusterizerComponent::PrintObject( TClonesArray* inClustersArray)
+void AliHLTTRDClusterizerComponent::PrintObject(
+#ifdef __DEBUG
+ TClonesArray* inClustersArray
+#else
+ TClonesArray*
+#endif
+ )
{
+#ifdef __DEBUG
AliTRDcluster* cluster=0x0;
for (Int_t i=0; i < inClustersArray->GetEntriesFast(); i++){
HLTDebug(" Detector = %i, Amplitude = %f, Center = %f", cluster->GetDetector(), cluster->GetQ(), cluster->GetCenter());
HLTDebug(" LocalTimeBin = %i; NPads = %i; maskedPosition: %s, status: %s", cluster->GetLocalTimeBin(), cluster->GetNPads(),cluster->GetPadMaskedPosition(),cluster->GetPadMaskedPosition());
}
-
+#endif
}
int AliHLTTRDClusterizerComponent::Configure(const char* arguments){
argument=((TObjString*)pTokens->At(i))->GetString();
if (argument.IsNull()) continue;
- if (argument.CompareTo("-OFFLINE")==0) {
- fOfflineMode = kTRUE;
- HLTFatal("You have selected OFFLINE mode!");
- HLTFatal("This program shall NOT run on the HLT cluster like this!");
- continue;
- }
- else if (argument.CompareTo("output_percentage")==0) {
+ if (argument.CompareTo("output_percentage")==0) {
if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
HLTInfo("Setting output percentage to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
fOutputPercentage=((TObjString*)pTokens->At(i))->GetString().Atoi();
fgeometryFileName=((TObjString*)pTokens->At(i))->GetString();
continue;
}
- if (argument.CompareTo("-lowflux")==0) {
+ else if (argument.CompareTo("-lowflux")==0) {
fRecoParamType = 0;
HLTInfo("Low flux reconstruction selected");
continue;
}
- if (argument.CompareTo("-highflux")==0) {
+ else if (argument.CompareTo("-highflux")==0) {
fRecoParamType = 1;
HLTInfo("High flux reconstruction selected");
continue;
}
- if (argument.CompareTo("-cosmics")==0) {
+ else if (argument.CompareTo("-cosmics")==0) {
fRecoParamType = 2;
HLTInfo("Cosmics reconstruction selected");
continue;
}
- if (argument.CompareTo("-simulation")==0) {
+ else if (argument.CompareTo("-simulation")==0) {
fRecoDataType = 0;
HLTInfo("Awaiting simulated data");
continue;
}
- if (argument.CompareTo("-experiment")==0) {
+ else if (argument.CompareTo("-experiment")==0) {
fRecoDataType = 1;
HLTInfo("Awaiting real data");
continue;
}
- if (argument.CompareTo("-processTracklets")==0) {
+ else if (argument.CompareTo("-processTracklets")==0) {
fProcessTracklets = kTRUE;
- HLTInfo("Processing L1 Tracklets");
+ HLTInfo("Writing L1 tracklets to output");
continue;
}
- if (argument.CompareTo("-noZS")==0) {
- fOutputPercentage = 100;
+ else if (argument.CompareTo("-noZS")==0) {
+ fOutputPercentage = 10;
HLTInfo("Awaiting non zero surpressed data");
continue;
}
- if (argument.CompareTo("-faststreamer")==0) {
+ else if (argument.CompareTo("-HLTflag")==0) {
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
+ if (toCompareTo.CompareTo("yes")==0){
+ HLTInfo("Setting HLTflag to: %s", toCompareTo.Data());
+ fHLTflag=kTRUE;
+ }
+ else if (toCompareTo.CompareTo("no")==0){
+ HLTInfo("Setting HLTflag to: %s", toCompareTo.Data());
+ fHLTflag=kFALSE;
+ }
+ else {
+ HLTError("unknown argument for HLTflag: %s", toCompareTo.Data());
+ iResult=-EINVAL;
+ break;
+ }
+ continue;
+ }
+ else if (argument.CompareTo("-faststreamer")==0) {
fHLTstreamer = kTRUE;
HLTInfo("Useing fast raw streamer");
continue;
}
+ else if (argument.CompareTo("-nofaststreamer")==0) {
+ fHLTstreamer = kFALSE;
+ HLTInfo("Don't use fast raw streamer");
+ continue;
+ }
+ else if (argument.CompareTo("-tailcancellation")==0) {
+ fTC = kTRUE;
+ HLTInfo("Useing tailcancellation");
+ continue;
+ }
else if (argument.CompareTo("-rawver")==0) {
if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
HLTInfo("Raw data version is: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
fRawDataVersion=((TObjString*)pTokens->At(i))->GetString().Atoi();
continue;
}
+ else if (argument.CompareTo("-highLevelOutput")==0) {
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
+ if (toCompareTo.CompareTo("yes")==0){
+ HLTWarning("Setting highLevelOutput to: %s", toCompareTo.Data());
+ fHighLevelOutput=kTRUE;
+ }
+ else if (toCompareTo.CompareTo("no")==0){
+ HLTInfo("Setting highLevelOutput to: %s", toCompareTo.Data());
+ fHighLevelOutput=kFALSE;
+ }
+ else {
+ HLTError("unknown argument for highLevelOutput: %s", toCompareTo.Data());
+ iResult=-EINVAL;
+ break;
+ }
+ continue;
+ }
+ else if (argument.CompareTo("-emulateHLToutput")==0) {
+ if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
+ TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
+ if (toCompareTo.CompareTo("yes")==0){
+ HLTWarning("Setting emulateHLToutput to: %s", toCompareTo.Data());
+ fEmulateHLTClusters=kTRUE;
+ }
+ else if (toCompareTo.CompareTo("no")==0){
+ HLTInfo("Setting emulateHLToutput to: %s", toCompareTo.Data());
+ fEmulateHLTClusters=kFALSE;
+ }
+ else {
+ HLTError("unknown argument for emulateHLToutput: %s", toCompareTo.Data());
+ iResult=-EINVAL;
+ break;
+ }
+ continue;
+ }
else if (argument.CompareTo("-yPosMethod")==0) {
if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
TString toCompareTo=((TObjString*)pTokens->At(i))->GetString();
break;
}
continue;
- }
+ }
else {
HLTError("unknown argument: %s", argument.Data());
iResult=-EINVAL;
}
if(iResult>=0){
- if(fOfflineMode)SetOfflineParams();
iResult=SetParams();
}
return iResult;
{
Int_t iResult=0;
if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
- HLTError("DefaultStorage is not Set in CDBManager");
+ HLTError("DefaultStorage is not set in CDBManager");
return -EINVAL;
}
if(AliCDBManager::Instance()->GetRun()<0){
AliGeomManager::LoadGeometry(fgeometryFileName.Data());
}
if(!AliGeomManager::GetGeometry()){
- HLTError("Cannot load geometry");
+ HLTError("Could not load geometry");
return -EINVAL;
}
+ HLTInfo("Applying Alignment from CDB object");
+ AliGeomManager::ApplyAlignObjsFromCDB("TRD");
}
else{
HLTInfo("Geometry Already Loaded!");
}
- TString recoOptions="hlt,!cw,sl_cl_0";
-
- switch(fRecoDataType){
- case 0: recoOptions += ",tc"; break;
- case 1: recoOptions += ",!tc"; break;
- }
- switch(fyPosMethod){
- case 0: recoOptions += ",!gs,!lut"; break;
- case 1: recoOptions += ",!gs,lut"; break;
- case 2: recoOptions += ",gs,!lut"; break;
- }
- if(fProcessTracklets) recoOptions += ",tp";
- else recoOptions += ",!tp";
-
-
- if (fRecoParamType == 0)
- {
- HLTDebug("Low flux params init.");
- fRecoParam = AliTRDrecoParam::GetLowFluxParam();
+ if(fReconstructor->GetRecoParam()){
+ fRecoParam = new AliTRDrecoParam(*fReconstructor->GetRecoParam());
+ HLTInfo("RecoParam already set!");
+ }else{
+ if(fRecoParamType == 0){
+#ifndef HAVE_NOT_ALITRD_RECOPARAM_r41621
+ if(fHLTflag){
+ HLTInfo("Low flux HLT params init.");
+ fRecoParam = AliTRDrecoParam::GetLowFluxHLTParam();
+ }else
+#endif
+ {
+ HLTInfo("Low flux params init.");
+ fRecoParam = AliTRDrecoParam::GetLowFluxParam();
+ }
}
-
- if (fRecoParamType == 1)
- {
- HLTDebug("High flux params init.");
- fRecoParam = AliTRDrecoParam::GetHighFluxParam();
+ if(fRecoParamType == 1){
+#ifndef HAVE_NOT_ALITRD_RECOPARAM_r41621
+ if(fHLTflag){
+ HLTInfo("High flux HLT params init.");
+ fRecoParam = AliTRDrecoParam::GetHighFluxHLTParam();
+ }else
+#endif
+ {
+ HLTInfo("High flux params init.");
+ fRecoParam = AliTRDrecoParam::GetHighFluxParam();
+ }
}
-
- if (fRecoParamType == 2)
- {
- HLTDebug("Cosmic Test params init.");
+ if(fRecoParamType == 2){
+ HLTInfo("Cosmic Test params init.");
fRecoParam = AliTRDrecoParam::GetCosmicTestParam();
}
+ }
- if (fRecoParam == 0)
+ if (!fRecoParam)
{
HLTError("No reco params initialized. Sniffing big trouble!");
return -EINVAL;
}
+ if(fTC){fRecoParam->SetTailCancelation(kTRUE); HLTDebug("Enableing Tail Cancelation"); }
+ else{fRecoParam->SetTailCancelation(kFALSE); HLTDebug("Disableing Tail Cancelation"); }
+
+ switch(fyPosMethod){
+ case 0: fRecoParam->SetGAUS(kFALSE); fRecoParam->SetLUT(kFALSE); break;
+ case 1: fRecoParam->SetGAUS(kFALSE); fRecoParam->SetLUT(kTRUE); break;
+ case 2: fRecoParam->SetGAUS(kTRUE); fRecoParam->SetLUT(kFALSE); break;
+ }
+
+ fRecoParam->SetStreamLevel(AliTRDrecoParam::kClusterizer, 0);
fReconstructor->SetRecoParam(fRecoParam);
- fReconstructor->SetStreamLevel(0, AliTRDReconstructor::kClusterizer);
+
+ if(!fClusterizer){
+ fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer");
+ HLTDebug("TRDClusterizer at 0x%x", fClusterizer);
+ }
+
+ TString recoOptions="!cw";
+ if(fHLTflag){
+ recoOptions += ",hlt";
+
+ // we transfer clusters that do no contain the XYZ coodrinates (AliHLTTRDCluster),
+ // thus this coordinate transformation ist useless
+#ifndef HAVE_NOT_ALITRD_CLUSTERIZER_r42837
+ fClusterizer->SetSkipTransform();
+#endif
+ }
+ if(fProcessTracklets) recoOptions += ",tp";
+ else recoOptions += ",!tp";
HLTDebug("Reconstructor options are: %s",recoOptions.Data());
fReconstructor->SetOption(recoOptions.Data());
if (fRecoDataType == 0)
{
- AliTRDrawStreamBase::SetRawStreamVersion(AliTRDrawStreamBase::kTRDsimStream);
HLTDebug("Data type expected is SIMULATION!");
}
if (fRecoDataType == 1)
{
- AliTRDrawStreamBase::SetRawStreamVersion(AliTRDrawStreamBase::kTRDrealStream);
HLTDebug("Data type expected is EXPERIMENT!");
}
- if (fHLTstreamer)
- {
- AliTRDrawStreamBase::SetRawStreamVersion("FAST");
- HLTDebug("fast rawstreamer used");
- }
-
- if(!fClusterizer){
- fClusterizer = new AliHLTTRDClusterizer("TRDCclusterizer", "TRDCclusterizer");
- HLTDebug("TRDClusterizer at 0x%x", fClusterizer);
- }
-
fClusterizer->SetRawVersion(fRawDataVersion);
return iResult;
}
-void AliHLTTRDClusterizerComponent::SetOfflineParams(){
- HLTFatal("You have entered the OFFLINE configuration!");
- if(!AliCDBManager::Instance()->IsDefaultStorageSet()){
- HLTFatal("You are resetting the Default Storage of the CDBManager!");
- HLTFatal("Let's hope that this program is NOT running on the HLT cluster!");
- AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- }else{
- HLTError("DefaultStorage was already set!");
- }
- if(AliCDBManager::Instance()->GetRun()<0){
- HLTFatal("You are resetting the CDB run number to 0!");
- HLTFatal("Let's hope that this program is NOT running on the HLT cluster!");
- AliCDBManager::Instance()->SetRun(0);
- }else{
- HLTError("Run Number was already set!");
- }
-}
-
int AliHLTTRDClusterizerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
// see header file for class documentation
return iResult;
}
+
+void AliHLTTRDClusterizerComponent::GetOCDBObjectDescription(TMap* const targetMap){
+ // Get a list of OCDB object description needed for the particular component
+ if (!targetMap) return;
+ targetMap->Add(new TObjString("HLT/ConfigTRD/ClusterizerComponent"), new TObjString("component arguments"));
+ targetMap->Add(new TObjString("TRD/Calib/ChamberGainFactor"), new TObjString("gain factor of chambers"));
+ targetMap->Add(new TObjString("TRD/Calib/ChamberT0"), new TObjString("T0 of chambers"));
+ targetMap->Add(new TObjString("TRD/Calib/ChamberVdrift"), new TObjString("drift velocity of chambers"));
+ targetMap->Add(new TObjString("TRD/Calib/DetNoise"), new TObjString("noise of chambers"));
+ targetMap->Add(new TObjString("TRD/Calib/LocalGainFactor"), new TObjString("per pad gain factor"));
+ targetMap->Add(new TObjString("TRD/Calib/LocalT0"), new TObjString("per pad T0"));
+ targetMap->Add(new TObjString("TRD/Calib/LocalVdrift"), new TObjString("per pad drift velocity"));
+ targetMap->Add(new TObjString("TRD/Calib/PadNoise"), new TObjString("per pad noise"));
+ targetMap->Add(new TObjString("TRD/Calib/PadStatus"), new TObjString("pad status"));
+ targetMap->Add(new TObjString("TRD/Calib/PRFWidth"), new TObjString("pad response function"));
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff