MdcSegGrouper Class Reference

#include <MdcSegGrouper.h>

Inheritance diagram for MdcSegGrouper:

List of all members.

Public Member Functions
int	combineSegs (MdcTrack *&, MdcSeg *seed, TrkContext &, double trackT0, double maxSegChisqO)
int	combineSegs (MdcTrack *&, MdcSeg *seed, TrkContext &, double trackT0, double maxSegChisqO)
void	dumpSegList ()
void	dumpSegList ()
virtual int	incompWithGroup (MdcSeg **segGroup, const MdcSeg *testSeg, int iply)=0
virtual int	incompWithGroup (MdcSeg **segGroup, const MdcSeg *testSeg, int iply)=0
virtual int	incompWithSeg (const MdcSeg *refSeg, const MdcSeg *testSeg)=0
virtual int	incompWithSeg (const MdcSeg *refSeg, const MdcSeg *testSeg)=0
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nPly () const
int	nPly () const
virtual void	resetComb (const MdcSeg *seed)=0
virtual void	resetComb (const MdcSeg *seed)=0
void	resetGap (int nGap)
void	resetGap (int nGap)
virtual MdcTrack *	storePar (MdcTrack *trk, double parms[2], double chisq, TrkContext &, double trackT0)=0
virtual MdcTrack *	storePar (MdcTrack *trk, double parms[2], double chisq, TrkContext &, double trackT0)=0
void	transferHits (MdcTrack *track, int nSegs, MdcSeg **segGroup)
void	transferHits (MdcTrack *track, int nSegs, MdcSeg **segGroup)
int	updateGap ()
int	updateGap ()
virtual	~MdcSegGrouper ()
virtual	~MdcSegGrouper ()
Protected Member Functions
	MdcSegGrouper (const MdcDetector *gm, int nDeep, int debug)
	MdcSegGrouper (const MdcDetector *gm, int nDeep, int debug)
void	resetSegCounters ()
void	resetSegCounters ()
Protected Attributes
int	_debug
const MdcDetector *	_gm
const MdcDetector *	_gm
HepAList< MdcSeg > **	combList
HepAList< MdcSeg > **	combList
int *	currentSeg
int *	currentSeg
int *	firstBad
int *	firstBad
int *	firstGood
int *	firstGood
int *	gapCounter
int *	gapCounter
bool **	isValid
bool **	isValid
bool *	leaveGap
bool *	leaveGap
bool	lTestGroup
bool	lTestSingle
int	maxNull
int	nDeep
int	nNull
int	nPlyFilled
HepAList< MdcSeg > *	segList
HepAList< MdcSeg > *	segList
Private Member Functions
	MdcSegGrouper (const MdcSegGrouper &)
	MdcSegGrouper (const MdcSegGrouper &)
MdcSegGrouper &	operator= (const MdcSegGrouper &)
MdcSegGrouper &	operator= (const MdcSegGrouper &)

---

Constructor & Destructor Documentation

MdcSegGrouper::~MdcSegGrouper (   )  [virtual]

