MdcSegGrouperSt Class Reference

#include <MdcSegGrouperSt.h>

Inheritance diagram for MdcSegGrouperSt:

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 ()
void	fillWithSegs (const MdcSegList *inSegs, const MdcTrack *axialTrack)
void	fillWithSegs (const MdcSegList *inSegs, const MdcTrack *axialTrack)
virtual int	incompWithGroup (MdcSeg **segGroup, const MdcSeg *testSeg, int iply)
virtual int	incompWithGroup (MdcSeg **segGroup, const MdcSeg *testSeg, int iply)
virtual int	incompWithSeg (const MdcSeg *refSeg, const MdcSeg *testSeg)
virtual int	incompWithSeg (const MdcSeg *refSeg, const MdcSeg *testSeg)
	MdcSegGrouperSt (const MdcDetector *gm, int debug)
	MdcSegGrouperSt (const MdcDetector *gm, int debug)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nPly () const
int	nPly () const
void	plotStereo () const
void	plotStereo () const
void	resetComb (const MdcSeg *seed=0)
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)
virtual MdcTrack *	storePar (MdcTrack *trk, double parms[2], double chisq, TrkContext &, double trackT0)
void	transferHits (MdcTrack *track, int nSegs, MdcSeg **segGroup)
void	transferHits (MdcTrack *track, int nSegs, MdcSeg **segGroup)
int	updateGap ()
int	updateGap ()
	~MdcSegGrouperSt ()
	~MdcSegGrouperSt ()
Protected Member Functions
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
MdcSegGrouperSt &	operator= (const MdcSegGrouperSt &)
MdcSegGrouperSt &	operator= (const MdcSegGrouperSt &)
void	resetList ()
void	resetList ()

---

Constructor & Destructor Documentation

MdcSegGrouperSt::MdcSegGrouperSt (  const MdcDetector *  gm, int  debug )

