CSCCathodeLCTAnalyzer Class Reference

#include <CSCCathodeLCTAnalyzer.h>

Public Member Functions
	CSCCathodeLCTAnalyzer ()
std::vector< CSCCathodeLayerInfo >	getSimInfo (const CSCCLCTDigi &clct, const CSCDetId &clctId, const CSCComparatorDigiCollection *compdc, const edm::PSimHitContainer *allSimHits)
double	getStripPhi (const CSCDetId &layerId, const float strip)
int	nearestHS (const std::vector< CSCCathodeLayerInfo > &allLayerInfo, double &closestPhi, double &closestEta)
void	setGeometry (const CSCGeometry *geom)

Static Public Member Functions
static void	setDebug ()
static void	setNoDebug ()

Private Member Functions
void	digiSimHitAssociator (CSCCathodeLayerInfo &info, const edm::PSimHitContainer *allSimHits)
std::vector< CSCCathodeLayerInfo >	lctDigis (const CSCCLCTDigi &clct, const CSCDetId &clctId, const CSCComparatorDigiCollection *compdc)
int	preselectDigis (const int clct_bx, const CSCDetId &layerId, const CSCComparatorDigiCollection *compdc, std::vector< CSCComparatorDigi > &digiMap, int hfstripDigis[CSCConstants::NUM_HALF_STRIPS], int time[CSCConstants::MAX_NUM_STRIPS], int comp[CSCConstants::MAX_NUM_STRIPS], int digiNum[CSCConstants::MAX_NUM_STRIPS])

Private Attributes
const CSCGeometry *	geom_

Static Private Attributes
static bool	debug = true
static bool	doME1A = false

Detailed Description

Class for Monte Carlo studies of cathode LCTs. Returns a vector of up to six (one per layer) CSCCathodeLayerInfo objects for a given CLCT. They contain the list of comparator digis used to build a given CLCT, and the list of associated (closest) SimHits.

Author

Slava Valuev 26 May 2004. Porting from ORCA by S. Valuev in September 2006.

Definition at line 25 of file CSCCathodeLCTAnalyzer.h.

Constructor & Destructor Documentation

CSCCathodeLCTAnalyzer()

CSCCathodeLCTAnalyzer::CSCCathodeLCTAnalyzer ( )

inline

Default constructor.

Definition at line 28 of file CSCCathodeLCTAnalyzer.h.

{};

Member Function Documentation

digiSimHitAssociator()

void CSCCathodeLCTAnalyzer::digiSimHitAssociator ( CSCCathodeLayerInfo &  info, const edm::PSimHitContainer *  allSimHits  )

private

Definition at line 225 of file CSCCathodeLCTAnalyzer.cc.

                                                                                                                 {
  // This routine matches up the closest simHit to every digi on a given layer.
  // Note that it is possible to have up to 2 digis contribute to an LCT
  // on a given layer. In a primitive algorithm used now more than one digi on
  // a layer can be associated with the same simHit.
  vector<PSimHit> simHits;
 
  vector<CSCComparatorDigi> thisLayerDigis = info.getRecDigis();
  if (!thisLayerDigis.empty()) {
    CSCDetId layerId = info.getId();
    bool me11 = (layerId.station() == 1) && (layerId.ring() == 1);
 
    // Get simHits in this layer.
    for (edm::PSimHitContainer::const_iterator simHitIt = allSimHits->begin(); simHitIt != allSimHits->end();
         simHitIt++) {
      // Find detId where simHit is located.
      CSCDetId hitId = (CSCDetId)(*simHitIt).detUnitId();
      if (hitId == layerId)
        simHits.push_back(*simHitIt);
      if (me11) {
        CSCDetId layerId_me1a(layerId.endcap(), layerId.station(), 4, layerId.chamber(), layerId.layer());
        if (hitId == layerId_me1a)
          simHits.push_back(*simHitIt);
      }
    }
 
    if (!simHits.empty()) {
      ostringstream strstrm;
      if (debug) {
        strstrm << "\nLayer " << layerId.layer() << " has " << simHits.size() << " SimHit(s); phi value(s) = ";
      }
 
      // Get the strip number for every digi and convert to phi.
      for (vector<CSCComparatorDigi>::iterator prd = thisLayerDigis.begin(); prd != thisLayerDigis.end(); prd++) {
        double deltaPhiMin = 999.;
        double bestHitPhi = 999.;
        PSimHit* bestHit = nullptr;
 
        int strip = prd->getStrip();
        double digiPhi = getStripPhi(layerId, strip - 0.5);
 
        const CSCLayer* csclayer = geom_->layer(layerId);
        for (vector<PSimHit>::iterator psh = simHits.begin(); psh != simHits.end(); psh++) {
          // Get the local phi for the simHit.
          LocalPoint hitLP = psh->localPosition();
          GlobalPoint hitGP = csclayer->toGlobal(hitLP);
          double hitPhi = hitGP.phi();
          if (debug)
            strstrm << hitPhi << " ";
          // Find the lowest deltaPhi and store the associated simHit.
          // Check to see if comparison is on pi border, and if so, make
          // corrections.
          double deltaPhi = 999.;
          if (fabs(hitPhi - digiPhi) < M_PI) {
            deltaPhi = fabs(hitPhi - digiPhi);
          } else {
            if (debug)
              LogDebug("digiSimHitAssociator") << "SimHit and Digi are close to edge!!!";
            deltaPhi = fabs(fabs(hitPhi - digiPhi) - 2. * M_PI);
          }
          if (deltaPhi < deltaPhiMin) {
            deltaPhiMin = deltaPhi;
            bestHit = &(*psh);
            bestHitPhi = hitPhi;
          }
        }
        if (debug) {
          strstrm << "\nDigi Phi: " << digiPhi << ", closest SimHit phi: " << bestHitPhi
                  << ", particle type: " << bestHit->particleType();
        }
        info.addComponent(*bestHit);
      }
      if (debug) {
        LogTrace("digiSimHitAssociator") << strstrm.str();
      }
    }
  }
}

