// loop over events and fill them
// Multiplicity information needed by the header (to be revised!)
Int_t nTracks = esd->GetNumberOfTracks();
- for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
+
+// The line below should not be needed anymore (tracks already connected)
+// for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) esd->GetTrack(iTrack)->SetESDEvent(esd);
// Update the header
Int_t nV0s = esd->GetNumberOfV0s();
ClassImp(AliITSUSuze02)
-AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols) {
- if(Ncols%(kNumberOfFSBB*kNumberOfHalfFSBB)==0){
- fNRowsModule=Nrows;
- fNColsModule=Ncols;
- fModule=new TMatrixF(fNRowsModule,fNColsModule);
-
- fNWindowsPer32colsMax=0;
- fNWindowsPerHalfFSBBMax=0;
- fNWindowsPerFSBBMax=0;
-
- fTestColumnSize=2;
- fTestRowSize=2;
- }
- else{
+AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols):
+ fNRowsModule(Nrows),
+ fNColsModule(Ncols),
+ fModule(new TMatrixF(Nrows,Ncols)),
+ fTestColumnSize(2),
+ fTestRowSize(2),
+ fNWindowsPer32colsMax(0),
+ fNWindowsPerHalfFSBBMax(0),
+ fNWindowsPerFSBBMax(0),
+ fNDigitsEncoded(0),
+ fNEncodedWindows(0),
+ fNDigitsLost(0),
+ fNLostWindows(0),
+ fDataSizePerModule(0),
+ fNWindowsPer32colsMin(0),
+ fNWindowsPerHalfFSBBMin(0),
+ fNWindowsPerFSBBMin(0)
+{
+ if (Ncols%(kNumberOfFSBB*kNumberOfHalfFSBB) != 0) {
printf("Number of columns should be multiple of %d. SUZE matrix wasn't created\n",kNumberOfFSBB*kNumberOfHalfFSBB);
}
}
+AliITSUSuze02::AliITSUSuze02(const AliITSUSuze02& suze):
+ fNRowsModule(suze.fNRowsModule),
+ fNColsModule(suze.fNColsModule),
+ fModule(new TMatrixF(*suze.fModule)),
+ fTestColumnSize(suze.fTestColumnSize),
+ fTestRowSize(suze.fTestRowSize),
+ fNWindowsPer32colsMax(suze.fNWindowsPer32colsMax),
+ fNWindowsPerHalfFSBBMax(suze.fNWindowsPerHalfFSBBMax),
+ fNWindowsPerFSBBMax(suze.fNWindowsPerFSBBMax),
+ fNDigitsEncoded(suze.fNDigitsEncoded),
+ fNEncodedWindows(suze.fNEncodedWindows),
+ fNDigitsLost(suze.fNDigitsLost),
+ fNLostWindows(suze.fNLostWindows),
+ fDataSizePerModule(suze.fDataSizePerModule),
+ fNWindowsPer32colsMin(suze.fNWindowsPer32colsMin),
+ fNWindowsPerHalfFSBBMin(suze.fNWindowsPerHalfFSBBMin),
+ fNWindowsPerFSBBMin(suze.fNWindowsPerFSBBMin)
+{
+}
+
+AliITSUSuze02 &AliITSUSuze02::operator=(const AliITSUSuze02& suze) {
+ if (&suze == this) return *this;
+
+ fNRowsModule = suze.fNRowsModule;
+ fNColsModule = suze.fNColsModule;
+ fModule = new TMatrixF(*suze.fModule);
+ fTestColumnSize = suze.fTestColumnSize;
+ fTestRowSize = suze.fTestRowSize;
+ fNWindowsPer32colsMax = suze.fNWindowsPer32colsMax;
+ fNWindowsPerHalfFSBBMax = suze.fNWindowsPerHalfFSBBMax;
+ fNWindowsPerFSBBMax = suze.fNWindowsPerFSBBMax;
+ fNDigitsEncoded = suze.fNDigitsEncoded;
+ fNEncodedWindows = suze.fNEncodedWindows;
+ fNDigitsLost = suze.fNDigitsLost;
+ fNLostWindows = suze.fNLostWindows;
+ fDataSizePerModule = suze.fDataSizePerModule;
+ fNWindowsPer32colsMin = suze.fNWindowsPer32colsMin;
+ fNWindowsPerHalfFSBBMin = suze.fNWindowsPerHalfFSBBMin;
+ fNWindowsPerFSBBMin = suze.fNWindowsPerFSBBMin;
+
+ return *this;
+}
+
AliITSUSuze02::~AliITSUSuze02() {
if(fModule) delete fModule;
}
class AliITSUSuze02{
public:
AliITSUSuze02(Int_t Nrows, Int_t Ncols);
+ AliITSUSuze02(const AliITSUSuze02& suze);
+ AliITSUSuze02 &operator=(const AliITSUSuze02& suze);
virtual ~AliITSUSuze02();
void SetEncodingWindowSize(Int_t Wrows, Int_t Wcols);
TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,alpha*TMath::RadToDeg());
//AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation-dy, 0);
- AddTranslationToCombiTrans(ctSideR, 0, ladderHeight/2-2.85/*2.765250/*triangleHeight*/, 0);
+ AddTranslationToCombiTrans(ctSideR, 0, ladderHeight/2-2.85/*2.765250*//*triangleHeight*/, 0);
TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown,0,-alpha*TMath::RadToDeg());
//AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation-dy, 0);
AddTranslationToCombiTrans(ctSideL, 0, ladderHeight/2-2.85/*triangleHeight*/, 0);
-AliAnalysisTask *AddTask_Remi_LMEEPbPb2011AODSemiCent1(Char_t* outputFileName="LMEEoutput.root", Bool_t runAll=kFALSE,Bool_t setMC=kFALSE,Bool_t getFromAlien=kFALSE, Bool_t PIDbaseline=kFALSE, Bool_t rejOnly=kTRUE) {
+AliAnalysisTask *AddTask_Remi_LMEEPbPb2011AOD_SemiCent1(Char_t* outputFileName="LMEEoutput.root", Bool_t runAll=kFALSE,Bool_t setMC=kFALSE,Bool_t getFromAlien=kFALSE, Bool_t PIDbaseline=kFALSE, Bool_t rejOnly=kTRUE) {
Bool_t bESDANA=kFALSE; //Autodetect via InputHandler
//get the current analysis manager
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * 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. *
+ **************************************************************************/
+
+#include "TBits.h"
+#include "TRefArray.h"
+
+#include "AliVCluster.h"
+
+// Analysis task to fill histograms with PHOS ESD or AOD clusters and cells
+// Authors : Henrik Qvigstad
+// Date : 28.05.2011
+/* $Id$ */
+
+#include "AliPHOSClusterSelectionTask.h"
+ClassImp(AliPHOSClusterSelectionTask);
+
+AliPHOSClusterSelectionTask::AliPHOSClusterSelectionTask(const char* name = "AliPHOSClusterSelectionTask")
+ : AliAnalysisTaskSE(name),
+ fClusters(0x0)
+{
+ return;
+}
+
+AliPHOSClusterSelectionTask::~AliPHOSClusterSelectionTask()
+{
+ delete fClusters;
+}
+
+void AliPHOSClusterSelectionTask::UserCreateOutputObjects()
+{
+ //TODO: implement
+ return;
+}
+
+void AliPHOSClusterSelectionTask::UserExec(Option_t *option)
+{
+ AliVEvent* event = InputEvent();
+
+ if( 0x0 == fClusters ) fClusters = new TRefArray;
+ // Get PHOS Clusters
+ event->GetPHOSClusters( fClusters );
+
+ // Remove Clusters
+ for(int index = 0; index < fClusters->GetEntriesFast(); ++index) {
+ AliVCluster* cluster = (AliVCluster*) fClusters->At(iClu);
+
+ if( cluster->E() < kMinClusterEnergy // Low Energy Clusters
+ || cluster->GetDistanceToBadChannel() < kMinBCDistance // to close to Bad Channel
+ || cluster->GetNCells() < kMinNCells // to few cells
+ || cluster->GetM02() < kMinM02
+ )
+ fClusters->RemoveAt(index);
+ }
+
+ // Compact array after removel of clusters
+ fClusters->Compact();
+}
+
+TRefArray* AliPHOSClusterSelectionTask::GetPHOSClusters() const
+{
+ return fClusters;
+}
+
+TBits* AliPHOSClusterSelectionTask::GetPHOSClustersSelected(const AliPHOSClusterSelection* selection)
+{
+ int nClu = fClusters->GetEntriesFast();
+
+ static TBits* sBits = 0x0;
+ if( 0x0 == sBits ) sBits = new TBits(nClu);
+
+ if( sBits->GetNbits != nClu ){
+ delete sBits;
+ sBits = new TBits( nClu );
+ }
+
+
+ // Determine selection:
+ for(int iClu = 0; iClu < nClu; ++iClu) {
+ AliVCluster* cluster = (AliVCluster*) fClusters->At(iClu);
+ bool sel = selection->IsSelected(cluster);
+ sBits->SetBitNumber(iClu, sel);
+ }
+
+ return sBits;
+
+
+ // TMap initialization
+ if( 0x0 == fSelectionMap ) {
+ fSelectionMap = new TMap;
+ fSelectionMap->SetOwnerValue(true);
+ }
+
+ // Fetch Selection Bits
+ TObject* value = fSelectionMap->GetValue(selection);
+}
+
+
+static AliPHOSClusterSelectionTask* AliPHOSClusterSelectionTask::GetTask(const char* name)
+{
+ // Get AliPHOSClusterSelectionTask from AliAnalysisManager
+
+ AliAnalysisManager* analysisManager = dynamic_cast<AliAnalysisManager*>(AliAnalysisManager::GetAnalysisManager());
+ AliAnalysisTask* task = analysisManager->GetTask(name);
+ if( !task ) AliWarning( Form("No task with name: %s", name) );
+
+ AliPHOSClusterSelectionTask* stask = dynamic_cast<AliAnalysisTask*>(task);
+ if( !stask) AliWarning( Form("No AliPHOSClusterSelectionTask with name: %s", name) );
+
+ return stask;
+}
* See cxx source for full Copyright notice */
// Analysis Task for selecting PHOS clusters for other analysis
+// Makes some basic selections cuts, universal to all PHOS Analysis.
+// Additional selection cuts can be applied via AliPHOSClusterSelection.
+//
// Authors : Henrik Qvigstad
// Date : 16.01.2014
/* $Id$ */
-class AliVCluster;
+class TBits;
+class TRefArray;
-#include "TArrayI.h"
+class AliVCluster;
#include "AliAnalysisTaskSE.h"
virtual void UserExec(Option_t *option);
/* virtual void Terminate(Option_t *); */
- int GetNClusters() const; // Number of clusters in the current event
- AliVCluster* GetCluster(int index) const; // get cluster of index
- TArrayI GetIndexOfSelected(const AliPHOSClusterSelection* selection) const;
+ TRefArray* GetPHOSClusters() const;
+ virtual TBits* GetPHOSClustersSelected(const AliPHOSClusterSelection* selection);
+
+ static AliPHOSClusterSelectionTask* GetTask(const char* name = "AliPHOSClusterSelectionTask");
protected:
AliPHOSClusterSelectionTask(const AliPHOSClusterSelectionTask&); // not implemented
AliPHOSClusterSelectionTask& operator=(const AliPHOSClusterSelectionTask&); // not implemented
+ TRefArray* fClusters;
+
+ // cluster cut variables:
+ static const Double_t kMinClusterEnergy;
+ static const Double_t kMinBCDistance; //distance to nearest bad channel
+ static const Int_t kMinNCells;
+ static const Double_t kMinM02;
ClassDef(AliPHOSClusterSelectionTask, 1);
};
AliHFEpidQAmanager *fPIDqa; //! PID QA manager
AliFlowTrackCuts *fCutsRP; // track cuts for reference particles
AliFlowTrackCuts *fNullCuts; // dummy cuts for flow event tracks
- AliFlowEvent *fFlowEvent; // flow events Inclusive e
+ AliFlowEvent *fFlowEvent; //! flow events Inclusive e
const char *fkCentralityMethod; // method used to determine centrality (V0 by default)
Double_t fCentrality; // event centrality for QA
Double_t fCentralityMin; // lower bound of cenrality bin
AliHFEpidQAmanager *fPIDqa; //! PID QA manager
AliFlowTrackCuts *fCutsRP; // track cuts for reference particles
AliFlowTrackCuts *fNullCuts; // dummy cuts for flow event tracks
- AliFlowEvent *fFlowEvent; // flow events Inclusive e
+ AliFlowEvent *fFlowEvent; //! flow events Inclusive e
const char *fkCentralityMethod; // method used to determine centrality (V0 by default)
Double_t fCentrality; // event centrality for QA
Double_t fCentralityMin; // lower bound of cenrality bin
// time of flight QA
// - distribution of (time - t0 - pion_time)
- Double_t times[5];
+ Double_t times[AliPID::kSPECIESC];
esdTrack->GetIntegratedTimes(times);
Double_t tItrackL = esdTrack->GetIntegratedLength();
Double_t tTOFsignal = esdTrack->GetTOFsignal();
if (vert)
vert->GetXYZ(fVertex);
- if (fOutTracks)
- fOutTracks->Delete();
- if (fOutClusters)
- fOutClusters->Delete();
- if (fOutMCParticles)
- fOutMCParticles->Delete();
+ if (fCopyArray) {
+ if (fOutTracks)
+ fOutTracks->Delete();
+ if (fOutClusters)
+ fOutClusters->Delete();
+ if (fOutMCParticles)
+ fOutMCParticles->Delete();
+ }
if (fDensitySpectrum) {
fNTracks = TMath::Nint(fDensitySpectrum->GetRandom());
fAODObjects(0),
fAODFolder(0),
fConnected(kFALSE),
+ fTracksConnected(kFALSE),
fHeader(0),
fTracks(0),
fVertices(0),
fAODObjects(new TList()),
fAODFolder(0),
fConnected(kFALSE),
+ fTracksConnected(kFALSE),
fHeader(new AliAODHeader(*aod.fHeader)),
fTracks(new TClonesArray(*aod.fTracks)),
fVertices(new TClonesArray(*aod.fVertices)),
AddObject(fTOFHeader);
AddObject(fTrdTracks);
fConnected = aod.fConnected;
+ ConnectTracks();
GetStdContent();
CreateStdFolders();
}
}
}
fConnected = aod.fConnected;
+ fTracksConnected = kFALSE;
+ ConnectTracks();
return *this;
}
}
}
+//______________________________________________________________________________
+Int_t AliAODEvent::AddTrack(const AliAODTrack* trk)
+{
+// Add new AOD track. Make sure to set the event if needed.
+ AliAODTrack *track = new((*fTracks)[fTracks->GetEntriesFast()]) AliAODTrack(*trk);
+ track->SetAODEvent(this);
+ return fTracks->GetEntriesFast()-1;
+}
+
//______________________________________________________________________________
void AliAODEvent::RemoveObject(TObject* obj)
{
}
}
+//______________________________________________________________________________
void AliAODEvent::CreateStdFolders()
{
// Create the standard folder structure
//______________________________________________________________________________
void AliAODEvent::ResetStd(Int_t trkArrSize,
- Int_t vtxArrSize,
- Int_t v0ArrSize,
- Int_t cascadeArrSize,
- Int_t jetSize,
- Int_t caloClusSize,
- Int_t fmdClusSize,
- Int_t pmdClusSize,
- Int_t hmpidRingsSize,
- Int_t dimuonArrSize,
- Int_t nTrdTracks
+ Int_t vtxArrSize,
+ Int_t v0ArrSize,
+ Int_t cascadeArrSize,
+ Int_t jetSize,
+ Int_t caloClusSize,
+ Int_t fmdClusSize,
+ Int_t pmdClusSize,
+ Int_t hmpidRingsSize,
+ Int_t dimuonArrSize,
+ Int_t nTrdTracks
)
{
// deletes content of standard arrays and resets size
+ fTracksConnected = kFALSE;
if (fTracks) {
fTracks->Delete();
if (trkArrSize > fTracks->GetSize())
}
+//______________________________________________________________________________
void AliAODEvent::ClearStd()
{
// clears the standard arrays
if (fHeader)
fHeader ->Clear();
+ fTracksConnected = kFALSE;
if (fTracks)
fTracks ->Delete();
if (fVertices)
return;
}
+//______________________________________________________________________________
void AliAODEvent::AssignIDtoCollection(const TCollection* col)
{
// Static method which assigns a ID to each object in a collection
TProcessID::AssignID(obj);
}
+//______________________________________________________________________________
Bool_t AliAODEvent::IsPileupFromSPDInMultBins() const {
Int_t nTracklets=GetTracklets()->GetNumberOfTracklets();
if(nTracklets<20) return IsPileupFromSPD(3,0.8);
else return IsPileupFromSPD(5,0.8);
}
+//______________________________________________________________________________
void AliAODEvent::Reset()
{
// Handle the cases
// Std content + Non std content
ClearStd();
-
if(fAODObjects->GetSize()>kAODListN){
// we have non std content
// this also covers aodfriends
AliAODTrdTrack& AliAODEvent::AddTrdTrack(const AliVTrdTrack *track) {
return *(new ((*fTrdTracks)[fTrdTracks->GetEntriesFast()]) AliAODTrdTrack(*track));
}
+
+//______________________________________________________________________________
+void AliAODEvent::ConnectTracks() {
+// Connect tracks to this event
+ if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
+ AliAODTrack *track;
+ TIter next(fTracks);
+ while ((track=(AliAODTrack*)next())) track->SetAODEvent(this);
+ fTracksConnected = kTRUE;
+}
+
TList *GetList() const { return fAODObjects; }
void SetConnected(Bool_t conn=kTRUE) {fConnected=conn;}
Bool_t GetConnected() const {return fConnected;}
+ Bool_t AreTracksConnected() const {return fTracksConnected;}
// -- Header
AliAODHeader *GetHeader() const { return fHeader; }
// -- Tracks
TClonesArray *GetTracks() const { return fTracks; }
+ void ConnectTracks();
Int_t GetNTracks() const { return fTracks? fTracks->GetEntriesFast() : 0; }
Int_t GetNumberOfTracks() const { return GetNTracks(); }
- AliAODTrack *GetTrack(Int_t nTrack) const { if(fTracks && fTracks->UncheckedAt(nTrack)) ((AliAODTrack*)fTracks->UncheckedAt(nTrack))->SetAODEvent(this);return fTracks ? (AliAODTrack*)fTracks->UncheckedAt(nTrack):0; }
- Int_t AddTrack(const AliAODTrack* trk)
- {new((*fTracks)[fTracks->GetEntriesFast()]) AliAODTrack(*trk); return fTracks->GetEntriesFast()-1;}
+ AliAODTrack *GetTrack(Int_t nTrack) const { return fTracks ? (AliAODTrack*)fTracks->UncheckedAt(nTrack):0; }
+ Int_t AddTrack(const AliAODTrack* trk);
Int_t GetMuonTracks(TRefArray *muonTracks) const;
Int_t GetNumberOfMuonTracks() const;
TList *fAODObjects; // list of AODObjects
TFolder *fAODFolder; // folder structure of branches
Bool_t fConnected; //! flag if leaves are alreday connected
+ Bool_t fTracksConnected; //! flag if tracks have already pointer to event set
// standard content
AliAODHeader *fHeader; //! event information
TClonesArray *fTracks; //! charged tracks
fIsSelectedResult = fEvent->GetHeader()->GetOfflineTrigger();
if (fMixingHandler) fMixingHandler->BeginEvent(entry);
-
+
+ // set transient pointer to event inside tracks
+ fEvent->ConnectTracks();
+
return kTRUE;
}
void GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
const AliAODEvent* GetAODEvent() const {return fAODEvent;}
+ virtual const AliVEvent* GetEvent() const {return (AliVEvent*)fAODEvent;}
void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
const AliTOFHeader* GetTOFHeader() const;
Double_t fTPCsignalTuned; //! TPC signal tuned on data when using MC
Double_t fTOFsignalTuned; //! TOF signal tuned on data when using MC
- const AliAODEvent* fAODEvent; //!
+ const AliAODEvent* fAODEvent; //! pointer back to the event the track belongs to
ClassDef(AliAODTrack, 23);
};
fESDFriendOld(0),
fConnected(kFALSE),
fUseOwnList(kFALSE),
+ fTracksConnected(kFALSE),
fTOFHeader(0),
fCentrality(0),
fEventplane(0),
fESDFriendOld(esd.fESDFriendOld ? new AliESDfriend(*esd.fESDFriendOld) : 0),
fConnected(esd.fConnected),
fUseOwnList(esd.fUseOwnList),
+ fTracksConnected(kFALSE),
fTOFHeader(new AliTOFHeader(*esd.fTOFHeader)),
fCentrality(new AliCentrality(*esd.fCentrality)),
fEventplane(new AliEventplane(*esd.fEventplane)),
AddObject(fMuonClusters);
AddObject(fMuonPads);
GetStdContent();
+ ConnectTracks();
}
//______________________________________________________________________________
fConnected = source.fConnected;
fUseOwnList = source.fUseOwnList;
-
+
fDetectorStatus = source.fDetectorStatus;
fDAQDetectorPattern = source.fDAQDetectorPattern;
fDAQAttributes = source.fDAQAttributes;
*fTOFcluster = *source.fTOFcluster;
// fTOFcluster = new TObjArray(*(source.fTOFcluster));
-
+ fTracksConnected = kFALSE;
+ ConnectTracks();
return *this;
}
}
+//______________________________________________________________________________
Bool_t AliESDEvent::ResetWithPlacementNew(TObject *pObject){
//
// funtion to reset using the already allocated space
return kTRUE;
}
+//______________________________________________________________________________
void AliESDEvent::ResetStdContent()
{
// Reset the standard contents
if(fEMCALTrigger)fEMCALTrigger->DeAllocate();
if(fSPDPileupVertices)fSPDPileupVertices->Delete();
if(fTrkPileupVertices)fTrkPileupVertices->Delete();
+ fTracksConnected = kFALSE;
if(fTracks)fTracks->Delete();
if(fMuonTracks)fMuonTracks->Clear("C");
if(fMuonClusters)fMuonClusters->Clear("C");
}
+//______________________________________________________________________________
Int_t AliESDEvent::AddV0(const AliESDv0 *v) {
//
// Add V0
return;
}
-void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const {
- //
- // Attaches the complementary info to the ESD
- //
+//______________________________________________________________________________
+void AliESDEvent::SetESDfriend(const AliESDfriend *ev) const
+{
+//
+// Attaches the complementary info to the ESD
+//
if (!ev) return;
// to be sure that we set the tracks also
}
}
-Bool_t AliESDEvent::RemoveKink(Int_t rm) const {
- // ---------------------------------------------------------
- // Remove a kink candidate and references to it from ESD,
- // if this candidate does not come from a reconstructed decay
- // Not yet implemented...
- // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t AliESDEvent::RemoveKink(Int_t rm) const
+{
+// ---------------------------------------------------------
+// Remove a kink candidate and references to it from ESD,
+// if this candidate does not come from a reconstructed decay
+// Not yet implemented...
+// ---------------------------------------------------------
Int_t last=GetNumberOfKinks()-1;
if ((rm<0)||(rm>last)) return kFALSE;
return kTRUE;
}
-Bool_t AliESDEvent::RemoveV0(Int_t rm) const {
- // ---------------------------------------------------------
- // Remove a V0 candidate and references to it from ESD,
- // if this candidate does not come from a reconstructed decay
- // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t AliESDEvent::RemoveV0(Int_t rm) const
+{
+// ---------------------------------------------------------
+// Remove a V0 candidate and references to it from ESD,
+// if this candidate does not come from a reconstructed decay
+// ---------------------------------------------------------
Int_t last=GetNumberOfV0s()-1;
if ((rm<0)||(rm>last)) return kFALSE;
return kTRUE;
}
-Bool_t AliESDEvent::RemoveTrack(Int_t rm) const {
- // ---------------------------------------------------------
- // Remove a track and references to it from ESD,
- // if this track does not come from a reconstructed decay
- // ---------------------------------------------------------
+//______________________________________________________________________________
+Bool_t AliESDEvent::RemoveTrack(Int_t rm) const
+{
+// ---------------------------------------------------------
+// Remove a track and references to it from ESD,
+// if this track does not come from a reconstructed decay
+// ---------------------------------------------------------
Int_t last=GetNumberOfTracks()-1;
if ((rm<0)||(rm>last)) return kFALSE;
return kTRUE;
}
-
-Bool_t AliESDEvent::Clean(Float_t *cleanPars) {
+//______________________________________________________________________________
+Bool_t AliESDEvent::Clean(Float_t *cleanPars)
+{
//
// Remove the data which are not needed for the physics analysis.
//
return rc;
}
+//______________________________________________________________________________
Char_t AliESDEvent::AddPileupVertexSPD(const AliESDVertex *vtx)
{
// Add a pileup primary vertex reconstructed with SPD
return n;
}
+//______________________________________________________________________________
Char_t AliESDEvent::AddPileupVertexTracks(const AliESDVertex *vtx)
{
// Add a pileup primary vertex reconstructed with SPD
return n;
}
+//______________________________________________________________________________
Int_t AliESDEvent::AddTrack(const AliESDtrack *t)
{
// Add track
TClonesArray &ftr = *fTracks;
AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack(*t);
track->SetID(fTracks->GetEntriesFast()-1);
+ track->SetESDEvent(this);
return track->GetID();
}
+//______________________________________________________________________________
AliESDtrack* AliESDEvent::NewTrack()
{
// Add a new track
TClonesArray &ftr = *fTracks;
AliESDtrack * track = new(ftr[fTracks->GetEntriesFast()])AliESDtrack();
track->SetID(fTracks->GetEntriesFast()-1);
+ track->SetESDEvent(this);
return track;
}
return new(fmu[fMuonPads->GetEntriesFast()]) AliESDMuonPad();
}
+//______________________________________________________________________________
void AliESDEvent::AddPmdTrack(const AliESDPmdTrack *t)
{
TClonesArray &fpmd = *fPmdTracks;
new(fpmd[fPmdTracks->GetEntriesFast()]) AliESDPmdTrack(*t);
}
+//______________________________________________________________________________
void AliESDEvent::SetTrdTrigger(const AliESDTrdTrigger *t)
{
*fTrdTrigger = *t;
}
+//______________________________________________________________________________
void AliESDEvent::AddTrdTrack(const AliESDTrdTrack *t)
{
TClonesArray &ftrd = *fTrdTracks;
new(ftrd[fTrdTracks->GetEntriesFast()]) AliESDTrdTrack(*t);
}
+//______________________________________________________________________________
void AliESDEvent::AddTrdTracklet(const AliESDTrdTracklet *trkl)
{
new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(*trkl);
}
+//______________________________________________________________________________
void AliESDEvent::AddTrdTracklet(UInt_t trackletWord, Short_t hcid, Int_t label)
{
new ((*fTrdTracklets)[fTrdTracklets->GetEntriesFast()]) AliESDTrdTracklet(trackletWord, hcid, label);
}
+//______________________________________________________________________________
Int_t AliESDEvent::AddKink(const AliESDkink *c)
{
- // Add kink
- TClonesArray &fk = *fKinks;
- AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
- kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
- return fKinks->GetEntriesFast()-1;
+ // Add kink
+ TClonesArray &fk = *fKinks;
+ AliESDkink * kink = new(fk[fKinks->GetEntriesFast()]) AliESDkink(*c);
+ kink->SetID(fKinks->GetEntriesFast()); // CKB different from the other imps..
+ return fKinks->GetEntriesFast()-1;
}
+//______________________________________________________________________________
void AliESDEvent::AddCascade(const AliESDcascade *c)
{
TClonesArray &fc = *fCascades;
new(fc[fCascades->GetEntriesFast()]) AliESDcascade(*c);
}
+//______________________________________________________________________________
void AliESDEvent::AddCosmicTrack(const AliESDCosmicTrack *t)
{
TClonesArray &ft = *fCosmicTracks;
}
+//______________________________________________________________________________
Int_t AliESDEvent::AddCaloCluster(const AliESDCaloCluster *c)
{
- // Add calocluster
- TClonesArray &fc = *fCaloClusters;
- AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
- clus->SetID(fCaloClusters->GetEntriesFast()-1);
- return fCaloClusters->GetEntriesFast()-1;
- }
+ // Add calocluster
+ TClonesArray &fc = *fCaloClusters;
+ AliESDCaloCluster *clus = new(fc[fCaloClusters->GetEntriesFast()]) AliESDCaloCluster(*c);
+ clus->SetID(fCaloClusters->GetEntriesFast()-1);
+ return fCaloClusters->GetEntriesFast()-1;
+}
+//______________________________________________________________________________
void AliESDEvent::AddRawDataErrorLog(const AliRawDataErrorLog *log) const {
TClonesArray &errlogs = *fErrorLogs;
new(errlogs[errlogs.GetEntriesFast()]) AliRawDataErrorLog(*log);
}
+//______________________________________________________________________________
void AliESDEvent::SetZDCData(const AliESDZDC * obj)
{
// use already allocated space
*fESDZDC = *obj;
}
+//______________________________________________________________________________
void AliESDEvent::SetPrimaryVertexTPC(const AliESDVertex *vertex)
{
// Set the TPC vertex
}
}
+//______________________________________________________________________________
void AliESDEvent::SetPrimaryVertexSPD(const AliESDVertex *vertex)
{
// Set the SPD vertex
}
}
+//______________________________________________________________________________
void AliESDEvent::SetPrimaryVertexTracks(const AliESDVertex *vertex)
{
// Set the primary vertex reconstructed using he ESD tracks.
}
}
+//______________________________________________________________________________
const AliESDVertex * AliESDEvent::GetPrimaryVertex() const
{
//
return fSPDVertex;
}
+//______________________________________________________________________________
AliESDVertex * AliESDEvent::PrimaryVertexTracksUnconstrained() const
{
//
return vertex;
}
+//______________________________________________________________________________
void AliESDEvent::SetMultiplicity(const AliMultiplicity *mul)
{
// Set the SPD Multiplicity
}
+//______________________________________________________________________________
void AliESDEvent::SetFMDData(AliESDFMD * obj)
{
// use already allocated space
}
}
+//______________________________________________________________________________
void AliESDEvent::SetVZEROData(const AliESDVZERO * obj)
{
// use already allocated space
*fESDVZERO = *obj;
}
+//______________________________________________________________________________
void AliESDEvent::SetTZEROData(const AliESDTZERO * obj)
{
// use already allocated space
}
+//______________________________________________________________________________
void AliESDEvent::SetACORDEData(AliESDACORDE * obj)
{
if(fESDACORDE)
*fESDACORDE = *obj;
}
+//______________________________________________________________________________
void AliESDEvent::SetADData(AliESDAD * obj)
{
if(fESDAD)
*fESDAD = *obj;
}
-
-
+//______________________________________________________________________________
void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
{
//
if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
}
+//______________________________________________________________________________
void AliESDEvent::AddObject(TObject* obj)
{
// Add an object to the list of object.
fESDObjects->AddLast(obj);
}
-
+//______________________________________________________________________________
void AliESDEvent::GetStdContent()
{
// set pointers for standard content
fTOFcluster = new TObjArray(1);
}
+//______________________________________________________________________________
void AliESDEvent::SetStdNames(){
// Set the names of the standard contents
//
}
}
-
+//______________________________________________________________________________
void AliESDEvent::CreateStdContent(Bool_t bUseThisList){
fUseOwnList = bUseThisList;
CreateStdContent();
}
+//______________________________________________________________________________
void AliESDEvent::CreateStdContent()
{
// create the standard AOD content and set pointers
GetStdContent();
}
+//______________________________________________________________________________
void AliESDEvent::CompleteStdContent()
{
// Create missing standard objects and add them to the TList of objects
}
}
+//______________________________________________________________________________
TObject* AliESDEvent::FindListObject(const char *name) const {
//
// Find object with name "name" in the list of branches
return 0;
}
+//______________________________________________________________________________
Int_t AliESDEvent::GetPHOSClusters(TRefArray *clusters) const
{
// fills the provided TRefArray with all found phos clusters
return clusters->GetEntriesFast();
}
+//______________________________________________________________________________
Int_t AliESDEvent::GetEMCALClusters(TRefArray *clusters) const
{
// fills the provided TRefArray with all found emcal clusters
return clusters->GetEntriesFast();
}
+//______________________________________________________________________________
void AliESDEvent::WriteToTree(TTree* tree) const {
// Book the branches as in TTree::Branch(TCollection*)
// but add a "." at the end of top level branches which are
tree->Branch("fTOFcluster","TObjArray",(void *) &fTOFcluster);
}
-
+//______________________________________________________________________________
void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
//
// Connect the ESDEvent to a tree
}
}
-
+//______________________________________________________________________________
void AliESDEvent::CopyFromOldESD()
{
// Method which copies over everthing from the old esd structure to the
}// if fesdold
}
+//______________________________________________________________________________
Bool_t AliESDEvent::IsEventSelected(const char *trigExpr) const
{
// Check if the event satisfies the trigger
}
+//______________________________________________________________________________
TObject* AliESDEvent::GetHLTTriggerDecision() const
{
// get the HLT trigger decission object
return description;
}
+//______________________________________________________________________________
Bool_t AliESDEvent::IsHLTTriggerFired(const char* name) const
{
// get the HLT trigger decission description
//
}
+//______________________________________________________________________________
Bool_t AliESDEvent::IsPileupFromSPDInMultBins() const {
Int_t nTracklets=GetMultiplicity()->GetNumberOfTracklets();
if(nTracklets<20) return IsPileupFromSPD(3,0.8);
else return IsPileupFromSPD(5,0.8);
}
+//______________________________________________________________________________
void AliESDEvent::SetTOFHeader(const AliTOFHeader *header)
{
//
}
+//______________________________________________________________________________
AliCentrality* AliESDEvent::GetCentrality()
{
if (!fCentrality) fCentrality = new AliCentrality();
return fCentrality;
}
+//______________________________________________________________________________
AliEventplane* AliESDEvent::GetEventplane()
{
if (!fEventplane) fEventplane = new AliEventplane();
return fEventplane;
}
+//______________________________________________________________________________
Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
{
// Get VZERO Multiplicity for channel i
return (fESDVZERO->GetMultiplicity(i)/factor);
}
+//______________________________________________________________________________
void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster,Int_t *mapping){
fNTOFclusters = 0;
}
+
+//______________________________________________________________________________
void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster[],Int_t *mapping){
fNTOFclusters = 0;
}
+
+//______________________________________________________________________________
+void AliESDEvent::ConnectTracks() {
+// Connect tracks to this event
+ if (fTracksConnected || !fTracks || !fTracks->GetEntriesFast()) return;
+ AliESDtrack *track;
+ TIter next(fTracks);
+ while ((track=(AliESDtrack*)next())) track->SetESDEvent(this);
+ fTracksConnected = kTRUE;
+}
virtual Bool_t IsPileupFromSPDInMultBins() const;
- AliESDtrack *GetTrack(Int_t i) const {
- if (!fTracks) return 0;
- AliESDtrack* track = (AliESDtrack*) fTracks->At(i);
- if (track) track->SetESDEvent(this);
- return track;
- }
+ void ConnectTracks();
+ Bool_t AreTracksConnected() const {return fTracksConnected;}
+
+ AliESDtrack *GetTrack(Int_t i) const {return (fTracks)?(AliESDtrack*)fTracks->At(i) : 0;}
Int_t AddTrack(const AliESDtrack *t);
/// add new track at the end of tracks array and return instance
AliESDfriend *fESDFriendOld; //! Old friend esd Structure
Bool_t fConnected; //! flag if leaves are alreday connected
Bool_t fUseOwnList; //! Do not use the list from the esdTree but use the one created by this class
+ Bool_t fTracksConnected; //! flag if tracks have already pointer to event set
static const char* fgkESDListName[kESDListN]; //!
((AliESDEvent*)fEvent)->SetESDfriend(fFriend);
called = kTRUE;
+ // set transient pointer to event inside tracks
+ fEvent->ConnectTracks();
+
if (fMixingHandler) fMixingHandler->BeginEvent(entry);
if (fUseTags && fRunTag) {
fEventTag = 0;
virtual void Print(Option_t * opt) const ;
const AliESDEvent* GetESDEvent() const {return fESDEvent;}
const AliTOFHeader* GetTOFHeader() const;
+ const AliVEvent* GetEvent() const {return (AliVEvent*)fESDEvent;}
void SetESDEvent(const AliESDEvent* evt) {fESDEvent = evt;}
// Trasient PID object, is owned by the track
#include "AliVParticle.h"
+class AliVEvent;
class AliVVertex;
class AliExternalTrackParam;
class AliTPCdEdxInfo;
AliVTrack(const AliVTrack& vTrack);
AliVTrack& operator=(const AliVTrack& vTrack);
+ virtual const AliVEvent* GetEvent() const {return 0;}
virtual Int_t GetID() const = 0;
virtual UChar_t GetITSClusterMap() const = 0;
virtual void GetITSdEdxSamples(Double_t s[4]) const {for (int i=4;i--;) s[i]=0;};
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff