MdcSeg Class Reference

#include <MdcSeg.h>

Inheritance diagram for MdcSeg:

Public Member Functions
	MdcSeg (double bunchT)
virtual	~MdcSeg ()
double	phi () const
double	slope () const
double	chisq () const
unsigned int	quality () const
const double *	errmat () const
const MdcSuperLayer *	superlayer () const
MdcSegInfo *	info () const
void	setInfo (MdcSegInfo *ptr)
void	setAmbig ()
void	setUsed ()
void	setFull ()
void	setPattern (unsigned thePatt)
int	segAmbig ()
int	segUsed ()
int	segFull ()
unsigned	segPattern () const
double	bunchTime ()
void	plotSeg () const
void	plotSegAll () const
void	setValues (int nInPatt, int nhit, MdcHit *hits[], MdcLine *span, const MdcSuperLayer *slay, int ambig[])
void	setValues (int nInPatt, double inPhi, double inSlope, double chi2, double inError[3], const MdcSuperLayer *slay)
int	addHits (MdcLine *span, MdcHit *hits[], const MdcHitMap *, double corr)
void	markHits (const MdcMap< const MdcHit *, MdcSegUsage * > &usedHits) const
void	append (MdcHitUse *)
void	remove (MdcHitUse *)
int	nHit () const
MdcHitUse *	hit (int i) const
double	testCombSeg (const MdcSeg *) const
double	testCombSegPt () const
double	testCombSegTheta () const
double	testCombSegPhi () const
double	testCombSegAmbig () const
MdcSeg &	operator= (const MdcSeg &)
	MdcSeg (const MdcSeg &)
Public Member Functions inherited from GmsListLink
	GmsListLink ()
virtual	~GmsListLink ()
GmsListLink *	next () const
GmsListLink *	prev () const

Static Public Member Functions
static MdcSegParams *	segPar ()
static void	setParam (MdcSegParams *segpar)

Additional Inherited Members
Protected Attributes inherited from GmsListLink
GmsListLink *	_next
GmsListLink *	_prev

Detailed Description

Definition at line 41 of file MdcSeg.h.

Constructor & Destructor Documentation

MdcSeg() [1/2]

MdcSeg::MdcSeg

(

double

bunchT

)

Definition at line 35 of file MdcSeg.cxx.

                        {
//------------------------------------------------------------------------
  _info = 0;
  _bunchTime = bt;
}

~MdcSeg()

MdcSeg::~MdcSeg ( )

virtual

Definition at line 42 of file MdcSeg.cxx.

                {
//------------------------------------------------------------------------
  if (_info != 0) delete _info;
  reset();  // delete Hots
}

MdcSeg() [2/2]

MdcSeg::MdcSeg

(

const MdcSeg &

other

)

Definition at line 49 of file MdcSeg.cxx.

                                 :
  GmsListLink(), _slayer(other._slayer), _phi(other._phi), _slope(other._slope),  _chisq(other._chisq), _qual(other._qual), _pattern(other._pattern), _info(other._info), _bunchTime(other._bunchTime)
 //------------------------------------------------------------------------
{  
  HepAListDeleteAll(_theList);
  for(int i=0; i<other.nHit(); i++){
    _theList.append(other.hit(i));
  }
  for(int j=0; j<3; j++){
    _errmat[0] = other._errmat[0];
    _errmat[1] = other._errmat[1];
    _errmat[2] = other._errmat[2];
  }
  segParam = other.segParam; 
}

Member Function Documentation

addHits()

int MdcSeg::addHits	(	MdcLine *	span,
		MdcHit *	hits[],
		const MdcHitMap *	,
		double	corr )

