ROOT logo
AliRoot » TRD » AliTRDcluster

class AliTRDcluster: public AliCluster


TRD cluster


Function Members (Methods)

public:
AliTRDcluster()
AliTRDcluster(const AliTRDcluster& c)
AliTRDcluster(const AliTRDtrackletWord *const tracklet, Int_t det, UShort_t volid)
AliTRDcluster(Int_t det, UChar_t col, UChar_t row, UChar_t time, const Short_t* sig, UShort_t volid)
AliTRDcluster(Int_t det, Float_t q, const Float_t* pos, const Float_t* sig, const Int_t* tracks, Char_t npads, Short_t *const signals, UChar_t col, UChar_t row, UChar_t time, Char_t timebin, Float_t center, UShort_t volid)
virtual~AliTRDcluster()
voidTObject::AbstractMethod(const char* method) const
virtual voidAddTrackIndex(const Int_t *const i)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidClear(Option_t* o = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) 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 voidTObject::Error(const char* method, const char* msgfmt) const
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 voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Float_tGetCenter() const
Int_tGetDetector() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual Bool_tAliCluster::GetGlobalCov(Float_t* cov) const
virtual Bool_tAliCluster::GetGlobalXYZ(Float_t* xyz) const
virtual const char*TObject::GetIconName() const
Int_tAliCluster::GetLabel(Int_t i) const
Int_tGetLocalTimeBin() const
virtual const char*TObject::GetName() const
Int_tGetNPads() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Int_tGetPadCol() const
UChar_tGetPadMaskedPosition() const
UChar_tGetPadMaskedStatus() const
Int_tGetPadRow() const
Int_tGetPadTime() const
Float_tGetQ() const
Short_tGetRawQ() const
Float_tAliCluster::GetSigmaY2() const
Float_tAliCluster::GetSigmaYZ() const
Float_tAliCluster::GetSigmaZ2() const
Short_t*GetSignals()
Float_tGetSumS() const
static Double_tGetSX(Int_t tb, Double_t z = -1)
static Double_tGetSYcharge(Float_t q)
static Double_tGetSYdrift(Int_t tb, Int_t ly = 0, Double_t z = -1)
static Double_tGetSYprf(Int_t ly, Double_t center, Double_t s2)
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
UShort_tAliCluster::GetVolumeId() const
Float_tAliCluster::GetX() const
virtual Bool_tAliCluster::GetXAlphaRefPlane(Float_t& x, Float_t& alpha) const
static Double_tGetXcorr(Int_t tb, Double_t z = -1)
Float_tGetXloc(Double_t t0, Double_t vd, const Double_t *const q = 0x0, const Double_t *const xq = 0x0, Double_t z = 0.2)
virtual Bool_tAliCluster::GetXRefPlane(Float_t& xref) const
Float_tAliCluster::GetY() const
static Double_tGetYcorr(Int_t ly, Float_t y)
Float_tGetYloc(Double_t y0, Double_t s2, Double_t W, Double_t *const y1 = 0x0, Double_t *const y2 = 0x0)
Float_tAliCluster::GetZ() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
Bool_tHasRawSignals() const
Bool_tHasXcorr() const
voidAliCluster::IncreaseClusterUsage()
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 voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tAliCluster::IsClusterShared() const
Bool_tAliCluster::IsClusterUsed() const
virtual Bool_tIsEqual(const TObject* otherCluster) const
Bool_tIsFivePad() const
virtual Bool_tTObject::IsFolder() const
Bool_tIsInChamber() const
Bool_tIsMasked() const
Bool_tIsMCcluster() const
Bool_tTObject::IsOnHeap() const
Bool_tIsRPhiMethod(AliTRDcluster::ETRDclusterStatus m) const
Bool_tIsShared() const
virtual Bool_tTObject::IsSortable() const
Bool_tIsUsed() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
Bool_tAliCluster::Misalign()
virtual Bool_tTObject::Notify()
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)
AliTRDcluster&operator=(const AliTRDcluster& c)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidPrint(Option_t* o = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetClusterMasking(UChar_t inClusterMasking)
voidSetDetector(Short_t inDetector)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetFivePad(Bool_t b = kTRUE)
voidSetInChamber(Bool_t in = kTRUE)
voidAliCluster::SetLabel(Int_t lab, Int_t i)
voidSetLocalTimeBin(Char_t t)
voidSetNPads(Int_t n)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetPadCol(UChar_t inPadCol)
voidSetPadMaskedPosition(UChar_t position)
voidSetPadMaskedStatus(UChar_t status)
voidSetPadRow(UChar_t inPadRow)
voidSetPadTime(UChar_t inPadTime)
voidSetQ(Float_t inQ)
voidSetRPhiMethod(AliTRDcluster::ETRDclusterStatus m)
voidSetShared(Bool_t sh = kTRUE)
voidSetSigmaY2(Float_t s2, Float_t dt, Float_t exb, Float_t x0, Float_t z = -1., Float_t tgp = 0.)
voidAliCluster::SetSigmaYZ(Float_t sigyz)
voidAliCluster::SetSigmaZ2(Float_t sigz2)
voidSetSignals(Short_t* sig, Bool_t raw = kTRUE)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidAliCluster::SetVolumeId(UShort_t id)
voidAliCluster::SetX(Float_t x)
voidSetXcorr(Bool_t xc = kTRUE)
voidAliCluster::SetY(Float_t y)
voidAliCluster::SetZ(Float_t z)
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidUse(Int_t u = 1)
virtual voidTObject::UseCurrentStyle()
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:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual TGeoHMatrix*AliCluster::GetMatrix(Bool_t original = kFALSE) const
virtual const TGeoHMatrix*AliCluster::GetTracking2LocalMatrix() const
voidTObject::MakeZombie()
private:
static voidFillLUT()
Float_tGetDYcog(const Double_t *const y1 = 0x0, const Double_t *const y2 = 0x0)
Float_tGetDYgauss(Double_t sw, Double_t *const y1 = 0x0, Double_t *const y2 = 0x0)
Float_tGetDYlut(const Double_t *const y1 = 0x0, const Double_t *const y2 = 0x0)

Data Members

public:
enum ETRDclusterStatus { kInChamber
kFivePad
kLUT
kGAUS
kCOG
kXcorr
kRawSignals
};
enum ETRDclusterMask { kMaskedLeft
kMaskedCenter
kMaskedRight
};
enum AliCluster::[unnamed] { kUsed
kShared
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
Float_tfCenterCenter of the cluster relative to the pad
UChar_tfClusterMaskingBit field containing cluster status information;
Short_tfDetectorTRD detector number
Char_tfLocalTimeBinT0-calibrated time bin number
UChar_tfNPadsNumber of pads in cluster
UChar_tfPadColCentral pad number in column direction
UChar_tfPadRowCentral pad number in row direction
UChar_tfPadTimeUncalibrated time bin number
Float_tfQCalibrated cluster charge
Short_tfSignals[7]Raw signals if HasRawSignals() returns true. Otherwise calibrated.
private:
static Double_t*fgLUT! The lookup table
static const Int_tfgkNlut! Number of bins of the LUT

Class Charts

Inheritance Chart:
TObject
AliCluster
AliTRDcluster

Function documentation

AliTRDcluster()
 Default constructor

AliTRDcluster(Int_t det, UChar_t col, UChar_t row, UChar_t time, const Short_t* sig, UShort_t volid)
 Constructor for self constructing cluster. In this approach the information is inserted gradualy into the
 cluster and all dependencies are (re)calculated inside the cluster itself.

 A.Bercuci <A.Bercuci@gsi.de>
AliTRDcluster(Int_t det, Float_t q, const Float_t* pos, const Float_t* sig, const Int_t* tracks, Char_t npads, Short_t *const signals, UChar_t col, UChar_t row, UChar_t time, Char_t timebin, Float_t center, UShort_t volid)
 Constructor

AliTRDcluster(const AliTRDtrackletWord *const tracklet, Int_t det, UShort_t volid)
 Constructor from online tracklet

AliTRDcluster(const AliTRDcluster& c)
 Copy constructor

AliTRDcluster & operator=(const AliTRDcluster& c)
 Assignment operator

void AddTrackIndex(const Int_t *const i)
 Adds track index. Currently assumed that track is an array of
 size 9, and up to 3 track indexes are stored in fTracks[3].
 Indexes are sorted according to:
  1) index of max number of appearances is stored first
  2) if two or more indexes appear equal number of times, the lowest
     ones are stored first;

