#include <CSCComparatorDigiFitter.h>

Public Member Functions
	CSCComparatorDigiFitter ()

void	fit (const CSCDetId &ch_id, const CSCCorrelatedLCTDigi &, const CSCComparatorDigiCollection &, std::vector< float > &fit_phi_layers, std::vector< float > &fit_z_layers, float &keyRadius)

void	setGeometry (const CSCGeometry *csc_g)

void	setStripBits (int bits)

void	useKeyRadius (bool useKeyRadius)

	~CSCComparatorDigiFitter ()

Private Member Functions
void	calculateSlopeIntercept (float &alpha, float &beta)

bool	comparatorInLCTPattern (int keyStrip, int pattern, int layer, int halfStrip) const

float	cscHalfStripWidth (const CSCDetId &id) const

void	getComparatorDigiCoordinates (const CSCDetId &ch_id, const CSCCorrelatedLCTDigi &stub)

void	matchingComparatorDigisLCT (const CSCDetId &ch_id, const CSCCorrelatedLCTDigi &, const CSCComparatorDigiCollection &)

Private Attributes
CSCComparatorDigiContainerIds	compDigisIds_

const CSCGeometry *	cscGeometry_

const std::vector< float >	degrees_ = {10., 10., 10., 10., 20., 10., 20., 10., 20., 10.}

std::vector< float >	ephis_

std::vector< float >	ezs_

int	nStripBits_

std::vector< float >	phis_

float	radius_

const std::vector< int >	strips_ = {48, 64, 80, 64, 80, 80, 80, 80, 80, 80}

bool	useKeyRadius_

std::vector< float >	zs_

Detailed Description

Definition at line 38 of file CSCComparatorDigiFitter.h.

Constructor & Destructor Documentation

CSCComparatorDigiFitter::CSCComparatorDigiFitter ( )

inline

Definition at line 40 of file CSCComparatorDigiFitter.h.

40 {}

CSCComparatorDigiFitter::~CSCComparatorDigiFitter ( )

inline

Definition at line 41 of file CSCComparatorDigiFitter.h.

41 {}

Member Function Documentation

void CSCComparatorDigiFitter::calculateSlopeIntercept	(	float &	alpha,
		float &	beta
	)

private

Definition at line 213 of file CSCComparatorDigiFitter.cc.

References dumpMFGeometry_cfg::delta, ephis_, mps_fire::i, phis_, and zs_.

Referenced by fit(), and useKeyRadius().

                                                                                {
   // if there are at least 3 hits in the chamber, do a linear fit to the
   // comparator digi positions with the chi2 method
   if (phis_.size() >= 3) {
     float Sxx = 0, Sxy = 0, Sx = 0, Sy = 0, S = 0;
     for (unsigned i = 0; i < phis_.size(); ++i) {
       float sigma2_inv = 1. / ephis_[i] * ephis_[i];
       Sxx += zs_[i] * zs_[i] * sigma2_inv;
       Sxy += zs_[i] * phis_[i] * sigma2_inv;
       Sx += zs_[i] * zs_[i] * sigma2_inv;
       Sy += phis_[i] * sigma2_inv;
       S += sigma2_inv;
     }
     float delta = S * Sxx - Sx * Sx;
     alpha = (Sxx * Sy - Sx * Sxy) / delta;
     beta = (S * Sxy - Sx * Sy) / delta;
   } else {
     alpha = -99;
     beta = 0.0;
   }
 }

bool CSCComparatorDigiFitter::comparatorInLCTPattern	(	int	keyStrip,
		int	pattern,
		int	layer,
		int	halfStrip
	)		const

private

Definition at line 243 of file CSCComparatorDigiFitter.cc.

References spr::find(), or, and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by matchingComparatorDigisLCT(), and useKeyRadius().

                                                                                                               {
   // get the (sub)pattern
   const std::vector<int>& subpat = patIndexToPatternDelta[pattern].at(layer - 1);
 
   // due to comparator digi time extension in the CLCT processor we need to
   // search a bigger region around the key HS. +/-1, 0 should be sufficient
   const int halfStripDelta = halfStrip - keyStrip;
   return (std::find(subpat.begin(), subpat.end(), halfStripDelta + 1) != subpat.end() or
           std::find(subpat.begin(), subpat.end(), halfStripDelta) != subpat.end() or
           std::find(subpat.begin(), subpat.end(), halfStripDelta - 1) != subpat.end());
 }

float CSCComparatorDigiFitter::cscHalfStripWidth ( const CSCDetId & id ) const

private

Definition at line 235 of file CSCComparatorDigiFitter.cc.

References degrees_, M_PI, and strips_.

Referenced by getComparatorDigiCoordinates(), and useKeyRadius().

                                                                          {
   // what is the chamber type?
   int index = id.iChamberType() - 1;
 
   // calculate the half strip width of this chamber
   return degrees_[index] * M_PI / 180. / (2. * strips_[index]);
 }

