MdcSegGrouperSt Class Reference

#include <MdcSegGrouperSt.h>

Inheritance diagram for MdcSegGrouperSt:

List of all members.

Public Member Functions
	MdcSegGrouperSt (const MdcDetector *gm, int debug)
	~MdcSegGrouperSt ()
void	fillWithSegs (const MdcSegList *inSegs, const MdcTrack *axialTrack)
void	plotStereo () const
virtual int	incompWithSeg (const MdcSeg *refSeg, const MdcSeg *testSeg)
virtual int	incompWithGroup (MdcSeg **segGroup, const MdcSeg *testSeg, int iply)
void	resetComb (const MdcSeg *seed=0)
virtual MdcTrack *	storePar (MdcTrack *trk, double parms[2], double chisq, TrkContext &, double trackT0)
int	nextGroup (MdcSeg **segGroup, bool printit)
int	updateGap ()
void	resetGap (int nGap)
int	nPly () const
int	combineSegs (MdcTrack *&, MdcSeg *seed, TrkContext &, double trackT0, double maxSegChisqO, int combineByFitHits=0)
void	transferHits (MdcTrack *track, int nSegs, MdcSeg **segGroup)
void	dumpSegList ()
double	calcParBySegs (MdcSeg **segGroup, double seedAngle[2], int nToUse, double &qual, int &nSegFit, double param[2])
double	calcParByHits (MdcSeg **segGroup, int nToUse, const TrkExchangePar &par, double &qual, int &nSegFit, double param[2], double Bz)
Protected Member Functions
void	resetSegCounters ()
Protected Attributes
int	nDeep
int	nPlyFilled
int *	currentSeg
int *	firstGood
int *	firstBad
bool **	isValid
HepAList< MdcSeg > **	combList
const MdcDetector *	_gm
HepAList< MdcSeg > *	segList
bool *	leaveGap
int	nNull
int	maxNull
int *	gapCounter
bool	lTestGroup
bool	lTestSingle
int	_debug
Private Member Functions
void	resetList ()
MdcSegGrouperSt &	operator= (const MdcSegGrouperSt &)

---

Detailed Description

Definition at line 29 of file MdcSegGrouperSt.h.

---

Constructor & Destructor Documentation

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

Definition at line 45 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::isValid, ganga-rec::j, MdcSegGrouper::lTestGroup, MdcSegGrouper::lTestSingle, and MdcSegGrouper::nPly().

                                                                 : 
  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]

Definition at line 33 of file MdcSegGrouperSt.h.

{ };

---

Member Function Documentation

double MdcSegGrouper::calcParByHits	(	MdcSeg **	segGroup,
		int	nToUse,
		const TrkExchangePar &	par,
		double &	qual,
		int &	nSegFit,
		double	param[2],
		double	Bz
	)			[inherited]

Definition at line 585 of file MdcSegGrouper.cxx.

References MdcSegGrouper::_debug, MdcLine::chisq, MdcLine::fit(), MdcSeg::hit(), MdcSeg::info(), MdcLine::intercept, MdcHit::layernumber(), MdcHitUse::mdcHit(), MdcSeg::nHit(), MdcLine::nPoint, MdcLine::sigma, MdcLine::slope, MdcHit::wirenumber(), MdcLine::x, MdcLine::y, and MdcSegInfoSterO::zPosition().

Referenced by MdcSegGrouper::combineSegs().

                                                                                                                                                    {
  //************************************************************************
  //*** Calc. z and cot(theta) for stereo 
  int debug = false;
  if (11 == _debug ) debug = true;
  if (debug) std::cout<< "-----calculate group param by hit-----"<<std::endl;
  MdcLine span(50);
  MdcLine spanFit(50);

  int nHit = 0;
  if (debug) std::cout<< "nToUse="<<nToUse<<std::endl;
  for (int iPly = 0; iPly < nToUse; iPly++) {
    if (segGroup[iPly] == 0) continue;   // skipping this slayer
    nSegFit++;
    MdcSegInfoSterO *segInfo = dynamic_cast<MdcSegInfoSterO*> (segGroup[iPly]->info());

    if(debug) std::cout<< "nHit in segment="<<segGroup[iPly]->nHit()<<std::endl;
    for (int ii=0,iHit=0; ii<segGroup[iPly]->nHit(); ii++){

      if(debug)std::cout<< " calcParByHits ("<< segGroup[iPly]->hit(iHit)->mdcHit()->layernumber()<<","<<segGroup[iPly]->hit(iHit)->mdcHit()->wirenumber()<<")";
      //if(segGroup[iPly]->hit(iHit)->mdcHit()->layernumber()<4) continue;//yzhang TEMP TEST 2011-08-01 

      int szCode = segInfo->zPosition(*(segGroup[iPly]->hit(iHit)),par,&span,iHit,segGroup[iPly]->bunchTime(),Bz);
      if(debug)std::cout<< " szCode "<<szCode;
      if(szCode>0&&debug) std::cout<< iHit<<" s "<< span.x[iHit]<< " z "<<span.y[iHit] <<" sigma "<<span.sigma[iHit];
      if(debug)std::cout<<std::endl;

      spanFit.x[nHit]=span.x[iHit];
      spanFit.y[nHit]=span.y[iHit];
      //spanFit.sigma[nHit]=span.sigma[iHit];
      spanFit.sigma[nHit]=1.;
      if(debug)std::cout<< std::endl;
      iHit++;
      if(szCode>0) nHit++; 
    }
  }

  if(debug)std::cout<< __FILE__ << "   " << __LINE__ << " nHit  "<< nHit<<std::endl;
  if (nHit>0) spanFit.fit(nHit);
  else return -999;

  param[0] = spanFit.intercept;
  param[1] = spanFit.slope;
  if(debug)std::cout<< "nHit "<<nHit<<" intercept(z0) "<<param[0]<< " slope(ct) " << param[1] <<std::endl;

  qual = 2.*nHit - spanFit.chisq/(spanFit.nPoint - 2);
  if(debug)std::cout<< "chisq "<<spanFit.chisq<<" qual "<<qual<<std::endl;

  return spanFit.chisq;
} 

double MdcSegGrouper::calcParBySegs	(	MdcSeg **	segGroup,
		double	seedAngle[2],
		int	nToUse,
		double &	qual,
		int &	nSegFit,
		double	param[2]
	)			[inherited]

Definition at line 475 of file MdcSegGrouper.cxx.

References MdcSegGrouper::_debug, MdcSegInfo::errmat(), ers::error, genRecEmupikp::i, MdcSeg::info(), MdcSegInfo::inverr(), ganga-rec::j, mdcTwoInv(), mdcTwoVec(), mdcWrapAng(), MdcSeg::nHit(), MdcSegInfo::par(), and MdcSegInfo::parIsAngle().

Referenced by MdcSegGrouper::combineSegs().

                                                             {
  //************************************************************************
  if (11 == _debug) std::cout<< "-----calculate group param by segment param-----"<<std::endl;
  double wgtmat[3], wgtinv[3];
  double wgtpar[2];
  double temvec[2], diff[2];
  // Calculate track & chisq for this group 
  int nhit = 0;
  wgtmat[0] = wgtmat[1] = wgtmat[2] = wgtpar[0] = wgtpar[1] = 0.0;

  int iPly;
  for (iPly = 0; iPly < nToUse; iPly++) {
    if (11 == _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(11 == _debug) {
      std::cout<<0<<": param "<<param[0]<<" inverr "<< segInfo->inverr()[0]<<" par*W "<<temvec[0]<<std::endl;
      std::cout<<1<<": param "<<param[1]<<" "<<1/param[1]<<" inverr "<< segInfo->inverr()[1]<<" par*W "<<temvec[1]<<std::endl;
      std::cout<< "   " <<std::endl;
    }
    nhit += segGroup[iPly]->nHit();
  }

  // And the fitted parameters are . . . 
  int error = mdcTwoInv(wgtmat,wgtinv);
  if (error && (11 == _debug)) {
    cout << "ErrMsg(warning) " 
      <<  "failed matrix inversion in MdcTrackList::combineSegs" << endl;
    //continue;
    return -999.;
  }
  mdcTwoVec( wgtinv, wgtpar, param );
  if(11 == _debug) {
    std::cout<< " param of wgtinv * wgtpar" << std::endl;
    std::cout<<0<<": param "<<param[0]<< std::endl;
    std::cout<<1<<": param "<<param[1]<<" "<<1/param[1]<< std::endl;
    std::cout<< "   " <<std::endl;
  }

  //param[0]= 5.312286;
  //param[1]= -0.006;
  //std::cout<< "set param   " <<param[0]<< "   "<<param[1]<<std::endl;
  if(11 == _debug)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(11 == _debug) {
        std::cout<<" segPar"<<j<<" "<<temPar<<  std::endl;
      }
      diff[j] = temPar - param[j];
    }

    if(11 == _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<<"diff " <<diff[0]<<" "<<diff[1]<<" temvec "<<temvec[0]<<" "<<temvec[1]<< std::endl;
      std::cout<<  std::endl;
    }
    mdcTwoVec( segInfo->inverr(), diff, temvec);

    chisq += diff[0] * temvec[0] + diff[1] * temvec[1];

    if(11 == _debug){
      std::cout<<iPly<<" chi2Add:"<<diff[0] * temvec[0] + diff[1] * temvec[1]<<" diff0 "<< diff[0]<< " vec0 "<<temvec[0]<<" diff1 "<< diff[1]<< " vec1 "<<temvec[1] << std::endl;
    }
  }

  double chiDof = chisq/(2.*nSegFit - 2.);
  if (11 == _debug) {
    cout << "segment:"<<endl<<" chiDof "<<chiDof<<" chisq "<< chisq << " nhit " << nhit << " phi0/z0 " << 
      param[0] << " cpa/cot " << param[1] << " qual "<<(2. * nhit - chiDof) <<endl;
  }

  qual = 2. * nhit - chiDof;

  //if(is3d) std::cout<< __FILE__ << "   " << " z0 "<<param[0] << " ct "<<param[0] <<std::endl;//zhange TEMP test 2011-05-06 
  return chisq;
}

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

Definition at line 270 of file MdcSegGrouper.cxx.

References MdcSegGrouper::_debug, TrkRecoTrk::bField(), BField::bFieldZ(), MdcSegGrouper::calcParByHits(), MdcSegGrouper::calcParBySegs(), TrkRecoTrk::fitResult(), g_maxSegChisqAx, g_maxSegChisqSt, TrkFit::helix(), genRecEmupikp::i, MdcSeg::info(), iprint, MdcSegGrouper::nextGroup(), MdcSegGrouper::nPly(), MdcSegInfo::par(), MdcSegInfo::parIsAngle(), MdcSeg::plotSegAll(), MdcSegGrouper::resetComb(), MdcSegGrouper::storePar(), MdcTrack::track(), and MdcSegGrouper::transferHits().

Referenced by MdcTrackListCsmc::createFromSegs(), and MdcTrackList::createFromSegs().

                                                                               {
  //************************************************************************/
  // forms track from list of segs; does 2-param fit (either r-phi from origin
  //  or s-z) and picks best combination.
  if (3 == _debug) std::cout<<std::endl<<  "=====MdcSegGrouper::combineSegs=====" <<std::endl;
  bool lSeed = (seed != 0); // no seed for stereo group

  int success = 0;
  double qual;
  double qualBest = -1000.;
  int nSegFit = 0;
  int nSegBest = 0;
  //int nHitBest = 0;
  double param[2];
  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;

  //bool is3d = (seed==NULL);//zhange TEMP test 2011-05-06 

  // Loop over all combinations of segs consistent with seed (including gaps)
  if ((3 == _debug)&&lSeed) {
    std::cout<<"seed segment: ";
    seed->plotSegAll();
    std::cout<< std::endl;
  }
  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;

    if (3 == _debug || 11 == _debug) {
      cout << endl <<"-----found a segment group by nextGroup()----- nInGroup "<<nInGroup<<" nToUse "<<nToUse<<endl;
      for(int ii=0; ii<nToUse; ii++){ if(segGroup[ii]) {segGroup[ii]->plotSegAll(); cout<<endl;} }
      //cout << endl <<"--calc. parameters of this segment group"<<endl;
    }

    double chisq =-999.;
    nSegFit=0;

    if(lSeed){
      //2d
      chisq = calcParBySegs(segGroup, seedAngle, nToUse, qual, nSegFit, param);
    }else{
      if (combineByFitHits == 0){
        chisq = calcParBySegs(segGroup, seedAngle, nToUse, qual, nSegFit, param);
      }else{
        //3d 
        const TrkFit* tkFit = trk->track().fitResult();
        double Bz = trk->track().bField().bFieldZ();//??
        TrkExchangePar par = tkFit->helix(0.0);
        //par.print(std::cout);
        if (tkFit != 0) chisq = calcParByHits(segGroup, nToUse, par, qual,nSegFit, param, Bz);
        //std::cout<< __FILE__ << "   " << __LINE__ << " calcParByHits"<<std::endl;
        if(chisq<=0){
          //std::cout<< "calcParByHits failed! calc. by seg" <<std::endl;
          chisq = calcParBySegs(segGroup, seedAngle, nToUse, qual, nSegFit, param);
        }
      }
    }


    if (chisq < 0.) continue;//yzhang add
    double chiDof = chisq/(2.*nSegFit - 2.);

    if (g_maxSegChisqAx && lSeed ) { g_maxSegChisqAx->fill(chiDof); } //yzhang hist cut
    if (g_maxSegChisqSt && !lSeed) { g_maxSegChisqSt->fill(chiDof); } //yzhang hist cut

    //std::cout<<  " chisq  " << chisq<< " chi2dof "<<chiDof<<std::endl;

    if (3 == _debug || 11 == _debug) {
      std::cout<< endl<<"chisq "<<chisq<<" nSegFit " << nSegFit<< " chiDof "<<chiDof<<std::endl;
      if(chiDof > maxSegChisqO) {
        cout << "***** DROP this group by chiDof "<<chiDof<<" > maxSegChisqO:"<<maxSegChisqO<<endl;
      }else{
        cout << "***** KEEP this group by chiDof "<<chiDof<<" <= maxSegChisqO:"<<maxSegChisqO<<endl;
      }
    }
    // Chisq test
    if (chiDof > maxSegChisqO) continue;

    success = 1;
    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];
      }
      if (3 == _debug && 11 == _debug) std::cout<<"Keep as best group. param: phi0/z0 "
        <<paramBest[0]<< " cpa/ct "<<paramBest[1]<<  std::endl;
    }// end test on qual
  }

  if (success == 1) {
    if(3 == _debug || 11 == _debug) {
      std::cout<< endl<<"-----Parameter best group-----    "<<std::endl;
      std::cout<< "paramBest "<<paramBest[0]<<" "<<paramBest[1]<< " chiBest " << chiBest<< std::endl;
    }
    // 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]

Definition at line 464 of file MdcSegGrouper.cxx.

References genRecEmupikp::i, and MdcSegGrouper::segList.

Referenced by MdcTrackList::createFromSegs().

                               {
  //************************************************************************
  for(int islayer=0; islayer<11; islayer++){
    for(int i=0; i<segList[islayer].length(); i++){
      segList[islayer][i]->plotSegAll();
      std::cout<< std::endl;
    }
  }
}

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

Definition at line 69 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_debug, MdcSegGrouper::_gm, MdcSegInfoSterO::calcStereo(), MdcSegInfoSterO::ct(), MdcSegParams::ctcut, TrkExchangePar::d0(), MdcSuperLayer::delPhi(), GmsList::first(), TrkRecoTrk::fitResult(), g_ctCut, g_z0Cut, TrkFit::helix(), GmsListLink::next(), MdcDetector::nSuper(), TrkExchangePar::omega(), MdcSegList::oneList(), MdcSeg::phi(), TrkExchangePar::phi0(), phi0, MdcSegWorks::phiArg, MdcSegWorks::phiAx, MdcSeg::plotSeg(), MdcSuperLayer::rEnd(), resetList(), MdcSegGrouper::segList, MdcSeg::segPar(), MdcSeg::setInfo(), BesAngle::setRad(), MdcSeg::superlayer(), MdcTrack::track(), MdcSuperLayer::whichView(), MdcSegWorks::wirLen2inv, MdcSegInfoSterO::z0(), MdcSegParams::z0cut, and MdcSuperLayer::zEnd().

Referenced by MdcTrackListCsmc::createFromSegs(), and MdcTrackList::createFromSegs().

                           {
  //------------------------------------------------------------------------
  // 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 
  if(3==_debug) std::cout<<std::endl<< "=====MdcSegGrouperSt::fillWithSegs====="<<std::endl;

  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;
    BesAngle maxPhiA = segStuff.phiAx + delPhi + 0.1;  // allow a little slop yzhang 2011-06-15 
    BesAngle minPhiA = segStuff.phiAx - delPhi - 0.1;//yzhang TEMP 2011-06-15 
    //yzhang FIXME
    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
    if(_debug==3) std::cout<<std::endl<<"Pick segment by phi from " <<minPhi<< " to "<<maxPhi<<" phiAx="<<segStuff.phiAx<<" delPhi="<<delPhi<<std::endl;
    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 << " CUT by phi "<<phiSeg
            << "<min "<<minPhi << std::endl;}//yzhang debug     
          continue;  // not up to candidates
        }
        else if(phiSeg > maxPhi) {
          if (_debug ==3){std::cout << " CUT by phi "<<phiSeg
            <<">max "<<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 seg phi="<<phiSeg<<  std::endl;

      //std::cout<< __FILE__ << "   " << __LINE__ << " MdcSegGrouperSt::fillWithSegs call calcStereo "<<std::endl;
      int isBad = info->calcStereo(inSeg, track->track(), segStuff);  

      if (isBad) {
        if (_debug ==3){std::cout << " CUT by calcStereo isBad!"<<std::endl;}
        continue;
      }
      // 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 << " CUT by ctcut! "
          <<fabs(info->ct())<<" > cut:"<< inSeg->segPar()->ctcut<<" "<<phiSeg<<std::endl; }
        continue;
      }
      if (fabs(info->z0()) > inSeg->segPar()->z0cut){
        if (_debug ==3){std::cout << " CUT by z0cut! "
          <<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<<" APPEND this stereo seg"<<  std::endl;

    }  // end loop over new segs
  }  //  end loop over superlayers
  delete info;
}

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

Implements MdcSegGrouper.

Definition at line 228 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_debug, MdcSegInfo::arc(), MdcSegGrouper::combList, MdcSegInfoSterO::ct(), MdcSegGrouper::currentSeg, MdcSegParams::delCtCut, MdcSegParams::delZ0Cut, first, g_delCt, g_delZ0, genRecEmupikp::i, MdcSeg::info(), MdcSegGrouper::leaveGap, MdcSeg::plotSeg(), MdcSeg::segPar(), and MdcSegInfoSterO::z0().

              {
  //-------------------------------------------------------------------------
  // 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
      std::cout<<"first:"; first->plotSeg(); std::cout<<std::endl;
      std::cout<<"test:"; testSeg->plotSeg();std::cout<<std::endl;
      std::cout << "first.ct "<< firstInfo->ct()
        <<" test.ct "<<newInfo->ct()
        <<" delta ct "<<firstInfo->ct() - newInfo->ct()
        <<" Cut "<<testSeg->segPar()->delCtCut << std::endl;//yzhang debug

      std::cout<<"--- "<<  std::endl;
    } 
    return -1;
  }else{
  }

  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;
}

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

Implements MdcSegGrouper.

Definition at line 220 of file MdcSegGrouperSt.cxx.

                           {
  //-------------------------------------------------------------------------

  return 0;
}

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

Definition at line 83 of file MdcSegGrouper.cxx.

References MdcSegGrouper::combList, MdcSegInfoSterO::ct(), MdcSegGrouper::currentSeg, MdcSegGrouper::firstBad, MdcSegGrouper::firstGood, MdcSegGrouper::incompWithGroup(), MdcSegGrouper::isValid, MdcSegGrouper::leaveGap, MdcSegGrouper::lTestGroup, MdcSegGrouper::lTestSingle, MdcSegGrouper::maxNull, MdcSegGrouper::nDeep, MdcSegGrouper::nNull, MdcSegGrouper::nPlyFilled, MdcSegGrouper::resetGap(), MdcSegGrouper::resetSegCounters(), and MdcSegGrouper::updateGap().

Referenced by MdcSegGrouper::combineSegs().

                                                              {
  //------------------------------------------------------------------------

  // 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]) {
      if(printit) std::cout<< " reach end of list, break." << iply<< std::endl;
      break;
    }
    //if (nSegUsed > segPar.nSegUsedNextGroup) break;
    if (leaveGap[iply]) {
      if(printit) std::cout<< "  leaveGap  " <<std::endl;
      // 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(printit) { std::cout<< "reach end of segs  "<<std::endl; }
        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) {
              if(printit) { std::cout<<endl<< " All done!  "<<std::endl; }
              return 0;  // All done
            }
            resetGap(nNull);
            updateGap();
          } // end if lDone
        }  //end if exhausted gap group
        break;
      }  // end reached end of segs

      if(printit){
        std::cout<< "ply " << iply<< " seg "<<currentSeg[iply]<<": ";
        (*combList[iply])[currentSeg[iply]]->plotSeg();
        if((*combList[iply])[currentSeg[iply]]->superlayer()->whichView()!= 0){
          MdcSegInfoSterO* info = (MdcSegInfoSterO *) (*combList[iply])[currentSeg[iply]]->info();
          std::cout<< " ct " << info->ct();
        }
      }

      //yzhang 09-09-28 delete
      if( (*combList[iply])[currentSeg[iply]]->segUsed()) {
        if(printit) {
          std::cout<< std::endl<<" Used??";
          (*combList[iply])[currentSeg[iply]]->plotSeg();
        }
        if(printit) { std::cout<< " segUsed! SKIP "<<std::endl; }
        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(printit) {
          if(invalid){ std::cout<<" invalid "<< std::endl;
          }else{ std::cout<<" KEEP 1 "<< std::endl; }
        }
        if (invalid) continue;
      }else{
        if(printit) std::cout<<" KEEP 2 "<< std::endl; 
      }

      // 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){
          if(lBad) std::cout<<" incompWithGroup Bad! restart" << std::endl;
          //else std::cout<<" incompWithGroup Bad! restart" << std::endl;
        }
        if (lBad) goto restart;
      }
      nFound++;
    }
  }

  if (printit) std::cout<< "nextGoup() found " << nFound << " segment(s)"<<std::endl;
  return nFound;
}

int MdcSegGrouper::nPly

(

)

const [inline, inherited]

Definition at line 54 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::combineSegs(), MdcSegGrouperAx::MdcSegGrouperAx(), MdcSegGrouperCsmc::MdcSegGrouperCsmc(), and MdcSegGrouperSt().

{return nDeep;}

MdcSegGrouperSt& MdcSegGrouperSt::operator=

(

const MdcSegGrouperSt &

)

[private]

void MdcSegGrouperSt::plotStereo

(

)

const

Definition at line 191 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_gm, first, ganga-rec::j, MdcDetector::nSuper(), and MdcSegGrouper::segList.

                                        {
  //-------------------------------------------------------------------------
  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.

Definition at line 318 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_gm, MdcSegGrouper::combList, MdcSegGrouper::firstBad, MdcSegGrouper::firstGood, MdcDetector::firstSlay(), genRecEmupikp::i, MdcSegGrouper::isValid, MdcSegGrouper::leaveGap, MdcSegGrouper::maxNull, MdcSegGrouper::nDeep, MdcSuperLayer::next(), MdcSegGrouper::nNull, MdcSegGrouper::nPlyFilled, MdcSegGrouper::resetSegCounters(), and MdcSegGrouper::segList.

                                                  {
  //**************************************************************************

  // 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]

Definition at line 214 of file MdcSegGrouper.cxx.

References MdcSegGrouper::gapCounter, genRecEmupikp::i, and MdcSegGrouper::nPlyFilled.

Referenced by MdcSegGrouper::nextGroup().

                                     {
  //**************************************************************************

  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]

Definition at line 59 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_gm, genRecEmupikp::i, MdcDetector::nSuper(), and MdcSegGrouper::segList.

Referenced by fillWithSegs().

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

Definition at line 262 of file MdcSegGrouper.cxx.

References MdcSegGrouper::currentSeg, MdcSegGrouper::firstGood, genRecEmupikp::i, and MdcSegGrouper::nPlyFilled.

Referenced by MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), and MdcSegGrouperAx::resetComb().

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

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

Implements MdcSegGrouper.

Definition at line 362 of file MdcSegGrouperSt.cxx.

References MdcSegGrouper::_debug, TrkHelixMaker::addZValues(), and MdcTrack::track().

                         {
  //---------------------------------------------------------------------
  assert (trk != 0);
  TrkHelixMaker maker;
  if(3==_debug) std::cout<< "-----storePar z0 "<<parms[0]<<" ct "<<parms[1]<<std::endl;
  maker.addZValues(trk->track(), parms[0], parms[1], chisq);
  return trk;
}

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

Definition at line 408 of file MdcSegGrouper.cxx.

References MdcSegGrouper::_debug, TrkHitList::appendHit(), MdcTrack::firstLayer(), MdcTrack::hasCurled(), TrkRecoTrk::hits(), genRecEmupikp::i, MdcTrack::lastLayer(), MdcSeg::nHit(), MdcSeg::plotSegAll(), MdcLayer::rMid(), MdcTrack::setFirstLayer(), MdcTrack::setLastLayer(), MdcSeg::setUsed(), and MdcTrack::track().

Referenced by MdcSegGrouper::combineSegs().

                                                                            {
  //************************************************************************/
  //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();

  //yzhang 2011-05-04 
  //bool maintainAmbiguity = (trk->track().status()->is2d() == 0) ? false: true;
  //bool maintainAmbiguity = false;
  //std::cout<< __FILE__ << "   " << __LINE__ << " maintainAmbiguity "<<maintainAmbiguity<<std::endl;

  if(3 == _debug) std::cout<< endl<<"-----transferHits for this segGroup-----  " <<std::endl;
  for (int i = 0; i < nSegs; i++) {
    if (segGroup[i] == 0) continue;   // skipping this slayer
    if(3 == _debug) {
      cout << i << "  "; segGroup[i]->plotSegAll(); cout<< 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, maintainAmbiguity);
      theHits->appendHit(*aHit);
      //zhangy

      //std::cout<<"in MdcSegGrouper  append ok"<<std::endl;//yzhang debug
    }   
  }  // end loop over slayers
} 

int MdcSegGrouper::updateGap

(

)

[inherited]

Definition at line 226 of file MdcSegGrouper.cxx.

References MdcSegGrouper::gapCounter, genRecEmupikp::i, ganga-rec::j, MdcSegGrouper::leaveGap, MdcSegGrouper::nNull, and MdcSegGrouper::nPlyFilled.

Referenced by MdcSegGrouper::nextGroup().

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

Definition at line 96 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::calcParByHits(), MdcSegGrouper::calcParBySegs(), MdcSegGrouper::combineSegs(), fillWithSegs(), MdcSegGrouperAx::fillWithSegs(), incompWithGroup(), MdcSegGrouperAx::incompWithSeg(), MdcSegGrouper::MdcSegGrouper(), MdcSegGrouperAx::resetComb(), storePar(), and MdcSegGrouper::transferHits().

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

Definition at line 78 of file MdcSegGrouper.h.

Referenced by fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), MdcSegGrouperAx::fillWithSegs(), MdcSegGrouper::MdcSegGrouper(), plotStereo(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), resetList(), MdcSegGrouperCsmc::storePar(), and MdcSegGrouperAx::storePar().

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

Definition at line 77 of file MdcSegGrouper.h.

Referenced by incompWithGroup(), MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), and MdcSegGrouper::~MdcSegGrouper().

int* MdcSegGrouper::currentSeg [protected, inherited]

Definition at line 70 of file MdcSegGrouper.h.

Referenced by incompWithGroup(), MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), MdcSegGrouper::resetSegCounters(), and MdcSegGrouper::~MdcSegGrouper().

int* MdcSegGrouper::firstBad [protected, inherited]

Definition at line 72 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), and MdcSegGrouper::~MdcSegGrouper().

int* MdcSegGrouper::firstGood [protected, inherited]

Definition at line 71 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), MdcSegGrouper::resetSegCounters(), and MdcSegGrouper::~MdcSegGrouper().

int* MdcSegGrouper::gapCounter [protected, inherited]

Definition at line 91 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::resetGap(), MdcSegGrouper::updateGap(), and MdcSegGrouper::~MdcSegGrouper().

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

Definition at line 73 of file MdcSegGrouper.h.

Referenced by MdcSegGrouperAx::MdcSegGrouperAx(), MdcSegGrouperCsmc::MdcSegGrouperCsmc(), MdcSegGrouperSt(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), and MdcSegGrouper::~MdcSegGrouper().

bool* MdcSegGrouper::leaveGap [protected, inherited]

Definition at line 88 of file MdcSegGrouper.h.

Referenced by incompWithGroup(), MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), MdcSegGrouper::updateGap(), and MdcSegGrouper::~MdcSegGrouper().

bool MdcSegGrouper::lTestGroup [protected, inherited]

Definition at line 93 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouperAx::MdcSegGrouperAx(), MdcSegGrouperCsmc::MdcSegGrouperCsmc(), MdcSegGrouperSt(), and MdcSegGrouper::nextGroup().

bool MdcSegGrouper::lTestSingle [protected, inherited]

Definition at line 94 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouperAx::MdcSegGrouperAx(), MdcSegGrouperCsmc::MdcSegGrouperCsmc(), MdcSegGrouperSt(), and MdcSegGrouper::nextGroup().

int MdcSegGrouper::maxNull [protected, inherited]

Definition at line 90 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), and MdcSegGrouperAx::resetComb().

int MdcSegGrouper::nDeep [protected, inherited]

Definition at line 68 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::MdcSegGrouper(), MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), and MdcSegGrouper::~MdcSegGrouper().

int MdcSegGrouper::nNull [protected, inherited]

Definition at line 89 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), and MdcSegGrouper::updateGap().

int MdcSegGrouper::nPlyFilled [protected, inherited]

Definition at line 69 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::nextGroup(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), MdcSegGrouper::resetGap(), MdcSegGrouper::resetSegCounters(), and MdcSegGrouper::updateGap().

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

Definition at line 79 of file MdcSegGrouper.h.

Referenced by MdcSegGrouper::dumpSegList(), fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), MdcSegGrouperAx::fillWithSegs(), MdcSegGrouper::MdcSegGrouper(), plotStereo(), resetComb(), MdcSegGrouperCsmc::resetComb(), MdcSegGrouperAx::resetComb(), resetList(), and MdcSegGrouper::~MdcSegGrouper().

---