ROOT logo
AliRoot » PWGPP » TRD » AliTRDresolution

class AliTRDresolution: public AliTRDrecoTask


TRD tracking resolution

 The class performs resolution and residual studies
 of the TRD tracks for the following quantities :
   - spatial position (y, [z])
   - angular (phi) tracklet
   - momentum at the track level

 The class has to be used for regular detector performance checks using the official macros:
   - $ALICE_ROOT/TRD/qaRec/run.C
   - $ALICE_ROOT/TRD/qaRec/makeResults.C

 For stand alone usage please refer to the following example:
 {
   gSystem->Load("libANALYSIS.so");
   gSystem->Load("libTRDqaRec.so");
   AliTRDresolution *res = new AliTRDresolution();
   //res->SetMCdata();
   //res->SetVerbose();
   //res->SetVisual();
   res->Load();
   if(!res->PostProcess()) return;
   res->GetRefFigure(0);
 }

Authors:
Alexandru Bercuci <A.Bercuci@gsi.de>
Markus Fasel <M.Fasel@gsi.de>


Function Members (Methods)

public:
AliTRDresolution()
AliTRDresolution(const AliTRDresolution&)
AliTRDresolution(char* name, Bool_t xchange = kTRUE)
virtual~AliTRDresolution()
virtual voidTTask::Abort()MENU
voidTObject::AbstractMethod(const char* method) const
virtual voidTTask::Add(TTask* task)
virtual voidAliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char* fname = "")
voidAdjustF1(TH1* h, TF1* f)
virtual AliAODEvent*AliAnalysisTaskSE::AODEvent() const
virtual voidTObject::AppendPad(Option_t* option = "")
Bool_tAliAnalysisTask::AreSlotsConnected()
virtual voidTTask::Browse(TBrowser* b)
Bool_tAliAnalysisTask::CheckCircularDeps()
voidAliAnalysisTask::CheckNotify(Bool_t init = kFALSE)
virtual Bool_tAliAnalysisTask::CheckOwnership() const
virtual Bool_tAliAnalysisTask::CheckPostData() const
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTTask::CleanTasks()
virtual voidTTask::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tAliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer* cont)
virtual voidAliAnalysisTaskSE::ConnectInputData(Option_t* option = "")
Bool_tAliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer* cont)
virtual voidTTask::Continue()MENU
virtual voidTNamed::Copy(TObject& named) const
virtual voidAliAnalysisTaskSE::CreateOutputObjects()
virtual const char*AliAnalysisTaskSE::CurrentFileName()
virtual Int_tAliAnalysisTaskSE::DebugLevel() const
virtual voidTObject::Delete(Option_t* option = "")MENU
TH1*DetCluster(const TObjArray* cl = NULL)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
TH2*DrawSigma(TH2* h2, const Char_t* t, Float_t m = 0., Float_t M = -1., Float_t scale = 1)
virtual voidTObject::Dump() constMENU
virtual Long64_tAliAnalysisTaskSE::Entry() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual AliESDfriend*AliAnalysisTaskSE::ESDfriend() const
virtual const AliEventTag*AliAnalysisTaskSE::EventTag() const
virtual voidAliAnalysisTaskSE::Exec(Option_t* option)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTTask::ExecuteTask(Option_t* option = "0")MENU
virtual voidTTask::ExecuteTasks(Option_t* option)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
virtual voidAliAnalysisTask::FinishTaskOutput()
static Bool_tFitTrack(const Int_t np, AliTrackPoint* points, Float_t* params)
static Bool_tFitTracklet(const Int_t ly, const Int_t np, const AliTrackPoint* points, const Float_t* trackPars, Float_t* trackletPars)
voidAliAnalysisTask::GetBranches(const char* type, TString& result) const
Int_tTTask::GetBreakin() const
Int_tTTask::GetBreakout() const
virtual UInt_tAliAnalysisTaskSE::GetCollisionCandidates() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
TObject*AliAnalysisTask::GetInputData(Int_t islot) const
AliAnalysisDataSlot*AliAnalysisTask::GetInputSlot(Int_t islot) const
TClass*AliAnalysisTask::GetInputType(Int_t islot) const
voidGetLandauMpvFwhm(TF1 *const f, Float_t& mpv, Float_t& xm, Float_t& xM)
TList*TTask::GetListOfTasks() const
static Float_tAliTRDrecoTask::GetMeanStat(TH1* h, Float_t cut = 0., Int_t opt = 0, Float_t* sigma = NULL)
virtual const char*TNamed::GetName() const
const Char_t*AliTRDrecoTask::GetNameId() const
Int_tAliAnalysisTask::GetNinputs() const
Int_tAliAnalysisTask::GetNoutputs() const
Int_tAliTRDrecoTask::GetNRefFigures() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TObject*AliAnalysisTask::GetOutputData(Int_t islot) const
AliAnalysisDataSlot*AliAnalysisTask::GetOutputSlot(Int_t islot) const
TClass*AliAnalysisTask::GetOutputType(Int_t islot) const
TList*AliTRDrecoTask::GetPlotFunctors() const
Int_tAliTRDrecoTask::GetPtBin(Float_t pt)
Float_tGetPtThreshold() const
TObject*AliAnalysisTask::GetPublishedData() const
virtual TList*AliAnalysisTaskSE::GetQAHistos() const
voidGetRange(TH2* h2, Char_t mod, Float_t* range)
static voidGetRangeZ(TH2* h2, Float_t& m, Float_t& M)
virtual Bool_tGetRefFigure(Int_t ifig)
virtual const char*TNamed::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
Bool_tAliAnalysisTask::HasBranches() const
Bool_tAliAnalysisTask::HasExecuted() const
Bool_tAliTRDrecoTask::HasFriends() const
virtual ULong_tTNamed::Hash() const
Bool_tAliTRDrecoTask::HasMCdata() const
Bool_tAliTRDrecoTask::HasPostProcess() const
Bool_tAliTRDrecoTask::HasRunTerminate() const
virtual TObjArray*Histos()
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidAliAnalysisTaskSE::Init()
voidInitExchangeContainers()
virtual AliVEvent*AliAnalysisTaskSE::InputEvent() const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tTTask::IsActive() const
Bool_tAliAnalysisTask::IsChecked() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tAliAnalysisTaskSE::IsEventInBinZero()
virtual Bool_tTTask::IsFolder() const
Bool_tAliTRDrecoTask::IsHeavyIon() const
Bool_tAliAnalysisTask::IsInitialized() const
Bool_tTObject::IsOnHeap() const
Bool_tAliAnalysisTask::IsOutputReady(Int_t islot) const
Bool_tAliAnalysisTask::IsPostEventLoop() const
Bool_tAliTRDrecoTask::IsPP() const
Bool_tAliAnalysisTask::IsReady() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tAliAnalysisTaskSE::IsStandardAOD() const
Bool_tAliAnalysisTask::IsUsed() const
Bool_tIsVerbose() const
Bool_tIsVisual() const
Bool_tAliAnalysisTask::IsZombie() const
virtual Bool_tAliTRDrecoTask::Load(const Char_t* file = "AnalysisResults.root", const Char_t* dir = "TRD_Performance")
voidAliAnalysisTaskSE::LoadBranches() const
virtual Bool_tAliTRDrecoTask::LoadDetectorMap(const Char_t* file = "AnalysisResults.root", const Char_t* dir = "TRD_Performance")
virtual voidAliAnalysisTask::LocalInit()
virtual voidTTask::ls(Option_t* option = "*") constMENU
voidAliTRDrecoTask::MakeDetectorPlot(Int_t ly = 0, Option_t* opt = "")
voidAliTRDrecoTask::MakeDetectorPlotOLD(Int_t ly = 0, Option_t* opt = "")
virtual voidMakeSummary()
voidTObject::MayNotUse(const char* method) const
virtual AliMCEvent*AliAnalysisTaskSE::MCEvent() const
virtual Bool_tAliAnalysisTaskSE::Notify()
virtual Bool_tAliAnalysisTask::NotifyBinChange()
virtual voidAliAnalysisTaskSE::NotifyRun()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliTRDresolution&operator=(const AliTRDresolution&)
virtual TTree*AliAnalysisTaskSE::OutputTree() const
virtual voidTObject::Paint(Option_t* option = "")
TH1*PlotCluster(const AliTRDtrackV1* t = NULL)
TH1*PlotMC(const AliTRDtrackV1* t = NULL)
TH1*PlotTrackIn(const AliTRDtrackV1* t = NULL)
TH1*PlotTracklet(const AliTRDtrackV1* t = NULL)
virtual voidTObject::Pop()
virtual Bool_tPostProcess()
virtual voidTNamed::Print(Option_t* option = "") const
voidAliAnalysisTask::PrintContainers(Option_t* option = "all", Int_t indent = 0) const
virtual voidAliAnalysisTask::PrintTask(Option_t* option = "all", Int_t indent = 0) const
static Bool_tProcess(TH2 *const, TGraphErrors**, Int_t stat = 100)
Bool_tAliAnalysisTask::ProducersTouched() const
virtual Bool_tAliTRDrecoTask::PutTrendValue(const Char_t* name, Double_t val, Double_t err = 0)
virtual Int_tTObject::Read(const char* name)
static Int_tAliTRDrecoTask::Rebin(TH2* h, Int_t n, Int_t* rebinX, Int_t* rebinY, Int_t nstat)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual voidAliAnalysisTask::Reset()
voidTObject::ResetBit(UInt_t f)
TObjArray*Results(AliTRDresolution::ETRDresolutionClass c) const
virtual Bool_tAliTRDrecoTask::Save(TObjArray *const res)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual voidAliAnalysisTaskSE::SelectCollisionCandidates(UInt_t offlineTriggerMask = AliVEvent::kMB)
voidTTask::SetActive(Bool_t active = kTRUE)TOGGLE
voidSetBCselectFill(Int_t b = 0)
voidSetBCselectTOF(Int_t b = 0)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidAliAnalysisTask::SetBranches(const char* names)
voidTTask::SetBreakin(Int_t breakin = 1)TOGGLE
voidTTask::SetBreakout(Int_t breakout = 1)TOGGLE
voidSetBsign(Int_t b = 0)
voidAliAnalysisTask::SetChecked(Bool_t flag = kTRUE)
virtual voidAliTRDrecoTask::SetDebugLevel(Int_t level)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetDump3D(Bool_t det, Bool_t cl, Bool_t trklt, Bool_t trkin)
virtual voidAliTRDrecoTask::SetFriends(Bool_t fr = kTRUE)
voidSetLYselect(Int_t ly = 0)
virtual voidAliTRDrecoTask::SetMCdata(Bool_t mc = kTRUE)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidAliTRDrecoTask::SetNameId(const Char_t* nid)
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static Float_tAliTRDrecoTask::SetNormZ(TH2* h2, Int_t bxmin = 1, Int_t bxmax = -1, Int_t bymin = 1, Int_t bymax = -1, Float_t thr = 0.)
static voidTObject::SetObjectStat(Bool_t stat)
voidAliAnalysisTask::SetPostEventLoop(Bool_t flag = kTRUE)
virtual voidAliTRDrecoTask::SetPostProcess(Bool_t pp = kTRUE)
voidSetProcesses(Bool_t det, Bool_t cl, Bool_t trklt, Bool_t trkin)
voidSetPtThreshold(Float_t pt)
static voidAliTRDrecoTask::SetRangeZ(TH2* h2, Float_t m, Float_t M, Float_t thr = 0.)
voidAliTRDrecoTask::SetRunTerminate(Bool_t runTerminate = kTRUE)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidAliTRDrecoTask::SetTriggerList(const Char_t* tl)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidAliAnalysisTask::SetUsed(Bool_t flag = kTRUE)
voidSetUseExchangeContainers(Bool_t v = kTRUE)
voidSetVerbose(Bool_t v = kTRUE)
voidSetVisual(Bool_t v = kTRUE)
voidAliAnalysisTask::SetZombie(Bool_t flag = kTRUE)
virtual voidShowMembers(TMemberInspector&)
virtual Int_tTNamed::Sizeof() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
virtual voidTerminate(Option_t* opt)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
Bool_tUseBCselectFill() const
Bool_tUseBCselectTOF() const
virtual voidTObject::UseCurrentStyle()
Bool_tUseExchangeContainers() const
Bool_tUseLYselectTrklt() const
virtual voidUserCreateOutputObjects()
virtual voidUserExec(Option_t* opt)
virtual voidAliAnalysisTaskSE::UserExecMix(Option_t*)
virtual Bool_tAliAnalysisTaskSE::UserNotify()
static Bool_tUseTrack(const Int_t np, const AliTrackPoint* points, Float_t* params)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidAliAnalysisTaskSE::ConnectMultiHandler()
static TTreeSRedirector*AliTRDrecoTask::DebugStream()
voidAliAnalysisTask::DefineInput(Int_t islot, TClass* type)
voidAliAnalysisTask::DefineOutput(Int_t islot, TClass* type)
voidAliAnalysisTaskSE::DisconnectMultiHandler()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidAliAnalysisTask::EnableBranch(Int_t islot, const char* bname) const
char*AliAnalysisTask::GetBranchAddress(Int_t islot, const char* branch) const
Bool_tHasDump3DFor(AliTRDresolution::ETRDresolutionClass cls) const
Bool_tAliTRDrecoTask::HasFunctorList() const
Bool_tHasProcess(AliTRDresolution::ETRDresolutionClass cls) const
virtual voidAliTRDrecoTask::InitFunctorList()
Bool_tAliTRDrecoTask::MakeMomSegmentation()
Bool_tMakeProjectionCluster(Bool_t mc = kFALSE)
Bool_tMakeProjectionDetector()
Bool_tMakeProjectionTrack()
Bool_tMakeProjectionTrackIn(Bool_t mc = kFALSE, Bool_t v0 = kFALSE)
Bool_tMakeProjectionTracklet(Bool_t mc = kFALSE)
voidTObject::MakeZombie()
TFile*AliAnalysisTask::OpenFile(Int_t iout, Option_t* option = "RECREATE") const
Bool_tAliAnalysisTask::PostData(Int_t iout, TObject* data, Option_t* option = "")
Bool_tProcess(TH2 *const, TF1*, Float_t, TGraphErrors**)
Bool_tPulls(Double_t* dyz, Double_t* cc, Double_t tilt) const
Bool_tAliAnalysisTask::SetBranchAddress(Int_t islot, const char* branch, void* address) const

