[u/mrichter/AliRoot.git] / HLT / ITS / AliHLTITSClusterFinderComponent.cxx

// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Gaute Øvrebekk <st05886@alf.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   AliHLTITSClusterFinderComponent.cxx
    @author Gaute Øvrebekk <st05886@alf.uib.no>
    @date   
    @brief  Component to run offline clusterfinders
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTITSClusterFinderComponent.h" 

#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliITSgeomTGeo.h"
#include "AliITSRecPoint.h"
#include "AliHLTITSSpacePointData.h"
#include "AliHLTITSClusterDataFormat.h"
#include <AliHLTDAQ.h>
#include "AliGeomManager.h"
#include "AliITSRecoParam.h"
#include "AliITSReconstructor.h"
#include "AliHLTITSClusterFinderSPD.h"
#include "AliHLTITSClusterFinderSSD.h"

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

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

AliHLTITSClusterFinderComponent::AliHLTITSClusterFinderComponent(int mode)
  :
  fModeSwitch(mode),
  fInputDataType(kAliHLTVoidDataType),
  fOutputDataType(kAliHLTVoidDataType),
  fUseOfflineFinder(0),
  fNModules(0),
  fId(0),
  fNddl(0),
  fClusters(NULL),
  fRawReader(NULL),
  fDettype(NULL),
  fgeom(NULL),
  fgeomInit(NULL),
  fSPD(NULL),
  fSSD(NULL),
  tD(NULL),
  tR(NULL),
  fclusters()
{ 
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

  switch(fModeSwitch){
  case kClusterFinderSPD:
    fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSPD;
    fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD;
    break;
  case kClusterFinderSDD: 	 
    fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSDD;
    fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD;
    break;
  case kClusterFinderSSD:
    fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSSD;
    fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD;
    break;
  case kClusterFinderDigits:
    fInputDataType  = kAliHLTDataTypeAliTreeD|kAliHLTDataOriginITS;
    fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITS;
    break;
  default:
    HLTFatal("unknown cluster finder");
  }
}

AliHLTITSClusterFinderComponent::~AliHLTITSClusterFinderComponent() 
{
  // see header file for class documentation
  delete fRawReader;
  delete fDettype;
  delete fgeomInit;  
  delete fSPD;
  delete fSSD;
}

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTITSClusterFinderComponent::GetComponentID()
{
  // see header file for class documentation
  switch(fModeSwitch){
  case kClusterFinderSPD:
    return "ITSClusterFinderSPD";
    break;
  case kClusterFinderSDD: 	 
    return "ITSClusterFinderSDD";
    break;
  case kClusterFinderSSD:
    return "ITSClusterFinderSSD";
    break;
  case kClusterFinderDigits:
    return "ITSClusterFinderDigits";
    break;
  }
  return "";
}

void AliHLTITSClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) 
{
  // see header file for class documentation
  list.clear(); 
  list.push_back( fInputDataType );
}

AliHLTComponentDataType AliHLTITSClusterFinderComponent::GetOutputDataType() 
{
  // see header file for class documentation
  return fOutputDataType;
}

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

AliHLTComponent* AliHLTITSClusterFinderComponent::Spawn() {
  // see header file for class documentation
  return new AliHLTITSClusterFinderComponent(fModeSwitch);
}
	
