GEMClusterProcessor Class Reference

#include <GEMClusterProcessor.h>

Public Types
enum	ClusterTypes { AllClusters = 1, SingleClusters = 2, CoincidenceClusters = 3 }

Public Member Functions
void	clear ()
	GEMClusterProcessor (int region, unsigned station, unsigned chamber, const edm::ParameterSet &conf)
std::vector< GEMInternalCluster >	getClusters (int bx, int deltaBX=0, ClusterTypes option=AllClusters) const
std::vector< GEMInternalCluster >	getCoincidenceClusters (int bx) const
bool	hasGE21Geometry16Partitions () const
std::vector< GEMCoPadDigi >	readoutCoPads () const
void	run (const GEMPadDigiClusterCollection *)
void	setESLookupTables (const CSCL1TPLookupTableME11ILT *conf)
void	setESLookupTables (const CSCL1TPLookupTableME21ILT *conf)

Private Member Functions
void	addCoincidenceClusters (const GEMPadDigiClusterCollection *)
void	addSingleClusters (const GEMPadDigiClusterCollection *)
void	doCoordinateConversion ()

Private Attributes
const int	chamber_
std::vector< GEMInternalCluster >	clusters_
bool	hasGE21Geometry16Partitions_
bool	isEven_
const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT_
const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT_
unsigned int	maxDeltaBX_
unsigned int	maxDeltaPad_
unsigned int	maxDeltaRoll_
const int	region_
const int	station_

Detailed Description

Author

Sven Dildick (Rice University)

Definition at line 19 of file GEMClusterProcessor.h.

Member Enumeration Documentation

enum GEMClusterProcessor::ClusterTypes

Enumerator
AllClusters
SingleClusters
CoincidenceClusters

Definition at line 34 of file GEMClusterProcessor.h.

{ AllClusters = 1, SingleClusters = 2, CoincidenceClusters = 3 };

Constructor & Destructor Documentation

GEMClusterProcessor::GEMClusterProcessor	(	int	region,
		unsigned	station,
		unsigned	chamber,
		const edm::ParameterSet &	conf
	)

Normal constructor.

Definition at line 7 of file GEMClusterProcessor.cc.

References chamber_, edm::ParameterSet::getParameter(), hasGE21Geometry16Partitions_, isEven_, maxDeltaBX_, maxDeltaPad_, maxDeltaRoll_, or, and station_.

    : region_(region), station_(station), chamber_(chamber), hasGE21Geometry16Partitions_(false) {
  isEven_ = chamber_ % 2 == 0;

  // These LogErrors are sanity checks and should not be printed
  if (station_ == 3 or station_ == 4) {
    edm::LogError("GEMClusterProcessor") << "Class constructed for a chamber in ME3 or ME4!";
  };

  if (station_ == 1) {
    const edm::ParameterSet copad(conf.getParameter<edm::ParameterSet>("copadParamGE11"));
    maxDeltaPad_ = copad.getParameter<unsigned int>("maxDeltaPad");
    maxDeltaRoll_ = copad.getParameter<unsigned int>("maxDeltaRoll");
    maxDeltaBX_ = copad.getParameter<unsigned int>("maxDeltaBX");
  }

  if (station_ == 2) {
    // by default set to true
    hasGE21Geometry16Partitions_ = true;

    const edm::ParameterSet copad(conf.getParameter<edm::ParameterSet>("copadParamGE21"));
    maxDeltaPad_ = copad.getParameter<unsigned int>("maxDeltaPad");
    maxDeltaRoll_ = copad.getParameter<unsigned int>("maxDeltaRoll");
    maxDeltaBX_ = copad.getParameter<unsigned int>("maxDeltaBX");
  }
}

Member Function Documentation

void GEMClusterProcessor::addCoincidenceClusters ( const GEMPadDigiClusterCollection *  in_clusters )

private

Definition at line 92 of file GEMClusterProcessor.cc.

References funct::abs(), chamber_, clusters_, GEMPadDigiCluster::GE21, hasGE21Geometry16Partitions_, GeomDetEnumerators::isME0(), phase1PixelTopology::layer, match(), maxDeltaBX_, maxDeltaPad_, maxDeltaRoll_, or, AlCaHLTBitMon_ParallelJobs::p, HLT_FULL_cff::region, region_, relativeConstraints::ring, relativeConstraints::station, and station_.

Referenced by run().

                                                                                               {
  // Build coincidences
  for (auto det_range = in_clusters->begin(); det_range != in_clusters->end(); ++det_range) {
    const GEMDetId& id = (*det_range).first;

    // coincidence pads are not built for ME0
    if (id.isME0())
      continue;

    // same chamber (no restriction on the roll number)
    if (id.region() != region_ or id.station() != station_ or id.chamber() != chamber_)
      continue;

    // all coincidences detIDs will have layer=1
    if (id.layer() != 1)
      continue;

    // find all corresponding ids with layer 2 and same roll that differs at most maxDeltaRoll_
    for (unsigned int roll = id.roll() - maxDeltaRoll_; roll <= id.roll() + maxDeltaRoll_; ++roll) {
      GEMDetId co_id(id.region(), id.ring(), id.station(), 2, id.chamber(), roll);

      auto co_clusters_range = in_clusters->get(co_id);

      // empty range = no possible coincidence pads
      if (co_clusters_range.first == co_clusters_range.second)
        continue;

      // now let's correlate the pads in two layers of this partition
      const auto& pads_range = (*det_range).second;
      for (auto p = pads_range.first; p != pads_range.second; ++p) {
        // ignore 8-partition GE2/1 pads
        if (id.isGE21() and p->nPartitions() == GEMPadDigiCluster::GE21) {
          hasGE21Geometry16Partitions_ = false;
          continue;
        }

        // only consider valid pads
        if (!p->isValid())
          continue;

        for (auto co_p = co_clusters_range.first; co_p != co_clusters_range.second; ++co_p) {
          // only consider valid clusters
          if (!co_p->isValid())
            continue;

          // check the match in BX
          if ((unsigned)std::abs(p->bx() - co_p->bx()) > maxDeltaBX_)
            continue;

          // get the corrected minimum and maximum of cluster 1
          int cl1_min = p->pads().front() - maxDeltaPad_;
          int cl1_max = p->pads().back() + maxDeltaPad_;

          // get the minimum and maximum of cluster 2
          int cl2_min = co_p->pads().front();
          int cl2_max = co_p->pads().back();

          // match condition
          const bool condition1(cl1_min <= cl2_min and cl1_max >= cl2_min);
          const bool condition2(cl1_min <= cl2_max and cl1_max >= cl2_max);
          const bool match(condition1 or condition2);

          if (!match)
            continue;

          // make a new coincidence
          clusters_.emplace_back(id, *p, *co_p);
        }
      }
    }
  }
}

void GEMClusterProcessor::addSingleClusters ( const GEMPadDigiClusterCollection *  in_clusters )

private

Definition at line 165 of file GEMClusterProcessor.cc.

References SplitLinear::begin, chamber_, clusters_, dataset::end, GEMPadDigiCluster::GE21, GEMInternalCluster::has_cluster(), hasGE21Geometry16Partitions_, GeomDetEnumerators::isME0(), phase1PixelTopology::layer, or, AlCaHLTBitMon_ParallelJobs::p, submitPVResolutionJobs::q, HLT_FULL_cff::region, region_, and station_.

Referenced by run().

                                                                                          {
  // first get the coincidences
  const std::vector<GEMInternalCluster>& coincidences = clusters_;

  // now start add single clusters
  for (auto det_range = in_clusters->begin(); det_range != in_clusters->end(); ++det_range) {
    const GEMDetId& id = (*det_range).first;

    // ignore ME0
    if (id.isME0())
      continue;

    // same chamber (no restriction on the roll number)
    if (id.region() != region_ or id.station() != station_ or id.chamber() != chamber_)
      continue;

    const auto& clusters_range = (*det_range).second;
    for (auto p = clusters_range.first; p != clusters_range.second; ++p) {
      // only consider valid clusters
      if (!p->isValid())
        continue;

      // ignore 8-partition GE2/1 pads
      if (id.isGE21() and p->nPartitions() == GEMPadDigiCluster::GE21) {
        hasGE21Geometry16Partitions_ = false;
        continue;
      }

      // ignore clusters already contained in a coincidence cluster
      if (std::find_if(std::begin(coincidences), std::end(coincidences), [p](const GEMInternalCluster& q) {
            return q.has_cluster(*p);
          }) != std::end(coincidences))
        continue;

      // put the single clusters into the collection
      if (id.layer() == 1)
        clusters_.emplace_back(id, *p, GEMPadDigiCluster());
      else
        clusters_.emplace_back(id, GEMPadDigiCluster(), *p);
    }
  }
}

