#include <CSCSectorReceiverLUT.h>

Public Member Functions
	CSCSectorReceiverLUT (int endcap, int sector, int subsector, int station, const edm::ParameterSet &pset, bool TMB07)

	CSCSectorReceiverLUT (const CSCSectorReceiverLUT &)

std::string	encodeFileIndex () const
	Helpers. More...

gbletadat	globalEtaME (int phi_bend, int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const

gbletadat	globalEtaME (unsigned address, const bool gangedME1a=false) const

gbletadat	globalEtaME (gbletaadd address, const bool gangedME1a=false) const

gblphidat	globalPhiMB (int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const

gblphidat	globalPhiMB (unsigned address, const bool gangedME1a=false) const

gblphidat	globalPhiMB (gblphiadd address, const bool gangedME1a=false) const

gblphidat	globalPhiME (int phi_local, int wire_group, int cscid, const bool gangedME1a=false) const

gblphidat	globalPhiME (unsigned address, const bool gangedME1a=false) const

gblphidat	globalPhiME (gblphiadd address, const bool gangedME1a=false) const

lclphidat	localPhi (int strip, int pattern, int quality, int lr, const bool gangedME1a=false) const
	Geometry Lookup Tables. More...

lclphidat	localPhi (unsigned address, const bool gangedME1a=false) const

lclphidat	localPhi (lclphiadd address, const bool gangedME1a=false) const

CSCSectorReceiverLUT &	operator= (const CSCSectorReceiverLUT &)

void	setCSCGeometry (const CSCGeometry *g)

	~CSCSectorReceiverLUT ()

Private Member Functions
gbletadat	calcGlobalEtaME (const gbletaadd &address) const
	Global Eta LUT. More...

gblphidat	calcGlobalPhiMB (const gblphidat &me_gphi_data) const

gblphidat	calcGlobalPhiME (const gblphiadd &address) const
	Global Phi LUT. More...

lclphidat	calcLocalPhi (const lclphiadd &address) const
	Local Phi LUT. More...

void	fillLocalPhiLUT ()

double	getGlobalEtaValue (const unsigned &cscid, const unsigned &wire_group, const unsigned &phi_local) const

double	getGlobalPhiValue (const CSCLayer *thelayer, const unsigned &strip, const unsigned &wire_group) const

void	readLUTsFromFile ()

Private Attributes
int	_endcap

int	_sector

int	_station

int	_subsector

const CSCGeometry *	csc_g

bool	isBinary

bool	isTMB07

bool	LUTsFromFile

edm::FileInPath	mb_gbl_phi_file

gblphidat *	mb_global_phi

edm::FileInPath	me_gbl_eta_file

edm::FileInPath	me_gbl_phi_file

gbletadat *	me_global_eta

gblphidat *	me_global_phi

edm::FileInPath	me_lcl_phi_file

bool	useMiniLUTs

Static Private Attributes
static lclphidat *	me_lcl_phi = 0

static bool	me_lcl_phi_loaded = false

Detailed Description

Author: Lindsey Gray, Slava Valuev, Jason Mumford

Provides Look Up Table information for use in the SP Core. Partial port from ORCA.

Definition at line 19 of file CSCSectorReceiverLUT.h.

Constructor & Destructor Documentation

CSCSectorReceiverLUT::CSCSectorReceiverLUT	(	int	endcap,
		int	sector,
		int	subsector,
		int	station,
		const edm::ParameterSet &	pset,
		bool	TMB07
	)

Definition at line 25 of file CSCSectorReceiverLUT.cc.

References encodeFileIndex(), edm::ParameterSet::getUntrackedParameter(), isBinary, LUTsFromFile, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, me_lcl_phi_file, readLUTsFromFile(), AlCaHLTBitMon_QueryRunRegistry::string, and useMiniLUTs.

                                                                 :_endcap(endcap),_sector(sector),
                                                                                        _subsector(subsector),
                                                                                        _station(station),isTMB07(TMB07)
 {
   LUTsFromFile = pset.getUntrackedParameter<bool>("ReadLUTs",false);
   useMiniLUTs = pset.getUntrackedParameter<bool>("UseMiniLUTs", true);
   isBinary = pset.getUntrackedParameter<bool>("Binary",false);
 
   me_global_eta = nullptr;
   me_global_phi = nullptr;
   mb_global_phi = nullptr;
   if(LUTsFromFile && !useMiniLUTs)
     {
       me_lcl_phi_file = pset.getUntrackedParameter<edm::FileInPath>("LocalPhiLUT", edm::FileInPath(std::string("L1Trigger/CSCTrackFinder/LUTs/LocalPhiLUT"
                                                            + (isBinary ? std::string(".bin") : std::string(".dat")))));
       me_gbl_phi_file = pset.getUntrackedParameter<edm::FileInPath>("GlobalPhiLUTME", edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalPhiME")
                                                        + encodeFileIndex()
                                                        + (isBinary ? std::string(".bin") : std::string(".dat")))));
       if(station == 1)
     mb_gbl_phi_file = pset.getUntrackedParameter<edm::FileInPath>("GlobalPhiLUTMB", edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalPhiMB")
                                                      + encodeFileIndex()
                                                      + (isBinary ? std::string(".bin") : std::string(".dat")))));
       me_gbl_eta_file = pset.getUntrackedParameter<edm::FileInPath>("GlobalEtaLUTME", edm::FileInPath((std::string("L1Trigger/CSCTrackFinder/LUTs/GlobalEtaME")
                                                        + encodeFileIndex()
                                                        + (isBinary ? std::string(".bin") : std::string(".dat")))));
       readLUTsFromFile();
     }
 
 }

CSCSectorReceiverLUT::CSCSectorReceiverLUT ( const CSCSectorReceiverLUT & lut )

Definition at line 56 of file CSCSectorReceiverLUT.cc.

References CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, mb_global_phi, me_global_eta, and me_global_phi.

                                                                          :_endcap(lut._endcap),
                                         _sector(lut._sector),
                                         _subsector(lut._subsector),
                                         _station(lut._station),
                                         me_lcl_phi_file(lut.me_lcl_phi_file),
                                         me_gbl_phi_file(lut.me_gbl_phi_file),
                                         mb_gbl_phi_file(lut.mb_gbl_phi_file),
                                         me_gbl_eta_file(lut.me_gbl_eta_file),
                                         LUTsFromFile(lut.LUTsFromFile),
                                         isBinary(lut.isBinary)
 {
   if(lut.mb_global_phi)
     {
       mb_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       memcpy(mb_global_phi, lut.mb_global_phi, (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(gblphidat));
     }
   else mb_global_phi = nullptr;
   if(lut.me_global_phi)
     {
       me_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       memcpy(me_global_phi, lut.me_global_phi, (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(gblphidat));
     }
   else me_global_phi = nullptr;
   if(lut.me_global_eta)
     {
       me_global_eta = new gbletadat[1<<CSCBitWidths::kGlobalEtaAddressWidth];
       memcpy(me_global_eta, lut.me_global_eta, (1<<CSCBitWidths::kGlobalEtaAddressWidth)*sizeof(gbletadat));
     }
   else me_global_eta = nullptr;
 }

CSCSectorReceiverLUT::~CSCSectorReceiverLUT ( )

Definition at line 126 of file CSCSectorReceiverLUT.cc.

References mb_global_phi, me_global_eta, me_global_phi, me_lcl_phi, and me_lcl_phi_loaded.

 {
   if(me_lcl_phi_loaded)
     {
       delete me_lcl_phi;
       me_lcl_phi = nullptr;
       me_lcl_phi_loaded = false;
     }
   if(me_global_eta)
     {
       delete me_global_eta;
       me_global_eta = nullptr;
     }
   if(me_global_phi)
     {
       delete me_global_phi;
       me_global_phi = nullptr;
     }
   if(mb_global_phi)
     {
       delete mb_global_phi;
       mb_global_phi = nullptr;
     }
 }

Member Function Documentation

gbletadat CSCSectorReceiverLUT::calcGlobalEtaME ( const gbletaadd & address ) const

private

Global Eta LUT.

Definition at line 718 of file CSCSectorReceiverLUT.cc.

References _sector, _station, CSCTFConstants::etaBins, Exception, getGlobalEtaValue(), CSCTFConstants::maxEta, CSCTriggerNumbering::maxTriggerCscId(), CSCTFConstants::minEta, CSCTriggerNumbering::minTriggerCscId(), mps_fire::result, relativeConstraints::ring, and CSCTriggerNumbering::ringFromTriggerLabels().

Referenced by globalEtaME().

 {
 
 
   gbletadat result;
   double float_eta = getGlobalEtaValue(address.cscid, address.wire_group, address.phi_local);
   unsigned int_eta = 0;
   unsigned bend_global = 0; // not filled yet... will change when it is.
   const double etaPerBin = (CSCTFConstants::maxEta - CSCTFConstants::minEta)/CSCTFConstants::etaBins;
   const unsigned me12EtaCut = 56;
 
 
 
 
 
   if ((float_eta < CSCTFConstants::minEta) || (float_eta >= CSCTFConstants::maxEta))
     {
       edm::LogWarning("CSCSectorReceiverLUT:OutOfBounds")
     << "CSCSectorReceiverLUT warning: float_eta = " << float_eta
     << " minEta = " << CSCTFConstants::minEta << " maxEta = " << CSCTFConstants::maxEta
     << "   station " << _station << " sector " << _sector
     << " chamber "   << address.cscid << " wire group " << address.wire_group;
 
       throw cms::Exception("CSCSectorReceiverLUT")
     << "+++ Value of CSC ID, " << float_eta
     << ", is out of bounds [" << CSCTFConstants::minEta << "-"
     << CSCTFConstants::maxEta << ") +++\n";
 
       //if (float_eta < CSCTFConstants::minEta)
       //result.global_eta = 0;
       //else if (float_eta >= CSCTFConstants::maxEta)
       //result.global_eta = CSCTFConstants::etaBins - 1;
     }
   else
     {
       float_eta -= CSCTFConstants::minEta;
       float_eta = float_eta/etaPerBin;
       int_eta = static_cast<unsigned>(float_eta);
       /* Commented until I find out its use.
       // Fine-tune eta boundary between DT and CSC.
       if ((intEta == L1MuCSCSetup::CscEtaStart() && (L1MuCSCSetup::CscEtaStartCorr() > 0.) ) ||
       (intEta == L1MuCSCSetup::CscEtaStart() - 1 && (L1MuCSCSetup::CscEtaStartCorr() < 0.) ) ) {
     bitEta = (thisEta-minEta-L1MuCSCSetup::CscEtaStartCorr())/EtaPerBin;
     intEta = static_cast<int>(bitEta);
       }
       */
       if (_station == 1 && address.cscid >= static_cast<unsigned>(CSCTriggerNumbering::minTriggerCscId())
       && address.cscid <= static_cast<unsigned>(CSCTriggerNumbering::maxTriggerCscId()) )
     {
       unsigned ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, address.cscid);
 
       if      (ring == 1 && int_eta <  me12EtaCut) {int_eta = me12EtaCut;}
       else if (ring == 2 && int_eta >= me12EtaCut) {int_eta = me12EtaCut-1;}
     }
       result.global_eta = int_eta;
     }
   result.global_bend = bend_global;
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::calcGlobalPhiMB ( const gblphidat & me_gphi_data ) const

private

Definition at line 538 of file CSCSectorReceiverLUT.cc.

References _subsector.

Referenced by globalPhiMB().

 {
   gblphidat dtlut;
 
   // The following method was ripped from D. Holmes' LUT conversion program
   // modifications from Darin and GP
   int GlobalPhiMin = (_subsector == 1) ? 0x42 : 0x800;  // (0.999023 : 31 in degrees)
   int GlobalPhiMax = (_subsector == 1) ? 0x7ff : 0xfbd; // (30.985 : 60.986 in degrees)
   double GlobalPhiShift = (1.0*GlobalPhiMin + (GlobalPhiMax - GlobalPhiMin)/2.0);
 
   double dt_out = static_cast<double>(csclut.global_phi) - GlobalPhiShift;
 
   // these numbers are 62 deg / 1 rad (CSC phi scale vs. DT phi scale)
   dt_out = (dt_out/1982)*2145; //CSC phi 62 degrees; DT phi 57.3 degrees
 
   if(dt_out >= 0) // msb != 1
     {
       dtlut.global_phi = 0x7ff&static_cast<unsigned>(dt_out);
     }
   else
     {
       dtlut.global_phi = static_cast<unsigned>(-dt_out);
       dtlut.global_phi = ~dtlut.global_phi;
       dtlut.global_phi |= 0x800;
     }
 
   return dtlut;
 }

gblphidat CSCSectorReceiverLUT::calcGlobalPhiME ( const gblphiadd & address ) const

private

Global Phi LUT.

Definition at line 270 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), constexpr, csc_g, caloCompatibility_cff::delta_phi, MillePedeFileConverter_cfg::e, Exception, CSCLayer::geometry(), getGlobalPhiValue(), isTMB07, CSCConstants::KEY_CLCT_LAYER, CSCConstants::KEY_CLCT_LAYER_PRE_TMB07, CSCBitWidths::kGlobalPhiDataBitWidth, CSCBitWidths::kLocalPhiDataBitWidth, CSCChamber::layer(), LogDebug, M_PI, CSCConstants::MAX_NUM_STRIPS, CSCTriggerNumbering::maxTriggerCscId(), CSCTriggerNumbering::minTriggerCscId(), CSCLayerGeometry::numberOfStrips(), mps_fire::result, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), CSCTFConstants::SECTOR1_CENT_RAD, CSCTFConstants::SECTOR_DEG, CSCTFConstants::SECTOR_RAD, digitizers_cfi::strip, and cms::Exception::what().