{ //------------------------------------------------------------------------ delete [] segList; delete [] combList; delete [] currentSeg; delete [] leaveGap; delete [] gapCounter; delete [] firstGood; delete [] firstBad; if (isValid != 0) { for (int i = 0; i < nDeep; i++) { delete [] isValid[i]; } delete [] isValid; } }

MdcSegGrouper::MdcSegGrouper (  const MdcDetector *  gm, int  nDeep, int  debug )  [protected]

{ //------------------------------------------------------------------------ nDeep = nd; int nsuper = gm->nSuper(); segList = new HepAList<MdcSeg>[nsuper]; currentSeg = new int[nDeep]; leaveGap = new bool[nDeep]; gapCounter = new int[nDeep]; combList = new HepAList<MdcSeg> * [nDeep]; _gm = gm; firstGood = new int[nDeep]; firstBad = new int[nDeep]; lTestGroup = false; lTestSingle = false; _debug = debug; }

MdcSegGrouper::MdcSegGrouper (  const MdcSegGrouper &   )  [private]

virtual MdcSegGrouper::~MdcSegGrouper (   )  [virtual]

MdcSegGrouper::MdcSegGrouper (  const MdcDetector *  gm, int  nDeep, int  debug )  [protected]

MdcSegGrouper::MdcSegGrouper (  const MdcSegGrouper &   )  [private]

---

Member Function Documentation

int MdcSegGrouper::combineSegs (  MdcTrack *&  , MdcSeg *  seed, TrkContext &  , double  trackT0, double  maxSegChisqO )

int MdcSegGrouper::combineSegs (  MdcTrack *&  , MdcSeg *  seed, TrkContext &  , double  trackT0, double  maxSegChisqO )

{ //************************************************************************/ // forms track from list of segs; does 2-param fit (either r-phi from origin // or s-z) and picks best combination. bool lSeed = (seed != 0); double wgtmat[3], wgtinv[3]; double wgtpar[2]; double temvec[2], param[2], diff[2]; int success = 0; double qualBest = -1000.; int nSegBest = 0; int nHitBest = 0; double paramBest[2]; double chiBest = 9999.; int nToUse = nPly(); if (lSeed) nToUse++; // seed isn't included in the segs list MdcSeg **segGroup; MdcSeg **segGroupBest; segGroup = new MdcSeg * [nToUse]; segGroupBest = new MdcSeg * [nToUse]; // static int counter = 0; // counter++; // cout << counter << endl; // Loop over all combinations of segs consistent with seed (including gaps) if ((3 == _debug)&&lSeed) { std::cout<<"seed segment: "<< std::endl; seed->plotSeg(); } resetComb(seed); // Save seed params (if angles) for later use as reference angle in // mdcWrapAng (don't really have to test whether it's an angle, but I do) double seedAngle[2] = {0.,0.}; if (lSeed) { if (seed->info()->parIsAngle(0)) seedAngle[0] = seed->info()->par(0); if (seed->info()->parIsAngle(1)) seedAngle[1] = seed->info()->par(1); } int iprint = (3 == _debug); int nInGroup = 0; while ( (nInGroup = nextGroup(segGroup, iprint)) != 0) { if (lSeed) { segGroup[nToUse-1] = seed; nInGroup++; } if (nInGroup < 0) continue; if (nInGroup < 2) break; if (nInGroup < nSegBest) break; // Calculate track & chisq for this group int nSegFit = 0; int nhit = 0; wgtmat[0] = wgtmat[1] = wgtmat[2] = wgtpar[0] = wgtpar[1] = 0.0; if (3 == _debug) { cout << endl <<"--parameters of "<<nInGroup<<" segment in this group"<<endl; } int iPly; for (iPly = 0; iPly < nToUse; iPly++) { if (3 == _debug) { //if (!lSeed) //if (segGroup[iPly] == 0) cout << "ply empty: " << iPly << "\n"; } if (segGroup[iPly] == 0) continue; // skipping this slayer nSegFit++; MdcSegInfo *segInfo = segGroup[iPly]->info(); // Accumulate sums for (int i = 0; i < 3; i++) wgtmat[i] += (segInfo->inverr())[i]; for (int k = 0; k < 2; k++) { param[k] = segInfo->par(k); //zhangy add if (segInfo->parIsAngle(k)) { param[k] = mdcWrapAng(seedAngle[k], param[k]); } } // Multiply by weight matrix. mdcTwoVec( segInfo->inverr(), param, temvec ); wgtpar[0] += temvec[0]; wgtpar[1] += temvec[1]; if(3 == _debug) { std::cout<<" par * W "<<temvec[0]<<" "<<temvec[1]<< std::endl; } nhit += segGroup[iPly]->nHit(); } // And the fitted parameters are . . . int error = mdcTwoInv(wgtmat,wgtinv); if (error && (3 == _debug)) { cout << "ErrMsg(warning) " << "failed matrix inversion in MdcTrackList::combineSegs" << endl; continue; } mdcTwoVec( wgtinv, wgtpar, param ); if(_debug==3)cout<<endl<<"-- Calculate track & chisq for this group "<<endl; // Calc. chisq. = sum( (Vi - V0) * W * (Vi - V0) ) // W = weight, Vi = measurement, V0 = fitted param. double chisq = 0.0; for (iPly = 0; iPly < nToUse; iPly++) { if (segGroup[iPly] == 0) continue; // skipping this slayer MdcSegInfo *segInfo = segGroup[iPly]->info(); for (int j = 0; j < 2; j++) { double temPar; if (segInfo->parIsAngle(j)) { temPar = mdcWrapAng(seedAngle[j], segInfo->par(j)); } else { temPar = segInfo->par(j); } if(3 == _debug) { std::cout<<" segPar"<<j<<" "<<temPar<< std::endl; } diff[j] = temPar - param[j]; } if(3 == _debug) { std::cout<<"inverr " <<segInfo->inverr()[0]<<" " <<segInfo->inverr()[1] <<" "<<segInfo->inverr()[2] << std::endl; std::cout<<"errmat " <<segInfo->errmat()[0]<< " " <<segInfo->errmat()[1] << " "<<segInfo->errmat()[2] << std::endl; std::cout<< std::endl; } mdcTwoVec( segInfo->inverr(), diff, temvec); chisq += diff[0] * temvec[0] + diff[1] * temvec[1]; if(3 == _debug){ std::cout<<iPly<<" chi2Add:"<<diff[0] * temvec[0] + diff[1] * temvec[1]<<" diff0 "<<setw(10) << diff[0]<< " vec0 "<<setw(10)<<temvec[0]<<" diff1 "<<setw(10) << diff[1]<< " vec1 "<<setw(10)<<temvec[1] << std::endl; } } if (3 == _debug) { cout << "Candidate track:"<<endl<<" chisq: " << chisq << " nhit: " << nhit << " cpa/cot: " << param[0] << " phi0/z0: " << param[1] << endl; std::cout<< "chiDof="<<chisq/(2*nSegFit - 2) <<" maxSegChisqO="<<maxSegChisqO << std::endl;//yzhang debug if((chisq/(2*nSegFit - 2))<maxSegChisqO) cout << "---KEEP!---"<<endl; else cout << "---DROP!---"<<endl; } if (chisq < 0.) continue;//yzhang add // Chisq test double chiDof = chisq/(2.*nSegFit - 2.); if (g_maxSegChisqO ) { g_maxSegChisqO->fill(chiDof); } //yzhang hist cut if (chiDof > maxSegChisqO) continue; success = 1; double qual = 2. * nhit - chiDof; if (qual > qualBest) { qualBest = qual; nSegBest = nSegFit; nHitBest = nhit; paramBest[0] = param[0]; paramBest[1] = param[1]; chiBest = chisq; for (int i = 0; i < nToUse; i++) { segGroupBest[i] = segGroup[i]; //std::cout<<__FILE__<<" "<<__LINE__<<" Keep BEST"<< std::endl; } }// end test on qual } if (success == 1) { // Store the results in a track, possibly creating it in the process trk = storePar(trk, paramBest, chiBest, context, t0); transferHits(trk, nToUse, segGroupBest); // Store hits with track } delete [] segGroupBest; delete [] segGroup; return success; }

void MdcSegGrouper::dumpSegList (   )

void MdcSegGrouper::dumpSegList (   )

{ //************************************************************************ for(int islayer=0; islayer<11; islayer++){ for(int i=0; i<segList[islayer].length(); i++){ segList[islayer][i]->plotSeg(); } } }

virtual int MdcSegGrouper::incompWithGroup (  MdcSeg **  segGroup, const MdcSeg *  testSeg, int  iply )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

virtual int MdcSegGrouper::incompWithGroup (  MdcSeg **  segGroup, const MdcSeg *  testSeg, int  iply )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

virtual int MdcSegGrouper::incompWithSeg (  const MdcSeg *  refSeg, const MdcSeg *  testSeg )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

virtual int MdcSegGrouper::incompWithSeg (  const MdcSeg *  refSeg, const MdcSeg *  testSeg )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

int MdcSegGrouper::nextGroup (  MdcSeg **  segGroup, bool  printit )

int MdcSegGrouper::nextGroup (  MdcSeg **  segGroup, bool  printit )

{ //------------------------------------------------------------------------ // Loop over the superlayers, moving to next valid seg for each if necessary // First, loop over the slayers w/o good segs, filling segGroup w/ 0 int iply; for (iply = nPlyFilled; iply < nDeep; iply++) { segGroup[iply] = 0; } restart: if (printit) cout <<endl<< "MdcSegGrouper::nextGroup starting group finder, nply = " << nPlyFilled << endl; int nFound = 0; bool incrementNext = true; //int nSegUsed;//yzhang 2010-05-21 for (iply = 0; iply < nPlyFilled; iply++) { segGroup[iply] = 0; if (!incrementNext && currentSeg[iply] >= firstGood[iply]) break; //if (nSegUsed > segPar.nSegUsedNextGroup) break; if (leaveGap[iply]) { // This ply is currently a gap; move on. if (iply == nPlyFilled - 1 && incrementNext) { // we've exhausted this gap group; start another iply = -1; resetSegCounters(); int lDone = updateGap(); if (lDone) { // all gap groups for nNull exhausted; increment nNull nNull++; if (nNull > maxNull) return 0; // All done resetGap(nNull); updateGap(); } // end if lDone } //end if exhausted gap group continue; } incrementNext = false; // Loop through the segs in this ply until valid one found while (1) { currentSeg[iply]++; if (currentSeg[iply] == firstBad[iply]) { // reached end of segs incrementNext = true; currentSeg[iply] = firstGood[iply]; if (iply == nPlyFilled - 1) { // we've exhausted this gap group; start another iply = -1; resetSegCounters(); int lDone = updateGap(); if (lDone) { // all gap groups for nNull exhausted; increment nNull nNull++; if (nNull > maxNull) return 0; // All done resetGap(nNull); updateGap(); } // end if lDone } //end if exhausted gap group break; } // end reached end of segs if(3 == _debug) { if( (*combList[iply])[currentSeg[iply]]->segUsed()) { std::cout<< "segUsed! :"; (*combList[iply])[currentSeg[iply]]->plotSeg(); } } //yzhang 09-09-28 delete if( (*combList[iply])[currentSeg[iply]]->segUsed()) { continue; //yzhang 2010-05-21 add //nSegUsed++; } // Test this seg for validity if (lTestSingle) { assert(isValid != 0); assert(isValid[iply] != 0); int invalid = (isValid[iply][currentSeg[iply]] == false); if (invalid) continue; } // Whew. We successfully incremented. break; } // end seg loop } // end ply loop // Fill segGroup with appropriate segs for (iply = 0; iply < nPlyFilled; iply++) { if (leaveGap[iply]) { segGroup[iply] = 0; } else { segGroup[iply] = (*combList[iply])[currentSeg[iply]]; if (lTestGroup && nFound > 1) { int lBad = incompWithGroup(segGroup, segGroup[iply], iply); if(printit && lBad )std::cout<<" incompWithGroup Bad! restart" << std::endl; if (lBad) goto restart; } nFound++; } } if (printit) { cout << "-- end of nextGroup, nSeg="<<nFound <<endl; for (iply = 0; iply < nPlyFilled; iply++) { std::cout<<iply<<": "; if(0 != segGroup[iply]) segGroup[iply]->plotSeg(); } } return nFound; }

int MdcSegGrouper::nPly (   )  const [inline]

{return nDeep;}

int MdcSegGrouper::nPly (   )  const [inline]

{return nDeep;}

MdcSegGrouper& MdcSegGrouper::operator= (  const MdcSegGrouper &   )  [private]

MdcSegGrouper& MdcSegGrouper::operator= (  const MdcSegGrouper &   )  [private]

virtual void MdcSegGrouper::resetComb (  const MdcSeg *  seed  )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperSt, MdcSegGrouperAx, and MdcSegGrouperSt.

virtual void MdcSegGrouper::resetComb (  const MdcSeg *  seed  )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperSt, MdcSegGrouperAx, and MdcSegGrouperSt.

void MdcSegGrouper::resetGap (  int  nGap  )

void MdcSegGrouper::resetGap (  int  nGap  )

{ //************************************************************************** for (int i = 0; i < nPlyFilled; i++) { gapCounter[i] = nGap - 1 - i; } gapCounter[0]--; // so 1st increment will put 1st counter in right place return; }

void MdcSegGrouper::resetSegCounters (   )  [protected]

void MdcSegGrouper::resetSegCounters (   )  [protected]

{ //------------------------------------------------------------------------- for (int i = 0; i < nPlyFilled; i++) { currentSeg[i] = firstGood[i] - 1; } }

virtual MdcTrack* MdcSegGrouper::storePar (  MdcTrack *  trk, double  parms[2], double  chisq, TrkContext &  , double  trackT0 )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

virtual MdcTrack* MdcSegGrouper::storePar (  MdcTrack *  trk, double  parms[2], double  chisq, TrkContext &  , double  trackT0 )  [pure virtual]

Implemented in MdcSegGrouperAx, MdcSegGrouperCsmc, MdcSegGrouperSt, MdcSegGrouperAx, MdcSegGrouperCsmc, and MdcSegGrouperSt.

void MdcSegGrouper::transferHits (  MdcTrack *  track, int  nSegs, MdcSeg **  segGroup )

void MdcSegGrouper::transferHits (  MdcTrack *  track, int  nSegs, MdcSeg **  segGroup )

{ //************************************************************************/ //Move hits from segments to track hitlist // Also note first and last layers in list // Only handles Mdc segments double smallRad = 1000.; if (trk->firstLayer() != 0) smallRad = trk->firstLayer()->rMid(); double bigRad = 0.; if (trk->lastLayer() != 0) bigRad = trk->lastLayer()->rMid(); for (int i = 0; i < nSegs; i++) { if (segGroup[i] == 0) continue; // skipping this slayer if(3 == _debug) { cout << i << " " << segGroup[i] << endl; } segGroup[i]->setUsed(); // mark seg as used for (int ihit = 0; ihit < segGroup[i]->nHit(); ihit++) { MdcHitUse *aHit = segGroup[i]->hit(ihit); const MdcLayer *layer = aHit->mdcHit()->layer(); double radius = layer->rMid(); if (radius < smallRad) { smallRad = radius; trk->setFirstLayer(layer); } // Assume that segs aren't added to backside of curler if (radius > bigRad && !trk->hasCurled()) { bigRad = radius; trk->setLastLayer(layer); } // Provide very crude starting guess of flightlength double flt = radius; flt += 0.000001 * (aHit->mdcHit()->x() +aHit->mdcHit()->y()); aHit->setFltLen(flt); TrkHitList* theHits = trk->track().hits(); if (theHits == 0) return; theHits->appendHit(*aHit); //std::cout<<"in MdcSegGrouper append ok"<<std::endl;//yzhang debug } } // end loop over slayers }

int MdcSegGrouper::updateGap (   )

int MdcSegGrouper::updateGap (   )

{ //************************************************************************** if (nNull == 0) return 1; for (int i = 0; i < nPlyFilled; i++) { leaveGap[i] = false; } for (int igap = 0; igap < nNull; igap++) { gapCounter[igap]++; if (gapCounter[igap] == nPlyFilled - igap) { // End of loop for this counter; look at the other counters to // decide where this one should be reset to. int inext = igap + 1; while (1) { if (inext >= nNull) return 1; // done with all combos if (gapCounter[inext] + inext + 1 < nPlyFilled) { // This is the right spot to reset to gapCounter[igap] = gapCounter[inext] + inext + 1 - igap; break; } inext++; } } else { // We successfully incremented. Quit looping and return. break; } } // end loop over igap for (int j = 0; j < nNull; j++) { leaveGap[gapCounter[j]] = true; } return 0; }

---

Member Data Documentation

int MdcSegGrouper::_debug [protected]

const MdcDetector* MdcSegGrouper::_gm [protected]

const MdcDetector* MdcSegGrouper::_gm [protected]

HepAList<MdcSeg>** MdcSegGrouper::combList [protected]

HepAList<MdcSeg>** MdcSegGrouper::combList [protected]

int* MdcSegGrouper::currentSeg [protected]

int* MdcSegGrouper::currentSeg [protected]

int* MdcSegGrouper::firstBad [protected]

int* MdcSegGrouper::firstBad [protected]

int* MdcSegGrouper::firstGood [protected]

int* MdcSegGrouper::firstGood [protected]

int* MdcSegGrouper::gapCounter [protected]

int* MdcSegGrouper::gapCounter [protected]

bool** MdcSegGrouper::isValid [protected]

bool** MdcSegGrouper::isValid [protected]

bool* MdcSegGrouper::leaveGap [protected]

bool* MdcSegGrouper::leaveGap [protected]

bool MdcSegGrouper::lTestGroup [protected]

bool MdcSegGrouper::lTestSingle [protected]

int MdcSegGrouper::maxNull [protected]

int MdcSegGrouper::nDeep [protected]

int MdcSegGrouper::nNull [protected]

int MdcSegGrouper::nPlyFilled [protected]

HepAList<MdcSeg>* MdcSegGrouper::segList [protected]

HepAList<MdcSeg>* MdcSegGrouper::segList [protected]

---

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/MdcSegGrouper.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Reconstruction/MdcPatRec/MdcTrkRecon/MdcTrkRecon-00-03-31/MdcTrkRecon/MdcSegGrouper.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Reconstruction/MdcPatRec/MdcTrkRecon/MdcTrkRecon-00-03-31/src/MdcSegGrouper.cxx

---