RpcClusterization Class Reference

#include <RpcClusterization.h>

Public Member Functions
void	configure (int maxClusterSize, int maxClusterCnt, bool dropAllClustersIfMoreThanMax)
virtual int	convertTiming (double timing) const
virtual std::vector< RpcCluster >	getClusters (const RPCDetId &roll, std::vector< RPCDigi > &digis) const
	N.B. digis are sorted inside the function. More...
	RpcClusterization ()
virtual	~RpcClusterization ()

Private Attributes
bool	dropAllClustersIfMoreThanMax = true
unsigned int	maxClusterCnt = 2
unsigned int	maxClusterSize = 3

Detailed Description

Definition at line 33 of file RpcClusterization.h.

Constructor & Destructor Documentation

RpcClusterization::RpcClusterization ( )

inline

Definition at line 35 of file RpcClusterization.h.

{};

RpcClusterization::~RpcClusterization ( )

virtual

Definition at line 14 of file RpcClusterization.cc.

{}

Member Function Documentation

void RpcClusterization::configure ( int  maxClusterSize, int  maxClusterCnt, bool  dropAllClustersIfMoreThanMax  )

inline

Definition at line 39 of file RpcClusterization.h.

References dropAllClustersIfMoreThanMax, maxClusterCnt, and maxClusterSize.

Referenced by MuonStubMakerBase::initialize().

                                                                                           {
    this->maxClusterSize = maxClusterSize;
    this->maxClusterCnt = maxClusterCnt;
    this->dropAllClustersIfMoreThanMax = dropAllClustersIfMoreThanMax;
  }

int RpcClusterization::convertTiming ( double  timing ) const

virtual

Definition at line 86 of file RpcClusterization.cc.

Referenced by getClusters().

                                                        {
  return timing;  //TODO implement
}

std::vector< RpcCluster > RpcClusterization::getClusters ( const RPCDetId &  roll, std::vector< RPCDigi > &  digis  ) const

virtual

N.B. digis are sorted inside the function.

Definition at line 16 of file RpcClusterization.cc.

References a, b, convertTiming(), dropAllClustersIfMoreThanMax, RPCDigi::strip(), and digitizers_cfi::strip.

Referenced by RpcDigiToStubsConverter::makeStubs().

                                                                                                          {
  std::vector<RpcCluster> allClusters;

  if (!dropAllClustersIfMoreThanMax) {
    //with the 2018 firmware the agreement is better with this sort
    std::sort(digis.begin(), digis.end(), [](const RPCDigi& a, const RPCDigi& b) { return a.strip() < b.strip(); });
  } else {
    //with the fixed RPC clusterization (Nov 2021 firmware) the data to emulator agreement is better if this reverse is used here,
    //with the 2018 firmware the agreement is worse with this reverse,
    std::reverse(digis.begin(), digis.end());
  }

  typedef std::pair<unsigned int, unsigned int> Cluster;

  //This implementation of clusterization emulation gives the cluster in the same order as the order of digis,
  //and the order of unpacked digis should be the same as the order of the LB channels on which the clustrization
  //in the firmware is performed.
  //This cluster order plays role in some rare cases for the OMTF algorithm
  //when two hits has the same abs(minDistPhi), and then the phi of the resulting candidate
  //depends on the order of these hits.
  for (unsigned int iDigi = 0; iDigi < digis.size(); iDigi++) {
    //edm::LogVerbatim("l1tOmtfEventPrint")<< __FUNCTION__ << ":" << __LINE__<<" "<<roll<<" iDigi "<<iDigi<<" digi "<<digis[iDigi];

    //removing duplicated digis
    //the digis might be duplicated, because the same data might be received by two OMTF boards (as the same link goes to two neighboring boards)
    //and the unpacker is not cleaning them
    bool duplicatedDigi = false;
    for (unsigned int iDigi2 = 0; iDigi2 < iDigi; iDigi2++) {
      if (digis[iDigi].strip() == digis[iDigi2].strip()) {
        duplicatedDigi = true;
        //edm::LogVerbatim("l1tOmtfEventPrint")<<"duplicatedDigi";
        break;
      }
    }

    if (duplicatedDigi)
      continue;

    bool addNewCluster = true;

    for (auto& cluster : allClusters) {
      if (digis[iDigi].strip() - cluster.lastStrip == 1) {
        cluster.lastStrip = digis[iDigi].strip();
        addNewCluster = false;
      } else if (digis[iDigi].strip() - cluster.firstStrip == -1) {
        cluster.firstStrip = digis[iDigi].strip();
        addNewCluster = false;
      } else if (digis[iDigi].strip() >= cluster.firstStrip && digis[iDigi].strip() <= cluster.lastStrip) {
        addNewCluster = false;
      }
    }

    if (addNewCluster) {
      allClusters.emplace_back(digis[iDigi].strip(), digis[iDigi].strip());
      allClusters.back().bx = digis[iDigi].bx();
      allClusters.back().timing = convertTiming(digis[iDigi].time());
    }
  }

  /* Debug only
  if(allClusters.size())
      edm::LogVerbatim("l1tOmtfEventPrint")<< __FUNCTION__ <<" "<<roll<<" allClusters.size() "<<allClusters.size();
  for (auto& cluster : allClusters)
      edm::LogVerbatim("l1tOmtfEventPrint")
        << __FUNCTION__ << " cluster: firstStrip " << cluster.firstStrip
        << " lastStrip " << cluster.lastStrip << " halfStrip " << cluster.halfStrip() << std::endl;*/

  return allClusters;
}

Member Data Documentation

bool RpcClusterization::dropAllClustersIfMoreThanMax = true

private

Definition at line 56 of file RpcClusterization.h.

Referenced by configure(), and getClusters().

unsigned int RpcClusterization::maxClusterCnt = 2

private

Definition at line 53 of file RpcClusterization.h.

Referenced by configure().

unsigned int RpcClusterization::maxClusterSize = 3

private

Definition at line 52 of file RpcClusterization.h.

Referenced by configure().