Int_t AliHLTITSClusterFinderComponent::DoInit( int argc, const char** argv ) {
  // see header file for class documentation
  /*
  fStatTime = 0;
  fStatTimeAll = 0;
  fStatTimeC = 0;
  fStatTimeAllC = 0;
  fStatNEv = 0;
  */
  
  Int_t runNo = GetRunNo();
  AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
  if (!store) {
    return NULL;
  }

  bool cdbOK = true;
  //OCDB for SPD
  if(store->GetLatestVersion("ITS/Calib/SPDNoisy", runNo)<0){
    HLTError("SPDNoisy is not found in SPD/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/SPDDead", runNo)<0){
    HLTError("SPDDead is not found in SPD/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("TRIGGER/SPD/PITConditions", runNo)<0){
    HLTError("PITConditions is not found in TRIGGER/SPD");
    cdbOK = false;
  }
  
  //OCDB for SDD
  if(store->GetLatestVersion("ITS/Calib/CalibSDD", runNo)<0){
    HLTError("CalibSDD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/RespSDD", runNo)<0){
    HLTError("RespSDD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/DriftSpeedSDD", runNo)<0){
    HLTError("DriftSpeedSDD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/DDLMapSDD", runNo)<0){
    HLTError("DDLMapSDD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/MapsTimeSDD", runNo)<0){
    HLTError("MapsTimeSDD is not found in ITS/Calib");
    cdbOK = false;
  }

  //OCDB for SSD
  if(store->GetLatestVersion("ITS/Calib/NoiseSSD", runNo)<0){
    HLTError("NoiseSSD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/GainSSD", runNo)<0){
    HLTError("GainSSD is not found in ITS/Calib");
    cdbOK = false;
  }
  if(store->GetLatestVersion("ITS/Calib/BadChannelsSSD", runNo)<0){
    HLTError("BadChannelsSSD is not found in ITS/Calib");
    cdbOK = false;
  }
  
  //General reconstruction
  if(store->GetLatestVersion("GRP/CTP/Scalers", runNo)<0){
    HLTError("Scalers is not found in GRP/CTP/");
    cdbOK = false;
  }
  if(!cdbOK){return NULL;}

  if(fModeSwitch==kClusterFinderSPD) {
    HLTDebug("using ClusterFinder for SPD");
    //fNModules=AliITSgeomTGeo::GetNDetectors(1)*AliITSgeomTGeo::GetNLadders(1) + AliITSgeomTGeo::GetNDetectors(2)*AliITSgeomTGeo::GetNLadders(2);
    fId=AliHLTDAQ::DdlIDOffset("ITSSPD");
    fNddl=AliHLTDAQ::NumberOfDdls("ITSSPD");
  }
  else if(fModeSwitch==kClusterFinderSDD) {
    HLTDebug("using ClusterFinder for SDD");
    //fNModules=AliITSgeomTGeo::GetNDetectors(3)*AliITSgeomTGeo::GetNLadders(3) + AliITSgeomTGeo::GetNDetectors(4)*AliITSgeomTGeo::GetNLadders(4);
    fId=AliHLTDAQ::DdlIDOffset("ITSSDD");
    fNddl=AliHLTDAQ::NumberOfDdls("ITSSDD");
  }
  else if(fModeSwitch==kClusterFinderSSD) {
    HLTDebug("using ClusterFinder for SSD");
    //fNModules=AliITSgeomTGeo::GetNDetectors(5)*AliITSgeomTGeo::GetNLadders(5) + AliITSgeomTGeo::GetNDetectors(6)*AliITSgeomTGeo::GetNLadders(6);
    fId=AliHLTDAQ::DdlIDOffset("ITSSSD");
    fNddl=AliHLTDAQ::NumberOfDdls("ITSSSD");
  }
  else if(fModeSwitch==kClusterFinderDigits) {
    //tR = new TTree();
  }
  else{
     HLTFatal("No mode set for clusterfindercomponent");
  }

  //Removed the warning for loading default RecoParam in HLT
  AliITSRecoParam *par = AliITSRecoParam::GetLowFluxParam();
  AliITSReconstructor *rec = new AliITSReconstructor();
  rec->SetRecoParam(par);
  
  AliCDBManager* man = AliCDBManager::Instance();
  if (!man->IsDefaultStorageSet()){
    HLTError("Default CDB storage has not been set !");
    return -ENOENT;
  }

  if(AliGeomManager::GetGeometry()==NULL){
    AliGeomManager::LoadGeometry();
  }

 //fgeomInit = new AliITSInitGeometry(kvSPD02,2);
  fgeomInit = new AliITSInitGeometry(kvPPRasymmFMD,2);
  //fgeomInit->InitAliITSgeom(fgeom);
  fgeom = fgeomInit->CreateAliITSgeom();
 
  fNModules = fgeom->GetIndexMax();

  fClusters = new TClonesArray*[fNModules]; 
  for (Int_t iModule = 0; iModule < fNModules; iModule++) {
    fClusters[iModule] = NULL;
  } 

  //set dettype
  fDettype = new AliITSDetTypeRec();
  fDettype->SetITSgeom(fgeom); 
  fDettype->SetDefaults();
  fDettype->SetDefaultClusterFindersV2(kTRUE); 

  if ( fRawReader )
    return -EINPROGRESS;

  fRawReader = new AliRawReaderMemory();
  fSPD = new AliHLTITSClusterFinderSPD( fDettype );
  fSSD = new AliHLTITSClusterFinderSSD( fDettype, fRawReader );

  TString arguments = "";
  for ( int i = 0; i < argc; i++ ) {
    if ( !arguments.IsNull() ) arguments += " ";
    arguments += argv[i];
  }

  tD = NULL;
  tR = NULL;

  return Configure( arguments.Data() );
}

Int_t AliHLTITSClusterFinderComponent::DoDeinit() {
  // see header file for class documentation

  if ( fRawReader )
    delete fRawReader;
  fRawReader = NULL;

  if ( fDettype )
    delete fDettype;
  fDettype = NULL;

  if ( fgeomInit )
    delete fgeomInit;
  fgeomInit = NULL;
  
  delete fSPD;
  fSPD = 0;

  delete fSSD;
  fSSD = 0;

  for (Int_t iModule = 0; iModule < fNModules; iModule++) {
    if(fClusters[iModule] != NULL){
      fClusters[iModule]->Delete();
      delete fClusters[iModule];
    }
    fClusters[iModule] = NULL;
  } 
  
  fUseOfflineFinder = 0;

  return 0;
}

// #include "TStopwatch.h"

int AliHLTITSClusterFinderComponent::DoEvent
(
 const AliHLTComponentEventData& evtData,
 const AliHLTComponentBlockData* blocks,
 AliHLTComponentTriggerData& /*trigData*/,
 AliHLTUInt8_t* outputPtr,
 AliHLTUInt32_t& size,
  vector<AliHLTComponentBlockData>& outputBlocks )
{
 // see header file for class documentation
  
  AliHLTUInt32_t maxBufferSize = size;
  size = 0; // output size

  if (!IsDataEvent()) return 0;
  
  if ( evtData.fBlockCnt<=0 )
    {
      HLTDebug("no blocks in event" );
      return 0;
    }
  
  // TStopwatch timer;
  Int_t ret = 0;
  //std::vector<AliITSRecPoint> vclusters;
  if(fModeSwitch==kClusterFinderDigits) {
    for ( const TObject *iter = GetFirstInputObject(fInputDataType); iter != NULL; iter = GetNextInputObject() ) {  
      tD = dynamic_cast<TTree*>(const_cast<TObject*>( iter ) );
      if(!tD){
	HLTFatal("No Digit Tree found");
	return -1;
      }
      tR = new TTree();
      fDettype->SetTreeAddressD(tD);
      fDettype->MakeBranch(tR,"R");
      fDettype->SetTreeAddressR(tR);
      Option_t *opt="All";
      fDettype->DigitsToRecPoints(tD,tR,0,opt,kTRUE);
      
      TClonesArray * fRecPoints;
      tR->SetBranchAddress("ITSRecPoints",&fRecPoints);
      for(Int_t treeEntry=0;treeEntry<tR->GetEntries();treeEntry++){
	tR->GetEntry(treeEntry);
	for(Int_t tCloneEntry=0;tCloneEntry<fRecPoints->GetEntries();tCloneEntry++){
	  AliITSRecPoint *recpoint=(AliITSRecPoint*)fRecPoints->At(tCloneEntry);
	  fclusters.push_back(*recpoint);
	}
      }
      
      if(tR){
	tR->Delete();
      }
      UInt_t nClusters=fclusters.size();
      
      UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
      if( size + bufferSize > maxBufferSize ){
	HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
	ret = -ENOSPC;      
	break;		
      }
      if( nClusters>0 ){

	RecPointToSpacePoint(outputPtr,size);
	
	AliHLTComponentBlockData bd;
	FillBlockData( bd );
	bd.fOffset = size;
	bd.fSize = bufferSize;
	bd.fSpecification = 0x00000000;
	bd.fDataType = GetOutputDataType();
	outputBlocks.push_back( bd );
	size += bufferSize;
	
	fclusters.clear();	
      }
    }
  }
  else{
      
    // -- Loop over blocks
    for( const AliHLTComponentBlockData* iter = GetFirstInputBlock(fInputDataType); iter != NULL; iter = GetNextInputBlock() ) {
      
      // -- Debug output of datatype --
      HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	       evtData.fEventID, evtData.fEventID, 
	       DataType2Text(iter->fDataType).c_str(), 
	       DataType2Text(fInputDataType).c_str());
      
      // -- Check for the correct data type
      if ( iter->fDataType != (fInputDataType) )  
	continue;
      
      // -- Get equipment ID out of specification
      AliHLTUInt32_t spec = iter->fSpecification;
      
      Int_t id = fId;
      for ( Int_t ii = 0; ii < fNddl ; ii++ ) {   //number of ddl's
	if ( spec & 0x00000001 ) {
	  id += ii;
	  break;
	}
	spec = spec >> 1 ;
      }
      
      // -- Set equipment ID to the raw reader
      
      if(!fRawReader->AddBuffer((UChar_t*) iter->fPtr, iter->fSize, id)){
	HLTWarning("Could not add buffer");
      }
      // TStopwatch timer1;
      
      if(fModeSwitch==kClusterFinderSPD && !fUseOfflineFinder){ fSPD->RawdataToClusters( fRawReader, fclusters ); }
      else if(fModeSwitch==kClusterFinderSSD && !fUseOfflineFinder){ fSSD->RawdataToClusters( fclusters ); }
      else{
	if(fModeSwitch==kClusterFinderSPD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SPD");}
	if(fModeSwitch==kClusterFinderSSD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SSD");}
	if(fModeSwitch==kClusterFinderSDD) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SDD");}
	for(int i=0;i<fNModules;i++){
	  if(fClusters[i] != NULL){
	    for(int j=0;j<fClusters[i]->GetEntriesFast();j++){
	      AliITSRecPoint *recpoint = (AliITSRecPoint*) (fClusters[i]->At(j));
	      fclusters.push_back(*recpoint);
	    }
	    fClusters[i]->Delete();
	    delete fClusters[i];
	  }
	  fClusters[i] = NULL;
	}     
      }
      
      // timer1.Stop();
      // fStatTime+=timer1.RealTime();
      // fStatTimeC+=timer1.CpuTime();
      
      fRawReader->ClearBuffers();    
         
      UInt_t nClusters=fclusters.size();
      
      UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
      if( size + bufferSize > maxBufferSize ){
	HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
	ret = -ENOSPC;      
	break;		
      }
      if( nClusters>0 ){

	RecPointToSpacePoint(outputPtr,size);

	AliHLTComponentBlockData bd;
	FillBlockData( bd );
	bd.fOffset = size;
	bd.fSize = bufferSize;
	bd.fSpecification = iter->fSpecification;
	bd.fDataType = GetOutputDataType();
	outputBlocks.push_back( bd );
	size += bufferSize;
	
	fclusters.clear();	
      }
      
    } // input blocks
  }
  /*
  timer.Stop();
  
  fStatTimeAll+=timer.RealTime();
  fStatTimeAllC+=timer.CpuTime();
  fStatNEv++;
  if( fStatNEv%1000==0 && fStatTimeAll>0.0 && fStatTime>0.0 && fStatTimeAllC>0.0 && fStatTimeC>0.0)
    cout<<fStatTimeAll/fStatNEv*1.e3<<" "<<fStatTime/fStatNEv*1.e3<<" "
	<<fStatTimeAllC/fStatNEv*1.e3<<" "<<fStatTimeC/fStatNEv*1.e3<<" ms"<<endl;
  */

  return ret;
}

int AliHLTITSClusterFinderComponent::Configure(const char* arguments)
{
  
  int iResult=0;
  
  if (!arguments) return iResult;
  
  TString allArgs=arguments;
  TString argument;
  
  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("-use-offline-finder")==0) {
	fUseOfflineFinder = 1;
	HLTInfo("Off-line ClusterFinder will be used");
	continue;
      }
      /*
      else if (argument.CompareTo("")==0) {
	HLTInfo("");
	continue;
      }
      */
      else {
	HLTError("unknown argument %s", argument.Data());
	iResult=-EINVAL;
	break;
      }
    }
    delete pTokens;
  }
  
  return iResult;
}

int AliHLTITSClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
  // see header file for class documentation
  int iResult=0;
  
  const char* path="HLT/ConfigITS/ClusterFinderComponent";
  const char* defaultNotify="";
  if (cdbEntry) {
    path=cdbEntry;
    defaultNotify=" (default)";
  }
  if (path) {
    HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);
    if (pEntry) {
      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
      if (pString) {
	HLTInfo("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;
}
void AliHLTITSClusterFinderComponent::RecPointToSpacePoint(AliHLTUInt8_t* outputPtr,AliHLTUInt32_t& size){
  AliHLTITSClusterData *outputClusters = reinterpret_cast<AliHLTITSClusterData*>(outputPtr + size);
  outputClusters->fSpacePointCnt=fclusters.size();    
  int clustIdx=0;
  for(UInt_t i=0;i<fclusters.size();i++){
    AliITSRecPoint *recpoint = (AliITSRecPoint*) &(fclusters[i]);
    outputClusters->fSpacePoints[clustIdx].fY=recpoint->GetY();
    outputClusters->fSpacePoints[clustIdx].fZ=recpoint->GetZ();
    outputClusters->fSpacePoints[clustIdx].fSigmaY2=recpoint->GetSigmaY2();
    outputClusters->fSpacePoints[clustIdx].fSigmaZ2=recpoint->GetSigmaZ2();
    outputClusters->fSpacePoints[clustIdx].fSigmaYZ=recpoint->GetSigmaYZ();
    outputClusters->fSpacePoints[clustIdx].fQ=recpoint->GetQ();
    outputClusters->fSpacePoints[clustIdx].fNy=recpoint->GetNy();
    outputClusters->fSpacePoints[clustIdx].fNz=recpoint->GetNz();
    outputClusters->fSpacePoints[clustIdx].fLayer=recpoint->GetLayer();
    outputClusters->fSpacePoints[clustIdx].fIndex=recpoint->GetDetectorIndex() | recpoint->GetPindex() | recpoint->GetNindex();
    outputClusters->fSpacePoints[clustIdx].fTracks[0]=recpoint->GetLabel(0);
    outputClusters->fSpacePoints[clustIdx].fTracks[1]=recpoint->GetLabel(1);
    outputClusters->fSpacePoints[clustIdx].fTracks[2]=recpoint->GetLabel(2);      
    clustIdx++;
  }
}
Commit	Line	Data
6b7742a2	1	// $Id$
	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: Gaute Øvrebekk <st05886@alf.uib.no> *
	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 AliHLTITSClusterFinderComponent.cxx
	19	@author Gaute Øvrebekk <st05886@alf.uib.no>
	20	@date
	21	@brief Component to run offline clusterfinders
	22	*/
	23
	24	#if __GNUC__>= 3
	25	using namespace std;
	26	#endif
	27
	28	#include "AliHLTITSClusterFinderComponent.h"
	29
	30	#include "AliCDBEntry.h"
	31	#include "AliCDBManager.h"
2bd1335e	32	#include "AliCDBStorage.h"
6b7742a2	33	#include "AliITSgeomTGeo.h"
	34	#include "AliITSRecPoint.h"
	35	#include "AliHLTITSSpacePointData.h"
	36	#include "AliHLTITSClusterDataFormat.h"
	37	#include <AliHLTDAQ.h>
	38	#include "AliGeomManager.h"
060f29ad	39	#include "AliITSRecoParam.h"
060f29ad	40	#include "AliITSReconstructor.h"
3f61e9ce	41	#include "AliHLTITSClusterFinderSPD.h"
a2a2a7ce	42	#include "AliHLTITSClusterFinderSSD.h"
6b7742a2	43
	44	#include <cstdlib>
	45	#include <cerrno>
	46	#include "TString.h"
	47	#include "TObjString.h"
	48	#include <sys/time.h>
	49
	50	/** ROOT macro for the implementation of ROOT specific class methods */
	51	ClassImp(AliHLTITSClusterFinderComponent);
	52
	53	AliHLTITSClusterFinderComponent::AliHLTITSClusterFinderComponent(int mode)
	54	:
	55	fModeSwitch(mode),
a2a2a7ce	56	fInputDataType(kAliHLTVoidDataType),
	57	fOutputDataType(kAliHLTVoidDataType),
	58	fUseOfflineFinder(0),
6b7742a2	59	fNModules(0),
	60	fId(0),
	61	fNddl(0),
d293cef8	62	fClusters(NULL),
6b7742a2	63	fRawReader(NULL),
	64	fDettype(NULL),
	65	fgeom(NULL),
3f61e9ce	66	fgeomInit(NULL),
a2a2a7ce	67	fSPD(NULL),
618f422f	68	fSSD(NULL),
	69	tD(NULL),
	70	tR(NULL),
	71	fclusters()
6b7742a2	72	{
	73	// see header file for class documentation
	74	// or
	75	// refer to README to build package
	76	// or
	77	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
a2a2a7ce	78
	79	switch(fModeSwitch){
	80	case kClusterFinderSPD:
	81	fInputDataType = kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginITSSPD;
	82	fOutputDataType = kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSPD;
	83	break;
	84	case kClusterFinderSDD:
	85	fInputDataType = kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginITSSDD;
	86	fOutputDataType = kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSDD;
	87	break;
	88	case kClusterFinderSSD:
	89	fInputDataType = kAliHLTDataTypeDDLRaw \| kAliHLTDataOriginITSSSD;
	90	fOutputDataType = kAliHLTDataTypeClusters\|kAliHLTDataOriginITSSSD;
	91	break;
618f422f	92	case kClusterFinderDigits:
59b3dd4b	93	fInputDataType = kAliHLTDataTypeAliTreeD\|kAliHLTDataOriginITS;
618f422f	94	fOutputDataType = kAliHLTDataTypeClusters\|kAliHLTDataOriginITS;
618f422f	95	break;
a2a2a7ce	96	default:
6b7742a2	97	HLTFatal("unknown cluster finder");
	98	}
	99	}
	100
3f61e9ce	101	AliHLTITSClusterFinderComponent::~AliHLTITSClusterFinderComponent()
3f61e9ce	102	{
6b7742a2	103	// see header file for class documentation
3f61e9ce	104	delete fRawReader;
	105	delete fDettype;
	106	delete fgeomInit;
	107	delete fSPD;
a2a2a7ce	108	delete fSSD;
6b7742a2	109	}
	110
	111	// Public functions to implement AliHLTComponent's interface.
	112	// These functions are required for the registration process
	113
	114	const char* AliHLTITSClusterFinderComponent::GetComponentID()
	115	{
	116	// see header file for class documentation
	117	switch(fModeSwitch){
	118	case kClusterFinderSPD:
	119	return "ITSClusterFinderSPD";
	120	break;
	121	case kClusterFinderSDD:
	122	return "ITSClusterFinderSDD";
	123	break;
	124	case kClusterFinderSSD:
	125	return "ITSClusterFinderSSD";
	126	break;
618f422f	127	case kClusterFinderDigits:
	128	return "ITSClusterFinderDigits";
	129	break;
6b7742a2	130	}
	131	return "";
	132	}
	133
a2a2a7ce	134	void AliHLTITSClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
a2a2a7ce	135	{
6b7742a2	136	// see header file for class documentation
6b7742a2	137	list.clear();
a2a2a7ce	138	list.push_back( fInputDataType );
6b7742a2	139	}
6b7742a2	140
a2a2a7ce	141	AliHLTComponentDataType AliHLTITSClusterFinderComponent::GetOutputDataType()
a2a2a7ce	142	{
6b7742a2	143	// see header file for class documentation
a2a2a7ce	144	return fOutputDataType;
6b7742a2	145	}
	146
	147	void AliHLTITSClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
	148	// see header file for class documentation
	149	constBase = 0;
	150	inputMultiplier = 100;
	151	}
	152
	153	AliHLTComponent* AliHLTITSClusterFinderComponent::Spawn() {
	154	// see header file for class documentation
	155	return new AliHLTITSClusterFinderComponent(fModeSwitch);
	156	}
	157
1ea949fd	158	Int_t AliHLTITSClusterFinderComponent::DoInit( int argc, const char** argv ) {
6b7742a2	159	// see header file for class documentation
a2a2a7ce	160	/*
3f61e9ce	161	fStatTime = 0;
	162	fStatTimeAll = 0;
	163	fStatTimeC = 0;
	164	fStatTimeAllC = 0;
	165	fStatNEv = 0;
a2a2a7ce	166	*/
2bd1335e	167
	168	Int_t runNo = GetRunNo();
	169	AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
	170	if (!store) {
	171	return NULL;
	172	}
	173
	174	bool cdbOK = true;
	175	//OCDB for SPD
	176	if(store->GetLatestVersion("ITS/Calib/SPDNoisy", runNo)<0){
	177	HLTError("SPDNoisy is not found in SPD/Calib");
	178	cdbOK = false;
	179	}
	180	if(store->GetLatestVersion("ITS/Calib/SPDDead", runNo)<0){
	181	HLTError("SPDDead is not found in SPD/Calib");
	182	cdbOK = false;
	183	}
	184	if(store->GetLatestVersion("TRIGGER/SPD/PITConditions", runNo)<0){
	185	HLTError("PITConditions is not found in TRIGGER/SPD");
	186	cdbOK = false;
	187	}
	188
	189	//OCDB for SDD
	190	if(store->GetLatestVersion("ITS/Calib/CalibSDD", runNo)<0){
	191	HLTError("CalibSDD is not found in ITS/Calib");
	192	cdbOK = false;
	193	}
	194	if(store->GetLatestVersion("ITS/Calib/RespSDD", runNo)<0){
	195	HLTError("RespSDD is not found in ITS/Calib");
	196	cdbOK = false;
	197	}
	198	if(store->GetLatestVersion("ITS/Calib/DriftSpeedSDD", runNo)<0){
	199	HLTError("DriftSpeedSDD is not found in ITS/Calib");
	200	cdbOK = false;
	201	}
	202	if(store->GetLatestVersion("ITS/Calib/DDLMapSDD", runNo)<0){
	203	HLTError("DDLMapSDD is not found in ITS/Calib");
	204	cdbOK = false;
	205	}
	206	if(store->GetLatestVersion("ITS/Calib/MapsTimeSDD", runNo)<0){
	207	HLTError("MapsTimeSDD is not found in ITS/Calib");
	208	cdbOK = false;
	209	}
	210
	211	//OCDB for SSD
	212	if(store->GetLatestVersion("ITS/Calib/NoiseSSD", runNo)<0){
	213	HLTError("NoiseSSD is not found in ITS/Calib");
	214	cdbOK = false;
	215	}
	216	if(store->GetLatestVersion("ITS/Calib/GainSSD", runNo)<0){
	217	HLTError("GainSSD is not found in ITS/Calib");
	218	cdbOK = false;
	219	}
	220	if(store->GetLatestVersion("ITS/Calib/BadChannelsSSD", runNo)<0){
	221	HLTError("BadChannelsSSD is not found in ITS/Calib");
	222	cdbOK = false;
	223	}
	224
	225	//General reconstruction
	226	if(store->GetLatestVersion("GRP/CTP/Scalers", runNo)<0){
	227	HLTError("Scalers is not found in GRP/CTP/");
	228	cdbOK = false;
	229	}
	230	if(!cdbOK){return NULL;}
231
6b7742a2	232	if(fModeSwitch==kClusterFinderSPD) {
6b7742a2	233	HLTDebug("using ClusterFinder for SPD");
d293cef8	234	//fNModules=AliITSgeomTGeo::GetNDetectors(1)AliITSgeomTGeo::GetNLadders(1) + AliITSgeomTGeo::GetNDetectors(2)AliITSgeomTGeo::GetNLadders(2);
6b7742a2	235	fId=AliHLTDAQ::DdlIDOffset("ITSSPD");
	236	fNddl=AliHLTDAQ::NumberOfDdls("ITSSPD");
	237	}
	238	else if(fModeSwitch==kClusterFinderSDD) {
	239	HLTDebug("using ClusterFinder for SDD");
d293cef8	240	//fNModules=AliITSgeomTGeo::GetNDetectors(3)AliITSgeomTGeo::GetNLadders(3) + AliITSgeomTGeo::GetNDetectors(4)AliITSgeomTGeo::GetNLadders(4);
6b7742a2	241	fId=AliHLTDAQ::DdlIDOffset("ITSSDD");
	242	fNddl=AliHLTDAQ::NumberOfDdls("ITSSDD");
	243	}
	244	else if(fModeSwitch==kClusterFinderSSD) {
	245	HLTDebug("using ClusterFinder for SSD");
d293cef8	246	//fNModules=AliITSgeomTGeo::GetNDetectors(5)AliITSgeomTGeo::GetNLadders(5) + AliITSgeomTGeo::GetNDetectors(6)AliITSgeomTGeo::GetNLadders(6);
6b7742a2	247	fId=AliHLTDAQ::DdlIDOffset("ITSSSD");
	248	fNddl=AliHLTDAQ::NumberOfDdls("ITSSSD");
	249	}
ec0e5f0f	250	else if(fModeSwitch==kClusterFinderDigits) {
618f422f	251	//tR = new TTree();
618f422f	252	}
6b7742a2	253	else{
	254	HLTFatal("No mode set for clusterfindercomponent");
	255	}
	256
060f29ad	257	//Removed the warning for loading default RecoParam in HLT
	258	AliITSRecoParam *par = AliITSRecoParam::GetLowFluxParam();
	259	AliITSReconstructor *rec = new AliITSReconstructor();
	260	rec->SetRecoParam(par);
	261
6b7742a2	262	AliCDBManager* man = AliCDBManager::Instance();
	263	if (!man->IsDefaultStorageSet()){
	264	HLTError("Default CDB storage has not been set !");
	265	return -ENOENT;
	266	}
	267
	268	if(AliGeomManager::GetGeometry()==NULL){
	269	AliGeomManager::LoadGeometry();
	270	}
3f61e9ce	271
3f61e9ce	272	//fgeomInit = new AliITSInitGeometry(kvSPD02,2);
6b7742a2	273	fgeomInit = new AliITSInitGeometry(kvPPRasymmFMD,2);
	274	//fgeomInit->InitAliITSgeom(fgeom);
	275	fgeom = fgeomInit->CreateAliITSgeom();
3f61e9ce	276
d293cef8	277	fNModules = fgeom->GetIndexMax();
	278
	279	fClusters = new TClonesArray*[fNModules];
	280	for (Int_t iModule = 0; iModule < fNModules; iModule++) {
	281	fClusters[iModule] = NULL;
	282	}
	283
6b7742a2	284	//set dettype
6b7742a2	285	fDettype = new AliITSDetTypeRec();
3f61e9ce	286	fDettype->SetITSgeom(fgeom);
6b7742a2	287	fDettype->SetDefaults();
86e746ed	288	fDettype->SetDefaultClusterFindersV2(kTRUE);
86e746ed	289
6b7742a2	290	if ( fRawReader )
	291	return -EINPROGRESS;
	292
	293	fRawReader = new AliRawReaderMemory();
3f61e9ce	294	fSPD = new AliHLTITSClusterFinderSPD( fDettype );
a2a2a7ce	295	fSSD = new AliHLTITSClusterFinderSSD( fDettype, fRawReader );
6b7742a2	296
1ea949fd	297	TString arguments = "";
	298	for ( int i = 0; i < argc; i++ ) {
	299	if ( !arguments.IsNull() ) arguments += " ";
	300	arguments += argv[i];
	301	}
	302
618f422f	303	tD = NULL;
	304	tR = NULL;
	305
1ea949fd	306	return Configure( arguments.Data() );
6b7742a2	307	}
	308
	309	Int_t AliHLTITSClusterFinderComponent::DoDeinit() {
	310	// see header file for class documentation
	311
	312	if ( fRawReader )
	313	delete fRawReader;
	314	fRawReader = NULL;
	315
6b7742a2	316	if ( fDettype )
	317	delete fDettype;
	318	fDettype = NULL;
	319
	320	if ( fgeomInit )
	321	delete fgeomInit;
	322	fgeomInit = NULL;
3f61e9ce	323
	324	delete fSPD;
	325	fSPD = 0;
6b7742a2	326
a2a2a7ce	327	delete fSSD;
	328	fSSD = 0;
	329
d293cef8	330	for (Int_t iModule = 0; iModule < fNModules; iModule++) {
	331	if(fClusters[iModule] != NULL){
	332	fClusters[iModule]->Delete();
	333	delete fClusters[iModule];
	334	}
	335	fClusters[iModule] = NULL;
	336	}
	337
a2a2a7ce	338	fUseOfflineFinder = 0;
a2a2a7ce	339
6b7742a2	340	return 0;
	341	}
	342
a2a2a7ce	343	// #include "TStopwatch.h"
3f61e9ce	344
a2a2a7ce	345	int AliHLTITSClusterFinderComponent::DoEvent
	346	(
	347	const AliHLTComponentEventData& evtData,
	348	const AliHLTComponentBlockData* blocks,
	349	AliHLTComponentTriggerData& /trigData/,
	350	AliHLTUInt8_t* outputPtr,
	351	AliHLTUInt32_t& size,
	352	vector<AliHLTComponentBlockData>& outputBlocks )
	353	{
	354	// see header file for class documentation
	355
	356	AliHLTUInt32_t maxBufferSize = size;
	357	size = 0; // output size
6b7742a2	358
a2a2a7ce	359	if (!IsDataEvent()) return 0;
a2a2a7ce	360
6b7742a2	361	if ( evtData.fBlockCnt<=0 )
a2a2a7ce	362	{
	363	HLTDebug("no blocks in event" );
	364	return 0;
	365	}
6b7742a2	366
a2a2a7ce	367	// TStopwatch timer;
a2a2a7ce	368	Int_t ret = 0;
618f422f	369	//std::vector<AliITSRecPoint> vclusters;
	370	if(fModeSwitch==kClusterFinderDigits) {
	371	for ( const TObject *iter = GetFirstInputObject(fInputDataType); iter != NULL; iter = GetNextInputObject() ) {
	372	tD = dynamic_cast<TTree>(const_cast<TObject>( iter ) );
	373	if(!tD){
	374	HLTFatal("No Digit Tree found");
	375	return -1;
	376	}
	377	tR = new TTree();
	378	fDettype->SetTreeAddressD(tD);
	379	fDettype->MakeBranch(tR,"R");
	380	fDettype->SetTreeAddressR(tR);
	381	Option_t *opt="All";
	382	fDettype->DigitsToRecPoints(tD,tR,0,opt,kTRUE);
	383
	384	TClonesArray * fRecPoints;
	385	tR->SetBranchAddress("ITSRecPoints",&fRecPoints);
	386	for(Int_t treeEntry=0;treeEntry<tR->GetEntries();treeEntry++){
	387	tR->GetEntry(treeEntry);
	388	for(Int_t tCloneEntry=0;tCloneEntry<fRecPoints->GetEntries();tCloneEntry++){
	389	AliITSRecPoint recpoint=(AliITSRecPoint)fRecPoints->At(tCloneEntry);
	390	fclusters.push_back(*recpoint);
	391	}
	392	}
	393
	394	if(tR){
	395	tR->Delete();
	396	}
	397	UInt_t nClusters=fclusters.size();
	398
	399	UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
	400	if( size + bufferSize > maxBufferSize ){
	401	HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
	402	ret = -ENOSPC;
	403	break;
	404	}
	405	if( nClusters>0 ){
3f61e9ce	406
618f422f	407	RecPointToSpacePoint(outputPtr,size);
	408
	409	AliHLTComponentBlockData bd;
	410	FillBlockData( bd );
	411	bd.fOffset = size;
	412	bd.fSize = bufferSize;
	413	bd.fSpecification = 0x00000000;
	414	bd.fDataType = GetOutputDataType();
	415	outputBlocks.push_back( bd );
	416	size += bufferSize;
	417
	418	fclusters.clear();
	419	}
	420	}
	421	}
	422	else{
	423
	424	// -- Loop over blocks
	425	for( const AliHLTComponentBlockData* iter = GetFirstInputBlock(fInputDataType); iter != NULL; iter = GetNextInputBlock() ) {
	426
	427	// -- Debug output of datatype --
	428	HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
6b7742a2	429	evtData.fEventID, evtData.fEventID,
6b7742a2	430	DataType2Text(iter->fDataType).c_str(),
df7307a2	431	DataType2Text(fInputDataType).c_str());
618f422f	432
	433	// -- Check for the correct data type
	434	if ( iter->fDataType != (fInputDataType) )
	435	continue;
	436
	437	// -- Get equipment ID out of specification
	438	AliHLTUInt32_t spec = iter->fSpecification;
	439
	440	Int_t id = fId;
	441	for ( Int_t ii = 0; ii < fNddl ; ii++ ) { //number of ddl's
	442	if ( spec & 0x00000001 ) {
	443	id += ii;
	444	break;
	445	}
	446	spec = spec >> 1 ;
6b7742a2	447	}
618f422f	448
	449	// -- Set equipment ID to the raw reader
	450
	451	if(!fRawReader->AddBuffer((UChar_t*) iter->fPtr, iter->fSize, id)){
	452	HLTWarning("Could not add buffer");
	453	}
	454	// TStopwatch timer1;
	455
	456	if(fModeSwitch==kClusterFinderSPD && !fUseOfflineFinder){ fSPD->RawdataToClusters( fRawReader, fclusters ); }
	457	else if(fModeSwitch==kClusterFinderSSD && !fUseOfflineFinder){ fSSD->RawdataToClusters( fclusters ); }
	458	else{
	459	if(fModeSwitch==kClusterFinderSPD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SPD");}
	460	if(fModeSwitch==kClusterFinderSSD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SSD");}
	461	if(fModeSwitch==kClusterFinderSDD) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SDD");}
	462	for(int i=0;i<fNModules;i++){
	463	if(fClusters[i] != NULL){
	464	for(int j=0;j<fClusters[i]->GetEntriesFast();j++){
	465	AliITSRecPoint recpoint = (AliITSRecPoint) (fClusters[i]->At(j));
	466	fclusters.push_back(*recpoint);
	467	}
	468	fClusters[i]->Delete();
	469	delete fClusters[i];
3f61e9ce	470	}
618f422f	471	fClusters[i] = NULL;
618f422f	472	}
a2a2a7ce	473	}
618f422f	474
	475	// timer1.Stop();
	476	// fStatTime+=timer1.RealTime();
	477	// fStatTimeC+=timer1.CpuTime();
	478
	479	fRawReader->ClearBuffers();
	480
	481	UInt_t nClusters=fclusters.size();
	482
	483	UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
	484	if( size + bufferSize > maxBufferSize ){
	485	HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
	486	ret = -ENOSPC;
	487	break;
	488	}
	489	if( nClusters>0 ){
	490
	491	RecPointToSpacePoint(outputPtr,size);
	492
	493	AliHLTComponentBlockData bd;
	494	FillBlockData( bd );
	495	bd.fOffset = size;
	496	bd.fSize = bufferSize;
	497	bd.fSpecification = iter->fSpecification;
	498	bd.fDataType = GetOutputDataType();
	499	outputBlocks.push_back( bd );
	500	size += bufferSize;
	501
	502	fclusters.clear();
	503	}
	504
	505	} // input blocks
	506	}
a2a2a7ce	507	/*
3f61e9ce	508	timer.Stop();
a2a2a7ce	509
3f61e9ce	510	fStatTimeAll+=timer.RealTime();
	511	fStatTimeAllC+=timer.CpuTime();
	512	fStatNEv++;
a2a2a7ce	513	if( fStatNEv%1000==0 && fStatTimeAll>0.0 && fStatTime>0.0 && fStatTimeAllC>0.0 && fStatTimeC>0.0)
	514	cout<<fStatTimeAll/fStatNEv1.e3<<" "<<fStatTime/fStatNEv1.e3<<" "
	515	<<fStatTimeAllC/fStatNEv1.e3<<" "<<fStatTimeC/fStatNEv1.e3<<" ms"<<endl;
	516	*/
3f61e9ce	517
a2a2a7ce	518	return ret;
6b7742a2	519	}
	520
	521	int AliHLTITSClusterFinderComponent::Configure(const char* arguments)
	522	{
	523
	524	int iResult=0;
	525
	526	if (!arguments) return iResult;
	527
	528	TString allArgs=arguments;
	529	TString argument;
	530
	531	TObjArray* pTokens=allArgs.Tokenize(" ");
	532
	533	if (pTokens) {
	534	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	535	argument=((TObjString*)pTokens->At(i))->GetString();
a2a2a7ce	536	if (argument.IsNull()) continue;
	537	if (argument.CompareTo("-use-offline-finder")==0) {
	538	fUseOfflineFinder = 1;
	539	HLTInfo("Off-line ClusterFinder will be used");
6b7742a2	540	continue;
6b7742a2	541	}
a2a2a7ce	542	/*
6b7742a2	543	else if (argument.CompareTo("")==0) {
	544	HLTInfo("");
	545	continue;
	546	}
	547	*/
	548	else {
	549	HLTError("unknown argument %s", argument.Data());
	550	iResult=-EINVAL;
	551	break;
	552	}
	553	}
	554	delete pTokens;
	555	}
	556
	557	return iResult;
	558	}
	559
	560	int AliHLTITSClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
	561	{
	562	// see header file for class documentation
	563	int iResult=0;
	564
	565	const char* path="HLT/ConfigITS/ClusterFinderComponent";
	566	const char* defaultNotify="";
	567	if (cdbEntry) {
	568	path=cdbEntry;
	569	defaultNotify=" (default)";
	570	}
	571	if (path) {
	572	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
	573	AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);
	574	if (pEntry) {
	575	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
	576	if (pString) {
	577	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	578	iResult=Configure(pString->GetString().Data());
	579	} else {
	580	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	581	}
	582	} else {
	583	HLTError("can not fetch object \"%s\" from CDB", path);
	584	}
	585	}
	586
	587	return iResult;
	588	}
