RPCtoDTTranslator Class Reference

#include <RPCtoDTTranslator.h>

Public Member Functions
L1MuDTChambPhContainer const &	getDTContainer () const
	Return Output PhContainer. More...
L1MuDTChambPhContainer const &	getDTRPCHitsContainer () const
	RPCtoDTTranslator (const RPCDigiCollection &inrpcDigis)
void	run (const edm::EventSetup &c)

Static Public Member Functions
static int	bendingAngle (int, int, int)
static int	localX (RPCDetId, const edm::EventSetup &, int)
	function - will be replaced by LUTs(?) More...
static int	localXX (int, int, int)
static int	radialAngle (RPCDetId, const edm::EventSetup &, int)
	function - will be replaced by LUTs(?) More...

Private Attributes
const RPCDigiCollection &	m_rpcDigis
L1MuDTChambPhContainer	m_rpcdt_translated
	Output PhContainer. More...
L1MuDTChambPhContainer	m_rpchitsdt_translated

Detailed Description

Definition at line 32 of file RPCtoDTTranslator.h.

Constructor & Destructor Documentation

RPCtoDTTranslator::RPCtoDTTranslator

(

const RPCDigiCollection &

inrpcDigis

)

Definition at line 28 of file RPCtoDTTranslator.cc.

References mps_check::array, constexpr, createfilelist::int, operator[](), or, findQualityFiles::size, relativeConstraints::station, digitizers_cfi::strip, and makeMuonMisalignmentScenario::wheel.

                                                                        :
  m_rpcDigis{inrpcDigis}
{
}

Member Function Documentation

int RPCtoDTTranslator::bendingAngle ( int  xin, int  xout, int  phi  )

static

Definition at line 342 of file RPCtoDTTranslator.cc.

References createfilelist::int.

Referenced by getDTRPCHitsContainer(), and run().

                                                             {
    // use chamber size and max angle in hw units 512
    int atanv = (int)(atan((xout-xin)/34.6) * 512);
    if(atanv>512) return 512;
    int rvalue = atanv - phi/8;
    return rvalue;
}

L1MuDTChambPhContainer const& RPCtoDTTranslator::getDTContainer ( ) const

inline

Return Output PhContainer.

Definition at line 39 of file RPCtoDTTranslator.h.

References m_rpcdt_translated.

{  return m_rpcdt_translated;}

L1MuDTChambPhContainer const& RPCtoDTTranslator::getDTRPCHitsContainer ( ) const

inline

Definition at line 40 of file RPCtoDTTranslator.h.

References bendingAngle(), localX(), localXX(), m_rpchitsdt_translated, and radialAngle().

{  return m_rpchitsdt_translated;}

int RPCtoDTTranslator::localX ( RPCDetId  detid, const edm::EventSetup &  c, int  strip  )

static

function - will be replaced by LUTs(?)

Orientaion of RPCs

—Orientaion

Definition at line 325 of file RPCtoDTTranslator.cc.

References funct::abs(), RPCRoll::centreOfStrip(), edm::EventSetup::get(), PV3DBase< T, PVType, FrameType >::phi(), RPCGeometry::roll(), GeomDet::toGlobal(), and PV3DBase< T, PVType, FrameType >::x().

Referenced by getDTRPCHitsContainer(), and IOPrinter::run().

                                                                              {
    edm::ESHandle<RPCGeometry> rpcGeometry;
    c.get<MuonGeometryRecord>().get(rpcGeometry);

    const RPCRoll* roll = rpcGeometry->roll(detid);

    GlobalPoint p1cmPRG = roll->toGlobal(LocalPoint(1,0,0));
    GlobalPoint m1cmPRG = roll->toGlobal(LocalPoint(-1,0,0));
    float phip1cm = p1cmPRG.phi();
    float phim1cm = m1cmPRG.phi();
    int direction = (phip1cm-phim1cm)/abs(phip1cm-phim1cm);

    return direction * roll->centreOfStrip(strip).x();
}

int RPCtoDTTranslator::localXX ( int  phi, int  layer, int  station  )

static

Definition at line 350 of file RPCtoDTTranslator.cc.

References dttmaxenums::R, and funct::tan().

Referenced by getDTRPCHitsContainer(), and run().

                                                             {
  //R[stat][layer] - radius of rpc station/layer from center of CMS
  double R[2][2] = {{410.0,444.8},{492.7,527.3}};
  double rvalue = R[station-1][layer-1]*tan(phi/4096.);
  return rvalue;
}

