// @(#) $Id$
// Original: AliHLTClustFinderNew.cxx,v 1.29 2005/06/14 10:55:21 cvetan Exp
-/**************************************************************************
- * This file is property of and copyright by the ALICE HLT Project *
- * ALICE Experiment at CERN, All rights reserved. *
- * *
- * Primary Authors: Kenneth Aamodt, Kalliopi Kanaki *
- * 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 AliHLTTPCClusterFinder.cxx
- @author Kenneth Aamodt, Kalliopi Kanaki
- @date
- @brief Cluster Finder for the TPC
-*/
+//**************************************************************************
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* *
+//* Primary Authors: Anders Vestbo, Constantin Loizides *
+//* Developers: Kenneth Aamodt <kenneth.aamodt@student.uib.no> *
+//* Kalliopi Kanaki *
+//* 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 AliHLTTPCClusterFinder.cxx
+// @author Kenneth Aamodt, Kalliopi Kanaki
+// @date
+// @brief Cluster Finder for the TPC
+// @note
#include "AliHLTTPCDigitReader.h"
#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCClusterFinder.h"
-#include "AliHLTTPCDigitData.h"
-#include "AliHLTTPCTransform.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCMemHandler.h"
#include "AliHLTTPCPad.h"
#include <sys/time.h>
+#include <algorithm>
+#include <cmath>
+#include "AliTPCcalibDB.h"
+#include "AliTPCTransform.h"
+#include "AliTPCParam.h"
#if __GNUC__ >= 3
using namespace std;
#endif
-/** \class AliHLTTPCClusterFinder
-//
-// The current cluster finder for HLT
-// (Based on STAR L3)
-//
-//Basically we have two versions for the cluster finder now.
-//The default version, reads the data pad by pad, and find the
-//clusters as it reads the data. The other version has now been
-//developed to cope with unsorted data. New methods for the unsorted
-//version can be found at the end of the default one i the source file.
-//Currently the new version is only build to manage zero-suppressed data.
-//More functionality will be added later.
-//
-// The cluster finder is initialized with the Init function,
-// providing the slice and patch information to work on.
-//
-// The input is a provided by the AliHLTTPCDigitReader class,
-// using the init() funktion, and the next() funktion in order
-// to get the next bin. Either packed or unpacked data can be
-// processed, dependent if one uses AliHLTTPCDigitReaderPacked
-// class or AliHLTTPCDigitReaderUnpacked class in the
-// Clusterfinder Component.
-// The resulting space points will be in the
-// array given by the SetOutputArray function.
-//
-// There are several setters which control the behaviour:
-//
-// - SetXYError(Float_t): set fixed error in XY direction
-// - SetZError(Float_t): set fixed error in Z direction
-// (used if errors are not calculated)
-// - SetDeconv(Bool_t): switch on/off deconvolution
-// - SetThreshold(UInt_t): set charge threshold for cluster
-// - SetMatchWidth(UInt_t): set the match distance in
-// time for sequences to be merged
-// - SetSTDOutput(Bool_t): switch on/off output about found clusters
-// - SetCalcErr(Bool_t): switch on/off calculation of
-// space point errors (or widths in raw system)
-// - SetRawSP(Bool_t): switch on/off convertion to raw system
-//
-//
-// Example Usage:
-//
-// AliHLTTPCFileHandler *file = new AliHLTTPCFileHandler();
-// file->SetAliInput(digitfile); //give some input file
-// for(int slice=0; slice<=35; slice++){
-// for(int patch=0; pat<6; pat++){
-// file->Init(slice,patch);
-// UInt_t ndigits=0;
-// UInt_t maxclusters=100000;
-// UInt_t pointsize = maxclusters*sizeof(AliHLTTPCSpacePointData);
-// AliHLTTPCSpacePointData *points = (AliHLTTPCSpacePointData*)memory->Allocate(pointsize);
-// AliHLTTPCDigitRowData *digits = (AliHLTTPCDigitRowData*)file->AliAltroDigits2Memory(ndigits,event);
-// AliHLTTPCClusterFinder *cf = new AliHLTTPCClusterFinder();
-// cf->SetMatchWidth(2);
-// cf->InitSlice( slice, patch, row[0], row[1], maxPoints );
-// cf->SetSTDOutput(kTRUE); //Some output to standard IO
-// cf->SetRawSP(kFALSE); //Convert space points to local system
-// cf->SetThreshold(5); //Threshold of cluster charge
-// cf->SetDeconv(kTRUE); //Deconv in pad and time direction
-// cf->SetCalcErr(kTRUE); //Calculate the errors of the spacepoints
-// cf->SetOutputArray(points); //Move the spacepoints to the array
-// cf->Read(iter->fPtr, iter->fSize ); //give the data to the cf
-// cf->ProcessDigits(); //process the rows given by init
-// Int_t npoints = cf->GetNumberOfClusters();
-// AliHLTTPCMemHandler *out= new AliHLTTPCMemHandler();
-// out->SetBinaryOutput(fname);
-// out->Memory2Binary(npoints,points); //store the spacepoints
-// out->CloseBinaryOutput();
-// delete out;
-// file->free();
-// delete cf;
-// }
-// }
-*/
-
ClassImp(AliHLTTPCClusterFinder)
AliHLTTPCClusterFinder::AliHLTTPCClusterFinder()
:
+ fClustersHWAddressVector(),
+ fRowPadVector(),
fSpacePointData(NULL),
fDigitReader(NULL),
fPtr(NULL),
fSize(0),
- fDeconvTime(kTRUE),
- fDeconvPad(kTRUE),
+ fDeconvTime(kFALSE),
+ fDeconvPad(kFALSE),
fStdout(kFALSE),
fCalcerr(kTRUE),
fRawSP(kFALSE),
fCurrentPatch(0),
fMatch(1),
fThreshold(10),
- fSignalThreshold(-1),
- fNSigmaThreshold(0),
fNClusters(0),
fMaxNClusters(0),
fXYErr(0.2),
fOccupancyLimit(1.0),
fUnsorted(0),
fVectorInitialized(kFALSE),
- fRowPadVector(),
fClusters(),
+ fClustersMCInfo(),
+ fMCDigits(),
fNumberOfPadsInRow(NULL),
fNumberOfRows(0),
- fRowOfFirstCandidate(0)
+ fRowOfFirstCandidate(0),
+ fDoPadSelection(kFALSE),
+ fFirstTimeBin(0),
+ fLastTimeBin(AliHLTTPCTransform::GetNTimeBins()),
+ fTotalChargeOfPreviousClusterCandidate(0),
+ fChargeOfCandidatesFalling(kFALSE),
+ f32BitFormat(kFALSE),
+ fDoMC(kFALSE),
+ fClusterMCVector(),
+ fOfflineTransform(NULL),
+ fOfflineTPCParam( NULL ),
+ fOfflineTPCRecoParam(*AliTPCRecoParam::GetHLTParam()),
+ fTimeMeanDiff(2),
+ fReleaseMemory(0)
{
//constructor
+
+ //uptate the transform class
+
+ fOfflineTransform = AliTPCcalibDB::Instance()->GetTransform();
+ if(!fOfflineTransform){
+ HLTError("AliHLTTPCClusterFinder()::UpdateCAlibDB:: Offline transform not in AliTPCcalibDB.");
+ }
+ else{
+ fOfflineTransform->SetCurrentRecoParam(&fOfflineTPCRecoParam);
+ }
+
+ fOfflineTPCParam = AliTPCcalibDB::Instance()->GetParameters();
+ if( !fOfflineTPCParam ){
+ HLTError("AliHLTTPCClusterFinder()::UpdateCAlibDB:: Offline TPC parameters not in AliTPCcalibDB.");
+ } else {
+ fOfflineTPCParam->Update();
+ fOfflineTPCParam->ReadGeoMatrices();
+ }
+
}
-AliHLTTPCClusterFinder::~AliHLTTPCClusterFinder()
-{
+AliHLTTPCClusterFinder::~AliHLTTPCClusterFinder(){
+ // see header file for class documentation
+
//destructor
if(fVectorInitialized){
DeInitializePadArray();
fNumberOfPadsInRow=NULL;
}
}
-
-void AliHLTTPCClusterFinder::InitSlice(Int_t slice,Int_t patch,Int_t firstrow, Int_t lastrow,Int_t nmaxpoints)
-{
+
+void AliHLTTPCClusterFinder::InitSlice(Int_t slice,Int_t patch,Int_t nmaxpoints){
+ // see header file for class documentation
+
//init slice
fNClusters = 0;
fMaxNClusters = nmaxpoints;
fCurrentSlice = slice;
fCurrentPatch = patch;
- fFirstRow = firstrow;
- fLastRow = lastrow;
+ fFirstRow=AliHLTTPCTransform::GetFirstRow(patch);
+ fLastRow=AliHLTTPCTransform::GetLastRow(patch);
+
+ fClusters.clear();
+ fClustersMCInfo.clear();
+ fMCDigits.clear();
+ fClusterMCVector.clear();
}
void AliHLTTPCClusterFinder::InitializePadArray(){
memset( fNumberOfPadsInRow, 0, sizeof(Int_t)*(fNumberOfRows));
+ fRowPadVector.clear();
+
for(UInt_t i=0;i<fNumberOfRows;i++){
fNumberOfPadsInRow[i]=AliHLTTPCTransform::GetNPads(i+fFirstRow);
AliHLTTPCPadVector tmpRow;
- for(UInt_t j=0;j<fNumberOfPadsInRow[i];j++){
+ for(UInt_t j=0;j<=fNumberOfPadsInRow[i];j++){
AliHLTTPCPad *tmpPad = new AliHLTTPCPad(2);
tmpPad->SetID(i,j);
tmpRow.push_back(tmpPad);
fVectorInitialized=kTRUE;
}
-Int_t AliHLTTPCClusterFinder::DeInitializePadArray()
-{
+Int_t AliHLTTPCClusterFinder::DeInitializePadArray(){
// see header file for class documentation
- for(UInt_t i=0;i<fNumberOfRows;i++){
- for(UInt_t j=0;j<fNumberOfPadsInRow[i];j++){
- delete fRowPadVector[i][j];
- fRowPadVector[i][j]=NULL;
+
+ if( fVectorInitialized ){
+ for(UInt_t i=0;i<fNumberOfRows;i++){
+ for(UInt_t j=0;j<=fNumberOfPadsInRow[i];j++){
+ delete fRowPadVector[i][j];
+ fRowPadVector[i][j]=NULL;
+ }
+ fRowPadVector[i].clear();
}
- fRowPadVector[i].clear();
+ fRowPadVector.clear();
+ delete[] fNumberOfPadsInRow;
+ fNumberOfPadsInRow = 0;
}
- fRowPadVector.clear();
+ fVectorInitialized=kFALSE;
return 1;
-}
-
-
-void AliHLTTPCClusterFinder::InitSlice(Int_t slice,Int_t patch,Int_t nmaxpoints)
-{
- //init slice
- fNClusters = 0;
- fMaxNClusters = nmaxpoints;
- fCurrentSlice = slice;
- fCurrentPatch = patch;
- fFirstRow=AliHLTTPCTransform::GetFirstRow(patch);
- fLastRow=AliHLTTPCTransform::GetLastRow(patch);
}
-void AliHLTTPCClusterFinder::SetOutputArray(AliHLTTPCSpacePointData *pt)
-{
+
+void AliHLTTPCClusterFinder::SetOutputArray(AliHLTTPCSpacePointData *pt){
+ // see header file for class documentation
//set pointer to output
fSpacePointData = pt;
}
+
+void AliHLTTPCClusterFinder::ReadDataUnsorted(void* ptr,unsigned long size){
+ // see header file for class documentation
+ //set input pointer
+ fPtr = (UChar_t*)ptr;
+ fSize = size;
+
+ if(!fVectorInitialized){
+ InitializePadArray();
+ }
+
+ if (fDigitReader->InitBlock(fPtr,fSize,fFirstRow,fLastRow,fCurrentPatch,fCurrentSlice)<0) {
+ HLTError("failed setting up digit reader (InitBlock)");
+ return;
+ }
+
+ while(fDigitReader->NextChannel()){
+ UInt_t row=fDigitReader->GetRow();
+ UInt_t pad=fDigitReader->GetPad();
+
+ if(row>=fRowPadVector.size()){
+ HLTError("Row number is to large: %d, max is %d",row,fRowPadVector.size()-1);
+ continue;
+ }
+ if(pad>=fRowPadVector[row].size()){
+ HLTError("Pad number is to large: %d, max is %d",pad,fRowPadVector[row].size());
+ continue;
+ }
+
+ while(fDigitReader->NextBunch()){
+ if(fDigitReader->GetBunchSize()>1){//to remove single timebin values, this will have to change at some point
+ UInt_t time = fDigitReader->GetTime();
+ if((Int_t)time>=fFirstTimeBin && (Int_t)time+fDigitReader->GetBunchSize()<=fLastTimeBin){
+ // Kenneth: 20-04-09. The following if have been added because of inconsistency in the 40 bit decoder and the 32 bit decoder.
+ // GetSignals() in the 40 bit decoder returns an array of UInt_t while the 32 bit one returns UShort_t
+ // The same is true for the function ReadDataUnsortedDeconvoluteTime() below.
+ // In addition the signals are organized in the opposite direction
+ if(f32BitFormat){
+ const UShort_t *bunchData= fDigitReader->GetSignalsShort();
+ AliHLTTPCClusters candidate;
+ for(Int_t i=fDigitReader->GetBunchSize()-1;i>=0;i--){
+ candidate.fTotalCharge+=bunchData[i];
+ candidate.fTime += time*bunchData[i];
+ candidate.fTime2 += time*time*bunchData[i];
+ if(bunchData[i]>candidate.fQMax){
+ candidate.fQMax=bunchData[i];
+ }
+ time++;
+ }
+ if(candidate.fTotalCharge>0){
+ candidate.fMean=candidate.fTime/candidate.fTotalCharge;
+ candidate.fPad=candidate.fTotalCharge*pad;
+ candidate.fPad2=candidate.fPad*pad;
+ candidate.fLastMergedPad=pad;
+ candidate.fRowNumber=row+fDigitReader->GetRowOffset();
+ }
+ if(fRowPadVector[row][pad] != NULL){
+ fRowPadVector[row][pad]->AddClusterCandidate(candidate);
+ }
+ }
+ else{
+ const UInt_t *bunchData= fDigitReader->GetSignals();
+ AliHLTTPCClusters candidate;
+ const AliHLTTPCDigitData* digits = NULL;
+ if(fDoMC && (digits = fDigitReader->GetBunchDigits())!=NULL){
+ for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
+ candidate.fTotalCharge+=bunchData[i];
+ candidate.fTime += time*bunchData[i];
+ candidate.fTime2 += time*time*bunchData[i];
+ if(bunchData[i]>candidate.fQMax){
+ candidate.fQMax=bunchData[i];
+ }
+ fMCDigits.push_back(digits[i]);
+ time++;
+ }
+ }
+ else{
+ for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
+ candidate.fTotalCharge+=bunchData[i];
+ candidate.fTime += time*bunchData[i];
+ candidate.fTime2 += time*time*bunchData[i];
+ if(bunchData[i]>candidate.fQMax){
+ candidate.fQMax=bunchData[i];
+ }
+ time++;
+ }
+ }
+ if(candidate.fTotalCharge>0){
+ candidate.fMean=candidate.fTime/candidate.fTotalCharge;
+ candidate.fPad=candidate.fTotalCharge*pad;
+ candidate.fPad2=candidate.fPad*pad;
+ candidate.fLastMergedPad=pad;
+ candidate.fRowNumber=row+fDigitReader->GetRowOffset();
+ }
+ if(fRowPadVector[row][pad] != NULL){
+ fRowPadVector[row][pad]->AddClusterCandidate(candidate);
+ if(fDoMC){
+ fRowPadVector[row][pad]->AddCandidateDigits(fMCDigits);
+ fMCDigits.clear();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+void AliHLTTPCClusterFinder::ReadDataUnsortedDeconvoluteTime(void* ptr,unsigned long size){
+ // see header file for class documentation
+
+ //set input pointer
+ fPtr = (UChar_t*)ptr;
+ fSize = size;
+
+ if(!fVectorInitialized){
+ InitializePadArray();
+ }
+
+ if (fDigitReader->InitBlock(fPtr,fSize,fFirstRow,fLastRow,fCurrentPatch,fCurrentSlice)<0) {
+ HLTError("failed setting up digit reader (InitBlock)");
+ return;
+ }
+
+ while(fDigitReader->NextChannel()){
+ UInt_t row=fDigitReader->GetRow();
+ UInt_t pad=fDigitReader->GetPad();
+
+ while(fDigitReader->NextBunch()){
+ if(fDigitReader->GetBunchSize()>1){//to remove single timebin values, this will have to change at some point
+ UInt_t time = fDigitReader->GetTime();
+ if((Int_t)time>=fFirstTimeBin && (Int_t)time+fDigitReader->GetBunchSize()<=fLastTimeBin){
+ Int_t indexInBunchData=0;
+ Bool_t moreDataInBunch=kFALSE;
+ UInt_t prevSignal=0;
+ Bool_t signalFalling=kFALSE;
+
+ // Kenneth: 20-04-09. The following if have been added because of inconsistency in the 40 bit decoder and the 32 bit decoder.
+ // GetSignals() in the 40 bit decoder returns an array of UInt_t while the 32 bit one returns UShort_t
+ // The same is true for the function ReadDataUnsorted() above.
+ // In addition the signals are organized in the opposite direction
+ if(f32BitFormat){
+ indexInBunchData = fDigitReader->GetBunchSize();
+ const UShort_t *bunchData= fDigitReader->GetSignalsShort();
+
+ do{
+ AliHLTTPCClusters candidate;
+ //for(Int_t i=indexInBunchData;i<fDigitReader->GetBunchSize();i++){
+ for(Int_t i=indexInBunchData;i>=0;i--){
+ // Checks if one need to deconvolute the signals
+ if(bunchData[i]>prevSignal && signalFalling==kTRUE){
+ if(i<fDigitReader->GetBunchSize()-1){ // means there are more than one signal left in the bunch
+ moreDataInBunch=kTRUE;
+ prevSignal=0;
+ }
+ break;
+ }
+
+ // Checks if the signal is 0, then quit processing the data.
+ if(bunchData[i]==0 && i<fDigitReader->GetBunchSize()-1){//means we have 0 data fom the rcu, might happen depending on the configuration settings
+ moreDataInBunch=kTRUE;
+ prevSignal=0;
+ break;
+ }
+
+ if(prevSignal>bunchData[i]){//means the peak of the signal has been reached and deconvolution will happen if the signal rise again.
+ signalFalling=kTRUE;
+ }
+ candidate.fTotalCharge+=bunchData[i];
+ candidate.fTime += time*bunchData[i];
+ candidate.fTime2 += time*time*bunchData[i];
+ if(bunchData[i]>candidate.fQMax){
+ candidate.fQMax=bunchData[i];
+ }
+
+ prevSignal=bunchData[i];
+ time++;
+ indexInBunchData--;
+ }
+ if(candidate.fTotalCharge>0){
+ candidate.fMean=candidate.fTime/candidate.fTotalCharge;
+ candidate.fPad=candidate.fTotalCharge*pad;
+ candidate.fPad2=candidate.fPad*pad;
+ candidate.fLastMergedPad=pad;
+ candidate.fRowNumber=row+fDigitReader->GetRowOffset();
+ }
+ fRowPadVector[row][pad]->AddClusterCandidate(candidate);
+ fRowPadVector[row][pad]->AddCandidateDigits(fMCDigits);
+ if(indexInBunchData<fDigitReader->GetBunchSize()-1){
+ moreDataInBunch=kFALSE;
+ }
+ }while(moreDataInBunch);
+ }
+ else{
+ const UInt_t *bunchData= fDigitReader->GetSignals();
+ do{
+ AliHLTTPCClusters candidate;
+ for(Int_t i=indexInBunchData;i<fDigitReader->GetBunchSize();i++){
+ // Checks if one need to deconvolute the signals
+ if(bunchData[i]>prevSignal && signalFalling==kTRUE){
+ if(i<fDigitReader->GetBunchSize()-1){ // means there are more than one signal left in the bunch
+ moreDataInBunch=kTRUE;
+ prevSignal=0;
+ }
+ break;
+ }
+
+ // Checks if the signal is 0, then quit processing the data.
+ if(bunchData[i]==0 && i<fDigitReader->GetBunchSize()-1){//means we have 0 data fom the rcu, might happen depending on the configuration settings
+ moreDataInBunch=kTRUE;
+ prevSignal=0;
+ break;
+ }
+
+ if(prevSignal>bunchData[i]){//means the peak of the signal has been reached and deconvolution will happen if the signal rise again.
+ signalFalling=kTRUE;
+ }
+
+ candidate.fTotalCharge+=bunchData[i];
+ candidate.fTime += time*bunchData[i];
+ candidate.fTime2 += time*time*bunchData[i];
+ if(bunchData[i]>candidate.fQMax){
+ candidate.fQMax=bunchData[i];
+ }
+
+ prevSignal=bunchData[i];
+ time++;
+ indexInBunchData++;
+ }
+ if(candidate.fTotalCharge>0){
+ candidate.fMean=candidate.fTime/candidate.fTotalCharge;
+ candidate.fPad=candidate.fTotalCharge*pad;
+ candidate.fPad2=candidate.fPad*pad;
+ candidate.fLastMergedPad=pad;
+ candidate.fRowNumber=row+fDigitReader->GetRowOffset();
+ }
+ fRowPadVector[row][pad]->AddClusterCandidate(candidate);
+ if(indexInBunchData<fDigitReader->GetBunchSize()-1){
+ moreDataInBunch=kFALSE;
+ }
+ }while(moreDataInBunch);
+ }
+ }
+ }
+ }
+ }
+}
+
+Bool_t AliHLTTPCClusterFinder::ComparePads(AliHLTTPCPad *nextPad,AliHLTTPCClusters* cluster,Int_t nextPadToRead){
+ // see header file for class documentation
+
+ //Checking if we have a match on the next pad
+ for(UInt_t candidateNumber=0;candidateNumber<nextPad->fClusterCandidates.size();candidateNumber++){
+ if(nextPad->fUsedClusterCandidates[candidateNumber] == 1){
+ continue;
+ }
+ AliHLTTPCClusters *candidate =&nextPad->fClusterCandidates[candidateNumber];
+ // if(cluster->fMean-candidate->fMean==1 || candidate->fMean-cluster->fMean==1 || cluster->fMean-candidate->fMean==0){
+
+ if( abs((Int_t)(cluster->fMean - candidate->fMean)) <= fTimeMeanDiff ){
+ if(fDeconvPad){
+ if(candidate->fTotalCharge<fTotalChargeOfPreviousClusterCandidate){//peak is reached
+ fChargeOfCandidatesFalling=kTRUE;
+ }
+ if(candidate->fTotalCharge>fTotalChargeOfPreviousClusterCandidate && fChargeOfCandidatesFalling==kTRUE){//we have deconvolution
+ return kFALSE;
+ }
+ }
+ cluster->fMean=candidate->fMean;
+ cluster->fTotalCharge+=candidate->fTotalCharge;
+ cluster->fTime += candidate->fTime;
+ cluster->fTime2 += candidate->fTime2;
+ cluster->fPad+=candidate->fPad;
+ cluster->fPad2+=candidate->fPad2;
+ cluster->fLastMergedPad=candidate->fPad;
+ if(candidate->fQMax>cluster->fQMax){
+ cluster->fQMax=candidate->fQMax;
+ }
+ if(fDoMC){
+ FillMCClusterVector(nextPad->GetCandidateDigits(candidateNumber));
+ }
+
+ if(fDoPadSelection){
+ UInt_t rowNo = nextPad->GetRowNumber();
+ UInt_t padNo = nextPad->GetPadNumber();
+ if(padNo-1>0){
+ fRowPadVector[rowNo][padNo-2]->fSelectedPad=kTRUE;
+ fRowPadVector[rowNo][padNo-2]->fHWAddress=(AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr(rowNo,padNo-2);
+ }
+ fRowPadVector[rowNo][padNo-1]->fSelectedPad=kTRUE;// quick solution to set the first pad to selected
+ fRowPadVector[rowNo][padNo-1]->fHWAddress=(AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr(rowNo,padNo-1);
+ fRowPadVector[rowNo][padNo]->fSelectedPad=kTRUE;
+ fRowPadVector[rowNo][padNo]->fHWAddress=(AliHLTUInt16_t)fDigitReader->GetAltroBlockHWaddr(rowNo,padNo);
+ }
+
+ //setting the matched pad to used
+ nextPad->fUsedClusterCandidates[candidateNumber]=1;
+ nextPadToRead++;
+ if(nextPadToRead<(Int_t)fNumberOfPadsInRow[fRowOfFirstCandidate]){
+ nextPad=fRowPadVector[fRowOfFirstCandidate][nextPadToRead];
+ ComparePads(nextPad,cluster,nextPadToRead);
+ }
+ else{
+ return kFALSE;
+ }
+ }
+ }
+ return kFALSE;
+}
+
+Int_t AliHLTTPCClusterFinder::FillHWAddressList(AliHLTUInt16_t *hwaddlist, Int_t maxHWadd){
+ // see header file for class documentation
+
+ Int_t counter=0;
+ for(UInt_t row=0;row<fNumberOfRows;row++){
+ for(UInt_t pad=0;pad<fNumberOfPadsInRow[row]-1;pad++){
+ if(fRowPadVector[row][pad]->fSelectedPad){
+ if(counter<maxHWadd){
+ hwaddlist[counter]=(AliHLTUInt16_t)fRowPadVector[row][pad]->fHWAddress;
+ counter++;
+ }
+ else{
+ HLTWarning("To many hardwareaddresses, skip adding");
+ }
+
+ }
+ }
+ }
+ return counter;
+}
+
+
+Int_t AliHLTTPCClusterFinder::FillOutputMCInfo(AliHLTTPCClusterFinder::ClusterMCInfo * outputMCInfo, Int_t maxNumberOfClusterMCInfo){
+ // see header file for class documentation
+
+ Int_t counter=0;
+
+ for(UInt_t mc=0;mc<fClustersMCInfo.size();mc++){
+ if(counter<maxNumberOfClusterMCInfo){
+ outputMCInfo[counter] = fClustersMCInfo[mc];
+ counter++;
+ }
+ else{
+ HLTWarning("To much MCInfo has been added (no more space), skip adding");
+ }
+ }
+ return counter;
+}
+
+void AliHLTTPCClusterFinder::FindClusters(){
+ // see header file for function documentation
+
+ AliHLTTPCClusters* tmpCandidate=NULL;
+ for(UInt_t row=0;row<fNumberOfRows;row++){
+ fRowOfFirstCandidate=row;
+ for(UInt_t pad=0;pad<fNumberOfPadsInRow[row];pad++){
+ AliHLTTPCPad *tmpPad=fRowPadVector[row][pad];
+ for(size_t candidate=0;candidate<tmpPad->fClusterCandidates.size();candidate++){
+ if(tmpPad->fUsedClusterCandidates[candidate]){
+ continue;
+ }
+ tmpCandidate=&tmpPad->fClusterCandidates[candidate];
+ UInt_t tmpTotalCharge=tmpCandidate->fTotalCharge;
+
+ if(fDoMC){
+ fClusterMCVector.clear();
+ FillMCClusterVector(tmpPad->GetCandidateDigits(candidate));
+ }
+
+ ComparePads(fRowPadVector[row][pad+1],tmpCandidate,pad+1);
+ if(tmpCandidate->fTotalCharge>tmpTotalCharge){
+ //we have a cluster
+ fClusters.push_back(*tmpCandidate);
+ if(fDoMC){
+ //sort the vector (large->small) according to weight and remove elements above 2 (keep 0 1 and 2)
+ sort(fClusterMCVector.begin(),fClusterMCVector.end(), MCWeight::CompareWeights );
+ ClusterMCInfo tmpClusterMCInfo;
+
+ MCWeight zeroMC;
+ zeroMC.fMCID=-1;
+ zeroMC.fWeight=0;
+
+ if(fClusterMCVector.size()>0){
+ tmpClusterMCInfo.fClusterID[0]=fClusterMCVector.at(0);
+ }
+ else{
+ tmpClusterMCInfo.fClusterID[0]=zeroMC;
+ }
+
+ if(fClusterMCVector.size()>1){
+ tmpClusterMCInfo.fClusterID[1]=fClusterMCVector.at(1);
+ }
+ else{
+ tmpClusterMCInfo.fClusterID[1]=zeroMC;
+ }
+
+ if(fClusterMCVector.size()>2){
+ tmpClusterMCInfo.fClusterID[2]=fClusterMCVector.at(2);
+ }
+ else{
+ tmpClusterMCInfo.fClusterID[2]=zeroMC;
+ }
+
+ fClustersMCInfo.push_back(tmpClusterMCInfo);
+ }
+
+ }
+ }
+ tmpPad->ClearCandidates();
+ }
+ fRowPadVector[row][fNumberOfPadsInRow[row]]->ClearCandidates();
+ }
+
+ HLTInfo("Found %d clusters.",fClusters.size());
+
+ //TODO: Change so it stores AliHLTTPCSpacePointData directly, instead of this copying
+
+ AliClusterData * clusterlist = new AliClusterData[fClusters.size()]; //Clusterlist
+ for(unsigned int i=0;i<fClusters.size();i++){
+ clusterlist[i].fTotalCharge = fClusters[i].fTotalCharge;
+ clusterlist[i].fPad = fClusters[i].fPad;
+ clusterlist[i].fPad2 = fClusters[i].fPad2;
+ clusterlist[i].fTime = fClusters[i].fTime;
+ clusterlist[i].fTime2 = fClusters[i].fTime2;
+ clusterlist[i].fMean = fClusters[i].fMean;
+ clusterlist[i].fFlags = fClusters[i].fFlags;
+ clusterlist[i].fChargeFalling = fClusters[i].fChargeFalling;
+ clusterlist[i].fLastCharge = fClusters[i].fLastCharge;
+ clusterlist[i].fLastMergedPad = fClusters[i].fLastMergedPad;
+ clusterlist[i].fRow = fClusters[i].fRowNumber;
+ clusterlist[i].fQMax = fClusters[i].fQMax;
+ }
+
+ WriteClusters(fClusters.size(),clusterlist);
+ delete [] clusterlist;
+ fClusters.clear();
+ if( fReleaseMemory ) DeInitializePadArray();// call this when the -releaseMemory flag is set
+}
+
+
+Bool_t AliHLTTPCClusterFinder::UpdateCalibDB(){
+
+ //update the db
+ AliTPCcalibDB::Instance()->Update();
+
+ Bool_t ret = 1;
+
+ //uptate the transform class
+
+ fOfflineTransform = AliTPCcalibDB::Instance()->GetTransform();
+ if(!fOfflineTransform){
+ HLTError("AliHLTTPCClusterFinder()::UpdateCAlibDB:: Offline transform not in AliTPCcalibDB.");
+ ret = 0;
+ }
+ else{
+ fOfflineTransform->SetCurrentRecoParam(&fOfflineTPCRecoParam);
+ }
+
+ fOfflineTPCParam = AliTPCcalibDB::Instance()->GetParameters();
+ if( !fOfflineTPCParam ){
+ HLTError("AliHLTTPCClusterFinder()::UpdateCAlibDB:: Offline TPC parameters not in AliTPCcalibDB.");
+ ret = 0;
+ } else {
+ fOfflineTPCParam->Update();
+ fOfflineTPCParam->ReadGeoMatrices();
+ }
+
+ return ret;
+}
+
+//---------------------------------- Under this line the old sorted clusterfinder functions can be found --------------------------------
+
+
+void AliHLTTPCClusterFinder::PrintClusters(){
+ // see header file for class documentation
+
+ for(size_t i=0;i<fClusters.size();i++){
+ HLTInfo("Cluster number: %d",i);
+ HLTInfo("Row: %d \t Pad: %d",fClusters[i].fRowNumber,fClusters[i].fPad/fClusters[i].fTotalCharge);
+ HLTInfo("Total Charge: %d",fClusters[i].fTotalCharge);
+ HLTInfo("fPad: %d",fClusters[i].fPad);
+ HLTInfo("PadError: %d",fClusters[i].fPad2);
+ HLTInfo("TimeMean: %d",fClusters[i].fTime/fClusters[i].fTotalCharge);
+ HLTInfo("TimeError: %d",fClusters[i].fTime2);
+ HLTInfo("EndOfCluster:");
+ }
+}
+
+void AliHLTTPCClusterFinder::FillMCClusterVector(vector<AliHLTTPCDigitData> digitData){
+ // see header file for class documentation
+
+ for(UInt_t d=0;d<digitData.size();d++){
+ Int_t nIDsInDigit = (digitData.at(d).fTrackID[0]>=0) + (digitData.at(d).fTrackID[1]>=0) + (digitData.at(d).fTrackID[2]>=0);
+ for(Int_t id=0; id<3; id++){
+ if(digitData.at(d).fTrackID[id]>=0){
+ Bool_t matchFound = kFALSE;
+ MCWeight mc;
+ mc.fMCID = digitData.at(d).fTrackID[id];
+ mc.fWeight = ((Float_t)digitData.at(d).fCharge)/nIDsInDigit;
+ for(UInt_t i=0;i<fClusterMCVector.size();i++){
+ if(mc.fMCID == fClusterMCVector.at(i).fMCID){
+ fClusterMCVector.at(i).fWeight += mc.fWeight;
+ matchFound = kTRUE;
+ }
+ }
+ if(matchFound == kFALSE){
+ fClusterMCVector.push_back(mc);
+ }
+ }
+ }
+ }
+}
+
+
void AliHLTTPCClusterFinder::Read(void* ptr,unsigned long size){
//set input pointer
fPtr = (UChar_t*)ptr;
fSize = size;
}
-void AliHLTTPCClusterFinder::ProcessDigits()
-{
+void AliHLTTPCClusterFinder::ProcessDigits(){
+ // see header file for class documentation
+
int iResult=0;
bool readValue = true;
Int_t newRow = 0;
bins.
*/
Int_t gatingGridOffset=50;
+ if(fFirstTimeBin>0){
+ gatingGridOffset=fFirstTimeBin;
+ }
AliHLTTPCPad baseline(gatingGridOffset, AliHLTTPCTransform::GetNTimeBins());
// just to make later conversion to a list of objects easier
AliHLTTPCPad* pCurrentPad=NULL;
- if (fSignalThreshold>=0) {
+ /*
+ if (fSignalThreshold>=0) {
pCurrentPad=&baseline;
baseline.SetThreshold(fSignalThreshold);
}
-
+ */
while ( readValue!=0 && iResult>=0){ // Reads through all digits in block
iResult=0;
} // ENDEND
-void AliHLTTPCClusterFinder::WriteClusters(Int_t nclusters,AliClusterData *list)
-{
+void AliHLTTPCClusterFinder::WriteClusters(Int_t nclusters,AliClusterData *list){
+ // see header file for class documentation
+
//write cluster to output pointer
Int_t thisrow=-1,thissector=-1;
UInt_t counter = fNClusters;
- if(!list[j].fFlags) continue; //discard single pad clusters
- if(list[j].fTotalCharge < fThreshold) continue; //noise cluster
-
+ if(!list[j].fFlags){
+ if(fDoMC){
+ if(j+(Int_t)fClustersMCInfo.size()-nclusters >=0 && j+fClustersMCInfo.size()-nclusters < fClustersMCInfo.size()){
+ fClustersMCInfo.erase(fClustersMCInfo.begin()+j+fClustersMCInfo.size()-nclusters); // remove the mc info for this cluster since it is not taken into account
+ }
+ }
+ continue; //discard single pad clusters
+ }
+ if(list[j].fTotalCharge < fThreshold){
+ if(fDoMC){
+ if(j+(Int_t)fClustersMCInfo.size()-nclusters >=0 && j+fClustersMCInfo.size()-nclusters < fClustersMCInfo.size()){
+ fClustersMCInfo.erase(fClustersMCInfo.begin()+j+fClustersMCInfo.size()-nclusters); // remove the mc info for this cluster since it is not taken into account
+ }
+ }
+ continue; //noise cluster
+ }
Float_t xyz[3];
Float_t fpad =(Float_t)list[j].fPad / list[j].fTotalCharge;
Float_t fpad2=fXYErr*fXYErr; //fixed given error
if(fCalcerr) { //calc the errors, otherwice take the fixed error
Int_t patch = AliHLTTPCTransform::GetPatch(fCurrentRow);
UInt_t q2=list[j].fTotalCharge*list[j].fTotalCharge;
- Float_t sy2=list[j].fPad2 * list[j].fTotalCharge - list[j].fPad * list[j].fPad;
+ // Float_t sy2=list[j].fPad2 * list[j].fTotalCharge - list[j].fPad * list[j].fPad;
+ Float_t sy2=(Float_t)list[j].fPad2 * list[j].fTotalCharge - (Float_t)list[j].fPad * list[j].fPad;
sy2/=q2;
if(sy2 < 0) {
LOG(AliHLTTPCLog::kError,"AliHLTTPCClusterFinder::WriteClusters","Cluster width")
}
} else fpad2=sy2; //take the width not the error
}
- Float_t sz2=list[j].fTime2*list[j].fTotalCharge - list[j].fTime*list[j].fTime;
+ // Float_t sz2=list[j].fTime2*list[j].fTotalCharge - list[j].fTime*list[j].fTime;
+ Float_t sz2=(Float_t)list[j].fTime2*list[j].fTotalCharge - (Float_t)list[j].fTime*list[j].fTime;
sz2/=q2;
if(sz2 < 0){
LOG(AliHLTTPCLog::kError,"AliHLTTPCClusterFinder::WriteClusters","Cluster width")
if(!fRawSP){
AliHLTTPCTransform::Slice2Sector(fCurrentSlice,fCurrentRow,thissector,thisrow);
- AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,fpad,ftime);
-
- if(xyz[0]==0) LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder","Cluster Finder")
- <<AliHLTTPCLog::kDec<<"Zero cluster"<<ENDLOG;
- if(fNClusters >= fMaxNClusters)
- {
- LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder::WriteClusters","Cluster Finder")
- <<AliHLTTPCLog::kDec<<"Too many clusters "<<fNClusters<<ENDLOG;
- return;
- }
-
- fSpacePointData[counter].fX = xyz[0];
- fSpacePointData[counter].fY = xyz[1];
- fSpacePointData[counter].fZ = xyz[2];
+
+ if(fOfflineTransform == NULL){
+ AliHLTTPCTransform::Raw2Local(xyz,thissector,thisrow,fpad,ftime);
+
+ if(xyz[0]==0) LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder","Cluster Finder")
+ <<AliHLTTPCLog::kDec<<"Zero cluster"<<ENDLOG;
+ if(fNClusters >= fMaxNClusters)
+ {
+ LOG(AliHLTTPCLog::kError,"AliHLTTPCClustFinder::WriteClusters","Cluster Finder")
+ <<AliHLTTPCLog::kDec<<"Too many clusters "<<fNClusters<<ENDLOG;
+ return;
+ }
- } else {
+ fSpacePointData[counter].fX = xyz[0];
+ // fSpacePointData[counter].fY = xyz[1];
+ if(fCurrentSlice<18){
+ fSpacePointData[counter].fY = xyz[1];
+ }
+ else{
+ fSpacePointData[counter].fY = -1*xyz[1];
+ }
+ fSpacePointData[counter].fZ = xyz[2];
+ }
+ else{
+ Double_t x[3]={thisrow,fpad+.5,ftime};
+ Int_t iSector[1]={thissector};
+ fOfflineTransform->Transform(x,iSector,0,1);
+ double y[3] = {x[0], x[1], x[2] };
+
+ if( fOfflineTPCParam && thissector<fOfflineTPCParam->GetNSector() ){
+ TGeoHMatrix *alignment = fOfflineTPCParam->GetClusterMatrix( thissector );
+ if ( alignment ) alignment->LocalToMaster( x, y);
+ }
+
+ fSpacePointData[counter].fX = y[0];
+ fSpacePointData[counter].fY = y[1];
+ fSpacePointData[counter].fZ = y[2];
+ }
+
+ }
+ else {
fSpacePointData[counter].fX = fCurrentRow;
fSpacePointData[counter].fY = fpad;
fSpacePointData[counter].fZ = ftime;
fSpacePointData[counter].fSigmaY2 = fpad2;
fSpacePointData[counter].fSigmaZ2 = ftime2;
+ fSpacePointData[counter].fQMax = list[j].fQMax;
+
fSpacePointData[counter].fUsed = kFALSE; // only used / set in AliHLTTPCDisplay
fSpacePointData[counter].fTrackN = -1; // only used / set in AliHLTTPCDisplay
// STILL TO FIX ----------------------------------------------------------------------------
#ifdef do_mc
-void AliHLTTPCClusterFinder::GetTrackID(Int_t pad,Int_t time,Int_t *trackID)
-{
+void AliHLTTPCClusterFinder::GetTrackID(Int_t pad,Int_t time,Int_t *trackID) const {
+ // see header file for class documentation
+
//get mc id
AliHLTTPCDigitRowData *rowPt = (AliHLTTPCDigitRowData*)fDigitRowData;
}
#endif
-//----------------------------------Methods for the new unsorted way of reading the data --------------------------------
-void AliHLTTPCClusterFinder::ReadDataUnsorted(void* ptr,unsigned long size)
-{
- //set input pointer
- fPtr = (UChar_t*)ptr;
- fSize = size;
- if(!fVectorInitialized){
- InitializePadArray();
- }
-
- fDigitReader->InitBlock(fPtr,fSize,fFirstRow,fLastRow,fCurrentPatch,fCurrentSlice);
-
- while(fDigitReader->NextChannel()){
- UInt_t row=fDigitReader->GetRow();
- UInt_t pad=fDigitReader->GetPad();
-
- fRowPadVector[row][pad]->ClearCandidates();
- while(fDigitReader->NextBunch()){
- if(fDigitReader->GetBunchSize()>1){//to remove single timebin values, this will have to change at some point
- const UInt_t *bunchData= fDigitReader->GetSignals();
- UInt_t time = fDigitReader->GetTime();
- AliHLTTPCClusters candidate;
- for(Int_t i=0;i<fDigitReader->GetBunchSize();i++){
- candidate.fTotalCharge+=bunchData[i];
- candidate.fTime += time*bunchData[i];
- candidate.fTime2 += time*time*bunchData[i];
- time++;
- }
- if(candidate.fTotalCharge>0){
- candidate.fMean=candidate.fTime/candidate.fTotalCharge;
- candidate.fPad=candidate.fTotalCharge*pad;
- candidate.fPad2=candidate.fPad*pad;
- candidate.fLastMergedPad=pad;
- candidate.fRowNumber=row+fDigitReader->GetRowOffset();
- }
- fRowPadVector[row][pad]->AddClusterCandidate(candidate);
- }
- }
- }
-}
-
-Bool_t AliHLTTPCClusterFinder::ComparePads(AliHLTTPCPad *nextPad,AliHLTTPCClusters* cluster,Int_t nextPadToRead){
- //Checking if we have a match on the next pad
- for(UInt_t candidateNumber=0;candidateNumber<nextPad->fClusterCandidates.size();candidateNumber++){
- AliHLTTPCClusters *candidate =&nextPad->fClusterCandidates[candidateNumber];
- if(cluster->fMean-candidate->fMean==1 || candidate->fMean-cluster->fMean==1 || cluster->fMean-candidate->fMean==0){
- cluster->fMean=candidate->fMean;
- cluster->fTotalCharge+=candidate->fTotalCharge;
- cluster->fTime += candidate->fTime;
- cluster->fTime2 += candidate->fTime2;
- cluster->fPad+=candidate->fPad;
- cluster->fPad2=candidate->fPad2;
- cluster->fLastMergedPad=candidate->fPad;
-
- //setting the matched pad to used
- nextPad->fUsedClusterCandidates[candidateNumber]=1;
- nextPadToRead++;
- if(nextPadToRead<(Int_t)fNumberOfPadsInRow[fRowOfFirstCandidate]){
- nextPad=fRowPadVector[fRowOfFirstCandidate][nextPadToRead];
- ComparePads(nextPad,cluster,nextPadToRead);
- }
- else{
- return kFALSE;
- }
- }
- else{
- return kFALSE;
- }
- }
- return kFALSE;
-}
-
-void AliHLTTPCClusterFinder::FindClusters()
-{
- // see header file for function documentation
-
- AliHLTTPCClusters* tmpCandidate=NULL;
- for(UInt_t row=0;row<fNumberOfRows;row++){
- fRowOfFirstCandidate=row;
- for(UInt_t pad=0;pad<fNumberOfPadsInRow[row]-1;pad++){
- AliHLTTPCPad *tmpPad=fRowPadVector[row][pad];
- for(size_t candidate=0;candidate<tmpPad->fClusterCandidates.size();candidate++){
- if(tmpPad->fUsedClusterCandidates[candidate]){
- continue;
- }
- tmpCandidate=&tmpPad->fClusterCandidates[candidate];
- UInt_t tmpTotalCharge=tmpCandidate->fTotalCharge;
- ComparePads(fRowPadVector[row][pad+1],tmpCandidate,pad+1);
- if(tmpCandidate->fTotalCharge>tmpTotalCharge){
- //we have a cluster
- fClusters.push_back(*tmpCandidate);
- }
- }
- }
- }
-
- HLTInfo("Found %d clusters.",fClusters.size());
-
- //TODO: Change so it stores AliHLTTPCSpacePointData directly, instead of this copying
-
- AliClusterData * clusterlist = new AliClusterData[fClusters.size()]; //Clusterlist
- for(unsigned int i=0;i<fClusters.size();i++){
- clusterlist[i].fTotalCharge = fClusters[i].fTotalCharge;
- clusterlist[i].fPad = fClusters[i].fPad;
- clusterlist[i].fPad2 = fClusters[i].fPad2;
- clusterlist[i].fTime = fClusters[i].fTime;
- clusterlist[i].fTime2 = fClusters[i].fTime2;
- clusterlist[i].fMean = fClusters[i].fMean;
- clusterlist[i].fFlags = fClusters[i].fFlags;
- clusterlist[i].fChargeFalling = fClusters[i].fChargeFalling;
- clusterlist[i].fLastCharge = fClusters[i].fLastCharge;
- clusterlist[i].fLastMergedPad = fClusters[i].fLastMergedPad;
- clusterlist[i].fRow = fClusters[i].fRowNumber;
- }
- // PrintClusters();
- WriteClusters(fClusters.size(),clusterlist);
- delete [] clusterlist;
- fClusters.clear();
-}
-
-void AliHLTTPCClusterFinder::PrintClusters()
-{
+void AliHLTTPCClusterFinder::WriteClusters(Int_t nclusters,AliHLTTPCClusters *list){//This is used when using the AliHLTTPCClusters class for cluster data
// see header file for class documentation
- for(size_t i=0;i<fClusters.size();i++){
- HLTInfo("Cluster number: %d",i);
- HLTInfo("Row: %d \t Pad: %d",fClusters[i].fRowNumber,fClusters[i].fFirstPad);
- HLTInfo("Total Charge: %d",fClusters[i].fTotalCharge);
- HLTInfo("fPad: %d",fClusters[i].fPad);
- HLTInfo("PadError: %d",fClusters[i].fPad2);
- HLTInfo("TimeMean: %d",fClusters[i].fTime);
- HLTInfo("TimeError: %d",fClusters[i].fTime2);
- HLTInfo("EndOfCluster:");
- }
-}
-void AliHLTTPCClusterFinder::WriteClusters(Int_t nclusters,AliHLTTPCClusters *list)//This is used when using the AliHLTTPCClusters class for cluster data
-{
//write cluster to output pointer
Int_t thisrow,thissector;
UInt_t counter = fNClusters;
}
fSpacePointData[counter].fX = xyz[0];
- fSpacePointData[counter].fY = xyz[1];
+ // fSpacePointData[counter].fY = xyz[1];
+ if(fCurrentSlice<18){
+ fSpacePointData[counter].fY = xyz[1];
+ }
+ else{
+ fSpacePointData[counter].fY = -1*xyz[1];
+ }
fSpacePointData[counter].fZ = xyz[2];
} else {
fSpacePointData[counter].fSigmaY2 = fpad2;
fSpacePointData[counter].fSigmaZ2 = ftime2;
+ fSpacePointData[counter].fQMax = list[j].fQMax;
+
fSpacePointData[counter].fUsed = kFALSE; // only used / set in AliHLTTPCDisplay
fSpacePointData[counter].fTrackN = -1; // only used / set in AliHLTTPCDisplay
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff