[u/mrichter/AliRoot.git] / HLT / TPCLib / offline / AliHLTTPCOfflineTrackerComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                                                                        *
//* 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   AliHLTTPCOfflineTrackerComponent.cxx
    @author Jacek Otwinowski & Matthias Richter
    @date   
    @brief  Wrapper component to the TPC offline tracker
*/

#include "AliHLTTPCOfflineTrackerComponent.h"
#include "TString.h"
#include "TClonesArray.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "AliVParticle.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliGeomManager.h"
#include "AliMagFMaps.h"
#include "AliTPCReconstructor.h"
#include "AliTPCParam.h"
#include "AliTPCRecoParam.h"
#include "AliTPCParamSR.h"
#include "AliTPCtrackerMI.h"
#include "AliTPCClustersRow.h"
#include "AliTPCseed.h"
#include "AliESDEvent.h"
#include "AliESDfriend.h"
#include "AliHLTTPCDefinitions.h"

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

AliHLTTPCOfflineTrackerComponent::AliHLTTPCOfflineTrackerComponent() : AliHLTProcessor(),
fGeometryFileName(""),
fTPCGeomParam(0),
fTracker(0),
fESD(0),
fESDfriend(0)
{
  // Default constructor
  fGeometryFileName = getenv("ALICE_ROOT");
  fGeometryFileName += "/HLT/TPCLib/offline/geometry.root";
}

AliHLTTPCOfflineTrackerComponent::~AliHLTTPCOfflineTrackerComponent()
{
  // see header file for class documentation
}

const char* AliHLTTPCOfflineTrackerComponent::GetComponentID()
{
  // see header file for class documentation
  return "TPCOfflineTracker";
}

void AliHLTTPCOfflineTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
{
  // get input data type
  list.push_back(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/);
}

AliHLTComponentDataType AliHLTTPCOfflineTrackerComponent::GetOutputDataType()
{
  // create output data type
  return kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineTrackSegmentsDataType*/;
}

void AliHLTTPCOfflineTrackerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
{
  // get output data size
  constBase = 2000000;
  inputMultiplier = 1;
}

AliHLTComponent* AliHLTTPCOfflineTrackerComponent::Spawn()
{
  // create instance of the component
  return new AliHLTTPCOfflineTrackerComponent;
}

int AliHLTTPCOfflineTrackerComponent::DoInit( int argc, const char** argv )
{
  // init configuration 
  //
  int iResult=0;
#ifdef HAVE_NOT_TPCOFFLINE_REC
  HLTFatal("AliRoot version > v4-13-Release required");
  return -ENOSYS;
#endif

  TString argument="";
  TString configuration=""; 
  int bMissingParam=0;

  // loop over input parameters
  for (int i=0; i<argc && iResult>=0; i++) {
    argument=argv[i];
    if (argument.IsNull()) continue;

    if (argument.CompareTo("-geometry")==0) {
      if ((bMissingParam=(++i>=argc))) break;

      HLTInfo("got \'-geometry\' argument: %s", argv[i]);
      fGeometryFileName = argv[i];
      HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());

      // the remaining arguments are treated as configuration
    } else {
      if (!configuration.IsNull()) configuration+=" ";
      configuration+=argument;
    }
  } // end loop

  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }

  if (iResult>=0 && !configuration.IsNull()) {
    iResult=Configure(configuration.Data());
  } else {
    iResult=Reconfigure(NULL, NULL);
  }

  //
  // initialisation
  //
   
  // Load geometry
  HLTInfo("Geometry file %s",fGeometryFileName.c_str());
  AliGeomManager::LoadGeometry(fGeometryFileName.c_str());
  if((AliGeomManager::GetGeometry()) == 0) {
    HLTError("Cannot load geometry from file %s",fGeometryFileName.c_str());
    iResult=-EINVAL;
  }

  // TPC reconstruction parameters
  //AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetLowFluxParam();
  AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetHLTParam();
  if(tpcRecoParam) {
    AliTPCReconstructor::SetRecoParam(tpcRecoParam);
  }
 
  // TPC geometry parameters
  fTPCGeomParam = new AliTPCParamSR;
  if (fTPCGeomParam) {
    fTPCGeomParam->ReadGeoMatrices();
  }

  // Init tracker
  fTracker = new AliTPCtrackerMI(fTPCGeomParam);

  // AliESDEvent event needed by AliTPCtrackerMI
  // output of the component
  fESD = new AliESDEvent();
  if (fESD) {
    fESD->CreateStdContent();

    // add ESD friend
    fESDfriend = new AliESDfriend();
    if(fESDfriend) fESD->AddObject(fESDfriend);
  }

  if (!fTracker || !fESD || !fTPCGeomParam) {
    HLTError("failed creating internal objects");
    iResult=-ENOMEM;
  }

  if (iResult>=0) {
    // read the default CDB entries
    iResult=Reconfigure(NULL, NULL);
  }

  return iResult;
}

