GEMDigiMatcher.cc

Go to the documentation of this file.

#include "Validation/MuonGEMDigis/interface/GEMDigiMatcher.h"
#include "Validation/MuonGEMHits/interface/SimHitMatcher.h"

#include "DataFormats/MuonDetId/interface/GEMDetId.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

using namespace std;
using namespace matching;

GEMDigiMatcher::GEMDigiMatcher(const SimHitMatcher& sh, const edm::Event& e, const GEMGeometry& geom, const edm::ParameterSet& cfg,edm::EDGetToken& gem_digiToken, edm::EDGetToken& gem_padToken, edm::EDGetToken& gem_copadToken ):simhit_matcher_(sh),gem_geo_(geom)
{
  minBXGEM_ = cfg.getUntrackedParameter<int>("minBXGEM", -1);
  maxBXGEM_ = cfg.getUntrackedParameter<int>("maxBXGEM", 1);

  matchDeltaStrip_ = cfg.getUntrackedParameter<int>("matchDeltaStripGEM", 1);

  //setVerbose(cfg.getUntrackedParameter<int>("verboseGEMDigi", 0));
  verbose_=false;

  e.getByToken(gem_digiToken, gem_digis_);
  e.getByToken(gem_padToken, gem_pads_);
  e.getByToken(gem_copadToken, gem_co_pads_);
  if ( !gem_digis_.isValid() || !gem_pads_.isValid() ) return ;
  // CoPad can be missing when we use only digi data.
  if ( !gem_co_pads_.isValid() )  { 
    edm::LogError("GEMDigiMatcher")<<"Copad is missing from collections.Pass copad.";
  }
  init(e);
}

GEMDigiMatcher::~GEMDigiMatcher() {}


void
GEMDigiMatcher::init(const edm::Event& e)
{
  matchDigisToSimTrack(*gem_digis_.product());
  matchPadsToSimTrack(*gem_pads_.product());
  if ( gem_co_pads_.isValid())  matchCoPadsToSimTrack(*gem_co_pads_.product()); 
}


void
GEMDigiMatcher::matchDigisToSimTrack(const GEMDigiCollection& digis)
{
  auto det_ids = simhit_matcher_.detIdsGEM();
  for (auto id: det_ids)
  {
    GEMDetId p_id(id);
    GEMDetId superch_id(p_id.region(), p_id.ring(), p_id.station(), 1, p_id.chamber(), 0);

    auto hit_strips = simhit_matcher_.hitStripsInDetId(id, matchDeltaStrip_);
    if (verbose_)
    {
      cout<<"hit_strips_fat ";
      copy(hit_strips.begin(), hit_strips.end(), ostream_iterator<int>(cout, " "));
      cout<<endl;
    }

    auto digis_in_det = digis.get(GEMDetId(id));

    for (auto d = digis_in_det.first; d != digis_in_det.second; ++d)
    {
      if (verbose_) cout<<"gdigi "<<p_id<<" "<<*d<<endl;
      // check that the digi is within BX range
      if (d->bx() < minBXGEM_ || d->bx() > maxBXGEM_) continue;
      // check that it matches a strip that was hit by SimHits from our track
      if (hit_strips.find(d->strip()) == hit_strips.end()) continue;
      if (verbose_) cout<<"oki"<<endl;

      auto mydigi = make_digi(id, d->strip(), d->bx(), GEM_STRIP);
      detid_to_digis_[id].push_back(mydigi);
      chamber_to_digis_[ p_id.chamberId().rawId() ].push_back(mydigi);
      superchamber_to_digis_[ superch_id() ].push_back(mydigi);

      //int pad_num = 1 + static_cast<int>( roll->padOfStrip(d->strip()) ); // d->strip() is int
      //digi_map[ make_pair(pad_num, d->bx()) ].push_back( d->strip() );
    }
  }
}