618f422f	589	void AliHLTITSClusterFinderComponent::RecPointToSpacePoint(AliHLTUInt8_t* outputPtr,AliHLTUInt32_t& size){
	590	AliHLTITSClusterData outputClusters = reinterpret_cast<AliHLTITSClusterData>(outputPtr + size);
	591	outputClusters->fSpacePointCnt=fclusters.size();
	592	int clustIdx=0;
565c81f8	593	for(UInt_t i=0;i<fclusters.size();i++){
618f422f	594	AliITSRecPoint recpoint = (AliITSRecPoint) &(fclusters[i]);
	595	outputClusters->fSpacePoints[clustIdx].fY=recpoint->GetY();
	596	outputClusters->fSpacePoints[clustIdx].fZ=recpoint->GetZ();
	597	outputClusters->fSpacePoints[clustIdx].fSigmaY2=recpoint->GetSigmaY2();
	598	outputClusters->fSpacePoints[clustIdx].fSigmaZ2=recpoint->GetSigmaZ2();
	599	outputClusters->fSpacePoints[clustIdx].fSigmaYZ=recpoint->GetSigmaYZ();
	600	outputClusters->fSpacePoints[clustIdx].fQ=recpoint->GetQ();
	601	outputClusters->fSpacePoints[clustIdx].fNy=recpoint->GetNy();
	602	outputClusters->fSpacePoints[clustIdx].fNz=recpoint->GetNz();
	603	outputClusters->fSpacePoints[clustIdx].fLayer=recpoint->GetLayer();
	604	outputClusters->fSpacePoints[clustIdx].fIndex=recpoint->GetDetectorIndex() \| recpoint->GetPindex() \| recpoint->GetNindex();
	605	outputClusters->fSpacePoints[clustIdx].fTracks[0]=recpoint->GetLabel(0);
	606	outputClusters->fSpacePoints[clustIdx].fTracks[1]=recpoint->GetLabel(1);
	607	outputClusters->fSpacePoints[clustIdx].fTracks[2]=recpoint->GetLabel(2);
	608	clustIdx++;
	609	}
	610	}