Referenced by globalPhiME().

 {
   gblphidat result(0);
   const CSCChamber* thechamber = nullptr;
   const CSCLayer* thelayer = nullptr;
   const CSCLayerGeometry* layergeom = nullptr;
   int cscid = address.cscid;
   unsigned wire_group = address.wire_group;
   unsigned local_phi = address.phi_local;
   const double sectorOffset = (CSCTFConstants::SECTOR1_CENT_RAD-CSCTFConstants::SECTOR_RAD/2.) + (_sector-1)*M_PI/3.;
 
   //Number of global phi units per radian.
   constexpr int maxPhiG = 1<<CSCBitWidths::kGlobalPhiDataBitWidth;
   double binPhiG = static_cast<double>(maxPhiG)/CSCTFConstants::SECTOR_RAD;
 
   // We will use these to convert the local phi into radians.
   constexpr unsigned int maxPhiL = 1<<CSCBitWidths::kLocalPhiDataBitWidth;
   const double binPhiL = static_cast<double>(maxPhiL)/(2.*CSCConstants::MAX_NUM_STRIPS);
 
   if(cscid < CSCTriggerNumbering::minTriggerCscId())
     {
       edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
     << " warning: cscId " << cscid << " is out of bounds ["
     << CSCTriggerNumbering::minTriggerCscId() << "-"
     << CSCTriggerNumbering::maxTriggerCscId() << "]\n";
       throw cms::Exception("CSCSectorReceiverLUT")
     << "+++ Value of CSC ID, " << cscid
     << ", is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
     << CSCTriggerNumbering::maxTriggerCscId() << "] +++\n";
     }
 
   if(cscid > CSCTriggerNumbering::maxTriggerCscId())
     {
       edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
     << " warning: cscId " << cscid << " is out of bounds ["
     << CSCTriggerNumbering::minTriggerCscId() << "-"
     << CSCTriggerNumbering::maxTriggerCscId() << "]\n";
       throw cms::Exception("CSCSectorReceiverLUT")
     << "+++ Value of CSC ID, " << cscid
     << ", is out of bounds [" << CSCTriggerNumbering::minTriggerCscId() << "-"
     << CSCTriggerNumbering::maxTriggerCscId() << "] +++\n";
     }
 
   if(wire_group >= 1<<5)
     {
       edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
     << "warning: wire_group" << wire_group
     << " is out of bounds (1-" << ((1<<5)-1) << "]\n";
       throw cms::Exception("CSCSectorReceiverLUT")
     << "+++ Value of wire_group, " << wire_group
     << ", is out of bounds (1-" << ((1<<5)-1) << "] +++\n";
     }
 
   if(local_phi >= maxPhiL)
     {
       edm::LogWarning("CSCSectorReceiverLUT|getGlobalPhiValue")
     << "warning: local_phi" << local_phi
     << " is out of bounds [0-" << maxPhiL << ")\n";
       throw cms::Exception("CSCSectorReceiverLUT")
     << "+++ Value of local_phi, " << local_phi
     << ", is out of bounds [0-, " << maxPhiL << ") +++\n";
     }
 
   try
     {
       int ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid);
       int chid = CSCTriggerNumbering::chamberFromTriggerLabels(_sector, _subsector, _station, cscid);
       CSCDetId detid(_endcap, _station, ring, chid, 0);
       thechamber = const_cast<const CSCChamber*>(csc_g->chamber(detid));
       if(thechamber)
     {
       if(isTMB07)
         {
           layergeom = thechamber->layer(CSCConstants::KEY_CLCT_LAYER)->geometry();
           thelayer = thechamber->layer(CSCConstants::KEY_CLCT_LAYER);
         }
       else
         {
           layergeom = thechamber->layer(CSCConstants::KEY_CLCT_LAYER_PRE_TMB07)->geometry();
           thelayer = thechamber->layer(CSCConstants::KEY_CLCT_LAYER_PRE_TMB07);
         }
       const int nStrips = layergeom->numberOfStrips();
       // PhiL is the strip number converted into some units between 0 and
       // 1023.  When we did the conversion in fillLocalPhiTable(), we did
       // not know for which chamber we do it (and, therefore, how many strips
       // it has), and always used the maximum possible number of strips
       // per chamber, MAX_NUM_STRIPS=80.  Now, since we know the chamber id
       // and how many strips the chamber has, we can re-adjust the scale.
       //const double scale = static_cast<double>(CSCConstants::MAX_NUM_STRIPS)/nStrips;
 
       int strip = 0, halfstrip = 0;
 
           halfstrip = static_cast<int>(local_phi/binPhiL);
           strip     = halfstrip/2;
 
       // Find the phi width of the chamber and the position of its "left"
       // (lower phi) edge (both in radians).
       // Phi positions of the centers of the first and of the last strips
       // in the chamber.
       const double phi_f = getGlobalPhiValue(thelayer, 1, wire_group);
       const double phi_l = getGlobalPhiValue(thelayer, nStrips, wire_group);
       // Phi widths of the half-strips at both ends of the chamber;
       // surprisingly, they are not the same.
       const double hsWidth_f = fabs(getGlobalPhiValue(thelayer, 2, wire_group) - phi_f)/2.;
       const double hsWidth_l = fabs(phi_l - getGlobalPhiValue(thelayer, nStrips - 1, wire_group))/2.;
 
       // The "natural" match between the strips and phi values -- when
       // a larger strip number corresponds to a larger phi value, i.e. strips
       // are counted clockwise if we look at them from the inside of the
       // detector -- is reversed for some stations.  At the moment, these
       // are stations 3 and 4 of the 1st endcap, and stations 1 and 2 of
       // the 2nd endcap.  Instead of using
       // if ((theEndcap == 1 && theStation <= 2) ||
       // (theEndcap == 2 && theStation >= 3)),
       // we get the order from the phi values of the first and the last strip
       // in a chamber, just in case the counting scheme changes in the future.
       // Once we know how the strips are counted, we can go from the middle
       // of the strips to their outer edges.
       bool   clockwiseOrder;
       double leftEdge, rightEdge;
       if (fabs(phi_f - phi_l) < M_PI)
         {
           if (phi_f < phi_l) clockwiseOrder = true;
           else clockwiseOrder = false;
         }
       else
         { // the chamber crosses the phi = pi boundary
           if (phi_f < phi_l) clockwiseOrder = false;
           else clockwiseOrder = true;
         }
       if (clockwiseOrder)
         {
           leftEdge  = phi_f - hsWidth_f;
           rightEdge = phi_l + hsWidth_l;
         }
       else
         {
           leftEdge  = phi_l - hsWidth_l;
           rightEdge = phi_f + hsWidth_f;
         }
       if (fabs(phi_f - phi_l) >= M_PI) {rightEdge += 2.*M_PI;}
       //double chamberWidth = (rightEdge - leftEdge);
 
       // Chamber offset, relative to the edge of the sector.
       //double chamberOffset = leftEdge - sectorOffset;
       //if (chamberOffset < -M_PI) chamberOffset += 2*M_PI;
 
       double temp_phi = 0.0, strip_phi = 0.0, delta_phi = 0.0;
       double distFromHalfStripCenter = 0.0, halfstripWidth = 0.0;
 
       if (strip < nStrips)
         {
           // Approximate distance from the center of the half-strip to the center
           // of this phil bin, in units of half-strip width.
           distFromHalfStripCenter = (local_phi+0.5)/binPhiL - halfstrip - 0.5;
           // Half-strip width (in rad), calculated as the half-distance between
           // the adjacent strips.  Since in the current ORCA implementation
           // the half-strip width changes from strip to strip, base the choice
           // of the adjacent strip on the half-strip number.
           if ((halfstrip%2 == 0 && halfstrip != 0) || halfstrip == 2*nStrips-1) {
         halfstripWidth =
           fabs(getGlobalPhiValue(thelayer, strip+1, wire_group) - getGlobalPhiValue(thelayer, strip, wire_group)) / 2.;
           }
           else
         {
           halfstripWidth =
             fabs(getGlobalPhiValue(thelayer, strip+1, wire_group) - getGlobalPhiValue(thelayer, strip+2, wire_group)) / 2.;
         }
           // Correction for the strips crossing the 180 degree boundary.
           if (halfstripWidth > M_PI/2.) halfstripWidth = M_PI - halfstripWidth;
           // Phi at the center of the strip.
           strip_phi = getGlobalPhiValue(thelayer, strip+1, wire_group);
           // Distance between the center of the strip and the phil position.
           delta_phi = halfstripWidth*(((halfstrip%2)-0.5)+distFromHalfStripCenter);
           if (clockwiseOrder)
         temp_phi = strip_phi+ delta_phi;
           else
         temp_phi = strip_phi- delta_phi;
         }
       else
         {
           // PhiL values that do not have corresponding strips (the chamber
           // has less than 80 strips assumed in fillLocalPhi).  It does not
           // really matter what we do with these values; at the moment, just
           // set them to the phis of the edges of the chamber.
           if (clockwiseOrder) temp_phi = rightEdge;
           else temp_phi = leftEdge;
         }
 
       // Finally, subtract the sector offset and convert to the scale of
       // the global phi.
 
       temp_phi -= sectorOffset;
 
       if (temp_phi < 0.) temp_phi += 2.*M_PI;
 
       temp_phi *= binPhiG;
 
       if (temp_phi < 0.)
         {
           result.global_phi = 0;
         }
       else if (temp_phi >= maxPhiG)
         {
           result.global_phi = maxPhiG - 1;
         }
       else
         {
          result.global_phi = static_cast<unsigned short>(temp_phi);
         }
 
       LogDebug("CSCSectorReceiverLUT")
         << "local_phi = " << local_phi
         << " halfstrip = " << halfstrip << " strip = " << strip
         << " distFromHalfStripCenter = " << distFromHalfStripCenter
         << " halfstripWidth = " << halfstripWidth
         << " strip phi = " << strip_phi/(M_PI/180.)
         << " temp_phi = " << temp_phi*CSCTFConstants::SECTOR_DEG/maxPhiG
         << " global_phi = "    << result.global_phi
         << " " << result.global_phi*CSCTFConstants::SECTOR_DEG/maxPhiG;
 
     }
     }
   catch(edm::Exception& e)
     {
       edm::LogError("CSCSectorReceiverLUT|getGlobalPhiValue") << e.what();
     }
 
   return result;
 }

lclphidat CSCSectorReceiverLUT::calcLocalPhi ( const lclphiadd & address ) const

private

Local Phi LUT.

Local Phi Bend is always zero. Until we start using it.

Definition at line 151 of file CSCSectorReceiverLUT.cc.

References _endcap, _station, constexpr, data, Exception, CSCPatternLUT::get2007Position(), CSCPatternLUT::getPosition(), isTMB07, CSCBitWidths::kLocalPhiDataBitWidth, LogDebug, and CSCConstants::MAX_NUM_STRIPS.

Referenced by localPhi().

 {
   lclphidat data;
 
   constexpr int maxPhiL = 1<<CSCBitWidths::kLocalPhiDataBitWidth;
   double binPhiL = static_cast<double>(maxPhiL)/(2.*CSCConstants::MAX_NUM_STRIPS);
 
   double patternOffset;
 
   if(isTMB07) patternOffset = CSCPatternLUT::get2007Position((theadd.pattern_type<<3) + theadd.clct_pattern);
   else patternOffset = CSCPatternLUT::getPosition(theadd.clct_pattern);
 
   // The phiL value stored is for the center of the half-/di-strip.
   if(theadd.strip < 2*CSCConstants::MAX_NUM_STRIPS)
     if(theadd.pattern_type == 1 || isTMB07) // if halfstrip (Note: no distrips in TMB 2007 patterns)
       data.phi_local = static_cast<unsigned>((0.5 + theadd.strip + patternOffset)*binPhiL);
     else // if distrip
       data.phi_local = static_cast<unsigned>((2 + theadd.strip + 4.*patternOffset)*binPhiL);
   else {
     throw cms::Exception("CSCSectorReceiverLUT")
       << "+++ Value of strip, " << theadd.strip
       << ", exceeds max allowed, " << 2*CSCConstants::MAX_NUM_STRIPS-1
       << " +++\n";
   }
 
   if (data.phi_local >= maxPhiL) {
     throw cms::Exception("CSCSectorReceiverLUT")
       << "+++ Value of phi_local, " << data.phi_local
       << ", exceeds max allowed, " << maxPhiL-1 << " +++\n";
   }
 
   LogDebug("CSCSectorReceiver")
     << "endcap = " << _endcap << " station = " << _station
     << " maxPhiL = " << maxPhiL << " binPhiL = " << binPhiL;
   LogDebug("CSCSectorReceiver")
     << "strip # " << theadd.strip << " hs/ds = " << theadd.pattern_type
     << " pattern = " << theadd.clct_pattern << " offset = " << patternOffset
     << " phi_local = " << data.phi_local;
 
   data.phi_bend_local = 0;
 
   return data; //return LUT result
 }

std::string CSCSectorReceiverLUT::encodeFileIndex ( ) const

Helpers.

Definition at line 817 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, MillePedeFileConverter_cfg::fileName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CSCSectorReceiverLUT().

                                                       {
   std::string fileName = "";
   if (_station == 1) {
     if (_subsector == 1) fileName += "1a";
     if (_subsector == 2) fileName += "1b";
   }
   else if (_station == 2) fileName += "2";
   else if (_station == 3) fileName += "3";
   else if (_station == 4) fileName += "4";
   fileName += "End";
   if (_endcap == 1) fileName += "1";
   else                fileName += "2";
   fileName += "Sec";
   if      (_sector == 1) fileName += "1";
   else if (_sector == 2) fileName += "2";
   else if (_sector == 3) fileName += "3";
   else if (_sector == 4) fileName += "4";
   else if (_sector == 5) fileName += "5";
   else if (_sector == 6) fileName += "6";
   fileName += "LUT";
   return fileName;
 }

void CSCSectorReceiverLUT::fillLocalPhiLUT ( )

private

Definition at line 197 of file CSCSectorReceiverLUT.cc.

 {
   // read data in from a file... Add this later.
 }

double CSCSectorReceiverLUT::getGlobalEtaValue	(	const unsigned &	cscid,
		const unsigned &	wire_group,
		const unsigned &	phi_local
	)		const

private

Calculate Eta correction

Definition at line 610 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, CSCLayer::centerOfWireGroup(), CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), csc_g, MillePedeFileConverter_cfg::e, PV3DBase< T, PVType, FrameType >::eta(), CSCLayer::geometry(), CSCConstants::KEY_ALCT_LAYER, CSCChamber::layer(), LogDebug, CSCConstants::MAX_NUM_STRIPS, CSCTriggerNumbering::maxTriggerCscId(), CSCTriggerNumbering::minTriggerCscId(), CSCLayerGeometry::numberOfStrips(), CSCLayerGeometry::numberOfWireGroups(), mps_fire::result, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), CSCLayerGeometry::stripWireGroupIntersection(), GeomDet::surface(), Surface::toGlobal(), and cms::Exception::what().

