MdcSegList Class Reference

#include <MdcSegList.h>

List of all members.

Public Member Functions
void	append (MdcSeg *aSeg)
void	append (MdcSeg *aSeg)
int	count () const
int	count () const
void	destroySegs ()
void	destroySegs ()
MdcSeg *	getSeed (int iview, int goodOnly)
MdcSeg *	getSeed (int iview, int goodOnly)
	MdcSegList (int nSupers, const MdcSegParams segParms)
	MdcSegList (int nSupers, const MdcSegParams segParms)
const GmsList *	oneList (int slayIndex) const
const GmsList *	oneList (int slayIndex) const
void	plot () const
void	plot () const
void	resetSeed (const MdcDetector *gm)
void	resetSeed (const MdcDetector *gm)
MdcSegParams *	segPar ()
MdcSegParams *	segPar ()
void	setPlot (int lPlt)
void	setPlot (int lPlt)
	~MdcSegList ()
	~MdcSegList ()
Private Member Functions
void	deleteDups (bool drop)
void	deleteDups (bool drop)
void	massageSegs ()
void	massageSegs ()
void	sortByPhi ()
void	sortByPhi ()
void	tagAmbig ()
void	tagAmbig ()
void	zeroSeed ()
void	zeroSeed ()
Private Attributes
int	_nsupers
MdcSeg *	seedSeg [3]
MdcSeg *	seedSeg [3]
const MdcSuperLayer *	seedSlay [3]
const MdcSuperLayer *	seedSlay [3]
GmsList *	segList
GmsList *	segList
MdcSegParams	segParam
Friends
class	MdcSegFinder

---

Constructor & Destructor Documentation

MdcSegList::MdcSegList (  int  nSupers, const MdcSegParams  segParms )