int AliHLTTPCOfflineTrackerComponent::DoDeinit()
{
  // deinit configuration

  if(fTPCGeomParam) delete fTPCGeomParam; fTPCGeomParam = 0; 
  if(fTracker) delete fTracker; fTracker = 0; 
  if(fESD) delete fESD; fESD = 0;
  //Note: fESD is owner of fESDfriends

  return 0;
}

int AliHLTTPCOfflineTrackerComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
{
  // tracker function
  HLTInfo("DoEvent processing data");

  int iResult=0;
  TClonesArray *clusterArray=0;
  TObjArray *seedArray=0;
  int slice, patch;

  const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC); 
  if(!pBlock) {
     HLTError("Cannot get first data block 0x%08x ",pBlock);
     iResult=-ENOMEM; return iResult;
  }
  int minSlice=AliHLTTPCDefinitions::GetMinSliceNr(pBlock->fSpecification);
  int maxSlice=AliHLTTPCDefinitions::GetMaxSliceNr(pBlock->fSpecification);
  int minPatch=AliHLTTPCDefinitions::GetMinPatchNr(pBlock->fSpecification);
  int maxPatch=AliHLTTPCDefinitions::GetMaxPatchNr(pBlock->fSpecification);  

  if (fTracker && fESD) {
      // loop over input data blocks: TClonesArrays of clusters
      for (TObject *pObj = (TObject *)GetFirstInputObject(kAliHLTDataTypeTObjArray|kAliHLTDataOriginTPC/*AliHLTTPCDefinitions::fgkOfflineClustersDataType*/,"TClonesArray",0);
	 pObj !=0 && iResult>=0;
	 pObj = (TObject *)GetNextInputObject(0)) {
      clusterArray = dynamic_cast<TClonesArray*>(pObj);
      if (!clusterArray) continue;

      HLTInfo("load %d clusters from block %s 0x%08x", clusterArray->GetEntries(), DataType2Text(GetDataType(pObj)).c_str(), GetSpecification(pObj));
      slice=AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(pObj));
      patch=AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(pObj));

      if(slice < minSlice) minSlice=slice;
      if(slice > maxSlice) maxSlice=slice;
      if(patch < minPatch) minPatch=patch;
      if(patch > maxPatch) maxPatch=patch;
#ifndef HAVE_NOT_TPCOFFLINE_REC
      fTracker->LoadClusters(clusterArray);
#endif //HAVE_NOT_TPCOFFLINE_REC
 
    clusterArray->Delete();
    }// end loop over input objects

#ifndef HAVE_NOT_TPCOFFLINE_REC
    // Load outer sectors
      fTracker->LoadOuterSectors();
    // Load inner sectors
      fTracker->LoadInnerSectors();
#endif

    // set magnetic field for the ESD, assumes correct initialization of
    // the field map
    fESD->SetMagneticField(AliTracker::GetBz());
  
    // run tracker
    fTracker->Clusters2Tracks(fESD);

    // add TPC seed to the AliESDtrack
    seedArray = fTracker->GetSeeds();
    if(seedArray) {
       Int_t nseed = seedArray->GetEntriesFast();
       HLTInfo("Number TPC seeds %d",nseed);

       for(Int_t i=0; i<nseed; ++i) {
          AliTPCseed *seed = (AliTPCseed*)seedArray->UncheckedAt(i);
          if(!seed) continue; 

          //HLTInfo("TPC seed:  sec %d, row %d",seed->GetSector(), seed->GetRow());

          AliESDtrack *esdtrack=fESD->GetTrack(i);
          if(esdtrack) esdtrack->AddCalibObject((TObject*)seed);
	  else 
	     HLTInfo("Cannot add TPC seed to AliESDtrack %d", i);
       }
    seedArray->Clear();
    }

    // reset ESDs friends (no Reset function!)
    fESDfriend->~AliESDfriend();
    new (fESDfriend) AliESDfriend(); // Reset ...

    // add ESDfriend to AliESDEvent
    fESD->GetESDfriend(fESDfriend);

    // unload clusters
    fTracker->UnloadClusters();

    Int_t nTracks = fESD->GetNumberOfTracks();
    HLTInfo("Number of tracks %d", nTracks);

    // calculate specification from the specification of input data blocks
    AliHLTUInt32_t iSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
    HLTInfo("minSlice %d, maxSlice %d, minPatch %d, maxPatch %d", minSlice, maxSlice, minPatch, maxPatch);

    // send data
    PushBack(fESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, iSpecification);

    // reset ESDs and ESDs friends
    fESD->Reset();

  } else {
    HLTError("component not initialized");
    iResult=-ENOMEM;
  }

  return iResult;
}

int AliHLTTPCOfflineTrackerComponent::Configure(const char* arguments)
{
  // see header file for class documentation
  int iResult=0;
  if (!arguments) return iResult;

  TString allArgs=arguments;
  TString argument;
  int bMissingParam=0;

  TObjArray* pTokens=allArgs.Tokenize(" ");
  if (pTokens) {
    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
      argument=((TObjString*)pTokens->At(i))->GetString();
      if (argument.IsNull()) continue;

      if (argument.CompareTo("-solenoidBz")==0) {
	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	// TODO: check if there is common functionality in the AliMagF* classes
	float SolenoidBz=((TObjString*)pTokens->At(i))->GetString().Atof();
	if (SolenoidBz<kAlmost0Field) SolenoidBz=kAlmost0Field;
	float factor=1.;
	int map=AliMagFMaps::k2kG;
	if (SolenoidBz<3.) {
	  map=AliMagFMaps::k2kG;
	  factor=SolenoidBz/2;
	} else if (SolenoidBz>=3. && SolenoidBz<4.5) {
	  map=AliMagFMaps::k4kG;
	  factor=SolenoidBz/4;
	} else {
	  map=AliMagFMaps::k5kG;
	  factor=SolenoidBz/5;
	}
	// the magnetic field map is not supposed to change
	// field initialization should be done once in the beginning
	// TODO: does the factor need adjustment?
	const AliMagF* currentMap=AliTracker::GetFieldMap();
	if (!currentMap) {
	  AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., map);
	  AliTracker::SetFieldMap(field,kFALSE);
	  HLTInfo("Solenoid Field set to: %f map %d", SolenoidBz, map);
	} else if (currentMap->Map()!=map) {
	  HLTWarning("omitting request to override field map %s with %s", currentMap->Map(), map);
	}
	continue;
      } else {
	HLTError("unknown argument %s", argument.Data());
	iResult=-EINVAL;
	break;
      }
    }
    delete pTokens;
  }
  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTPCOfflineTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
  // see header file for class documentation
  int iResult=0;
  const char* path=kAliHLTCDBSolenoidBz;
  const char* defaultNotify="";
  if (cdbEntry) {
    path=cdbEntry;
    defaultNotify=" (default)";
  }
  if (path) {
    if (chainId) {} // just to get rid of warning, can not comment argument due to debug message
    HLTDebug("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
    if (pEntry) {
      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
      if (pString) {
	HLTDebug("received configuration object string: \'%s\'", pString->GetString().Data());
	iResult=Configure(pString->GetString().Data());
      } else {
	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
      }
    } else {
      HLTError("can not fetch object \"%s\" from CDB", path);
    }
  }
  
  return iResult;
}
Commit	Line	Data
1ac82ce6	1	// $Id$
	2
	3	//**************************************************************************
	4	//* This file is property of and copyright by the ALICE HLT Project *
	5	//* ALICE Experiment at CERN, All rights reserved. *
	6	//* *
	7	//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	8	//* *
	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 AliHLTTPCOfflineTrackerComponent.cxx
1726bb2d	19	@author Jacek Otwinowski & Matthias Richter
1ac82ce6	20	@date
	21	@brief Wrapper component to the TPC offline tracker
	22	*/
	23
	24	#include "AliHLTTPCOfflineTrackerComponent.h"
	25	#include "TString.h"
