#include <CSCUpgradeMotherboardLUTGenerator.h>

Classes
class	Helpers

Public Member Functions
int	assignRoll (const std::vector< std::pair< double, double > > &, double eta) const

	CSCUpgradeMotherboardLUTGenerator ()

void	generateLUTs (unsigned e, unsigned s, unsigned se, unsigned sb, unsigned c) const
	generate and print LUT More...

void	generateLUTsME11 (unsigned e, unsigned se, unsigned sb, unsigned c) const

void	generateLUTsME21 (unsigned e, unsigned se, unsigned sb, unsigned c) const

void	generateLUTsME3141 (unsigned e, unsigned s, unsigned se, unsigned sb, unsigned c) const

void	setCSCGeometry (const CSCGeometry *g)
	set CSC and GEM geometries for the matching needs More...

void	setGEMGeometry (const GEMGeometry *g)

void	setRPCGeometry (const RPCGeometry *g)

	~CSCUpgradeMotherboardLUTGenerator ()

Private Member Functions
void	cscHsToGemPadLUT (const CSCLayer , const GEMEtaPartition , int minH, int maxH, std::vector< std::pair< int, int > > &) const

void	cscHsToRpcStripLUT (const CSCLayer , const RPCRoll , int minH, int maxH, std::vector< std::pair< int, int > > &) const

void	cscWgToEtaLimitsLUT (const CSCLayer *, std::vector< std::pair< double, double > > &) const

void	cscWgToRollLUT (const std::vector< std::pair< double, double > > &, const std::vector< std::pair< double, double > > &, std::vector< std::pair< int, int > > &) const

void	gemPadToCscHsLUT (const CSCLayer , const GEMEtaPartition , std::vector< int > &) const

void	gemRollToEtaLimitsLUT (const GEMChamber *c, std::vector< std::pair< double, double > > &) const

void	rpcRollToEtaLimitsLUT (const RPCChamber *c, std::vector< std::pair< double, double > > &) const

void	rpcStripToCscHsLUT (const CSCLayer , const RPCRoll , std::vector< int > &) const

Private Attributes
const CSCGeometry *	csc_g

const GEMGeometry *	gem_g

const RPCGeometry *	rpc_g

Detailed Description

Definition at line 12 of file CSCUpgradeMotherboardLUTGenerator.h.

Constructor & Destructor Documentation

CSCUpgradeMotherboardLUTGenerator::CSCUpgradeMotherboardLUTGenerator ( )

inline

Definition at line 22 of file CSCUpgradeMotherboardLUTGenerator.h.

22 {}

CSCUpgradeMotherboardLUTGenerator::~CSCUpgradeMotherboardLUTGenerator ( )

inline

Definition at line 23 of file CSCUpgradeMotherboardLUTGenerator.h.

23 {}

Member Function Documentation

int CSCUpgradeMotherboardLUTGenerator::assignRoll	(	const std::vector< std::pair< double, double > > &	lut_,
		double	eta
	)		const

Definition at line 249 of file CSCUpgradeMotherboardLUTGenerator.cc.

References funct::abs(), maxEta, cutBasedElectronID_CSA14_50ns_V0_cff::minEta, AlCaHLTBitMon_ParallelJobs::p, and mps_fire::result.

Referenced by cscWgToRollLUT(), and setRPCGeometry().

 {
   int result = -99;
   for(const auto& p : lut_) {
     const float minEta(p.first);
     const float maxEta(p.second);
     if (minEta <= std::abs(eta) and std::abs(eta) < maxEta) {
       result = p.first;
       break;
     }
   }
   return result;
 }

void CSCUpgradeMotherboardLUTGenerator::cscHsToGemPadLUT	(	const CSCLayer *	keyLayer,
		const GEMEtaPartition *	randRoll,
		int	minH,
		int	maxH,
		std::vector< std::pair< int, int > > &	lut
	)		const

private

Definition at line 312 of file CSCUpgradeMotherboardLUTGenerator.cc.

References CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, lumiPlot::lut, GEMEtaPartition::pad(), GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME11(), generateLUTsME21(), and setRPCGeometry().

 {
   const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
   auto nStrips(keyLayerGeometry->numberOfStrips());
   for (float i = 0; i< nStrips; i = i+0.5){
     const LocalPoint lpCSC(keyLayerGeometry->topology()->localPosition(i));
     const GlobalPoint gp(keyLayer->toGlobal(lpCSC));
     const LocalPoint lpGEM(randRoll->toLocal(gp));
     const int HS(i/0.5);
     const bool edge(HS < minH or HS > maxH);
     const float pad(edge ? -99 : randRoll->pad(lpGEM));
     lut.emplace_back(std::floor(pad),std::ceil(pad));
   }
 }

void CSCUpgradeMotherboardLUTGenerator::cscHsToRpcStripLUT	(	const CSCLayer *	keyLayer,
		const RPCRoll *	randRoll,
		int	minH,
		int	maxH,
		std::vector< std::pair< int, int > > &	lut
	)		const

private

Definition at line 346 of file CSCUpgradeMotherboardLUTGenerator.cc.

References CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, lumiPlot::lut, digi_MixPreMix_cfi::strip, RPCRoll::strip(), GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME3141(), and setRPCGeometry().

 {
   const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
   auto nStrips(keyLayerGeometry->numberOfStrips());
   for (float i = 0; i< nStrips; i = i+0.5){
     const LocalPoint lpCSC(keyLayerGeometry->topology()->localPosition(i));
     const GlobalPoint gp(keyLayer->toGlobal(lpCSC));
     const LocalPoint lpRPC(randRoll->toLocal(gp));
     const int HS(i/0.5);
     const bool edge(HS < minH or HS > maxH);
     const float strip(edge ? -99 : randRoll->strip(lpRPC));
     lut.emplace_back(std::floor(strip),std::ceil(strip));
   }
 }

void CSCUpgradeMotherboardLUTGenerator::cscWgToEtaLimitsLUT	(	const CSCLayer *	keyLayer,
		std::vector< std::pair< double, double > > &	lut
	)		const

private

Definition at line 299 of file CSCUpgradeMotherboardLUTGenerator.cc.

References CSCLayer::geometry(), mps_fire::i, lumiPlot::lut, and GeomDet::toGlobal().

Referenced by generateLUTsME11(), generateLUTsME21(), generateLUTsME3141(), and setRPCGeometry().

 {
   const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
   const int numberOfWG(keyLayerGeometry->numberOfWireGroups());
   for (int i = 0; i< numberOfWG; ++i){
     const float middle_wire(keyLayerGeometry->middleWireOfGroup(i));
     const std::pair<LocalPoint, LocalPoint> wire_ends(keyLayerGeometry->wireTopology()->wireEnds(middle_wire));
     const GlobalPoint gp_top(keyLayer->toGlobal(wire_ends.first));
     const GlobalPoint gp_bottom(keyLayer->toGlobal(wire_ends.first));
     lut.emplace_back(gp_top.eta(), gp_bottom.eta());
   }
 }

void CSCUpgradeMotherboardLUTGenerator::cscWgToRollLUT	(	const std::vector< std::pair< double, double > > &	inLUT1,
		const std::vector< std::pair< double, double > > &	inLUT2,
		std::vector< std::pair< int, int > > &	outLUT
	)		const

private

Definition at line 288 of file CSCUpgradeMotherboardLUTGenerator.cc.

References assignRoll(), ALCARECOTkAlBeamHalo_cff::etaMax, ALCARECOTkAlBeamHalo_cff::etaMin, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by generateLUTsME11(), generateLUTsME21(), generateLUTsME3141(), and setRPCGeometry().

 {
   for (const auto& p: inLUT1){
     double etaMin(p.first);
     double etaMax(p.second);
     outLUT.emplace_back(assignRoll(inLUT2, etaMin), assignRoll(inLUT2, etaMax));
   }
 }

void CSCUpgradeMotherboardLUTGenerator::gemPadToCscHsLUT	(	const CSCLayer *	keyLayer,
		const GEMEtaPartition *	randRoll,
		std::vector< int > &	lut
	)		const

private

Definition at line 330 of file CSCUpgradeMotherboardLUTGenerator.cc.

References GEMEtaPartition::centreOfPad(), CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, GEMEtaPartition::npads(), digi_MixPreMix_cfi::strip, GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME11(), generateLUTsME21(), and setRPCGeometry().

 {
   const int nGEMPads(randRoll->npads());
   const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
   for (int i = 1; i<= nGEMPads; ++i){
     const LocalPoint lpGEM(randRoll->centreOfPad(i));
     const GlobalPoint gp(randRoll->toGlobal(lpGEM));
     const LocalPoint lpCSC(keyLayer->toLocal(gp));
     const float strip(keyLayerGeometry->strip(lpCSC));
     lut.push_back( (int) (strip)/0.5 );
   }
 }

void CSCUpgradeMotherboardLUTGenerator::gemRollToEtaLimitsLUT	(	const GEMChamber *	c,
		std::vector< std::pair< double, double > > &	lut
	)		const

private

Definition at line 263 of file CSCUpgradeMotherboardLUTGenerator.cc.

References funct::abs(), GEMChamber::etaPartitions(), and lumiPlot::lut.

Referenced by generateLUTsME11(), generateLUTsME21(), and setRPCGeometry().

 {
   for(const auto& roll : gemChamber->etaPartitions()) {
     const float half_striplength(roll->specs()->specificTopology().stripLength()/2.);
     const LocalPoint lp_top(0., half_striplength, 0.);
     const LocalPoint lp_bottom(0., -half_striplength, 0.);
     const GlobalPoint gp_top(roll->toGlobal(lp_top));
     const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom));
     lut.emplace_back(std::abs(gp_top.eta()), std::abs(gp_bottom.eta()));
   }
 }

void CSCUpgradeMotherboardLUTGenerator::generateLUTs	(	unsigned	e,
		unsigned	s,
		unsigned	se,
		unsigned	sb,
		unsigned	c
	)		const

generate and print LUT

Definition at line 19 of file CSCUpgradeMotherboardLUTGenerator.cc.

References generateLUTsME11(), generateLUTsME21(), and generateLUTsME3141().

Referenced by setRPCGeometry().

 {
   if (theStation==1) generateLUTsME11(theEndcap, theSector, theSubsector, theTrigChamber);
   if (theStation==2) generateLUTsME21(theEndcap, theSector, theSubsector, theTrigChamber);
   if (theStation==3) generateLUTsME3141(theEndcap, 3, theSector, theSubsector, theTrigChamber);
   if (theStation==4) generateLUTsME3141(theEndcap, 4, theSector, theSubsector, theTrigChamber);
 }

void CSCUpgradeMotherboardLUTGenerator::generateLUTsME11	(	unsigned	e,
		unsigned	se,
		unsigned	sb,
		unsigned	c
	)		const

Definition at line 27 of file CSCUpgradeMotherboardLUTGenerator.cc.

References CSCDetId::chamber(), CSCGeometry::chamber(), GEMGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, cscHsToGemPadLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), gem_g, gemPadToCscHsLUT(), gemRollToEtaLimitsLUT(), and LogTrace.

Referenced by generateLUTs(), and setRPCGeometry().

 {
   bool gemGeometryAvailable(false);
   if (gem_g != nullptr) {
     LogTrace("CSCUpgradeMotherboardLUTGenerator")
       << "+++ generateLUTsME11() called for ME11 chamber! +++ \n";
     gemGeometryAvailable = true;
   }
   
   // check for GEM geometry
   if (not gemGeometryAvailable){
     LogTrace("CSCUpgradeMotherboardLUTGenerator")
       << "+++ generateLUTsME11() called for ME11 chamber without valid GEM geometry! +++ \n";
     return;
   }
 
   // CSC trigger geometry
   const int chid = CSCTriggerNumbering::chamberFromTriggerLabels(theSector, theSubsector, 1, theTrigChamber);
   const CSCDetId me1bId(theEndcap, 1, 1, chid, 0);
   const CSCDetId me1aId(theEndcap, 1, 4, chid, 0);
   const CSCChamber* cscChamberME1b(csc_g->chamber(me1bId));
   const CSCChamber* cscChamberME1a(csc_g->chamber(me1aId));
   const CSCLayer* keyLayerME1b(cscChamberME1b->layer(3));
   const CSCLayer* keyLayerME1a(cscChamberME1a->layer(3));
   
   // GEM trigger geometry
   const int region((theEndcap == 1) ? 1: -1);
   const GEMDetId gem_id_l1(region, 1, 1, 1, me1bId.chamber(), 0);
   const GEMDetId gem_id_l2(region, 1, 1, 2, me1bId.chamber(), 0);
   const GEMChamber* gemChamber_l1(gem_g->chamber(gem_id_l1));
   const GEMChamber* gemChamber_l2(gem_g->chamber(gem_id_l2));
   const GEMEtaPartition* randRoll(gemChamber_l1->etaPartition(2));
   
   // LUTs
   std::vector<std::pair<double,double> > gemRollEtaLimits_l1;
   std::vector<std::pair<double,double> > gemRollEtaLimits_l2;
   std::vector<std::pair<double,double> > cscWGToEtaLimits;
   std::vector<std::pair<int,int> > cscWgToGemRoll_l1;
   std::vector<std::pair<int,int> > cscWgToGemRoll_l2;
   std::vector<std::pair<int,int> > cscHsToGemPadME1a;
   std::vector<std::pair<int,int> > cscHsToGemPadME1b;
   std::vector<int> gemPadToCscHsME1a;
   std::vector<int> gemPadToCscHsME1b;
 
   gemRollToEtaLimitsLUT(gemChamber_l1, gemRollEtaLimits_l1);
   gemRollToEtaLimitsLUT(gemChamber_l2, gemRollEtaLimits_l2);
   cscWgToEtaLimitsLUT(keyLayerME1b, cscWGToEtaLimits);
   cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l1, cscWgToGemRoll_l1);
   cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l2, cscWgToGemRoll_l2);
   cscHsToGemPadLUT(keyLayerME1a, randRoll, 4, 93, cscHsToGemPadME1a);
   cscHsToGemPadLUT(keyLayerME1b, randRoll, 5, 124, cscHsToGemPadME1b);
   gemPadToCscHsLUT(keyLayerME1a, randRoll, gemPadToCscHsME1a);
   gemPadToCscHsLUT(keyLayerME1b, randRoll, gemPadToCscHsME1b);
 
   // print LUTs
   std::stringstream os;
   os << "ME11 "<< me1bId <<std::endl;
 
   os << "GEM L1 roll to eta limits" << std::endl;
   os << gemRollEtaLimits_l1;
 
   os << "GEM L2 roll to eta limits" << std::endl;
   os << gemRollEtaLimits_l2;
   
   os << "ME1b "<< me1bId <<std::endl;
   os << "WG roll to eta limits" << std::endl;
   os << cscWGToEtaLimits;
 
   os << "WG to Roll L1" << std::endl;
   os << cscWgToGemRoll_l1;
 
   os << "WG to Roll L2" << std::endl;
   os << cscWgToGemRoll_l2;
   
   os << "CSC HS to GEM pad LUT in ME1a" << std::endl;
   os << cscHsToGemPadME1a;
 
   os << "CSC HS to GEM pad LUT in ME1b" << std::endl;
   os << cscHsToGemPadME1b;
   
   os << "GEM pad to CSC HS LUT in ME1a" << std::endl;
   os << gemPadToCscHsME1a;
 
   os << "GEM pad to CSC HS LUT in ME1b" << std::endl;
   os << gemPadToCscHsME1b;
 
   // print LUTs
   LogTrace("CSCUpgradeMotherboardLUTGenerator") << os.str();
 }