Referenced by calcGlobalEtaME().

 {
   double result = 0.0;
   unsigned wire_group = thewire_group;
   int cscid = thecscid;
   unsigned phi_local = thephi_local;
 
   // Flag to be set if one wants to apply phi corrections ONLY in ME1/1.
   // Turn it into a parameter?
   bool me1ir_only = false;
 
   if(cscid < CSCTriggerNumbering::minTriggerCscId() ||
      cscid > CSCTriggerNumbering::maxTriggerCscId()) {
        edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
      << " warning: cscId " << cscid
      << " is out of bounds [1-" << CSCTriggerNumbering::maxTriggerCscId()
      << "]\n";
       cscid = CSCTriggerNumbering::maxTriggerCscId();
     }
 
   CSCLayerGeometry* layerGeom = nullptr;
   const unsigned numBins = 1 << 2; // 4 local phi bins
 
   if(phi_local > numBins - 1) {
       edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
     << "warning: phiL " << phi_local
     << " is out of bounds [0-" << numBins - 1 << "]\n";
       phi_local = numBins - 1;
   }
   try
     {
       int ring = CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid);
       int chid = CSCTriggerNumbering::chamberFromTriggerLabels(_sector, _subsector, _station, cscid);
       CSCDetId detid(_endcap, _station, ring, chid, 0);
       const CSCChamber* thechamber = const_cast<const CSCChamber*>(csc_g->chamber(detid));
       if(thechamber) {
     layerGeom = const_cast<CSCLayerGeometry*>(thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->geometry());
     const unsigned nWireGroups = layerGeom->numberOfWireGroups();
 
     // Check wire group numbers; expect them to be counted from 0, as in
     // CorrelatedLCTDigi class.
     if (wire_group >= nWireGroups) {
        edm::LogWarning("CSCSectorReceiverLUT|getEtaValue")
          << "warning: wireGroup " << wire_group
         << " is out of bounds [0-" << nWireGroups << ")\n";
       wire_group = nWireGroups - 1;
     }
     // Convert to [1; nWireGroups] range used in geometry methods.
     wire_group += 1;
 
     // If me1ir_only is set, apply phi corrections only in ME1/1.
     if (me1ir_only &&
         (_station != 1 ||
          CSCTriggerNumbering::ringFromTriggerLabels(_station, cscid) != 1))
       {
         result = thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->centerOfWireGroup(wire_group).eta();
       }
     else {
       const unsigned nStrips = layerGeom->numberOfStrips();
       const unsigned nStripsPerBin = CSCConstants::MAX_NUM_STRIPS/numBins;
       // Check that no strips will be left out.
       if (nStrips%numBins != 0 || CSCConstants::MAX_NUM_STRIPS%numBins != 0)
         edm::LogWarning("CSCSectorReceiverLUT")
           << "getGlobalEtaValue warning: number of strips "
           << nStrips << " (" << CSCConstants::MAX_NUM_STRIPS
           << ") is not divisible by numBins " << numBins
           << " Station " << _station << " sector " << _sector
           << " subsector " << _subsector << " cscid " << cscid << "\n";
 
       unsigned    maxStripPrevBin = 0, maxStripThisBin = 0;
       unsigned    correctionStrip;
       LocalPoint  lPoint;
       GlobalPoint gPoint;
       // Bins phi_local and find the the middle strip for each bin.
       maxStripThisBin = nStripsPerBin * (phi_local+1);
       if (maxStripThisBin <= nStrips) {
         correctionStrip = nStripsPerBin/2 * (2*phi_local+1);
       }
       else {
         // If the actual number of strips in the chamber is smaller than
         // the number of strips corresponding to the right edge of this phi
         // local bin, we take the middle strip between number of strips
         // at the left edge of the bin and the actual number of strips.
         maxStripPrevBin = nStripsPerBin * phi_local;
         correctionStrip = (nStrips+maxStripPrevBin)/2;
       }
 
       lPoint = layerGeom->stripWireGroupIntersection(correctionStrip, wire_group);
       gPoint = thechamber->layer(CSCConstants::KEY_ALCT_LAYER)->surface().toGlobal(lPoint);
 
       // end calc of eta correction.
       result = gPoint.eta();
     }
       }
     }
   catch (cms::Exception &e)
     {
       LogDebug("CSCSectorReceiver|OutofBoundInput") << e.what();
     }
 
   return std::fabs(result);
 }

double CSCSectorReceiverLUT::getGlobalPhiValue	(	const CSCLayer *	thelayer,
		const unsigned &	strip,
		const unsigned &	wire_group
	)		const

private

Definition at line 246 of file CSCSectorReceiverLUT.cc.

References CSCLayer::centerOfStrip(), MillePedeFileConverter_cfg::e, LogDebug, M_PI, PV3DBase< T, PVType, FrameType >::phi(), mps_fire::result, and cms::Exception::what().

Referenced by calcGlobalPhiME().

 {
   double result = 0.0;
   //CSCLayerGeometry* thegeom;
   //LocalPoint lp;
   //GlobalPoint gp;
 
   try
     {
       //thegeom = const_cast<CSCLayerGeometry*>(thelayer->geometry());
       //lp = thegeom->stripWireGroupIntersection(strip, wire_group);
       //gp = thelayer->surface().toGlobal(lp);
       result = thelayer->centerOfStrip(strip).phi();//gp.phi();
 
       if (result < 0.) result += 2.*M_PI;
     }
   catch(edm::Exception& e)
     {
       LogDebug("CSCSectorReceiverLUT|getGlobalPhiValue") << e.what();
     }
 
   return result;
 }

gbletadat CSCSectorReceiverLUT::globalEtaME	(	int	phi_bend,
		int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = `false`
	)		const

Definition at line 779 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), isTMB07, CSCBitWidths::kLocalPhiDataBitWidth, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

Referenced by L1TCSCTF::analyze().

 {
   gbletadat result;
   gbletaadd theadd;
 
   theadd.phi_bend = tphi_bend;
   theadd.phi_local = (tphi_local>>(CSCBitWidths::kLocalPhiDataBitWidth - 2)) & 0x3; // want 2 msb of local phi
   theadd.wire_group = twire_group;
   theadd.cscid = tcscid;
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(_endcap, _sector, _station, _subsector, theadd.toint(), gangedME1a);
   else if(LUTsFromFile) result = me_global_eta[theadd.toint()];
   else result = calcGlobalEtaME(theadd);
 
 
   return result;
 }

gbletadat CSCSectorReceiverLUT::globalEtaME	(	unsigned	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 796 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), isTMB07, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

 {
   gbletadat result;
   gbletaadd theadd(address);
 
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(_endcap, _sector, _station, _subsector, address,  gangedME1a);
   else if(LUTsFromFile) result = me_global_eta[address];
   else result = calcGlobalEtaME(theadd);
   return result;
 }

