MdcTrackListCsmc Class Reference

#include <MdcTrackListCsmc.h>

Inheritance diagram for MdcTrackListCsmc:

List of all members.

Public Member Functions
	MdcTrackListCsmc (const MdcTrackParams &tkPar)
	~MdcTrackListCsmc ()
int	createFromSegs (MdcSegList *segs, const MdcHitMap *, const MdcDetector *, TrkContext &, double trackT0)
int	finish3d (TrkRecoTrk &trk)
void	remove (MdcTrack *atrack)
int	nTrack () const
void	setPlot (int plotFlag)
void	newParams (const MdcTrackParams &tkPar)
void	plot () const
void	store (RecMdcTrackCol *, RecMdcHitCol *)
int	arbitrateHits ()
void	dropMultiHotInLayer (const MdcTrack *tk)
void	setD0Cut (double d0Cut)
void	setZ0Cut (double z0Cut)
void	setPtCut (double ptCut)
Static Public Attributes
static double	m_d0Cut = -999.
static double	m_z0Cut = -999.
static double	m_ptCut = -999.
Protected Attributes
MdcTrackParams	tkParam

---

Detailed Description

Definition at line 30 of file MdcTrackListCsmc.h.

---

Constructor & Destructor Documentation

MdcTrackListCsmc::MdcTrackListCsmc

(

const MdcTrackParams &

tkPar

)

Definition at line 34 of file MdcTrackListCsmc.cxx.

                                                              : 
  MdcTrackListBase(tkPar) { 
// *************************************************************************
    return;
  }

MdcTrackListCsmc::~MdcTrackListCsmc

(

)

Definition at line 41 of file MdcTrackListCsmc.cxx.

{} 

---

Member Function Documentation

int MdcTrackListBase::arbitrateHits

(

)

[inherited]

Definition at line 104 of file MdcTrackListBase.cxx.

References TrkHitList::begin(), TrkHitList::end(), TrkRecoTrk::fitResult(), for, MdcMap< K, V >::get(), TrkRecoTrk::hits(), genRecEmupikp::i, TrkRecoTrk::id(), MdcTrackParams::lPrint, MdcTrackParams::lRemoveInActive, MdcTrackListBase::nTrack(), MdcMap< K, V >::put(), q, TrkHitList::removeHit(), MdcTrackListBase::tkParam, and MdcTrack::track().

                                {
  //*************************************************************************
  // Look at all hits used in two or more tracks.  Assign hits to the track
  // that gives the lower residual.  If, however, many hits are shared by
  // a pair of tracks, assign them all to one or the other.
  // Refit any tracks that have had hits dropped.
  // The implementation is very clumsy, since the arrays were originally
  // indexed by id # => there is an unneeded layer of indexing.

  // return # of tracks deleted

  if (8 == tkParam.lPrint){
    std::cout << "=======Print before arbitrateHits=======" << std::endl;
  }

  int nDeleted = 0;
  std::vector<MdcTrack*> trksToKill;
  trksToKill.reserve(4);

  MdcMap<long,long> idMap;

  //usedInTrackNum records how many shared hits track has with each other track
  int* usedInTrackNum = new int [nTrack()];
  // to navigate from track id # to track pointer:
  MdcTrack** trkXRef = new MdcTrack* [nTrack()];
  //refitTrack flags track id #s of tracks to be refit
  int *refitTrack = new int [nTrack()];
  for (int i = 0; i < nTrack(); i++) {
    refitTrack[i] = 0;
  }

  // Fill xref table
  int itrack;
  for (itrack = 0; itrack < nTrack(); itrack++) {
    MdcTrack *atrack = (*this)[itrack];
    if (atrack == 0) continue;  // I don't think it can be, but . . .
    idMap.put(atrack->track().id(), itrack);
    trkXRef[itrack] = atrack;
  }
  // Loop through the tracks
  for (itrack = 0; itrack < nTrack(); itrack++) {

    if (8 == tkParam.lPrint) std::cout<<"arbitrate track No."<<itrack<<  std::endl;
    MdcTrack *atrack = (*this)[itrack];
    if (atrack == 0) continue;
    TrkRecoTrk& aRecoTrk = atrack->track();
    int lRefit = 0;
    int trackOld = -1;
    const TrkFit* tkFit = aRecoTrk.fitResult();
    assert (tkFit != 0);
    TrkHitList* hitList = aRecoTrk.hits();
    assert (hitList != 0);
restart:
    for (int ii = 0; ii < nTrack(); ii++) usedInTrackNum[ii] = 0;

    // Loop through hits on track, counting # used in other tracks
    int nPrev = 0;
    int nHitDeleted = 0;
    int maxGapLength = 0;//yzhang 2011-07-29 # of max continuous no hits layer for a track, Gap defined as missing layer >=2 
    int nGapGE2= 0;//yzhang 2011-07-29 # of no hits gap for a track 
    int nGapGE3= 0;//yzhang 2011-07-29 # of no hits gap for a track 
    int nHitInLayer[43];//yzhang 2010-09-20 for bad tracking testing
    int nDeleteInLayer[43];//yzhang 2010-09-20 
    for(int i=0;i<43;i++){
      nHitInLayer[i]=0;
      nDeleteInLayer[i]=0;
    }
    if(8 == tkParam.lPrint) std::cout<< "--arbitrate--"<<std::endl;
    for (TrkHitList::hot_iterator ihit(hitList->begin()); ihit != hitList->end(); ++ihit){
      int nUsed = ihit->hit()->nUsedHits();
      if (8 == tkParam.lPrint){
        std::cout<<"nUsed="<<nUsed<<":";
        ihit->hit()->printAll(std::cout);
      }
      if (8 == tkParam.lPrint) {
        double deltaChi = -999;
        ihit->getFitStuff(deltaChi);
        std::cout<< "deltaChi="<<deltaChi<<std::endl;
      }
      int layer = ihit->layerNumber();
      nHitInLayer[layer]++;

      if (!ihit->isActive()) {
        //-----------------------------------
        //yzhang delete not ACT hit 2010-05-14 
        //-----------------------------------
        if(tkParam.lRemoveInActive ) {//2010-05-16 
          nDeleteInLayer[layer]++;
          if (8 == tkParam.lPrint) {
            std::cout<< "=remove above inactive "<<std::endl;
          }
          TrkFundHit* hit = const_cast<TrkFundHit*> (ihit->hit());
          hitList->removeHit(hit);
          if(ihit == hitList->end()) break;
          --ihit;//be careful of the iterator, yzhang
        }
        continue;   // active hits only yzhang 2009-11-03 delete
      }
      if (nUsed > 1) {
        bool wasUsed = false;
        std::pair<TrkFundHit::hot_iterator,TrkFundHit::hot_iterator> q =
          ihit->hit()->getUsedHits();
        for (TrkFundHit::hot_iterator i = q.first; i != q.second; ++i) {
          if ( !i->isActive() ) continue; //yzhang 2009-11-03 delete
          TrkRecoTrk * recoTrk=i->parentTrack();
          int id = recoTrk->id();
          if (id == aRecoTrk.id()) continue; //skip same track
          long index = 0;
          idMap.get(id, index);
          assert(index >= 0);
          usedInTrackNum[index]++;
          if (8 == tkParam.lPrint){
            std::cout<<" track "<<itrack<<"&" <<index
              << " shared hits "<<usedInTrackNum[index]<<":";
            ihit->printAll(std::cout);
          }
          wasUsed = true;
        }
        if (wasUsed) nPrev++;
      }// end nUsed > 1
    } // end loop over hits

    int testGap = 0;
    //std::cout<< __FILE__ << "   " << itrack<< "   "<<std::endl;
    for (int i=0;i<43;i++){
      //std::cout<< __FILE__ << "   " << i<< " nHitInLayer  "<<nHitInLayer[i]<<" nDeleteInLayer "<<nDeleteInLayer[i]<<std::endl;
      if (8 == tkParam.lPrint) {
        std::cout<<i<<" nHitInLayer  "<<nHitInLayer[i]
          <<" nDeleteInLayer "<<nDeleteInLayer[i]<<std::endl;
      }
      //1.only hit in layer deleted; 2.no hits in layer; 3.got hits in layer;
      if(nHitInLayer[i]>0 && (nHitInLayer[i]-nDeleteInLayer[i])==0) {
        //only hit in layer i has been deleted
        nHitDeleted++;
        if (8 == tkParam.lPrint) { 
          cout << "rec hits have been deleted in this layer"<<std::endl; 
        }
        testGap++;
        //std::cout<< __FILE__ << "   " << __LINE__ << " testGap3  "<<testGap<<std::endl;
      }else if(nHitInLayer[i]==0){
        //no hits in this layer i
        testGap++;
        //std::cout<< __FILE__ << "   " << __LINE__ << " testGap3  "<<testGap<<std::endl;
      }else{
        //std::cout<< __FILE__ << "   " << __LINE__ << " testGap3  "<<testGap<<std::endl;
        //got hit in layer i
        if(testGap>=2){
          nGapGE2++;
          if(testGap>=3){ nGapGE3++; }
          if(testGap>maxGapLength) maxGapLength=testGap;
          //std::cout<< __FILE__ << "   " << __LINE__ << " maxGapLength  "<<maxGapLength<<std::endl;
        }
        testGap=0;
      }//end for layer 43
    }

    bool toBeDeleted = false;

    if(tkParam.lPrint>1) std::cout<< "arbitrateHits tkNo:"<<itrack<<" nGapGE2=  "<<nGapGE2 << " nGapGE3=  "<<nGapGE3 << " maxGapLength=  "<<maxGapLength<<std::endl;
    //yzhang add nHitDeleted cut 2010-09-13 
    // remove track if # not Active 
    if (nHitDeleted >= tkParam.nHitDeleted) {
      if (tkParam.lPrint>1) {
        cout << "arbitrateHits: nHitDeleted "<<nHitDeleted<<" >= "<<tkParam.nHitDeleted
          <<" Killing tkNo " << itrack << endl;
      }
      toBeDeleted = true;
    }

    //yzhang add nGap cut 2011-07-29 
    // remove track with gaps and big gap
    if (nGapGE2 >= tkParam.nGapGE2) {
      if (tkParam.lPrint>1) {
        cout << "arbitrateHits: nGapGE2 "<<nGapGE2<<" >= "<<tkParam.nGapGE2 <<" Killing tkNo " << itrack << endl;
      }
      toBeDeleted = true;
    } 
    if (nGapGE3 >= tkParam.nGapGE3) {
      if (tkParam.lPrint>1) {
        cout << "arbitrateHits: nGapGE3 "<<nGapGE3<<" >= "<<tkParam.nGapGE3 <<" Killing tkNo " << itrack << endl;
      }
      toBeDeleted = true;
    } 
    if (maxGapLength >= tkParam.maxGapLength) {
      if (tkParam.lPrint>1) {
        cout << "arbitrateHits: maxGapLength "<<maxGapLength<<" >= "<<tkParam.maxGapLength<<" Killing tkNo " << itrack << endl;
      }
      toBeDeleted = true;
    } 

    if(toBeDeleted){
      nDeleted++;
      delete &(atrack->track());    // Delete the RecoTrk inside atrack
      atrack->setTrack(0);
      trksToKill.push_back(atrack);
      continue;
    } 

    //*******
    // How many hits are shared with a single track?
    int nMost = 0;
    int trackMost = 0;
    for (int ii = 0; ii < nTrack(); ii++) {
      if (8 == tkParam.lPrint){
        std::cout<<"tk:"<<itrack<<"&"<<ii
          <<" shared "<<usedInTrackNum[ii]<<" hits "<<  std::endl;
      }
      if (usedInTrackNum[ii] > nMost) {
        nMost = usedInTrackNum[ii];
        trackMost = ii;  //index of track w/ most hits in common w/ current trk
      }
    }

    // A little precaution against infinite loops:
    if (trackMost == trackOld) {
      std::cout << "ErrMsg(error) MdcTrackListBase:"
        << "Something ghastly happened in MdcTrackListBase::arbitrateHits"
        << std::endl;
      return 0;
    }
    trackOld = trackMost;


    //******
    // Decide whether to handle hits individually or in group
    double groupDiff = 0.0;   // relative quality of grouped hits for the two
    // tracks; > 0. => current track worse
    int nFound = 0;    // # of grouped hits located so far
    TrkHitOnTrk **theseHits = 0;  // grouped hits as seen in current track
    TrkHitOnTrk **thoseHits = 0;  // grouped hits as seen in the other track
    int lGroupHits = 0;

    if (nMost >= tkParam.nOverlap) {
      if (8 == tkParam.lPrint){
        std::cout<<"track "<<trackMost<<" shared "<<nMost<<" hits > Cut nOverlap "
          <<tkParam.nOverlap<<", group hits!"<<std::endl;
      }
      lGroupHits = 1;
      theseHits = new TrkHitOnTrk*[nMost];
      thoseHits = new TrkHitOnTrk*[nMost];
    }

    //*********
    // Go back through hits on this track, looking up the overlap of each
    // if grouping hits, only deal with hits shared with trackMost on this pass
    // otherwise, deal with all shared hits as encountered
    if(8 == tkParam.lPrint) std::cout<<"Go back through hits, looking up overlap hits"<< std::endl;
    if (nMost > 0) {
      if (8 == tkParam.lPrint) std::cout<<" nHits= "<< hitList->nHit()<< std::endl;
      for (TrkHitList::hot_iterator ihit(hitList->begin()); ihit != hitList->end(); ++ihit) {
        int nUsed = ihit->hit()->nUsedHits();

        if (8 == tkParam.lPrint){
          std::cout<< "--hit go back, nUsed="<<nUsed<<":";
          ihit->hit()->printAll(std::cout);
        }

        // only shared hits 
        if (nUsed < 2) { continue; }

        // active hits only
        if (!ihit->isActive()) {
          if (8 == tkParam.lPrint){ std::cout<<"act=0 continue"<<std::endl; }
          continue;   
        }

        //*** look at all overlaps for this hit
        std::pair<TrkFundHit::hot_iterator,TrkFundHit::hot_iterator> q = ihit->hit()->getUsedHits();
        while (q.first!=q.second) { // nUsed > 0
          int dropThisHit = 0;
          TrkHitOnTrk *otherHot = const_cast<TrkHitOnTrk*>((--q.second).get());
          TrkRecoTrk *otherTrack = otherHot->parentTrack();

          if (!otherHot->isActive()) continue;

          // Again, skip "overlap" of track with itself
          if ( &aRecoTrk == otherTrack) continue;
          int otherId = otherTrack->id();
          long otherIndex = -1;
          idMap.get(otherId, otherIndex); assert(otherIndex >= 0);

          // if grouping hits, only look at hits shared with trackMost
          if (lGroupHits && otherIndex != trackMost) continue;

          if (lGroupHits) {
            if (8 == tkParam.lPrint) {
              std::cout<<"group hits "<<  std::endl;
            }
            // Calculate contribution of group to each chisq/dof
            //        groupDiff += fabs(ihit->resid(0)) -
            //          fabs(otherHot->resid(0));
            // Hack to handle tracks with 5 active hits:
            int aDof = tkFit->nActive() - 5;
            assert (otherTrack->fitResult() != 0);
            int otherDof = otherTrack->fitResult()->nActive() - 5;
            if (aDof <= 0) {groupDiff = 999;}
            else if (otherDof <= 0) {groupDiff = -999;}
            else {
              groupDiff += ihit->resid(0) * ihit->resid(0) * ihit->weight() /
                aDof -
                otherHot->resid(0) * otherHot->resid(0) * otherHot->weight() /
                otherDof;
            }
            theseHits[nFound] = const_cast<TrkHitOnTrk*>(ihit.get());
            thoseHits[nFound] = otherHot;
            nFound++;
            dropThisHit = 1;
          } else {   // handle hits individually

            if (8 == tkParam.lPrint) {
              std::cout<<"handle hits individually"<<  std::endl;
            }
            nFound++;
            if (fabs(ihit->resid(0)) > fabs(otherHot->resid(0)) ) {
              // turn off (inactivate) hit on this track
              lRefit = 1;
              //              ihit->hit()->setUnusedHit(ihit.get());
              //Should I be setting inactive, or deleting the hit???????
              const_cast<TrkHitOnTrk*>(ihit.get())->setActivity(0);
              dropThisHit = 1;
              if (8 == tkParam.lPrint) {
                std::cout<<"dorp hit ";
                const_cast<TrkHitOnTrk*>(ihit.get())->print(std::cout);
              }
              break;      // found other hit, so quit loop
            } else {
              // inactivate hit on other track
              refitTrack[otherIndex] = 1;
              //              otherHot->hit()->setUnusedHit(otherHot);
              otherHot->setActivity(0);
              if (8 == tkParam.lPrint) {
                std::cout<<"inactive hit on other track";
                const_cast<TrkHitOnTrk*>(ihit.get())->print(std::cout);
              }
              break;      // found other hit, so quit loop
            }
          } // end grouped/individual treatment

          if (dropThisHit == 1) break; // don't look for other matches since
          // this hit is now turned off
        } // end loop over nUsed

        // Quit if we've found all of the shared hits on this track
        if (lGroupHits && nFound == nMost  ||  nFound == nPrev) {
          if (8 == tkParam.lPrint) {
            std::cout<<"we've found all of the shared hits on this track,Quit"<<std::endl;
          }
          break;
        }

      }  // end loop over hits

      // Decide which track grouped hits belong with and inactivate accordingly
      if (lGroupHits) {
        if (8 == tkParam.lPrint) {
          cout << "nGroup: " << nMost << "  groupDiff: " << groupDiff << endl;
          cout << "Track: " << aRecoTrk.id() << "  nHit: "
            << hitList->nHit() << "  nActive: "
            << tkFit->nActive() << " chisq/dof: " <<
            tkFit->chisq()/(tkFit->nActive() - 5) << endl;
          TrkRecoTrk& othTrack = trkXRef[trackMost]->track();
          cout << "Track: "<< othTrack.id() << "  nHit: " <<
            othTrack.hits()->nHit() << "  nActive: " <<
            othTrack.fitResult()->nActive() << " chisq/dof: " <<
            othTrack.fitResult()->chisq() /
            (othTrack.fitResult()->nActive() - 5) << endl;
        }

        if (groupDiff > 0.0) {
          // inactivate hits on this track
          lRefit = 1;
          for (int ii = 0; ii < nMost; ii++) {
            TrkHitOnTrk *alink = theseHits[ii];
            TrkFundHit* hit = const_cast<TrkFundHit*> (alink->hit());
            hitList->removeHit(hit);//yzhang 2011-02-12 
            //alink->setActivity(0);
          }
          if (8 == tkParam.lPrint) std::cout<<"inactive hits on this track, No."<<aRecoTrk.id()<<  std::endl;
        } else {
          // inactivate hits on other track
          refitTrack[trackMost] = 1;
          for (int ii = 0; ii < nMost; ii++) {
            TrkHitOnTrk *alink = thoseHits[ii];
            TrkFundHit* hit = const_cast<TrkFundHit*> (alink->hit());
            hitList->removeHit(hit);//yzhang 2011-02-12 
            //alink->setActivity(0);
          }
          if (8 == tkParam.lPrint) std::cout<<"inactive hits on other track "<<   std::endl;
        }
        delete [] theseHits;
        delete [] thoseHits;

      } // end if lGroupHits

    } // end if nMost > 0

    //*********
    // Refit this track, if any hits have been dropped
    TrkErrCode fitResult;
    long index = -1;
    idMap.get(aRecoTrk.id(), index); assert (index >= 0);

    if (lRefit || refitTrack[index] == 1) {
      if (8 == tkParam.lPrint) {
        std::cout<<"after group ,refit track"<<aRecoTrk.id()<<  std::endl;
      }
      fitResult = hitList->fit();
      aRecoTrk.status()->addHistory(
          TrkErrCode(fitResult.success()?TrkErrCode::succeed:TrkErrCode::fail,14,"Arbitrated"), "MdcTrkRecon");
      if (fitResult.failure() && (8 == tkParam.lPrint )) {
        fitResult.print(std::cerr);
      }


      double chisqperDOF;
      bool badFit = true;
      if (fitResult.success()) {
        badFit = false;
        int nDOF = tkFit->nActive() - 5;
        if (nDOF > 5){
          chisqperDOF = tkFit->chisq() / nDOF;
        }else{
          chisqperDOF = tkFit->chisq();
        }

        if (chisqperDOF > tkParam.maxChisq) badFit = true;
        if (tkFit->nActive() < tkParam.minHits) badFit = true;
        double tem2 = (float) hitList->nHit() - tkFit->nActive();
        if (tkParam.lUseQualCuts) {
          if (tem2 >= tkParam.maxNmissTrack) badFit = true;
          if (tem2 /float(hitList->nHit()) > tkParam.maxNmissNorm){
            badFit = true;
          }
        }
        if(8== tkParam.lPrint) std::cout<<"fit quality:"<<
          " chisqperDof "<<chisqperDOF<<"?>"<<tkParam.maxChisq<<
            " nActive "<<tkFit->nActive()<<"?<"<<tkParam.minHits<<
            " nHit "<<hitList->nHit()<<" nhit-act "<<tem2<<"?>= nMiss "<<tkParam.maxNmissTrack<<
            " hit-act/nhit "<<tem2/float(hitList->nHit())<<"?> MissNorm "<<tkParam.maxNmissNorm
            <<  std::endl;


      }
      if (8 == tkParam.lPrint)  {
        cout << "Refitting track " << aRecoTrk.id() << " success = "
          << fitResult.success() << "\n";
      }
      // If the track no longer passes cuts, delete it
      if (fitResult.failure() || badFit ) {
        nDeleted++;
        //  Don't change the track list while we're iterating through it!
        //      remove(atrack);
        //int id = aRecoTrk.id();
        if (8 == tkParam.lPrint) {
          cout << "fitResult.failure? "<<fitResult.failure()
            <<" badFit? "<<badFit <<" Killing tkNo " << itrack << endl;
        }
        delete &(atrack->track());    // Delete the RecoTrk inside atrack
        atrack->setTrack(0);
        trksToKill.push_back(atrack);
        continue;
      }
    } // end if lRefit

    if (lGroupHits) goto restart;

  } // end loop over tracks
  if (8 == tkParam.lPrint) std::cout<<"end of loop over tracks"<<  std::endl;

  // Remove dead track husks
  for (int itk = 0; itk < (int)trksToKill.size(); itk++) {
    remove(trksToKill[itk]);
    if (8 == tkParam.lPrint) std::cout<<"remode dead track No."<<itk<<  std::endl;
  }
  if (8 == tkParam.lPrint) std::cout<<"---end of arbitrateHits"<<  std::endl;

  delete [] usedInTrackNum;
  delete [] refitTrack;
  delete [] trkXRef;
  return nDeleted;
}