void Clear(Option_t* o = "")
 Reset all member to the default value

Float_t GetSumS() const
 Returns the total charge from a not unfolded cluster

Double_t GetSX(Int_t tb, Double_t z = -1)
 Returns the error parameterization in the radial direction for TRD clusters as function of
 the calibrated time bin (tb) and optionally distance to anode wire (z). By default (no z information)
 the mean value over all cluster to wire distance is chosen.

 There are several contributions which are entering in the definition of the radial errors of the clusters.
 Although an analytic defition should be possible for the moment this is not yet available but instead a
 numerical parameterization is provided (see AliTRDclusterResolution::ProcessSigma() for the calibration
 method). The result is displayed in the figure below as a 2D plot and also as the projection on the drift axis.



 Here is a list of uncertainty components:
 - Time Response Function (TRF) - the major contribution. since TRF is also not symmetric (even if tail is
   cancelled) it also creates a systematic shift dependent on the charge distribution before and after the cluster.
 - longitudinal diffusion - increase the width of TRF and scales with square root of drift length
 - variation in the drift velocity within the drift cell

 Author
 A.Bercuci <A.Bercuci@gsi.de>

Double_t GetSYdrift(Int_t tb, Int_t ly = 0, Double_t z = -1)
 Returns the error parameterization for TRD clusters as function of the drift length (here calibrated time bin tb)
 and optionally distance to anode wire (z) for the LUT r-phi cluster shape. By default (no z information) the largest
 value over all cluster to wire values is chosen.

 For the LUT method the dependence of s_y with x and d is obtained via a fit to the cluster to MC
 resolution. (see class AliTRDclusterResolution for more details). A normalization to the reference radial position
 x0 = 0.675 (tb=5 for ideal vd) is also applied (see GetSYprf()). The function is *NOT* calibration aware !
 The result is displayed in the figure below as a 2D plot and also as the projection on the drift axis. A comparison
 with the GAUS parameterization is also given

 For the GAUS method the dependence of s_y with x is *analytic* and it is expressed by the relation.

