ROOT logo
HYDRA - THE HADES ANALYSIS PACKAGE » (UNKNOWN) » HParticleBtRing

class HParticleBtRing: public TObject

_HADES_CLASS_DESCRIPTION


  HParticleBtRing

  In this container all ring identification output provided by RICH
  backtracking is stored. HParticleCand::getRichBTInd() returns the
  ID to identify the corresponding backtracking container.
  -1 is returned if no backtracking information is provided.
  Only  tracks that fulfill the criteria of the track selection
  function and have at least one fired pad are stored. Track Fragments
  used for shared maxima information are only calculated in 4 degree range
  around good particle candidate with backtracking hits.






    Track selection function for lepton candidates



    Bool_t selectEpEm = kFALSE;
    if(pcand->isFlagAND(4,
			Particle::kIsAcceptedHitInnerMDC,
			Particle::kIsAcceptedHitOuterMDC,
			Particle::kIsAcceptedHitMETA,
			Particle::kIsAcceptedRK)&&

       pcand->getInnerSegmentChi2() > 0
       &&
       isGoodLepton(pcand)
       &&
       ( (sys == 0 && beta > 0.95) || (sys == 1 && beta > 0.93) )
        &&
       (MDCdEdx < 10)
       &&
       pcand->getChi2() < 1000) selectEpEm=kTRUE;
       )
           return kTRUE;
       else
	     return kFALSE;




  Example


    HCategory* btCat = (HCategory*)HCategoryManager::getCategory(catParticleBtRing);
    HParticleBtRing*     btRing;
    btRing = HCategoryManager::getObject(btRing,btCat,pcand1->getRichBTInd());
    btRing->getMaxima();
    btRing->getMaximaSharedTrack(pcand2->getIndex());



  Hints for usage

  Good Rings have at least 2 Maxima  and even more PadsRing. There are also
  rings with 1 Maxima, but this data sample is dominated by noise and will
  be unefficient to suppress large numbers of pions. Thresholds on other
  observables can be used to improve hadron suppression.
  Shared maxima are useful to identify overlapping rings from close pairs
  and hadronic tracks which pick up charge from good rings.




  Output variables:


  PadsRing:   Number of pads with good charge (q>65) on ring prediction area.
  PadsSum:    Number of all pads from clusters with at least one pad on ring.
              prediction area.
  ChargeRing: Charge of pads with good charge (q>65) on ring prediction area.
  ChargeSum:  Charge of all pads from clusters with at least one pad on ring
              prediction area.

  Clusters:     Number of clusters with at least one pad on ring prediction area.
  Maxima:       Number of maxima from contributing clusters inside 6 sigma area.
  MaximaCharge: Sum of charge of all maxima pads contributing clusters inside 6 sigma area.
  NearbyMaxima: Number of maxima from contributing clusters inside 3 sigma area.

  Chi2:       Ring quality based on maxima position.
  MeanDist:   Shift of ring center which minimizes Chi2 value
  RingMatrix: Charge of  pads matching with the ring prediction region divided by the charge of all pads in
              pad region with a radius of 8 pads around ring center.

  MaximaShared:                Number of maxima shared with other tracks.
  MaximaSharedFragement:      Number of maxima shared with other track Fragments in 4 degree
                               area around particle candidate
  MaximaChargeShared:          Sum  charge of all maxima pads that is shared other tracks.
  MaximaChargeSharedFragment: Sum  charge of all maxima pads that is shared with other
                               track fragments in 4 degree area around ring.
  NearbyMaximaShared:          Number of nearby maxima shared with other tracks.


  MaximaSharedTrack:          Number of maxima shared with one specific track.
                              HParticleCand index is needed as input value.
  MaximaSharedFragmentTrack: Number of maxima shared with one specific track fragment in
                              4 degree area around ring.
                              HParticleCand index is needed as input value.
  MaximaChargeSharedTrack:    Sum  charge of all maxima pads that is with one specific track.
                              HParticleCand index is needed as input value.
  MaximaChargeSharedFragmentTrack: Sum  charge of all maxima pads that is with one specific
                              track fragment in 4 degree area around ring.
                              HParticleCand index is needed as input value.

  NearbyMaximaSharedTrack: Number of nearby maxima shared with one specific track.
                           HParticleCand index is needed as input value.