int MdcTrackListCsmc::createFromSegs	(	MdcSegList *	segs,
		const MdcHitMap *	,
		const MdcDetector *	,
		TrkContext &	,
		double	trackT0
	)			[virtual]

Implements MdcTrackListBase.

Definition at line 45 of file MdcTrackListCsmc.cxx.

References EvtCyclic3::append(), MdcSegGrouper::combineSegs(), MdcSegGrouperSt::fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), finish3d(), MdcSegList::getSeed(), MdcTrackParams::lPrint, MdcTrackParams::maxSegChisqO, TrkRecoTrk::printAll(), MdcSegList::resetSeed(), MdcTrackListBase::tkParam, and MdcTrack::track().

                                                                     {
// *************************************************************************
  // Forms tracks out of list of superlayer segments
  int nTracks = 0;
  // Create empty list of stereo segs (to save time)
  MdcSegGrouperSt stereoSegs(gm,tkParam.lPrint);
  // *** Create r-phi track

  // Create list of axial segments, treated as on straight tracks
  MdcSegGrouperCsmc straightSegs(gm, tkParam.lPrint);
  straightSegs.fillWithSegs(segs);
  //std::cout<< "after straight fill  " << std::endl; 
  //segs->plot();//yzhang debug
  MdcSeg *seed;
  int goodOnly = 1;
  MdcTrack* trialTrack = 0;
  while (1) {
    seed = segs->getSeed(0,goodOnly);
    if (seed == 0 && goodOnly == 1) {
      segs->resetSeed(gm);
      goodOnly = 0;
      continue;
    }
    else if (seed == 0 && goodOnly == 0) {
      break;
    }
    delete trialTrack;
    trialTrack = 0;            
    int success = straightSegs.combineSegs(trialTrack, seed,
                                           context, t0, tkParam.maxSegChisqO);
    if (!success) {
      //std::cout<< " MdcTrackListCsmc::combineSegs not successed!" << std::endl;
      continue;
    }

    if (tkParam.lPrint > 1) {
      trialTrack->track().printAll(cout);
    }
    // *** End r-phi track-finding

    // *** Add stereo to taste
    stereoSegs.fillWithSegs(segs, trialTrack);

    success = stereoSegs.combineSegs(trialTrack, 0, context, t0, 
                                     tkParam.maxSegChisqO);
    if (success) {
    // Finish 3-d track;
      success = finish3d(trialTrack->track());
      //      success = finish3d(trialTrack->track()); // GSciolla: try to repeat
    }  
    if (!success) {
      //std::cout<< " MdcTrackListCsmc::finish3d not successed!" << std::endl;
      continue;
    }

    if (tkParam.lPrint > 1) {
      trialTrack->track().printAll(cout);
    }

    nTracks++;
    append(trialTrack);    // Add to list of Tracks
    trialTrack = 0;
    
  }  // end while(1)   
  delete trialTrack;
  

  //cout << " Number of Tracks found= " << nTracks  ;
  //cout << " " << endl;
  return nTracks;
}

void MdcTrackListBase::dropMultiHotInLayer

(

const MdcTrack *

tk

)

[inherited]

Reimplemented in MdcTrackList.

int MdcTrackListCsmc::finish3d

(

TrkRecoTrk &

trk

)

Definition at line 120 of file MdcTrackListCsmc.cxx.

References TrkSimpleMaker< T >::changeFit(), TrkAbsFit::chisq(), TrkHitList::fit(), TrkRecoTrk::fitResult(), TrkRecoTrk::hits(), MdcTrackParams::maxChisq, MdcTrackParams::minHits, TrkFit::nActive(), TrkSimpleMaker< T >::setFlipAndDrop(), TrkErrCode::success(), and MdcTrackListBase::tkParam.

Referenced by createFromSegs().

                                              {
// ************************************************************************
  int success = 0;
  int nParamFit = 0 ;

  TrkErrCode fitResult;

  // ------------------------
  //   4 param fit (line)
  // ------------------------
  nParamFit = 4;
  TrkLineMaker makeFit;
  makeFit.changeFit(trk);
  makeFit.setFlipAndDrop(trk, true, true);
  //setCosmic(&trk);    // set hot to cosmics OBSOLETE! REMOVE!
  fitResult = trk.hits()->fit();
  makeFit.setFlipAndDrop(trk, false, false);  
  
  // ---------------------------------------------------------------
  // Are there some TDC that can be replaced with later measurements? ( beginning) 
  // ---------------------------------------------------------------
  // Note to Sciolla: multiple hits commented out for now OK! I will put it back later...
  /*  if( _flags.useMultipleHits ) { 
    int NHITS   = trk.nHit(); 
    
    if (fitResult.success()) {
      int ifirst = 0;     
      for (int ihot = 0; ihot < NHITS ; ihot++) {
        
        MdcHitOnTrack* ahot = (MdcHitOnTrack*)trk.hitAList()[ihot];
        double firstTime = ahot->mdcHit()->rawTime(0); 
        
        // Get the list of times for this Digi 
        const MdcDigi* tmpDigi = ahot->mdcHit()->digi() ; 
//      int nTDChits = tmpDigi->getTdcTimeAList()->length() ;
        int nTDChits = tmpDigi->tmdcits() ;
        
        double newTime=0. ; 
        
        for( int il = 1; il<nTDChits ; il++){ 
          
          // get the time corresponding to this doca ---> distance to time 
          newTime = tmpDigi->TdcTime(il); 
          double newDrift = ahot->layer()->timeToDistance(newTime); 
          
          double tmp_doca  = ahot->dcaToWire();
          double new_diff = fabs(fabs(tmp_doca)-fabs(newDrift)); 
          double tmp_drift = ahot->drift();
          double tmp_drift2 = 
            ahot->layer()->timeToDistance(tmpDigi->TdcTime(0)); 
          double old_diff  = fabs(fabs(tmp_doca)-fabs(tmp_drift2)); 
          
          if( ((old_diff-new_diff)>0.1)  // new time better then old of at least 1 mm  
              && (new_diff<=0.8) ) { // and newresid < 2 mm 
            //  if(_flags.debug) {                  
            if(1) { 
              
              if(ifirst==0) { 
                ifirst = 1 ; 
                cout <<" nHits | time1  |fittim | time2 | doca(mm) | drift1 " 
                     <<"  drift1(rec) | drift2 | layer | wire | isActive" 
                     << " | chi2 | nactive" << endl; 
              }
              
              int isAct = 1 ; 
              if (!ahot->isActive()) { 
                isAct = 0 ; 
                //      cout<< " >> " ;    
                //      cout << "This hit is not active " << endl ;
              }
              
              cout << "   " << nTDChits 
                   << "    " << tmpDigi->TdcTime(0) 
                   << "  " << ahot->fitTime()
                   << "  " <<  newTime  
                   << "  " << tmp_doca*10
                   << "  " << tmp_drift*10 
                   << "  " << tmp_drift2*10 
                   << "  " << newDrift*10 
                   << "  " << ahot->layer()->layNum() 
                   << "  " << ahot->wire()
                   << "  " <<  isAct 
                   << "  " << trk.chisq()
                   << "  " << trk.nActive() 
                   << endl;       
              
              cout << " old/new diff (mm) = " << old_diff*10 
                   << " | " << new_diff*10
                   << endl ; 
            }     
            
            ahot->setTimeIndex(il) ; 
            //  cout << "new rawtime =" 
            //     << ahot->mdcHit()->rawTime(0)<< endl ; // check the new value 
            
            
            // store results in ntuple to see improvements ... before ...               
            HepTuple* tupleMultHits = _manager->ntuple("multiHits");
            
            tupleMultHits->column("ch2Dof1", trk.chisq()/(trk.nActive() - 4));
            tupleMultHits->column("nActiv1", trk.nActive());
            tupleMultHits->column("resid1",ahot->resid());
            tupleMultHits->column("doca1",ahot->resid()+ahot->drift()); 
            tupleMultHits->column("time1",  ahot->fitTime() );   
            tupleMultHits->column("rawtime1",  ahot->mdcHit()->rawTime(il) ); 
            
            // - make the hit active and usable 
            ahot->setActivity(true);
            
            // now refit the track ... 
            fitResult = trk.fit();
            
            // store results in ntuple to see improvements ... after ...                
            tupleMultHits->column("ch2Dof2", trk.chisq()/(trk.nActive() - 4));
            tupleMultHits->column("nActiv2", trk.nActive());
            tupleMultHits->column("resid2",ahot->resid());
            tupleMultHits->column("doca2",ahot->resid()+ahot->drift()); 
            tupleMultHits->column("time2",  ahot->fitTime() );   
            tupleMultHits->column("rawtime2",  ahot->mdcHit()->rawTime(il) );   
            tupleMultHits->dumpData();
          }
        }
      }
    }  
  } // Are there some TDC that can be replaced with later measurements?  (end)
  */
  
  const TrkFit* tkFit = trk.fitResult();
  double chisqperDOF = 0.;
  if (fitResult.success()) {
    int nDOF = tkFit->nActive() - nParamFit;
    if (nDOF > nParamFit) 
      chisqperDOF = tkFit->chisq() / nDOF;
    else 
      chisqperDOF = tkFit->chisq();
    int goodMatch = 1;
    if (chisqperDOF > tkParam.maxChisq) goodMatch = 0;
    if (tkFit->nActive() < tkParam.minHits) goodMatch = 0;

    if (goodMatch) success = 1;
  }
  
  return success;
}

void MdcTrackListBase::newParams

(

const MdcTrackParams &

tkPar

)

[inherited]

Definition at line 588 of file MdcTrackListBase.cxx.

References MdcTrackListBase::tkParam.

                                                       {
  //**************************************************************************
  tkParam = tkPar;
}

int MdcTrackListBase::nTrack

(

)

const [inline, inherited]

Definition at line 39 of file MdcTrackListBase.h.

Referenced by MdcTrackListBase::arbitrateHits(), MdcTrackListBase::plot(), and MdcTrackListBase::store().

{return length();}

void MdcTrackListBase::plot

(

)

const [inherited]

Definition at line 92 of file MdcTrackListBase.cxx.

References MdcTrackListBase::nTrack().

                             {
  //*************************************************************************
  std::cout<< "nTrack   "<<nTrack() << std::endl;//yzhang debug
  for (int itrack = 0; itrack < nTrack(); itrack++) {
    MdcTrack *atrack = (*this)[itrack];
    if (atrack == NULL) continue;
    atrack->track().printAll(cout);
  }
}

void MdcTrackListCsmc::remove

(

MdcTrack *

atrack

)

Reimplemented from MdcTrackListBase.

void MdcTrackListBase::setD0Cut

(

double

d0Cut

)

[inline, inherited]

Definition at line 57 of file MdcTrackListBase.h.

References MdcTrackListBase::m_d0Cut.

{m_d0Cut = d0Cut;}//yzhang add 

void MdcTrackListBase::setPlot

(

int

plotFlag

)

[inline, inherited]

Definition at line 40 of file MdcTrackListBase.h.

References MdcTrackParams::lPlot, and MdcTrackListBase::tkParam.

{ tkParam.lPlot = plotFlag;};

void MdcTrackListBase::setPtCut

(

double

ptCut

)

[inline, inherited]

Definition at line 59 of file MdcTrackListBase.h.

References MdcTrackListBase::m_ptCut.

{m_ptCut = ptCut;}//yzhang add 2009-10-27

void MdcTrackListBase::setZ0Cut

(

double

z0Cut

)

[inline, inherited]

Definition at line 58 of file MdcTrackListBase.h.

References MdcTrackListBase::m_z0Cut.

{m_z0Cut = z0Cut;}//yzhang add 2010-05-21 

void MdcTrackListBase::store	(	RecMdcTrackCol *	,
		RecMdcHitCol *
	)			[inherited]

Definition at line 75 of file MdcTrackListBase.cxx.

References MdcTrackListBase::nTrack().

                                                                        {
  // ***********************************************************************
  int trackId = 0;
  for (int itrack = 0; itrack < nTrack(); itrack++) {
    MdcTrack* track = (*this)[itrack];
    //tkStat:  0,PatRec 1,MdcxReco 2,Tsf 3,CurlFinder
    int tkStat = 0;
    track->storeTrack(trackId, trackList, hitList, tkStat);
    ++trackId;
  }
  HepAListDeleteAll(*this);   // Discard the husks
  removeAll(); 
  return;
}

---

Member Data Documentation

double MdcTrackListBase::m_d0Cut = -999. [static, inherited]

Definition at line 60 of file MdcTrackListBase.h.

Referenced by MdcTrackList::createFromSegs(), MdcTrkRecon::initialize(), and MdcTrackListBase::setD0Cut().

double MdcTrackListBase::m_ptCut = -999. [static, inherited]

Definition at line 62 of file MdcTrackListBase.h.

Referenced by MdcTrackList::createFromSegs(), MdcTrkRecon::initialize(), and MdcTrackListBase::setPtCut().

double MdcTrackListBase::m_z0Cut = -999. [static, inherited]

Definition at line 61 of file MdcTrackListBase.h.

Referenced by MdcTrackList::createFromSegs(), MdcTrkRecon::initialize(), and MdcTrackListBase::setZ0Cut().

MdcTrackParams MdcTrackListBase::tkParam [protected, inherited]

Definition at line 72 of file MdcTrackListBase.h.

Referenced by MdcTrackListBase::arbitrateHits(), createFromSegs(), MdcTrackList::createFromSegs(), finish3d(), MdcTrackList::finishCircle(), MdcTrackList::finishHelix(), MdcTrackListBase::MdcTrackListBase(), MdcTrackListBase::newParams(), MdcTrackList::pickHits(), and MdcTrackListBase::setPlot().

---