Definition at line 230 of file MdcSeg.cxx.

                 {
  //------------------------------------------------------------------------
 
  /* Pick up hits adjacent to an existing segment.  Output final number of
     hits.  Note: input hits are not refound.  It picks up hits
     in cells that the segment should pass through, checking that they
     have a plausible drift distance.  In event of a wraparound (i.e. track that
     passes through 2pi), all angles are relative to phiseg (i.e. if phiseg is
     just above 0, some phi's may be negative).  */
  //****
 
  int cell[2], ambig[2]; //wire # and ambig for cells in current layer
  double phiwire[2];
  int cellused[4] = {0}; // list of wire #'s of existing hits in span
  int lAdded = 0;
  int nhits = nHit();
  int m_debug = 0;
 
  // Note the hits already in the fit, so we don't pick them up again.
  int firstnum = superlayer()->firstLayer()->layNum();
  for (int i = 0; i < nHit(); i++) {
    const MdcHit* dHit = hit(i)->mdcHit();
    int laynum = dHit->layernumber();
    cellused[laynum - firstnum ] = dHit->wirenumber();
  }
 
  // Loop through the layers, predicting cells that could be hit.
  //  for (int layIndex = 0; layIndex < 4; layIndex++) {
  for (int layIndex = 0; layIndex < superlayer()->nLayers(); layIndex++) {
    const MdcLayer *layer = superlayer()->layer(layIndex);
    int laynum = layer->layNum();
 
    // Calc. projected phi of hit
    double rinv = 1. / layer->rMid();
    double ncellinv = 1. / (double) layer->nWires();
    double phiproj = phi() + (layer->rMid() - superlayer()->rad0()) * slope();
    // Calc. nearest wire.
    BesAngle tmp(phiproj - layer->phiOffset());
    cell[0] = (int) floor(layer->nWires() *
    tmp.rad() / twoPi + 0.5);
    cell[0] = mdcWrapWire( cell[0], layer->nWires() );
    phiwire[0] = mdcWrapAng( phi(), cell[0] * twoPi * ncellinv +
    layer->phiOffset() );
    // Which ambiguity? +1 if phi(wire) < phi(projected).
    ambig[0] = (phiwire[0] < phiproj) ? 1 : -1;
 
    // Now next nearest wire.
    ambig[1] = -ambig[0];
    cell[1] = mdcWrapWire( cell[0] + ambig[0], layer->nWires() );
    phiwire[1] = mdcWrapAng( phi(), cell[1] * twoPi * ncellinv +
    layer->phiOffset() );
 
    if(m_debug) std::cout<< " loop over the two possible wires  " << std::endl;
    //*** Loop over the two possible wires.
    for (int iroad = 0; iroad < 2; iroad++) {
      if (cellused[laynum - firstnum] == cell[iroad]) continue;
      if(m_debug) std::cout<<  "possible wires  "<<laynum<<" "<<cell[iroad]<<std::endl;
      if (map->hitWire(laynum, cell[iroad]) != 0) {
    MdcHit *ahit = map->hitWire(laynum, cell[iroad]);
    // if hit is already used, skip it!
    if (ahit->usedHit()) {
      if(m_debug) std::cout<< "hit used continue   " <<std::endl;
      continue;
    }
    // drift as delphi
    // FIXME: flip ambiguity for incoming tracks
    double phidrift = ahit->driftDist(bunchTime(), ambig[iroad]) * corr * rinv;
    double phihit = mdcWrapAng( phi(), phidrift * ambig[iroad] + ahit->phi());
 
    // Check the drift distance.
    double sigphi = corr * ahit->sigma(bunchTime(), 0) * rinv;
    // Skip hit if more than n sigma away from track.
    if ( g_nSigAdd && fabs(sigphi)>0.0001 ) { g_nSigAdd->fill(fabs(phihit - phiproj) / sigphi); }//yzhang hist cut
    if ( fabs(phihit - phiproj) > sigphi * segParam->nsigAddHit ) {
      if(m_debug) std::cout<< fabs(phihit-phiproj) <<"> add hit sigma   " 
        << sigphi<< "*"<< segParam->nsigAddHit <<"="<<sigphi*segParam->nsigAddHit<<std::endl;
      continue;
    }
 
    // Load hit for refitting
    lAdded = 1;
    span->sigma[nhits] = sigphi;
    span->x[nhits] = layer->rMid() - superlayer()->rad0();
    span->y[nhits] = mdcWrapAng(span->y[0], phihit);
 
    // Add this hit to segment
    MdcHitUse *alink = new MdcHitUse(*ahit, superlayer()->rad0(),
        ambig[iroad]);
    append(alink);
    //std::cout<< __FILE__ << "   " << __LINE__ << " addhit  "<<std::endl;
 
    nhits++;
      }  // end if hit wire
 
    } // end loop over 2 cells
 
  } // end layer loop
 
  if (lAdded) {
    span->fit(nhits);
    BesAngle tmpAngle(span->intercept);
    span->intercept = tmpAngle;
    _phi = span->intercept;
    _slope = span->slope;
    _chisq = span->chisq;
    _errmat[0] = span->errmat[0];
    _errmat[1] = span->errmat[1];
    _errmat[2] = span->errmat[2];
  }
 
  return nhits;
}

append()

void MdcSeg::append

(

MdcHitUse *

theHitUse

)

Definition at line 353 of file MdcSeg.cxx.

                                   {
  //------------------------------------------------------------------------
  _theList.append(theHitUse);
}

Referenced by addHits(), and setValues().

bunchTime()

double MdcSeg::bunchTime ( )

inline

Definition at line 62 of file MdcSeg.h.

{return _bunchTime;}

Referenced by addHits(), and MdcSegInfoSterO::calcStereo().

chisq()

double MdcSeg::chisq ( ) const

inline

Definition at line 48 of file MdcSeg.h.

{return _chisq;}

Referenced by plotSegAll().

errmat()

const double * MdcSeg::errmat ( ) const

inline

Definition at line 50 of file MdcSeg.h.

{return _errmat;}

Referenced by MdcSegInfoAxialO::calcFromOrigin(), MdcSegInfoSterO::calcStereo(), and MdcSegInfoCsmc::calcStraight().

hit()

MdcHitUse * MdcSeg::hit ( int i ) const

inline

Definition at line 77 of file MdcSeg.h.

{return _theList[i];}

Referenced by addHits(), MdcSegGrouper::calcParByHits(), MdcSegInfoSterO::calcStereo(), MdcTrkRecon::fillSegList(), MdcSegList::getSeed(), plotSeg(), plotSegAll(), testCombSeg(), testCombSegAmbig(), testCombSegPhi(), testCombSegPt(), testCombSegTheta(), and MdcSegGrouper::transferHits().

info()

MdcSegInfo * MdcSeg::info ( ) const

inline

Definition at line 52 of file MdcSeg.h.

{return _info;}

Referenced by MdcSegGrouper::calcParByHits(), MdcSegGrouper::calcParBySegs(), MdcSegGrouper::combineSegs(), MdcTrackList::createFromSegs(), MdcSegGrouperAx::fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), MdcSegGrouperSt::incompWithGroup(), MdcSegGrouperAx::incompWithSeg(), MdcSegGrouperCsmc::incompWithSeg(), plotSeg(), and plotSegAll().

markHits()

void MdcSeg::markHits

(

const MdcMap< const MdcHit *, MdcSegUsage * > &

usedHits

)

const

Definition at line 148 of file MdcSeg.cxx.

                                                                         {
  //------------------------------------------------------------------------
  for (int i = 0; i < nHit(); i++) {
    MdcHitUse *alink = _theList[i];
    MdcSegUsage *x ;
    if ( usedHits.get( alink->mdcHit() , x) ) x->setUsedAmbig( alink->ambig() );
  }
}

nHit()

int MdcSeg::nHit

(

)

const

Definition at line 368 of file MdcSeg.cxx.

                   {
  //------------------------------------------------------------------------
  return _theList.length();
}

Referenced by addHits(), MdcSegGrouper::calcParByHits(), MdcSegGrouper::calcParBySegs(), MdcSegInfoSterO::calcStereo(), MdcTrkRecon::fillSegList(), MdcSegList::getSeed(), MdcSegGrouperAx::incompWithSeg(), markHits(), plotSeg(), plotSegAll(), testCombSeg(), testCombSegAmbig(), testCombSegPhi(), testCombSegPt(), testCombSegTheta(), and MdcSegGrouper::transferHits().

operator=()

MdcSeg & MdcSeg::operator=

(

const MdcSeg &

other

)

Definition at line 67 of file MdcSeg.cxx.

                                       {
  //------------------------------------------------------------------------
  if(&other != this){
 
    HepAListDeleteAll(_theList);
    for(int i=0; i<other.nHit(); i++){
      _theList.append(other.hit(i));
    }
    _slayer = other._slayer;
    _phi = other._phi;
    _slope= other._slope;
    _errmat[0] = other._errmat[0];
    _errmat[1] = other._errmat[1]; 
    _errmat[2] = other._errmat[2];
    _chisq = other._chisq;
    _qual = other._qual;
    _pattern = other._pattern;
    _info = other._info;
    _bunchTime = other._bunchTime;
    segParam = other.segParam; 
  }
 
  return *this;
}

phi()

double MdcSeg::phi ( ) const

inline

Definition at line 46 of file MdcSeg.h.

{return _phi;}

Referenced by addHits(), MdcSegInfoAxialO::calcFromOrigin(), MdcSegInfoSterO::calcStereo(), MdcSegInfoCsmc::calcStraight(), MdcSegGrouperSt::fillWithSegs(), and plotSegAll().

plotSeg()

void MdcSeg::plotSeg

(

)

const

Definition at line 194 of file MdcSeg.cxx.

                      {
  //------------------------------------------------------------------------
  std::cout<<superlayer()->slayNum()<<" pat"<<segPattern()<<" ";
  for (int ihit=0 ; ihit< nHit() ; ihit++){
    hit(ihit)->mdcHit()->print(std::cout);//print hit
    std::cout <<hit(ihit)->ambig()<<" ";
  }
  if (info()!=NULL){
    cout<< " . "; 
  }
  //std::cout << std::endl;
}

Referenced by MdcSegInfoSterO::calcStereo(), MdcSegGrouperSt::fillWithSegs(), and MdcSegGrouperSt::incompWithGroup().

plotSegAll()

void MdcSeg::plotSegAll

(

)

const

Definition at line 159 of file MdcSeg.cxx.

                         {
  //------------------------------------------------------------------------
  //print hit
  //if(superlayer()!=NULL) std::cout<<"sl"<<superlayer()->slayNum()<<" p"<<segPattern()<<" st"<<quality();
  for (int ihit=0 ; ihit< nHit() ; ihit++){
    hit(ihit)->mdcHit()->print(std::cout);
    std::cout << setw(2)<<hit(ihit)->ambig()<<" ";
  }
 
  cout<<setiosflags(ios::fixed);
  if (info()!=NULL){
    std::cout<< " phi " << setprecision(2) << phi()
      << " slope " <<std::setw(2)<< setprecision(2) <<slope()<<" ";
    if(superlayer()->whichView()==0){
      std::cout <<setprecision (2) <<"phi0="<<info()->par(0);
      cout<<setprecision(5)<<" cpa="<<info()->par(1);
    }else{
      std::cout <<setprecision(2)<<"z0="<<info()->par(0)
    <<setprecision(2)<<" ct="<<info()->par(1);
    }
    if(fabs(info()->arc())>0.0001){
      std::cout<<setprecision(2)<<" arc="<<info()->arc();
    }
    std::cout<<setprecision(3)<<" chi2="<<_chisq;
  }else{
    std::cout<< " phi " << setprecision(2) << phi()
      << " slope " <<std::setw(2)<< setprecision(2) <<slope()
      << " chi2 "<<setprecision(3) <<chisq();
  }
 
  cout<<setprecision(6);
  cout<<setiosflags(ios::scientific);
}

Referenced by MdcSegGrouper::combineSegs(), MdcTrackList::dumpSeed(), MdcSegGrouperAx::incompWithSeg(), MdcSegList::plot(), and MdcSegGrouper::transferHits().

quality()

unsigned int MdcSeg::quality ( ) const

inline

Definition at line 49 of file MdcSeg.h.

{return _qual;}

Referenced by MdcSegGrouperAx::incompWithSeg().

remove()

void MdcSeg::remove

(

MdcHitUse *

theHitUse

)

Definition at line 360 of file MdcSeg.cxx.

                                   {
  //------------------------------------------------------------------------
  _theList.remove(theHitUse);
  delete theHitUse;
}

segAmbig()

int MdcSeg::segAmbig ( )

inline

Definition at line 58 of file MdcSeg.h.

{return (_qual & segAmbigFlag);}

segFull()

int MdcSeg::segFull ( )

inline

Definition at line 60 of file MdcSeg.h.

{return (_qual & segFullFlag);}

segPar()

static MdcSegParams * MdcSeg::segPar ( )

inlinestatic

Definition at line 79 of file MdcSeg.h.

