RPCConeBuilderFromES Class Reference

#include <L1Trigger/RPCTrigger/interface/RPCConeBuilderFromES.h>

Public Member Functions
L1RpcLogConesVec	getConesFromES (edm::Handle< RPCDigiCollection > rpcDigis, edm::ESHandle< L1RPCConeBuilder > coneBuilder, edm::ESHandle< L1RPCConeDefinition > coneDef, edm::ESHandle< L1RPCBxOrConfig > bxOrDef, edm::ESHandle< L1RPCHwConfig > hwConfig, int bx)
	RPCConeBuilderFromES ()
virtual	~RPCConeBuilderFromES ()

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 41 of file RPCConeBuilderFromES.h.

Constructor & Destructor Documentation

RPCConeBuilderFromES()

RPCConeBuilderFromES::RPCConeBuilderFromES

(

)

Definition at line 29 of file RPCConeBuilderFromES.cc.

{}

~RPCConeBuilderFromES()

RPCConeBuilderFromES::~RPCConeBuilderFromES ( )

virtual

Definition at line 36 of file RPCConeBuilderFromES.cc.

{}

Member Function Documentation

getConesFromES()

L1RpcLogConesVec RPCConeBuilderFromES::getConesFromES	(	edm::Handle< RPCDigiCollection >	rpcDigis,
		edm::ESHandle< L1RPCConeBuilder >	coneBuilder,
		edm::ESHandle< L1RPCConeDefinition >	coneDef,
		edm::ESHandle< L1RPCBxOrConfig >	bxOrDef,
		edm::ESHandle< L1RPCHwConfig >	hwConfig,
		int	bx
	)

Definition at line 38 of file RPCConeBuilderFromES.cc.