void CSCComparatorDigiFitter::fit	(	const CSCDetId &	ch_id,
		const CSCCorrelatedLCTDigi &	stub,
		const CSCComparatorDigiCollection &	hCSCComparators,
		std::vector< float > &	fit_phi_layers,
		std::vector< float > &	fit_z_layers,
		float &	keyRadius
	)

Definition at line 150 of file CSCComparatorDigiFitter.cc.

References funct::abs(), zMuMuMuonUserData::alpha, zMuMuMuonUserData::beta, calculateSlopeIntercept(), CSCDetId::chamber(), CSCGeometry::chamber(), cscGeometry_, CSCDetId::endcap(), CSCLayer::geometry(), getComparatorDigiCoordinates(), CSCCorrelatedLCTDigi::getFractionalStrip(), CSCCorrelatedLCTDigi::getKeyWG(), mps_fire::i, CSCGeometry::idToDet(), CSCConstants::KEY_CLCT_LAYER, CSCChamber::layer(), matchingComparatorDigisLCT(), CSCLayerGeometry::middleWireOfGroup(), normalizedPhi(), nStripBits_, CSCConstants::NUM_LAYERS, or, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), phis_, radius_, CSCDetId::ring(), CSCDetId::station(), GeomDet::surface(), Surface::toGlobal(), and useKeyRadius_.

Referenced by trackingPlots.Iteration::modules(), and useKeyRadius().

                                                     {
   // clear fit results
   fit_phi_layers.clear();
   fit_z_layers.clear();
   keyRadius = 0;
 
   // first, match the comparator digis to the LCT
   matchingComparatorDigisLCT(ch_id, stub, hCSCComparators);
 
   // second, get the coordinates
   getComparatorDigiCoordinates(ch_id, stub);
 
   // get radius of the stub from key layer
   const CSCDetId key_id(ch_id.endcap(), ch_id.station(), ch_id.ring(), ch_id.chamber(), CSCConstants::KEY_CLCT_LAYER);
   const float fractional_strip = stub.getFractionalStrip();
 
   const auto& cscChamber = cscGeometry_->chamber(ch_id);
   const auto& layer_geo = cscChamber->layer(CSCConstants::KEY_CLCT_LAYER)->geometry();
 
   // LCT::getKeyWG() also starts from 0
   const float wire = layer_geo->middleWireOfGroup(stub.getKeyWG() + 1);
   const LocalPoint& csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire);
   const GlobalPoint& csc_gp = cscGeometry_->idToDet(key_id)->surface().toGlobal(csc_intersect);
 
   // get radius from key layer
   if (useKeyRadius_)
     radius_ = radius_ / phis_.size();
   else
     radius_ = csc_gp.perp();
 
   float alpha = -99., beta = 0.;
   // do a fit to the comparator digis
   calculateSlopeIntercept(alpha, beta);
   if (phis_.size() <= 2 or std::abs(alpha) >= 99) {
     alpha = csc_gp.phi();
     beta = 0.0;
   }
 
   // determine the pitch of the chamber
   // option to discretize the pitch
   float stripPhiPitch = layer_geo->stripPhiPitch();
   if (nStripBits_)
     stripPhiPitch = stripPhiPitch / nStripBits_;
 
   // get the fit results
   // option to discretize the fitted phi value
   keyRadius = radius_;
 
   for (int i = 0; i < CSCConstants::NUM_LAYERS; i++) {
     const float fit_z = cscChamber->layer(i + 1)->centerOfStrip(20).z();
     const float fit_phi = normalizedPhi(alpha + beta * fit_z);
     fit_z_layers.push_back(fit_z);
     fit_phi_layers.push_back(fit_phi);
     if (nStripBits_)
       fit_phi_layers.push_back((std::floor(fit_phi / stripPhiPitch) + 0.5) * stripPhiPitch);
   }
 }

void CSCComparatorDigiFitter::getComparatorDigiCoordinates	(	const CSCDetId &	ch_id,
		const CSCCorrelatedLCTDigi &	stub
	)

private

Definition at line 94 of file CSCComparatorDigiFitter.cc.

References CSCGeometry::chamber(), compDigisIds_, cscGeometry_, cscHalfStripWidth(), ephis_, ezs_, geometry, CSCCorrelatedLCTDigi::getKeyWG(), CSCGeometry::idToDet(), M_PI, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::perp(), PV3DBase< T, PVType, FrameType >::phi(), phis_, radius_, findQualityFiles::size, mathSSE::sqrt(), GeomDet::surface(), Surface::toGlobal(), PV3DBase< T, PVType, FrameType >::z(), and zs_.