int RPCtoDTTranslator::radialAngle ( RPCDetId  detid, const edm::EventSetup &  c, int  strip  )

static

function - will be replaced by LUTs(?)

Definition at line 304 of file RPCtoDTTranslator.cc.

References RPCRoll::centreOfStrip(), edm::EventSetup::get(), RPCRoll::id(), createfilelist::int, PV3DBase< T, PVType, FrameType >::phi(), Geom::pi(), RPCGeometry::roll(), and GeomDet::toGlobal().

Referenced by getDTRPCHitsContainer(), IOPrinter::run(), and run().

                                                                                  {

    int radialAngle;
    // from phiGlobal to radialAngle of the primitive in sector sec in [1..12] <- RPC scheme
    edm::ESHandle<RPCGeometry> rpcGeometry;
    c.get<MuonGeometryRecord>().get(rpcGeometry);

    const RPCRoll* roll = rpcGeometry->roll(detid);
    GlobalPoint stripPosition = roll->toGlobal(roll->centreOfStrip(strip));

    double globalphi = stripPosition.phi();
    int sector = (roll->id()).sector();
    if ( sector == 1) radialAngle = int( globalphi*1024 );
    else {
        if ( globalphi >= 0) radialAngle = int( (globalphi-(sector-1)*Geom::pi()/6.)*1024 );
        else radialAngle = int( (globalphi+(13-sector)*Geom::pi()/6.)*1024 );
    }
    return radialAngle;
}

void RPCtoDTTranslator::run

(

const edm::EventSetup &

c

)

Init structues

for chamber

hit belongs to cluster with clusterid

strip of i-1

for chamber

Loop over all combinations of layer 1 and 2.

Use ts2tag variable to store N rpchits for the same st/wheel/sec

Container to store RPC->DT for RPC only (only in stations 1 and 2 (2 layers->phib))

Container to store RPC->DT for Bx correction

Definition at line 71 of file RPCtoDTTranslator.cc.