void
GEMDigiMatcher::matchPadsToSimTrack(const GEMPadDigiCollection& pads)
{
  auto det_ids = simhit_matcher_.detIdsGEM();
  for (auto id: det_ids)
  {
    GEMDetId p_id(id);
    GEMDetId superch_id(p_id.region(), p_id.ring(), p_id.station(), 1, p_id.chamber(), 0);

    auto hit_pads = simhit_matcher_.hitPadsInDetId(id);
    auto pads_in_det = pads.get(p_id);

    if (verbose_)
    {
      cout<<"checkpads "<<hit_pads.size()<<" "<<std::distance(pads_in_det.first, pads_in_det.second)<<" hit_pads: ";
      copy(hit_pads.begin(), hit_pads.end(), ostream_iterator<int>(cout," "));
      cout<<endl;
    }

    for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad)
    {
      if (verbose_) cout<<"chp "<<*pad<<endl;
      // check that the pad BX is within the range
      if (pad->bx() < minBXGEM_ || pad->bx() > maxBXGEM_) continue;
      if (verbose_) cout<<"chp1"<<endl;
      // check that it matches a pad that was hit by SimHits from our track
      if (hit_pads.find(pad->pad()) == hit_pads.end()) continue;
      if (verbose_) cout<<"chp2"<<endl;

      auto mydigi = make_digi(id, pad->pad(), pad->bx(), GEM_PAD);
      detid_to_pads_[id].push_back(mydigi);
      chamber_to_pads_[ p_id.chamberId().rawId() ].push_back(mydigi);
      superchamber_to_pads_[ superch_id() ].push_back(mydigi);
    }
  }
}


void
GEMDigiMatcher::matchCoPadsToSimTrack(const GEMCoPadDigiCollection& co_pads)
{
  auto det_ids = simhit_matcher_.detIdsGEMCoincidences();
  for (auto id: det_ids)
  {
    GEMDetId p_id(id);
    GEMDetId superch_id(p_id.region(), p_id.ring(), p_id.station(), 1, p_id.chamber(), 0);

    auto hit_co_pads = simhit_matcher_.hitCoPadsInDetId(id);
    auto co_pads_in_det = co_pads.get(p_id);

    for (auto pad = co_pads_in_det.first; pad != co_pads_in_det.second; ++pad)
    {
      // check that the pad BX is within the range
      if (pad->bx(1) < minBXGEM_ || pad->bx(1) > maxBXGEM_) continue;
      if (pad->bx(2) < minBXGEM_ || pad->bx(2) > maxBXGEM_) continue;
      // check that it matches a coincidence pad that was hit by SimHits from our track
      if (hit_co_pads.find(pad->pad(1)) == hit_co_pads.end()) continue;
      if (hit_co_pads.find(pad->pad(2)) == hit_co_pads.end()) continue;

      auto mydigi = make_digi(id, pad->pad(1), pad->bx(1), GEM_COPAD);
      //auto mydigi = make_digi(id, pad->pad(2), pad->bx(2), GEM_COPAD);  // FIXIT : Solve duplicate problem.
      detid_to_copads_[id].push_back(mydigi);
      superchamber_to_copads_[ superch_id() ].push_back(mydigi);
    }
  }
}


std::set<unsigned int>
GEMDigiMatcher::detIds() const
{
  std::set<unsigned int> result;
  for (auto& p: detid_to_digis_) result.insert(p.first);
  return result;
}


std::set<unsigned int>
GEMDigiMatcher::chamberIds() const
{
  std::set<unsigned int> result;
  for (auto& p: chamber_to_digis_) result.insert(p.first);
  return result;
}
std::set<unsigned int>
GEMDigiMatcher::chamberIdsWithPads() const
{
  std::set<unsigned int> result;
  for (auto& p: chamber_to_pads_) result.insert(p.first);
  return result;
}
std::set<unsigned int>
GEMDigiMatcher::superChamberIds() const
{
  std::set<unsigned int> result;
  for (auto& p: superchamber_to_digis_) result.insert(p.first);
  return result;
}
std::set<unsigned int>
GEMDigiMatcher::superChamberIdsWithPads() const
{
  std::set<unsigned int> result;
  for (auto& p: superchamber_to_pads_) result.insert(p.first);
  return result;
}
std::set<unsigned int>
GEMDigiMatcher::superChamberIdsWithCoPads() const
{
  std::set<unsigned int> result;
  for (auto& p: superchamber_to_copads_) result.insert(p.first);
  return result;
}
std::set<unsigned int>
GEMDigiMatcher::detIdsWithCoPads() const
{
  std::set<unsigned int> result;
  for (auto& p: detid_to_copads_) result.insert(p.first);
  return result;
}