References nano_mu_digi_cff::bx, L1RPCConeBuilder::getCompConVec(), L1RPCConeBuilder::getConVec(), L1RPCBxOrConfig::getFirstBX(), L1RPCBxOrConfig::getLastBX(), L1RPCConeDefinition::getLPSizeVec(), mps_fire::i, L1RPCHwConfig::isActive(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, mathSSE::lh, FastTimerService_cff::range, nano_mu_digi_cff::rawId, and RPCLogCone::setIdx().

Referenced by RPCTrigger::produce().

                                                              {
  std::vector<RPCLogHit> logHits;
  std::vector<RPCLogHit> logHitsFromUncomp;

  // Build cones from digis
  // first build loghits

  short int digiIndex = 0;
  RPCDigiCollection::DigiRangeIterator detUnitIt;
  for (detUnitIt = rpcDigis->begin(); detUnitIt != rpcDigis->end(); ++detUnitIt) {
    const RPCDetId& id = (*detUnitIt).first;

    uint32_t rawId = id.rawId();

    const RPCDigiCollection::Range& range = (*detUnitIt).second;

    std::pair<L1RPCConeBuilder::TCompressedConVec::const_iterator, L1RPCConeBuilder::TCompressedConVec::const_iterator>
        compressedConnPair = coneBuilder->getCompConVec(rawId);

    // iterate over strips
    for (RPCDigiCollection::const_iterator digiIt = range.first; digiIt != range.second; ++digiIt) {
      ++digiIndex;
      if (digiIt->bx() < bxOrDef->getFirstBX() + bx || digiIt->bx() > bxOrDef->getLastBX() + bx) {
        //if ( digiIt->bx() < hwConfig->getFirstBX() + bx || digiIt->bx() > hwConfig->getLastBX() +bx  ){
        continue;
      }

      //std::cout << digiIt->bx() << " D " << rawId << " " << id << " S " <<  digiIt->strip() << std::endl;
      // for uncompressed connections
      std::pair<L1RPCConeBuilder::TStripConVec::const_iterator, L1RPCConeBuilder::TStripConVec::const_iterator> itPair =
          coneBuilder->getConVec(rawId, digiIt->strip());

      L1RPCConeBuilder::TStripConVec::const_iterator it = itPair.first;
      // Iterate over uncompressed connections, convert digis to logHits
      for (; it != itPair.second; ++it) {
        //std::cout << " Not empty!" << std::endl;
        if (hwConfig->isActive(it->m_tower, it->m_PAC)) {
          RPCLogHit lh(it->m_tower, it->m_PAC, it->m_logplane, it->m_logstrip);
          lh.setDigiIdx(digiIndex);
          logHitsFromUncomp.push_back(lh);
        }
      }

      /*
      bool printOut = false;
      if (digiIt->strip() == 62 || digiIt->strip() == 63 ){
        std::cout << "Strip " << digiIt->strip() << std::endl;
        printOut = true;
      }
      */

      L1RPCConeBuilder::TCompressedConVec::const_iterator itComp = compressedConnPair.first;
      for (; itComp != compressedConnPair.second; ++itComp) {
        if (hwConfig->isActive(itComp->m_tower, itComp->m_PAC)) {
          int logstrip = itComp->getLogStrip(digiIt->strip(), coneDef->getLPSizeVec());
          if (logstrip != -1) {
            RPCLogHit lh(itComp->m_tower, itComp->m_PAC, itComp->m_logplane, logstrip);
            lh.setDigiIdx(digiIndex);
            logHits.push_back(lh);
          }
          /*
           if (printOut){
             std::cout << "T " << (int)itComp->m_tower << " P " 
                 << (int)itComp->m_PAC << " LP " 
                 << (int)itComp->m_logplane << " LS " 
                 << (int)logstrip << std::endl;
         }*/
        }
      }

    }  // strip iteration ends
  }

  // check if we dont have any preferable uncompressed loghits
  std::vector<RPCLogHit>::iterator itLHitUncomp = logHitsFromUncomp.begin();
  std::vector<RPCLogHit>::iterator itLHitComp;

  // overwrite uncompressed with those coming from compressed
  for (; itLHitUncomp != logHitsFromUncomp.end(); ++itLHitUncomp) {
    for (itLHitComp = logHits.begin(); itLHitComp != logHits.end(); ++itLHitComp) {
      if (itLHitComp->getTower() == itLHitUncomp->getTower() &&
          itLHitComp->getLogSector() == itLHitUncomp->getLogSector() &&
          itLHitComp->getLogSegment() == itLHitUncomp->getLogSegment() &&
          itLHitComp->getlogPlaneNumber() == itLHitUncomp->getlogPlaneNumber()) {
        //         std::cout<< "Overwrite " << std::endl;
        //std::cout.flush();
        *itLHitUncomp = *itLHitComp;
      }
    }
  }

  // copy missing from compressed to uncompressed
  for (; itLHitUncomp != logHitsFromUncomp.end(); ++itLHitUncomp) {
    bool present = false;
    for (unsigned int i = 0; i < logHits.size(); ++i) {
      if (logHits[i].getTower() == itLHitUncomp->getTower() &&
          logHits[i].getLogSector() == itLHitUncomp->getLogSector() &&
          logHits[i].getLogSegment() == itLHitUncomp->getLogSegment() &&
          logHits[i].getlogPlaneNumber() == itLHitUncomp->getlogPlaneNumber()) {
        present = true;
      }
    }
    if (!present) {
      //       std::cout<< "Copy " << std::endl;
      //std::cout.flush();

      logHits.push_back(*itLHitUncomp);
    }
  }

  // build cones
  L1RpcLogConesVec ActiveCones;

  std::vector<RPCLogHit>::iterator p_lhit;
  for (p_lhit = logHits.begin(); p_lhit != logHits.end(); ++p_lhit) {
    bool hitTaken = false;
    L1RpcLogConesVec::iterator p_cone;
    for (p_cone = ActiveCones.begin(); p_cone != ActiveCones.end(); p_cone++) {
      hitTaken = p_cone->addLogHit(*p_lhit);
      if (hitTaken)
        break;
    }

    if (!hitTaken) {
      RPCLogCone newcone(*p_lhit);
      newcone.setIdx(ActiveCones.size());
      ActiveCones.push_back(newcone);
    }
  }  // for loghits

  /*
  for (int tower = -16; tower<17;++tower)
  {
    for (int sector = 0; sector<12;++sector)
    {
      for (int segment = 0; segment<12;++segment)
      {
        for (L1RpcLogConesVec::iterator it =  ActiveCones.begin(); it!=ActiveCones.end(); ++it)
        {
          if (it->getTower()==tower 
              && it->getLogSector()==sector
              && it->getLogSegment()==segment)
          {
           std::cout << it->toString() << std::endl;
          }
        }
      }
    }
  }
  // */

  return ActiveCones;
}