References funct::abs(), bendingAngle(), relativeConstraints::chamber, SoftLeptonByDistance_cfi::distance, hfClusterShapes_cfi::hits, RPCDetId::layer(), localXX(), m_rpcDigis, m_rpcdt_translated, m_rpchitsdt_translated, radialAngle(), RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), L1MuDTChambPhContainer::setContainer(), relativeConstraints::station, RPCDetId::station(), digitizers_cfi::strip, tmp, and makeMuonMisalignmentScenario::wheel.

                                                  {

  std::vector<L1MuDTChambPhDigi> l1ttma_out;
  std::vector<L1MuDTChambPhDigi> l1ttma_hits_out;

  std::vector<rpc_hit> vrpc_hit_layer1, vrpc_hit_layer2, vrpc_hit_st3, vrpc_hit_st4;

  for( auto chamber = m_rpcDigis.begin(); chamber != m_rpcDigis.end(); ++chamber ) {
     RPCDetId detid = (*chamber).first;
     for( auto digi = (*chamber).second.first ; digi != (*chamber).second.second; ++digi ) {
        if(detid.region()!=0 ) continue; //Region = 0 Barrel
        if(BxToHit::outOfRange(digi->bx())) continue;
        if(detid.layer()==1) vrpc_hit_layer1.emplace_back(digi->bx(), detid.station(), detid.sector(), detid.ring(), detid, digi->strip(), detid.roll(), detid.layer());
        if(detid.station()==3) vrpc_hit_st3.emplace_back(digi->bx(), detid.station(), detid.sector(), detid.ring(), detid, digi->strip(), detid.roll(), detid.layer());
        if(detid.layer()==2) vrpc_hit_layer2.emplace_back(digi->bx(), detid.station(), detid.sector(), detid.ring(), detid, digi->strip(), detid.roll(), detid.layer());
        if(detid.station()==4) vrpc_hit_st4.emplace_back(digi->bx(), detid.station(), detid.sector(), detid.ring(), detid, digi->strip(), detid.roll(), detid.layer());
     }
  }

      vector<int> vcluster_size ;
      int cluster_id = -1;
      int itr=0;
//      int hits[5][4][12][2][5][3][100]= {{{{{{{0}}}}}}};
      std::map<RPCHitCleaner::detId_Ext, int> hits;
      int cluster_size = 0;
      for( auto chamber = m_rpcDigis.begin(); chamber != m_rpcDigis.end(); ++chamber ){
        RPCDetId detid = (*chamber).first;
        int strip_n1 = -10000;
        int bx_n1 = -10000;
        if(detid.region()!=0 ) continue; //Region = 0 Barrel
        for( auto digi = (*chamber).second.first ; digi != (*chamber).second.second; ++digi ){
           if(fabs(digi->bx())>3 ) continue;
           //Create cluster ids and store their size
           //if((digi->strip()+1!=strip_n1)|| digi->bx()!=bx_n1){
           if( abs(digi->strip()-strip_n1)!=1 || digi->bx()!=bx_n1){
             if(itr!=0)vcluster_size.push_back(cluster_size);
             cluster_size = 0;
             cluster_id++;
           }
           itr++;
           cluster_size++;
        //hits[(detid.ring()+2)][(detid.station()-1)][(detid.sector()-1)][(detid.layer()-1)][(digi->bx()+2)][detid.roll()-1][digi->strip()]= cluster_id ;
           RPCHitCleaner::detId_Ext tmp{detid,digi->bx(),digi->strip()};
           hits[tmp] = cluster_id;
           strip_n1 = digi->strip();
           bx_n1 = digi->bx();
         }
      }
        vcluster_size.push_back(cluster_size);



   for(int wh=-2; wh<=2; wh++){
     for(int sec=1; sec<=12; sec++){
        for(int st=1; st<=4; st++){
          int rpcbx = 0;
          std::vector<int> delta_phib;
          bool found_hits = false;
          std::vector<int> rpc2dt_phi, rpc2dt_phib;
          int itr1=0;
          for(unsigned int l1=0; l1<vrpc_hit_layer1.size(); l1++){
           RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer1[l1].detid,vrpc_hit_layer1[l1].bx,vrpc_hit_layer1[l1].strip};
           int id = hits[tmp];
           int phi1 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip) ;
           if(vcluster_size[id]==2 && itr1==0) {
             itr1++;
             continue;
             }
           if(vcluster_size[id]==2 && itr1==1 ) {
             itr1 = 0;
             phi1 = phi1 + (radialAngle(vrpc_hit_layer1[l1-1].detid, c, vrpc_hit_layer1[l1-1].strip));
             phi1 /= 2;
             }
            int itr2 = 0;
            for(unsigned int l2=0; l2<vrpc_hit_layer2.size(); l2++){
              if(vrpc_hit_layer1[l1].station!=st || vrpc_hit_layer2[l2].station!=st ) continue;
              if(vrpc_hit_layer1[l1].sector!=sec || vrpc_hit_layer2[l2].sector!=sec ) continue;
              if(vrpc_hit_layer1[l1].wheel!=wh || vrpc_hit_layer2[l2].wheel!=wh ) continue;
              if(vrpc_hit_layer1[l1].bx!=vrpc_hit_layer2[l2].bx ) continue;
              RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer2[l2].detid,vrpc_hit_layer2[l2].bx,vrpc_hit_layer2[l2].strip};
              int id = hits[tmp];

              if(vcluster_size[id]==2 && itr2==0) {
                 itr2++;
                 continue;
                 }

                        //int phi1 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip) ;
              int phi2 = radialAngle(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip) ;
              if(vcluster_size[id]==2 && itr2==1) {
                itr2 = 0;
                phi2 = phi2 + (radialAngle(vrpc_hit_layer2[l2-1].detid, c, vrpc_hit_layer2[l2-1].strip));
                phi2 /= 2;
                }
              int average = ( (phi1 + phi2)/2 )<<2; //10-bit->12-bit
              rpc2dt_phi.push_back(average);  //Convert and store to 12-bit
              //int xin = localX(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip);
             //int xout = localX(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip);
             //cout<<(phi1<<2)<<"   "<<l1<<"   "<<vrpc_hit_layer1[l1].station<<endl;
             //cout<<(phi2<<2)<<"   "<<l1<<"   "<<vrpc_hit_layer1[l1].station<<endl;
             int xin = localXX((phi1<<2), 1, vrpc_hit_layer1[l1].station );
             int xout = localXX((phi2<<2), 2, vrpc_hit_layer2[l2].station);
             if(vcluster_size[id]==2 && itr2==1) {
               int phi1_n1 = radialAngle(vrpc_hit_layer1[l1-1].detid, c, vrpc_hit_layer1[l1-1].strip);
               int phi2_n1 = radialAngle(vrpc_hit_layer2[l2-1].detid, c, vrpc_hit_layer2[l2-1].strip);
               xin += localXX((phi1_n1<<2), 1, vrpc_hit_layer1[l1].station );
               xout += localXX((phi2_n1<<2), 2, vrpc_hit_layer2[l2].station );
               xin /= 2;
               xout /= 2;
               }
             //cout<<">>"<<xin<<"   "<<xout<<endl;
             int phi_b = bendingAngle(xin,xout,average);
             //cout<<"phib   "<<phi_b<<endl;
             rpc2dt_phib.push_back(phi_b);
             //delta_phib to find the highest pt primitve
             delta_phib.push_back(abs(phi_b));
             found_hits = true;
             rpcbx = vrpc_hit_layer1[l1].bx;
             }
            }
          if(found_hits){
            //cout<<"found_hits"<<endl;
            int min_index = std::distance(delta_phib.begin(), std::min_element(delta_phib.begin(), delta_phib.end())) + 0;
            //cout<<min_index<<endl;
            l1ttma_out.emplace_back( rpcbx, wh, sec-1, st, rpc2dt_phi[min_index], rpc2dt_phib[min_index], 3, 0, 0, 2);
            
           }
          BxToHit hit;
          itr1=0;
          for(unsigned int l1=0; l1<vrpc_hit_layer1.size(); l1++){
           if(vrpc_hit_layer1[l1].station!=st || st>2 || vrpc_hit_layer1[l1].sector!=sec || vrpc_hit_layer1[l1].wheel!=wh) continue;
           //int id = hits[vrpc_hit_layer1[l1].wheel+2][(vrpc_hit_layer1[l1].station-1)][(vrpc_hit_layer1[l1].sector-1)][(vrpc_hit_layer1[l1].layer-1)][(vrpc_hit_layer1[l1].bx+2)][vrpc_hit_layer1[l1].roll-1][vrpc_hit_layer1[l1].strip];
            RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer1[l1].detid,vrpc_hit_layer1[l1].bx,vrpc_hit_layer1[l1].strip};
            int id = hits[tmp];
            if(vcluster_size[id]==2 && itr1==0) {
              itr1++;
              continue;
              }
            int phi2 = radialAngle(vrpc_hit_layer1[l1].detid, c, vrpc_hit_layer1[l1].strip);
            phi2 = phi2<<2;
            if(vcluster_size[id]==2 && itr1==1 ) {
              itr1 = 0;
              phi2 = phi2 + (radialAngle(vrpc_hit_layer1[l1-1].detid, c, vrpc_hit_layer1[l1-1].strip)<<2);
              phi2 /= 2;
              }
                        
            l1ttma_hits_out.emplace_back(vrpc_hit_layer1[l1].bx, wh, sec-1, st, phi2, 0, 3, hit[vrpc_hit_layer1[l1].bx], 0, 2);
            hit[vrpc_hit_layer1[l1].bx]++;
            }
            itr1 = 0;
            for(unsigned int l2=0; l2<vrpc_hit_layer2.size(); l2++){
              if(vrpc_hit_layer2[l2].station!=st || st>2 || vrpc_hit_layer2[l2].sector!=sec || vrpc_hit_layer2[l2].wheel!=wh) continue;
              RPCHitCleaner::detId_Ext tmp{vrpc_hit_layer2[l2].detid,vrpc_hit_layer2[l2].bx,vrpc_hit_layer2[l2].strip};
              int id = hits[tmp];
//              int id = hits[vrpc_hit_layer2[l2].wheel+2][(vrpc_hit_layer2[l2].station-1)][(vrpc_hit_layer2[l2].sector-1)][(vrpc_hit_layer2[l2].layer-1)][(vrpc_hit_layer2[l2].bx+2)][vrpc_hit_layer2[l2].roll-1][vrpc_hit_layer2[l2].strip];
              if(vcluster_size[id]==2 && itr1==0) {
                itr1++;
                continue;
                }
              int phi2 = radialAngle(vrpc_hit_layer2[l2].detid, c, vrpc_hit_layer2[l2].strip);
              phi2 = phi2<<2;
              if(vcluster_size[id]==2 && itr1==1) {
                itr1 = 0;
                phi2 = phi2 + (radialAngle(vrpc_hit_layer2[l2-1].detid, c, vrpc_hit_layer2[l2-1].strip)<<2);
                phi2 /= 2;
               }
               l1ttma_hits_out.emplace_back( vrpc_hit_layer2[l2].bx, wh, sec-1, st, phi2, 0, 3, hit[vrpc_hit_layer2[l2].bx] , 0, 2);
             hit[vrpc_hit_layer2[l2].bx]++;
            
            }
            itr1 = 0;
            
            for(unsigned int l1=0; l1<vrpc_hit_st3.size(); l1++){
              if(st!=3 || vrpc_hit_st3[l1].station!=3 || vrpc_hit_st3[l1].wheel!=wh || vrpc_hit_st3[l1].sector!=sec) continue;
              RPCHitCleaner::detId_Ext tmp{vrpc_hit_st3[l1].detid,vrpc_hit_st3[l1].bx,vrpc_hit_st3[l1].strip};
              int id = hits[tmp];
              //int id = hits[vrpc_hit_st3[l1].wheel+2][(vrpc_hit_st3[l1].station-1)][(vrpc_hit_st3[l1].sector-1)][(vrpc_hit_st3[l1].layer-1)][(vrpc_hit_st3[l1].bx+2)][vrpc_hit_st3[l1].roll-1][vrpc_hit_st3[l1].strip];
              if(vcluster_size[id]==2 && itr1==0) {
                itr1++;
                continue;
                 }
              int phi2 = radialAngle(vrpc_hit_st3[l1].detid, c, vrpc_hit_st3[l1].strip);
              phi2 = phi2<<2;
              if(vcluster_size[id]==2 && itr1==1) {
                itr1 = 0;
                phi2 = phi2 + (radialAngle(vrpc_hit_st3[l1-1].detid, c, vrpc_hit_st3[l1-1].strip)<<2);
                phi2 /= 2;
                }
               l1ttma_hits_out.emplace_back( vrpc_hit_st3[l1].bx, wh, sec-1, st, phi2, 0, 3, hit[vrpc_hit_st3[l1].bx], 0, 2);
              hit[vrpc_hit_st3[l1].bx]++;
              
            }
            itr1 = 0;

            for(unsigned int l1=0; l1<vrpc_hit_st4.size(); l1++){
              if(st!=4 || vrpc_hit_st4[l1].station!=4 || vrpc_hit_st4[l1].wheel!=wh || vrpc_hit_st4[l1].sector!=sec) continue;
              //int id = hits[vrpc_hit_st4[l1].wheel+2][(vrpc_hit_st4[l1].station-1)][(vrpc_hit_st4[l1].sector-1)][(vrpc_hit_st4[l1].layer-1)][(vrpc_hit_st4[l1].bx+2)][vrpc_hit_st4[l1].roll-1][vrpc_hit_st4[l1].strip];
              RPCHitCleaner::detId_Ext tmp{vrpc_hit_st4[l1].detid,vrpc_hit_st4[l1].bx,vrpc_hit_st4[l1].strip};
              int id = hits[tmp];
              if(vcluster_size[id]==2 && itr1==0) {
                 itr1++;
                 continue;
               }
              int phi2 = radialAngle(vrpc_hit_st4[l1].detid, c, vrpc_hit_st4[l1].strip);
              phi2 = phi2<<2;
              if(vcluster_size[id]==2 && itr1==1) {
                 itr1 = 0;
                 phi2 = phi2 + (radialAngle(vrpc_hit_st4[l1-1].detid, c, vrpc_hit_st4[l1-1].strip)<<2);
                 phi2 /= 2;
              }
              l1ttma_hits_out.emplace_back(vrpc_hit_st4[l1].bx, wh, sec-1, st, phi2, 0, 3, hit[vrpc_hit_st4[l1].bx] , 0, 2);
              hit[vrpc_hit_st4[l1].bx]++;
              //l1ttma_out.push_back(rpc2dt_out);
              
              //break;
            }
       }
    }
   }
m_rpcdt_translated.setContainer(l1ttma_out);
m_rpchitsdt_translated.setContainer(l1ttma_hits_out);

}

Member Data Documentation

const RPCDigiCollection& RPCtoDTTranslator::m_rpcDigis

private

Definition at line 54 of file RPCtoDTTranslator.h.

Referenced by run().

L1MuDTChambPhContainer RPCtoDTTranslator::m_rpcdt_translated

private

Output PhContainer.

Definition at line 51 of file RPCtoDTTranslator.h.

Referenced by getDTContainer(), and run().

L1MuDTChambPhContainer RPCtoDTTranslator::m_rpchitsdt_translated

private

Definition at line 52 of file RPCtoDTTranslator.h.

Referenced by getDTRPCHitsContainer(), and run().