References CSCDetId::chamber(), debug, SiPixelRawToDigiRegional_cfi::deltaPhi, CSCDetId::endcap(), info(), CSCDetId::layer(), LogDebug, LogTrace, M_PI, PSimHit::particleType(), PV3DBase< T, PVType, FrameType >::phi(), create_new_empty_test_file_cfg::prd, CSCDetId::ring(), FastTrackerRecHitCombiner_cfi::simHits, CSCDetId::station(), digitizers_cfi::strip, and GeomDet::toGlobal().

getSimInfo()

vector< CSCCathodeLayerInfo > CSCCathodeLCTAnalyzer::getSimInfo	(	const CSCCLCTDigi &	clct,
		const CSCDetId &	clctId,
		const CSCComparatorDigiCollection *	compdc,
		const edm::PSimHitContainer *	allSimHits
	)

Constructs vector of CSCCathodeLayerInfo objects for CLCT.

Definition at line 16 of file CSCCathodeLCTAnalyzer.cc.

                                                                                                     {
  // Fills vector of CSCCathodeLayerInfo objects.  There can be up to 6 such
  // objects (one per layer); they contain the list of comparator digis used to
  // build a given CLCT, and the list of associated (closest) SimHits.
  // Filling is done in two steps: first, we construct the list of comparator
  // digis; next, find associated SimHits.
  vector<CSCCathodeLayerInfo> clctInfo = lctDigis(clct, clctId, compdc);
 
  // Sanity checks.
  if (clctInfo.size() > CSCConstants::NUM_LAYERS) {
    throw cms::Exception("CSCCathodeLCTAnalyzer") << "+++ Number of CSCCathodeLayerInfo objects, " << clctInfo.size()
                                                  << ", exceeds max expected, " << CSCConstants::NUM_LAYERS << " +++\n";
  }
  //  not a good check for high PU
  //if (clctInfo.size() != (unsigned)clct.getQuality()) {
  //  edm::LogWarning("L1CSCTPEmulatorWrongValues")
  //    << "+++ Warning: mismatch between CLCT quality, " << clct.getQuality()
  //    << ", and the number of layers with digis, " << clctInfo.size()
  //    << ", in clctInfo! +++\n";
  //}
 
  // Find the closest SimHit to each Digi.
  vector<CSCCathodeLayerInfo>::iterator pcli;
  for (pcli = clctInfo.begin(); pcli != clctInfo.end(); pcli++) {
    digiSimHitAssociator(*pcli, allSimHits);
  }
 
  return clctInfo;
}

References Exception, and CSCConstants::NUM_LAYERS.

Referenced by CSCTriggerPrimitivesReader::calcResolution().

getStripPhi()

double CSCCathodeLCTAnalyzer::getStripPhi	(	const CSCDetId &	layerId,
		const float	strip
	)

Returns phi position of a given strip.