#sigma^{2}_{y} = #sigma^{2}_{PRF} + #frac{x#delta_{t}^{2}}{(1+tg(#alpha_{L}))^{2}}
 The result is displayed in the figure below as function of the drift time and compared with the LUT parameterization.


 Author
 A.Bercuci <A.Bercuci@gsi.de>

Double_t GetSYcharge(Float_t q)
 Parameterization of the r-phi resolution component due to cluster charge.
 The value is the offset from the nominal cluster resolution defined as the
 cluster resolution at average cluster charge (q0).


#Delta #sigma_{y}(q) = a*(#frac{1}{q} - #frac{1}{q_{0}})
 The definition is *NOT* robust against gain fluctuations and thus two approaches are possible
 when residual miscalibration are available:
   - determine parameterization with a resolution matching those of the gain
   - define an analytic model which scales with the gain.

 For more details please see AliTRDclusterResolution::ProcessCharge()



 Author
 A.Bercuci <A.Bercuci@gsi.de>

Double_t GetSYprf(Int_t ly, Double_t center, Double_t s2)
 Parameterization of the cluster error in the r-phi direction due to charge sharing between
 adiacent pads. Should be identical to what is provided in the OCDB as PRF [TODO]

 The parameterization is obtained from fitting cluster resolution at phi=exb and |x-0.675|<0.225.
 For more details see AliTRDclusterResolution::ProcessCenter().



 Author
 A.Bercuci <A.Bercuci@gsi.de>

Double_t GetXcorr(Int_t tb, Double_t z = -1)
 Drift length correction [cm]. Due to variation of mean drift velocity along the drift region
 from nominal vd at xd->infinity. For drift velocity determination based on tracking information
 the correction should be negligible.

 TODO to be parametrized in term of drift velocity at infinite drift length
 A.Bercuci (Mar 28 2009)

Double_t GetYcorr(Int_t ly, Float_t y)
 PRF correction for the LUT r-phi cluster shape.


Float_t GetXloc(Double_t t0, Double_t vd, const Double_t *const q = 0x0, const Double_t *const xq = 0x0, Double_t z = 0.2)
 (Re)Calculate cluster position in the x direction in local chamber coordinates (with respect to the anode wire
 position) using all available information from tracking.
 Input parameters:
   t0 - calibration aware trigger delay [us]
   vd - drift velocity in the region of the cluster [cm/us]
   z  - distance to the anode wire [cm]. By default average over the drift cell width.
   q & xq - array of charges and cluster positions from previous clusters in the tracklet [a.u.]
 Output values :
   return x position of the cluster with respect to the
   anode wire using all tracking information

 The estimation of the radial position is based on calculating the drift time and the drift velocity at the point of
 estimation. The drift time can be estimated according to the expression:

t_{drift} = t_{bin} - t_{0} - t_{cause}(x) - t_{TC}(q_{i-1}, q_{i-2}, ...)
 where t_0 is the delay of the trigger signal. t_cause is the causality delay between ionisation electrons hitting
 the anode and the registration of maximum signal by the electronics - it is due to the rising time of the TRF
 A second order correction here comes from the fact that the time spreading of charge at anode is the convolution of
 TRF with the diffusion and thus cross-talk between clusters before and after local clusters changes with drift length.
 t_TC is the residual charge from previous (in time) clusters due to residual tails after tail cancellation.
 This tends to push cluster forward and depends on the magnitude of their charge.

 The drift velocity varies with the drift length (and distance to anode wire) as described by cell structure simulation.
 Thus one, in principle, can calculate iteratively the drift length from the expression:

x = t_{drift}(x)*v_{drift}(x)
 In practice we use a numerical approach (AliTRDcluster::GetXcorr()) to correct for anisochronity obtained from MC
 comparison (see AliTRDclusterResolution::ProcessSigma()). Also the calibration of 0 approximation (no x dependence)
 for t_cause is obtained from MC comparisons and impossible to disentangle in real life from trigger delay.

 Author
 Alex Bercuci <A.Bercuci@gsi.de>

Float_t GetYloc(Double_t y0, Double_t s2, Double_t W, Double_t *const y1 = 0x0, Double_t *const y2 = 0x0)
 Calculate, in tracking cooordinate system, the r-phi offset the cluster
 from the middle of the center pad. Three possible methods are implemented:
   - Center of Gravity (COG) see AliTRDcluster::GetDYcog()
   - Look-up Table (LUT) see AliTRDcluster::GetDYlut()
   - Gauss shape (GAUS) see AliTRDcluster::GetDYgauss()
 In addition for the case of LUT method position corrections are also
 applied (see AliTRDcluster::GetYcorr())

void SetSigmaY2(Float_t s2, Float_t dt, Float_t exb, Float_t x0, Float_t z = -1., Float_t tgp = 0.)
 Set variance of TRD cluster in the r-phi direction for each method.
 Parameters :
   - s2  - variance due to PRF width for the case of Gauss model. Replaced by parameterization in case of LUT.
   - dt  - transversal diffusion coeficient
   - exb - tg of lorentz angle
   - x   - drift length - with respect to the anode wire
   - z   - offset from the anode wire
   - tgp - local tangent of the track momentum azimuthal angle

 The ingredients from which the error is computed are:
   - PRF (charge sharing on adjacent pads)  - see AliTRDcluster::GetSYprf()
   - diffusion (dependence with drift length and [2nd order] distance to anode wire) - see AliTRDcluster::GetSYdrift()
   - charge of the cluster (complex dependence on gain and tail cancellation) - see AliTRDcluster::GetSYcharge()
   - lorentz angle (dependence on the drift length and [2nd order] distance to anode wire) - see AliTRDcluster::GetSX()
   - track angle (superposition of charges on the anode wire) - see AliTRDseedV1::Fit()
   - projection of radial(x) error on r-phi due to fixed value assumed in tracking for x - see AliTRDseedV1::Fit()

 The last 2 contributions to cluster error can be estimated only during tracking when the track angle
 is known (tgp). For this reason the errors (and optional position) of TRD clusters are recalculated during
 tracking and thus clusters attached to tracks might differ from bare clusters.

 Taking into account all contributions one can write the the TRD cluster error parameterization as:

#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
 From this formula one can deduce a that the simplest calibration method for PRF and diffusion contributions is
 by measuring resolution at B=0T and phi=0. To disentangle further the two remaining contributions one has
 to represent s2 as a function of drift length.

 In the gaussian model the diffusion contribution can be expressed as:

#sigma^{2}_{y} = #sigma^{2}_{PRF} + #frac{x#delta_{t}^{2}}{(1+tg(#alpha_{L}))^{2}}
 thus resulting the PRF contribution. For the case of the LUT model both contributions have to be determined from
 the fit (see AliTRDclusterResolution::ProcessCenter() for details).

 Author:
 A.Bercuci <A.Bercuci@gsi.de>

Bool_t IsEqual(const TObject* otherCluster) const
 Compare relevant information of this cluster with another one

void Print(Option_t* o = "") const
 Print cluster information

void SetPadMaskedPosition(UChar_t position)
 Store the pad corruption position code

 Code: 1 = left cluster
       2 = middle cluster;
       4 = right cluster

void SetPadMaskedStatus(UChar_t status)
 Store the status of the corrupted pad

 Code: 2 = noisy
       4 = Bridged Left
       8 = Bridged Right
      32 = Not Connected

Float_t GetDYcog(const Double_t *const y1 = 0x0, const Double_t *const y2 = 0x0)
 Get COG position
 Used for clusters with more than 3 pads - where LUT not applicable

Float_t GetDYlut(const Double_t *const y1 = 0x0, const Double_t *const y2 = 0x0)
 Calculates the cluster position using the lookup table.
 Method provided by Bogdan Vulpescu.

Float_t GetDYgauss(Double_t sw, Double_t *const y1 = 0x0, Double_t *const y2 = 0x0)
 (Re)Calculate cluster position in the y direction in local chamber coordinates using all available information from tracking.

 Input parameters:
   s2 - sigma of gaussian parameterization (see bellow for the exact parameterization)
   W  - pad width
   xd - drift length (with respect to the anode wire) [cm]
   wt - omega*tau = tg(a_L)
 Output values :
   y1 and y2 - partial positions based on 2 pads clusters
   return y position of the cluster from all information

 Estimation of y coordinate is based on the gaussian approximation of the PRF. Thus one may
 calculate the y position knowing the signals q_i-1, q_i and q_i+1 in the 3 adiacent pads by:

y = #frac{1}{w_{1}+w_{2}}#[]{w_{1}#(){y_{0}-#frac{W}{2}+#frac{s^{2}}{W}ln#frac{q_{i}}{q_{i-1}}}+w_{2}#(){y_{0}+ #frac{W}{2}+#frac{s^{2}}{W}ln#frac{q_{i+1}}{q_{i}}}}
 where W is the pad width, y_0 is the position of the center pad and s^2 is given by

s^{2} = s^{2}_{0} + s^{2}_{diff} (x,B) + #frac{tg^{2}(#phi-#alpha_{L})*l^{2}}{12}
 with s_0 being the PRF for 0 drift and track incidence phi equal to the lorentz angle a_L and the diffusion term
 being described by:

s_{diff} (x,B) = #frac{D_{L}#sqrt{x}}{1+#(){#omega#tau}^{2}}
 with x being the drift length. The weights w_1 and w_2 are taken to be q_i-1^2 and q_i+1^2 respectively

 Authors
 Alex Bercuci <A.Bercuci@gsi.de>
 Theodor Rascanu <trascanu@stud.uni-frankfurt.de>

void FillLUT()
 Create the LUT

Bool_t IsMCcluster() const
Bool_t IsRPhiMethod(AliTRDcluster::ETRDclusterStatus m) const
void SetRPhiMethod(AliTRDcluster::ETRDclusterStatus m)
virtual ~AliTRDcluster()
{}
Bool_t IsInChamber() const
{ return TestBit(kInChamber); }
Bool_t IsMasked() const
{ return fClusterMasking ? kTRUE : kFALSE; }
Bool_t IsShared() const
{ return IsClusterShared(); }
Bool_t IsUsed() const
{ return IsClusterUsed(); }
Bool_t IsFivePad() const
{ return TestBit(kFivePad); }
Bool_t HasXcorr() const
{ return TestBit(kXcorr); }
Bool_t HasRawSignals() const
{ return TestBit(kRawSignals); }
UChar_t GetPadMaskedPosition() const
{ return fClusterMasking & 7; }
UChar_t GetPadMaskedStatus() const
{ return fClusterMasking >> 3; }
Int_t GetDetector() const
{ return fDetector; }
Int_t GetLocalTimeBin() const
{ return fLocalTimeBin; }
Float_t GetQ() const
{ return fQ; }
Short_t GetRawQ() const
Int_t GetNPads() const
{ return fNPads; }
Float_t GetCenter() const
{ return fCenter; }
Int_t GetPadCol() const
{ return fPadCol; }
Int_t GetPadRow() const
{ return fPadRow; }
Int_t GetPadTime() const
{ return fPadTime; }
Short_t * GetSignals()
{ return fSignals; }
void SetLocalTimeBin(Char_t t)
{ fLocalTimeBin = t; }
void SetNPads(Int_t n)
{ fNPads = n; }
void SetPadCol(UChar_t inPadCol)
{ fPadCol = inPadCol; }
void SetPadRow(UChar_t inPadRow)
{ fPadRow = inPadRow; }
void SetPadTime(UChar_t inPadTime)
{ fPadTime = inPadTime; }
void SetDetector(Short_t inDetector)
{ fDetector = inDetector; }
void SetQ(Float_t inQ)
{ fQ = inQ; }
void SetClusterMasking(UChar_t inClusterMasking)
{ fClusterMasking = inClusterMasking; }
void SetShared(Bool_t sh = kTRUE)
void SetFivePad(Bool_t b = kTRUE)
void SetInChamber(Bool_t in = kTRUE)
void SetSignals(Short_t* sig, Bool_t raw = kTRUE)
{ memcpy(fSignals, sig, 7*sizeof(Short_t)); SetBit(kRawSignals, raw);}
void SetXcorr(Bool_t xc = kTRUE)
{ SetBit(kXcorr,xc); }
void Use(Int_t u = 1)