[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCCFComparisonComponent.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   AliHLTTPCCFComparisonComponent.cxx
    @author Kalliopi Kanaki
    @date   
    @brief  A comparison component for FCF and SCF properties
*/

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

#include "AliHLTTPCCFComparisonComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCMemHandler.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTGlobalBarrelTrack.h"
#include "AliHLTExternalTrackParam.h"
#include "AliHLTDataTypes.h"

#include <TFile.h>
#include <TString.h>
#include "TNtuple.h"
#include "TH1F.h"
#include "TObjString.h"
#include "TObjArray.h"

#include "AliHLTTPCTrack.h"


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

AliHLTTPCCFComparisonComponent::AliHLTTPCCFComparisonComponent()
    :
    fEvtMod(20)
  , fBufferSize(5000)
  , fMultiplicity(NULL)
  , fClusters(NULL)
  , fTracks(NULL)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  for(int i=0; i<36; i++){
     for(int j=0; j<6; j++){
         fSCFClustersArray[i][j] = NULL;
         fSCFNSpacePoints[i][j]  = 0;     
         fFCFClustersArray[i][j] = NULL;
         fFCFNSpacePoints[i][j]  = 0;     
     }  
  }
}

const char* AliHLTTPCCFComparisonComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCCFComparison";

AliHLTTPCCFComparisonComponent::~AliHLTTPCCFComparisonComponent(){
// see header file for class documentation
  for(int i=0; i<36; i++){
     for(int j=0; j<6; j++){
         delete[] fSCFClustersArray[i][j];
         fSCFClustersArray[i][j] = NULL;         
         delete[] fSCFClustersArray[i][j];
         fSCFClustersArray[i][j] = NULL;         
     }  
  }
}

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

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

void AliHLTTPCCFComparisonComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list){
// see header file for class documentation
  
  list.clear();
  list.push_back(AliHLTTPCDefinitions::fgkClustersDataType|kAliHLTDataOriginTPC);
  list.push_back(AliHLTTPCDefinitions::fgkAlterClustersDataType|kAliHLTDataOriginTPC);
  list.push_back(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);  
}

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

int AliHLTTPCCFComparisonComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList){
// see header file for class documentation
  tgtList.clear();
  tgtList.push_back(kAliHLTDataTypeTNtuple|kAliHLTDataOriginTPC);
  tgtList.push_back(kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC);
  return tgtList.size();
}

void AliHLTTPCCFComparisonComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ){
// see header file for class documentation
  
  constBase = 5000;
  inputMultiplier = 1;// XXX TODO: Find more realistic value
}

AliHLTComponent* AliHLTTPCCFComparisonComponent::Spawn(){
// see header file for class documentation
  return new AliHLTTPCCFComparisonComponent;
}

int AliHLTTPCCFComparisonComponent::DoInit( int argc, const char** argv ){
// see header file for class documentation
 
  fClusters = new TNtuple("fClusters", "fClusters", "charge:qmax:residualY:residualZ"); 
  fTracks   = new TNtuple("fTracks",  "fTracks",  "pt:eta:psi:nclusters"); 
 
  fClusters->SetCircular(fBufferSize);
  fTracks->SetCircular(fBufferSize);
 
  fMultiplicity = new TH1F("fMultiplicity","Track multiplicity per event", 1000, 0, 1000);
  
  
  // first configure the default
  int iResult=0;
  if (iResult>=0) iResult=ConfigureFromCDBTObjString(fgkOCDBEntry);

  // configure from the command line parameters if specified
  if (iResult>=0 && argc>0)  iResult=ConfigureFromArgumentString(argc, argv);
  
  return iResult;
}
  
int AliHLTTPCCFComparisonComponent::DoDeinit(){
// see header file for class documentation
  
  delete fClusters;
  delete fTracks;
  delete fMultiplicity;
  
  return 0;
}

int AliHLTTPCCFComparisonComponent::Reconfigure(const char* cdbEntry, const char* /*chainId*/){
// see header file for class documentation

  // configure from the specified antry or the default one
  const char* entry=cdbEntry;
  if (!entry || entry[0]==0) {
     entry=fgkOCDBEntry;
  }
  return ConfigureFromCDBTObjString(entry);
}


int AliHLTTPCCFComparisonComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/){
// see header file for class documentation

  if(GetFirstInputBlock(kAliHLTDataTypeSOR) || GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;  

  const AliHLTComponentBlockData *iter = NULL;
  
  for(int i=0; i<36; i++){
     for(int j=0; j<6; j++){
         fSCFClustersArray[i][j] = NULL;
         fSCFNSpacePoints[i][j]  = 0;     
         fFCFClustersArray[i][j] = NULL;
         fFCFNSpacePoints[i][j]  = 0;     
     }  
  }
 
 
  //----------------- loop over SCF output blocks ---------------------//
  
  //Int_t totalSpacePoints = 0;
  
  for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
            
      if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType) continue;

      AliHLTUInt8_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
      AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
      //HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);

      const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
      Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;    
      //totalSpacePoints += nSpacepoint;
      HLTDebug("TPCCFComparison component found %d SCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
      
      AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
      
      if(fSCFClustersArray[minSlice][minPartition] != NULL){
         delete(fSCFClustersArray[minSlice][minPartition]); 
         fSCFClustersArray[minSlice][minPartition] = NULL;
      }      

      fSCFClustersArray[minSlice][minPartition] = clusters;
      fSCFNSpacePoints[minSlice][minPartition]  = nSpacepoint;
      
      HLTInfo("SCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);   
      
      // Here are all the cluster data you can use:
              
      //Float_t fX;	   // X coordinate in local coordinates
      //Float_t fY;	   // Y coordinate in local coordinates
      //Float_t fZ;	   // Z coordinate in local coordinates
      //UInt_t fID;	   // contains slice patch and number
      //UChar_t fPadRow;  // Pad row number
      //Float_t fSigmaY2; // error (former width) of the clusters
      //Float_t fSigmaZ2; // error (former width) of the clusters
      //UInt_t fCharge;   // total charge of cluster
      //UInt_t fQMax;     // QMax of cluster
  
      
      if(nSpacepoint==0) fSCFClustersArray[minSlice][minPartition] = NULL;

  } // end of loop over cluster data blocks
  
  //HLTDebug("TPCCFComparison found %d spacepoints",totalSpacePoints);
  
  
  //----------------- loop over FCF output blocks ---------------------//
  
  
  for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkAlterClustersDataType); iter != NULL; iter = GetNextInputBlock()){
            
      if(iter->fDataType!=AliHLTTPCDefinitions::fgkAlterClustersDataType) continue;

      AliHLTUInt8_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
      AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
      //HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);

      const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
      Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;    
      //totalSpacePoints += nSpacepoint;
      HLTDebug("TPCCFComparison component found %d FCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
      
      AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*)clusterData->fSpacePoints;
      
      if(fFCFClustersArray[minSlice][minPartition] != NULL){
         delete(fFCFClustersArray[minSlice][minPartition]); 
         fFCFClustersArray[minSlice][minPartition] = NULL;
      }      

      fFCFClustersArray[minSlice][minPartition] = clusters;
      fFCFNSpacePoints[minSlice][minPartition]  = nSpacepoint;
           
      HLTInfo("FCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);  
      
      if(nSpacepoint==0) fFCFClustersArray[minSlice][minPartition] = NULL;

  } // end of loop over cluster data blocks
  
  
  //----------------- loop over merged tracks -------------------//

//   Int_t totalTracks = 0;
//   
//   for(iter = GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){    
//       if(iter->fDataType != (kAliHLTDataTypeTrack|kAliHLTDataOriginTPC)) continue; 
//       ReadTracks(iter,totalTracks);
//   }
//   
//   HLTDebug("TrackHisto found %d tracks", totalTracks);  
// 
//   fMultiplicity->Fill(totalTracks);
// 
//   PushHisto();
  
  return 0;
} // end of DoEvent
 
// void AliHLTTPCCFComparisonComponent::ReadTracks(const AliHLTComponentBlockData* iter,Int_t &tt){
// // see header file for class documentation
// 
//   //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
//   
//   Int_t usedSpacePoints = 0;
//   
//   vector<AliHLTGlobalBarrelTrack> tracksVector;
//   AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(iter->fPtr), iter->fSize, tracksVector);
//   
//   tt = tracksVector.size();
//   
//   for(vector<AliHLTGlobalBarrelTrack>::iterator element=tracksVector.begin();  element!=tracksVector.end(); element++){
//        
//   
// 
//            
//        UInt_t nHits = element->GetNumberOfPoints();
//        fTracks->Fill( 1./element->OneOverPt(), element->GetSnp(), element->GetTgl(), nHits );  
//        //fdNdEta->Fill(element->GetSnp());
//  
//        Double_t totCharge = 0;
//        const UInt_t *hitnum = element->GetPoints();
//        for(UInt_t i=0; i<element->GetNumberOfPoints(); i++){
//            
//       	   UInt_t idTrack   = hitnum[i];
//            Int_t sliceTrack = AliHLTTPCSpacePointData::GetSlice(idTrack);
//            Int_t patchTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
//            UInt_t pos	    = AliHLTTPCSpacePointData::GetNumber(idTrack);
// 	   
// 	   //printf("KKKK pos :%d\n", pos);
// 	   cout << "KKKK pos  " << pos << endl;
// 
//            if( !fClustersArray[sliceTrack][patchTrack] ) continue;	       
//       	   
//       	   if(sliceTrack<0 || sliceTrack>36 || patchTrack<0 || patchTrack>5 ){
//       	      HLTError("Corrupted TPC cluster Id: slice %d, patch %d, cluster %d", sliceTrack, patchTrack, idTrack);
//       	      continue;
//       	   }
// 
//            if(fNSpacePoints[sliceTrack][patchTrack]<=pos ){
//       	      HLTError("Space point array out of boundaries!");
//       	      continue;
//            }
//       	   
//       	   totCharge += (fClustersArray[sliceTrack][patchTrack])[pos].fCharge; 
//       	   
//       	   //Float_t xyz[3]; xyz[0] = xyz[1] = xyz[2] = 0.;
//         
//            //xyz[0] = (fClustersArray[sliceTrack][patchTrack])[pos].fX;
//            //xyz[1] = (fClustersArray[sliceTrack][patchTrack])[pos].fY;
//            //xyz[2] = (fClustersArray[sliceTrack][patchTrack])[pos].fZ;
//         
//            //AliHLTTPCTransform::Local2Global(xyz,slice); 
//       	   
//       	   //Double_t p[2]   = { xyz[1], xyz[2] };
//            //Double_t cov[3] = { (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaY2, 0., (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaZ2};  
//       	   //Double_t *res = element->GetResiduals(p,cov,kFALSE); 
//       	   
//       	   //HLTInfo("resy: %f, resz: %f", res[0], res[1]);
//       	   
//       	   //if(!res)  res[0] = res[1] = -1000.;
//       	   //else      fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, res[0], res[1]);
//       	  
//       	   fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, -1000., -1000.);
//             
//       	   usedSpacePoints++;	   
//        }	
// 
//   }
// }

// void AliHLTTPCCFComparisonComponent::PushHisto(){
// // see header file for class documentation
//     
//     PushBack( (TObject*)fTracks,       kAliHLTDataTypeTNtuple  |kAliHLTDataOriginTPC, 0x0);   
//     PushBack( (TObject*)fClusters,     kAliHLTDataTypeTNtuple  |kAliHLTDataOriginTPC, 0x0);
//     PushBack( (TObject*)fMultiplicity, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, 0x0);
// }

int AliHLTTPCCFComparisonComponent::ScanConfigurationArgument(int argc, const char** argv){
// see header file for class documentation
 
  if (argc<=0) return 0;
  int i=0;
  TString argument=argv[i];

  // -event-modulo
  if (argument.CompareTo("-event-modulo")==0) {
    if (++i>=argc) return -EPROTO;
    argument=argv[i];
    fEvtMod=argument.Atoi();
    return 2;
  }    

  // -buffer-size
  if (argument.CompareTo("-buffer-size")==0) {
    if (++i>=argc) return -EPROTO;
    argument=argv[i];
    fBufferSize=argument.Atoi();
    return 2;
  }    
   
  return -EINVAL;
}