: MdcSegGrouper(gm, gm->nStereoSuper(-1) + gm->nStereoSuper(1), debug) { //------------------------------------------------------------------------ lTestGroup = true; lTestSingle = false; isValid = new bool * [nPly()]; for (int j = 0; j < nPly(); j++) { isValid[j] = 0; } }

MdcSegGrouperSt::~MdcSegGrouperSt (   )  [inline]

{ };

MdcSegGrouperSt::MdcSegGrouperSt (  const MdcDetector *  gm, int  debug )

MdcSegGrouperSt::~MdcSegGrouperSt (   )  [inline]

{ };

---

Member Function Documentation

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

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

{ //************************************************************************/ // 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 (   )  [inherited]

void MdcSegGrouper::dumpSegList (   )  [inherited]

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

void MdcSegGrouperSt::fillWithSegs (  const MdcSegList *  inSegs, const MdcTrack *  axialTrack )

void MdcSegGrouperSt::fillWithSegs (  const MdcSegList *  inSegs, const MdcTrack *  axialTrack )

{ //------------------------------------------------------------------------ // Prepare for stereo finding // Load segments consistent with input track (already in phi order) // Assuming from origin int nsuper = _gm->nSuper(); resetList(); // Clear existing lists const TrkFit* tkFit = track->track().fitResult(); if (tkFit == 0) return; TrkExchangePar par = tkFit->helix(0.0); double kap = 0.5 * par.omega(); double phi0 = par.phi0(); double d0 = par.d0(); MdcSegWorks segStuff; // holds some calculated values to pass to segInfo bool lStraight = false; if (fabs(kap) < 1.e-9) { lStraight = true; } double rCurl = 99999999.; if (!lStraight) { rCurl = fabs(d0 + 1./kap); } // Create an info object to store the info (will be owned by seg) MdcSegInfoSterO *info = new MdcSegInfoSterO; // Loop over superlayers for (int isuper = 0; isuper < nsuper; isuper++) { const GmsList *inList = inSegs->oneList(isuper); if (inList->count() == 0) continue; MdcSeg *inSeg = (MdcSeg *) inList->first(); // Only load stereo segments if (inSeg->superlayer()->whichView() == 0) continue; // Calculate r & phi (approx) of axial track at slayer double radius = inSeg->superlayer()->rEnd(); if (radius >= rCurl) break; double phiArg = kap * radius; if (lStraight) phiArg = d0 / radius; if (phiArg < -1.0) phiArg = -1.0; else if (phiArg > 1.0) phiArg = 1.0; segStuff.phiArg = phiArg; segStuff.phiAx.setRad(phi0 + asin(phiArg)); // Approx??!!!! BesAngle delPhi( fabs(inSeg->superlayer()->delPhi()) ); BesAngle maxPhiA = segStuff.phiAx + delPhi + 0.05; // allow a little slop BesAngle minPhiA = segStuff.phiAx - delPhi - 0.05; double maxPhi = maxPhiA; double minPhi = minPhiA; bool phitest = (maxPhi > minPhi); //phitest = false => the valid range straddles phi = 0, so skip //checking against phimin and phimax //Calc some things needed in segInfo::calcStereo segStuff.wirLen2inv = 1./ (inSeg->superlayer()->zEnd() * inSeg->superlayer()->zEnd() ); // Loop over segs in superlayer for ( ; inSeg != 0; inSeg = (MdcSeg *) inSeg->next()) { // Test if within allowed phi range BesAngle phiSeg(inSeg->phi()); if(_debug==3)inSeg->plotSeg(); if (phitest) { if (phiSeg < minPhi){ if (_debug ==3){std::cout << "St combine CUT! phi "<<setw(10)<<phiSeg << " < min "<<setw(10)<<minPhi << std::endl;}//yzhang debug continue; // not up to candidates } else if(phiSeg > maxPhi) { if (_debug ==3){std::cout << "St combine CUT! phi "<<setw(10)<<phiSeg <<" >max "<<setw(10)<<maxPhi<< std::endl;}//yzhang debug break; // past candidates } } else { // !phitest if (phiSeg > maxPhi && phiSeg < minPhi) { if (_debug ==3){std::cout << "!phitest "<<phiSeg <<" max "<<maxPhi<< " min "<<minPhi << std::endl;}//yzhang debug continue; } } if(_debug == 3) std::cout<<" KEEP phi="<<phiSeg<< std::endl; int isBad = info->calcStereo(inSeg, track->track(), segStuff); if (isBad) { if (_debug ==3){std::cout << "St combine calcStereo isBad CUT!"<<std::endl;} continue; } if(_debug==3)inSeg->plotSeg(); // Test for sensible values of ct and z0 if (g_z0Cut) {g_z0Cut->fill(info->z0());} if (g_ctCut) {g_ctCut->fill(info->ct());} if (fabs(info->ct()) > inSeg->segPar()->ctcut) { if (_debug ==3){std::cout << "St combine ctCut! CUT:" <<fabs(info->ct())<<" >cut "<< inSeg->segPar()->ctcut<<" "<<phiSeg<<std::endl; } continue; } if (fabs(info->z0()) > inSeg->segPar()->z0cut){ if (_debug ==3){std::cout << "St combine z0Cut! CUT:" <<fabs(info->z0())<<" >cut "<< inSeg->segPar()->z0cut<<" "<<phiSeg<<std::endl; } continue; } inSeg->setInfo(info); info = new MdcSegInfoSterO; segList[isuper].append(inSeg); if(_debug==3)std::cout<<__FILE__<<" APPEND"<< std::endl; } // end loop over new segs } // end loop over superlayers delete info; }

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

Implements MdcSegGrouper.

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

Implements MdcSegGrouper. { //------------------------------------------------------------------------- // Test that the latest seg lies more or less in a line with the others // Currently requiring line to point to IP; also require rough // agreement in ct. // iply = depth index of current seg (not yet in group) int i; // Find first segment already in group for (i = iply - 1; i > 0; i--) { if (!leaveGap[i]) break; } const MdcSeg *first = (*combList[i])[currentSeg[i]]; // Test ct MdcSegInfoSterO* firstInfo = (MdcSegInfoSterO *) first->info(); MdcSegInfoSterO* newInfo = (MdcSegInfoSterO *) testSeg->info(); if (g_delCt) {g_delCt->fill( firstInfo->ct() - newInfo->ct());}//yzhang hist cut if (fabs( firstInfo->ct() - newInfo->ct() ) > testSeg->segPar()->delCtCut) { if(_debug==3){ cout << "---MdcSegGrouperSt Ct CUT!" << endl;//yzhang debug testSeg->plotSeg(); std::cout << "segInGroup.ct "<< firstInfo->ct() <<"new "<<newInfo->ct() << "delta ct "<<firstInfo->ct() - newInfo->ct() <<"Cut "<<testSeg->segPar()->delCtCut << std::endl;//yzhang debug std::cout<<"--- "<< std::endl; } return -1; } double arcFirst = firstInfo->arc(); double arcNew = newInfo->arc(); double zFirst = firstInfo->z0() + firstInfo->ct() * arcFirst; double zNew = newInfo->z0() + newInfo->ct() * arcNew; // project line from IP through 1st seg to new seg double zProj = zFirst / arcFirst * arcNew; if (g_delZ0) {g_delZ0->fill( zProj - zNew);}//yzhang hist cut if (fabs(zProj - zNew) > testSeg->segPar()->delZ0Cut) { if(3==_debug){ cout << "MdcSegGrouperSt delZ0Cut not incompWithGroup CUT!" << endl;//yzhang debug testSeg->plotSeg(); std::cout<<" zProj "<< zProj << " zNew "<< zNew<< " CUT! " << testSeg->segPar()->delZ0Cut << std::endl; } return -1; } /* double delZ = newInfo->z0() + newInfo->ct() * arcNew - zFirst; double z0 = zFirst - arcFirst * delZ / (arcNew - arcFirst); if (fabs(z0) > testSeg->segPar()->delZ0Cut)return -1; for (i = iply - 1; i > 0; i--) { if (segGroup[i] != 0) break; } const MdcSeg *last = segGroup[i]; MdcSegInfoSterO* lastInfo = (MdcSegInfoSterO *) last->info(); // Test that slope from last segment to new one is roughly = slope from // first seg to last double arcLast = lastInfo->arc(); double arcFirst = firstInfo->arc(); double arcNew = newInfo->arc(); double delZold = lastInfo->z0() - firstInfo->z0() + lastInfo->ct() * arcLast - firstInfo->ct() * arcFirst; double delArcold = arcLast - arcFirst; double delZnew = newInfo->z0() - lastInfo->z0() + newInfo->ct() * arcNew - lastInfo->ct() * arcLast; double delArcnew = arcNew - arcLast; double p1 = delZold * delArcnew; double p2 = delZnew * delArcold; cout << " test: " << p1 << " " << p2 << endl; if (fabs(p2 - p1) > 0.02) return -1; */ return 0; }

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

Implements MdcSegGrouper.

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

Implements MdcSegGrouper. { //------------------------------------------------------------------------- return 0; }

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

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

{ //------------------------------------------------------------------------ // 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, inherited]

{return nDeep;}

int MdcSegGrouper::nPly (   )  const [inline, inherited]

{return nDeep;}

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

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

void MdcSegGrouperSt::plotStereo (   )  const

void MdcSegGrouperSt::plotStereo (   )  const

{ //------------------------------------------------------------------------- int nsuper = _gm->nSuper(); int isuper; /* for (isuper = 0; isuper < nsuper; isuper++) { if (segList[isuper].length() == 0) continue; MdcSeg *inSeg = (MdcSeg *) segList[isuper].first(); // Only draw stereo segments if (inSeg->superlayer()->whichView() == 0) continue; for (int j = 0 ; j < (int) segList[isuper].length(); j++) { segList[isuper][j]->plotSeg(0,orange); } } */ for (isuper = 0; isuper < nsuper; isuper++) { if (segList[isuper].length() == 0) continue; MdcSeg *inSeg = (MdcSeg *) segList[isuper].first(); // Only draw stereo segments //if (inSeg->superlayer()->whichView() == 0) continue; for (int j = 0 ; j < (int) segList[isuper].length(); j++) { segList[isuper][j]->plotSeg(); } } }

void MdcSegGrouperSt::resetComb (  const MdcSeg *  seed = 0  )  [virtual]

Implements MdcSegGrouper.

void MdcSegGrouperSt::resetComb (  const MdcSeg *  seed = 0  )  [virtual]

Implements MdcSegGrouper. { //************************************************************************** // Delete existing list of valid/invalid segs if (isValid != 0) { int i; for (i = 0; i < nDeep; i++) { delete [] isValid[i]; isValid[i] = 0; } } //Grab the seglist for each slayer int islay = 0; int iply = 0; nPlyFilled = 0; nNull = 0; // Set up all sorts of stuff for fast grouping of segs in nextGroup() for (const MdcSuperLayer *thisSlay = _gm->firstSlay(); thisSlay != 0; thisSlay = thisSlay->next()) { //bool noGoodYet = true; islay++; if (thisSlay->whichView() == 0) continue; firstGood[iply] = 0; firstBad[iply] = segList[islay-1].length(); if (firstGood[iply] > firstBad[iply]) firstGood[iply] = firstBad[iply]; if (firstGood[iply] == firstBad[iply]) { // If there are no valid segs for this ply, skip it continue; } // Associate correct seglist with this ply combList[iply] = &segList[islay-1]; leaveGap[iply] = false; iply++; } nPlyFilled = iply; resetSegCounters(); maxNull = nPlyFilled - 2; }

void MdcSegGrouper::resetGap (  int  nGap  )  [inherited]

void MdcSegGrouper::resetGap (  int  nGap  )  [inherited]

{ //************************************************************************** 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 MdcSegGrouperSt::resetList (   )  [private]

void MdcSegGrouperSt::resetList (   )  [private]

{ //------------------------------------------------------------------------ // Clear existing lists for stereo finding int nsuper = _gm->nSuper(); for (int i = 0; i < nsuper; i++) { segList[i].removeAll(); } }

void MdcSegGrouper::resetSegCounters (   )  [protected, inherited]

void MdcSegGrouper::resetSegCounters (   )  [protected, inherited]

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

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

Implements MdcSegGrouper.

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

Implements MdcSegGrouper. { //--------------------------------------------------------------------- assert (trk != 0); TrkHelixMaker maker; maker.addZValues(trk->track(), parms[0], parms[1], chisq); return trk; }

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

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

{ //************************************************************************/ //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 (   )  [inherited]

int MdcSegGrouper::updateGap (   )  [inherited]

{ //************************************************************************** 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, inherited]

const MdcDetector* MdcSegGrouper::_gm [protected, inherited]

const MdcDetector* MdcSegGrouper::_gm [protected, inherited]

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

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

int* MdcSegGrouper::currentSeg [protected, inherited]

int* MdcSegGrouper::currentSeg [protected, inherited]

int* MdcSegGrouper::firstBad [protected, inherited]

int* MdcSegGrouper::firstBad [protected, inherited]

int* MdcSegGrouper::firstGood [protected, inherited]

int* MdcSegGrouper::firstGood [protected, inherited]

int* MdcSegGrouper::gapCounter [protected, inherited]

int* MdcSegGrouper::gapCounter [protected, inherited]

bool** MdcSegGrouper::isValid [protected, inherited]

bool** MdcSegGrouper::isValid [protected, inherited]

bool* MdcSegGrouper::leaveGap [protected, inherited]

bool* MdcSegGrouper::leaveGap [protected, inherited]

bool MdcSegGrouper::lTestGroup [protected, inherited]

bool MdcSegGrouper::lTestSingle [protected, inherited]

int MdcSegGrouper::maxNull [protected, inherited]

int MdcSegGrouper::nDeep [protected, inherited]

int MdcSegGrouper::nNull [protected, inherited]

int MdcSegGrouper::nPlyFilled [protected, inherited]

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

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

---

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

---