MdcSegFinder Class Reference

#include <MdcSegFinder.h>

Public Member Functions
	MdcSegFinder (int useAllAmbig)
	~MdcSegFinder ()
int	createSegs (const MdcDetector *gm, MdcSegList &segs, const MdcMap< const MdcHit *, MdcSegUsage * > &usedHits, const MdcHitMap *map, double tbunch)
MdcSegPatterns *	thePattList ()

Detailed Description

Definition at line 36 of file MdcSegFinder.h.

Constructor & Destructor Documentation

MdcSegFinder()

MdcSegFinder::MdcSegFinder

(

int

useAllAmbig

)

Definition at line 60 of file MdcSegFinder.cxx.

                                          :
  patternList(useAllAmbig) {
    //-------------------------------------------------------------------------
 
  }

~MdcSegFinder()

MdcSegFinder::~MdcSegFinder ( )

inline

Definition at line 40 of file MdcSegFinder.h.

{ };

Member Function Documentation

createSegs()

int MdcSegFinder::createSegs	(	const MdcDetector *	gm,
		MdcSegList &	segs,
		const MdcMap< const MdcHit *, MdcSegUsage * > &	usedHits,
		const MdcHitMap *	map,
		double	tbunch
	)

Definition at line 67 of file MdcSegFinder.cxx.

                      {
  //-------------------------------------------------------------------------
  // Forms all possible Segs of hits to act as candidate tracks
  // Construct group of 8 hits; translate hit wires into bit-mapped word
  // and look up valid patterns (if any) for this group.
 
  _addHits = segs.segPar()->addHits;
  int nSegs = 0;
  int newSegs;
  unsigned int groupWord;
  MdcHit *groupHits[8];
  int lPrevHit = 0;  // flags that 2nd layer was hit in last group
  //which layer/wire to look at for each hit in group
  static const int layerWire[8][2] =
  { { 0,  -1}, { 0,  0}, { 1,  0}, { 2,  -1},
    { 2,  0}, { 3, -1}, { 3,  0}, { 3,  1} };
 
  // Loop through the superlayers
  const MdcSuperLayer *slayer = gm->firstSlay();
  while (slayer != 0) {
    const MdcLayer *layArray[4];
    int wireIndex[4];
 
 
    //    layArray[0] = slayer->firstLayer();
    //    for (int i = 1; i < 4; i++) layArray[i] = gm->nextLayer(layArray[i-1]);
    int nslay = slayer->nLayers();
    for (int i = 0; i < nslay; i++) layArray[i] = slayer->layer(i);
    if(nslay != 4) layArray[3] = 0;
 
 
    //    std::cout<<"-------------super layer----- "<<slayer->Id() << " nlayer "<<nslay<<std::endl;
    //for (int i = 0; i < nslay; i++) std::cerr<<layArray[i]->Id()<<" "<<layArray[i]->nWires()<<"\n";
    //slayer = slayer->next();continue;
 
 
 
    // Loop over cells (index refers to cells in 2nd layer of superlayer)
    for (int cellIndex = 0; cellIndex < layArray[1]->nWires(); cellIndex++) {
      //yzhang change FIXME     
      double phi = layArray[1]->getWire(cellIndex)->phiE();
      for(int i = 0; i < 4; i++ ) {
    wireIndex[i] = cellIndex;
    if ( slayer->slayNum() > 4) continue;//nWires over No.4 slayer is uniform
    if ( (slayer->slayNum() > 9) && (i==3) ) break;//stop when get last layer
    if ( i == 1 ) continue;
    if ( i == 3 ) phi = layArray[2]->getWire(wireIndex[2])->phiE();
    BesAngle tmp(phi - layArray[i]->phiEPOffset());
    int wlow = (int)floor(layArray[i]->nWires() * tmp.rad() / twopi );
    int wbig = (int)ceil(layArray[i]->nWires() * tmp.rad() / twopi );
    if (tmp == 0 ){
      wlow = -1;
      wbig = 1;
    }
    if ( i!=3 ) {
      wireIndex[i]=wbig;
    }else{
      wireIndex[i]= wlow;
    }
    //zhangy change                                   
    wireIndex[i] = mdcWrapWire(wireIndex[i], layArray[i]->nWires());
      }
      // Form group of 8 wires
      groupWord = 0u;
      unsigned bitWord = 1u;
      int nGroup = 0;
      for (int ii = 0; ii < 8; ii++) {
    groupHits[ii] = 0;
    //-----------------------------
    if(layArray[ layerWire[ii][0] ] == 0) continue;
    //-----------------------------
    int laynum = layArray[ layerWire[ii][0] ]->layNum();
    int wire = wireIndex[ layerWire[ii][0] ] + layerWire[ii][1];
    wire = mdcWrapWire(wire, layArray[ layerWire[ii][0] ]->nWires());  //handle wrap-around
    MdcHit* thisHit = map->hitWire(laynum, wire);
    if (thisHit != 0) {
      if ( !usedHits.get(thisHit)->deadHit() ) {
        groupHits[ii] = thisHit;
        groupWord |= bitWord;
        nGroup++;
      } else {
        //      cout << "Skipping hit " << endl;
      }
    }
    // Quit if no hits in 1st 2 layers or 1 hit in 3 layers
    if ( (ii == 2 && nGroup < 1) || (ii == 4 && nGroup < 2) ) break;
    bitWord <<= 1;
      }
      if (nGroup < 3) continue;
 
      //int lastWire = mdcWrapWire(cellIndex - 1, layArray[1]->nWires());//2011-08-10 
      int lastWire = mdcWrapWire(cellIndex - 1, layArray[0]->nWires());
      if (map->hitWire(layArray[1]->layNum(), lastWire) != 0) lPrevHit = 1;
      //      if (layArray[1]->hitWire(lastWire) != 0) lPrevHit = 1;
      else lPrevHit = 0;
 
      // Try all allowed 4-hit patterns for this group (if any)
      int nPatt = patternList.npatt4[groupWord];
 
      if ((layArray[1]->layNum()==5) && (cellIndex ==46)) {
    for(int i=0;i<4;i++){
      //std::cout<<__FILE__<<" "<<__LINE__<<"====("<<layArray[i]->layNum()<<","<< wireIndex[i]<<")" << std::endl;
    }
    //std::cout<<__FILE__<<" "<<__LINE__<< " groupWord:"<<groupWord<<" nPatt:"<<nPatt<< std::endl;
      }
 
      if (nPatt > 0) {
    newSegs = tryPatterns(groupHits, groupWord, 4, lPrevHit, nPatt,
        patternList.allowedPatt4[groupWord], slayer, segs, usedHits, map,
        bunchTime);
    nSegs += newSegs;
      }
 
 
      // If unsuccessful, try 3-hit patterns ???? may want to try 2nd pass here
      if (!segs.segPar()->find3[slayer->index()]) continue;
      int nUnused = 0;
      for (int i = 0; i < 8; i++) {
    if (groupHits[i] != 0) {
      if (usedHits.get(groupHits[i])->usedSeg() == 0) nUnused++;
    }
      }
      if (nUnused > 0) {
    nPatt = patternList.npatt3[groupWord];
    if (nPatt > 0) {
 
      newSegs = tryPatterns(groupHits, groupWord, 3, lPrevHit, nPatt,
          patternList.allowedPatt3[groupWord], slayer, segs, usedHits, map,
          bunchTime); 
      nSegs += newSegs;
    }
      }
    }  // cellIndex loop
 
    slayer = slayer->next();
  }   //superlayer loop
 
  if (nSegs > 0) {
    segs.massageSegs();
    segs.resetSeed(gm);
  }
 
  nSegs = segs.count();
 
  if (5 == segs.segPar()->lPrint){ 
    cout << "Number of Segs found: " << nSegs << "\n";
  }
 
  return nSegs;
}

thePattList()

MdcSegPatterns * MdcSegFinder::thePattList ( )

inline

Definition at line 43 of file MdcSegFinder.h.

{return &patternList;}

---

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

• MdcSegFinder.h
• MdcSegFinder.cxx