MdcSegData Class Reference

#include <MdcSegData.h>

Public Types
typedef MdcMap< const MdcHit *, MdcSegUsage * >	MdcHitDict

Public Member Functions
	MdcSegData (bool skipUsedHit)
virtual	~MdcSegData ()
int	nevent () const
int	nhits () const
int	runNumber () const
const MdcHit *	hit (int hitno) const
const MdcHitDict &	segUsage () const
const MdcHitMap *	hitMap () const
void	loadevent (MdcHitCol *col, MdcHitMap *hmap, double tbunch)
double	bunchTime (void) const
bool	skippingUsed () const
void	poisonHits (const MdcDetector *gm, int debug=0)

Detailed Description

Definition at line 26 of file MdcSegData.h.

Member Typedef Documentation

MdcHitDict

typedef MdcMap<const MdcHit*,MdcSegUsage*> MdcSegData::MdcHitDict

Definition at line 29 of file MdcSegData.h.

Constructor & Destructor Documentation

MdcSegData()

MdcSegData::MdcSegData

(

bool

skipUsedHit

)

Definition at line 16 of file MdcSegData.cxx.

{
  eventNumber=0;
  _segUsage = 0;
  _hitMap = 0;
  _bunchTime = 0;
  _skipUsed = skip;
 
  _theHits = 0;
}

~MdcSegData()

MdcSegData::~MdcSegData ( void  )

virtual

Definition at line 29 of file MdcSegData.cxx.

                            {
//------------------------------------------------------------------------
  delete [] _segUsage;
}

Member Function Documentation

bunchTime()

double MdcSegData::bunchTime ( void  ) const

inline

Definition at line 41 of file MdcSegData.h.

{return _bunchTime;}

hit()

const MdcHit * MdcSegData::hit

(

int

hitno

)

const

Definition at line 73 of file MdcSegData.cxx.

                               {
//------------------------------------------------------------------------
return (*_theHits)[hitno];
}

hitMap()

const MdcHitMap * MdcSegData::hitMap ( ) const

inline

Definition at line 39 of file MdcSegData.h.

{return _hitMap;}

Referenced by poisonHits().

loadevent()

void MdcSegData::loadevent	(	MdcHitCol *	col,
		MdcHitMap *	hmap,
		double	tbunch
	)

Definition at line 43 of file MdcSegData.cxx.

                                                                     {
//------------------------------------------------------------------------
  _bunchTime = tb;
  _theHits   = hitcol;
  _hitMap    = hitmap;
  assert (_hitMap != 0);
 
  _segUsageDict.clear();
  delete [] _segUsage;
  _segUsage = 0;
  eventNumber++;
 
  _segUsage = new MdcSegUsage[nhits()];
 
  MdcHit* aHit = 0;
  MdcHitCol::iterator iter = _theHits->begin();
  int index = 0;
  for (;iter != _theHits->end(); iter++) {
    aHit = *iter;
    _segUsageDict.put(aHit, &(_segUsage[index]));
    if (skippingUsed() && aHit->usedHit()) {
      // Mark for later skipping
      _segUsage[index].killHit();
    }
    index++;
  }
}

nevent()

int MdcSegData::nevent ( ) const

inline

Definition at line 34 of file MdcSegData.h.

{return eventNumber;}

nhits()

int MdcSegData::nhits

(

)

const

Definition at line 36 of file MdcSegData.cxx.

                        {
//------------------------------------------------------------------------
  return _theHits->size();
}

Referenced by loadevent().

poisonHits()

void MdcSegData::poisonHits	(	const MdcDetector *	gm,
		int	debug = 0
	)

Definition at line 81 of file MdcSegData.cxx.

                                                       {
//------------------------------------------------------------------------
  // Mark hits as poor candidates for segment-finding, if they are located 
  //  within a string of consecutive hits in the same layer (end hits are 
  //  not marked).
  for (int ilayer = 0; ilayer < gm->nLayer(); ilayer++) {
    int nwire = gm->Layer(ilayer)->nWires();
    for (int iwire=0; iwire < nwire;++iwire) {
      int wireNext = mdcWrapWire(iwire+1, nwire);
      if ( 0 == hitMap()->hitWire(ilayer, wireNext) ) { 
              //                        0 1 2 3 4
              // next wire not there:   ? o ? ? ?
              // so the next-to-next wire shouldn't be poisened 
              // (it's left neighbour is empty)
              // and the next candidate to check is + 3
              iwire+=2; continue;
      }
 
      MdcHit* theHit = hitMap()->hitWire(ilayer, iwire);
      if (theHit == 0) { 
              //                                        0 1 2 3 4
              // next wire is there, this one isn't :   o x ? ? ?
              // and the next candidate to check is + 2
              ++iwire; continue;
      }
 
      int wirePrev = mdcWrapWire(iwire-1, nwire);
      if ( 0 != hitMap()->hitWire(ilayer, wirePrev)) { 
      segUsage().get(theHit)->killHit();
      if(debug>1){
        theHit->print(std::cout);
        std::cout<< " killed " << std::endl;
      }
      }else{
    if(debug>1){
      theHit->print(std::cout);
      std::cout<< " ok " << std::endl;
    }
      }
    }      // end wire loop
  }        // end layer loop
 
  return;
}

runNumber()

int MdcSegData::runNumber ( ) const

inline

Definition at line 36 of file MdcSegData.h.

{return _runNumber;}

segUsage()

const MdcHitDict & MdcSegData::segUsage ( ) const

inline

Definition at line 38 of file MdcSegData.h.

{return _segUsageDict;}

Referenced by poisonHits().

skippingUsed()

bool MdcSegData::skippingUsed ( ) const

inline

Definition at line 42 of file MdcSegData.h.

{return _skipUsed;}

Referenced by loadevent().

---

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

• MdcSegData.h
• MdcSegData.cxx