Referenced by fit(), and useKeyRadius().

                                                                                                                   {
   const auto& cscChamber = cscGeometry_->chamber(ch_id);
 
   // get the z and phi positions of the comparator digis
   float radius_ = 0.0;
 
   // loop on all matching digis
   for (const auto& p : compDigisIds_) {
     const auto& detId = p.first;
 
     float phi_tmp = 0.0;
     float radius_tmp = 0.0;
     float z_tmp = 0.0;
 
     // ignore layers with no digis
     if (p.second.empty())
       continue;
 
     // loop on all matching digis in this layer
     for (const auto& hit : p.second) {
       const float fractional_strip = hit.getFractionalStrip();
       const auto& layer_geo = cscChamber->layer(detId.layer())->geometry();
       const float wire = layer_geo->middleWireOfGroup(stub.getKeyWG() + 1);
 
       // get the phi of each comparator digi
       const LocalPoint& csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire);
       const GlobalPoint& csc_gp = cscGeometry_->idToDet(detId)->surface().toGlobal(csc_intersect);
       const float gpphi = csc_gp.phi();
 
       // normalize phi values according to first one
       if (!phis_.empty() and gpphi > 0 and phis_[0] < 0 and (gpphi - phis_[0]) > M_PI)
         phi_tmp += (gpphi - 2 * M_PI);
       else if (!phis_.empty() and gpphi < 0 and phis_[0] > 0 and (gpphi - phis_[0]) < -M_PI)
         phi_tmp += (gpphi + 2 * M_PI);
       else
         phi_tmp += (csc_gp.phi());
 
       z_tmp = csc_gp.z();
       radius_tmp += csc_gp.perp();
     }
 
     //in case there are more than one comparator digis in one layer
     radius_tmp = radius_tmp / (p.second).size();
     radius_ += radius_tmp;
 
     zs_.push_back(z_tmp);
     ezs_.push_back(0);
 
     phi_tmp = phi_tmp / (p.second).size();
     phis_.push_back(phi_tmp);
     // assume that the charge is flat distributed across the half-strip
     // this is only approximately valid, but good enough for now
     ephis_.push_back(cscHalfStripWidth(detId) / sqrt(12));
   }
 }

void CSCComparatorDigiFitter::matchingComparatorDigisLCT	(	const CSCDetId &	ch_id,
		const CSCCorrelatedLCTDigi &	stub,
		const CSCComparatorDigiCollection &	hCSCComparators
	)

private

Definition at line 64 of file CSCComparatorDigiFitter.cc.

References funct::abs(), CSCDetId::chamber(), comparatorInLCTPattern(), compDigisIds_, CSCDetId::endcap(), CSCCorrelatedLCTDigi::getPattern(), CSCCorrelatedLCTDigi::getStrip(), CSCConstants::NUM_LAYERS, CSCDetId::ring(), and CSCDetId::station().

Referenced by fit(), and useKeyRadius().

                                                                                                              {
   // fetch the CSC comparator digis in this chamber
   for (int iLayer = 1; iLayer <= CSCConstants::NUM_LAYERS; ++iLayer) {
     const CSCDetId layerId(ch_id.endcap(), ch_id.station(), ch_id.ring(), ch_id.chamber(), iLayer);
 
     // get the digis per layer
     const auto& compRange = hCSCComparators.get(layerId);
     CSCComparatorDigiContainer compDigis;
 
     for (auto compDigiItr = compRange.first; compDigiItr != compRange.second; compDigiItr++) {
       const auto& compDigi = *compDigiItr;
 
       //if (stub.getTimeBin() < 4 or stub.getTimeBin() > 8) continue;
       const int stubHalfStrip(compDigi.getHalfStrip());
 
       // these comparator digis never fit the pattern anyway!
       if (std::abs(stubHalfStrip - stub.getStrip()) > 5)
         continue;
 
       // check if this comparator digi fits the pattern
       if (comparatorInLCTPattern(stub.getStrip(), stub.getPattern(), iLayer, stubHalfStrip)) {
         compDigis.push_back(compDigi);
       }
     }
     compDigisIds_.emplace_back(layerId, compDigis);
   }
 }

void CSCComparatorDigiFitter::setGeometry ( const CSCGeometry * csc_g )

inline

Definition at line 44 of file CSCComparatorDigiFitter.h.

References cscGeometry_.

44 { cscGeometry_ = csc_g; }

CSCComparatorDigiFitter::cscGeometry_

const CSCGeometry * cscGeometry_

Definition: CSCComparatorDigiFitter.h:80

void CSCComparatorDigiFitter::setStripBits ( int bits )

inline

Definition at line 47 of file CSCComparatorDigiFitter.h.

References bits, and nStripBits_.

47 { nStripBits_ = bits; }

bits

How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision bits

Definition: EventSelector-behavior.doc:35

CSCComparatorDigiFitter::nStripBits_

int nStripBits_

Definition: CSCComparatorDigiFitter.h:83

void CSCComparatorDigiFitter::useKeyRadius ( bool useKeyRadius )

inline

Definition at line 50 of file CSCComparatorDigiFitter.h.

References zMuMuMuonUserData::alpha, zMuMuMuonUserData::beta, calculateSlopeIntercept(), comparatorInLCTPattern(), cscHalfStripWidth(), fit(), getComparatorDigiCoordinates(), matchingComparatorDigisLCT(), topSingleLeptonDQM_PU_cfi::pattern, useKeyRadius(), and useKeyRadius_.