#include <AngleConverter.h>

Public Member Functions
	AngleConverter ()

void	checkAndUpdateGeometry (const edm::EventSetup &)
	Update the Geometry with current Event Setup. More...

int	getGlobalEta (unsigned int rawid, const L1MuDTChambPhDigi &aDigi, const L1MuDTChambThContainer *dtThDigis)
	Convert local eta coordinate to global digital microGMT scale. More...

int	getGlobalEta (unsigned int rawid, const CSCCorrelatedLCTDigi &aDigi)
	Convert local eta coordinate to global digital microGMT scale. More...

int	getGlobalEta (unsigned int rawid, const unsigned int &aDigi)
	Convert local eta coordinate to global digital microGMT scale. More...

int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const L1MuDTChambPhDigi &digi) const

int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const CSCDetId &csc, const CSCCorrelatedLCTDigi &digi) const

int	getProcessorPhi (unsigned int iProcessor, l1t::tftype part, const RPCDetId &rollId, const unsigned int &digi) const

	~AngleConverter ()

Private Member Functions
const int	findBTIgroup (const L1MuDTChambPhDigi &aDigi, const L1MuDTChambThContainer *dtThDigis)
	Find BTI group. More...

bool	isCSCCounterClockwise (const std::unique_ptr< const CSCLayer > &layer) const
	Check orientation of strips in given CSC chamber. More...

Private Attributes
edm::ESHandle< CSCGeometry >	_geocsc

edm::ESHandle< DTGeometry >	_geodt

unsigned long long	_geom_cache_id

edm::ESHandle< RPCGeometry >	_georpc

Detailed Description

Definition at line 27 of file AngleConverter.h.

Constructor & Destructor Documentation

AngleConverter::AngleConverter ( )

Definition at line 23 of file AngleConverter.cc.

23 : _geom_cache_id(0ULL) { }

AngleConverter::_geom_cache_id

unsigned long long _geom_cache_id

Definition: AngleConverter.h:62

AngleConverter::~AngleConverter ( )

Definition at line 26 of file AngleConverter.cc.

26 { }

Member Function Documentation

void AngleConverter::checkAndUpdateGeometry ( const edm::EventSetup & es )

Update the Geometry with current Event Setup.

Definition at line 29 of file AngleConverter.cc.

References _geocsc, _geodt, _geom_cache_id, _georpc, edm::eventsetup::EventSetupRecord::cacheIdentifier(), relativeConstraints::geom, edm::EventSetup::get(), and edm::eventsetup::EventSetupRecord::get().

Referenced by OMTFinputMaker::initialize().

                                                                    {
   const MuonGeometryRecord& geom = es.get<MuonGeometryRecord>();
   unsigned long long geomid = geom.cacheIdentifier();
   if( _geom_cache_id != geomid ) {
     geom.get(_georpc);  
     geom.get(_geocsc);    
     geom.get(_geodt);
     _geom_cache_id = geomid;
   }  
 }

const int AngleConverter::findBTIgroup	(	const L1MuDTChambPhDigi &	aDigi,
		const L1MuDTChambThContainer *	dtThDigis
	)

private

Find BTI group.

If there are more than one theta digi we do not take is due to unresolvet ambiguity. In this case we take eta of the middle of the chamber.

Definition at line 284 of file AngleConverter.cc.

References L1MuDTChambPhDigi::bxNum(), L1MuDTChambThContainer::chThetaSegm(), i, L1MuDTChambThDigi::position(), L1MuDTChambPhDigi::scNum(), L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

Referenced by getGlobalEta().

                                                                {
 
   int bti_group = -1;
   
   const L1MuDTChambThDigi *theta_segm = dtThDigis->chThetaSegm(aDigi.whNum(),
                                    aDigi.stNum(),
                                    aDigi.scNum(),
                                    aDigi.bxNum());
   if(!theta_segm) return  bti_group;
   
   for(unsigned int i = 0; i < 7; ++i ){
     if(theta_segm->position(i) && bti_group<0) bti_group = i;
     else if(theta_segm->position(i) && bti_group>-1) return -1;
   }
       
   return bti_group;
 }

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const L1MuDTChambPhDigi &	aDigi,
		const L1MuDTChambThContainer *	dtThDigis
	)

Convert local eta coordinate to global digital microGMT scale.

Definition at line 154 of file AngleConverter.cc.

References _geodt, PV3DBase< T, PVType, FrameType >::eta(), findBTIgroup(), L1MuDTChambPhDigi::scNum(), L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