Data Members

public:
enum ETRDresolutionSteer { kVerbose
kVisual
kTrackRefit
kTrackSelect
kXchange
};
enum ETRDresolutionSlots { kClToTrk
kClToMC
kTrkltToTrk
kTrkltToMC
kNSlots
};
enum ETRDresolutionClass { kDetector
kCluster
kTracklet
kTrackIn
kMCcluster
kMCtracklet
kMCtrackIn
kMCtrack
kNclasses
kV0TrackIn
};
enum ETRDresolutionClassProjs { kDetNproj
kClNproj
kTrkltNproj
kTrkInNproj
kTrkNproj
kMCTrkInNproj
};
enum ETRDresolutionProjs { kBC
kPhi
kEta
kYrez
kPrez
kZrez
kSpeciesChgRC
kPt
kNdim
kNdimDet
kNdimCl
kNdimTrklt
kNdimTrkIn
kNbunchCross
kNspc
kNcharge
kNpads
};
enum AliTRDrecoTask::AliTRDrecoSteeringBits { kMCdata
kFriends
kPostProcess
kHeavyIon
};
enum AliAnalysisTask::EAnalysisTaskFlags { kTaskUsed
kTaskZombie
kTaskChecked
kTaskPostEventLoop
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
Bool_tTTask::fActivetrue if task is active
Int_tfBCbinFillset/select by Bunch Fill index
Int_tfBCbinTOFset/select by TOF BC index
TStringAliAnalysisTask::fBranchNamesList of input branches that need to be loaded for this task
Int_tTTask::fBreakin=1 if a break point set at task extry
Int_tTTask::fBreakout=1 if a break point set at task exit
Bool_tfBsignsign of magnetic field (kFALSE[-] kTRUE[+])
TObjArray*fCl! cluster2track calib
TObjArray*AliTRDrecoTask::fClusters! Array of clusters
TObjArray*AliTRDrecoTask::fContainer! container to store results
Int_tAliAnalysisTaskSE::fCurrentRunNumber! Current run number
TDatabasePDG*fDBPDG! PDG database
Int_tAliAnalysisTaskSE::fDebugDebug flag
TObjArray*AliTRDrecoTask::fDets! OLD container to store detector position and status support should be discontinued
TObjArray*AliTRDrecoTask::fDetsV! NEW container to store detector position and status
AliESDfriend*AliAnalysisTaskSE::fESDfriend! ESD friend
Int_tAliAnalysisTaskSE::fEntryCurrent entry in the chain
Float_tAliTRDrecoTask::fEta! eta of the track being analyzed
AliTRDeventInfo*AliTRDrecoTask::fEvent! Event Info
Bool_tTTask::fHasExecutedTrue if task has executed
TList*AliAnalysisTaskSE::fHistosQA! Output histos for QA
Bool_tAliAnalysisTask::fInitializedTrue if Init() was called
AliVEvent*AliAnalysisTaskSE::fInputEvent! VEvent Input
AliInputEventHandler*AliAnalysisTaskSE::fInputHandler! Input Handler
TObjArray*AliAnalysisTask::fInputsArray of input slots
Int_tfLYselectselect layer for Tracklet projections (in debug mode)
AliMCEvent*AliAnalysisTaskSE::fMCEvent! MC
AliInputEventHandler*AliAnalysisTaskSE::fMCEventHandler! pointer to MCEventHandler
TObjArray*fMCcl! cluster2mc calib
AliMultiInputEventHandler*AliAnalysisTaskSE::fMultiInputHandler! pointer to multihandler
UChar_tAliTRDrecoTask::fNRefFiguresno of reference figures reported by task
TStringTNamed::fNameobject identifier
Char_tAliTRDrecoTask::fNameId[10]unique identifier of task particularity
Int_tAliAnalysisTask::fNinputsNumber of inputs
Int_tAliAnalysisTask::fNoutputsNumber of outputs
Int_tAliTRDrecoTask::fNptno of pt/p bins actually used
UInt_tAliAnalysisTaskSE::fOfflineTriggerMaskTask processes collision candidates only
TStringTTask::fOptionOption specified in ExecuteTask
AliAODEvent*AliAnalysisTaskSE::fOutputAOD! AOD out
Bool_t*AliAnalysisTask::fOutputReady[fNoutputs] Flags for output readyness
TObjArray*AliAnalysisTask::fOutputsArray of output slots
Float_tAliTRDrecoTask::fPhi! phi of the track being analyzed
TObjArray*fProj! result holder - sigma values
Float_tAliTRDrecoTask::fPt! p_t of the track being analyzed
Float_tfPtThresholdpt threshold for some performance plots
TObject*AliAnalysisTask::fPublishedData! published data
Bool_tAliAnalysisTask::fReadyFlag if the task is ready
Char_tAliTRDrecoTask::fSpecies! species index +1 with charge sign
UShort_tfSteerbit map to steer internal behaviour of class
TList*TTask::fTasksList of Tasks
TStringTNamed::fTitleobject title
TObjArray*AliTRDrecoTask::fTracks! Array of tracks
TTree*AliAnalysisTaskSE::fTreeAAOD output Tree
TObjArray*AliTRDrecoTask::fTriggerList! optional trigger list to be monitored
Char_tAliTRDrecoTask::fTriggerSlot! selected triggers map (if requested)
static TClonesArray*AliAnalysisTaskSE::fgAODCaloClusters! CaloClusters for replication
static TClonesArray*AliAnalysisTaskSE::fgAODDimuons! Dimuons replication
static AliAODCaloTrigger*AliAnalysisTaskSE::fgAODEMCALTrigger! Emcal Trigger for replication
static AliAODCaloCells*AliAnalysisTaskSE::fgAODEmcalCells! Emcal Cell replication
static TClonesArray*AliAnalysisTaskSE::fgAODFMDClusters! FMDClusters for replication
static AliAODHeader*AliAnalysisTaskSE::fgAODHeader! Header for replication
static TClonesArray*AliAnalysisTaskSE::fgAODHmpidRings! HMPID replication
static TClonesArray*AliAnalysisTaskSE::fgAODJets! Jets for replication
static TClonesArray*AliAnalysisTaskSE::fgAODMCParticles! MC Particles for replicatio
static AliAODCaloTrigger*AliAnalysisTaskSE::fgAODPHOSTrigger! Phos Trigger for replication
static TClonesArray*AliAnalysisTaskSE::fgAODPMDClusters! PMDClusters for replication
static AliAODCaloCells*AliAnalysisTaskSE::fgAODPhosCells! Phos Cell replication
static AliAODTracklets*AliAnalysisTaskSE::fgAODTracklets! Tracklets for replication
static TClonesArray*AliAnalysisTaskSE::fgAODTracks! Tracks for replication
static TClonesArray*AliAnalysisTaskSE::fgAODV0s! V0s for replication
static AliAODVZERO*AliAnalysisTaskSE::fgAODVZERO! VZERO for replication
static TClonesArray*AliAnalysisTaskSE::fgAODVertices! Vertices for replication
static TTask*TTask::fgBeginTaskpointer to task initiator
static TTask*TTask::fgBreakPointpointer to current break point
static const Int_tAliTRDrecoTask::fgNPt! No of debug pt bins
static const Char_t*fgPerformanceName[8]! name of performance plot
static Float_tAliTRDrecoTask::fgPt[26]! Array with limits for debug pt bins
static AliTOFHeader*AliAnalysisTaskSE::fgTOFHeader! TOFHeader for replication
static const Double_tfgkMax[8]! high limits for projections
static const Double_tfgkMin[8]! low limits for projections
static const Int_tfgkNbins[8]! no of bins/projection
static const Char_t*fgkTitle[8]! title of projection
const TObjArray*AliTRDrecoTask::fkClusters! current detector clusters array
const AliTRDtrackInfo::AliESDinfo*AliTRDrecoTask::fkESD! ESD info
const AliTRDtrackInfo::AliMCinfo*AliTRDrecoTask::fkMC! MC info
const AliTRDtrackV1*AliTRDrecoTask::fkTrack! current track

Class Charts

Inheritance Chart:
TTask
AliAnalysisTask
AliAnalysisTaskSE
AliTRDrecoTask
AliTRDresolution
AliTRDcheckTRK

Function documentation

AliTRDresolution()
 Default constructor

AliTRDresolution(char* name, Bool_t xchange = kTRUE)
 Default constructor

~AliTRDresolution()
 Destructor

void UserCreateOutputObjects()
 spatial resolution
void InitExchangeContainers()
 Init containers for subsequent tasks (AliTRDclusterResolution)
void UserExec(Option_t* opt)
 Execution part

Bool_t Pulls(Double_t* dyz, Double_t* cc, Double_t tilt) const
 Helper function to calculate pulls in the yz plane
 using proper tilt rotation
 Uses functionality defined by AliTRDseedV1.
TH1* DetCluster(const TObjArray* cl = NULL)
 Plot the cluster distributions

TH1* PlotCluster(const AliTRDtrackV1* t = NULL)
 Plot the cluster distributions

TH1* PlotTracklet(const AliTRDtrackV1* t = NULL)
 Plot normalized residuals for tracklets to track.