gbletadat CSCSectorReceiverLUT::globalEtaME	(	gbletaadd	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 807 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalEtaME(), CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(), isTMB07, LUTsFromFile, me_global_eta, mps_fire::result, and useMiniLUTs.

 {
   gbletadat result;
 
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalEtaMEMini(_endcap, _sector, _station, _subsector, address.toint(), gangedME1a);
   else if(LUTsFromFile) result = me_global_eta[address.toint()];
   else result = calcGlobalEtaME(address);
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = `false`
	)		const

Definition at line 567 of file CSCSectorReceiverLUT.cc.

References calcGlobalPhiMB(), globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

 {
   gblphiadd address;
   gblphidat result;
 
   address.cscid = cscid;
   address.wire_group = ((1<<5)-1)&(wire_group>>2);
   address.phi_local = phi_local;
 
   // comment for now
   //  if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address.toint());
   //else
   if(LUTsFromFile) result = mb_global_phi[address.toint()];
   else result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	unsigned	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 585 of file CSCSectorReceiverLUT.cc.

References calcGlobalPhiMB(), globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

 {
   gblphidat result;
   gblphiadd theadd(address);
 
   //if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address);
   //else
   if(LUTsFromFile) result = mb_global_phi[theadd.toint()];
   else result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiMB	(	gblphiadd	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 598 of file CSCSectorReceiverLUT.cc.

References calcGlobalPhiMB(), globalPhiME(), LUTsFromFile, mb_global_phi, and mps_fire::result.

 {
   gblphidat result;
 
   //if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMBMini(_endcap, _sector, _subsector, address.toint());
   //else
   if(LUTsFromFile) result = mb_global_phi[address.toint()];
   else result = calcGlobalPhiMB(globalPhiME(address, gangedME1a));
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiME	(	int	phi_local,
		int	wire_group,
		int	cscid,
		const bool	gangedME1a = `false`
	)		const

Definition at line 501 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

Referenced by L1TCSCTF::analyze(), and globalPhiMB().

 {
   gblphidat result;
   gblphiadd theadd;
   theadd.phi_local = phi_local;
   theadd.wire_group = ((1<<5)-1)&(wire_group >> 2); // want 2-7 of wg
   theadd.cscid = cscid;
 
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(_endcap, _sector, _station, _subsector, theadd.toint(), gangedME1a);
   else if(LUTsFromFile) result = me_global_phi[theadd.toint()];
   else result = calcGlobalPhiME(theadd);
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiME	(	unsigned	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 516 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

 {
   gblphidat result;
 
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(_endcap, _sector, _station, _subsector, address, gangedME1a);
   else if(LUTsFromFile) result = me_global_phi[address];
   else result = calcGlobalPhiME(gblphiadd(address));
 
   return result;
 }

gblphidat CSCSectorReceiverLUT::globalPhiME	(	gblphiadd	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 527 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, calcGlobalPhiME(), CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(), isTMB07, LUTsFromFile, me_global_phi, mps_fire::result, and useMiniLUTs.

 {
   gblphidat result;
 
   if(useMiniLUTs && isTMB07) result = CSCSectorReceiverMiniLUT::calcGlobalPhiMEMini(_endcap, _sector, _station, _subsector, address.toint(), gangedME1a);
   else if(LUTsFromFile) result = me_global_phi[address.toint()];
   else result = calcGlobalPhiME(address);
 
   return result;
 }

lclphidat CSCSectorReceiverLUT::localPhi	(	int	strip,
		int	pattern,
		int	quality,
		int	lr,
		const bool	gangedME1a = `false`
	)		const

Geometry Lookup Tables.

Please note, the pattern used below is the 4 bit pattern. ex) digi->getPattern(), NOT digi->getCLCTPattern()

Definition at line 202 of file CSCSectorReceiverLUT.cc.

References jets_cff::quality, and digitizers_cfi::strip.

Referenced by L1TCSCTF::analyze().

 {
   lclphiadd theadd;
 
   theadd.strip = strip;
   theadd.clct_pattern = pattern & 0x7;
   theadd.pattern_type = (pattern & 0x8) >> 3;
   theadd.quality = quality;
   theadd.lr = lr;
   theadd.spare = 0;
 
   return localPhi(theadd, gangedME1a );
 }

lclphidat CSCSectorReceiverLUT::localPhi	(	unsigned	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 217 of file CSCSectorReceiverLUT.cc.

References calcLocalPhi(), CSCSectorReceiverMiniLUT::calcLocalPhiMini(), isTMB07, LUTsFromFile, me_lcl_phi, mps_fire::result, and useMiniLUTs.

 {
   lclphidat result;
   lclphiadd theadd(address);
 
   if(useMiniLUTs && isTMB07)
     {
       result = CSCSectorReceiverMiniLUT::calcLocalPhiMini(address, gangedME1a);
     }
   else if(LUTsFromFile) result = me_lcl_phi[address];
   else result = calcLocalPhi(theadd);
 
   return result;
 }

lclphidat CSCSectorReceiverLUT::localPhi	(	lclphiadd	address,
		const bool	gangedME1a = `false`
	)		const

Definition at line 232 of file CSCSectorReceiverLUT.cc.

References calcLocalPhi(), CSCSectorReceiverMiniLUT::calcLocalPhiMini(), isTMB07, LUTsFromFile, me_lcl_phi, mps_fire::result, and useMiniLUTs.

 {
   lclphidat result;
 
   if(useMiniLUTs && isTMB07)
     {
       result = CSCSectorReceiverMiniLUT::calcLocalPhiMini(address.toint(), gangedME1a);
     }
   else if(LUTsFromFile) result = me_lcl_phi[address.toint()];
   else result = calcLocalPhi(address);
 
   return result;
 }

CSCSectorReceiverLUT & CSCSectorReceiverLUT::operator= ( const CSCSectorReceiverLUT & lut )

Definition at line 87 of file CSCSectorReceiverLUT.cc.

References _endcap, _sector, _station, _subsector, isBinary, CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, LUTsFromFile, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, and me_lcl_phi_file.

 {
   if(this != &lut)
     {
       _endcap = lut._endcap;
       _sector = lut._sector;
       _subsector = lut._subsector;
       _station = lut._station;
       me_lcl_phi_file = lut.me_lcl_phi_file;
       me_gbl_phi_file = lut.me_gbl_phi_file;
       mb_gbl_phi_file = lut.mb_gbl_phi_file;
       me_gbl_eta_file = lut.me_gbl_eta_file;
       LUTsFromFile = lut.LUTsFromFile;
       isBinary = lut.isBinary;
 
       if(lut.mb_global_phi)
     {
       mb_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       memcpy(mb_global_phi, lut.mb_global_phi, (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(gblphidat));
     }
       else mb_global_phi = nullptr;
 
       if(lut.me_global_phi)
     {
       me_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       memcpy(me_global_phi, lut.me_global_phi, (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(gblphidat));
     }
       else me_global_phi = nullptr;
 
       if(lut.me_global_eta)
     {
       me_global_eta = new gbletadat[1<<CSCBitWidths::kGlobalEtaAddressWidth];
       memcpy(me_global_eta, lut.me_global_eta, (1<<CSCBitWidths::kGlobalEtaAddressWidth)*sizeof(gbletadat));
     }
       else me_global_eta = nullptr;
     }
   return *this;
 }

void CSCSectorReceiverLUT::readLUTsFromFile ( )

private

Arrays for holding read in LUT information. MB LUT arrays only initialized in ME1

Definition at line 840 of file CSCSectorReceiverLUT.cc.

References _station, end, edm::FileInPath::fullPath(), mps_fire::i, isBinary, CSCBitWidths::kGlobalEtaAddressWidth, CSCBitWidths::kGlobalPhiAddressWidth, CSCBitWidths::kLocalPhiAddressWidth, mb_gbl_phi_file, mb_global_phi, me_gbl_eta_file, me_gbl_phi_file, me_global_eta, me_global_phi, me_lcl_phi, me_lcl_phi_file, me_lcl_phi_loaded, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by CSCSectorReceiverLUT().

 {
   if(!me_lcl_phi_loaded)
     {
       me_lcl_phi = new lclphidat[1<<CSCBitWidths::kLocalPhiAddressWidth];
       std::string fName(me_lcl_phi_file.fullPath());
       std::ifstream LocalPhiLUT;
 
       edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
       if(isBinary)
     {
       LocalPhiLUT.open(fName.c_str(),std::ios::binary);
           LocalPhiLUT.seekg(0,std::ios::end);
           int length = LocalPhiLUT.tellg();
           if(length == (1<<CSCBitWidths::kLocalPhiAddressWidth)*sizeof(short))
         {
           LocalPhiLUT.seekg(0,std::ios::beg);
           LocalPhiLUT.read(reinterpret_cast<char*>(me_lcl_phi),length);
           LocalPhiLUT.close();
         }
       else
         edm::LogError("CSCSectorReceiverLUT") << "File "<< fName << " is incorrect size!";
       LocalPhiLUT.close();
     }
       else
         {
           LocalPhiLUT.open(fName.c_str());
           unsigned i = 0;
       unsigned short temp = 0;
           while(!LocalPhiLUT.eof() && i < 1<<CSCBitWidths::kLocalPhiAddressWidth)
         {
           LocalPhiLUT >> temp;
           me_lcl_phi[i++] = (*reinterpret_cast<lclphidat*>(&temp));
         }
       LocalPhiLUT.close();
     }
     }
   if(!me_global_phi)
     {
       me_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       std::string fName = me_gbl_phi_file.fullPath();
       std::ifstream GlobalPhiLUT;
 
       edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
       if(isBinary)
         {
           GlobalPhiLUT.open(fName.c_str(),std::ios::binary);
           GlobalPhiLUT.seekg(0,std::ios::end);
           int length = GlobalPhiLUT.tellg();
           if(length == (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(short))
             {
               GlobalPhiLUT.seekg(0,std::ios::beg);
               GlobalPhiLUT.read(reinterpret_cast<char*>(me_global_phi),length);
             }
           else
             edm::LogError("CSCSectorReceiverLUT") << "File "<< fName << " is incorrect size!";
           GlobalPhiLUT.close();
         }
       else
         {
           GlobalPhiLUT.open( fName.c_str());
           unsigned short temp = 0;
           unsigned i = 0;
           while(!GlobalPhiLUT.eof() && i < 1<<CSCBitWidths::kGlobalPhiAddressWidth)
         {
           GlobalPhiLUT >> temp;
           me_global_phi[i++] = (*reinterpret_cast<gblphidat*>(&temp));
         }
           GlobalPhiLUT.close();
         }
     }
   if(!mb_global_phi && _station == 1) // MB lut only in station one.
     {
       mb_global_phi = new gblphidat[1<<CSCBitWidths::kGlobalPhiAddressWidth];
       std::string fName = mb_gbl_phi_file.fullPath();
       std::ifstream GlobalPhiLUT;
 
       edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
       if(isBinary)
         {
           GlobalPhiLUT.open( fName.c_str(),std::ios::binary);
           GlobalPhiLUT.seekg(0,std::ios::end);
           int length = GlobalPhiLUT.tellg();
           if(length == (1<<CSCBitWidths::kGlobalPhiAddressWidth)*sizeof(short))
             {
               GlobalPhiLUT.seekg(0,std::ios::beg);
               GlobalPhiLUT.read(reinterpret_cast<char*>(mb_global_phi),length);
             }
           else
             edm::LogError("CSCSectorReceiverLUT") << "File "<< fName << " is incorrect size!";
           GlobalPhiLUT.close();
         }
       else
         {
           GlobalPhiLUT.open(fName.c_str());
           unsigned short temp = 0;
           unsigned i = 0;
           while(!GlobalPhiLUT.eof() && i < 1<<CSCBitWidths::kGlobalPhiAddressWidth)
         {
           GlobalPhiLUT >> temp;
           mb_global_phi[i++] = (*reinterpret_cast<gblphidat*>(&temp));
         }
           GlobalPhiLUT.close();
         }
     }
   if(!me_global_eta)
     {
       me_global_eta = new gbletadat[1<<CSCBitWidths::kGlobalEtaAddressWidth];
       std::string fName = me_gbl_eta_file.fullPath();
       std::ifstream GlobalEtaLUT;
 
       edm::LogInfo("CSCSectorReceiverLUT") << "Loading SR LUT: " << fName;
 
       if(isBinary)
     {
       GlobalEtaLUT.open(fName.c_str(),std::ios::binary);
       GlobalEtaLUT.seekg(0,std::ios::end);
       int length = GlobalEtaLUT.tellg();
       if(length == (1<<CSCBitWidths::kGlobalEtaAddressWidth)*sizeof(short))
         {
           GlobalEtaLUT.seekg(0,std::ios::beg);
           GlobalEtaLUT.read(reinterpret_cast<char*>(me_global_eta),length);
         }
       else
         edm::LogError("CSCSectorReceiverLUT") << "File "<< fName << " is incorrect size!";
       GlobalEtaLUT.close();
     }
       else
     {
       GlobalEtaLUT.open(fName.c_str());
       unsigned short temp = 0;
       unsigned i = 0;
       while(!GlobalEtaLUT.eof() && i < 1<<CSCBitWidths::kGlobalEtaAddressWidth)
       {
         GlobalEtaLUT >> temp;
         me_global_eta[i++] = (*reinterpret_cast<gbletadat*>(&temp));
       }
       GlobalEtaLUT.close();
     }
     }
 }

void CSCSectorReceiverLUT::setCSCGeometry ( const CSCGeometry * g )

inline

Definition at line 52 of file CSCSectorReceiverLUT.h.

References csc_g, and g.

52 { csc_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

CSCSectorReceiverLUT::csc_g

const CSCGeometry * csc_g

Definition: CSCSectorReceiverLUT.h:90