[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHWClusterTransformComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        *
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
//*                  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   AliHLTTPCHWClusterTransformComponent.cxx
    @author Kalliopi Kanaki
    @date   
    @brief 
*/

#include "AliHLTTPCHWClusterTransformComponent.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliRawDataHeader.h"
#include "AliHLTTPCRawCluster.h"
#include "AliHLTTPCHWCFEmulator.h"
#include "AliHLTTPCHWCFData.h"
#include "AliHLTErrorGuard.h"
#include "AliTPCTransform.h"

#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliTPCcalibDB.h"

#include "TMath.h"
#include "TObjString.h" 
#include <cstdlib>
#include <cerrno>
#include <sys/time.h>

using namespace std;

ClassImp(AliHLTTPCHWClusterTransformComponent) //ROOT macro for the implementation of ROOT specific class methods

const char* AliHLTTPCHWClusterTransformComponent::fgkOCDBEntryHWTransform="HLT/ConfigTPC/TPCHWClusterTransform";

AliHLTTPCClusterTransformation AliHLTTPCHWClusterTransformComponent::fgTransform;
Bool_t AliHLTTPCHWClusterTransformComponent::fgTimeInitialisedFromEvent = 0;

AliHLTTPCHWClusterTransformComponent::AliHLTTPCHWClusterTransformComponent()
:
fDataId(kFALSE),
fPublishRawClusters(kFALSE),
fpDecoder(NULL),
fBenchmark("HWClusterTransform")
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt  

  fBenchmark.Reset();
  fBenchmark.SetTimer(0,"total");
}

AliHLTTPCHWClusterTransformComponent::~AliHLTTPCHWClusterTransformComponent()
{ 
  // destructor
  if (!fpDecoder) delete fpDecoder;
  fpDecoder=NULL;
}

const char* AliHLTTPCHWClusterTransformComponent::GetComponentID() { 
// see header file for class documentation

  return "TPCHWClusterTransform";
}

void AliHLTTPCHWClusterTransformComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
  // see header file for class documentation

  list.clear(); 
  list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType );
}

AliHLTComponentDataType AliHLTTPCHWClusterTransformComponent::GetOutputDataType() { 
  // see header file for class documentation

  return AliHLTTPCDefinitions::fgkClustersDataType;
}

int AliHLTTPCHWClusterTransformComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
  // see header file for class documentation

  tgtList.clear();
  tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType| kAliHLTDataOriginTPC);
  tgtList.push_back(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC );
  tgtList.push_back(AliHLTTPCDefinitions::fgkRawClustersDataType  | kAliHLTDataOriginTPC );
  return tgtList.size();
}

void AliHLTTPCHWClusterTransformComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
  // see header file for class documentation
  constBase = 0;
  inputMultiplier = 3.0;
}

AliHLTComponent* AliHLTTPCHWClusterTransformComponent::Spawn() { 
  // see header file for class documentation

  return new AliHLTTPCHWClusterTransformComponent();
}
	
int AliHLTTPCHWClusterTransformComponent::DoInit( int argc, const char** argv ) 
{ 
  // see header file for class documentation
  
  AliTPCcalibDB *calib=AliTPCcalibDB::Instance();  
  if(!calib){
    HLTError("AliTPCcalibDB does not exist");
    return -ENOENT;
  }
  calib->SetRun(GetRunNo());
  calib->UpdateRunInformations(GetRunNo());
  
  if( !fgTransform.IsInitialised() ){
    int err = fgTransform.Init( GetBz(), GetTimeStamp() );
    if( err!=0 ){
      HLTError(Form("Cannot retrieve offline transform from AliTPCcalibDB, AliHLTTPCClusterTransformation returns %d",err));
      return -ENOENT;
    }
  }

  int iResult=0;
  iResult = ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);

  if (iResult>=0 && argc>0)
    iResult=ConfigureFromArgumentString(argc, argv);

  if (iResult>=0) {
    fpDecoder=new AliHLTTPCHWCFData;
    if (!fpDecoder) iResult=-ENOMEM;
  }
  
  return iResult;
} // end DoInit()

int AliHLTTPCHWClusterTransformComponent::DoDeinit() { 
  // see header file for class documentation   
  if (!fpDecoder) delete fpDecoder;
  fpDecoder=NULL;
  fgTransform.DeInit();
  return 0;
}

int AliHLTTPCHWClusterTransformComponent::DoEvent(const AliHLTComponentEventData& evtData, 
					          const AliHLTComponentBlockData* blocks, 
					          AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
					          AliHLTUInt32_t& size, 
					          vector<AliHLTComponentBlockData>& outputBlocks ){
  // see header file for class documentation
 
  UInt_t maxOutSize = size;
  size = 0;
  int iResult = 0;
  if(!IsDataEvent()) return 0;

  if (!fpDecoder) return -ENODEV;
  if( !fgTransform.IsInitialised() ){
    HLTError(" TPC Transformation is not initialised ");
    return -ENOENT;    
  }

  fBenchmark.StartNewEvent();
  fBenchmark.Start(0);

  // Initialise the transformation here once more for the case of off-line reprocessing
  if( !fgTimeInitialisedFromEvent ){
    Long_t currentTime = static_cast<AliHLTUInt32_t>(time(NULL));
    Long_t eventTimeStamp = GetTimeStamp();
    if( TMath::Abs( fgTransform.GetCurrentTimeStamp() - eventTimeStamp )>60 && 
	TMath::Abs( currentTime - eventTimeStamp)>60*60*5 ){
      int err = fgTransform.SetCurrentTimeStamp( eventTimeStamp );
      if( err!=0 ){
	HLTError(Form("Cannot set time stamp, AliHLTTPCClusterTransformation returns %d",err));
	return -ENOENT;
      }
    }
    fgTimeInitialisedFromEvent = 1;
  }

 for( unsigned long ndx=0; ndx<evtData.fBlockCnt; ndx++ ){
     
    const AliHLTComponentBlockData *iter   = blocks+ndx;
    
    fBenchmark.AddInput(iter->fSize);
    
    HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	     evtData.fEventID, evtData.fEventID, 
	     DataType2Text( iter->fDataType).c_str(), 
	     DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());                       
 
    if(iter->fDataType == (AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo | kAliHLTDataOriginTPC) ){
      // simply forward MC labels
      
      if( size+iter->fSize > maxOutSize ){
	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+iter->fSize);
	iResult  = -ENOSPC;
	break;
      }

      memcpy( outputPtr, iter->fPtr, iter->fSize );
      
      AliHLTComponentBlockData bd;
      FillBlockData( bd );
      bd.fOffset = size;
      bd.fSize = iter->fSize;
      bd.fSpecification = iter->fSpecification;     
      bd.fDataType = iter->fDataType;
      outputBlocks.push_back( bd );     
      fBenchmark.AddOutput(bd.fSize);    
      size   += bd.fSize;
      outputPtr += bd.fSize;
      continue;
    }

    if(iter->fDataType != (AliHLTTPCDefinitions::fgkHWClustersDataType | kAliHLTDataOriginTPC)) continue;                        
        
    UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter); 
    UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
    //UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(*iter); 
    //UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
    float padpitch=1.0;
    if ((int)minPartition<AliHLTTPCTransform::GetNRowLow())
      padpitch=AliHLTTPCTransform::GetPadPitchWidthLow();
    else
      padpitch=AliHLTTPCTransform::GetPadPitchWidthUp();
    float zwidth=AliHLTTPCTransform::GetZWidth();

    fBenchmark.SetName(Form("HWClusterTransform slice %d patch %d",minSlice,minPartition));

    HLTDebug("minSlice: %d, minPartition: %d", minSlice, minPartition);
    
    AliHLTTPCClusterData* outPtr  = (AliHLTTPCClusterData*)outputPtr;
    outPtr->fSpacePointCnt=0;

    long maxPoints = ((long)maxOutSize-size-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);

    AliHLTUInt32_t *buffer;     
    buffer = (AliHLTUInt32_t*)iter->fPtr;  
     
     // skip the first 8 32-bit CDH words
     buffer += 8;
     UInt_t bufferSize32 = ((Int_t)iter->fSize - sizeof(AliRawDataHeader) )/sizeof(AliHLTUInt32_t);

     if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t*>(buffer), bufferSize32*sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
       for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
	 if(outPtr->fSpacePointCnt>=maxPoints){
	   HLTWarning("No more space to add clusters, exiting!");
	   iResult  = -ENOSPC;
	   break;
	 }

	 AliHLTTPCSpacePointData& c=outPtr->fSpacePoints[outPtr->fSpacePointCnt];
	 int padrow=cl.GetPadRow();
	 if (padrow<0) {
	   // something wrong here, padrow is stored in the cluster header
	   // word which has bit pattern 0x3 in bits bit 30 and 31 which was
	   // not recognized
	   ALIHLTERRORGUARD(1, "can not read cluster header word");
	   break;
	 }
	 padrow+=AliHLTTPCTransform::GetFirstRow(minPartition);
	 AliHLTUInt32_t charge=cl.GetCharge();

	 float pad=cl.GetPad();
	 float time=cl.GetTime();
	 float sigmaY2=cl.GetSigmaY2();
	 float sigmaZ2=cl.GetSigmaZ2();
	 sigmaY2*=padpitch*padpitch;
	 sigmaZ2*=zwidth*zwidth;
	 c.SetPadRow(padrow);
	 c.SetCharge(charge);
	 c.SetSigmaY2(sigmaY2);
	 c.SetSigmaZ2(sigmaZ2);
	 c.SetQMax(cl.GetQMax());

	 Float_t xyz[3];
	 int err = fgTransform.Transform( minSlice, padrow, pad, time, xyz );	 
	 if( err!=0 ){
	   HLTWarning(Form("Cannot transform the cluster, AliHLTTPCClusterTransformation returns error %d, %s",err, fgTransform.GetLastError()));
	   continue;
	 }
	 c.SetX(xyz[0]);
	 c.SetY(xyz[1]);
	 c.SetZ(xyz[2]);

	 // set the cluster ID so that the cluster dump printout is the same for FCF and SCF
	 c.SetID( minSlice, minPartition, outPtr->fSpacePointCnt );
	 
	 HLTDebug("Cluster number %d: %f, Y: %f, Z: %f, charge: %d \n", outPtr->fSpacePointCnt, cluster.fX, cluster.fY, cluster.fZ, (UInt_t)cluster.fCharge);
	 
	 outPtr->fSpacePointCnt++; 
       } // end of loop over clusters
     }     
     HLTDebug("Number of found clusters: %d", outPtr->fSpacePointCnt);
     
     UInt_t mysize = sizeof(AliHLTTPCClusterData) + sizeof(AliHLTTPCSpacePointData)*outPtr->fSpacePointCnt;
 
     AliHLTComponentBlockData bd;
     FillBlockData( bd );
     bd.fOffset = size;
     bd.fSize = mysize;
     bd.fSpecification = iter->fSpecification;     
     if(fDataId==kFALSE) bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
     else                bd.fDataType = AliHLTTPCDefinitions::fgkAlterClustersDataType;
     
     //HLTDebug("datatype: %s", DataType2Text(bd.fDataType).c_str());
     
     outputBlocks.push_back( bd );
     
     fBenchmark.AddOutput(bd.fSize);    
     size   += mysize;
     outputPtr += mysize;
  
     if (fPublishRawClusters) {

       long maxRawClusters = ((long)maxOutSize-size-sizeof(AliHLTTPCRawClusterData))/sizeof(AliHLTTPCRawCluster);
       
       if( maxRawClusters<=0 ) {
	 HLTWarning("No more space to add raw clusters, exiting!");
	 iResult  = -ENOSPC;
       } else {       

	 // copy raw cluster data from input
	 
	 AliHLTTPCRawClusterData* outputRaw= (AliHLTTPCRawClusterData*)(outputPtr);
       
	 outputRaw->fVersion = 0;
	 outputRaw->fCount = 0;

	 // check if there are clusters available, if not the format might
	 // not even been decoded at that moment 
	 if (fpDecoder->GetNumberOfClusters()>0) {
	 for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
	   if(outputRaw->fCount>=maxRawClusters){
	     HLTWarning("No more space to add clusters, exiting!");
	     iResult  = -ENOSPC;
	     break;
	   }
	   AliHLTTPCRawCluster &c = outputRaw->fClusters[outputRaw->fCount];
	   int padrow=cl.GetPadRow();
	   if (padrow<0) {
	     // something wrong here, padrow is stored in the cluster header
	     // word which has bit pattern 0x3 in bits bit 30 and 31 which was
	     // not recognized
	     break;
	   }
	   padrow+=AliHLTTPCTransform::GetFirstRow(minPartition);
	   AliHLTUInt32_t charge= cl.GetCharge();

	   float pad =cl.GetPad();
	   float time =cl.GetTime();
	   float sigmaP2=cl.GetSigmaY2();
	   float sigmaT2=cl.GetSigmaZ2();
	   c.SetPadRow(padrow);
	   c.SetCharge(charge);
	   c.SetPad(pad);  
	   c.SetTime(time);
	   c.SetSigmaY2(sigmaP2);
	   c.SetSigmaZ2(sigmaT2);
	   c.SetQMax(cl.GetQMax());

	   // store cluster and continue
	   outputRaw->fCount++;
	 }
	 }

	 // fill into HLT output data
	 AliHLTComponentBlockData bdRawClusters;
	 FillBlockData( bdRawClusters );
	 bdRawClusters.fOffset = size;
	 bdRawClusters.fSize = sizeof(AliHLTTPCRawClusterData)+outputRaw->fCount*sizeof(AliHLTTPCRawCluster);
	 bdRawClusters.fSpecification = iter->fSpecification;
	 bdRawClusters.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType | kAliHLTDataOriginTPC;
	 outputBlocks.push_back( bdRawClusters );
	 fBenchmark.AddOutput(bdRawClusters.fSize);
	 size   += bdRawClusters.fSize;
	 outputPtr += bdRawClusters.fSize;
       }
     }
  } // end of loop over data blocks  
  
  fBenchmark.Stop(0);
  HLTInfo(fBenchmark.GetStatistics());
  
  return iResult;
} // end DoEvent()

int AliHLTTPCHWClusterTransformComponent::ScanConfigurationArgument(int argc, const char** argv){

  // see header file for class documentation

  if (argc<=0) return 0;
  int i=0;
  TString argument=argv[i];

  if (argument.CompareTo("-solenoidBz")==0){
    if (++i>=argc) return -EPROTO;
    argument=argv[i];
    AliTPCcalibDB*  calib=AliTPCcalibDB::Instance();
    if(!calib){
      HLTError("CalibDB instance cannot be created.");
      return 0;
    }
    Float_t magneticField = argument.Atof();
    calib->SetExBField(magneticField);
    HLTInfo("SolenoidBz is set to %f in the calibDB",magneticField);
    return 2;
  }

  if (argument.CompareTo("-change-dataId")==0){
    HLTDebug("Change data ID received.");
    fDataId = kTRUE;
    return 1;
  }
  
  if (argument.CompareTo("-charge-threshold")==0) {
    if (++i>=argc) return -EPROTO;
    argument=argv[i];    
    HLTInfo("The argument -charge-threshold is deprecated.");
    return 2;
  }    

  if (argument.CompareTo("-publish-raw")==0) {
    fPublishRawClusters=kTRUE;
    return 1;
  }  
  
  // unknown argument
  return -EINVAL;
}

int AliHLTTPCHWClusterTransformComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/) { 
  // see header file for class documentation
  return ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
}

void AliHLTTPCHWClusterTransformComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
// see header file for class documentation 

  HLTInfo("The size is: %d", size);
  for(Int_t n32bit=0; n32bit<size; n32bit++){
    
    AliHLTUInt8_t *wordPtr = reinterpret_cast<AliHLTUInt8_t*>(&buffer[n32bit]);
    //    cout << "word ptr initialized"<<endl;
    for(Int_t w=3;w>=0;w--){
      //     cout <<"accessing word"<<endl;
      AliHLTUInt8_t word = wordPtr[w];
      //     cout<< "word was accessed"<<endl; 
      for(int n=7; n>=0; n--){
	//print the byte values
	if((((word>>n)<<7)&0x80) != 0){
	  printf("1");
	}
	else{
	  printf("0");
	}
      }
      printf("  ");
    }
    printf("\n");
  }
} // end of PrintDebug

void AliHLTTPCHWClusterTransformComponent::GetOCDBObjectDescription( TMap* const targetMap)
{
  // Get a list of OCDB object description needed for the particular component
  if (!targetMap) return;
  
  // OCDB entries for component arguments

  targetMap->Add(new TObjString("HLT/ConfigTPC/TPCHWClusterTransform"), new TObjString("component argument for the charge threshold"));
  
  // OCDB entries to be fetched by the TAXI (access via the AliTPCcalibDB class)
  targetMap->Add(new TObjString("TPC/Calib/Parameters"),    new TObjString("unknown content"));
  targetMap->Add(new TObjString("TPC/Calib/TimeDrift"),     new TObjString("drift velocity calibration"));
  targetMap->Add(new TObjString("TPC/Calib/TimeGain"),     new TObjString("time gain  calibration"));
  targetMap->Add(new TObjString("TPC/Calib/Temperature"),   new TObjString("temperature map"));
  targetMap->Add(new TObjString("TPC/Calib/PadGainFactor"), new TObjString("gain factor pad by pad"));
  targetMap->Add(new TObjString("TPC/Calib/ClusterParam"),  new TObjString("cluster parameters"));
  targetMap->Add(new TObjString("TPC/Calib/Correction"),  new TObjString("coreection"));
  targetMap->Add(new TObjString("TPC/Calib/RecoParam"),  new TObjString("reconstruction parameters"));
 
  // OCDB entries needed to be fetched by the Pendolino
  targetMap->Add(new TObjString("TPC/Calib/AltroConfig"), new TObjString("contains the altro config, e.g. info about the L0 trigger timing"));
  targetMap->Add(new TObjString("GRP/CTP/CTPtiming"),     new TObjString("content used in the cluster coordinate transformation in relation to the L0 trigger timing"));

  // OCDB entries necessary for replaying data on the HLT cluster
  targetMap->Add(new TObjString("GRP/GRP/Data"), new TObjString("contains magnetic field info"));  
 
  // OCDB entries needed to suppress fatals/errors/warnings during reconstruction
  targetMap->Add(new TObjString("TPC/Calib/Distortion"),  new TObjString("distortion map"));
  targetMap->Add(new TObjString("TPC/Calib/GainFactorDedx"), new TObjString("gain factor dedx"));
  targetMap->Add(new TObjString("TPC/Calib/PadTime0"),    new TObjString("time0 offset pad by pad"));
  targetMap->Add(new TObjString("TPC/Calib/PadNoise"),    new TObjString("pad noise values"));
  targetMap->Add(new TObjString("TPC/Calib/Pedestals"),   new TObjString("pedestal info"));
  targetMap->Add(new TObjString("TPC/Calib/Pulser"),      new TObjString("pulser info"));
  targetMap->Add(new TObjString("TPC/Calib/CE"),          new TObjString("CE laser calibration result"));
  targetMap->Add(new TObjString("TPC/Calib/Raw"),         new TObjString("unknown content"));
  targetMap->Add(new TObjString("TPC/Calib/QA"),          new TObjString("not important"));
  targetMap->Add(new TObjString("TPC/Calib/Mapping"),     new TObjString("unknown content"));
  targetMap->Add(new TObjString("TPC/Calib/Goofie"),      new TObjString("Goofie values, not used at the moment (05.03.2010)"));
  targetMap->Add(new TObjString("TPC/Calib/HighVoltage"), new TObjString("high voltage values, not used"));
  targetMap->Add(new TObjString("TPC/Calib/Ref"),         new TObjString("unknown content"));
}
Commit	Line	Data
a9d14303	1	// $Id$
6af4f584	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: Kalliopi Kanaki <Kalliopi.Kanaki@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 AliHLTTPCHWClusterTransformComponent.cxx
	20	@author Kalliopi Kanaki
	21	@date
	22	@brief
	23	*/
	24
6af4f584	25	#include "AliHLTTPCHWClusterTransformComponent.h"
	26	#include "AliHLTTPCDefinitions.h"
	27	#include "AliHLTTPCTransform.h"
	28	#include "AliHLTTPCSpacePointData.h"
	29	#include "AliHLTTPCClusterDataFormat.h"
f670cd93	30	#include "AliRawDataHeader.h"
e9530747	31	#include "AliHLTTPCRawCluster.h"
e9530747	32	#include "AliHLTTPCHWCFEmulator.h"
fd086f6c	33	#include "AliHLTTPCHWCFData.h"
fd086f6c	34	#include "AliHLTErrorGuard.h"
96122515	35	#include "AliTPCTransform.h"
6af4f584	36
491d6af5	37	#include "AliCDBManager.h"
491d6af5	38	#include "AliCDBEntry.h"
dccee396	39	#include "AliTPCcalibDB.h"
491d6af5	40
2b727eff	41	#include "TMath.h"
7361746a	42	#include "TObjString.h"
6af4f584	43	#include <cstdlib>
	44	#include <cerrno>
	45	#include <sys/time.h>
	46
d5cf9283	47	using namespace std;
d5cf9283	48
6af4f584	49	ClassImp(AliHLTTPCHWClusterTransformComponent) //ROOT macro for the implementation of ROOT specific class methods
6af4f584	50
84e36c27	51	const char* AliHLTTPCHWClusterTransformComponent::fgkOCDBEntryHWTransform="HLT/ConfigTPC/TPCHWClusterTransform";
84e36c27	52
96122515	53	AliHLTTPCClusterTransformation AliHLTTPCHWClusterTransformComponent::fgTransform;
	54	Bool_t AliHLTTPCHWClusterTransformComponent::fgTimeInitialisedFromEvent = 0;
	55
6af4f584	56	AliHLTTPCHWClusterTransformComponent::AliHLTTPCHWClusterTransformComponent()
a9d14303	57	:
84e36c27	58	fDataId(kFALSE),
e9530747	59	fPublishRawClusters(kFALSE),
fd086f6c	60	fpDecoder(NULL),
a5dc9013	61	fBenchmark("HWClusterTransform")
6af4f584	62	{
	63	// see header file for class documentation
	64	// or
	65	// refer to README to build package
	66	// or
a9d14303	67	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
a5dc9013	68
	69	fBenchmark.Reset();
	70	fBenchmark.SetTimer(0,"total");
6af4f584	71	}
6af4f584	72
fd086f6c	73	AliHLTTPCHWClusterTransformComponent::~AliHLTTPCHWClusterTransformComponent()
	74	{
	75	// destructor
	76	if (!fpDecoder) delete fpDecoder;
	77	fpDecoder=NULL;
6af4f584	78	}
	79
	80	const char* AliHLTTPCHWClusterTransformComponent::GetComponentID() {
	81	// see header file for class documentation
	82
	83	return "TPCHWClusterTransform";
	84	}
	85
	86	void AliHLTTPCHWClusterTransformComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
	87	// see header file for class documentation
	88
	89	list.clear();
	90	list.push_back( AliHLTTPCDefinitions::fgkHWClustersDataType );
	91	}
	92
	93	AliHLTComponentDataType AliHLTTPCHWClusterTransformComponent::GetOutputDataType() {
	94	// see header file for class documentation
	95
	96	return AliHLTTPCDefinitions::fgkClustersDataType;
	97	}
	98
	99	int AliHLTTPCHWClusterTransformComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
	100	// see header file for class documentation
	101
	102	tgtList.clear();
7b86c66e	103	tgtList.push_back(AliHLTTPCDefinitions::fgkClustersDataType\| kAliHLTDataOriginTPC);
7b86c66e	104	tgtList.push_back(AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo \| kAliHLTDataOriginTPC );
e9530747	105	tgtList.push_back(AliHLTTPCDefinitions::fgkRawClustersDataType \| kAliHLTDataOriginTPC );
6af4f584	106	return tgtList.size();
	107	}
	108
	109	void AliHLTTPCHWClusterTransformComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
	110	// see header file for class documentation
6af4f584	111	constBase = 0;
641530bb	112	inputMultiplier = 3.0;
6af4f584	113	}
	114
	115	AliHLTComponent* AliHLTTPCHWClusterTransformComponent::Spawn() {
	116	// see header file for class documentation
	117
	118	return new AliHLTTPCHWClusterTransformComponent();
	119	}
	120
96122515	121	int AliHLTTPCHWClusterTransformComponent::DoInit( int argc, const char** argv )
	122	{
	123	// see header file for class documentation
dccee396	124
aa0d6ff8	125	AliTPCcalibDB *calib=AliTPCcalibDB::Instance();
	126	if(!calib){
	127	HLTError("AliTPCcalibDB does not exist");
	128	return -ENOENT;
	129	}
	130	calib->SetRun(GetRunNo());
	131	calib->UpdateRunInformations(GetRunNo());
9eb867b1	132
96122515	133	if( !fgTransform.IsInitialised() ){
	134	int err = fgTransform.Init( GetBz(), GetTimeStamp() );
	135	if( err!=0 ){
	136	HLTError(Form("Cannot retrieve offline transform from AliTPCcalibDB, AliHLTTPCClusterTransformation returns %d",err));
	137	return -ENOENT;
	138	}
b4c689c4	139	}
491d6af5	140
491d6af5	141	int iResult=0;
84e36c27	142	iResult = ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
	143
	144	if (iResult>=0 && argc>0)
	145	iResult=ConfigureFromArgumentString(argc, argv);
	146
fd086f6c	147	if (iResult>=0) {
	148	fpDecoder=new AliHLTTPCHWCFData;
	149	if (!fpDecoder) iResult=-ENOMEM;
	150	}
	151
84e36c27	152	return iResult;
6af4f584	153	} // end DoInit()
	154
	155	int AliHLTTPCHWClusterTransformComponent::DoDeinit() {
bd1ecd64	156	// see header file for class documentation
fd086f6c	157	if (!fpDecoder) delete fpDecoder;
fd086f6c	158	fpDecoder=NULL;
96122515	159	fgTransform.DeInit();
6af4f584	160	return 0;
	161	}
	162
	163	int AliHLTTPCHWClusterTransformComponent::DoEvent(const AliHLTComponentEventData& evtData,
491d6af5	164	const AliHLTComponentBlockData* blocks,
	165	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
	166	AliHLTUInt32_t& size,
	167	vector<AliHLTComponentBlockData>& outputBlocks ){
6af4f584	168	// see header file for class documentation
9eb867b1	169
7b86c66e	170	UInt_t maxOutSize = size;
	171	size = 0;
	172	int iResult = 0;
fd086f6c	173	if(!IsDataEvent()) return 0;
	174
	175	if (!fpDecoder) return -ENODEV;
96122515	176	if( !fgTransform.IsInitialised() ){
	177	HLTError(" TPC Transformation is not initialised ");
	178	return -ENOENT;
	179	}
a5dc9013	180
	181	fBenchmark.StartNewEvent();
	182	fBenchmark.Start(0);
	183
96122515	184	// Initialise the transformation here once more for the case of off-line reprocessing
	185	if( !fgTimeInitialisedFromEvent ){
	186	Long_t currentTime = static_cast<AliHLTUInt32_t>(time(NULL));
e412e5ed	187	Long_t eventTimeStamp = GetTimeStamp();
96122515	188	if( TMath::Abs( fgTransform.GetCurrentTimeStamp() - eventTimeStamp )>60 &&
	189	TMath::Abs( currentTime - eventTimeStamp)>60605 ){
	190	int err = fgTransform.SetCurrentTimeStamp( eventTimeStamp );
	191	if( err!=0 ){
	192	HLTError(Form("Cannot set time stamp, AliHLTTPCClusterTransformation returns %d",err));
	193	return -ENOENT;
	194	}
	195	}
	196	fgTimeInitialisedFromEvent = 1;
	197	}
	198
	199	for( unsigned long ndx=0; ndx<evtData.fBlockCnt; ndx++ ){
7b86c66e	200
	201	const AliHLTComponentBlockData *iter = blocks+ndx;
	202
	203	fBenchmark.AddInput(iter->fSize);
	204
	205	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	206	evtData.fEventID, evtData.fEventID,
	207	DataType2Text( iter->fDataType).c_str(),
	208	DataType2Text(AliHLTTPCDefinitions::fgkHWClustersDataType).c_str());
	209
	210	if(iter->fDataType == (AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo \| kAliHLTDataOriginTPC) ){
	211	// simply forward MC labels
	212
	213	if( size+iter->fSize > maxOutSize ){
	214	HLTWarning( "Output buffer (%db) is too small, required %db", maxOutSize, size+iter->fSize);
	215	iResult = -ENOSPC;
	216	break;
	217	}
dccee396	218
7b86c66e	219	memcpy( outputPtr, iter->fPtr, iter->fSize );
61c1f30c	220
7b86c66e	221	AliHLTComponentBlockData bd;
	222	FillBlockData( bd );
	223	bd.fOffset = size;
	224	bd.fSize = iter->fSize;
	225	bd.fSpecification = iter->fSpecification;
	226	bd.fDataType = iter->fDataType;
	227	outputBlocks.push_back( bd );
	228	fBenchmark.AddOutput(bd.fSize);
	229	size += bd.fSize;
	230	outputPtr += bd.fSize;
	231	continue;
	232	}
a5dc9013	233
7b86c66e	234	if(iter->fDataType != (AliHLTTPCDefinitions::fgkHWClustersDataType \| kAliHLTDataOriginTPC)) continue;
	235
	236	UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
	237	UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
	238	//UInt_t maxSlice = AliHLTTPCDefinitions::GetMaxSliceNr(*iter);
	239	//UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(*iter);
fd086f6c	240	float padpitch=1.0;
	241	if ((int)minPartition<AliHLTTPCTransform::GetNRowLow())
	242	padpitch=AliHLTTPCTransform::GetPadPitchWidthLow();
	243	else
	244	padpitch=AliHLTTPCTransform::GetPadPitchWidthUp();
	245	float zwidth=AliHLTTPCTransform::GetZWidth();
a5dc9013	246
7b86c66e	247	fBenchmark.SetName(Form("HWClusterTransform slice %d patch %d",minSlice,minPartition));
a5dc9013	248
7b86c66e	249	HLTDebug("minSlice: %d, minPartition: %d", minSlice, minPartition);
6af4f584	250
7b86c66e	251	AliHLTTPCClusterData* outPtr = (AliHLTTPCClusterData*)outputPtr;
fd086f6c	252	outPtr->fSpacePointCnt=0;
61c1f30c	253
7b86c66e	254	long maxPoints = ((long)maxOutSize-size-sizeof(AliHLTTPCClusterData))/sizeof(AliHLTTPCSpacePointData);
fd086f6c	255
7b86c66e	256	AliHLTUInt32_t *buffer;
7b86c66e	257	buffer = (AliHLTUInt32_t*)iter->fPtr;
6af4f584	258
6af4f584	259	// skip the first 8 32-bit CDH words
6af4f584	260	buffer += 8;
f670cd93	261	UInt_t bufferSize32 = ((Int_t)iter->fSize - sizeof(AliRawDataHeader) )/sizeof(AliHLTUInt32_t);
6af4f584	262
fd086f6c	263	if (fpDecoder->Init(reinterpret_cast<AliHLTUInt8_t>(buffer), bufferSize32sizeof(AliHLTUInt32_t))>=0 && fpDecoder->CheckVersion()>=0) {
536e7d6d	264	for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
fd086f6c	265	if(outPtr->fSpacePointCnt>=maxPoints){
7b86c66e	266	HLTWarning("No more space to add clusters, exiting!");
	267	iResult = -ENOSPC;
	268	break;
	269	}
fd086f6c	270
fd086f6c	271	AliHLTTPCSpacePointData& c=outPtr->fSpacePoints[outPtr->fSpacePointCnt];
536e7d6d	272	int padrow=cl.GetPadRow();
fd086f6c	273	if (padrow<0) {
	274	// something wrong here, padrow is stored in the cluster header
	275	// word which has bit pattern 0x3 in bits bit 30 and 31 which was
	276	// not recognized
536e7d6d	277	ALIHLTERRORGUARD(1, "can not read cluster header word");
fd086f6c	278	break;
fd086f6c	279	}
45d57965	280	padrow+=AliHLTTPCTransform::GetFirstRow(minPartition);
536e7d6d	281	AliHLTUInt32_t charge=cl.GetCharge();
fd086f6c	282
536e7d6d	283	float pad=cl.GetPad();
	284	float time=cl.GetTime();
	285	float sigmaY2=cl.GetSigmaY2();
	286	float sigmaZ2=cl.GetSigmaZ2();
fd086f6c	287	sigmaY2=padpitchpadpitch;
fd086f6c	288	sigmaZ2=zwidthzwidth;
	289	c.SetPadRow(padrow);
	290	c.SetCharge(charge);
	291	c.SetSigmaY2(sigmaY2);
	292	c.SetSigmaZ2(sigmaZ2);
536e7d6d	293	c.SetQMax(cl.GetQMax());
fd086f6c	294
7b86c66e	295	Float_t xyz[3];
96122515	296	int err = fgTransform.Transform( minSlice, padrow, pad, time, xyz );
	297	if( err!=0 ){
	298	HLTWarning(Form("Cannot transform the cluster, AliHLTTPCClusterTransformation returns error %d, %s",err, fgTransform.GetLastError()));
	299	continue;
	300	}
fd086f6c	301	c.SetX(xyz[0]);
	302	c.SetY(xyz[1]);
	303	c.SetZ(xyz[2]);
	304
7b86c66e	305	// set the cluster ID so that the cluster dump printout is the same for FCF and SCF
fd086f6c	306	c.SetID( minSlice, minPartition, outPtr->fSpacePointCnt );
7b86c66e	307
fd086f6c	308	HLTDebug("Cluster number %d: %f, Y: %f, Z: %f, charge: %d \n", outPtr->fSpacePointCnt, cluster.fX, cluster.fY, cluster.fZ, (UInt_t)cluster.fCharge);
7b86c66e	309
fd086f6c	310	outPtr->fSpacePointCnt++;
	311	} // end of loop over clusters
	312	}
	313	HLTDebug("Number of found clusters: %d", outPtr->fSpacePointCnt);
6af4f584	314
7b86c66e	315	UInt_t mysize = sizeof(AliHLTTPCClusterData) + sizeof(AliHLTTPCSpacePointData)*outPtr->fSpacePointCnt;
6af4f584	316
	317	AliHLTComponentBlockData bd;
	318	FillBlockData( bd );
7b86c66e	319	bd.fOffset = size;
6af4f584	320	bd.fSize = mysize;
7b86c66e	321	bd.fSpecification = iter->fSpecification;
491d6af5	322	if(fDataId==kFALSE) bd.fDataType = AliHLTTPCDefinitions::fgkClustersDataType;
	323	else bd.fDataType = AliHLTTPCDefinitions::fgkAlterClustersDataType;
	324
	325	//HLTDebug("datatype: %s", DataType2Text(bd.fDataType).c_str());
	326
6af4f584	327	outputBlocks.push_back( bd );
6af4f584	328
7b86c66e	329	fBenchmark.AddOutput(bd.fSize);
	330	size += mysize;
	331	outputPtr += mysize;
6af4f584	332
e9530747	333	if (fPublishRawClusters) {
	334
	335	long maxRawClusters = ((long)maxOutSize-size-sizeof(AliHLTTPCRawClusterData))/sizeof(AliHLTTPCRawCluster);
	336
	337	if( maxRawClusters<=0 ) {
	338	HLTWarning("No more space to add raw clusters, exiting!");
	339	iResult = -ENOSPC;
	340	} else {
	341
	342	// copy raw cluster data from input
	343
	344	AliHLTTPCRawClusterData* outputRaw= (AliHLTTPCRawClusterData*)(outputPtr);
	345
	346	outputRaw->fVersion = 0;
	347	outputRaw->fCount = 0;
	348
536e7d6d	349	// check if there are clusters available, if not the format might
	350	// not even been decoded at that moment
	351	if (fpDecoder->GetNumberOfClusters()>0) {
	352	for (AliHLTTPCHWCFData::iterator cl=fpDecoder->begin(); cl!=fpDecoder->end(); ++cl) {
fd086f6c	353	if(outputRaw->fCount>=maxRawClusters){
	354	HLTWarning("No more space to add clusters, exiting!");
	355	iResult = -ENOSPC;
e9530747	356	break;
e9530747	357	}
fd086f6c	358	AliHLTTPCRawCluster &c = outputRaw->fClusters[outputRaw->fCount];
536e7d6d	359	int padrow=cl.GetPadRow();
fd086f6c	360	if (padrow<0) {
	361	// something wrong here, padrow is stored in the cluster header
	362	// word which has bit pattern 0x3 in bits bit 30 and 31 which was
	363	// not recognized
	364	break;
	365	}
45d57965	366	padrow+=AliHLTTPCTransform::GetFirstRow(minPartition);
536e7d6d	367	AliHLTUInt32_t charge= cl.GetCharge();
fd086f6c	368
536e7d6d	369	float pad =cl.GetPad();
	370	float time =cl.GetTime();
	371	float sigmaP2=cl.GetSigmaY2();
	372	float sigmaT2=cl.GetSigmaZ2();
fd086f6c	373	c.SetPadRow(padrow);
	374	c.SetCharge(charge);
	375	c.SetPad(pad);
	376	c.SetTime(time);
	377	c.SetSigmaY2(sigmaP2);
	378	c.SetSigmaZ2(sigmaT2);
536e7d6d	379	c.SetQMax(cl.GetQMax());
fd086f6c	380
	381	// store cluster and continue
	382	outputRaw->fCount++;
	383	}
536e7d6d	384	}
fd086f6c	385
e9530747	386	// fill into HLT output data
	387	AliHLTComponentBlockData bdRawClusters;
	388	FillBlockData( bdRawClusters );
	389	bdRawClusters.fOffset = size;
	390	bdRawClusters.fSize = sizeof(AliHLTTPCRawClusterData)+outputRaw->fCount*sizeof(AliHLTTPCRawCluster);
	391	bdRawClusters.fSpecification = iter->fSpecification;
	392	bdRawClusters.fDataType = AliHLTTPCDefinitions::fgkRawClustersDataType \| kAliHLTDataOriginTPC;
	393	outputBlocks.push_back( bdRawClusters );
	394	fBenchmark.AddOutput(bdRawClusters.fSize);
	395	size += bdRawClusters.fSize;
	396	outputPtr += bdRawClusters.fSize;
	397	}
	398	}
	399	} // end of loop over data blocks
a5dc9013	400
	401	fBenchmark.Stop(0);
	402	HLTInfo(fBenchmark.GetStatistics());
e9530747	403
7b86c66e	404	return iResult;
6af4f584	405	} // end DoEvent()
84e36c27	406
	407	int AliHLTTPCHWClusterTransformComponent::ScanConfigurationArgument(int argc, const char** argv){
	408
	409	// see header file for class documentation
	410
	411	if (argc<=0) return 0;
	412	int i=0;
	413	TString argument=argv[i];
	414
	415	if (argument.CompareTo("-solenoidBz")==0){
	416	if (++i>=argc) return -EPROTO;
	417	argument=argv[i];
	418	AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
	419	if(!calib){
66a3e955	420	HLTError("CalibDB instance cannot be created.");
66a3e955	421	return 0;
84e36c27	422	}
	423	Float_t magneticField = argument.Atof();
	424	calib->SetExBField(magneticField);
	425	HLTInfo("SolenoidBz is set to %f in the calibDB",magneticField);
	426	return 2;
	427	}
	428
	429	if (argument.CompareTo("-change-dataId")==0){
	430	HLTDebug("Change data ID received.");
	431	fDataId = kTRUE;
	432	return 1;
	433	}
58df4cfa	434
	435	if (argument.CompareTo("-charge-threshold")==0) {
	436	if (++i>=argc) return -EPROTO;
5ab9dcd9	437	argument=argv[i];
5ab9dcd9	438	HLTInfo("The argument -charge-threshold is deprecated.");
58df4cfa	439	return 2;
58df4cfa	440	}
84e36c27	441
e9530747	442	if (argument.CompareTo("-publish-raw")==0) {
	443	fPublishRawClusters=kTRUE;
	444	return 1;
	445	}
	446
84e36c27	447	// unknown argument
	448	return -EINVAL;
	449	}
	450
84e36c27	451	int AliHLTTPCHWClusterTransformComponent::Reconfigure(const char* /cdbEntry/, const char* /chainId/) {
491d6af5	452	// see header file for class documentation
84e36c27	453	return ConfigureFromCDBTObjString(fgkOCDBEntryHWTransform);
491d6af5	454	}
6af4f584	455
	456	void AliHLTTPCHWClusterTransformComponent::PrintDebug(AliHLTUInt32_t *buffer, Int_t size){
	457	// see header file for class documentation
	458
	459	HLTInfo("The size is: %d", size);
	460	for(Int_t n32bit=0; n32bit<size; n32bit++){
	461
	462	AliHLTUInt8_t wordPtr = reinterpret_cast<AliHLTUInt8_t>(&buffer[n32bit]);
	463	// cout << "word ptr initialized"<<endl;
	464	for(Int_t w=3;w>=0;w--){
	465	// cout <<"accessing word"<<endl;
	466	AliHLTUInt8_t word = wordPtr[w];
	467	// cout<< "word was accessed"<<endl;
	468	for(int n=7; n>=0; n--){
	469	//print the byte values
	470	if((((word>>n)<<7)&0x80) != 0){
	471	printf("1");
	472	}
	473	else{
	474	printf("0");
	475	}
	476	}
	477	printf(" ");
	478	}
	479	printf("\n");
	480	}
	481	} // end of PrintDebug
1c29fee7	482
fe1a26cb	483	void AliHLTTPCHWClusterTransformComponent::GetOCDBObjectDescription( TMap* const targetMap)
	484	{
	485	// Get a list of OCDB object description needed for the particular component
1c29fee7	486	if (!targetMap) return;
fe1a26cb	487
	488	// OCDB entries for component arguments
	489
1c29fee7	490	targetMap->Add(new TObjString("HLT/ConfigTPC/TPCHWClusterTransform"), new TObjString("component argument for the charge threshold"));
fe1a26cb	491
	492	// OCDB entries to be fetched by the TAXI (access via the AliTPCcalibDB class)
	493	targetMap->Add(new TObjString("TPC/Calib/Parameters"), new TObjString("unknown content"));
	494	targetMap->Add(new TObjString("TPC/Calib/TimeDrift"), new TObjString("drift velocity calibration"));
f240af21	495	targetMap->Add(new TObjString("TPC/Calib/TimeGain"), new TObjString("time gain calibration"));
fe1a26cb	496	targetMap->Add(new TObjString("TPC/Calib/Temperature"), new TObjString("temperature map"));
	497	targetMap->Add(new TObjString("TPC/Calib/PadGainFactor"), new TObjString("gain factor pad by pad"));
	498	targetMap->Add(new TObjString("TPC/Calib/ClusterParam"), new TObjString("cluster parameters"));
f240af21	499	targetMap->Add(new TObjString("TPC/Calib/Correction"), new TObjString("coreection"));
	500	targetMap->Add(new TObjString("TPC/Calib/RecoParam"), new TObjString("reconstruction parameters"));
	501
fe1a26cb	502	// OCDB entries needed to be fetched by the Pendolino
	503	targetMap->Add(new TObjString("TPC/Calib/AltroConfig"), new TObjString("contains the altro config, e.g. info about the L0 trigger timing"));
	504	targetMap->Add(new TObjString("GRP/CTP/CTPtiming"), new TObjString("content used in the cluster coordinate transformation in relation to the L0 trigger timing"));
	505
	506	// OCDB entries necessary for replaying data on the HLT cluster
	507	targetMap->Add(new TObjString("GRP/GRP/Data"), new TObjString("contains magnetic field info"));
	508
	509	// OCDB entries needed to suppress fatals/errors/warnings during reconstruction
f240af21	510	targetMap->Add(new TObjString("TPC/Calib/Distortion"), new TObjString("distortion map"));
f240af21	511	targetMap->Add(new TObjString("TPC/Calib/GainFactorDedx"), new TObjString("gain factor dedx"));
fe1a26cb	512	targetMap->Add(new TObjString("TPC/Calib/PadTime0"), new TObjString("time0 offset pad by pad"));
	513	targetMap->Add(new TObjString("TPC/Calib/PadNoise"), new TObjString("pad noise values"));
	514	targetMap->Add(new TObjString("TPC/Calib/Pedestals"), new TObjString("pedestal info"));
	515	targetMap->Add(new TObjString("TPC/Calib/Pulser"), new TObjString("pulser info"));
	516	targetMap->Add(new TObjString("TPC/Calib/CE"), new TObjString("CE laser calibration result"));
	517	targetMap->Add(new TObjString("TPC/Calib/Raw"), new TObjString("unknown content"));
	518	targetMap->Add(new TObjString("TPC/Calib/QA"), new TObjString("not important"));
	519	targetMap->Add(new TObjString("TPC/Calib/Mapping"), new TObjString("unknown content"));
	520	targetMap->Add(new TObjString("TPC/Calib/Goofie"), new TObjString("Goofie values, not used at the moment (05.03.2010)"));
	521	targetMap->Add(new TObjString("TPC/Calib/HighVoltage"), new TObjString("high voltage values, not used"));
	522	targetMap->Add(new TObjString("TPC/Calib/Ref"), new TObjString("unknown content"));
1c29fee7	523	}