 We start from the result that if X=N(|m|, |Cov|)

(Cov^{-1})^{1/2}X = N((Cov^{-1})^{1/2}*|m|, |1|)
 in our case X=(y_trklt - y_trk z_trklt - z_trk) and |Cov| = |Cov_trklt| + |Cov_trk| at the radial
 reference position.
TH1* PlotTrackIn(const AliTRDtrackV1* t = NULL)
 Store resolution/pulls of Kalman before updating with the TRD information
 at the radial position of the first tracklet. The following points are used
 for comparison
  - the (y,z,snp) of the first TRD tracklet
  - the (y, z, snp, tgl, pt) of the MC track reference

 Additionally the momentum resolution/pulls are calculated for usage in the
 PID calculation.
TH1* PlotMC(const AliTRDtrackV1* t = NULL)
 Plot MC distributions

void GetRangeZ(TH2* h2, Float_t& m, Float_t& M)
 Get range on Z axis such to avoid outliers
Bool_t GetRefFigure(Int_t ifig)
 Get the reference figures

void MakeSummary()
 Build summary plots
TH2* DrawSigma(TH2* h2, const Char_t* t, Float_t m = 0., Float_t M = -1., Float_t scale = 1)
 Draw error bars scaled with "scale" instead of content values
use range [m,M] if limits are specified
void GetRange(TH2* h2, Char_t mod, Float_t* range)
 Returns the range of the bulk of data in histogram h2. Removes outliers.
 The "range" vector should be initialized with 2 elements
 Option "mod" can be any of
   - 0 : gaussian like distribution
   - 1 : tailed distribution
Bool_t MakeProjectionDetector()
 Analyse cluster
Bool_t MakeProjectionCluster(Bool_t mc = kFALSE)
 Analyse cluster
Bool_t MakeProjectionTracklet(Bool_t mc = kFALSE)
 Analyse tracklet
Bool_t MakeProjectionTrackIn(Bool_t mc = kFALSE, Bool_t v0 = kFALSE)
 Analyse track in
Bool_t MakeProjectionTrack()
 Analyse tracklet
Bool_t PostProcess()
 Fit, Project, Combine, Extract values from the containers filled during execution
void Terminate(Option_t* opt)
void AdjustF1(TH1* h, TF1* f)
 Helper function to avoid duplication of code
 Make first guesses on the fit parameters
TObjArray* Histos()
 Define histograms

Bool_t FitTrack(const Int_t np, AliTrackPoint* points, Float_t* params)
 Fit track with a staight line using the "np" clusters stored in the array "points".
 The following particularities are stored in the clusters from points:
   1. pad tilt as cluster charge
   2. pad row cross or vertex constrain as fake cluster with cluster type 1
 The parameters of the straight line fit are stored in the array "param" in the following order :
     param[0] - x0 reference radial position
     param[1] - y0 reference r-phi position @ x0
     param[2] - z0 reference z position @ x0
     param[3] - slope dy/dx
     param[4] - slope dz/dx