89c2e505	26	#include "TClonesArray.h"
1ac82ce6	27	#include "TObjArray.h"
1ac82ce6	28	#include "TObjString.h"
e642ae99	29	#include "AliVParticle.h"
	30	#include "AliCDBManager.h"
	31	#include "AliCDBEntry.h"
	32	#include "AliGeomManager.h"
	33	#include "AliMagFMaps.h"
89c2e505	34	#include "AliTPCReconstructor.h"
aa40a4a1	35	#include "AliTPCParam.h"
89c2e505	36	#include "AliTPCRecoParam.h"
aa40a4a1	37	#include "AliTPCParamSR.h"
	38	#include "AliTPCtrackerMI.h"
	39	#include "AliTPCClustersRow.h"
89c2e505	40	#include "AliTPCseed.h"
aa40a4a1	41	#include "AliESDEvent.h"
e642ae99	42	#include "AliESDfriend.h"
aa40a4a1	43	#include "AliHLTTPCDefinitions.h"
1ac82ce6	44
	45	/** ROOT macro for the implementation of ROOT specific class methods */
	46	ClassImp(AliHLTTPCOfflineTrackerComponent)
	47
aa40a4a1	48	AliHLTTPCOfflineTrackerComponent::AliHLTTPCOfflineTrackerComponent() : AliHLTProcessor(),
e642ae99	49	fGeometryFileName(""),
aa40a4a1	50	fTPCGeomParam(0),
aa40a4a1	51	fTracker(0),
e642ae99	52	fESD(0),
e642ae99	53	fESDfriend(0)
1ac82ce6	54	{
e642ae99	55	// Default constructor
	56	fGeometryFileName = getenv("ALICE_ROOT");
	57	fGeometryFileName += "/HLT/TPCLib/offline/geometry.root";
1ac82ce6	58	}
	59
	60	AliHLTTPCOfflineTrackerComponent::~AliHLTTPCOfflineTrackerComponent()
	61	{
	62	// see header file for class documentation
	63	}
	64
	65	const char* AliHLTTPCOfflineTrackerComponent::GetComponentID()
	66	{
	67	// see header file for class documentation
	68	return "TPCOfflineTracker";
	69	}
	70
	71	void AliHLTTPCOfflineTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	72	{
aa40a4a1	73	// get input data type
aa40a4a1	74	list.push_back(kAliHLTDataTypeTObjArray\|kAliHLTDataOriginTPC/AliHLTTPCDefinitions::fgkOfflineClustersDataType/);
1ac82ce6	75	}
	76
	77	AliHLTComponentDataType AliHLTTPCOfflineTrackerComponent::GetOutputDataType()
	78	{
aa40a4a1	79	// create output data type
aa40a4a1	80	return kAliHLTDataTypeESDObject\|kAliHLTDataOriginTPC/AliHLTTPCDefinitions::fgkOfflineTrackSegmentsDataType/;
1ac82ce6	81	}
	82
	83	void AliHLTTPCOfflineTrackerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
	84	{
aa40a4a1	85	// get output data size
aa40a4a1	86	constBase = 2000000;
e642ae99	87	inputMultiplier = 1;
1ac82ce6	88	}
	89
	90	AliHLTComponent* AliHLTTPCOfflineTrackerComponent::Spawn()
	91	{
aa40a4a1	92	// create instance of the component
1ac82ce6	93	return new AliHLTTPCOfflineTrackerComponent;
	94	}
	95
	96	int AliHLTTPCOfflineTrackerComponent::DoInit( int argc, const char** argv )
	97	{
aa40a4a1	98	// init configuration
aa40a4a1	99	//
1ac82ce6	100	int iResult=0;
c03e064d	101	#ifdef HAVE_NOT_TPCOFFLINE_REC
	102	HLTFatal("AliRoot version > v4-13-Release required");
	103	return -ENOSYS;
aa40a4a1	104	#endif
1ac82ce6	105
	106	TString argument="";
	107	TString configuration="";
	108	int bMissingParam=0;
e642ae99	109
e642ae99	110	// loop over input parameters
1ac82ce6	111	for (int i=0; i<argc && iResult>=0; i++) {
	112	argument=argv[i];
	113	if (argument.IsNull()) continue;
	114
e642ae99	115	if (argument.CompareTo("-geometry")==0) {
	116	if ((bMissingParam=(++i>=argc))) break;
	117
	118	HLTInfo("got \'-geometry\' argument: %s", argv[i]);
	119	fGeometryFileName = argv[i];
	120	HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());
	121
	122	// the remaining arguments are treated as configuration
	123	} else {
	124	if (!configuration.IsNull()) configuration+=" ";
	125	configuration+=argument;
	126	}
	127	} // end loop
	128
1ac82ce6	129	if (bMissingParam) {
	130	HLTError("missing parameter for argument %s", argument.Data());
	131	iResult=-EINVAL;
	132	}
	133
	134	if (iResult>=0 && !configuration.IsNull()) {
	135	iResult=Configure(configuration.Data());
	136	} else {
	137	iResult=Reconfigure(NULL, NULL);
	138	}
	139
e642ae99	140	//
	141	// initialisation
	142	//
	143
	144	// Load geometry
	145	HLTInfo("Geometry file %s",fGeometryFileName.c_str());
	146	AliGeomManager::LoadGeometry(fGeometryFileName.c_str());
	147	if((AliGeomManager::GetGeometry()) == 0) {
	148	HLTError("Cannot load geometry from file %s",fGeometryFileName.c_str());
	149	iResult=-EINVAL;
	150	}
89c2e505	151
	152	// TPC reconstruction parameters
	153	//AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetLowFluxParam();
	154	AliTPCRecoParam * tpcRecoParam = AliTPCRecoParam::GetHLTParam();
	155	if(tpcRecoParam) {
	156	AliTPCReconstructor::SetRecoParam(tpcRecoParam);
	157	}
e642ae99	158
aa40a4a1	159	// TPC geometry parameters
	160	fTPCGeomParam = new AliTPCParamSR;
	161	if (fTPCGeomParam) {
	162	fTPCGeomParam->ReadGeoMatrices();
	163	}
	164
e642ae99	165	// Init tracker
aa40a4a1	166	fTracker = new AliTPCtrackerMI(fTPCGeomParam);
	167
	168	// AliESDEvent event needed by AliTPCtrackerMI
	169	// output of the component
	170	fESD = new AliESDEvent();
	171	if (fESD) {
	172	fESD->CreateStdContent();
aa40a4a1	173
e642ae99	174	// add ESD friend
	175	fESDfriend = new AliESDfriend();
	176	if(fESDfriend) fESD->AddObject(fESDfriend);
488581c1	177	}
488581c1	178
aa40a4a1	179	if (!fTracker \|\| !fESD \|\| !fTPCGeomParam) {
	180	HLTError("failed creating internal objects");
	181	iResult=-ENOMEM;
	182	}
	183
e642ae99	184	if (iResult>=0) {
	185	// read the default CDB entries
	186	iResult=Reconfigure(NULL, NULL);
	187	}
	188
1ac82ce6	189	return iResult;
	190	}
	191
	192	int AliHLTTPCOfflineTrackerComponent::DoDeinit()
	193	{
aa40a4a1	194	// deinit configuration
	195
	196	if(fTPCGeomParam) delete fTPCGeomParam; fTPCGeomParam = 0;
	197	if(fTracker) delete fTracker; fTracker = 0;
	198	if(fESD) delete fESD; fESD = 0;
e642ae99	199	//Note: fESD is owner of fESDfriends
aa40a4a1	200
1ac82ce6	201	return 0;
	202	}
	203
	204	int AliHLTTPCOfflineTrackerComponent::DoEvent( const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/)
	205	{
aa40a4a1	206	// tracker function
aa40a4a1	207	HLTInfo("DoEvent processing data");
1ac82ce6	208
aa40a4a1	209	int iResult=0;
89c2e505	210	TClonesArray *clusterArray=0;
1726bb2d	211	TObjArray *seedArray=0;
e642ae99	212	int slice, patch;
	213
	214	const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTObjArray\|kAliHLTDataOriginTPC);
	215	if(!pBlock) {
	216	HLTError("Cannot get first data block 0x%08x ",pBlock);
	217	iResult=-ENOMEM; return iResult;
	218	}
	219	int minSlice=AliHLTTPCDefinitions::GetMinSliceNr(pBlock->fSpecification);
	220	int maxSlice=AliHLTTPCDefinitions::GetMaxSliceNr(pBlock->fSpecification);
	221	int minPatch=AliHLTTPCDefinitions::GetMinPatchNr(pBlock->fSpecification);
	222	int maxPatch=AliHLTTPCDefinitions::GetMaxPatchNr(pBlock->fSpecification);