Referenced by OMTFinputMaker::processCSC(), OMTFinputMaker::processDT(), and OMTFinputMaker::processRPC().

                                                          {
 
   
   const DTChamberId baseid(aDigi.whNum(),aDigi.stNum(),aDigi.scNum()+1);
   
   // do not use this pointer for anything other than creating a trig geom
   std::unique_ptr<DTChamber> chamb(const_cast<DTChamber*>(_geodt->chamber(baseid)));
   
   std::unique_ptr<DTTrigGeom> trig_geom( new DTTrigGeom(chamb.get(),false) );
   chamb.release(); // release it here so no one gets funny ideas  
   // super layer one is the theta superlayer in a DT chamber
   // station 4 does not have a theta super layer
   // the BTI index from the theta trigger is an OR of some BTI outputs
   // so, we choose the BTI that's in the middle of the group
   // as the BTI that we get theta from
   // TODO:::::>>> need to make sure this ordering doesn't flip under wheel sign
   const int NBTI_theta = ( (baseid.station() != 4) ? 
                trig_geom->nCell(2) : trig_geom->nCell(3) );
   const int bti_group = findBTIgroup(aDigi,dtThDigis);
   const unsigned bti_actual = bti_group*NBTI_theta/7 + NBTI_theta/14 + 1;  
   DTBtiId thetaBTI;  
   if ( baseid.station() != 4 && bti_group != -1) {
     thetaBTI = DTBtiId(baseid,2,bti_actual);
   } else {
     // since this is phi oriented it'll give us theta in the middle
     // of the chamber
     thetaBTI = DTBtiId(baseid,3,1); 
   }
   const GlobalPoint theta_gp = trig_geom->CMSPosition(thetaBTI);
   int iEta = theta_gp.eta()/2.61*240;
   return iEta;
 }

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const CSCCorrelatedLCTDigi &	aDigi
	)

Convert local eta coordinate to global digital microGMT scale.

Code taken from GeometryTranslator.

Will be replaced by direct CSC phi local to global scale transformation as used in FPGA implementation

Definition at line 190 of file AngleConverter.cc.

References _geocsc, PV3DBase< T, PVType, FrameType >::eta(), CSCPatternLUT::get2007Position(), CSCCorrelatedLCTDigi::getKeyWG(), CSCCorrelatedLCTDigi::getPattern(), CSCCorrelatedLCTDigi::getStrip(), isCSCCounterClockwise(), CSCConstants::KEY_ALCT_LAYER, PV3DBase< T, PVType, FrameType >::mag(), hltrates_dqm_sourceclient-live_cfg::offset, listBenchmarks::pattern, PV3DBase< T, PVType, FrameType >::phi(), PV3DBase< T, PVType, FrameType >::theta(), and Geom::Phi< T >::value().

                                                                                      {
 
 
   
   // alot of this is transcription and consolidation of the CSC
   // global phi calculation code
   // this works directly with the geometry 
   // rather than using the old phi luts
   const CSCDetId id(rawid); 
   // we should change this to weak_ptrs at some point
   // requires introducing std::shared_ptrs to geometry
   std::unique_ptr<const CSCChamber> chamb(_geocsc->chamber(id));
   std::unique_ptr<const CSCLayerGeometry> layer_geom(
                              chamb->layer(CSCConstants::KEY_ALCT_LAYER)->geometry()
                              );
   std::unique_ptr<const CSCLayer> layer(
                     chamb->layer(CSCConstants::KEY_ALCT_LAYER)
                     );
   
   const uint16_t halfstrip = aDigi.getStrip();
   const uint16_t pattern = aDigi.getPattern();
   const uint16_t keyWG = aDigi.getKeyWG();
   //const unsigned maxStrips = layer_geom->numberOfStrips();  
 
   // so we can extend this later 
   // assume TMB2007 half-strips only as baseline
   double offset = 0.0;
   switch(1) {
   case 1:
     offset = CSCPatternLUT::get2007Position(pattern);
   }
   const unsigned halfstrip_offs = unsigned(0.5 + halfstrip + offset);
   const unsigned strip = halfstrip_offs/2 + 1; // geom starts from 1
 
   // the rough location of the hit at the ALCT key layer
   // we will refine this using the half strip information
   const LocalPoint coarse_lp = 
     layer_geom->stripWireGroupIntersection(strip,keyWG);  
   const GlobalPoint coarse_gp = layer->surface().toGlobal(coarse_lp);  
   
   // the strip width/4.0 gives the offset of the half-strip
   // center with respect to the strip center
   const double hs_offset = layer_geom->stripPhiPitch()/4.0;
   
   // determine handedness of the chamber
   const bool ccw = isCSCCounterClockwise(layer);
   // we need to subtract the offset of even half strips and add the odd ones
   const double phi_offset = ( ( halfstrip_offs%2 ? 1 : -1)*
                   ( ccw ? -hs_offset : hs_offset ) );
   
   // the global eta calculation uses the middle of the strip
   // so no need to increment it
   const GlobalPoint final_gp( GlobalPoint::Polar( coarse_gp.theta(),
                           (coarse_gp.phi().value() + 
                            phi_offset),
                           coarse_gp.mag() ) );  
   // release ownership of the pointers
   chamb.release();
   layer_geom.release();
   layer.release();
 
   int iEta =  final_gp.eta()/2.61*240;
   return iEta;  
 }

int AngleConverter::getGlobalEta	(	unsigned int	rawid,
		const unsigned int &	aDigi
	)

Convert local eta coordinate to global digital microGMT scale.

Definition at line 259 of file AngleConverter.cc.

References _georpc, and PV3DBase< T, PVType, FrameType >::eta().

                                                                              {
 
   const RPCDetId id(rawid);
   std::unique_ptr<const RPCRoll>  roll(_georpc->roll(id));
   const LocalPoint lp = roll->centreOfStrip((int)strip);
   const GlobalPoint gp = roll->toGlobal(lp);
   roll.release();
 
   float iEta = gp.eta()/2.61*240;
 
   return iEta;
 
 } 

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const L1MuDTChambPhDigi &	digi
	)		const

get phi of DT,CSC and RPC azimutal angle digi in processor scale, used by OMTF algorithm. in case of wrong phi returns OMTFConfiguration::instance()->nPhiBins

Definition at line 42 of file AngleConverter.cc.

References OMTFConfiguration::instance(), M_PI, OMTFConfiguration::nPhiBins, l1t::omtf_pos, phi, L1MuDTChambPhDigi::phi(), pileupReCalc_HLTpaths::scale, L1MuDTChambPhDigi::scNum(), relativeConstraints::station, L1MuDTChambPhDigi::stNum(), and L1MuDTChambPhDigi::whNum().

Referenced by OMTFinputMaker::processCSC(), OMTFinputMaker::processDT(), and OMTFinputMaker::processRPC().

 {
 
   double hsPhiPitch = 2*M_PI/OMTFConfiguration::instance()->nPhiBins; // width of phi Pitch, related to halfStrip at CSC station 2
   const int dummy = OMTFConfiguration::instance()->nPhiBins;
 
   int processor= iProcessor+1;                           // FIXME: get from OMTF name when available
   int posneg = (part==l1t::tftype::omtf_pos) ? 1 : -1;        // FIXME: get from OMTF name
 
   int sector  = digi.scNum()+1;   //NOTE: there is a inconsistency in DT sector numb. Thus +1 needed to get detector numb.
   int wheel   = digi.whNum();
   int station = digi.stNum();
   int phiDT   = digi.phi();
 
   if (posneg*2 != wheel) return dummy;
   if (station > 3 ) return dummy;
 
   //FIXME: update the following two lines with proper method when Connections introduced
   if (processor !=6 && !(sector >= processor*2-1 && sector <= processor*2+1) ) return dummy;
   if (processor ==6 && !(sector >= 11 || sector==1) ) return dummy;
 
   // ichamber is consecutive chamber connected to processor, starting from 0 (overlaping one)
   int ichamber = sector-1-2*(processor-1);
   if (ichamber < 0) ichamber += 12;
 
   int offsetLoc = lround( ((ichamber-1)*M_PI/6+M_PI/12.)/hsPhiPitch );
   double scale = 1./4096/hsPhiPitch;
 
   int phi = static_cast<int>(phiDT*scale) + offsetLoc;
 
   return phi;
 }

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const CSCDetId &	csc,
		const CSCCorrelatedLCTDigi &	digi
	)		const

Definition at line 76 of file AngleConverter.cc.