void AliHLTTPCCFComparisonComponent::GetOCDBObjectDescription( TMap* const targetMap){
// Get a list of OCDB object description needed for the particular component
  if (!targetMap) return;
  targetMap->Add(new TObjString("HLT/ConfigTPC/TPCCFComparison"), new TObjString("component arguments for setting the size of the filled ntuples and the event modulo for the mean multiplicity distribution"));
}
Commit	Line	Data
cfe8311c	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: 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 AliHLTTPCCFComparisonComponent.cxx
	20	@author Kalliopi Kanaki
	21	@date
	22	@brief A comparison component for FCF and SCF properties
	23	*/
	24
	25	#if __GNUC__>= 3
	26	using namespace std;
	27	#endif
	28
	29	#include "AliHLTTPCCFComparisonComponent.h"
	30	#include "AliHLTTPCTransform.h"
	31	#include "AliHLTTPCClusterDataFormat.h"
	32	#include "AliHLTTPCTrackletDataFormat.h"
	33	#include "AliHLTTPCMemHandler.h"
	34	#include "AliHLTTPCDefinitions.h"
	35	#include "AliHLTGlobalBarrelTrack.h"
	36	#include "AliHLTExternalTrackParam.h"
	37	#include "AliHLTDataTypes.h"
	38
	39	#include <TFile.h>
	40	#include <TString.h>
	41	#include "TNtuple.h"
	42	#include "TH1F.h"
	43	#include "TObjString.h"
	44	#include "TObjArray.h"
	45
	46	#include "AliHLTTPCTrack.h"
	47
	48
	49	/** ROOT macro for the implementation of ROOT specific class methods */
	50	ClassImp(AliHLTTPCCFComparisonComponent)
	51
	52	AliHLTTPCCFComparisonComponent::AliHLTTPCCFComparisonComponent()
	53	:
	54	fEvtMod(20)
	55	, fBufferSize(5000)
	56	, fMultiplicity(NULL)
	57	, fClusters(NULL)
	58	, fTracks(NULL)
	59	{
	60	// see header file for class documentation
	61	// or
	62	// refer to README to build package
	63	// or
	64	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
65	for(int i=0; i<36; i++){
66	for(int j=0; j<6; j++){
67	fSCFClustersArray[i][j] = NULL;
68	fSCFNSpacePoints[i][j] = 0;
69	fFCFClustersArray[i][j] = NULL;
70	fFCFNSpacePoints[i][j] = 0;
71	}
72	}
73	}
74
75	const char* AliHLTTPCCFComparisonComponent::fgkOCDBEntry="HLT/ConfigTPC/TPCCFComparison";
76
77	AliHLTTPCCFComparisonComponent::~AliHLTTPCCFComparisonComponent(){
78	// see header file for class documentation
79	for(int i=0; i<36; i++){
80	for(int j=0; j<6; j++){
81	delete[] fSCFClustersArray[i][j];
82	fSCFClustersArray[i][j] = NULL;
83	delete[] fSCFClustersArray[i][j];
84	fSCFClustersArray[i][j] = NULL;
85	}
86	}
87	}
88
89	// Public functions to implement AliHLTComponent's interface.
90	// These functions are required for the registration process
91
92	const char* AliHLTTPCCFComparisonComponent::GetComponentID(){
93	// see header file for class documentation
94
95	return "TPCCFComparison";
96	}
97
98	void AliHLTTPCCFComparisonComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list){
99	// see header file for class documentation
100
101	list.clear();
102	list.push_back(AliHLTTPCDefinitions::fgkClustersDataType\|kAliHLTDataOriginTPC);
103	list.push_back(AliHLTTPCDefinitions::fgkAlterClustersDataType\|kAliHLTDataOriginTPC);
104	list.push_back(kAliHLTDataTypeTrack\|kAliHLTDataOriginTPC);
105	}
106
107	AliHLTComponentDataType AliHLTTPCCFComparisonComponent::GetOutputDataType(){
108	// see header file for class documentation
109	return kAliHLTMultipleDataType;
110	}
111
112	int AliHLTTPCCFComparisonComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList){
113	// see header file for class documentation
114	tgtList.clear();
115	tgtList.push_back(kAliHLTDataTypeTNtuple\|kAliHLTDataOriginTPC);
116	tgtList.push_back(kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC);
117	return tgtList.size();
118	}
119
120	void AliHLTTPCCFComparisonComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ){
121	// see header file for class documentation
122
123	constBase = 5000;
124	inputMultiplier = 1;// XXX TODO: Find more realistic value
125	}
126
127	AliHLTComponent* AliHLTTPCCFComparisonComponent::Spawn(){
128	// see header file for class documentation
129	return new AliHLTTPCCFComparisonComponent;
130	}
131
132	int AliHLTTPCCFComparisonComponent::DoInit( int argc, const char** argv ){
133	// see header file for class documentation
134
135	fClusters = new TNtuple("fClusters", "fClusters", "charge:qmax:residualY:residualZ");
136	fTracks = new TNtuple("fTracks", "fTracks", "pt:eta:psi:nclusters");
137
138	fClusters->SetCircular(fBufferSize);
139	fTracks->SetCircular(fBufferSize);
140
141	fMultiplicity = new TH1F("fMultiplicity","Track multiplicity per event", 1000, 0, 1000);
142
143
144	// first configure the default
145	int iResult=0;
146	if (iResult>=0) iResult=ConfigureFromCDBTObjString(fgkOCDBEntry);
147
148	// configure from the command line parameters if specified
149	if (iResult>=0 && argc>0) iResult=ConfigureFromArgumentString(argc, argv);
150
151	return iResult;
152	}
153
154	int AliHLTTPCCFComparisonComponent::DoDeinit(){
155	// see header file for class documentation
156
157	delete fClusters;
158	delete fTracks;
159	delete fMultiplicity;
160
161	return 0;
162	}
163
164	int AliHLTTPCCFComparisonComponent::Reconfigure(const char* cdbEntry, const char* /chainId/){
165	// see header file for class documentation
166
167	// configure from the specified antry or the default one
168	const char* entry=cdbEntry;
169	if (!entry \|\| entry[0]==0) {
170	entry=fgkOCDBEntry;
171	}
172	return ConfigureFromCDBTObjString(entry);
173	}
174
175
176	int AliHLTTPCCFComparisonComponent::DoEvent(const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/){
177	// see header file for class documentation
178
179	if(GetFirstInputBlock(kAliHLTDataTypeSOR) \|\| GetFirstInputBlock(kAliHLTDataTypeEOR)) return 0;
180
181	const AliHLTComponentBlockData *iter = NULL;
182
183	for(int i=0; i<36; i++){
184	for(int j=0; j<6; j++){
185	fSCFClustersArray[i][j] = NULL;
186	fSCFNSpacePoints[i][j] = 0;
187	fFCFClustersArray[i][j] = NULL;
188	fFCFNSpacePoints[i][j] = 0;
189	}
190	}
191
192
193	//----------------- loop over SCF output blocks ---------------------//
194
195	//Int_t totalSpacePoints = 0;
196
197	for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock()){
198
199	if(iter->fDataType!=AliHLTTPCDefinitions::fgkClustersDataType) continue;
200
201	AliHLTUInt8_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
202	AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
203	//HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);
204
205	const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
206	Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;
207	//totalSpacePoints += nSpacepoint;
208	HLTDebug("TPCCFComparison component found %d SCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
209
210	AliHLTTPCSpacePointData clusters = (AliHLTTPCSpacePointData)clusterData->fSpacePoints;
211
212	if(fSCFClustersArray[minSlice][minPartition] != NULL){
213	delete(fSCFClustersArray[minSlice][minPartition]);
214	fSCFClustersArray[minSlice][minPartition] = NULL;
215	}
216
217	fSCFClustersArray[minSlice][minPartition] = clusters;
218	fSCFNSpacePoints[minSlice][minPartition] = nSpacepoint;
219
220	HLTInfo("SCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);
221
222	// Here are all the cluster data you can use:
223
224	//Float_t fX; // X coordinate in local coordinates
225	//Float_t fY; // Y coordinate in local coordinates
226	//Float_t fZ; // Z coordinate in local coordinates
227	//UInt_t fID; // contains slice patch and number
228	//UChar_t fPadRow; // Pad row number
229	//Float_t fSigmaY2; // error (former width) of the clusters
230	//Float_t fSigmaZ2; // error (former width) of the clusters
231	//UInt_t fCharge; // total charge of cluster
232	//UInt_t fQMax; // QMax of cluster
233
234
235	if(nSpacepoint==0) fSCFClustersArray[minSlice][minPartition] = NULL;
236
237	} // end of loop over cluster data blocks
238
239	//HLTDebug("TPCCFComparison found %d spacepoints",totalSpacePoints);
240
241
242	//----------------- loop over FCF output blocks ---------------------//
243
244
245	for(iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkAlterClustersDataType); iter != NULL; iter = GetNextInputBlock()){
246
247	if(iter->fDataType!=AliHLTTPCDefinitions::fgkAlterClustersDataType) continue;
248
249	AliHLTUInt8_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
250	AliHLTUInt8_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(*iter);
251	//HLTDebug("Input Data - TPC cluster - slice/partition: %d/%d.", minSlice, minPartition);
252
253	const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*)iter->fPtr;
254	Int_t nSpacepoint = (Int_t)clusterData->fSpacePointCnt;
255	//totalSpacePoints += nSpacepoint;
256	HLTDebug("TPCCFComparison component found %d FCF spacepoints in slice %d partition %d", nSpacepoint, minSlice, minPartition);
257
258	AliHLTTPCSpacePointData clusters = (AliHLTTPCSpacePointData)clusterData->fSpacePoints;
259
260	if(fFCFClustersArray[minSlice][minPartition] != NULL){
261	delete(fFCFClustersArray[minSlice][minPartition]);
262	fFCFClustersArray[minSlice][minPartition] = NULL;
263	}
264
265	fFCFClustersArray[minSlice][minPartition] = clusters;
266	fFCFNSpacePoints[minSlice][minPartition] = nSpacepoint;
267
268	HLTInfo("FCF cluster loop charge %d, slice %d partition %d\n", (UInt_t)clusters->fCharge, minSlice, minPartition);
269
270	if(nSpacepoint==0) fFCFClustersArray[minSlice][minPartition] = NULL;
271
272	} // end of loop over cluster data blocks
273
274
275
276	//----------------- loop over merged tracks -------------------//
277
278	// Int_t totalTracks = 0;
279	//
280	// for(iter = GetFirstInputBlock(kAliHLTDataTypeTrack\|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputBlock()){
281	// if(iter->fDataType != (kAliHLTDataTypeTrack\|kAliHLTDataOriginTPC)) continue;
282	// ReadTracks(iter,totalTracks);
283	// }
284	//
285	// HLTDebug("TrackHisto found %d tracks", totalTracks);
286	//
287	// fMultiplicity->Fill(totalTracks);
288	//
289	// PushHisto();
290
291	return 0;
292	} // end of DoEvent
293
294	// void AliHLTTPCCFComparisonComponent::ReadTracks(const AliHLTComponentBlockData* iter,Int_t &tt){
295	// // see header file for class documentation
296	//
297	// //AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(*iter);
298	//
299	// Int_t usedSpacePoints = 0;
300	//
301	// vector<AliHLTGlobalBarrelTrack> tracksVector;
302	// AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(iter->fPtr), iter->fSize, tracksVector);
303	//
304	// tt = tracksVector.size();
305	//
306	// for(vector<AliHLTGlobalBarrelTrack>::iterator element=tracksVector.begin(); element!=tracksVector.end(); element++){
307	//
308	//
309	//
310	//
311	// UInt_t nHits = element->GetNumberOfPoints();
312	// fTracks->Fill( 1./element->OneOverPt(), element->GetSnp(), element->GetTgl(), nHits );
313	// //fdNdEta->Fill(element->GetSnp());
314	//
315	// Double_t totCharge = 0;
316	// const UInt_t *hitnum = element->GetPoints();
317	// for(UInt_t i=0; i<element->GetNumberOfPoints(); i++){
318	//
319	// UInt_t idTrack = hitnum[i];
a371a266	320	// Int_t sliceTrack = AliHLTTPCSpacePointData::GetSlice(idTrack);
	321	// Int_t patchTrack = AliHLTTPCSpacePointData::GetPatch(idTrack);
	322	// UInt_t pos = AliHLTTPCSpacePointData::GetNumber(idTrack);