void CSCUpgradeMotherboardLUTGenerator::generateLUTsME21	(	unsigned	e,
		unsigned	se,
		unsigned	sb,
		unsigned	c
	)		const

Definition at line 117 of file CSCUpgradeMotherboardLUTGenerator.cc.

References CSCDetId::chamber(), CSCGeometry::chamber(), GEMGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, cscHsToGemPadLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), gem_g, gemPadToCscHsLUT(), gemRollToEtaLimitsLUT(), and LogTrace.

Referenced by generateLUTs(), and setRPCGeometry().

 {
   bool gemGeometryAvailable(false);
   if (gem_g != nullptr) {
     LogTrace("CSCUpgradeMotherboardLUTGenerator") << "+++ generateLUTsME11() called for ME21 chamber! +++ \n";
     gemGeometryAvailable = true;
   }
 
   // check for GEM geometry
   if (not gemGeometryAvailable){
     LogTrace("CSCUpgradeMotherboardLUTGenerator") << "+++ generateLUTsME21() called for ME21 chamber without valid GEM geometry! +++ \n";
     return;
   }
   
   // CSC trigger geometry
   const int chid = CSCTriggerNumbering::chamberFromTriggerLabels(theSector, theSubsector, 2, theTrigChamber);
   const CSCDetId csc_id(theEndcap, 2, 1, chid, 0);
   const CSCChamber* cscChamber(csc_g->chamber(csc_id));
   const CSCLayer* keyLayer(cscChamber->layer(3));  
     
   // GEM trigger geometry
   const int region((theEndcap == 1) ? 1: -1);
   const GEMDetId gem_id_l1(region, 1, 2, 1, csc_id.chamber(), 0);
   const GEMDetId gem_id_l2(region, 1, 2, 2, csc_id.chamber(), 0);
   const GEMChamber* gemChamber_l1(gem_g->chamber(gem_id_l1));
   const GEMChamber* gemChamber_l2(gem_g->chamber(gem_id_l2));
   const GEMEtaPartition* randRoll(gemChamber_l1->etaPartition(2));
   
   // LUTs
   std::vector<std::pair<double,double> > gemRollEtaLimits_l1;
   std::vector<std::pair<double,double> > gemRollEtaLimits_l2;
   std::vector<std::pair<double,double> > cscWGToEtaLimits;
   std::vector<std::pair<int,int> > cscWgToGemRoll_l1;
   std::vector<std::pair<int,int> > cscWgToGemRoll_l2;
   std::vector<std::pair<int,int> > cscHsToGemPad;
   std::vector<int> gemPadToCscHs;
 
   gemRollToEtaLimitsLUT(gemChamber_l1, gemRollEtaLimits_l1);
   gemRollToEtaLimitsLUT(gemChamber_l2, gemRollEtaLimits_l2);
   cscWgToEtaLimitsLUT(keyLayer, cscWGToEtaLimits);
   cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l1, cscWgToGemRoll_l1);
   cscWgToRollLUT(cscWGToEtaLimits, gemRollEtaLimits_l2, cscWgToGemRoll_l2);
   cscHsToGemPadLUT(keyLayer, randRoll, 4, 155, cscHsToGemPad);
   gemPadToCscHsLUT(keyLayer, randRoll, gemPadToCscHs);
 
   std::stringstream os;
   os << "ME21 "<< csc_id <<std::endl;
 
   os << "GEM roll to eta limits L1" << std::endl;
   os << gemRollEtaLimits_l1;
 
   os << "GEM roll to eta limits L2" << std::endl;
   os << gemRollEtaLimits_l2;
 
   os << "WG to eta limits" << std::endl;
   os << cscWGToEtaLimits;
 
   os << "WG to Roll L1" << std::endl;
   os << cscWgToGemRoll_l1;
 
   os << "WG to Roll L2" << std::endl;
   os << cscWgToGemRoll_l2;
 
   os << "CSC HS to GEM pad LUT in ME21" << std::endl;
   os << cscHsToGemPad;
   
   os << "GEM pad to CSC HS LUT in ME21" << std::endl;
   os << gemPadToCscHs;
 
   // print LUTs
   LogTrace("CSCUpgradeMotherboardLUTGenerator") << os.str();
 }

void CSCUpgradeMotherboardLUTGenerator::generateLUTsME3141	(	unsigned	e,
		unsigned	s,
		unsigned	se,
		unsigned	sb,
		unsigned	c
	)		const

Definition at line 190 of file CSCUpgradeMotherboardLUTGenerator.cc.

References RPCGeometry::chamber(), CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, cscHsToRpcStripLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), CSCUpgradeMotherboardLUTGenerator::Helpers::getRPCfromCSC(), LogTrace, rpc_g, rpcRollToEtaLimitsLUT(), and rpcStripToCscHsLUT().

Referenced by generateLUTs(), and setRPCGeometry().

 {
   bool rpcGeometryAvailable(false);
   if (rpc_g != nullptr) {
     LogTrace("CSCUpgradeMotherboardLUTGenerator")<< "+++ generateLUTsME3141() called for ME3141 chamber! +++ \n";
     rpcGeometryAvailable = true;
   }
   
   if (not rpcGeometryAvailable){
     LogTrace("CSCUpgradeMotherboardLUTGenerator") << "+++ generateLUTsME3141() called for ME3141 chamber without valid RPC geometry! +++ \n";
     return;
   }
 
   // CSC trigger geometry
   const int chid = CSCTriggerNumbering::chamberFromTriggerLabels(theSector, theSubsector, theStation, theTrigChamber);
   const CSCDetId csc_id(theEndcap, theStation, 1, chid, 0);
   const CSCChamber* cscChamber(csc_g->chamber(csc_id));
   const CSCLayer* keyLayer(cscChamber->layer(3));
 
   // RPC trigger geometry
   const RPCDetId& rpc_id(CSCUpgradeMotherboardLUTGenerator::Helpers::getRPCfromCSC(csc_id));
   const RPCChamber* rpcChamber(rpc_g->chamber(rpc_id));
   const RPCRoll* randRoll(rpcChamber->roll(2));
 
   // LUTs
   std::vector<std::pair<double,double> > rpcRollToEtaLimits;
   std::vector<std::pair<double,double> > cscWGToEtaLimits;
   std::vector<std::pair<int,int> > cscWgToRpcRoll;
   std::vector<std::pair<int,int> > cscHsToRpcStrip;
   std::vector<int> rpcStripToCscHs;
 
   rpcRollToEtaLimitsLUT(rpcChamber, rpcRollToEtaLimits);
   cscWgToEtaLimitsLUT(keyLayer, cscWGToEtaLimits);
   cscWgToRollLUT(cscWGToEtaLimits, rpcRollToEtaLimits, cscWgToRpcRoll);
   cscHsToRpcStripLUT(keyLayer, randRoll, 5, 155, cscHsToRpcStrip);
   rpcStripToCscHsLUT(keyLayer, randRoll, rpcStripToCscHs);
 
   std::stringstream os;
   os << "ME31/41 "<< csc_id <<std::endl;
 
   os << "RPC roll to eta limits" << std::endl;
   os << rpcRollToEtaLimits;
 
   os << "WG to eta limits" << std::endl;
   os << cscWGToEtaLimits;
 
   os << "WG to Roll" << std::endl;
   os << cscWgToRpcRoll;
 
   os << "CSC HS to RPC strip LUT in ME3141" << std::endl;
   os << cscHsToRpcStrip;
   
   os << "RPC strip to CSC HS LUT in ME3141" << std::endl;
   os << rpcStripToCscHs;
 
   // print LUTs
   LogTrace("CSCUpgradeMotherboardLUTGenerator") << os.str();
 }

void CSCUpgradeMotherboardLUTGenerator::rpcRollToEtaLimitsLUT	(	const RPCChamber *	c,
		std::vector< std::pair< double, double > > &	lut
	)		const

private

Definition at line 276 of file CSCUpgradeMotherboardLUTGenerator.cc.

References funct::abs(), lumiPlot::lut, and RPCChamber::rolls().

Referenced by generateLUTsME3141(), and setRPCGeometry().

 {
   for(const auto& roll : rpcChamber->rolls()) {
     const float half_striplength(roll->specs()->specificTopology().stripLength()/2.);
     const LocalPoint lp_top(0., half_striplength, 0.);
     const LocalPoint lp_bottom(0., -half_striplength, 0.);
     const GlobalPoint gp_top(roll->toGlobal(lp_top));
     const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom));
     lut.push_back(std::make_pair(std::abs(gp_top.eta()), std::abs(gp_bottom.eta())));
   }
 }

void CSCUpgradeMotherboardLUTGenerator::rpcStripToCscHsLUT	(	const CSCLayer *	keyLayer,
		const RPCRoll *	randRoll,
		std::vector< int > &	lut
	)		const

private

Definition at line 364 of file CSCUpgradeMotherboardLUTGenerator.cc.

References RPCRoll::centreOfStrip(), CSCLayer::geometry(), runTauDisplay::gp, mps_fire::i, RPCRoll::nstrips(), digi_MixPreMix_cfi::strip, GeomDet::toGlobal(), and GeomDet::toLocal().

Referenced by generateLUTsME3141(), and setRPCGeometry().

 {
   const int nRPCStrips(randRoll->nstrips());
   const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry());
   for (int i = 1; i<= nRPCStrips; ++i){
     const LocalPoint lpRPC(randRoll->centreOfStrip(i));
     const GlobalPoint gp(randRoll->toGlobal(lpRPC));
     const LocalPoint lpCSC(keyLayer->toLocal(gp));
     const float strip(keyLayerGeometry->strip(lpCSC));
     lut.push_back( (int) (strip-0.25)/0.5 );
   }
 }

void CSCUpgradeMotherboardLUTGenerator::setCSCGeometry ( const CSCGeometry * g )

inline

set CSC and GEM geometries for the matching needs

Definition at line 26 of file CSCUpgradeMotherboardLUTGenerator.h.

References csc_g, and g.

26 { csc_g = g; }

CSCUpgradeMotherboardLUTGenerator::csc_g

const CSCGeometry * csc_g

Definition: CSCUpgradeMotherboardLUTGenerator.h:64

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

void CSCUpgradeMotherboardLUTGenerator::setGEMGeometry ( const GEMGeometry * g )

inline

Definition at line 27 of file CSCUpgradeMotherboardLUTGenerator.h.

References g, and gem_g.

27 { gem_g = g; }

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

CSCUpgradeMotherboardLUTGenerator::gem_g

const GEMGeometry * gem_g

Definition: CSCUpgradeMotherboardLUTGenerator.h:65

void CSCUpgradeMotherboardLUTGenerator::setRPCGeometry ( const RPCGeometry * g )

inline

Definition at line 28 of file CSCUpgradeMotherboardLUTGenerator.h.

References assignRoll(), EnergyCorrector::c, cscHsToGemPadLUT(), cscHsToRpcStripLUT(), cscWgToEtaLimitsLUT(), cscWgToRollLUT(), MillePedeFileConverter_cfg::e, PVValHelper::eta, g, gemPadToCscHsLUT(), gemRollToEtaLimitsLUT(), generateLUTs(), generateLUTsME11(), generateLUTsME21(), generateLUTsME3141(), rpc_g, rpcRollToEtaLimitsLUT(), rpcStripToCscHsLUT(), and alignCSCRings::s.

28 { rpc_g = g; }

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

CSCUpgradeMotherboardLUTGenerator::rpc_g

const RPCGeometry * rpc_g

Definition: CSCUpgradeMotherboardLUTGenerator.h:66