/** Container of HLT ITS tracks */
const AliHLTComponentDataType fgkITSTracksDataType = AliHLTComponentDataTypeInitializer( "ITSTRACK", kAliHLTDataOriginITS );
+/** Container of HLT ITS SAP tracker data */
+const AliHLTComponentDataType kAliHLTDataTypeITSSAPData = AliHLTComponentDataTypeInitializer( "SAPTRACK", kAliHLTDataOriginITS );
+
/** Container of HLT calorimeter clusters */
const AliHLTComponentDataType kAliHLTDataTypeCaloCluster = AliHLTComponentDataTypeInitializer( "CALOCLUS", kAliHLTDataOriginAny );
*/
extern const AliHLTComponentDataType fgkITSTracksDataType;
+ /** Container of ITS SAP tracker data
+ * @ingroup alihlt_component_datatypes
+ */
+ extern const AliHLTComponentDataType kAliHLTDataTypeITSSAPData;
+
/** Container of calorimeter clusters
* @ingroup alihlt_component_datatypes
*/
set ( MODULE_DHDR )
-set ( EINCLUDE HLT/BASE HLT/BASE/util HLT/ITS HLT/TPCLib HLT/ITS/tracking HLT/ITS/clusterfinders ITS RAW STEER/STEER STEER/ESD STEER/STEERBase)
+set ( EINCLUDE HLT/BASE HLT/BASE/util HLT/ITS HLT/TPCLib HLT/ITS/tracking HLT/ITS/trackingSAP HLT/ITS/clusterfinders ITS RAW STEER/STEER STEER/ESD STEER/STEERBase)
set ( ELIBS "HLTbase AliHLTUtil RAWDatarec RAWDatabase ITSrec ITSbase ESD STEER STEERBase -lEG")
#include "AliHLTITSClusterFinderComponent.h"
#include "AliHLTITSClusterHistoComponent.h"
#include "AliHLTITSTrackerComponent.h"
+#include "AliHLTITSSAPTrackerComponent.h"
#include "AliHLTITSVertexerSPDComponent.h"
#include "AliHLTITSDigitPublisherComponent.h"
// to run on digits, a digit publisher needs to be implemented
TString trackerInput="";
+ TString trackerSAPInput="";
TString vertexerSPDInput="";
if (rawReader || !runloader) {
// AliSimulation: use the AliRawReaderPublisher if the raw reader is available
// define the ITS tracker input
//
trackerInput="ITS-SPD-CF ITS-SDD-CF ITS-SSD-CF";
+ trackerSAPInput="ITS-SPD-CF ITS-SDD-CF ITS-SSD-CF";
}
else if (runloader && !rawReader) {
// indicates AliSimulation with no RawReader available -> run on digits
// Currently there is a seg fault in the TTree access from the DigitClusterFinder
// needs first to be investigated
trackerInput="DigitClusterFinder";
+ trackerSAPInput="DigitClusterFinder";
+ vertexerSPDInput="DigitClusterFinder";
}
///////////////////////////////////////////////////////////////////////////////////////////////////
}
handler->CreateConfiguration("ITS-tracker","ITSTracker",trackerInput.Data(),"");
}
+
+ if( !trackerSAPInput.IsNull() ) trackerSAPInput+=" ";
+ trackerSAPInput+="ITS-SPD-vertexer";
+
+ handler->CreateConfiguration("ITS-SAPtracker","ITSSAPTracker",trackerSAPInput.Data(),"");
return iResult;
}
pHandler->AddComponent(new AliHLTITSClusterFinderComponent(AliHLTITSClusterFinderComponent::kClusterFinderDigits));
pHandler->AddComponent(new AliHLTITSClusterHistoComponent);
pHandler->AddComponent(new AliHLTITSTrackerComponent);
+ pHandler->AddComponent(new AliHLTITSSAPTrackerComponent);
pHandler->AddComponent(new AliHLTITSVertexerSPDComponent);
pHandler->AddComponent(new AliHLTITSDigitPublisherComponent);
// see header file for class documentation
list.clear();
list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
+ list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITS );
}
AliHLTComponentDataType AliHLTITSVertexerSPDComponent::GetOutputDataType()
// Read ITS SPD clusters
- if ( iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ){
+ if ( ( iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) ||
+ ( iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITS) ) ) {
AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
int nClusters = inPtr->fSpacePointCnt;
double s = 400.E-4;
double cov[6] = {s*s,0,s*s,0,0,s*s};
AliESDVertex v(pos, cov, 0, fSumN[bestBin]);
- PushBack( (TObject*) &v, kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS,0 );
+ PushBack( (TObject*) &v, kAliHLTDataTypeESDVertex|kAliHLTDataOriginITSSPD,0 );
//cout<<"ITSVertexerSPD: vtx found "<<vtxX<<" "<<vtxY<<" "<<vtxZ<<endl;
}
--- /dev/null
+// $Id$
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* See cxx source for full Copyright notice *
+
+#ifndef ALIHLTITSSAPTRACKERDATA_H
+#define ALIHLTITSSAPTRACKERDATA_H
+
+#include "AliHLTDataTypes.h"
+#include "AliFlatExternalTrackParam.h"
+#include "AliHLTStdIncludes.h"
+
+struct AliHLTITSSAPTrackerData
+{
+ AliFlatExternalTrackParam paramOut;
+ AliFlatExternalTrackParam paramInw;
+ float chi2;
+ short ncl;
+ int label;
+};
+
+typedef struct AliHLTITSSAPTrackerData AliHLTITSSAPTrackerData;
+
+struct AliHLTITSSAPTrackerDataContainer {
+ AliHLTUInt32_t fCount; // number of tracklets
+#if defined(__HP_aCC) || defined(__DECCXX) || defined(__SUNPRO_CC)
+ AliHLTITSSAPTrackerData fTracks[1]; // array of tracklets
+#else
+ AliHLTITSSAPTrackerData fTracks[0]; // array of tracklets
+#endif
+};
+
+typedef struct AliHLTITSSAPTrackerDataContainer AliHLTITSSAPTrackerDataContainer;
+
+#endif
#include "AliGeomManager.h"
#include "AliHLTTrackMCLabel.h"
#include "AliITSRecPoint.h"
+#include "AliHLTSAPTrackerData.h"
#include <map>
using namespace std;
const char* AliHLTITSSAPTrackerComponent::GetComponentID()
{
// see header file for class documentation
- return "ITSTracker";
+ return "ITSSAPTracker";
}
void AliHLTITSSAPTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
const AliHLTComponentEventData& evtData,
const AliHLTComponentBlockData* blocks,
AliHLTComponentTriggerData& /*trigData*/,
- AliHLTUInt8_t* /*outputPtr*/,
+ AliHLTUInt8_t* outputPtr,
AliHLTUInt32_t& size,
- vector<AliHLTComponentBlockData>& /*outputBlocks*/ )
+ vector<AliHLTComponentBlockData>& outputBlocks )
{
//* process event
- // AliHLTUInt32_t maxBufferSize = size;
+ AliHLTUInt32_t maxBufferSize = size;
size = 0; // output size
if (!IsDataEvent()) return 0;
const AliESDVertex *vertexSPD = 0;
{
- const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS);
+ const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITSSPD);
if( iter != NULL ) {
if( !( vertexSPD = dynamic_cast<AliESDVertex*>(const_cast<TObject*>( iter ) ) ) ){
HLTError("ITS SPD vertex object is corrupted");
// Fill output tracks
-
- // RS??: HERE I AM NOT SURE WHAT TO DO
- int nFoundTracks = fTracker->GetNTracks();
int nAddedTracks = 0;
- for (int itr=0;itr<nFoundTracks;itr++) {
- const AliITSSAPTracker::ITStrack_t& track = fTracker->GetTrack(itr);
- // the track is just a struct of 2 AliExternalTrackParams (params at vertex and at the outer ITS layer)
- // + some extra info, see "struct ITStrack" in the AliITSSAPTracker.h
- if ( track.paramOut.TestBit(AliITSSAPTracker::kInvalidBit) ||
- track.paramInw.TestBit(AliITSSAPTracker::kInvalidBit)) continue;
- // use only those tracks whose both inward and outward params are OK.
-
- nAddedTracks++;
- // RS??:
-
- // I don't know if it should be passes as it is or converted to ESDtrack?
+ {
+ int nFoundTracks = fTracker->GetNTracks();
+ AliHLTUInt32_t blockSize = sizeof(AliHLTITSSAPTrackerDataContainer) + nFoundTracks*sizeof(AliHLTITSSAPTrackerData);
+ if( size + blockSize > maxBufferSize ){
+ HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored",
+ maxBufferSize, size + blockSize, nFoundTracks);
+ iResult = -ENOSPC;
+ }
+ if( iResult>=0 ){
+ blockSize = sizeof(AliHLTITSSAPTrackerDataContainer);
+ AliHLTITSSAPTrackerDataContainer *data = reinterpret_cast<AliHLTITSSAPTrackerDataContainer*>(outputPtr);
+ data->fCount=0;
+ for (int itr=0;itr<nFoundTracks;itr++) {
+ const AliITSSAPTracker::ITStrack_t& track = fTracker->GetTrack(itr);
+ // the track is just a struct of 2 AliExternalTrackParams (params at vertex and at the outer ITS layer)
+ // + some extra info, see "struct ITStrack" in the AliITSSAPTracker.h
+ if ( track.paramOut.TestBit(AliITSSAPTracker::kInvalidBit) ||
+ track.paramInw.TestBit(AliITSSAPTracker::kInvalidBit)) continue;
+ // use only those tracks whose both inward and outward params are OK.
+ AliHLTITSSAPTrackerData &trcHLT = data->fTracks[data->fCount];
+ trcHLT.paramOut.SetExternalTrackParam(&track.paramOut);
+ trcHLT.paramInw.SetExternalTrackParam(&track.paramInw);
+ trcHLT.chi2 = track.chi2;
+ trcHLT.ncl = track.ncl;
+ trcHLT.label = track.label;
+ data->fCount++;
+ blockSize += sizeof(AliHLTITSSAPTrackerData);
+ nAddedTracks++;
+ }
+
+ AliHLTComponentBlockData resultData;
+ FillBlockData( resultData );
+ resultData.fOffset = size;
+ resultData.fSize = blockSize;
+ resultData.fDataType = kAliHLTDataTypeITSSAPData|kAliHLTDataOriginITS;
+ fBenchmark.AddOutput(resultData.fSize);
+ outputBlocks.push_back( resultData );
+ size += resultData.fSize;
+ }
}
- // Fill output vertexTracks
-
- // RS: HERE I AM NOT SURE WHAT TO DO
-
Bool_t vtxOK = kFALSE;
- AliESDVertex& vtxTracks = fTracker->GetTrackVertex();
- if (vtxTracks.GetStatus()==1) {
- // here we should add the vertex to the output
-
- // RS??: ADD TO THE OUTPUT
- PushBack( (TObject*) &vtxTracks, kAliHLTDataTypeESDVertex|kAliHLTDataOriginOut,0 );
- vtxOK = kTRUE;
+ { // Fill output vertexTracks
+ AliESDVertex& vtxTracks = fTracker->GetTrackVertex();
+ if (vtxTracks.GetStatus()==1) {
+ PushBack( (TObject*) &vtxTracks, kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS,0 );
+ vtxOK = kTRUE;
+ }
}
//
fTracker->Clear();
,fNFoundClusters(0)
,fFoundClusterIterator(0)
,fFoundBinIterator(0)
- ,fFoundBins(0)
- ,fSortedClInfo(0)
+ ,fFoundBins()
+ ,fSortedClInfo()
+ ,fDetectors()
{
// def. c-tor
}
,fNFoundClusters(0)
,fFoundClusterIterator(0)
,fFoundBinIterator(0)
- ,fFoundBins(0)
- ,fSortedClInfo(0)
+ ,fFoundBins()
+ ,fSortedClInfo()
+ ,fDetectors()
{
// c-tor
Init(buffer);
virtual void Clear(Option_t *opt="");
virtual void Print(Option_t *opt="") const;
+ private:
+ AliITSSAPLayer(const AliITSSAPLayer&);
+ AliITSSAPLayer& operator=(const AliITSSAPLayer&);
+ //
protected:
TObjArray* fClusters; // externally supplied clusters
int fLrID; // layer id
//______________________________________________
AliITSSAPTracker::AliITSSAPTracker() :
- fBlacklist(0)
+ fSPD2Discard()
+ ,fTracklets()
+ ,fSPD1Tracklet()
+ ,fBlacklist(0)
,fPhiShift(0.0045)
,fSigThetaTracklet(0.025)
,fSigPhiTracklet(0.08)
,fMissChi2Penalty(3)
,fMaxMissedLayers(1)
,fNTracks(0)
+ ,fTracks()
+ ,fTrackVertex()
,fFitVertex(kTRUE)
//
,fSPDVertex(0)
#ifdef _CONTROLH_
FillRecoStat();
#endif
+ /*
+ PrintTracklets();
+ PrintTracks();
+ if (fSPDVertex) {printf("SPDvtx: "); fSPDVertex->Print();}
+ printf("TRKVtx: "); fTrackVertex.Print();
+ */
}
//
float dPhi = cli1->phi - cli2->phi; // fast check on phi
if (dPhi>TMath::Pi()) dPhi = TMath::TwoPi()-dPhi;
+ else if (dPhi<-TMath::Pi()) dPhi += TMath::TwoPi();
double dPhiS = TMath::Abs(dPhi)-fPhiShiftSc;
if (TMath::Abs(dPhiS)>fDPhiTrackletSc) continue;
//
float chi2 = dTheta*dTheta*fDThSig2Inv + dPhiS*dPhiS*fDPhSig2Inv; // check final chi2
- if (chi2>1.) continue;
+ if (chi2>1.) {
+ Blacklist(icl1,icl2);
+ continue;
+ }
nCand++;
if (chi2>chiBest) continue;
// check if cl1 is already associated with better
if (!oldId) { // store new tracklet
fTracklets.push_back(trk);
fSPD1Tracklet[trk.id1] = fTracklets.size(); // refer from clusters to tracklet (id+1)
+ fSPD2Discard[icl2] = true; // mark as used
Blacklist(trk.id1,trk.id2);
return 1;
}
- SPDtracklet_t& oldTrk = (SPDtracklet_t&)fSPD1Tracklet[--oldId];
+ SPDtracklet_t& oldTrk = (SPDtracklet_t&)fTracklets[--oldId];
if (oldTrk.chi2 < trk.chi2) { // previous is better
Blacklist(trk.id1,trk.id2); // shall we blacklist new combination?
if (nCand==1) fSPD2Discard[icl2] = true; // there was just 1 candidate and it is discarded
return 0;
}
+ // new combination is better, overwrite the old one with new one, marking old L2 cluster free
+ fSPD2Discard[oldTrk.id2] = false; // mark as free
+ fSPD2Discard[icl2] = true; // mark as used
oldTrk = trk; // new combination is better, overwrite it with new one
Blacklist(trk.id1,trk.id2);
return 1;
}
//______________________________________________
-Bool_t AliITSSAPTracker::IsAcceptableTrack(const AliITSSAPTracker::ITStrack_t& track) const
+Bool_t AliITSSAPTracker::IsAcceptableTrack(const AliITSSAPTracker::ITStrack_t& /*track*/) const
{
// check if the track is acceptable
return kTRUE;
typedef struct SPDtracklet SPDtracklet_t;
//
struct ITStrack {
+ ITStrack() : paramOut(),paramInw(),chi2(0),ncl(0),nmiss(0),label(0),trackletID(0) {}
AliExternalTrackParam paramOut;
AliExternalTrackParam paramInw;
float chi2;
void ClearTracks() {fTracks.clear();}
//
void SetSPDVertex(const AliESDVertex* v) {fSPDVertex = v;}
+ const AliESDVertex* GetSPDVertex() const {return fSPDVertex;}
void AddCluster(AliITSRecPoint* cl);
void SetBz(float v) {fBz = v;}
//
int GetNTracks() const {return fNTracks;}
void PrintTracklets() const;
void PrintTracklet(Int_t itr) const;
+ const AliITSSAPTracker::SPDtracklet_t& GetTracklet(int i) const {return fTracklets[i];}
// methods for trackleting ----------------<<<
//
// methods for track reconstruction ------->>>
Int_t GetTrackletMCTruth(AliITSSAPTracker::SPDtracklet_t& trlet) const;
void RefitInward();
Bool_t RefitInward(int itr);
+ void SetMaxMissedLayers(int n=0) { fMaxMissedLayers = n;}
+ Int_t GetMaxMissedLayers() const { return fMaxMissedLayers;}
AliITSSAPTracker::ITStrack_t& GetTrack(int i) const {return (ITStrack_t &)fTracks[i];}
// methods for track reconstruction -------<<<
//
TTree* treeInp = 0;
AliRunLoader* runLoader = 0;
AliESDEvent* esd=0;
+typedef struct {
+ Bool_t validSPD;
+ Bool_t validTrc;
+ Bool_t isPrim;
+ Char_t ntlC;
+ Char_t ntlF;
+ Char_t mtlC;
+ Char_t mtlF;
+ Char_t ntrC;
+ Char_t ntrF;
+ Int_t pdg;
+ Int_t evID;
+ Int_t mult;
+ Float_t pt;
+ Float_t eta;
+ Float_t phi;
+ Float_t zv;
+ //
+ Float_t spdDPhi;
+ Float_t spdDTht;
+ Float_t spdChi2;
+} tres_t;
+
+tres_t tres;
+TFile* flOut = 0;
+TTree* trOut = 0;
+
void ProcessEvent(int iev);
void Process(const char* path);
void TestTracker(TTree* tRP, const AliESDVertex* vtx);
void LoadClusters(TTree* tRP);
Double_t* DefLogAx(double xMn,double xMx, int nbin);
+void CheckRecStatus();
+void InitOutTree(const char* fname="rcInfo.root");
+void SaveOutTree();
void InitTracker(int runNumber);
+
+
#ifdef _TIMING_
TProfile* hTiming[AliITSSAPTracker::kNSW];
#endif
void Process(const char* inpData)
{
//
+ InitOutTree();
TString inpDtStr = inpData;
if (inpDtStr.EndsWith(".root") || inpDtStr.EndsWith(".zip#")) {
ProcChunk(inpDtStr.Data());
#ifdef _CONTROLH_
tracker->SaveHistos();
#endif
+ SaveOutTree();
}
void ProcChunk(const char* path)
}
#endif
//
+ CheckRecStatus();
//esd->Reset();
//
}
//_________________________________________________
void LoadClusters(TTree* tRP)
{
- AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
- TClonesArray* itsClusters = rpcont->FetchClusters(0,tRP);
- if(!rpcont->IsSPDActive()){
- printf("No SPD rec points found, multiplicity not calculated\n");
- tRP->Print();
- return;
+ // AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
+ // TClonesArray* itsClusters = rpcont->FetchClusters(0,tRP);
+ // if(!rpcont->IsSPDActive()){
+ // printf("No SPD rec points found, multiplicity not calculated\n");
+ // tRP->Print();
+ // return;
+ // }
+ // else printf("NSP0: %d\n",itsClusters->GetEntriesFast());
+ static TClonesArray* itsModAdd[2198] = {0};
+ static Bool_t first = kTRUE;
+ if (first) {
+ first = 0;
+ for (int i=0;i<2198;i++) itsModAdd[i] = new TClonesArray("AliITSRecPoint");
}
int nMod = AliITSgeomTGeo::GetNModules();
for (int imd=0;imd<nMod;imd++) {
- itsClusters = rpcont->UncheckedGetClusters(imd);
+ TClonesArray* itsClusters = itsModAdd[imd];
+ tRP->SetBranchAddress("ITSRecPoints",&itsClusters);
+ tRP->GetEntry(imd);
+ // itsClusters = rpcont->UncheckedGetClusters(imd);
+
int nClusters = itsClusters->GetEntriesFast();
if (!nClusters) continue;
while(nClusters--) {
for (int i=0;i<=nbin;i++) xax[i]= xMn*exp(dx*i);
return xax;
}
+//______________________________________________
+void CheckRecStatus()
+{
+ //
+ static int nev = -1;
+ static TBits patternMC;
+ static vector<char> ntrCorr;
+ static vector<char> ntrFake;
+ static vector<char> mtlCorr;
+ static vector<char> mtlFake;
+ static vector<char> ntlCorr;
+ static vector<char> ntlFake;
+ static vector<float> spdDPhi;
+ static vector<float> spdDTht;
+ static vector<float> spdChi2;
+ //
+ AliStack* stack = 0;
+ AliRunLoader* rl = AliRunLoader::Instance();
+ if (!rl || !(stack=rl->Stack())) return;
+ nev++;
+ //
+ enum {kIsPrim=AliITSSAPTracker::kNLrActive,kValidTracklet,kValidTrack,kRecDone,kBitPerTrack};
+ int nTrkMC = stack->GetNtrack();
+ patternMC.SetBitNumber(nTrkMC*kBitPerTrack,0);
+ patternMC.ResetAllBits();
+ //
+ ntrCorr.clear();
+ ntrFake.clear();
+ ntlCorr.clear();
+ ntlFake.clear();
+ mtlCorr.clear();
+ mtlFake.clear();
+ //
+ spdDPhi.clear();
+ spdDTht.clear();
+ spdChi2.clear();
+ //
+ ntrCorr.resize(nTrkMC,0);
+ ntrFake.resize(nTrkMC,0);
+ ntlCorr.resize(nTrkMC,0);
+ ntlFake.resize(nTrkMC,0);
+ mtlCorr.resize(nTrkMC,0);
+ mtlFake.resize(nTrkMC,0);
+ spdDPhi.resize(nTrkMC,0);
+ spdDTht.resize(nTrkMC,0);
+ spdChi2.resize(nTrkMC,0);
+
+ //
+ // fill MC track patterns
+ for (int ilr=6;ilr--;) {
+ AliITSSAPLayer *lr = tracker->GetLayer(ilr);
+ int ncl = lr->GetNClusters();
+ for (int icl=ncl;icl--;) {
+ AliITSRecPoint* cl = lr->GetClusterUnSorted(icl);
+ for (int j=0;j<3;j++) {
+ int lb = cl->GetLabel(j);
+ if (lb<0 || lb>=nTrkMC) break;
+ patternMC.SetBitNumber(lb*kBitPerTrack+ilr,kTRUE);
+ }
+ }
+ }
+ //
+ int nTrk = tracker->GetNTracklets();
+ if (!nTrk) return;
+ for (int itr=0;itr<nTrk;itr++) {
+ const AliITSSAPTracker::SPDtracklet_t& trlet = tracker->GetTracklet(itr);
+ // PrintTracklet(itr);
+ //
+ int lbl = trlet.label;
+ if (lbl==-3141593) continue;
+ int lblA = TMath::Abs(lbl);
+ if (lblA==lbl) ntlCorr[lblA]++;
+ else ntlFake[lblA]++;
+ //
+ if (spdChi2[lblA]==0 || spdChi2[lblA]<trlet.chi2) {
+ spdChi2[lblA] = trlet.chi2;
+ spdDPhi[lblA] = trlet.dphi;
+ spdDTht[lblA] = trlet.dtht;
+ }
+ }
+ //
+ AliITSSAPLayer* lr0 = tracker->GetLayer(0);
+ AliITSSAPLayer* lr1 = tracker->GetLayer(1);
+ for (int itrm=0;itrm<nTrkMC;itrm++) {
+ if (ntlCorr[itrm]+ntlFake[itrm]<2) continue;
+ printf("\nExtra for tr %d nC:%d nF:%d\n",itrm,ntlCorr[itrm],ntlFake[itrm]);
+ //
+ int cnt = 0;
+ for (int itr=0;itr<nTrk;itr++) {
+ const AliITSSAPTracker::SPDtracklet_t& trlet = tracker->GetTracklet(itr);
+ if (TMath::Abs(trlet.label)!=itrm) continue;
+ AliITSSAPLayer::ClsInfo_t* clinf0 = lr0->GetClusterInfo(trlet.id1);
+ AliITSSAPLayer::ClsInfo_t* clinf1 = lr1->GetClusterInfo(trlet.id2);
+ printf("#%2d%s%4d chi:%.2f [%4d/%3d] [%4d/%3d]\n",cnt++,trlet.label<0 ? "-":"+",itr,trlet.chi2,
+ trlet.id1,clinf0->detid,
+ trlet.id2,clinf1->detid);
+ }
+ }
+ //
+ const AliMultiplicity* mltESD = esd->GetMultiplicity();
+ nTrk = mltESD->GetNumberOfTracklets();
+ for (int itr=0;itr<nTrk;itr++) {
+ int lb0 = mltESD->GetLabel(itr,0);
+ int lb1 = mltESD->GetLabel(itr,1);
+ if (lb0==lb1) mtlCorr[lb1]++;
+ else mtlFake[lb1]++;
+ }
+ //
+ nTrk = tracker->GetNTracks();
+ for (int itr=0;itr<nTrk;itr++) {
+ const AliITSSAPTracker::ITStrack_t &track = tracker->GetTrack(itr);
+ //
+ int lbl = track.label;
+ if (lbl==-3141593) continue;
+ int lblA = TMath::Abs(lbl);
+ if (lblA==lbl) ntrCorr[lblA]++;
+ else ntrFake[lblA]++;
+ }
+ //
+ // set reconstructability
+ for (int itr=nTrkMC;itr--;) {
+ int bitoffs = itr*kBitPerTrack;
+ //
+ tres.validSPD = patternMC.TestBitNumber(bitoffs+AliITSSAPTracker::kALrSPD1) &&
+ patternMC.TestBitNumber(bitoffs+AliITSSAPTracker::kALrSPD2);
+ int nmiss = 0;
+ for (int il=AliITSSAPTracker::kALrSDD1;il<=AliITSSAPTracker::kALrSSD2;il++)
+ if (tracker->IsObligatoryLayer(il) && !patternMC.TestBitNumber(bitoffs+il)) nmiss++;
+ tres.validTrc = tres.validSPD && (nmiss<=tracker->GetMaxMissedLayers());
+ //
+ if ( !tres.validSPD && !tres.validTrc &&
+ (ntlCorr[itr]+ntlFake[itr])==0 &&
+ (ntrCorr[itr]+ntrFake[itr])==0 &&
+ (mtlCorr[itr]+mtlFake[itr])==0 ) continue;
+ //
+ TParticle* mctr = stack->Particle(itr);
+ tres.isPrim = stack->IsPhysicalPrimary(itr);
+ tres.pdg = mctr->GetPdgCode();
+ tres.pt = mctr->Pt();
+ tres.eta = mctr->Eta();
+ tres.phi = mctr->Phi();
+ //
+ tres.ntlC = ntlCorr[itr];
+ tres.ntlF = ntlFake[itr];
+ tres.ntrC = ntrCorr[itr];
+ tres.ntrF = ntrFake[itr];
+ //
+ tres.mtlC = mtlCorr[itr];
+ tres.mtlF = mtlFake[itr];
+ //
+ tres.evID = nev;
+ tres.mult = tracker->GetNTracklets();
+ tres.zv = tracker->GetSPDVertex()->GetZ();
+ //
+ tres.spdDPhi = spdDPhi[itr];
+ tres.spdDTht = spdDTht[itr];
+ tres.spdChi2 = spdChi2[itr];
+ //
+ trOut->Fill();
+ }
+ //
+}
+
+//___________________________________________________
+void InitOutTree(const char* fname)
+{
+ // output tree
+ flOut = TFile::Open(fname,"recreate");
+ trOut = new TTree("rcinfo","rcinfo");
+ trOut->Branch("res",&tres);
+}
+
+//___________________________________________________
+void SaveOutTree()
+{
+ if (!trOut) return;
+ flOut->cd();
+ trOut->Write();
+ delete trOut;
+ flOut->Close();
+ delete flOut;
+ trOut = 0;
+ flOut = 0;
+}
//______________________________________________
aliroot 'TestITSSAP.C(<path>)'
where the <path> is the directory cotaining the output of the standard
reconstruction, including the ITS.RecPoints.root file
+
+
+To test tracker in the HLT simulation, generate some MC (e.g. ppbench),
+copy the macro TestHLTITSSAP.C to the generation directory and run
+aliroot TestHLTITSSAP.C
--- /dev/null
+void TestHLTITSSAP() {
+
+ gSystem->Load("liblhapdf");
+ gSystem->Load("libEGPythia6");
+ gSystem->Load("libpythia6");
+ gSystem->Load("libAliPythia6");
+ gSystem->Load("libhijing");
+ gSystem->Load("libTHijing");
+ gSystem->Load("libgeant321");
+
+ if (gSystem->Getenv("EVENT"))
+ nev = atoi(gSystem->Getenv("EVENT")) ;
+
+ AliSimulation simulator;
+ simulator.SetRunGeneration(0);
+ simulator.SetRunSimulation(0);
+ simulator.SetMakeDigits("");
+ simulator.SetMakeSDigits("");
+ simulator.SetMakeDigitsFromHits("");
+ //simulator.SetWriteRawData("ALL","raw.root",kTRUE);
+
+ simulator.SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+ simulator.SetSpecificStorage("GRP/GRP/Data",
+ Form("local://%s",gSystem->pwd()));
+ simulator.SetSpecificStorage("ITS/Align/Data",
+ "alien://folder=/alice/simulation/2008/v4-15-Release/Ideal");
+
+ simulator.SetRunQA(":") ;
+
+ AliHLTConfigurationHandler::CreateHandler();
+ AliHLTConfigurationHandler *handler = AliHLTConfigurationHandler::Instance();
+
+ handler->CreateConfiguration("ITS-SAPtracker1","ITSSAPTracker","DigitClusterFinder ITS-SPD-vertexer",
+ "");
+
+
+ simulator.SetRunHLT("chains=ITS-SAPtracker1");
+
+ TStopwatch timer;
+ timer.Start();
+ simulator.Run();
+ timer.Stop();
+ timer.Print();
+}
{
return const_cast<AliFlatESDTrack*>(GetFlatTrack(i));
}
+
+AliVEvent::EDataLayoutType AliFlatESDEvent::GetDataLayoutType() const
+{
+ return AliVEvent::kFlat;
+}
+
UInt_t GetEventSpecie() const { return fEventSpecie; }
Int_t GetNumberOfKinks() const { return 0; }
- AliVTrack *GetVTrack( Int_t i ) { return GetFlatTrackNonConst(i); }
+ AliVTrack *GetVTrack( Int_t i ) const { return GetFlatTrackNonConst(i); }
AliESDkink *GetKink(Int_t /*i*/) const { return NULL;}
+ using AliVEvent::GetPrimaryVertex;
+ using AliVEvent::GetPrimaryVertexTPC;
+ using AliVEvent::GetPrimaryVertexSPD;
+ using AliVEvent::GetPrimaryVertexTracks;
Int_t GetPrimaryVertex( AliESDVertex &v ) const ;
Int_t GetPrimaryVertexTPC( AliESDVertex &v ) const ;
Int_t GetPrimaryVertexSPD( AliESDVertex &v ) const ;
const AliFlatESDV0 *GetV0s() const { return reinterpret_cast<const AliFlatESDV0*>( fContent + fV0Pointer ); }
const AliFlatESDTrack *GetFlatTrack( Int_t i ) const ;
- AliFlatESDTrack *GetFlatTrackNonConst( Int_t i );
+ AliFlatESDTrack *GetFlatTrackNonConst( Int_t i ) const;
// --------------------------------------------------------------------------------
// -- Size methods
virtual Int_t EventIndexForEMCALCell(Int_t) const {return 0;}
virtual AliVVZERO* GetVZEROData() const {return NULL;}
virtual AliVZDC *GetZDCData() const {return NULL;}
+ virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
private:
// Inline implementations
-inline AliFlatESDTrack *AliFlatESDEvent::GetFlatTrackNonConst( Int_t i )
+inline AliFlatESDTrack *AliFlatESDEvent::GetFlatTrackNonConst( Int_t i ) const
{
const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
if( i<0 || i>(int) fNTracks || table[i]<0 ) return NULL;
- return reinterpret_cast<AliFlatESDTrack*>( fContent + table[i] );
+ return reinterpret_cast<AliFlatESDTrack*>( const_cast<Byte_t*>(fContent + table[i]) );
}
inline const AliFlatESDTrack *AliFlatESDEvent::GetFlatTrack( Int_t i ) const
// ---------------------------------------------------------------------------------
// AliVParticle interface
virtual Double_t Pt() const {const AliFlatExternalTrackParam* p=GetFlatTrackParam(); return (p)?p->GetPt():kVeryBig;}
+ virtual Double_t GetTgl() const {const AliFlatExternalTrackParam* p=GetFlatTrackParam(); return (p)?p->GetTgl():kVeryBig;}
+ using AliVTrack::GetImpactParameters;
+ virtual void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=0.; z=0.;}
virtual Double_t Px() const {return 0.;}
virtual Double_t Py() const {return 0.;}
virtual Double_t Pz() const {return 0.;}
fAnalysisManager->SetExternalLoop(kTRUE);
AliAnalysisTaskPt *task = new AliAnalysisTaskPt("TaskPt");
+ printf("-----> AliHLTAnaManagerComponent: here we set the usage of the friends to %d\n", (Int_t)task->GetUseFriends());
task->SetUseFriends(kTRUE);
fAnalysisManager->AddTask(task);
AliAnalysisDataContainer *cinput = fAnalysisManager->GetCommonInputContainer();
rm galice.root; aliroot -b -q -l testconfigFlat.C'("GLOBAL-flat-esd-converter")' $ALICE_ROOT/HLT/exa/recraw-local.C'("raw.root","local://$ALICE_ROOT/OCDB", 0, 10, "HLT", "chains=RootWriter ignore-hltout")' 2>&1| tee recHLT.log
Note that you need to have a raw.root file in your folder.
+
+
+*******************************************************************************
+
+To run the same AliAnalysisPtTask but on Offline ESDs (that you need locally, optionally with the
+friends) run:
+
+aliroot -b -q runTaskOffline.C
--- /dev/null
+void runTaskOffline()
+{
+ // load analysis framework
+ gSystem->Load("libANALYSISalice");
+
+ gROOT->LoadMacro("$ALICE_ROOT/PWGUD/macros/CreateESDChain.C");
+
+ // for includes use either global setting in $HOME/.rootrc
+ // ACLiC.IncludePaths: -I$(ALICE_ROOT)/include
+ // or in each macro
+ gSystem->AddIncludePath("-I$ALICE_ROOT/include");
+ gROOT->Macro("$ALICE_ROOT/PWGPP/CalibMacros/CPass0/LoadLibraries.C");
+
+ // Create the analysis manager
+ AliAnalysisManager *mgr = new AliAnalysisManager("testAnalysis");
+
+ // Add ESD input handler
+ AliESDInputHandler* esdH = new AliESDInputHandler();
+ esdH->SetReadFriends(kTRUE);
+ esdH->SetActiveBranches("ESDfriend");
+
+ // Register input handler to manager
+ mgr->SetInputEventHandler(esdH);
+
+ // Create task
+
+ //gROOT->LoadMacro("AliAnalysisTaskPt.cxx+g");
+ AliAnalysisTaskPt *task = new AliAnalysisTaskPt("TaskPt");
+ task->SetUseFriends(kTRUE);
+
+ // Add task
+ mgr->AddTask(task);
+
+ // Create containers for input/output
+ AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
+ AliAnalysisDataContainer *coutput = mgr->CreateContainer("chist", TList::Class(), AliAnalysisManager::kOutputContainer, "Pt.ESD.1.root");
+
+ // Connect input/output
+ mgr->ConnectInput(task, 0, cinput);
+ mgr->ConnectOutput(task, 0, coutput);
+
+ // Enable debug printouts
+ mgr->SetDebugLevel(2);
+
+ if (!mgr->InitAnalysis())
+ return;
+
+ mgr->PrintStatus();
+
+ TChain *chain1 = new TChain("esdTree");
+ chain1->Add("AliESDs.root");
+
+ mgr->StartAnalysis("local", chain1);
+}
Double_t GetD(Double_t x, Double_t y) const {
return AliExternalTrackParam::GetD(x,y,GetBz());
}
+ using AliExternalTrackParam::GetDZ;
void GetDZ(Double_t xv, Double_t yv, Double_t zv, Float_t dz[2]) const {
return AliExternalTrackParam::GetDZ(xv,yv,zv,GetBz(),dz);
}
fTracksConnected = kTRUE;
}
+AliVEvent::EDataLayoutType AliAODEvent::GetDataLayoutType() const {return AliVEvent::kAOD;}
+
{new((*fVertices)[fVertices->GetEntriesFast()]) AliAODVertex(*vtx); return fVertices->GetEntriesFast()-1;}
// primary vertex
+ using AliVEvent::GetPrimaryVertex;
+ using AliVEvent::GetPrimaryVertexSPD;
virtual AliAODVertex *GetPrimaryVertex() const { return GetVertex(0); }
virtual AliAODVertex *GetPrimaryVertexSPD() const;
// V0
TClonesArray *GetV0s() const { return fV0s; }
Int_t GetNumberOfV0s() const { return fV0s->GetEntriesFast(); }
+ using AliVEvent::GetV0;
AliAODv0 *GetV0(Int_t nV0) const { return (AliAODv0*)fV0s->UncheckedAt(nV0); }
Int_t AddV0(const AliAODv0* v0)
{new((*fV0s)[fV0s->GetEntriesFast()]) AliAODv0(*v0); return fV0s->GetEntriesFast()-1;}
//ZDC
AliAODZDC *GetZDCData() const { return fAODZDC; }
+ virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
private :
//
Int_t GetTOFBunchCrossing(Double_t b=0, Bool_t tpcPIDonly=kFALSE) const;
//
+ using AliVTrack::GetP;
template <typename T> void GetP(T *p) const {
p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
STEERBase/AliVTOFHit.cxx
STEERBase/AliVTOFMatch.cxx
STEERBase/AliVTOFcluster.cxx
+ STEERBase/AliVMisc.cxx
+ STEERBase/AliVfriendTrack.cxx
+ STEERBase/AliVfriendEvent.cxx
)
string(REPLACE ".cxx" ".h" HDRS "${SRCS}")
}
- AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindListObject("AliESDfriend"));
+ AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindFriend());
if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
}
//
}
+//______________________________________________________________________________
+AliESDfriend* AliESDEvent::FindFriend() const
+{
+ return static_cast<AliESDfriend*>(FindListObject("AliESDfriend"));
+}
+
+AliVEvent::EDataLayoutType AliESDEvent::GetDataLayoutType() const {return AliVEvent::kESD;}
+
void SetESDfriend(const AliESDfriend *f) const;
void GetESDfriend(AliESDfriend *f) const;
- AliESDfriend* FindFriend() const { return static_cast<AliESDfriend*>(FindListObject("AliESDfriend")); }
+ virtual AliESDfriend* FindFriend() const;
void SetPrimaryVertexTPC(const AliESDVertex *vertex);
const AliESDVertex *GetPrimaryVertexTPC() const {return fTPCVertex;}
UInt_t GetDAQDetectorPattern() const {return fDAQDetectorPattern;}
UInt_t GetDAQAttributes() const {return fDAQAttributes;}
+ virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
+
protected:
AliESDEvent(const AliESDEvent&);
static Bool_t ResetWithPlacementNew(TObject *pObject);
ClassDef(AliESDEvent,23) //ESDEvent class
};
+
#endif
cTree->AddFriend("esdFriendTree", esdFriendTreeFName.Data());
cTree->SetBranchStatus("ESDfriend.", 1);
- fFriend = (AliESDfriend*)(fEvent->FindListObject("AliESDfriend"));
+ fFriend = fEvent->FindFriend();
if (fFriend) cTree->SetBranchAddress("ESDfriend.", &fFriend);
}
}
virtual void CreatePIDResponse(Bool_t isMC=kFALSE);
AliESDpid *GetESDpid() const {return fESDpid;}
void SetESDpid(AliESDpid* pid) {Changed(); fESDpid = pid;}
+
+ //HLT
+ virtual AliVfriendEvent* GetVfriendEvent() const {return fFriend;};
private:
AliESDInputHandler(const AliESDInputHandler& handler);
Bool_t
RelateToVertexBxByBz(const AliESDVertex *vtx, Double_t b[3], Double_t maxd,
AliExternalTrackParam *cParam=0);
- void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
+ virtual void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
void GetImpactParameters(Float_t p[2], Float_t cov[3]) const {
p[0]=fD; p[1]=fZ; cov[0]=fCdd; cov[1]=fCdz; cov[2]=fCzz;
}
SetVFriendEvent(friendEvent);
// set transient pointer to event inside tracks
fEvent->ConnectTracks();
- Printf("----> AliHLTTestInputHandler::InitTaskInpuData: ...Event set: fEvent = %p", fEvent);
+ Printf("----> AliHLTTestInputHandler::InitTaskInpuData: ...Event set: fEvent = %p; friend = %p", fEvent, friendEvent);
for (Int_t i = 0; i < arrTasks->GetEntries(); i++){
AliAnalysisTask* t = (AliAnalysisTask*)(arrTasks->At(i));
t->ConnectInputData("");
//AliVEvent* GetEvent() const {return NULL;}
void SetEvent(AliVEvent *event) {fEvent = event;}
- AliVfriendEvent* GetVFriendEvent() const {return fFriendEvent;}
+ AliVfriendEvent* GetVfriendEvent() const {return fFriendEvent;}
void SetVFriendEvent(AliVfriendEvent *friendEvent) {fFriendEvent = friendEvent;}
private:
Double_t GetY() const {return fP[0];}
Double_t GetZ() const {return fP[1];}
Double_t GetSnp() const {return fP[2];}
- Double_t GetTgl() const {return fP[3];}
+ virtual Double_t GetTgl() const {return fP[3];}
+ using AliVTrack::GetImpactParameters;
+ virtual void GetImpactParameters(Float_t& ,Float_t&) const {}
Double_t GetSigned1Pt() const {return fP[4];}
Double_t GetSigmaY2() const {return fC[0];}
return 1;
}
-
-
+AliVEvent::EDataLayoutType AliMCEvent::GetDataLayoutType() const {return AliVEvent::kMC;}
ClassImp(AliMCEvent)
virtual Int_t GetNumberOfV0s() const {return -1;}
virtual Int_t GetNumberOfCascades() const {return -1;}
// Vertex
+ using AliVEvent::GetPrimaryVertex;
virtual const AliVVertex *GetPrimaryVertex() const;
//
virtual AliVVZERO *GetVZEROData() const {return 0;}
virtual AliVZDC *GetZDCData() const {return 0;}
-
+
+ virtual AliVEvent::EDataLayoutType GetDataLayoutType() const;
private:
virtual void ReorderAndExpandTreeTR();
ClassDef(AliMCEvent, 2) // AliVEvent realisation for MC data
};
-
#endif
AliVEvent* evt = (AliVEvent*) (fEventList.At(0));
return evt->GetMagneticField();
}
+
+AliVEvent::EDataLayoutType AliMixedEvent::GetDataLayoutType() const
+{
+ return AliVEvent::kMixed;
+}
virtual AliCentrality* GetCentrality() {return 0;}
virtual AliEventplane* GetEventplane() {return 0;}
// Primary vertex
+ using AliVEvent::GetPrimaryVertex;
virtual const AliVVertex *GetPrimaryVertex() const {return fMeanVertex;}
virtual Bool_t ComputeVtx(const TObjArray *vertices, Double_t *pos,Double_t *sig,Int_t *nContributors);
// VZERO
virtual AliVVZERO *GetVZEROData() const {return 0;}
virtual AliVZDC *GetZDCData() const {return 0;}
+ virtual EDataLayoutType GetDataLayoutType() const;
private:
TList fEventList; //! List of Events
Int_t fNEvents; //! Number of Events
return *this;
}
+const char* AliVEvent::Whoami()
+{
+ switch (GetDataLayoutType())
+ {
+ case AliVEvent::kESD :
+ return "ESD";
+ case AliVEvent::kFlat :
+ return "Flat";
+ case AliVEvent::kAOD :
+ return "AOD";
+ case AliVEvent::kMC :
+ return "MC";
+ case AliVEvent::kMixed :
+ return "Mixed";
+ default:
+ return "unknown";
+ }
+}
ClassImp(AliVEvent)
ULong64_t GetTriggerMaskNext50() const { return 0; }
public:
+ enum EDataLayoutType { kESD, kMC, kAOD, kMixed, kFlat };
enum EOfflineTriggerTypes {
kMB = BIT(0), // Minimum bias trigger, i.e. interaction trigger, offline SPD or V0 selection
kINT7 = BIT(1), // V0AND trigger, offline V0 selection
// Tracks
virtual AliVParticle *GetTrack(Int_t i) const = 0;
virtual AliVTrack *GetVTrack(Int_t /*i*/) const {return NULL;}
+ //virtual AliVTrack *GetVTrack(Int_t /*i*/) {return NULL;}
//virtual Int_t AddTrack(const AliVParticle *t) = 0;
virtual Int_t GetNumberOfTracks() const = 0;
virtual Int_t GetNumberOfV0s() const = 0;
virtual Int_t GetPrimaryVertexTracks( AliESDVertex & ) const {return 0;}
virtual void ConnectTracks() {}
+ virtual EDataLayoutType GetDataLayoutType() const = 0;
+ const char* Whoami();
ClassDef(AliVEvent, 3) // base class for AliEvent data
};
// HLT
virtual Bool_t InitTaskInputData(AliVEvent* /*event*/, AliVfriendEvent* /*esdFriend*/, TObjArray* /*arrTasks*/) {return kTRUE;};
virtual AliVEvent* GetEvent() const {return 0x0;};
- virtual AliVfriendEvent* GetVFriendEvent() const {return 0x0;};
+ virtual AliVfriendEvent* GetVfriendEvent() const {return 0x0;};
private :
ClassDef(AliVEventHandler, 1);
--- /dev/null
+//dummy implementation file
--- /dev/null
+//implementation file
virtual UShort_t GetTPCsignalN() const {return 0 ;}
virtual Double_t GetTPCmomentum() const {return 0.;}
virtual Double_t GetTPCTgl() const {return 0.;}
+ virtual Double_t GetTgl() const {return 0.;}
virtual Double_t GetTOFsignal() const {return 0.;}
virtual Double_t GetTOFsignalTunedOnData() const {return 0.;}
virtual Double_t GetHMPIDsignal() const {return 0.;}
virtual void GetDirection(Double_t []) const {;}
virtual Double_t GetLinearD(Double_t /*xv*/, Double_t /*yv*/) const {return 0;}
virtual void GetDZ(Double_t /*x*/,Double_t /*y*/,Double_t /*z*/,Double_t /*b*/,Float_t [] /*dz[2]*/) const {;}
- virtual Double_t GetTgl() const {return 0;}
virtual Char_t GetITSclusters(Int_t */**idx*/) const {return 0;}
virtual UChar_t GetTRDclusters(Int_t */**idx*/) const {return 0;}
--- /dev/null
+//implementation file
--- /dev/null
+//implementation file
#include "AliAnalysisManager.h"
#include "AliESDEvent.h"
-//#include "AliFlatESDEvent.h"
#include "AliESDtrackCuts.h"
#include "AliVEventHandler.h"
#include "AliTPCseed.h"
#include "AliTPCclusterMI.h"
#include "AliVfriendEvent.h"
#include "AliVfriendTrack.h"
+#include "AliESDInputHandler.h"
#include "AliAnalysisTaskPt.h"
TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
if (!tree) {
Printf("ERROR: Could not read chain from input slot 0");
- } else {
+ }
+ else {
// Disable all branches and enable only the needed ones
// The next two lines are different when data produced as AliESDEvent is read
/*
if (!esdH) {
Printf("ERROR: Could not get ESDInputHandler");
- } else {
+ }
+ else {
Printf("----> AliAnalysisTaskPt::ConnectInputData Getting the event from handler %p", esdH);
- //fESD = dynamic_cast<AliFlatESDEvent*>(esdH->GetEvent());
fESD = esdH->GetEvent();
- if (fUseFriends){
- fESDfriend = esdH->GetVFriendEvent();
+ if (fUseFriends){
+ Printf("...We have to use the friends...");
+ if (classInputHandler.Contains("HLT")) { // we are running in HLT
+ fESDfriend = esdH->GetVfriendEvent();
+ }
+ else { /// we are running offline
+ if (esdH && esdH->GetTree()) {
+ Printf("...We got the tree...");
+ if (esdH->GetTree()->GetBranch("ESDfriend.")){
+ Printf("Yu-huuuu!!! friend branch found");
+ fESDfriend = ((AliESDInputHandler*)esdH)->GetESDfriend();
+ }
+ else {
+ Printf("No friend branch found");
+ }
+ }
+ }
+ Printf("and the result is: fESDfriend = %p", fESDfriend);
+ }
+ else {
+ Printf("The friends are not requested");
}
}
if (!fESD) {
Printf("ERROR: fESD not available");
return;
}
- if (!fESDfriend) {
- Printf("ERROR: fESDfriend not available");
- if (fUseFriends){
+
+ /*
+ if (fUseFriends){
+ Printf("In Exec: ...We have to use the friends...");
+ fESDfriend = fESD->FindFriend();
+ Printf("...and we got friends = %p", fESDfriend);
+ if (!fESDfriend) {
+ Printf("ERROR: fESDfriend not available");
return;
- }
+ }
+ }
+ */
+
+ if (fUseFriends){
+ Printf("In Exec: ...We have to use the friends...");
+ Printf("...and we got friends = %p", fESDfriend);
+ if (!fESDfriend) {
+ Printf("ERROR: fESDfriend not available");
+ return;
+ }
}
Int_t nESDtracks = fESD->GetNumberOfTracks();
// Track loop to fill a pT spectrum
for (Int_t iTracks = 0; iTracks < nESDtracks; iTracks++) {
- Printf("Checking track %d: Note that with Flat, the GetTrack is not yet implemented!!!", iTracks);
+ Printf("Checking track %d", iTracks);
const AliVTrack* track = dynamic_cast<AliVTrack*>(fESD->GetTrack(iTracks));
if (!track) {
Printf("ERROR: Could not receive track %d", iTracks);
if (fUseFriends){
+ Printf("In the loop over the friends");
// Friend Track loop
for (Int_t iFriend = 0; iFriend < nESDfriendtracks; iFriend++) {
- //Printf("Getting friend %d", iFriend);
+ Printf("Getting friend %d", iFriend);
const AliVfriendTrack* friendTrack = fESDfriend->GetTrack(iFriend);
if (!friendTrack) {
Printf("ERROR: Could not receive track %d", iFriend);
continue;
}
+ else {
+ Printf("friend track = %p", friendTrack);
+ }
AliTPCseed seed;
Int_t err = friendTrack->GetTPCseed( seed );
+ Printf("err = %d", err);
if( err==0 ){
Printf("Found TPC seed" );
for (Int_t irow = 0; irow < 160; irow++){
if (!fClusterOwner) for(Int_t i = 0;i<160;++i)fClusterPointer[i] = param.fClusterPointer[i];
else for(Int_t i = 0;i<160;++i) {
delete fClusterPointer[i];
- fClusterPointer[i] = new AliTPCclusterMI(*(param.fClusterPointer[i]));
+ if (param.fClusterPointer[i]) {
+ fClusterPointer[i] = new AliTPCclusterMI(*(param.fClusterPointer[i]));
+ }
+ else {
+ fClusterPointer[i] = 0x0;
+ }
}
// leave out fPoint, they are also not copied in the copy ctor...
// but deleted in the dtor... strange...
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff