MdcSegGrouperSt Class Reference

#include <MdcSegGrouperSt.h>

Inheritance diagram for MdcSegGrouperSt:

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)
Public Member Functions inherited from MdcSegGrouper
virtual	~MdcSegGrouper ()
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)
void	setNoInner (bool noInnerFlag)

Additional Inherited Members
Protected Member Functions inherited from MdcSegGrouper
	MdcSegGrouper (const MdcDetector *gm, int nDeep, int debug)
void	resetSegCounters ()
Protected Attributes inherited from MdcSegGrouper
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
bool	_noInner

Detailed Description

Definition at line 29 of file MdcSegGrouperSt.h.

Constructor & Destructor Documentation

MdcSegGrouperSt()

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

Definition at line 45 of file MdcSegGrouperSt.cxx.

                                                                 : 
  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::~MdcSegGrouperSt ( )

inline

Definition at line 33 of file MdcSegGrouperSt.h.

{ };

Member Function Documentation

fillWithSegs()

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

Definition at line 69 of file MdcSegGrouperSt.cxx.

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

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

incompWithGroup()

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

virtual

Implements MdcSegGrouper.

Definition at line 228 of file MdcSegGrouperSt.cxx.

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

incompWithSeg()

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

virtual

Implements MdcSegGrouper.

Definition at line 220 of file MdcSegGrouperSt.cxx.

                           {
  //-------------------------------------------------------------------------
 
  return 0;
}

plotStereo()

void MdcSegGrouperSt::plotStereo

(

)

const

Definition at line 191 of file MdcSegGrouperSt.cxx.

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

resetComb()

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

virtual

Implements MdcSegGrouper.

Definition at line 318 of file MdcSegGrouperSt.cxx.

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

storePar()

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

virtual

Implements MdcSegGrouper.

Definition at line 362 of file MdcSegGrouperSt.cxx.

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

---

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

• MdcSegGrouperSt.h
• MdcSegGrouperSt.cxx