Definition at line 401 of file CSCCathodeLCTAnalyzer.cc.

                                                                                    {
  // Returns phi position of a given strip.
  if (strip < 0. || strip >= CSCConstants::MAX_NUM_STRIPS) {
    edm::LogWarning("L1CSCTPEmulatorWrongInput")
        << "+++ Warning: strip, " << strip << ", is not in [0-" << CSCConstants::MAX_NUM_STRIPS << ") interval +++\n";
  }
 
  const CSCLayer* csclayer = geom_->layer(layerId);
  const CSCLayerGeometry* layerGeom = csclayer->geometry();
 
  // Position at the center of the strip.
  LocalPoint digiLP = layerGeom->topology()->localPosition(strip);
  // The alternative calculation gives exactly the same answer.
  // double ystrip = 0.0;
  // double xstrip = topology->xOfStrip(strip, ystrip);
  // LocalPoint  digiLP = LocalPoint(xstrip, ystrip);
  GlobalPoint digiGP = csclayer->toGlobal(digiLP);
  double phi = digiGP.phi();
 
  return phi;
}

References CSCLayer::geometry(), OffsetRadialStripTopology::localPosition(), CSCConstants::MAX_NUM_STRIPS, PV3DBase< T, PVType, FrameType >::phi(), digitizers_cfi::strip, GeomDet::toGlobal(), and CSCLayerGeometry::topology().

Referenced by CSCTriggerPrimitivesReader::calcResolution().

lctDigis()

vector< CSCCathodeLayerInfo > CSCCathodeLCTAnalyzer::lctDigis ( const CSCCLCTDigi &  clct, const CSCDetId &  clctId, const CSCComparatorDigiCollection *  compdc  )

private

Definition at line 49 of file CSCCathodeLCTAnalyzer.cc.

                                                                                                       {
  // Function to find a list of ComparatorDigis used to create an LCT.
  // The list of ComparatorDigis is stored in a class called CSCLayerInfo which
  // contains the layerId's of the stored ComparatorDigis as well as the actual
  // digis themselves.
  int hfstripDigis[CSCConstants::NUM_HALF_STRIPS];
  int time[CSCConstants::MAX_NUM_STRIPS], comp[CSCConstants::MAX_NUM_STRIPS];
  int digiNum[CSCConstants::MAX_NUM_STRIPS];
  int digiId = -999;
  CSCCathodeLayerInfo tempInfo;
  vector<CSCCathodeLayerInfo> vectInfo;
 
  // Inquire the clct for its key half-strip, strip type and pattern number.
  int clct_keystrip = clct.getKeyStrip();
  int clct_stripType = clct.getStripType();
  int clct_pattern = clct.getPattern();
  int clct_bx = clct.getBX();
 
  // Re-scale the key di-strip number to the count used in the search.
  if (clct_stripType == 0)
    clct_keystrip /= 4;
 
  if (debug) {
    char stype = (clct_stripType == 0) ? 'D' : 'H';
    LogDebug("lctDigis") << "\nlctDigis: CLCT keystrip = " << clct_keystrip << " (" << stype << ")"
                         << " pattern = " << clct_pattern << "; Id:"
                         << " endcap " << clctId.endcap() << ", station " << clctId.station() << ", ring "
                         << clctId.ring() << ", chamber " << clctId.chamber();
  }
 
  // 'Staggering' for key layer.  Needed for TMB07 version.
  const int key_layer = 3;  // counting from 1.
  CSCDetId layerId(clctId.endcap(), clctId.station(), clctId.ring(), clctId.chamber(), key_layer);
  const CSCLayer* csclayer = geom_->layer(layerId);
  int key_stagger = (csclayer->geometry()->stagger() + 1) / 2;
 
  for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
    // Clear tempInfo values every iteration before using.
    tempInfo.clear();
 
    // @ Switch to maps eventually
    vector<CSCComparatorDigi> digiMap;
    int digi_num = 0;
    for (int i_hstrip = 0; i_hstrip < CSCConstants::NUM_HALF_STRIPS; i_hstrip++) {
      hfstripDigis[i_hstrip] = -999;
    }
    for (int i_strip = 0; i_strip < CSCConstants::MAX_NUM_STRIPS; i_strip++) {
      time[i_strip] = -999;
      comp[i_strip] = 0;
      digiNum[i_strip] = -999;
    }
 
    // CLCTs belong to a chamber, so their layerId is 0.  Comparator digis
    // belong to layers, so in order to access them we need to add layer
    // number to CLCT's endcap, chamber, etc.
    CSCDetId layerId(clctId.endcap(), clctId.station(), clctId.ring(), clctId.chamber(), i_layer + 1);
 
    // Preselection of Digis: right layer and bx.
    digi_num += preselectDigis(clct_bx, layerId, compdc, digiMap, hfstripDigis, time, comp, digiNum);
 
    // In case of ME1/1, one can also look for digis in ME1/A.
    // Skip them for now since the resolution of CLCTs in ME1/A is
    // terrible (strips are ganged; channel numbers translated to be
    // in CFEB=4).
    if (doME1A) {
      if (clctId.station() == 1 && clctId.ring() == 1) {
        CSCDetId layerId_me1a(clctId.endcap(), clctId.station(), 4, clctId.chamber(), i_layer + 1);
        digi_num += preselectDigis(clct_bx, layerId_me1a, compdc, digiMap, hfstripDigis, time, comp, digiNum);
      }
    }
 
    // Loop over all the strips in a pattern.
    // FIXME !!!
    int strip;
    for (int i_layer = 0; i_layer < CSCConstants::NUM_LAYERS; i_layer++) {
      for (int i_strip = 0; i_strip < CSCConstants::CLCT_PATTERN_WIDTH; i_strip++) {
        strip = clct_keystrip + key_stagger + CSCPatternBank::clct_pattern_offset_[i_strip];
        if (strip >= 0 && strip < CSCConstants::NUM_HALF_STRIPS) {
          digiId = hfstripDigis[strip];
          // halfstripDigis contains the digi numbers
          // that were carried through the different transformations
          // to keystrip. 0 means there was no Digi.
          if (digiId >= 0) {
            tempInfo.setId(layerId);                 // store the layer of this object
            tempInfo.addComponent(digiMap[digiId]);  // and the RecDigi
            if (debug) {
              LogTrace("lctDigis") << " Digi on CLCT: strip/comp/time " << digiMap[digiId];
            }
          }
        }
      }
    }
 
    // Save results for each non-empty layer.
    if (tempInfo.getId().layer() != 0) {
      vectInfo.push_back(tempInfo);
    }
  }
  return vectInfo;
}

References CSCLayerInfo< TYPE >::addComponent(), CSCDetId::chamber(), CSCPatternBank::clct_pattern_offset_, CSCConstants::CLCT_PATTERN_WIDTH, CSCLayerInfo< TYPE >::clear(), AlCaHLTBitMon_QueryRunRegistry::comp, debug, CSCDetId::endcap(), CSCCLCTDigi::getBX(), CSCLayerInfo< TYPE >::getId(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getStripType(), CSCDetId::layer(), LogDebug, LogTrace, CSCConstants::MAX_NUM_STRIPS, CSCConstants::NUM_HALF_STRIPS, CSCConstants::NUM_LAYERS, CSCDetId::ring(), CSCLayerInfo< TYPE >::setId(), CSCDetId::station(), digitizers_cfi::strip, and protons_cff::time.

nearestHS()

int CSCCathodeLCTAnalyzer::nearestHS	(	const std::vector< CSCCathodeLayerInfo > &	allLayerInfo,
		double &	closestPhi,
		double &	closestEta
	)

Finds half-strip, phi and eta of the nearest SimHit for comparison to the reconstructed values.

Definition at line 304 of file CSCCathodeLCTAnalyzer.cc.

                                                         {
  // Function to set the simulated values for comparison to the reconstructed.
  // It first tries to look for the SimHit in the key layer.  If it is
  // unsuccessful, it loops over all layers and looks for an associated
  // hit in any one of the layers.  First instance of a hit gives a calculation
  // for phi.
  int nearestHS = -999;
  PSimHit matchedHit;
  bool hit_found = false;
  CSCDetId layerId;
  static const int key_layer = CSCConstants::KEY_CLCT_LAYER;
 
  vector<CSCCathodeLayerInfo>::const_iterator pli;
  for (pli = allLayerInfo.begin(); pli != allLayerInfo.end(); pli++) {
    if (pli->getId().layer() == key_layer) {
      vector<PSimHit> thisLayerHits = pli->getSimHits();
      if (!thisLayerHits.empty()) {
        // There can be one RecDigi (and therefore only one SimHit)
        // in a keylayer.
        if (thisLayerHits.size() != 1) {
          edm::LogWarning("L1CSCTPEmulatorWrongValues")
              << "+++ Warning: " << thisLayerHits.size() << " SimHits in key layer " << key_layer << "! +++ \n";
          for (unsigned i = 0; i < thisLayerHits.size(); i++) {
            edm::LogWarning("L1CSCTPEmulatorWrongValues") << " SimHit # " << i << thisLayerHits[i] << "\n";
          }
        }
        matchedHit = thisLayerHits[0];
        layerId = pli->getId();
        hit_found = true;
        break;
      }
    }
  }
 
  if (hit_found == false) {
    for (pli = allLayerInfo.begin(); pli != allLayerInfo.end(); pli++) {
      // if there is any occurrence of simHit size greater that zero, use this.
      if (!(pli->getRecDigis()).empty() && !(pli->getSimHits()).empty()) {
        // Always use the first SimHit for now.
        matchedHit = (pli->getSimHits())[0];
        layerId = pli->getId();
        hit_found = true;
        break;
      }
    }
  }
 
  // Set phi and eta if there were any hits found.
  if (hit_found) {
    const CSCLayer* csclayer = geom_->layer(layerId);
    const CSCLayerGeometry* layerGeom = csclayer->geometry();
    //nearestStrip = layerGeom->nearestStrip(matchedHit.localPosition());
    // Float in units of the strip (angular) width.  From RadialStripTopology
    // comments: "Strip in which a given LocalPoint lies. This is a float
    // which represents the fractional strip position within the detector.
    // Returns zero if the LocalPoint falls at the extreme low edge of the
    // detector or BELOW, and float(nstrips) if it falls at the extreme high
    // edge or ABOVE."
    float strip = layerGeom->topology()->strip(matchedHit.localPosition());
 
    // Should be in the interval [0-MAX_STRIPS).  I see (rarely) cases when
    // strip = nearestStrip = MAX_STRIPS; do not know how to handle them.
    int nearestStrip = static_cast<int>(strip);
    if (nearestStrip < 0 || nearestStrip >= CSCConstants::MAX_NUM_STRIPS) {
      edm::LogWarning("L1CSCTPEmulatorWrongInput")
          << "+++ Warning: nearest strip, " << nearestStrip << ", is not in [0-" << CSCConstants::MAX_NUM_STRIPS
          << ") interval; strip = " << strip << " +++\n";
    }
    // Left/right half of the strip.
    int comp = ((strip - nearestStrip) < 0.5) ? 0 : 1;
    nearestHS = 2 * nearestStrip + comp;
 
    GlobalPoint thisPoint = csclayer->toGlobal(matchedHit.localPosition());
    closestPhi = thisPoint.phi();
    closestEta = thisPoint.eta();
    ostringstream strstrm;
    if (debug)
      strstrm << "Matched cathode phi: " << closestPhi;
    if (closestPhi < 0.) {
      closestPhi += 2. * M_PI;
      if (debug)
        strstrm << "(" << closestPhi << ")";
    }
    if (debug) {
      strstrm << " eta: " << closestEta << " on a layer " << layerId.layer() << " (1-6);"
              << " nearest strip: " << nearestStrip;
      LogDebug("nearestHS") << strstrm.str();
    }
  }
 
  return nearestHS;
}

References AlCaHLTBitMon_QueryRunRegistry::comp, debug, relativeConstraints::empty, PV3DBase< T, PVType, FrameType >::eta(), CSCLayer::geometry(), mps_fire::i, CSCConstants::KEY_CLCT_LAYER, CSCDetId::layer(), PSimHit::localPosition(), LogDebug, M_PI, CSCConstants::MAX_NUM_STRIPS, PV3DBase< T, PVType, FrameType >::phi(), digitizers_cfi::strip, OffsetRadialStripTopology::strip(), GeomDet::toGlobal(), and CSCLayerGeometry::topology().

Referenced by CSCTriggerPrimitivesReader::calcResolution().

preselectDigis()

int CSCCathodeLCTAnalyzer::preselectDigis ( const int  clct_bx, const CSCDetId &  layerId, const CSCComparatorDigiCollection *  compdc, std::vector< CSCComparatorDigi > &  digiMap, int  hfstripDigis[CSCConstants::NUM_HALF_STRIPS], int  time[CSCConstants::MAX_NUM_STRIPS], int  comp[CSCConstants::MAX_NUM_STRIPS], int  digiNum[CSCConstants::MAX_NUM_STRIPS]  )

private

Definition at line 152 of file CSCCathodeLCTAnalyzer.cc.

                                                                                   {
  // Preselection of Digis: right layer and bx.
  int digi_num = 0;
 
  // Parameters defining time window for accepting hits; should come from
  // configuration file eventually.
  const int fifo_tbins = 12;
  const int hit_persist = 4;
  const int drift_delay = 2;
 
  // 'Staggering' for this layer.
  const CSCLayer* csclayer = geom_->layer(layerId);
  int stagger = (csclayer->geometry()->stagger() + 1) / 2;
 
  bool me1a = (layerId.station() == 1) && (layerId.ring() == 4);
 
  const CSCComparatorDigiCollection::Range rcompd = compdc->get(layerId);
  for (CSCComparatorDigiCollection::const_iterator digiIt = rcompd.first; digiIt != rcompd.second; ++digiIt) {
    if (debug)
      LogDebug("lctDigis") << "Comparator digi: layer " << layerId.layer() - 1
                           << " strip/comparator/time =" << (*digiIt);
 
    if ((*digiIt).getComparator() == 0 || (*digiIt).getComparator() == 1) {
      int bx_time = (*digiIt).getTimeBin();
      if (bx_time >= 0 && bx_time < fifo_tbins) {
        // Do not use digis which could not have contributed to a given CLCT.
        int latch_bx = clct_bx + drift_delay;
        if (bx_time <= latch_bx - hit_persist || bx_time > latch_bx) {
          if (debug)
            LogDebug("lctDigis") << "Late comparator digi: layer " << layerId.layer() - 1
                                 << " strip/comparator/time =" << (*digiIt) << " skipping...";
          continue;
        }
 
        // If there is more than one digi on the same strip, pick the one
        // which occurred earlier.
        int i_strip = (*digiIt).getStrip() - 1;  // starting from 0
        if (me1a && i_strip < 16) {
          // Move ME1/A comparators from CFEB=0 to CFEB=4 if this has not
          // been done already.
          i_strip += 64;
        }
 
        if (time[i_strip] <= 0 || time[i_strip] > bx_time) {
          // @ Switch to maps; check for match in time.
          int i_hfstrip = 2 * i_strip + (*digiIt).getComparator() + stagger;
          hfstripDigis[i_hfstrip] = digi_num;
 
          // Arrays for distrip stagger
          comp[i_strip] = (*digiIt).getComparator();
          time[i_strip] = bx_time;
          digiNum[i_strip] = digi_num;
 
          if (debug)
            LogDebug("lctDigis") << "digi_num = " << digi_num << " half-strip = " << i_hfstrip
                                 << " strip = " << i_strip;
        }
      }
    }
    digiMap.push_back(*digiIt);
    digi_num++;
  }
 
  return digi_num;
}

References AlCaHLTBitMon_QueryRunRegistry::comp, debug, CSCLayer::geometry(), CSCDetId::layer(), LogDebug, CSCDetId::ring(), CSCLayerGeometry::stagger(), CSCDetId::station(), and protons_cff::time.

setDebug()

static void CSCCathodeLCTAnalyzer::setDebug ( )

inlinestatic

Turns on the debug flag for this class.

Definition at line 47 of file CSCCathodeLCTAnalyzer.h.

{ debug = true; }

References debug.

setGeometry()

void CSCCathodeLCTAnalyzer::setGeometry

(

const CSCGeometry *

geom

)

Cache pointer to geometry for current event.

Definition at line 399 of file CSCCathodeLCTAnalyzer.cc.

{ geom_ = geom; }

References relativeConstraints::geom.

Referenced by CSCTriggerPrimitivesReader::calcResolution().

setNoDebug()

static void CSCCathodeLCTAnalyzer::setNoDebug ( )

inlinestatic

Turns off the debug flag for this class (default).

Definition at line 50 of file CSCCathodeLCTAnalyzer.h.

{ debug = false; }

References debug.

Member Data Documentation

debug

bool CSCCathodeLCTAnalyzer::debug = true

staticprivate

Definition at line 53 of file CSCCathodeLCTAnalyzer.h.

Referenced by runTauIdMVA.TauIDEmbedder::loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder::runTauID(), setDebug(), and setNoDebug().

doME1A

bool CSCCathodeLCTAnalyzer::doME1A = false

staticprivate

Flag to decide whether to analyze stubs in ME1/A or not.

Definition at line 56 of file CSCCathodeLCTAnalyzer.h.

geom_

const CSCGeometry* CSCCathodeLCTAnalyzer::geom_

private

Definition at line 59 of file CSCCathodeLCTAnalyzer.h.