Function Members (Methods)

public:
HParticleBtRing()
HParticleBtRing(const HParticleBtRing&)
virtual~HParticleBtRing()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
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_tgetChargeClus()
Float_tgetChargeRing()
Float_tgetChi2()
Int_tgetClusters()
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
Int_tgetMaxima()
Float_tgetMaximaCharge()
Float_tgetMaximaChargeShared()
Float_tgetMaximaChargeSharedFragment()
Float_tgetMaximaChargeSharedTrack(Int_t idx)
Int_tgetMaximaShared()
Int_tgetMaximaSharedFragment()
Int_tgetMaximaSharedTrack(Int_t idx)
Float_tgetMeanDist()
virtual const char*TObject::GetName() const
Int_tgetNearbyMaxima()
Int_tgetNearbyMaximaShared()
Int_tgetNearbyMaximaSharedTrack(Int_t idx)
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Int_tgetPadsClus()
Int_tgetPadsRing()
Float_tgetRingMatrix()
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
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
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
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)
HParticleBtRing&operator=(const HParticleBtRing&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") 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(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidsetChargeClus(Float_t val)
voidsetChargeRing(Float_t val)
voidsetChi2(Float_t val)
voidsetClusters(Int_t val)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidsetMaxima(Int_t val)
voidsetMaximaCharge(Float_t val)
voidsetMaximaChargeShared(Float_t val)
voidsetMaximaChargeSharedFragment(Float_t val)
voidsetMaximaChargeSharedFragmentTrack(Float_t* val)
voidsetMaximaChargeSharedFragmentTrackIdx(Int_t* val)
voidsetMaximaChargeSharedTrack(Float_t* val)
voidsetMaximaChargeSharedTrackIdx(Int_t* val)
voidsetMaximaShared(Int_t val)
voidsetMaximaSharedFragment(Int_t val)
voidsetMaximaSharedFragmentTrack(Int_t* val)
voidsetMaximaSharedFragmentTrackIdx(Int_t* val)
voidsetMaximaSharedTrack(Int_t* val)
voidsetMaximaSharedTrackIdx(Int_t* val)
voidsetMeanDist(Float_t val)
voidsetNearbyMaxima(Int_t val)
voidsetNearbyMaximaShared(Int_t val)
voidsetNearbyMaximaSharedTrack(Int_t* val)
voidsetNearbyMaximaSharedTrackIdx(Int_t* val)
static voidTObject::SetObjectStat(Bool_t stat)
voidsetPadsClus(Int_t val)
voidsetPadsRing(Int_t val)
voidsetRingMatrix(Float_t val)
virtual voidTObject::SetUniqueID(UInt_t uid)
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 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
voidTObject::MakeZombie()
private:
voidinit()

Data Members

private:
Float_tfChargeRing
Float_tfChargeSum
Float_tfChi2
Int_tfClusters
Int_tfMaxima
Float_tfMaximaCharge
Float_tfMaximaChargeShared
Float_tfMaximaChargeSharedBad
Float_tfMaximaChargeSharedBadTrack[10]
Int_tfMaximaChargeSharedBadTrackIdx[10]
Float_tfMaximaChargeSharedTrack[10]
Int_tfMaximaChargeSharedTrackIdx[10]
Int_tfMaximaShared
Int_tfMaximaSharedBad
Int_tfMaximaSharedBadTrack[10]
Int_tfMaximaSharedBadTrackIdx[10]
Int_tfMaximaSharedTrack[10]
Int_tfMaximaSharedTrackIdx[10]
Float_tfMeanDist
Int_tfNearbyMaxima
Int_tfNearbyMaximaShared
Int_tfNearbyMaximaSharedTrack[10]
Int_tfNearbyMaximaSharedTrackIdx[10]
Int_tfPadsRing
Int_tfPadsSum
Float_tfRingMatrix

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

HParticleBtRing()
~HParticleBtRing()
void init()
Int_t getMaximaSharedTrack(Int_t idx)
Returns number of maxima shared with ring of candidate with given index
If number of neighbouring tracks is larger than 5, -1 is returned
Shared maxima are searched in 3 sigma area
Float_t getMaximaChargeSharedTrack(Int_t idx)
Returns charge of maximas shared with ring of candidate with given index
If number of neighbouring tracks is larger than 5, -1 is returned
Shared maxima are searched in 3 sigma area
Int_t getNearbyMaximaSharedTrack(Int_t idx)
Returns number of maxima shared with ring of candidate with given index
If number of neighbouring tracks is larger than 5, -1 is returned
Shared maxima are searched in 3 sigma area
void Streamer(TBuffer& )
 Stream an object of class HParticleBtRing.
HParticleBtRing()
void setPadsRing(Int_t val)
 ------------ set functions -----------
{ fPadsRing = val;}
void setPadsClus(Int_t val)
{ fPadsSum = val;}
void setChargeRing(Float_t val)
{ fChargeRing = val;}
void setChargeClus(Float_t val)
{ fChargeSum = val;}
void setClusters(Int_t val)
{ fClusters = val;}
void setMaxima(Int_t val)
{ fMaxima = val;}
void setMaximaCharge(Float_t val)
{ fMaximaCharge = val;}
void setNearbyMaxima(Int_t val)
{ fNearbyMaxima = val;}
void setChi2(Float_t val)
{ fChi2 = val;}
void setMeanDist(Float_t val)
{ fMeanDist = val;}
void setRingMatrix(Float_t val)
{ fRingMatrix = val;}
void setMaximaShared(Int_t val)
{ fMaximaShared = val;}
void setMaximaSharedTrack(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaSharedTrack[i] = val[i];}
void setMaximaSharedTrackIdx(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaSharedTrackIdx[i] = val[i];}
void setMaximaSharedFragment(Int_t val)
void setMaximaSharedFragmentTrack(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaSharedBadTrack[i] = val[i];}
void setMaximaSharedFragmentTrackIdx(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaSharedBadTrackIdx[i] = val[i];}
void setMaximaChargeShared(Float_t val)
void setMaximaChargeSharedTrack(Float_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaChargeSharedTrack[i] = val[i];}
void setMaximaChargeSharedTrackIdx(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaChargeSharedTrackIdx[i] = val[i];}
void setMaximaChargeSharedFragment(Float_t val)
void setMaximaChargeSharedFragmentTrack(Float_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaChargeSharedBadTrack[i] = val[i];}
void setMaximaChargeSharedFragmentTrackIdx(Int_t* val)
{ for(Int_t i=0;i<10;i++) fMaximaChargeSharedBadTrackIdx[i] = val[i];}
void setNearbyMaximaShared(Int_t val)
void setNearbyMaximaSharedTrack(Int_t* val)
{ for(Int_t i=0;i<10;i++) fNearbyMaximaSharedTrack[i] = val[i];}
void setNearbyMaximaSharedTrackIdx(Int_t* val)
{ for(Int_t i=0;i<10;i++) fNearbyMaximaSharedTrackIdx[i] = val[i];}
Int_t getPadsRing(void)
 ------------ get functions -----------
{ return fPadsRing ;}
Int_t getPadsClus(void)
{ return fPadsSum ;}
Float_t getChargeRing(void)
{ return fChargeRing;}
Float_t getChargeClus(void)
{ return fChargeSum ;}
Int_t getClusters(void)
{ return fClusters ;}
Int_t getMaxima(void)
{ return fMaxima ;}
Float_t getMaximaCharge(void)
{ return fMaximaCharge;}
Int_t getNearbyMaxima(void)
{ return fNearbyMaxima;}
Float_t getChi2(void)
{ return fChi2 ;}
Float_t getMeanDist(void)
{ return fMeanDist ;}
Float_t getRingMatrix(void)
{ return fRingMatrix ;}
Int_t getMaximaShared(void)
{ return fMaximaShared ;}
Int_t getMaximaSharedFragment(void)
{ return fMaximaSharedBad ;}
Float_t getMaximaChargeShared(void)
Float_t getMaximaChargeSharedFragment(void)
Int_t getNearbyMaximaShared(void)