References _geocsc, CSCLayer::centerOfStrip(), CSCDetId::chamber(), CSCCorrelatedLCTDigi::getStrip(), OMTFConfiguration::instance(), CSCChamber::layer(), M_PI, OMTFConfiguration::nPhiBins, l1t::omtf_pos, phi, PV3DBase< T, PVType, FrameType >::phi(), CSCDetId::ring(), pileupReCalc_HLTpaths::scale, CSCChamber::specs(), CSCDetId::station(), CSCChamberSpecs::stripPhiPitch(), and CSCDetId::zendcap().

 {
 
   const double hsPhiPitch = 2*M_PI/OMTFConfiguration::instance()->nPhiBins; //
   const int dummy = OMTFConfiguration::instance()->nPhiBins;
 
   int processor= iProcessor+1;                           // FIXME: get from OMTF name when available
   int posneg = (part==l1t::tftype::omtf_pos) ? 1 : -1;        // FIXME: get from OMTF name
 
 
 
   // filter out chambers not connected to OMTF board
   // FIXME: temporary - use Connections or relay that filtering done before.
   if (posneg != csc.zendcap()) return dummy;
   if ( csc.ring() != 3 && !(csc.ring()==2 && (csc.station()==2 || csc.station()==3 || csc.station()==1)) ) return dummy;
   if (processor !=6) {
     if (csc.chamber() < (processor-1)*6 + 2) return dummy;
     if (csc.chamber() > (processor-1)*6 + 8) return dummy;
   } else {
     if (csc.chamber() > 2 && csc.chamber() < 32) return dummy;
   }
 
   //
   // assign number 0..6, consecutive processor for a processor
   //
   //int ichamber = (csc.chamber()-2-6*(processor-1));
   //if (ichamber < 0) ichamber += 36;
 
   //
   // get offset for each chamber.
   // FIXME: These parameters depends on processor and chamber only so may be precomputed and put in map
   //
   const CSCChamber* chamber = _geocsc->chamber(csc);
   const CSCChamberSpecs* cspec = chamber->specs();
   const CSCLayer* layer = chamber->layer(3);
   int order = ( layer->centerOfStrip(2).phi() - layer->centerOfStrip(1).phi()> 0) ? 1 : -1;
   double stripPhiPitch = cspec->stripPhiPitch();
   double scale = fabs(stripPhiPitch/hsPhiPitch/2.); if ( fabs(scale-1.) < 0.0002) scale=1.;
   double phi15deg = M_PI/3.*(processor-1)+M_PI/12.;
   double phiHalfStrip0 = layer->centerOfStrip(10).phi() - order*9*stripPhiPitch - order*stripPhiPitch/4.;
   if ( processor==6 || phiHalfStrip0<0) phiHalfStrip0 += 2*M_PI;
   int offsetLoc = lround( (phiHalfStrip0-phi15deg)/hsPhiPitch );
 
   int halfStrip = digi.getStrip(); // returns halfStrip 0..159
   //FIXME: to be checked (only important for ME1/3) keep more bits for offset, truncate at the end
   int phi = offsetLoc + order*scale*halfStrip;
 
   return phi;
 }

int AngleConverter::getProcessorPhi	(	unsigned int	iProcessor,
		l1t::tftype	part,
		const RPCDetId &	rollId,
		const unsigned int &	digi
	)		const

Definition at line 128 of file AngleConverter.cc.

References _georpc, RPCRoll::centreOfStrip(), OMTFConfiguration::instance(), M_PI, OMTFConfiguration::nPhiBins, and GeomDet::toGlobal().

 {
   const double hsPhiPitch = 2*M_PI/OMTFConfiguration::instance()->nPhiBins; //
   const int dummy = OMTFConfiguration::instance()->nPhiBins;
 
   int processor = iProcessor+1;
   const RPCRoll* roll = _georpc->roll(rollId);
   if (!roll) return dummy;
 
   double phi15deg =  M_PI/3.*(processor-1)+M_PI/12.;                    // "0" is 15degree moved cyclicaly to each processor, note [0,2pi]
   double stripPhi = (roll->toGlobal(roll->centreOfStrip((int)digi))).phi(); // note [-pi,pi]
 
   // adjust [0,2pi] and [-pi,pi] to get deltaPhi difference properly
   switch (processor) {
     case 1: break;
     case 6: {phi15deg -= 2*M_PI; break; }
     default : {if (stripPhi < 0) stripPhi += 2*M_PI; break; }
   }
 
   // local angle in CSC halfStrip usnits
   int halfStrip = lround ( (stripPhi-phi15deg)/hsPhiPitch );
     
   return halfStrip;
 }

bool AngleConverter::isCSCCounterClockwise ( const std::unique_ptr< const CSCLayer > & layer ) const

private

Check orientation of strips in given CSC chamber.

Definition at line 275 of file AngleConverter.cc.

References funct::abs(), and M_PI.

Referenced by getGlobalEta().

                                                                         {
   const int nStrips = layer->geometry()->numberOfStrips();
   const double phi1 = layer->centerOfStrip(1).phi();
   const double phiN = layer->centerOfStrip(nStrips).phi();
   return ( (std::abs(phi1 - phiN) < M_PI  && phi1 >= phiN) || 
        (std::abs(phi1 - phiN) >= M_PI && phi1 < phiN)     );  
 }