void GEMClusterProcessor::clear

(

void

)

Clear copad vector

Definition at line 34 of file GEMClusterProcessor.cc.

References clusters_.

Referenced by run().

{ clusters_.clear(); }

void GEMClusterProcessor::doCoordinateConversion ( )

private

Definition at line 208 of file GEMClusterProcessor.cc.

References clusters_, CSCL1TPLookupTableME11ILT::GEM_pad_CSC_es_ME1a_even(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_es_ME1a_odd(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_es_ME1b_even(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_es_ME1b_odd(), CSCL1TPLookupTableME21ILT::GEM_pad_CSC_es_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_pad_CSC_es_ME21_odd(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_hs_ME1a_even(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_hs_ME1a_odd(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_hs_ME1b_even(), CSCL1TPLookupTableME11ILT::GEM_pad_CSC_hs_ME1b_odd(), CSCL1TPLookupTableME21ILT::GEM_pad_CSC_hs_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_pad_CSC_hs_ME21_odd(), CSCL1TPLookupTableME11ILT::GEM_roll_L1_CSC_max_wg_ME11_even(), CSCL1TPLookupTableME11ILT::GEM_roll_L1_CSC_max_wg_ME11_odd(), CSCL1TPLookupTableME21ILT::GEM_roll_L1_CSC_max_wg_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_roll_L1_CSC_max_wg_ME21_odd(), CSCL1TPLookupTableME11ILT::GEM_roll_L1_CSC_min_wg_ME11_even(), CSCL1TPLookupTableME11ILT::GEM_roll_L1_CSC_min_wg_ME11_odd(), CSCL1TPLookupTableME21ILT::GEM_roll_L1_CSC_min_wg_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_roll_L1_CSC_min_wg_ME21_odd(), CSCL1TPLookupTableME11ILT::GEM_roll_L2_CSC_max_wg_ME11_even(), CSCL1TPLookupTableME11ILT::GEM_roll_L2_CSC_max_wg_ME11_odd(), CSCL1TPLookupTableME21ILT::GEM_roll_L2_CSC_max_wg_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_roll_L2_CSC_max_wg_ME21_odd(), CSCL1TPLookupTableME11ILT::GEM_roll_L2_CSC_min_wg_ME11_even(), CSCL1TPLookupTableME11ILT::GEM_roll_L2_CSC_min_wg_ME11_odd(), CSCL1TPLookupTableME21ILT::GEM_roll_L2_CSC_min_wg_ME21_even(), CSCL1TPLookupTableME21ILT::GEM_roll_L2_CSC_min_wg_ME21_odd(), isEven_, lookupTableME11ILT_, lookupTableME21ILT_, and station_.

Referenced by run().

                                                 {
  // loop on clusters
  for (auto& cluster : clusters_) {
    if (cluster.cl1().isValid()) {
      // starting coordinates
      const int layer1_first_pad = cluster.layer1_pad();
      const int layer1_last_pad = layer1_first_pad + cluster.layer1_size() - 1;

      // calculate the 1/2-strip
      int layer1_pad_to_first_hs = -1;
      int layer1_pad_to_last_hs = -1;
      int layer1_pad_to_first_hs_me1a = -1;
      int layer1_pad_to_last_hs_me1a = -1;

      // ME1/1
      if (station_ == 1) {
        if (isEven_) {
          // ME1/b
          layer1_pad_to_first_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_even(layer1_first_pad);
          layer1_pad_to_last_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_even(layer1_last_pad);
          // ME1/a
          layer1_pad_to_first_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_even(layer1_first_pad);
          layer1_pad_to_last_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_even(layer1_last_pad);
        } else {
          // ME1/b
          layer1_pad_to_first_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_odd(layer1_first_pad);
          layer1_pad_to_last_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_odd(layer1_last_pad);
          // ME1/a
          layer1_pad_to_first_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_odd(layer1_first_pad);
          layer1_pad_to_last_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_odd(layer1_last_pad);
        }
      }
      // ME2/1
      if (station_ == 2) {
        if (isEven_) {
          layer1_pad_to_first_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_even(layer1_first_pad);
          layer1_pad_to_last_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_even(layer1_last_pad);
        } else {
          layer1_pad_to_first_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_odd(layer1_first_pad);
          layer1_pad_to_last_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_odd(layer1_last_pad);
        }
      }
      // middle 1/2-strip
      int layer1_middle_hs = 0.5 * (layer1_pad_to_first_hs + layer1_pad_to_last_hs);
      int layer1_middle_hs_me1a = 0.5 * (layer1_pad_to_first_hs_me1a + layer1_pad_to_last_hs_me1a);

      // set the values
      cluster.set_layer1_first_hs(layer1_pad_to_first_hs);
      cluster.set_layer1_last_hs(layer1_pad_to_last_hs);
      cluster.set_layer1_middle_hs(layer1_middle_hs);

      if (station_ == 1) {
        cluster.set_layer1_first_hs_me1a(layer1_pad_to_first_hs_me1a);
        cluster.set_layer1_last_hs_me1a(layer1_pad_to_last_hs_me1a);
        cluster.set_layer1_middle_hs_me1a(layer1_middle_hs_me1a);
      }
      // calculate the 1/8-strips
      int layer1_pad_to_first_es = -1;
      int layer1_pad_to_last_es = -1;

      int layer1_pad_to_first_es_me1a = -1;
      int layer1_pad_to_last_es_me1a = -1;

      // ME1/1
      if (station_ == 1) {
        if (isEven_) {
          // ME1/b
          layer1_pad_to_first_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_even(layer1_first_pad);
          layer1_pad_to_last_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_even(layer1_last_pad);
          // ME1/a
          layer1_pad_to_first_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_even(layer1_first_pad);
          layer1_pad_to_last_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_even(layer1_last_pad);
        } else {
          // ME1/b
          layer1_pad_to_first_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_odd(layer1_first_pad);
          layer1_pad_to_last_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_odd(layer1_last_pad);
          // ME1/a
          layer1_pad_to_first_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_odd(layer1_first_pad);
          layer1_pad_to_last_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_odd(layer1_last_pad);
        }
      }
      // ME2/1
      if (station_ == 2) {
        if (isEven_) {
          layer1_pad_to_first_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_even(layer1_first_pad);
          layer1_pad_to_last_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_even(layer1_last_pad);
        } else {
          layer1_pad_to_first_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_odd(layer1_first_pad);
          layer1_pad_to_last_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_odd(layer1_last_pad);
        }
      }
      // middle 1/8-strip
      int layer1_middle_es = 0.5 * (layer1_pad_to_first_es + layer1_pad_to_last_es);
      int layer1_middle_es_me1a = 0.5 * (layer1_pad_to_first_es_me1a + layer1_pad_to_last_es_me1a);

      cluster.set_layer1_first_es(layer1_pad_to_first_es);
      cluster.set_layer1_last_es(layer1_pad_to_last_es);
      cluster.set_layer1_middle_es(layer1_middle_es);

      if (station_ == 1) {
        cluster.set_layer1_first_es_me1a(layer1_pad_to_first_es_me1a);
        cluster.set_layer1_last_es_me1a(layer1_pad_to_last_es_me1a);
        cluster.set_layer1_middle_es_me1a(layer1_middle_es_me1a);
      }

      // calculate the wiregroups
      // need to subtract 1 to use the LUTs
      const int roll = cluster.roll() - 1;

      int roll_l1_to_min_wg = -1;
      int roll_l1_to_max_wg = -1;

      // ME1/1
      if (station_ == 1) {
        if (isEven_) {
          roll_l1_to_min_wg = lookupTableME11ILT_->GEM_roll_L1_CSC_min_wg_ME11_even(roll);
          roll_l1_to_max_wg = lookupTableME11ILT_->GEM_roll_L1_CSC_max_wg_ME11_even(roll);
        } else {
          roll_l1_to_min_wg = lookupTableME11ILT_->GEM_roll_L1_CSC_min_wg_ME11_odd(roll);
          roll_l1_to_max_wg = lookupTableME11ILT_->GEM_roll_L1_CSC_max_wg_ME11_odd(roll);
        }
      }

      // ME2/1
      if (station_ == 2) {
        if (isEven_) {
          roll_l1_to_min_wg = lookupTableME21ILT_->GEM_roll_L1_CSC_min_wg_ME21_even(roll);
          roll_l1_to_max_wg = lookupTableME21ILT_->GEM_roll_L1_CSC_max_wg_ME21_even(roll);
        } else {
          roll_l1_to_min_wg = lookupTableME21ILT_->GEM_roll_L1_CSC_min_wg_ME21_odd(roll);
          roll_l1_to_max_wg = lookupTableME21ILT_->GEM_roll_L1_CSC_max_wg_ME21_odd(roll);
        }
      }

      // set the values
      cluster.set_layer1_min_wg(roll_l1_to_min_wg);
      cluster.set_layer1_max_wg(roll_l1_to_max_wg);
    }

    if (cluster.cl2().isValid()) {
      // starting coordinates
      const int layer2_first_pad = cluster.layer2_pad();
      const int layer2_last_pad = layer2_first_pad + cluster.layer2_size() - 1;

      // calculate the 1/2-strip
      int layer2_pad_to_first_hs = -1;
      int layer2_pad_to_last_hs = -1;
      int layer2_pad_to_first_hs_me1a = -1;
      int layer2_pad_to_last_hs_me1a = -1;

      if (station_ == 1) {
        if (isEven_) {
          // ME1/b
          layer2_pad_to_first_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_even(layer2_first_pad);
          layer2_pad_to_last_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_even(layer2_last_pad);
          // ME1/a
          layer2_pad_to_first_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_even(layer2_first_pad);
          layer2_pad_to_last_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_even(layer2_last_pad);
        } else {
          // ME1/b
          layer2_pad_to_first_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_odd(layer2_first_pad);
          layer2_pad_to_last_hs = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1b_odd(layer2_last_pad);
          // ME1/a
          layer2_pad_to_first_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_odd(layer2_first_pad);
          layer2_pad_to_last_hs_me1a = lookupTableME11ILT_->GEM_pad_CSC_hs_ME1a_odd(layer2_last_pad);
        }
      }
      // ME2/1
      if (station_ == 2) {
        if (isEven_) {
          layer2_pad_to_first_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_even(layer2_first_pad);
          layer2_pad_to_last_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_even(layer2_last_pad);
        } else {
          layer2_pad_to_first_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_odd(layer2_first_pad);
          layer2_pad_to_last_hs = lookupTableME21ILT_->GEM_pad_CSC_hs_ME21_odd(layer2_last_pad);
        }
      }
      // middle 1/2-strip
      int layer2_middle_hs = 0.5 * (layer2_pad_to_first_hs + layer2_pad_to_last_hs);
      int layer2_middle_hs_me1a = 0.5 * (layer2_pad_to_first_hs_me1a + layer2_pad_to_last_hs_me1a);

      // set the values
      cluster.set_layer2_first_hs(layer2_pad_to_first_hs);
      cluster.set_layer2_last_hs(layer2_pad_to_last_hs);
      cluster.set_layer2_middle_hs(layer2_middle_hs);

      if (station_ == 1) {
        cluster.set_layer2_first_hs_me1a(layer2_pad_to_first_hs_me1a);
        cluster.set_layer2_last_hs_me1a(layer2_pad_to_last_hs_me1a);
        cluster.set_layer2_middle_hs_me1a(layer2_middle_hs_me1a);
      }
      // calculate the 1/8-strips
      int layer2_pad_to_first_es = -1;
      int layer2_pad_to_last_es = -1;

      int layer2_pad_to_first_es_me1a = -1;
      int layer2_pad_to_last_es_me1a = -1;

      if (station_ == 1) {
        if (isEven_) {
          // ME1/b
          layer2_pad_to_first_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_even(layer2_first_pad);
          layer2_pad_to_last_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_even(layer2_last_pad);
          // ME1/a
          layer2_pad_to_first_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_even(layer2_first_pad);
          layer2_pad_to_last_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_even(layer2_last_pad);
        } else {
          // ME1/b
          layer2_pad_to_first_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_odd(layer2_first_pad);
          layer2_pad_to_last_es = lookupTableME11ILT_->GEM_pad_CSC_es_ME1b_odd(layer2_last_pad);
          // ME1/a
          layer2_pad_to_first_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_odd(layer2_first_pad);
          layer2_pad_to_last_es_me1a = lookupTableME11ILT_->GEM_pad_CSC_es_ME1a_odd(layer2_last_pad);
        }
      }

      // ME2/1
      if (station_ == 2) {
        if (isEven_) {
          layer2_pad_to_first_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_even(layer2_first_pad);
          layer2_pad_to_last_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_even(layer2_last_pad);
        } else {
          layer2_pad_to_first_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_odd(layer2_first_pad);
          layer2_pad_to_last_es = lookupTableME21ILT_->GEM_pad_CSC_es_ME21_odd(layer2_last_pad);
        }
      }
      // middle 1/8-strip
      int layer2_middle_es = 0.5 * (layer2_pad_to_first_es + layer2_pad_to_last_es);
      int layer2_middle_es_me1a = 0.5 * (layer2_pad_to_first_es_me1a + layer2_pad_to_last_es_me1a);

      cluster.set_layer2_first_es(layer2_pad_to_first_es);
      cluster.set_layer2_last_es(layer2_pad_to_last_es);
      cluster.set_layer2_middle_es(layer2_middle_es);

      if (station_ == 1) {
        cluster.set_layer2_first_es_me1a(layer2_pad_to_first_es_me1a);
        cluster.set_layer2_last_es_me1a(layer2_pad_to_last_es_me1a);
        cluster.set_layer2_middle_es_me1a(layer2_middle_es_me1a);
      }
    }

    // calculate the wiregroups
    // need to subtract 1 to use the LUTs
    const int roll = cluster.roll() - 1;

    int roll_l2_to_min_wg = -1;
    int roll_l2_to_max_wg = -1;

    // ME1/1
    if (station_ == 1) {
      if (isEven_) {
        roll_l2_to_min_wg = lookupTableME11ILT_->GEM_roll_L2_CSC_min_wg_ME11_even(roll);
        roll_l2_to_max_wg = lookupTableME11ILT_->GEM_roll_L2_CSC_max_wg_ME11_even(roll);
      } else {
        roll_l2_to_min_wg = lookupTableME11ILT_->GEM_roll_L2_CSC_min_wg_ME11_odd(roll);
        roll_l2_to_max_wg = lookupTableME11ILT_->GEM_roll_L2_CSC_max_wg_ME11_odd(roll);
      }
    }

    // ME2/1
    if (station_ == 2) {
      if (isEven_) {
        roll_l2_to_min_wg = lookupTableME21ILT_->GEM_roll_L2_CSC_min_wg_ME21_even(roll);
        roll_l2_to_max_wg = lookupTableME21ILT_->GEM_roll_L2_CSC_max_wg_ME21_even(roll);
      } else {
        roll_l2_to_min_wg = lookupTableME21ILT_->GEM_roll_L2_CSC_min_wg_ME21_odd(roll);
        roll_l2_to_max_wg = lookupTableME21ILT_->GEM_roll_L2_CSC_max_wg_ME21_odd(roll);
      }
    }

    // set the values
    cluster.set_layer2_min_wg(roll_l2_to_min_wg);
    cluster.set_layer2_max_wg(roll_l2_to_max_wg);
  }
}

std::vector< GEMInternalCluster > GEMClusterProcessor::getClusters	(	int	bx,
		int	deltaBX = 0,
		ClusterTypes	option = AllClusters
	)		const

Definition at line 60 of file GEMClusterProcessor.cc.

References funct::abs(), makePileupJSON::bx, haddnano::cl, clusters_, CoincidenceClusters, convertSQLitetoXML_cfg::output, and SingleClusters.

                                                                                                             {
  std::vector<GEMInternalCluster> output;

  for (const auto& cl : clusters_) {
    // valid single clusters with the right BX
    if (std::abs(cl.bx() - bx) <= deltaBX and cl.isValid()) {
      // ignore the coincidence clusters
      if (option == SingleClusters and cl.isCoincidence())
        continue;
      // ignore the single clusters
      if (option == CoincidenceClusters and !cl.isCoincidence())
        continue;
      output.push_back(cl);
    }
  }

  return output;
}

std::vector< GEMInternalCluster > GEMClusterProcessor::getCoincidenceClusters

(

int

bx

)

const

Definition at line 79 of file GEMClusterProcessor.cc.

References haddnano::cl, clusters_, and convertSQLitetoXML_cfg::output.

                                                                                      {
  std::vector<GEMInternalCluster> output;

  for (const auto& cl : clusters_) {
    // valid coincidences with the right BX
    if (cl.bx() == bx and cl.isCoincidence()) {
      output.push_back(cl);
    }
  }

  return output;
}

bool GEMClusterProcessor::hasGE21Geometry16Partitions ( ) const

inline

Definition at line 43 of file GEMClusterProcessor.h.

References hasGE21Geometry16Partitions_.

{ return hasGE21Geometry16Partitions_; }

std::vector< GEMCoPadDigi > GEMClusterProcessor::readoutCoPads

(

)

const

Returns vector of CoPads in the read-out time window, if any.

Definition at line 484 of file GEMClusterProcessor.cc.

References clusters_, and convertSQLitetoXML_cfg::output.

                                                                 {
  std::vector<GEMCoPadDigi> output;

  // loop on clusters
  for (const auto& cluster : clusters_) {
    // ignore single clusters
    if (!cluster.isCoincidence())
      continue;

    // construct coincidence pads out of the centers of the coincidence clusters
    output.emplace_back(cluster.roll(), cluster.mid1(), cluster.mid2());
  }

  return output;
}

void GEMClusterProcessor::run

(

const GEMPadDigiClusterCollection *

in_clusters

)

Runs the CoPad processor code.

Definition at line 40 of file GEMClusterProcessor.cc.

References addCoincidenceClusters(), addSingleClusters(), clear(), and doCoordinateConversion().

                                                                            {
  // Step 1: clear the GEMInternalCluster vector
  clear();

  // check that the GEM cluster collection is a valid pointer
  if (in_clusters == nullptr) {
    edm::LogWarning("GEMClusterProcessor") << "Attempt to run without valid in_clusters pointer.";
    return;
  }

  // Step 2: put coincidence clusters in GEMInternalCluster vector
  addCoincidenceClusters(in_clusters);

  // Step 3: put single clusters in GEMInternalCluster vector who are not part of any coincidence cluster
  addSingleClusters(in_clusters);

  // Step 4: translate the cluster central pad numbers into 1/8-strip number for matching with CSC trigger primitives
  doCoordinateConversion();
}

void GEMClusterProcessor::setESLookupTables

(

const CSCL1TPLookupTableME11ILT *

conf

)

Definition at line 36 of file GEMClusterProcessor.cc.

References lookupTableME11ILT_.

{ lookupTableME11ILT_ = conf; }

void GEMClusterProcessor::setESLookupTables

(

const CSCL1TPLookupTableME21ILT *

conf

)

Definition at line 38 of file GEMClusterProcessor.cc.

References lookupTableME21ILT_.

{ lookupTableME21ILT_ = conf; }

Member Data Documentation

const int GEMClusterProcessor::chamber_

private

Definition at line 65 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), and GEMClusterProcessor().

std::vector<GEMInternalCluster> GEMClusterProcessor::clusters_

private

Definition at line 75 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), clear(), doCoordinateConversion(), getClusters(), getCoincidenceClusters(), and readoutCoPads().

bool GEMClusterProcessor::hasGE21Geometry16Partitions_

private

Definition at line 72 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), GEMClusterProcessor(), and hasGE21Geometry16Partitions().

bool GEMClusterProcessor::isEven_

private

Definition at line 66 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and GEMClusterProcessor().

const CSCL1TPLookupTableME11ILT* GEMClusterProcessor::lookupTableME11ILT_

private

Definition at line 77 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and setESLookupTables().

const CSCL1TPLookupTableME21ILT* GEMClusterProcessor::lookupTableME21ILT_

private

Definition at line 78 of file GEMClusterProcessor.h.

Referenced by doCoordinateConversion(), and setESLookupTables().

unsigned int GEMClusterProcessor::maxDeltaBX_

private

Definition at line 69 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

unsigned int GEMClusterProcessor::maxDeltaPad_

private

Definition at line 68 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

unsigned int GEMClusterProcessor::maxDeltaRoll_

private

Definition at line 70 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and GEMClusterProcessor().

const int GEMClusterProcessor::region_

private

Chamber id (trigger-type labels).

Definition at line 63 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), and addSingleClusters().

const int GEMClusterProcessor::station_

private

Definition at line 64 of file GEMClusterProcessor.h.

Referenced by addCoincidenceClusters(), addSingleClusters(), doCoordinateConversion(), and GEMClusterProcessor().