ROOT logo
AliRoot » PWGPP » TRD » AliTRDclusterResolution

class AliTRDclusterResolution: public AliTRDrecoTask


TRD cluster error parameterization

 This class is designed to produce the reference plots for a detailed study
 and parameterization of TRD cluster errors. The following effects are taken
into account :
- dependence with the total charge of the cluster
   - dependence with the distance from the center pad. This is monitored
 for each layer individually since the pad size varies with layer
   - dependence with the drift length - here the influence of anisochronity
 and diffusion are searched
   - dependence with the distance to the anode wire - anisochronity effects
   - dependence with track angle (for y resolution)
 The correlation between effects is taken into account.

 Since magnetic field plays a very important role in the TRD measurement
 the ExB correction is forced by the setter function SetExB(Int_t). The
 argument is the detector index, if none is specified all will be
 considered.

 Two cases are of big importance.
   - comparison with MC
   - comparison with Kalman fit. In this case the covariance matrix of the
 Kalman fit are needed.

 The functionalities implemented in this class are based on the storage
 class AliTRDclusterInfo.

 The Method


 The method to disentangle s_y and s_x is based on the relation (see also fig.)

#sigma^{2} = #sigma^{2}_{y} + tg^{2}(#alpha_{L})*#sigma^{2}_{x_{d}} + tg^{2}(#phi-#alpha_{L})*(#sigma^{2}_{x_{d}}+#sigma^{2}_{x_{c}})
 with

#sigma^{2}_{x_{c}} #approx 0
 we suppose the chamber is well calibrated for t_{0} and aligned in
 radial direction.

 Clusters can be radially shifted due to three causes:
   - globally shifted - due to residual misalignment/miscalibration(t0)
   - locally shifted - due to different local drift velocity from the mean
   - randomly shifted - due to neighboring (radial direction) clusters
 charge induced by asymmetry of the TRF.

 We estimate this effects by the relations:

#mu_{y} = tg(#alpha_{L})*#Delta x_{d}(...) + tg(#phi-#alpha_{L})*(#Delta x_{c}(...) + #Delta x_{d}(...))
 where

#Delta x_{d}(...) = (<v_{d}> + #delta v_{d}(x_{d}, d)) * (t + t^{*}(Q))
 and we specified explicitely the variation of drift velocity parallel
 with the track (x_{d}) and perpendicular to it due to anisochronity (d).

 For estimating the contribution from asymmetry of TRF the following
 parameterization is being used

t^{*}(Q) = #delta_{0} * #frac{Q_{t+1} - Q_{t-1}}{Q_{t-1} + Q_{t} + Q_{t+1}}


 Clusters can also be r-phi shifted due to:
   - wrong PRF or wrong cuts at digits level
The following correction is applied :

<#Delta y> = a + b * sin(c*y_{pw})

Function Members (Methods)

public:
AliTRDclusterResolution()
AliTRDclusterResolution(const char* name)
virtual~AliTRDclusterResolution()
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 = "")
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
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
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()
voidAliAnalysisTask::GetBranches(const char* type, TString& result) const
Int_tTTask::GetBreakin() const
Int_tTTask::GetBreakout() const
virtual UInt_tAliAnalysisTaskSE::GetCollisionCandidates() const
Int_tGetDetector() const
voidGetDiffCoeff(Float_t& dt, Float_t& dl) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Float_tGetDyRange() const
Float_tGetExB() const
Float_tGetGain() const
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
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
voidGetPad(Int_t& c, Int_t& r) const
TList*AliTRDrecoTask::GetPlotFunctors() const
Int_tAliTRDrecoTask::GetPtBin(Float_t pt)
TObject*AliAnalysisTask::GetPublishedData() const
virtual TList*AliAnalysisTaskSE::GetQAHistos() const
virtual Bool_tGetRefFigure(Int_t ifig)
Float_tGetT0() const
virtual const char*TNamed::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
Float_tGetVdrift() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
Bool_tAliAnalysisTask::HasBranches() const
Bool_tAliAnalysisTask::HasExecuted() const
Bool_tAliTRDrecoTask::HasFriends() const
Bool_tHasGlobalPosition() const
virtual ULong_tTNamed::Hash() const
Bool_tAliTRDrecoTask::HasMCdata() const
Bool_tAliTRDrecoTask::HasPostProcess() const
Bool_tHasProcess(AliTRDclusterResolution::EResultContainer bit) 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()
virtual AliVEvent*AliAnalysisTaskSE::InputEvent() const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tTTask::IsActive() const
Bool_tIsCalibrated() 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
Bool_tIsSaveAs() const
virtual Bool_tTNamed::IsSortable() const
virtual Bool_tAliAnalysisTaskSE::IsStandardAOD() const
Bool_tAliAnalysisTask::IsUsed() const
Bool_tIsUsingCalibParam(AliTRDclusterResolution::ECalibrationParam par) 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
Bool_tLoadCalibration()
virtual Bool_tAliTRDrecoTask::LoadDetectorMap(const Char_t* file = "AnalysisResults.root", const Char_t* dir = "TRD_Performance")
Bool_tLoadGlobalChamberPosition()
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 voidAliTRDrecoTask::MakeSummary()
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)
virtual TTree*AliAnalysisTaskSE::OutputTree() const
virtual voidTObject::Paint(Option_t* option = "")
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
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)
voidResetProcesses()
TObjArray*Results() 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
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
voidSetCalibrationRegion(Int_t det, Int_t col = -1, Int_t row = -1)
voidAliAnalysisTask::SetChecked(Bool_t flag = kTRUE)
virtual voidAliTRDrecoTask::SetDebugLevel(Int_t level)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetDyRange(Float_t dy)
virtual voidAliTRDrecoTask::SetFriends(Bool_t fr = kTRUE)
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)
voidSetProcess(AliTRDclusterResolution::EResultContainer bit, Bool_t v = kTRUE)
static voidAliTRDrecoTask::SetRangeZ(TH2* h2, Float_t m, Float_t M, Float_t thr = 0.)
voidAliTRDrecoTask::SetRunTerminate(Bool_t runTerminate = kTRUE)
voidSetSaveAs(Bool_t v = kTRUE)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidAliTRDrecoTask::SetTriggerList(const Char_t* tl)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetUseCalibParam(AliTRDclusterResolution::ECalibrationParam par, Bool_t v = kTRUE)
voidAliAnalysisTask::SetUsed(Bool_t flag = kTRUE)
voidSetVisual()
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 voidAliTRDrecoTask::Terminate(Option_t*)
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidUserCreateOutputObjects()
virtual voidUserExec(Option_t*)
virtual voidAliAnalysisTaskSE::UserExecMix(Option_t*)
virtual Bool_tAliAnalysisTaskSE::UserNotify()
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_tAliTRDrecoTask::HasFunctorList() const
virtual voidAliTRDrecoTask::InitFunctorList()
Bool_tAliTRDrecoTask::MakeMomSegmentation()
voidTObject::MakeZombie()
TFile*AliAnalysisTask::OpenFile(Int_t iout, Option_t* option = "RECREATE") const
Bool_tAliAnalysisTask::PostData(Int_t iout, TObject* data, Option_t* option = "")
voidProcessCharge()
voidProcessMean()
Bool_tProcessNormalTracks()
voidProcessSigma()
Bool_tAliAnalysisTask::SetBranchAddress(Int_t islot, const char* branch, void* address) const

Data Members

public:
enum EAxisBinning { kND
};
enum EResultContainer { kYSys
kYRes
kSigm
kMean
kNtasks
};
enum ECalibrationParam { kVdrift
kT0
kGain
};
enum ECheckBits { kSaveAs
kCalibrated
kGlobal
};
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
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
TObjArray*AliTRDrecoTask::fClusters! Array of clusters
TObjArray*AliTRDrecoTask::fContainer! container to store results
Int_tAliAnalysisTaskSE::fCurrentRunNumber! Current run number
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
AliMCEvent*AliAnalysisTaskSE::fMCEvent! MC
AliInputEventHandler*AliAnalysisTaskSE::fMCEventHandler! pointer to MCEventHandler
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
Float_tAliTRDrecoTask::fPt! p_t of the track being analyzed
TObject*AliAnalysisTask::fPublishedData! published data
Bool_tAliAnalysisTask::fReadyFlag if the task is ready
Char_tAliTRDrecoTask::fSpecies! species index +1 with charge sign
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 Float_tAliTRDrecoTask::fgPt[26]! Array with limits for debug pt bins
static AliTOFHeader*AliAnalysisTaskSE::fgTOFHeader! TOFHeader for replication
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
private:
TCanvas*fCanvas! visualization canvas
Char_tfColpad column (-1 for all)
Short_tfDetdetector (-1 for all)
Float_tfDldiffusion coeff. longitudinal
Float_tfDtdiffusion coeff. transversal
Float_tfDyRangemin/max dy
Float_tfExBtg of the Lorentz angle
Float_tfGaingain
Float_tfHtg of tilting angle
TObjArray*fInfo! list of cluster info
UChar_tfLyTRD plane
Float_tfP[4]mean/sgm pulls
Float_tfR[4]mean/sgm resolution
TObjArray*fResultslist of result graphs/histos/trees
Char_tfRowpad row (-1 for all)
UChar_tfSubTaskMapsteer map for subtasks
Float_tfTcalibrated time
Float_tfT0time 0
UChar_tfUseCalibsteer map for calibration params
Float_tfVdriftmean drift velocity
Float_tfXlocal drift length
Float_tfXchanode wire position for chamber
Float_tfYlocal rphi offset
Float_tfZlocal anode wire offset
Float_tfZchZ position for calibration element
static const Float_tfgkTimeBinLengthtime bin length (invers of sampling frequency)

Class Charts

Inheritance Chart:
TTask
AliAnalysisTask
AliAnalysisTaskSE
AliTRDrecoTask
AliTRDclusterResolution

Function documentation

AliTRDclusterResolution()
 Constructor
AliTRDclusterResolution(const char* name)
 Constructor
~AliTRDclusterResolution()
 Destructor
void UserCreateOutputObjects()
 Build and post histo container.
 Actual population of the container with histo is done in function Histos.
Bool_t GetRefFigure(Int_t ifig)
 Steering function to retrieve performance plots
TObjArray* Histos()
 Retrieve histograms array if already build or build it
void UserExec(Option_t* )
 Fill container histograms
Bool_t PostProcess()
 Steer processing of various cluster resolution dependences :

   - process resolution dependency cluster charge
   if(HasProcess(kYRes)) ProcessCharge();
   - process resolution dependency on y displacement
   if(HasProcess(kYSys)) ProcessCenterPad();
   - process resolution dependency on drift legth and drift cell width
   if(HasProcess(kSigm)) ProcessSigma();
   - process systematic shift on drift legth and drift cell width
   if(HasProcess(kMean)) ProcessMean();
Bool_t LoadCalibration()
 Retrieve calibration parameters from OCDB, drift velocity and t0 for the detector region specified by
 a previous call to AliTRDclusterResolution::SetCalibrationRegion().
Bool_t LoadGlobalChamberPosition()
 Retrieve global chamber position from alignment
 a previous call to AliTRDclusterResolution::SetCalibrationRegion() is mandatory.
void SetCalibrationRegion(Int_t det, Int_t col = -1, Int_t row = -1)
 Set calibration region in terms of detector and pad.
 By default detector 0 mean values are considered.
void SetVisual()
void ProcessCharge()
 Resolution as a function of cluster charge.

 As described in the function ProcessCenterPad() the error parameterization for clusters for phi = a_L can be
 written as:

#sigma_{y}^{2} = #sigma_{y}^{2}|_{B=0} + tg^{2}(#alpha_{L})*#sigma_{x}^{2}
 with the contribution in case of B=0 given by:

#sigma_{y}|_{B=0} = #sigma_{diff}*Gauss(0, s_{ly}) + #delta_{#sigma}(q)
 which further can be simplified to:

<#sigma_{y}|_{B=0}>(q) = <#sigma_{y}> + #delta_{#sigma}(q)
 The results for s_y and f(q) are displayed below:

 The function has to extended to accomodate gain calibration scalling and errors.

 Author
 Alexandru Bercuci <A.Bercuci@gsi.de>
Bool_t ProcessNormalTracks()
 Resolution as a function of y displacement from pad center and drift length.

 Since the error parameterization of cluster r-phi position can be written as (see AliTRDcluster::SetSigmaY2()):

#sigma_{y}^{2} = (#sigma_{diff}*Gauss(0, s_{ly}) + #delta_{#sigma}(q))^{2} + tg^{2}(#alpha_{L})*#sigma_{x}^{2} + tg^{2}(#phi-#alpha_{L})*#sigma_{x}^{2}+[tg(#phi-#alpha_{L})*tg(#alpha_{L})*x]^{2}/12
 one can see that for phi = a_L one gets the following expression:

#sigma_{y}^{2} = #sigma_{y}^{2}|_{B=0} + tg^{2}(#alpha_{L})*#sigma_{x}^{2}
 where we have explicitely marked the remaining term in case of absence of magnetic field. Thus one can use the
 previous equation to estimate s_y for B=0 and than by comparing in magnetic field conditions one can get the s_x.
 This is a simplified method to determine the error parameterization for s_x and s_y as compared to the one
 implemented in ProcessSigma(). For more details on cluster error parameterization please see also
 AliTRDcluster::SetSigmaY2()

 The representation of dy=f(y_cen, x_drift| layer) can be also used to estimate the systematic shift in the r-phi
 coordinate resulting from imperfection in the cluster shape parameterization. From the expresion of the shift derived
 in ProcessMean() with phi=exb one gets:

<#Delta y>= <#delta x> * (tg(#alpha_{L})-h*dz/dx) + <#delta y - #delta x * tg(#alpha_{L})>
 where all dependences are made explicit. This last expression can be used in two ways:
   - by average on the dz/dx we can determine directly dy (the method implemented here)
   - by plotting as a function of dzdx one can determine both dx and dy components in an independent method.

 Author
 Alexandru Bercuci <A.Bercuci@gsi.de>
void ProcessSigma()
 As the r-phi coordinate is the only one which is measured by the TRD detector we have to rely on it to
 estimate both the radial (x) and r-phi (y) errors. This method is based on the following assumptions.
 The measured error in the y direction is the sum of the intrinsic contribution of the r-phi measurement
 with the contribution of the radial measurement - because x is not a parameter of Alice track model (Kalman).

#sigma^{2}|_{y} = #sigma^{2}_{y*} + #sigma^{2}_{x*}
 In the general case

#sigma^{2}_{y*} = #sigma^{2}_{y} + tg^{2}(#alpha_{L})#sigma^{2}_{x_{drift}}
 where we have explicitely show the lorentz angle correction on y and the projection of radial component on the y
 direction through the track angle in the bending plane (phi). Also we have shown that the radial component in the
 last equation has twp terms, the drift and the misalignment (x_0). For ideal geometry or known misalignment one
 can solve the equation

#sigma^{2}|_{y} = tg^{2}(#phi - #alpha_{L})*(#sigma^{2}_{x} + tg^{2}(#alpha_{L})*x^{2}/12)+ [#sigma^{2}_{y} + tg^{2}(#alpha_{L})#sigma^{2}_{x}]
 by fitting a straight line:

#sigma^{2}|_{y} = a(x_{cl}, z_{cl}) * tg^{2}(#phi - #alpha_{L}) + b(x_{cl}, z_{cl})
 the error parameterization will be given by:

#sigma_{x} (x_{cl}, z_{cl}) = #sqrt{a(x_{cl}, z_{cl}) - tg^{2}(#alpha_{L})*x^{2}/12}
 Below there is an example of such dependency.


 The error parameterization obtained by this method are implemented in the functions AliTRDcluster::GetSX() and
 AliTRDcluster::GetSYdrift(). For an independent method to determine s_y as a function of drift length check the
 function ProcessCenterPad(). One has to keep in mind that while this method return the mean s_y over the distance
 to pad center distribution the other method returns the *STANDARD* value at center=0 (maximum). To recover the
 standard value one has to solve the obvious equation:

#sigma_{y}^{STANDARD} = #frac{<#sigma_{y}>}{#int{s exp(s^{2}/#sigma) ds}}
 with "<s_y>" being the value calculated here and "sigma" the width of the s_y distribution calculated in
 ProcessCenterPad().

 Author
 Alexandru Bercuci <A.Bercuci@gsi.de>
void ProcessMean()
 By this method the cluster shift in r-phi and radial directions can be estimated by comparing with the MC.
 The resolution of the cluster corrected for pad tilt with respect to MC in the r-phi (measuring) plane can be
 expressed by:

#Delta y=w - y_{MC}(x_{cl})
 where x_cl is the drift length attached to a cluster, y_cl is the r-phi coordinate of the cluster measured by
 charge sharing on adjacent pads and y_0 and z_0 are MC reference points (as example the track references at
 entrance/exit of a chamber). If we suppose that both r-phi (y) and radial (x) coordinate of the clusters are
 affected by errors we can write

x_{cl} = x_{cl}^{*} + #delta x
 where the starred components are the corrected values. Thus by definition the following quantity

#Delta y^{*}= w^{*} - y_{MC}(x_{cl}^{*})
 has 0 average over all dependency. Using this decomposition we can write:

<#Delta y>=<#Delta y^{*}> + <#delta x * (dy/dx-h*dz/dx) + #delta y - #delta x * tg(#alpha_{L})>
 which can be transformed to the following linear dependence:

<#Delta y>= <#delta x> * (dy/dx-h*dz/dx) + <#delta y - #delta x * tg(#alpha_{L})>
 if expressed as function of dy/dx-h*dz/dx. Furtheremore this expression can be plotted for various clusters
 i.e. we can explicitely introduce the diffusion (x_cl) and drift cell - anisochronity (z_cl) dependences. From
 plotting this dependence and linear fitting it with:

<#Delta y>= a(x_{cl}, z_{cl}) * (dy/dx-h*dz/dx) + b(x_{cl}, z_{cl})
 the systematic shifts will be given by:

#delta x (x_{cl}, z_{cl}) = a(x_{cl}, z_{cl})
 Below there is an example of such dependency.


 The occurance of the radial shift is due to the following conditions
   - the approximation of a constant drift velocity over the drift length (larger drift velocities close to
     cathode wire plane)
   - the superposition of charge tails in the amplification region (first clusters appear to be located at the
     anode wire)
   - the superposition of charge tails in the drift region (shift towards anode wire)
   - diffusion effects which convolute with the TRF thus enlarging it
   - approximate knowledge of the TRF (approximate measuring in test beam conditions)

 The occurance of the r-phi shift is due to the following conditions
   - approximate model for cluster shape (LUT)
   - rounding-up problems

 The numerical results for ideal simulations for the radial and r-phi shifts are displayed below and used
 for the cluster reconstruction (see the functions AliTRDcluster::GetXcorr() and AliTRDcluster::GetYcorr()).

 More details can be found in the presentation given during the TRD
 software meeting at the end of 2008 and beginning of year 2009, published on indico.cern.ch.

 Author
 Alexandru Bercuci <A.Bercuci@gsi.de>
void GetDiffCoeff(Float_t& dt, Float_t& dl) const
Float_t GetExB() const
Float_t GetVdrift() const
Float_t GetT0() const
Float_t GetGain() const
void ResetProcesses()
AliTRDclusterResolution()
Int_t GetDetector() const
{ return fDet; }
void GetPad(Int_t& c, Int_t& r) const
{ c=fCol, r=fRow; return;}
Float_t GetDyRange() const
{return fDyRange;}
Bool_t HasProcess(AliTRDclusterResolution::EResultContainer bit) const
{return TESTBIT(fSubTaskMap, bit);}
Bool_t IsCalibrated() const
{ return TestBit(kCalibrated);}
Bool_t HasGlobalPosition() const
{ return TestBit(kGlobal);}
Bool_t IsUsingCalibParam(AliTRDclusterResolution::ECalibrationParam par) const
{return TESTBIT(fUseCalib, par);}
TObjArray* Results() const
{return fResults;}
Bool_t IsVisual() const
{return Bool_t(fCanvas);}
Bool_t IsSaveAs() const
{return TestBit(kSaveAs);}
void SetDyRange(Float_t dy)
{if(dy>0) fDyRange = dy;}
void SetProcess(AliTRDclusterResolution::EResultContainer bit, Bool_t v = kTRUE)
{v ? SETBIT(fSubTaskMap, bit) : CLRBIT(fSubTaskMap, bit);}
void SetSaveAs(Bool_t v = kTRUE)
void SetUseCalibParam(AliTRDclusterResolution::ECalibrationParam par, Bool_t v = kTRUE)
{v ? SETBIT(fUseCalib, par) : CLRBIT(fUseCalib, par);}
AliTRDclusterResolution& operator=(const AliTRDclusterResolution& )