cfe8311c	323	//
	324	// //printf("KKKK pos :%d\n", pos);
	325	// cout << "KKKK pos " << pos << endl;
	326	//
	327	// if( !fClustersArray[sliceTrack][patchTrack] ) continue;
	328	//
	329	// if(sliceTrack<0 \|\| sliceTrack>36 \|\| patchTrack<0 \|\| patchTrack>5 ){
	330	// HLTError("Corrupted TPC cluster Id: slice %d, patch %d, cluster %d", sliceTrack, patchTrack, idTrack);
	331	// continue;
	332	// }
	333	//
	334	// if(fNSpacePoints[sliceTrack][patchTrack]<=pos ){
	335	// HLTError("Space point array out of boundaries!");
	336	// continue;
	337	// }
	338	//
	339	// totCharge += (fClustersArray[sliceTrack][patchTrack])[pos].fCharge;
	340	//
	341	// //Float_t xyz[3]; xyz[0] = xyz[1] = xyz[2] = 0.;
	342	//
	343	// //xyz[0] = (fClustersArray[sliceTrack][patchTrack])[pos].fX;
	344	// //xyz[1] = (fClustersArray[sliceTrack][patchTrack])[pos].fY;
	345	// //xyz[2] = (fClustersArray[sliceTrack][patchTrack])[pos].fZ;
	346	//
	347	// //AliHLTTPCTransform::Local2Global(xyz,slice);
	348	//
	349	// //Double_t p[2] = { xyz[1], xyz[2] };
	350	// //Double_t cov[3] = { (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaY2, 0., (fClustersArray[sliceTrack][patchTrack])[pos].fSigmaZ2};
	351	// //Double_t *res = element->GetResiduals(p,cov,kFALSE);
	352	//
	353	// //HLTInfo("resy: %f, resz: %f", res[0], res[1]);
	354	//
	355	// //if(!res) res[0] = res[1] = -1000.;
	356	// //else fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, res[0], res[1]);
	357	//
	358	// fClusters->Fill( (fClustersArray[sliceTrack][patchTrack])[pos].fCharge, (fClustersArray[sliceTrack][patchTrack])[pos].fQMax, -1000., -1000.);
	359	//
	360	// usedSpacePoints++;
	361	// }
	362	//
	363	// }
	364	// }
	365
	366	// void AliHLTTPCCFComparisonComponent::PushHisto(){
	367	// // see header file for class documentation
	368	//
	369	// PushBack( (TObject*)fTracks, kAliHLTDataTypeTNtuple \|kAliHLTDataOriginTPC, 0x0);
	370	// PushBack( (TObject*)fClusters, kAliHLTDataTypeTNtuple \|kAliHLTDataOriginTPC, 0x0);
	371	// PushBack( (TObject*)fMultiplicity, kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC, 0x0);
	372	// }
	373
	374	int AliHLTTPCCFComparisonComponent::ScanConfigurationArgument(int argc, const char** argv){
	375	// see header file for class documentation
	376
	377	if (argc<=0) return 0;
	378	int i=0;
	379	TString argument=argv[i];
	380
	381	// -event-modulo
	382	if (argument.CompareTo("-event-modulo")==0) {
	383	if (++i>=argc) return -EPROTO;
	384	argument=argv[i];
a89de822	385	fEvtMod=argument.Atoi();
cfe8311c	386	return 2;
	387	}
	388
	389	// -buffer-size
	390	if (argument.CompareTo("-buffer-size")==0) {
	391	if (++i>=argc) return -EPROTO;
	392	argument=argv[i];
a89de822	393	fBufferSize=argument.Atoi();
cfe8311c	394	return 2;
	395	}
	396
	397	return -EINVAL;
	398	}
	399
	400	void AliHLTTPCCFComparisonComponent::GetOCDBObjectDescription( TMap* const targetMap){
	401	// Get a list of OCDB object description needed for the particular component
	402	if (!targetMap) return;
	403	targetMap->Add(new TObjString("HLT/ConfigTPC/TPCCFComparison"), new TObjString("component arguments for setting the size of the filled ntuples and the event modulo for the mean multiplicity distribution"));
	404	}