MdcSegGrouperAx Class Reference

#include <MdcSegGrouperAx.h>

Inheritance diagram for MdcSegGrouperAx:

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)
void	fillWithSegs (const MdcSegList *inSegs)
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)
	MdcSegGrouperAx (const MdcDetector *gm, int debug)
	MdcSegGrouperAx (const MdcDetector *gm, int debug)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	nPly () const
int	nPly () const
void	resetComb (const MdcSeg *seed)
void	resetComb (const MdcSeg *seed)
void	resetGap (int nGap)
void	resetGap (int nGap)
virtual MdcTrack *	storePar (MdcTrack *, double parms[2], double chisq, TrkContext &, double trackT0)
virtual MdcTrack *	storePar (MdcTrack *, 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 ()
	~MdcSegGrouperAx ()
	~MdcSegGrouperAx ()
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
MdcSegGrouperAx &	operator= (const MdcSegGrouperAx &)
MdcSegGrouperAx &	operator= (const MdcSegGrouperAx &)
Private Attributes
const MdcSeg *	_seed
const MdcSeg *	_seed

---

Constructor & Destructor Documentation

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

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

MdcSegGrouperAx::~MdcSegGrouperAx (   )  [inline]

{ };

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

MdcSegGrouperAx::~MdcSegGrouperAx (   )  [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 MdcSegGrouperAx::fillWithSegs (  const MdcSegList *  inSegs  )

void MdcSegGrouperAx::fillWithSegs (  const MdcSegList *  inSegs  )

{ //------------------------------------------------------------------------ // Prepare for axial finding // Store the segments (pointers, actually), sorting by phi0 for (int isuper = 0; isuper < _gm->nSuper(); isuper++) { const GmsList *inList = inSegs->oneList(isuper); if (inList->count() == 0) continue; MdcSeg *inSeg = (MdcSeg *) inList->first(); // Only load axial segments if (inSeg->superlayer()->whichView() != 0) continue; while (inSeg != 0) { // Create an info object within the seg to store info MdcSegInfoAxialO *info = new MdcSegInfoAxialO; inSeg->setInfo(info); info->calcFromOrigin(inSeg); // calc. origin-dependent info // Loop over the segs already stored, looking for the right place // to stick the new one int isInserted = 0; for (int iseg = 0; iseg < (int) segList[isuper].length(); iseg++) { MdcSeg *aSeg = segList[isuper][iseg]; if ( ((MdcSegInfoAxialO *)aSeg->info())->phi0() < info->phi0()) { continue; } segList[isuper].insert(inSeg, iseg); isInserted = 1; break; } // end of loop over existing segs if (isInserted == 0) segList[isuper].append(inSeg); inSeg = (MdcSeg *) inSeg->next(); } // end loop over new segs // cout<<"segList["<<isuper<<"].length"<< segList[isuper].length()<<endl;//yzhang debug } // end loop over superlayers /* for(int isuper = 0; isuper < _gm->nSuper(); isuper++) { std::cout<<"-------super layer "<<isuper<<std::endl; for (int iseg = 0; iseg < (int) segList[isuper].length(); iseg++) { MdcSeg *aSeg = segList[isuper][iseg]; std::cout << " seg phi "<<iseg<< " "<<((MdcSegInfoAxialO*)aSeg->info())->phi0()<<std::endl; } // end of loop over existing segs } */ }

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

Implements MdcSegGrouper.

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

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

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

Implements MdcSegGrouper.

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

Implements MdcSegGrouper. { //------------------------------------------------------------------------- // Returns 0 if valid, -1 if invalid, +1 if invalid and no more valid // ones possible in this slayer (assumes they're ordered) if (testSeg == 0) return 0; if(3 == _debug) { std::cout<< "ref" << std::endl;//yzhang debug refSeg->plotSeg(); std::cout<< "testSeg " << std::endl;//yzhang debug testSeg->plotSeg(); } // Test phi0 match MdcSegInfoAxialO *refInfo = (MdcSegInfoAxialO *) refSeg->info(); MdcSegInfoAxialO *testInfo = (MdcSegInfoAxialO *) testSeg->info(); //double sigPhi0 = (refInfo->sigPhi0() > testInfo->sigPhi0() ? //refInfo->sigPhi0() : testInfo->sigPhi0()); double refPhi0 = refInfo->phi0(); double testPhi0 = testInfo->phi0(); double corrPhi0 = mdcWrapAng(refPhi0, testPhi0); //double sigCurv = (refInfo->sigCurv() > testInfo->sigCurv() ? //refInfo->sigCurv() : testInfo->sigCurv()); double refCurv = refInfo->curv(); double testCurv = testInfo->curv(); //double nSigmaPhi0 = MdcTrkReconCut_combAxPhi0;//4. for default //double nSigmaCurv = MdcTrkReconCut_combAxCurv;//4. for default double phi0Cut = MdcTrkReconCut_combAxPhi0Cut; double curvCut = MdcTrkReconCut_combAxCurvCut; //std::cout << "test phi0 "<<corrPhi0<<" ref "<<refPhi0<<" sig "<< nSigmaPhi0 * sigPhi0 << std::endl; //std::cout << "test Curv "<<testCurv<<" ref "<<refCurv<<" sig "<< nSigmaCurv * sigCurv << std::endl; /* if (g_tupleCombAx) { g_combAxdPhi0 = refPhi0 - corrPhi0; g_combAxdCurv = refCurv - testCurv; g_combAxSigPhi0 = sigPhi0; g_combAxSigCurv = sigCurv; g_combAxSlSeed = refSeg->superlayer()->slayNum();; g_combAxSlTest = testSeg->superlayer()->slayNum(); g_combAxQualitySeed = refSeg->quality(); g_combAxQualityTest = testSeg->quality(); //const MdcHit* h = refSeg->hit(0)->mdcHit(); //unsigned int l = h->layernumber(); //unsigned int w = h->wirenumber(); //g_combAxMcPt = mcPt[havedigi[l][w]]; //test if the combined segments in the same track // return -1:seed false // return value = n hits on the seed track/ n hits of test seg g_combAxMc = refSeg->testCombSeg(testSeg); //std::cout<< "mc seg "<< refSeg->testCombSeg(testSeg) << std::endl;//yzhang debug g_tupleCombAx->write(); } */ //yzhang add 2009-10-16 //if (refPhi0 - corrPhi0 > nSigmaPhi0 * sigPhi0) if(3 == _debug){ std::cout << " phi0 ref"<<refPhi0 <<" corr "<<corrPhi0 << " diff "<<fabs(corrPhi0-refPhi0) <<" >? "<<phi0Cut<<std::endl; std::cout << " curv ref"<<refCurv <<" test "<<testCurv<< " diff "<<refCurv-testCurv <<" >? "<<curvCut<< std::endl; } if (fabs(corrPhi0 - refPhi0) > phi0Cut) { if(3 == _debug) std::cout << " SKIP by phi0"<<std::endl; //yzhang delete //if (testPhi0 > refPhi0) return 1; //else return -1; // => testPhi0>2pi & refPhi0<2pi } // Test curvature match // use larger error of the two //if (fabs(refCurv - testCurv) > nSigmaCurv * sigCurv) if (fabs(refCurv - testCurv) > curvCut){ if(3 == _debug) std::cout << " SKIP by curv"<<std::endl; return -2; } if(3 == _debug) std::cout << " ADD "<<std::endl; //std::cout<< "ok! " << std::endl;//yzhang debug 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;}

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

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

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

Implements MdcSegGrouper.

void MdcSegGrouperAx::resetComb (  const MdcSeg *  seed  )  [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; } } _seed = seed; //Grab the seglist for each non-seed slayer int islay = 0; int iply = 0; nPlyFilled = 0; nNull = 0; const MdcSuperLayer *seedSlay = 0; if (seed != 0) seedSlay = seed->superlayer(); // 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 == seedSlay) continue; if (thisSlay->whichView() != 0) continue;//Axial slayer firstGood[iply] = 0; // Loop over the segs, marking start & end of valid region for this seed firstBad[iply] = 0; if (segList[islay-1].length() != 0) { isValid[iply] = new bool[segList[islay-1].length()]; } for (int i = 0; i < (int) segList[islay-1].length(); i++) { MdcSeg *aSeg = segList[islay-1][i]; int invalid = incompWithSeg(seed, aSeg); isValid[iply][i] = true; if (invalid < 0) { firstBad[iply] = i; isValid[iply][i] = false; if (noGoodYet) firstGood[iply] = i+1; } else if (invalid > 0) { // No more valid segs in this slayer firstBad[iply] = i; for (int j = i; j < (int) segList[islay-1].length(); j++) isValid[iply][j] = false; break; } else { firstBad[iply] = i+1; noGoodYet = false; } } if(3 == _debug) std::cout<<iply<<" islay "<<islay<<" firstGood "<<firstGood[iply]<<" "<<firstBad[iply]<< std::endl; if (firstGood[iply] > firstBad[iply]) firstGood[iply] = firstBad[iply]; if (firstGood[iply] == firstBad[iply]) { // If there are no valid segs for this ply, drop it delete [] isValid[iply]; isValid[iply] = 0; continue; } // Associate correct seglist with this ply combList[iply] = &segList[islay-1]; leaveGap[iply] = false; iply++; } nPlyFilled = iply; resetSegCounters(); maxNull = nPlyFilled - 2; maxNull++; }

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 MdcSegGrouper::resetSegCounters (   )  [protected, inherited]

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

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

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

Implements MdcSegGrouper.

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

Implements MdcSegGrouper. { //--------------------------------------------------------------------- // cout << "storePar in MdcSegGrouperAx" <<endl;//yzhang debug assert(trk == 0); BesAngle foundPhi0(parms[0]); // factor of two to convert to BaBar def of curvature (omega) TrkExchangePar par(0.0, foundPhi0.rad(), 2.*parms[1], 0.0, 0.0); return new MdcTrack(_gm->nSuper(), par, chisq, context, t0); }

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]

const MdcSeg* MdcSegGrouperAx::_seed [private]

const MdcSeg* MdcSegGrouperAx::_seed [private]

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

---