LVL1MUCTPIPHASE1::OverlapHelper Class Reference

Collaboration diagram for LVL1MUCTPIPHASE1::OverlapHelper:

Public Member Functions
std::string	make_key (std::string prefix, int global_sec, int roi)
std::string	make_pair (const std::string &lhs, const std::string &rhs) const
void	create_indices ()
std::vector< std::string >	get_lhs_keys (const std::string &dettype, int roi, int sector) const
std::vector< std::string >	get_rhs_keys (const std::string &dettype, int roi, int sector) const
std::vector< std::string >	relevant_regions (int side, const std::string &dettype, int roi, int sector) const
void	configure (const std::string &lutFile)

Public Attributes
MuctpiXMLHelper	xmlHelper
std::map< int, std::set< std::string > >	global_pairs
std::array< std::map< std::string, std::vector< std::string > >, 2 >	lhs_index
std::array< std::map< std::string, std::vector< std::string > >, 2 >	rhs_index

Detailed Description

Definition at line 68 of file MuonSectorProcessor.cxx.

Member Function Documentation

configure()

void LVL1MUCTPIPHASE1::OverlapHelper::configure ( const std::string &  lutFile )

inline

Definition at line 132 of file MuonSectorProcessor.cxx.

    {
      ptree inputTree;
      read_xml(lutFile, inputTree);
 
      boost::property_tree::ptree topEle = inputTree.get_child("MUCTPI_LUT");
 
      // iterate through elements of the XML
      for(const boost::property_tree::ptree::value_type &x: topEle) {
 
    std::string topElementName = x.first;
    ptree lut = x.second;
 
    if (topElementName != "LUT") continue;
 
    std::string SectorId1 = xmlHelper.getAttribute(lut,"SectorId1");
    std::string SectorId2 = xmlHelper.getAttribute(lut,"SectorId2");
 
    unsigned left_mod = 32;
    unsigned right_mod = 32;
    if (SectorId1[0] == 'E') left_mod = 48;
    if (SectorId1[0] == 'F') left_mod = 24;
    if (SectorId2[0] == 'E') right_mod = 48;
    if (SectorId2[0] == 'F') right_mod = 24;
 
    std::string snum_left = std::string(1,SectorId1[1])+std::string(1,SectorId1[2]);
    int sec_left = std::stoi(snum_left) % left_mod;
 
    std::string snum_right = std::string(1,SectorId2[1])+std::string(1,SectorId2[2]);
    int sec_right = std::stoi(snum_right) % right_mod;
 
    std::string side = xmlHelper.getAttribute(lut,"Side");
    int active_side = (side == "C") ? 0 : 1;
 
    std::string System1 = SectorId1.substr(0,1);
    std::string System2 = SectorId2.substr(0,1);
 
    for(const boost::property_tree::ptree::value_type &z: lut) {
      std::string menuElementName = z.first;
      if(menuElementName!="Element" && menuElementName!="BBElement")continue;
      ptree ele = z.second;
      auto roi1 = xmlHelper.getIntAttribute(ele, "RoI1");
      auto roi2 = xmlHelper.getIntAttribute(ele, "RoI2");
      auto lhs_key = make_key(System1,sec_left,roi1);
      auto rhs_key = make_key(System2,sec_right,roi2);
      auto region = make_pair(lhs_key,rhs_key);
      global_pairs[active_side].insert(region);
    }
      }
      create_indices();
    }

create_indices()

void LVL1MUCTPIPHASE1::OverlapHelper::create_indices ( )

inline

Definition at line 87 of file MuonSectorProcessor.cxx.

                         {
      for(const auto& side_regions : global_pairs ){
    for(const auto& region : side_regions.second){
      auto split = region.find(':');
      auto left = region.substr(0,split);
      auto right = region.substr(split+1,std::string::npos);
      lhs_index[side_regions.first][left].push_back(right);
      rhs_index[side_regions.first][right].push_back(left);
    }
      }
    }

get_lhs_keys()

std::vector<std::string> LVL1MUCTPIPHASE1::OverlapHelper::get_lhs_keys ( const std::string &  dettype, int  roi, int  sector  ) const

inline

Definition at line 99 of file MuonSectorProcessor.cxx.

                                                                                           {
      std::vector<std::string>  r;
      r.push_back(dettype + std::to_string(sector) + "_" + std::to_string(roi));
      return r;
    }

get_rhs_keys()

std::vector<std::string> LVL1MUCTPIPHASE1::OverlapHelper::get_rhs_keys ( const std::string &  dettype, int  roi, int  sector  ) const

inline

Definition at line 105 of file MuonSectorProcessor.cxx.

                                                                                           {
      std::vector<std::string>  r;
      r.push_back(dettype + std::to_string(sector) + "_" + std::to_string(roi));
      return r;
    }

make_key()

std::string LVL1MUCTPIPHASE1::OverlapHelper::make_key ( std::string  prefix, int  global_sec, int  roi  )

inline

Definition at line 77 of file MuonSectorProcessor.cxx.

                                                                 {
      prefix += std::to_string(global_sec) + "_" + std::to_string(roi);
      return prefix;
    }

make_pair()

std::string LVL1MUCTPIPHASE1::OverlapHelper::make_pair ( const std::string &  lhs, const std::string &  rhs  ) const

inline

Definition at line 82 of file MuonSectorProcessor.cxx.

                                                                          {
      return lhs + ":" + rhs;
    }

relevant_regions()

std::vector<std::string> LVL1MUCTPIPHASE1::OverlapHelper::relevant_regions ( int  side, const std::string &  dettype, int  roi, int  sector  ) const

inline

Definition at line 111 of file MuonSectorProcessor.cxx.

                                                                                                         {
      std::vector<std::string>  r;
      for(const auto& key : get_lhs_keys(dettype,roi,sector)){
    auto x = lhs_index[side].find(key);
    if(x != lhs_index[side].end()){
      for(const auto& rr : x->second){
        r.push_back(make_pair(key,rr));
      }
    }
      }
      for(const auto& key : get_rhs_keys(dettype,roi,sector)){
    auto x = rhs_index[side].find(key);
    if(x != rhs_index[side].end()){
      for(const auto& rr : x->second){
        r.push_back(make_pair(rr,key));
      }
    }
      }
      return r;
    }

Member Data Documentation

global_pairs

std::map<int,std::set<std::string> > LVL1MUCTPIPHASE1::OverlapHelper::global_pairs

Definition at line 72 of file MuonSectorProcessor.cxx.

lhs_index

std::array<std::map<std::string,std::vector<std::string> >,2> LVL1MUCTPIPHASE1::OverlapHelper::lhs_index

Definition at line 74 of file MuonSectorProcessor.cxx.

rhs_index

std::array<std::map<std::string,std::vector<std::string> >,2> LVL1MUCTPIPHASE1::OverlapHelper::rhs_index

Definition at line 75 of file MuonSectorProcessor.cxx.

xmlHelper

MuctpiXMLHelper LVL1MUCTPIPHASE1::OverlapHelper::xmlHelper

Definition at line 71 of file MuonSectorProcessor.cxx.

---

The documentation for this class was generated from the following file:

• MuonSectorProcessor.cxx