const matching::DigiContainer&
GEMDigiMatcher::digisInDetId(unsigned int detid) const
{
  if (detid_to_digis_.find(detid) == detid_to_digis_.end()) return no_digis_;
  return detid_to_digis_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::digisInChamber(unsigned int detid) const
{
  if (chamber_to_digis_.find(detid) == chamber_to_digis_.end()) return no_digis_;
  return chamber_to_digis_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::digisInSuperChamber(unsigned int detid) const
{
  if (superchamber_to_digis_.find(detid) == superchamber_to_digis_.end()) return no_digis_;
  return superchamber_to_digis_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::padsInDetId(unsigned int detid) const
{
  if (detid_to_pads_.find(detid) == detid_to_pads_.end()) return no_digis_;
  return detid_to_pads_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::padsInChamber(unsigned int detid) const
{
  if (chamber_to_pads_.find(detid) == chamber_to_pads_.end()) return no_digis_;
  return chamber_to_pads_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::padsInSuperChamber(unsigned int detid) const
{
  if (superchamber_to_pads_.find(detid) == superchamber_to_pads_.end()) return no_digis_;
  return superchamber_to_pads_.at(detid);
}


const matching::DigiContainer&
GEMDigiMatcher::coPadsInDetId(unsigned int detid) const
{
  if (detid_to_copads_.find(detid) == detid_to_copads_.end()) return no_digis_;
  return detid_to_copads_.at(detid);
}

const matching::DigiContainer&
GEMDigiMatcher::coPadsInSuperChamber(unsigned int detid) const
{
  if (superchamber_to_copads_.find(detid) == superchamber_to_copads_.end()) return no_digis_;
  return superchamber_to_copads_.at(detid);
}


int
GEMDigiMatcher::nLayersWithDigisInSuperChamber(unsigned int detid) const
{
  set<int> layers;
  auto digis = digisInSuperChamber(detid);
  for (auto& d: digis)
  {
    GEMDetId idd(digi_id(d));
    layers.insert(idd.layer());
  }
  return layers.size();
}


int
GEMDigiMatcher::nLayersWithPadsInSuperChamber(unsigned int detid) const
{
  set<int> layers;
  auto digis = padsInSuperChamber(detid);
  for (auto& d: digis)
  {
    GEMDetId idd(digi_id(d));
    layers.insert(idd.layer());
  }
  return layers.size();
}


int
GEMDigiMatcher::nCoPads() const
{
  int n = 0;
  auto ids = superChamberIdsWithCoPads();
  for (auto id: ids)
  {
    n += coPadsInSuperChamber(id).size();
  }
  return n;
}


int
GEMDigiMatcher::nPads() const
{
  int n = 0;
  auto ids = superChamberIdsWithPads();
  for (auto id: ids)
  {
    n += padsInSuperChamber(id).size();
  }
  return n;
}


std::set<int>
GEMDigiMatcher::stripNumbersInDetId(unsigned int detid) const
{
  set<int> result;
  auto digis = digisInDetId(detid);
  for (auto& d: digis)
  {
    result.insert( digi_channel(d) );
  }
  return result;
}

std::set<int>
GEMDigiMatcher::padNumbersInDetId(unsigned int detid) const
{
  set<int> result;
  auto digis = padsInDetId(detid);
  for (auto& d: digis)
  {
    result.insert( digi_channel(d) );
  }
  return result;
}

std::set<int>
GEMDigiMatcher::coPadNumbersInDetId(unsigned int detid) const
{
  set<int> result;
  auto digis = coPadsInDetId(detid);
  for (auto& d: digis)
  {
    result.insert( digi_channel(d) );
  }
  return result;
}

std::set<int>
GEMDigiMatcher::partitionNumbers() const
{
  std::set<int> result;

  auto detids = detIds();
  for (auto id: detids)
  {
    GEMDetId idd(id);
    result.insert( idd.roll() );
  }
  return result;
}

std::set<int>
GEMDigiMatcher::partitionNumbersWithCoPads() const
{
  std::set<int> result;

  auto detids = detIdsWithCoPads();
  for (auto id: detids)
  {
    GEMDetId idd(id);
    result.insert( idd.roll() );
  }
  return result;
}