{return segParam;}

Referenced by MdcSegGrouperSt::fillWithSegs(), MdcSegGrouperSt::incompWithGroup(), and MdcSegList::setPlot().

segPattern()

unsigned MdcSeg::segPattern ( ) const

inline

Definition at line 61 of file MdcSeg.h.

{return _pattern;}

Referenced by plotSeg().

segUsed()

int MdcSeg::segUsed ( )

inline

Definition at line 59 of file MdcSeg.h.

{return (_qual & segUsedFlag);}

setAmbig()

void MdcSeg::setAmbig ( )

inline

Definition at line 54 of file MdcSeg.h.

{_qual |= segAmbigFlag;}

setFull()

void MdcSeg::setFull ( )

inline

Definition at line 56 of file MdcSeg.h.

{_qual |= segFullFlag;}

setInfo()

void MdcSeg::setInfo

(

MdcSegInfo *

ptr

)

Definition at line 96 of file MdcSeg.cxx.

                                   {
  //------------------------------------------------------------------------
  delete _info;  // if any
  _info = newInfo;
}

Referenced by MdcSegGrouperAx::fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), and MdcSegGrouperSt::fillWithSegs().

setParam()

static void MdcSeg::setParam ( MdcSegParams * segpar )

inlinestatic

Definition at line 80 of file MdcSeg.h.

{segParam = segpar;}

Referenced by MdcSegList::MdcSegList().

setPattern()

void MdcSeg::setPattern ( unsigned thePatt )

inline

Definition at line 57 of file MdcSeg.h.

{_pattern = thePatt;}

setUsed()

void MdcSeg::setUsed ( )

inline

Definition at line 55 of file MdcSeg.h.

{_qual |= segUsedFlag;}

Referenced by MdcSegGrouper::transferHits().

setValues() [1/2]

void MdcSeg::setValues	(	int	nInPatt,
		double	inPhi,
		double	inSlope,
		double	chi2,
		double	inError[3],
		const MdcSuperLayer *	slay )

Definition at line 128 of file MdcSeg.cxx.

                                                               {
  //------------------------------------------------------------------------
  // Sets segment values with no associated hits
  _qual = 0;
  if (nInPatt == 4) _qual |= segFullFlag;
  _phi = inPhi;
  _slope = inSlope;
  _chisq = chi2;
  _errmat[0] = inError[0];
  _errmat[1] = inError[1];
  _errmat[2] = inError[2];
  _slayer = slay;
  reset();  // clears hit list
 
  return;
}

setValues() [2/2]

void MdcSeg::setValues	(	int	nInPatt,
		int	nhit,
		MdcHit *	hits[],
		MdcLine *	span,
		const MdcSuperLayer *	slay,
		int	ambig[] )

Definition at line 104 of file MdcSeg.cxx.

                                                           {
  //------------------------------------------------------------------------
  _qual = 0;
  if (nInPatt == 4) _qual |= segFullFlag;
  _phi = BesAngle(span->intercept);
  _slope = span->slope;
  _chisq = span->chisq;
  _errmat[0] = span->errmat[0];
  _errmat[1] = span->errmat[1];
  _errmat[2] = span->errmat[2];
  reset();
  _slayer = slay;
  for (int i = 0; i < nhit; i++) {
    MdcHitUse *alink = new MdcHitUse(*(hits[i]), superlayer()->rad0(),
    ambig[i]);
    append(alink);
  }
 
  return;
}

slope()

double MdcSeg::slope ( ) const

inline

Definition at line 47 of file MdcSeg.h.

{return _slope;}

Referenced by addHits(), MdcSegInfoAxialO::calcFromOrigin(), MdcSegInfoSterO::calcStereo(), MdcSegInfoCsmc::calcStraight(), and plotSegAll().

superlayer()

const MdcSuperLayer * MdcSeg::superlayer ( ) const

inline

Definition at line 51 of file MdcSeg.h.

{return _slayer;}

Referenced by addHits(), MdcSegList::append(), MdcSegInfoAxialO::calcFromOrigin(), MdcSegInfoSterO::calcStereo(), MdcSegInfoCsmc::calcStraight(), MdcSegGrouperAx::fillWithSegs(), MdcSegGrouperCsmc::fillWithSegs(), MdcSegGrouperSt::fillWithSegs(), MdcSegGrouperAx::incompWithSeg(), plotSeg(), plotSegAll(), MdcSegGrouperAx::resetComb(), MdcSegGrouperCsmc::resetComb(), and setValues().