 Attention :
 Function should be used to refit tracks for B=0T

Bool_t FitTracklet(const Int_t ly, const Int_t np, const AliTrackPoint* points, const Float_t* trackPars, Float_t* trackletPars)
 Fit tracklet with a staight line using the coresponding subset of clusters out of the total "np" clusters stored in the array "points".
 See function FitTrack for the data stored in the "clusters" array
Bool_t UseTrack(const Int_t np, const AliTrackPoint* points, Float_t* params)
 Global selection mechanism of tracksbased on cluster to fit residuals
 The parameters are the same as used ni function FitTrack().
void GetLandauMpvFwhm(TF1 *const f, Float_t& mpv, Float_t& xm, Float_t& xM)
 Get the most probable value and the full width half mean
 of a Landau distribution

void SetProcesses(Bool_t det, Bool_t cl, Bool_t trklt, Bool_t trkin)
 steer processes
void SetDump3D(Bool_t det, Bool_t cl, Bool_t trklt, Bool_t trkin)
 steer processes
AliTRDresolution()
AliTRDresolution& operator=(const AliTRDresolution& )
Float_t GetPtThreshold() const
{return fPtThreshold;}
TObjArray* Results(AliTRDresolution::ETRDresolutionClass c) const
{ if(!fProj) return NULL; return (TObjArray*)fProj->At(c);}
Bool_t IsVerbose() const
  Bool_t          HasTrackRefit() const                 { return TestBit(kTrackRefit);}
Bool_t          HasTrackSelection() const             { return TestBit(kTrackSelect);}
{ return TestBit(kVerbose);}
Bool_t IsVisual() const
{ return TestBit(kVisual);}
Bool_t UseBCselectTOF() const
{ return fBCbinTOF>0;}
Bool_t UseBCselectFill() const
{ return fBCbinFill>0;}
Bool_t UseLYselectTrklt() const
{ return fLYselect>=0;}
Bool_t UseExchangeContainers() const
{ return TestBit(kXchange);}
Bool_t Process(TH2 *const , TGraphErrors** , Int_t stat = 100)
{ return Bool_t(stat);}
void SetPtThreshold(Float_t pt)
{ fPtThreshold = pt;}
void SetBCselectTOF(Int_t b = 0)
{ fBCbinTOF = b;}
void SetBCselectFill(Int_t b = 0)
{ fBCbinFill = b<0||b>3499?1:b+1;}
void SetBsign(Int_t b = 0)
{ fBsign = Bool_t(b);}
void SetLYselect(Int_t ly = 0)
{ fLYselect = ly;}
void SetVerbose(Bool_t v = kTRUE)
void SetVisual(Bool_t v = kTRUE)
  void            SetTrackRefit(Bool_t v = kTRUE)       { SetBit(kTrackRefit, v);}
void            SetTrackSelection(Bool_t v = kTRUE)   { SetBit(kTrackSelect, v);}
{ SetBit(kVisual, v);}
void SetUseExchangeContainers(Bool_t v = kTRUE)
Bool_t HasDump3DFor(AliTRDresolution::ETRDresolutionClass cls) const
{ return TESTBIT(fSteer, 4+cls);}
Bool_t HasProcess(AliTRDresolution::ETRDresolutionClass cls) const
{ return TESTBIT(fSteer, cls);}
Bool_t Process(TH2 *const , TF1* , Float_t , TGraphErrors** )
{ return kTRUE;}