aa40a4a1	223
aa40a4a1	224	if (fTracker && fESD) {
89c2e505	225	// loop over input data blocks: TClonesArrays of clusters
dcb8a00c	226	for (TObject pObj = (TObject )GetFirstInputObject(kAliHLTDataTypeTObjArray\|kAliHLTDataOriginTPC/AliHLTTPCDefinitions::fgkOfflineClustersDataType/,"TClonesArray",0);
aa40a4a1	227	pObj !=0 && iResult>=0;
aa40a4a1	228	pObj = (TObject *)GetNextInputObject(0)) {
89c2e505	229	clusterArray = dynamic_cast<TClonesArray*>(pObj);
aa40a4a1	230	if (!clusterArray) continue;
aa40a4a1	231
89c2e505	232	HLTInfo("load %d clusters from block %s 0x%08x", clusterArray->GetEntries(), DataType2Text(GetDataType(pObj)).c_str(), GetSpecification(pObj));
e642ae99	233	slice=AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(pObj));
	234	patch=AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(pObj));
	235
	236	if(slice < minSlice) minSlice=slice;
	237	if(slice > maxSlice) maxSlice=slice;
	238	if(patch < minPatch) minPatch=patch;
	239	if(patch > maxPatch) maxPatch=patch;
c03e064d	240	#ifndef HAVE_NOT_TPCOFFLINE_REC
aa40a4a1	241	fTracker->LoadClusters(clusterArray);
c03e064d	242	#endif //HAVE_NOT_TPCOFFLINE_REC
89c2e505	243
89c2e505	244	clusterArray->Delete();
aa40a4a1	245	}// end loop over input objects
aa40a4a1	246
89c2e505	247	#ifndef HAVE_NOT_TPCOFFLINE_REC
	248	// Load outer sectors
	249	fTracker->LoadOuterSectors();
	250	// Load inner sectors
	251	fTracker->LoadInnerSectors();
	252	#endif
	253
488581c1	254	// set magnetic field for the ESD, assumes correct initialization of
	255	// the field map
	256	fESD->SetMagneticField(AliTracker::GetBz());
89c2e505	257
aa40a4a1	258	// run tracker
aa40a4a1	259	fTracker->Clusters2Tracks(fESD);
1726bb2d	260
	261	// add TPC seed to the AliESDtrack
	262	seedArray = fTracker->GetSeeds();
	263	if(seedArray) {
	264	Int_t nseed = seedArray->GetEntriesFast();
	265	HLTInfo("Number TPC seeds %d",nseed);
	266
	267	for(Int_t i=0; i<nseed; ++i) {
	268	AliTPCseed seed = (AliTPCseed)seedArray->UncheckedAt(i);
	269	if(!seed) continue;
	270
89c2e505	271	//HLTInfo("TPC seed: sec %d, row %d",seed->GetSector(), seed->GetRow());
89c2e505	272
1726bb2d	273	AliESDtrack *esdtrack=fESD->GetTrack(i);
	274	if(esdtrack) esdtrack->AddCalibObject((TObject*)seed);
	275	else
89c2e505	276	HLTInfo("Cannot add TPC seed to AliESDtrack %d", i);
1726bb2d	277	}
89c2e505	278	seedArray->Clear();
8d644a5d	279	}
1726bb2d	280
89c2e505	281	// reset ESDs friends (no Reset function!)
1726bb2d	282	fESDfriend->~AliESDfriend();
1726bb2d	283	new (fESDfriend) AliESDfriend(); // Reset ...
89c2e505	284
89c2e505	285	// add ESDfriend to AliESDEvent
1726bb2d	286	fESD->GetESDfriend(fESDfriend);
	287
	288	// unload clusters
aa40a4a1	289	fTracker->UnloadClusters();
	290
	291	Int_t nTracks = fESD->GetNumberOfTracks();
	292	HLTInfo("Number of tracks %d", nTracks);
	293
e642ae99	294	// calculate specification from the specification of input data blocks
	295	AliHLTUInt32_t iSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
	296	HLTInfo("minSlice %d, maxSlice %d, minPatch %d, maxPatch %d", minSlice, maxSlice, minPatch, maxPatch);
aa40a4a1	297
e642ae99	298	// send data
e642ae99	299	PushBack(fESD, kAliHLTDataTypeESDObject\|kAliHLTDataOriginTPC, iSpecification);
aa40a4a1	300
89c2e505	301	// reset ESDs and ESDs friends
aa40a4a1	302	fESD->Reset();
e642ae99	303
aa40a4a1	304	} else {
	305	HLTError("component not initialized");
	306	iResult=-ENOMEM;
	307	}
	308
	309	return iResult;
1ac82ce6	310	}
	311
	312	int AliHLTTPCOfflineTrackerComponent::Configure(const char* arguments)
	313	{
	314	// see header file for class documentation
	315	int iResult=0;
	316	if (!arguments) return iResult;
	317
	318	TString allArgs=arguments;
	319	TString argument;
	320	int bMissingParam=0;
	321
	322	TObjArray* pTokens=allArgs.Tokenize(" ");
	323	if (pTokens) {
	324	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	325	argument=((TObjString*)pTokens->At(i))->GetString();
	326	if (argument.IsNull()) continue;
	327
e642ae99	328	if (argument.CompareTo("-solenoidBz")==0) {
1ac82ce6	329	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
e642ae99	330	// TODO: check if there is common functionality in the AliMagF* classes
	331	float SolenoidBz=((TObjString*)pTokens->At(i))->GetString().Atof();
	332	if (SolenoidBz<kAlmost0Field) SolenoidBz=kAlmost0Field;
	333	float factor=1.;
	334	int map=AliMagFMaps::k2kG;
	335	if (SolenoidBz<3.) {
	336	map=AliMagFMaps::k2kG;
	337	factor=SolenoidBz/2;
	338	} else if (SolenoidBz>=3. && SolenoidBz<4.5) {
	339	map=AliMagFMaps::k4kG;
	340	factor=SolenoidBz/4;
	341	} else {
	342	map=AliMagFMaps::k5kG;
	343	factor=SolenoidBz/5;
	344	}
	345	// the magnetic field map is not supposed to change
	346	// field initialization should be done once in the beginning
	347	// TODO: does the factor need adjustment?
	348	const AliMagF* currentMap=AliTracker::GetFieldMap();
	349	if (!currentMap) {
	350	AliMagFMaps* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., map);
f8880dee	351	AliTracker::SetFieldMap(field,kFALSE);
e642ae99	352	HLTInfo("Solenoid Field set to: %f map %d", SolenoidBz, map);
	353	} else if (currentMap->Map()!=map) {
	354	HLTWarning("omitting request to override field map %s with %s", currentMap->Map(), map);
	355	}
	356	continue;
1ac82ce6	357	} else {
	358	HLTError("unknown argument %s", argument.Data());
	359	iResult=-EINVAL;
	360	break;
	361	}
	362	}
	363	delete pTokens;
	364	}
	365	if (bMissingParam) {
	366	HLTError("missing parameter for argument %s", argument.Data());
	367	iResult=-EINVAL;
	368	}
	369	return iResult;
	370	}
	371
e642ae99	372	int AliHLTTPCOfflineTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
1ac82ce6	373	{
	374	// see header file for class documentation
	375	int iResult=0;
e642ae99	376	const char* path=kAliHLTCDBSolenoidBz;
	377	const char* defaultNotify="";
	378	if (cdbEntry) {
	379	path=cdbEntry;
	380	defaultNotify=" (default)";
	381	}
	382	if (path) {
73449074	383	if (chainId) {} // just to get rid of warning, can not comment argument due to debug message
e642ae99	384	HLTDebug("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
	385	AliCDBEntry pEntry = AliCDBManager::Instance()->Get(path/,GetRunNo()*/);
	386	if (pEntry) {
	387	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
	388	if (pString) {
	389	HLTDebug("received configuration object string: \'%s\'", pString->GetString().Data());
	390	iResult=Configure(pString->GetString().Data());
	391	} else {
	392	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	393	}
	394	} else {
	395	HLTError("can not fetch object \"%s\" from CDB", path);
	396	}
	397	}
	398
1ac82ce6	399	return iResult;
1ac82ce6	400	}