{ /**************************************************************************/ segParam = segP; // bit-wise copy MdcSeg::setParam(&segParam); zeroSeed(); segList = new GmsList[nSlayer]; _nsupers = nSlayer; }

MdcSegList::~MdcSegList (   )

{ /**************************************************************************/ delete [] segList; }

MdcSegList::MdcSegList (  int  nSupers, const MdcSegParams  segParms )

MdcSegList::~MdcSegList (   )

---

Member Function Documentation

void MdcSegList::append (  MdcSeg *  aSeg  )

void MdcSegList::append (  MdcSeg *  aSeg  )

{ /****************************************************************************/ segList[aSeg->superlayer()->index()].append(aSeg); }

int MdcSegList::count (   )  const

int MdcSegList::count (   )  const

{ //------------------------------------------------------------------------- int cnt = 0; for (int i = 0; i < _nsupers; i++) cnt += segList[i].count(); return cnt; }

void MdcSegList::deleteDups (  bool  drop  )  [private]

void MdcSegList::deleteDups (  bool  drop  )  [private]

{ /****************************************************************************/ // Removes segments that have almost identical parameters. A bit risky, // perhaps, but what kind of life would you have if you never took // any risks? // On second thought, offer the option of just marking them as used. // Takes pairs of segments, and if they have the same slope and phi // (within cuts), selects better, using nHit and chisq. Note that 2 // identical segs may be separated in list by non-identical for (int isuper = 0; isuper < _nsupers; isuper++) { GmsList *thisSegList = &segList[isuper]; if (thisSegList->count() < 2) continue; double thisphi, nextphi; double slopediff = segPar()->slopeDiffDrop; //FIXME // Calculate road width for this slayer. const MdcLayer *aLayer = ((MdcSeg *)thisSegList->first())->superlayer()->firstLayer(); double width = _twopi / aLayer->nWires(); double phidiff = segPar()->phiDiffDropMult * width; //FIXME int lWrapped = 0; MdcSeg *startSeg = (MdcSeg *) thisSegList->first(); while ( startSeg != 0 ) { if (thisSegList->count() < 2) break; if (lWrapped) break; thisphi = startSeg->phi(); MdcSeg *nextSeg = startSeg; while (1) { // loop over nextSeg nextSeg = (MdcSeg *) nextSeg->next(); if (nextSeg == 0) { nextSeg = (MdcSeg *) thisSegList->first(); if (lWrapped == 1) break; // cluster covers 2pi; run, screaming lWrapped = 1; } nextphi = nextSeg->phi(); if (nextphi < thisphi) nextphi += _twopi; if(5 == segPar()->lPrint){ std::cout<<__FILE__<<" "<<__LINE__<<" start "<< std::endl; startSeg->plotSeg(); std::cout<<__FILE__<<" "<<__LINE__<<" next "<< std::endl; nextSeg->plotSeg(); std::cout<<__FILE__<<" phi diff "<< nextphi -thisphi << " phidiff "<<phidiff<< std::endl; std::cout<<__FILE__<<" slope diff "<< nextSeg->slope() - startSeg->slope() << " slopdiff "<<slopediff<< std::endl; } if (g_phiDiff) {g_phiDiff->fill((nextphi - thisphi)/width);}//yzhang hist cut if (g_slopeDiff) {g_slopeDiff->fill(nextSeg->slope() - startSeg->slope());}//yzhang hist cut if (nextphi - thisphi > phidiff) { // Done with this segment (aSeg) startSeg = (MdcSeg *) startSeg->next(); break; } else if (fabs( nextSeg->slope() - startSeg->slope() ) > slopediff) { // attached, but not identical -- move on to next nextSeg continue; } else { // identical; choose better int firstBetter = 0; assert (startSeg->nHit() > 2); double chiFirst = startSeg->chisq() / (startSeg->nHit() - 2); assert (nextSeg->nHit() > 2); double chiNext = nextSeg->chisq() / (nextSeg->nHit() - 2); double theDiff; int cdiff = (int) nextSeg->nHit() - (int) startSeg->nHit(); theDiff = (chiFirst - chiNext) + 2. * (cdiff); if (theDiff < 0.) firstBetter = 1; if (firstBetter) { MdcSeg *tempSeg = nextSeg; nextSeg = (MdcSeg *) nextSeg->next(); if (ldrop) { thisSegList->remove(tempSeg); delete tempSeg; } else { tempSeg->setUsed(); } if (nextSeg == 0) { nextSeg = (MdcSeg *) thisSegList->first(); if (lWrapped == 1) break; // cluster covers 2pi; run, screaming lWrapped = 1; } } else { MdcSeg *tempSeg = startSeg; startSeg = (MdcSeg *) startSeg->next(); if (ldrop) { thisSegList->remove(tempSeg); delete tempSeg; } else { tempSeg->setUsed(); } break; } } // end if identical } // end loop over nextSeg } // end primary loop over segments } // end loop over superlayers }

void MdcSegList::destroySegs (   )

void MdcSegList::destroySegs (   )

{ /****************************************************************************/ zeroSeed(); MdcSeg *aSeg, *bSeg; for (int i = 0; i < _nsupers; i++) { aSeg = (MdcSeg *) segList[i].first(); while (aSeg != 0) { bSeg = (MdcSeg *) aSeg->next(); segList[i].remove( aSeg ); delete aSeg ; aSeg = bSeg; } } return; }

MdcSeg* MdcSegList::getSeed (  int  iview, int  goodOnly )

MdcSeg * MdcSegList::getSeed (  int  iview, int  goodOnly )

{ //*************************************************************************** // Find a suitable segment for starting a track. If goodOnly=1, look for // isolated, unambiguous segments; unambiguous is // defined as being the only segment within a band in phiseg (typically // 2 cell widths wide), or as differing only slightly from nearby // segments in phi and slope. When these have been exhausted, take any // unused segment. Return pointer to seed seg, or 0 if none found. int viewIndex = iview + 1; if (seedSlay[viewIndex] == 0) return 0; while (1) { //if(seedSeg[viewIndex] != 0){ //seedSeg[viewIndex]->plotSeg(0,0);//yzhang debug //std::cout<<__FILE__<<" "<<__LINE__<<" goodOnly "<<goodOnly<< std::endl; //} if (seedSeg[viewIndex] == 0) { //seedSlay[viewIndex] = seedSlay[viewIndex]->nextInView();//yzhang temp seedSlay[viewIndex] = seedSlay[viewIndex]->prevInView(); //yzhang del if (seedSlay[viewIndex] == 0) return 0; seedSeg[viewIndex] = (MdcSeg *) oneList(seedSlay[viewIndex]->index())->first(); } // We have a segment; is it a viable seed? else if (seedSeg[viewIndex]->segUsed()) { //std::cout<<__FILE__<<" segUsed " << std::endl; seedSeg[viewIndex] = (MdcSeg *) seedSeg[viewIndex]->next(); } else if (seedSeg[viewIndex]->segAmbig() && goodOnly) { //std::cout<<__FILE__<<" segAmbig && goodOnly" << std::endl; seedSeg[viewIndex] = (MdcSeg *) seedSeg[viewIndex]->next(); //yzhang delete 09-10-10 //delete (!seedSeg[viewIndex]->segAmbig() && !goodOnly) } //yzhang add 09-09-28 else if ( !seedSeg[viewIndex]->segFull() && goodOnly) { //std::cout<<__FILE__<<" segFull && goodOnly" << std::endl; seedSeg[viewIndex] = (MdcSeg *) seedSeg[viewIndex]->next(); //zhangy add } else { // Reject segments with a lot of used hits int nused = 0; int navail = seedSeg[viewIndex]->nHit(); for (int ihit = 0; ihit < seedSeg[viewIndex]->nHit(); ihit++) { MdcHitUse *ahit = seedSeg[viewIndex]->hit(ihit); if ( ahit->mdcHit()->usedHit() ) nused++; } // Minimum 2 unused hits (but allow special-purpose segs w/ 0 hits) if (navail - nused < 2 && navail > 0) { seedSeg[viewIndex] = (MdcSeg *) seedSeg[viewIndex]->next(); } else { //std::cout<<__FILE__<<" Reject segments with a lot of used hits" << std::endl; break; } } } // We have a seed MdcSeg *theSeed = seedSeg[viewIndex]; seedSeg[viewIndex] = (MdcSeg *) seedSeg[viewIndex]->next(); return theSeed; }

void MdcSegList::massageSegs (   )  [private]

void MdcSegList::massageSegs (   )  [private]

{ /****************************************************************************/ sortByPhi(); // Delete duplicates only if there are too many segments bool drop = (segPar()->dropDups && count() > 200);//yzhang FIXME deleteDups(drop); tagAmbig(); }

const GmsList* MdcSegList::oneList (  int  slayIndex  )  const

const GmsList * MdcSegList::oneList (  int  slayIndex  )  const

{ //------------------------------------------------------------------------- return &segList[slayIndex]; }

void MdcSegList::plot (   )  const

void MdcSegList::plot (   )  const

{ /**************************************************************************/ MdcSeg *aSeg; for (int i = 0; i < _nsupers; i++) { std::cout << " ---------------MdcSeg of Slayer "<<i<<"-------------" << std::endl; aSeg = (MdcSeg *) segList[i].first(); while (aSeg != 0) { aSeg->plotSegAll(); std::cout << endl; aSeg = (MdcSeg *) aSeg->next(); } } }

void MdcSegList::resetSeed (  const MdcDetector *  gm  )

void MdcSegList::resetSeed (  const MdcDetector *  gm  )

{ /**************************************************************************/ for (int iview = -1; iview <= 1; iview++) { int viewIndex = iview + 1; /* if(0 == iview){ seedSlay[viewIndex] = gm->firstSlayInView(iview); }else{ seedSlay[viewIndex] = gm->lastSlayInView(iview); } */ seedSlay[viewIndex] = gm->lastSlayInView(iview); if (seedSlay[viewIndex] != 0) seedSeg[viewIndex] = (MdcSeg *) oneList(seedSlay[viewIndex]->index())->first(); } }

MdcSegParams* MdcSegList::segPar (   )  [inline]

{return &segParam;}

MdcSegParams* MdcSegList::segPar (   )  [inline]

{return &segParam;}

void MdcSegList::setPlot (  int  lPlt  )

void MdcSegList::setPlot (  int  lPlt  )

{ MdcSeg::segPar()->lPlot = lPlt; }

void MdcSegList::sortByPhi (   )  [private]

void MdcSegList::sortByPhi (   )  [private]

{ //**************************************************************************** // Sort the list of segments by phi. Insertion sort, good only for small n for (int isuper = 0; isuper < _nsupers; isuper++) { if (segList[isuper].first() == 0) continue; MdcSeg *aseg = (MdcSeg *) segList[isuper].first()->next(); for (int j = 1; j < (int) segList[isuper].count(); j++) { double phiSeg = aseg->phi(); MdcSeg *nextseg = (MdcSeg *) aseg->next(); MdcSeg *bseg = (MdcSeg *) aseg->prev(); if (phiSeg < bseg->phi() ) { while (bseg != 0 && phiSeg < bseg->phi()) { bseg = (MdcSeg *) bseg->prev(); } segList[isuper].moveAfter(aseg, bseg); // insert aseg after bseg } aseg = nextseg; } } return; }

void MdcSegList::tagAmbig (   )  [private]

void MdcSegList::tagAmbig (   )  [private]

{ //*************************************************************************** // Go through the list of segments and tag ones that will not make good // seeds -- i.e. ones that overlap with each other for (int isuper = 0; isuper < _nsupers; isuper++) { const GmsList *thisSegList = &segList[isuper]; if (thisSegList->count() < 2) return; // Bunch some declarations: double width, diff; double thisphi, nextphi; double nisocell = 2; // width = cell width in phi for this superlayer // diff = width of band about the track = nisocell * width // Calculate road width for this slayer. const MdcLayer *aLayer = ((MdcSeg *)thisSegList->first())->superlayer()->firstLayer(); width = _twopi / aLayer->nWires(); diff = nisocell * width; for ( MdcSeg *startSeg = (MdcSeg *) thisSegList->first(); startSeg != 0; startSeg = (MdcSeg *) startSeg->next() ) { MdcSeg *nextSeg = (MdcSeg *) startSeg->next(); if (nextSeg == 0) nextSeg = (MdcSeg *) thisSegList->first(); thisphi = startSeg->phi(); nextphi = nextSeg->phi(); if (nextphi < thisphi) nextphi += _twopi; if (nextphi - thisphi < diff) { startSeg->setAmbig(); nextSeg->setAmbig(); } } // end loop over segments } // end loop over superlayers return; }

void MdcSegList::zeroSeed (   )  [private]

void MdcSegList::zeroSeed (   )  [private]

{ /**************************************************************************/ seedSeg[0] = seedSeg[1] = seedSeg[2] = 0; seedSlay[0] = seedSlay[1] = seedSlay[2] = 0; }

---

Friends And Related Function Documentation

MdcSegFinder [friend]

---

Member Data Documentation

int MdcSegList::_nsupers [private]

MdcSeg* MdcSegList::seedSeg[3] [private]

MdcSeg* MdcSegList::seedSeg[3] [private]

const MdcSuperLayer* MdcSegList::seedSlay[3] [private]

const MdcSuperLayer* MdcSegList::seedSlay[3] [private]

GmsList* MdcSegList::segList [private]

GmsList* MdcSegList::segList [private]

MdcSegParams MdcSegList::segParam [private]

---

The documentation for this class was generated from the following files:

• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/InstallArea/include/MdcTrkRecon/MdcTrkRecon/MdcSegList.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Reconstruction/MdcPatRec/MdcTrkRecon/MdcTrkRecon-00-03-31/MdcTrkRecon/MdcSegList.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Reconstruction/MdcPatRec/MdcTrkRecon/MdcTrkRecon-00-03-31/src/MdcSegList.cxx

---