testCombSeg()

double MdcSeg::testCombSeg

(

const MdcSeg *

testSeg

)

const

Definition at line 376 of file MdcSeg.cxx.

                                             {
  //------------------------------------------------------------------------
  int tkId= -1;
  for (int i=0; i<nHit(); i++){
    const MdcHit* h = hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    //std::cout<< __FILE__ << " ref  " << i << " haveDigiTk("<<l<<","<<w<<")"<<haveDigiTk[l][w]<<std::endl;
    if ( haveDigiTk[l][w]<0 || haveDigiTk[l][w]>100 ) continue;
    if (tkId<0){
      tkId = haveDigiTk[l][w];
    }else if (haveDigiTk[l][w] != tkId){
      return -1;//hits in this seg not in same mc track
    }
  }//end for
 
  double nSame = 0.;
  for (int i=0; i<testSeg->nHit(); i++){
    const MdcHit* h = testSeg->hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    if (haveDigiTk[l][w] == tkId){
      ++nSame;
    }
  }
 
  return nSame/testSeg->nHit();
}

Referenced by MdcSegGrouperAx::incompWithSeg().

testCombSegAmbig()

double MdcSeg::testCombSegAmbig

(

)

const

Definition at line 458 of file MdcSeg.cxx.

                             {
  //------------------------------------------------------------------------
  double ambigOk = 0.;
  for (int i=0; i<nHit(); i++){
    const MdcHit* h = hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    if( hit(i)->ambig() == haveDigiAmbig[l][w] ) ambigOk++;
  }//end for
 
  return ambigOk/nHit();
}

Referenced by MdcSegGrouperAx::incompWithSeg().

testCombSegPhi()

double MdcSeg::testCombSegPhi

(

)

const

Definition at line 441 of file MdcSeg.cxx.

                           {
  //------------------------------------------------------------------------
  double truthPhi = -999.;
  for (int i=0; i<nHit(); i++){
    const MdcHit* h = hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    if ( haveDigiPhi[l][w]<-998. ) continue;
    //std::cout<< __FILE__ << "   " << __LINE__ << "   haveDigiPhi("<<l<<","<<w<<")"<<haveDigiPhi[l][w]<<std::endl;
    if (truthPhi<-998.){ truthPhi = haveDigiPhi[l][w]; }
  }//end for
 
  return truthPhi;
}

testCombSegPt()

double MdcSeg::testCombSegPt

(

)

const

Definition at line 407 of file MdcSeg.cxx.

                          {
  //------------------------------------------------------------------------
  double truthPt = -1.;
  for (int i=0; i<nHit(); i++){
    const MdcHit* h = hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    if ( haveDigiPt[l][w]<0 ) continue;
    //std::cout<< __FILE__ << "   " << __LINE__ << "   haveDigiPt("<<l<<","<<w<<")"<<haveDigiPt[l][w]<<std::endl;
    if (truthPt<0){ truthPt = haveDigiPt[l][w]; }
  }//end for
 
  return truthPt;
}

Referenced by MdcSegGrouperAx::incompWithSeg().

testCombSegTheta()

double MdcSeg::testCombSegTheta

(

)

const

Definition at line 424 of file MdcSeg.cxx.

                             {
  //------------------------------------------------------------------------
  double truthTheta = -999.;
  for (int i=0; i<nHit(); i++){
    const MdcHit* h = hit(i)->mdcHit();
    unsigned int l = h->layernumber();
    unsigned int w = h->wirenumber();
    if ( haveDigiTheta[l][w]<-998. ) continue;
    //std::cout<< __FILE__ << "   " << __LINE__ << "   haveDigiTheta("<<l<<","<<w<<")"<<haveDigiTheta[l][w]<<std::endl;
    if (truthTheta<-998.){ truthTheta = haveDigiTheta[l][w]; }
  }//end for
 
  return truthTheta;
}

Referenced by MdcSegGrouperAx::incompWithSeg().

---

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

• MdcSeg.h
• MdcSeg.cxx