PPSAlignmentWorker::SectorData Struct Reference

Classes
struct	SlicePlots

Public Member Functions
void	init (DQMStore::IBooker &iBooker, const PPSAlignmentConfiguration &cfg, const PPSAlignmentConfiguration::SectorConfig &scfg, const std::string &folder, bool debug)
unsigned int	process (const CTPPSLocalTrackLiteCollection &tracks, const PPSAlignmentConfiguration &cfg, bool debug)

Public Attributes
MonitorElement *	h2_cut_h_aft
MonitorElement *	h2_cut_h_bef
MonitorElement *	h2_cut_v_aft
MonitorElement *	h2_cut_v_bef
MonitorElement *	h_q_cut_h_aft
MonitorElement *	h_q_cut_h_bef
MonitorElement *	h_q_cut_v_aft
MonitorElement *	h_q_cut_v_bef
std::map< unsigned int, MonitorElement * >	m_h2_y_vs_x_aft_sel
std::map< unsigned int, MonitorElement * >	m_h2_y_vs_x_bef_sel
std::map< unsigned int, MonitorElement * >	m_h2_y_vs_x_mlt_sel
MonitorElement *	p_x_diffFN_vs_x_N
MonitorElement *	p_y_diffFN_vs_y_F
PPSAlignmentConfiguration::SectorConfig	scfg_
std::map< unsigned int, SlicePlots >	x_slice_plots_F
std::map< unsigned int, SlicePlots >	x_slice_plots_N

Detailed Description

Definition at line 46 of file PPSAlignmentWorker.cc.

Member Function Documentation

void PPSAlignmentWorker::SectorData::init	(	DQMStore::IBooker &	iBooker,
		const PPSAlignmentConfiguration &	cfg,
		const PPSAlignmentConfiguration::SectorConfig &	scfg,
		const std::string &	folder,
		bool	debug
	)

Definition at line 176 of file PPSAlignmentWorker.cc.

References PPSAlignmentConfiguration::Binning::bin_size_x_, PPSAlignmentConfiguration::binning(), dqm::implementation::IBooker::book1DD(), dqm::implementation::IBooker::book2DD(), dqm::implementation::IBooker::bookProfile(), visDQMUpload::buf, PPSAlignmentConfiguration::Binning::diffFN_n_bins_x_, PPSAlignmentConfiguration::Binning::diffFN_x_max_, PPSAlignmentConfiguration::Binning::diffFN_x_min_, h2_cut_h_aft, h2_cut_h_bef, h2_cut_v_aft, h2_cut_v_bef, h_q_cut_h_aft, h_q_cut_h_bef, h_q_cut_v_aft, h_q_cut_v_bef, mps_fire::i, PPSAlignmentConfiguration::RPConfig::id_, m_h2_y_vs_x_aft_sel, m_h2_y_vs_x_bef_sel, m_h2_y_vs_x_mlt_sel, PPSAlignmentConfiguration::Binning::n_bins_x_, PPSAlignmentConfiguration::Binning::n_bins_y_, PPSAlignmentConfiguration::RPConfig::name_, PPSAlignmentConfiguration::SectorConfig::name_, p_x_diffFN_vs_x_N, PPSAlignmentConfiguration::Binning::pixel_x_offset_, PPSAlignmentConfiguration::SectorConfig::rp_F_, PPSAlignmentConfiguration::SectorConfig::rp_N_, scfg_, dqm::implementation::NavigatorBase::setCurrentFolder(), PPSAlignmentConfiguration::RPConfig::x_slice_min_, PPSAlignmentConfiguration::RPConfig::x_slice_n_, x_slice_plots_F, x_slice_plots_N, PPSAlignmentConfiguration::RPConfig::x_slice_w_, PPSAlignmentConfiguration::Binning::y_max_, and PPSAlignmentConfiguration::Binning::y_min_.

Referenced by PPSAlignmentWorker::bookHistograms().

                                                      {
  scfg_ = scfg;

  // binning
  const double bin_size_x = cfg.binning().bin_size_x_;
  const unsigned int n_bins_x = cfg.binning().n_bins_x_;

  const double pixel_x_offset = cfg.binning().pixel_x_offset_;

  const double x_min_pix = pixel_x_offset, x_max_pix = pixel_x_offset + n_bins_x * bin_size_x;
  const double x_min_str = 0., x_max_str = n_bins_x * bin_size_x;

  const unsigned int n_bins_y = cfg.binning().n_bins_y_;
  const double y_min = cfg.binning().y_min_, y_max = cfg.binning().y_max_;

  // hit distributions
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/before selection/" + scfg_.rp_N_.name_);
  m_h2_y_vs_x_bef_sel[scfg_.rp_N_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_str, x_max_str, n_bins_y, y_min, y_max);
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/before selection/" + scfg_.rp_F_.name_);
  m_h2_y_vs_x_bef_sel[scfg_.rp_F_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_pix, x_max_pix, n_bins_y, y_min, y_max);

  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/multiplicity selection/" + scfg_.rp_N_.name_);
  m_h2_y_vs_x_mlt_sel[scfg_.rp_N_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_str, x_max_str, n_bins_y, y_min, y_max);
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/multiplicity selection/" + scfg_.rp_F_.name_);
  m_h2_y_vs_x_mlt_sel[scfg_.rp_F_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_pix, x_max_pix, n_bins_y, y_min, y_max);

  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/after selection/" + scfg_.rp_N_.name_);
  m_h2_y_vs_x_aft_sel[scfg_.rp_N_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_str, x_max_str, n_bins_y, y_min, y_max);
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/after selection/" + scfg_.rp_F_.name_);
  m_h2_y_vs_x_aft_sel[scfg_.rp_F_.id_] =
      iBooker.book2DD("h2_y_vs_x", ";x;y", n_bins_x, x_min_pix, x_max_pix, n_bins_y, y_min, y_max);

  // cut plots
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/cuts/cut_h");
  h_q_cut_h_bef = iBooker.book1DD("h_q_cut_h_bef", ";cq_h", 400, -2., 2.);
  h_q_cut_h_aft = iBooker.book1DD("h_q_cut_h_aft", ";cq_h", 400, -2., 2.);
  h2_cut_h_bef =
      iBooker.book2DD("h2_cut_h_bef", ";x_up;x_dw", n_bins_x, x_min_str, x_max_str, n_bins_x, x_min_pix, x_max_pix);
  h2_cut_h_aft =
      iBooker.book2DD("h2_cut_h_aft", ";x_up;x_dw", n_bins_x, x_min_str, x_max_str, n_bins_x, x_min_pix, x_max_pix);

  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/cuts/cut_v");
  h_q_cut_v_bef = iBooker.book1DD("h_q_cut_v_bef", ";cq_v", 400, -2., 2.);
  h_q_cut_v_aft = iBooker.book1DD("h_q_cut_v_aft", ";cq_v", 400, -2., 2.);
  h2_cut_v_bef = iBooker.book2DD("h2_cut_v_bef", ";y_up;y_dw", n_bins_y, y_min, y_max, n_bins_y, y_min, y_max);
  h2_cut_v_aft = iBooker.book2DD("h2_cut_v_aft", ";y_up;y_dw", n_bins_y, y_min, y_max, n_bins_y, y_min, y_max);

  // near-far plots
  iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/near_far");

  auto profilePtr = std::make_unique<TProfile>("",
                                               ";x_{N};x_{F} - x_{N}",
                                               cfg.binning().diffFN_n_bins_x_,
                                               cfg.binning().diffFN_x_min_,
                                               cfg.binning().diffFN_x_max_);
  p_x_diffFN_vs_x_N = iBooker.bookProfile("p_x_diffFN_vs_x_N", profilePtr.get());

  for (int i = 0; i < scfg_.rp_N_.x_slice_n_; i++) {
    const double x_min = scfg_.rp_N_.x_slice_min_ + i * scfg_.rp_N_.x_slice_w_;
    const double x_max = scfg_.rp_N_.x_slice_min_ + (i + 1) * scfg_.rp_N_.x_slice_w_;

    char buf[100];
    sprintf(buf, "%.1f-%.1f", x_min, x_max);

    iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/near_far/x slices, N/" + buf);
    x_slice_plots_N.insert({i, SlicePlots(iBooker, cfg, debug)});
  }

  for (int i = 0; i < scfg_.rp_F_.x_slice_n_; i++) {
    const double x_min = scfg_.rp_F_.x_slice_min_ + i * scfg_.rp_F_.x_slice_w_;
    const double x_max = scfg_.rp_F_.x_slice_min_ + (i + 1) * scfg_.rp_F_.x_slice_w_;

    char buf[100];
    sprintf(buf, "%.1f-%.1f", x_min, x_max);

    iBooker.setCurrentFolder(folder + "/" + scfg_.name_ + "/near_far/x slices, F/" + buf);
    x_slice_plots_F.insert({i, SlicePlots(iBooker, cfg, debug)});
  }
}

unsigned int PPSAlignmentWorker::SectorData::process	(	const CTPPSLocalTrackLiteCollection &	tracks,
		const PPSAlignmentConfiguration &	cfg,
		bool	debug
	)

Definition at line 265 of file PPSAlignmentWorker.cc.

References CTPPSDetId::arm(), PPSAlignmentConfiguration::SectorConfig::cut_h_a_, PPSAlignmentConfiguration::SectorConfig::cut_h_apply_, PPSAlignmentConfiguration::SectorConfig::cut_h_c_, PPSAlignmentConfiguration::SectorConfig::cut_h_si_, PPSAlignmentConfiguration::SectorConfig::cut_v_a_, PPSAlignmentConfiguration::SectorConfig::cut_v_apply_, PPSAlignmentConfiguration::SectorConfig::cut_v_c_, PPSAlignmentConfiguration::SectorConfig::cut_v_si_, dqm::impl::MonitorElement::Fill(), h2_cut_h_aft, h2_cut_h_bef, h2_cut_v_aft, h2_cut_v_bef, h_q_cut_h_aft, h_q_cut_h_bef, h_q_cut_v_aft, h_q_cut_v_bef, PPSAlignmentConfiguration::RPConfig::id_, if(), m_h2_y_vs_x_aft_sel, m_h2_y_vs_x_bef_sel, m_h2_y_vs_x_mlt_sel, PPSAlignmentConfiguration::maxRPTracksSize(), PPSAlignmentConfiguration::minRPTracksSize(), PPSAlignmentConfiguration::n_si(), p_x_diffFN_vs_x_N, PPSAlignmentConfiguration::SectorConfig::rp_F_, PPSAlignmentConfiguration::SectorConfig::rp_N_, scfg_, PPSAlignmentConfiguration::RPConfig::x_slice_min_, PPSAlignmentConfiguration::RPConfig::x_slice_n_, x_slice_plots_F, x_slice_plots_N, and PPSAlignmentConfiguration::RPConfig::x_slice_w_.

Referenced by PPSAlignmentWorker::analyze().

                                                                 {
  CTPPSLocalTrackLiteCollection tracksUp, tracksDw;

  for (const auto& tr : tracks) {
    CTPPSDetId rpId(tr.rpId());
    unsigned int rpDecId = rpId.arm() * 100 + rpId.station() * 10 + rpId.rp();

    if (rpDecId != scfg_.rp_N_.id_ && rpDecId != scfg_.rp_F_.id_)
      continue;

    // store the track in the right collection
    if (rpDecId == scfg_.rp_N_.id_)
      tracksUp.push_back(tr);
    if (rpDecId == scfg_.rp_F_.id_)
      tracksDw.push_back(tr);
  }

  // update plots before selection
  for (const auto& tr : tracksUp)
    m_h2_y_vs_x_bef_sel[scfg_.rp_N_.id_]->Fill(tr.x(), tr.y());

  for (const auto& tr : tracksDw)
    m_h2_y_vs_x_bef_sel[scfg_.rp_F_.id_]->Fill(tr.x(), tr.y());

  // skip crowded events (multiplicity selection)
  if (tracksUp.size() < cfg.minRPTracksSize() || tracksUp.size() > cfg.maxRPTracksSize())
    return 0;

  if (tracksDw.size() < cfg.minRPTracksSize() || tracksDw.size() > cfg.maxRPTracksSize())
    return 0;

  // update plots with multiplicity selection
  for (const auto& tr : tracksUp)
    m_h2_y_vs_x_mlt_sel[scfg_.rp_N_.id_]->Fill(tr.x(), tr.y());

  for (const auto& tr : tracksDw)
    m_h2_y_vs_x_mlt_sel[scfg_.rp_F_.id_]->Fill(tr.x(), tr.y());

  // do the selection
  unsigned int pairsSelected = 0;

  for (const auto& trUp : tracksUp) {
    for (const auto& trDw : tracksDw) {
      h2_cut_h_bef->Fill(trUp.x(), trDw.x());
      h2_cut_v_bef->Fill(trUp.y(), trDw.y());

      const double cq_h = trDw.x() + scfg_.cut_h_a_ * trUp.x() + scfg_.cut_h_c_;
      h_q_cut_h_bef->Fill(cq_h);
      const bool cv_h = (std::fabs(cq_h) < cfg.n_si() * scfg_.cut_h_si_);

      const double cq_v = trDw.y() + scfg_.cut_v_a_ * trUp.y() + scfg_.cut_v_c_;
      h_q_cut_v_bef->Fill(cq_v);
      const bool cv_v = (std::fabs(cq_v) < cfg.n_si() * scfg_.cut_v_si_);

      bool cutsPassed = true;
      if (scfg_.cut_h_apply_)
        cutsPassed &= cv_h;
      if (scfg_.cut_v_apply_)
        cutsPassed &= cv_v;

      if (cutsPassed) {
        pairsSelected++;

        h_q_cut_h_aft->Fill(cq_h);
        h_q_cut_v_aft->Fill(cq_v);

        h2_cut_h_aft->Fill(trUp.x(), trDw.x());
        h2_cut_v_aft->Fill(trUp.y(), trDw.y());

        m_h2_y_vs_x_aft_sel[scfg_.rp_N_.id_]->Fill(trUp.x(), trUp.y());
        m_h2_y_vs_x_aft_sel[scfg_.rp_F_.id_]->Fill(trDw.x(), trDw.y());

        p_x_diffFN_vs_x_N->Fill(trUp.x(), trDw.x() - trUp.x());

        int idx = (trUp.x() - scfg_.rp_N_.x_slice_min_) / scfg_.rp_N_.x_slice_w_;
        if (idx >= 0 && idx < scfg_.rp_N_.x_slice_n_) {
          x_slice_plots_N[idx].h_y->Fill(trUp.y());
          x_slice_plots_N[idx].p_y_diffFN_vs_y->Fill(trUp.y(), trDw.y() - trUp.y());
          if (debug)
            x_slice_plots_N[idx].h2_y_diffFN_vs_y->Fill(trUp.y(), trDw.y() - trUp.y());
        }

        idx = (trDw.x() - scfg_.rp_F_.x_slice_min_) / scfg_.rp_F_.x_slice_w_;
        if (idx >= 0 && idx < scfg_.rp_F_.x_slice_n_) {
          x_slice_plots_F[idx].h_y->Fill(trDw.y());
          x_slice_plots_F[idx].p_y_diffFN_vs_y->Fill(trDw.y(), trDw.y() - trUp.y());
          if (debug)
            x_slice_plots_F[idx].h2_y_diffFN_vs_y->Fill(trDw.y(), trDw.y() - trUp.y());
        }
      }
    }
  }

  return pairsSelected;
}

Member Data Documentation

MonitorElement* PPSAlignmentWorker::SectorData::h2_cut_h_aft

Definition at line 60 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h2_cut_h_bef

Definition at line 59 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h2_cut_v_aft

Definition at line 65 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h2_cut_v_bef

Definition at line 64 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h_q_cut_h_aft

Definition at line 58 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h_q_cut_h_bef

Definition at line 57 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h_q_cut_v_aft

Definition at line 63 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::h_q_cut_v_bef

Definition at line 62 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

std::map<unsigned int, MonitorElement*> PPSAlignmentWorker::SectorData::m_h2_y_vs_x_aft_sel

Definition at line 54 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

std::map<unsigned int, MonitorElement*> PPSAlignmentWorker::SectorData::m_h2_y_vs_x_bef_sel

Definition at line 50 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

std::map<unsigned int, MonitorElement*> PPSAlignmentWorker::SectorData::m_h2_y_vs_x_mlt_sel

Definition at line 52 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::p_x_diffFN_vs_x_N

Definition at line 68 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

MonitorElement* PPSAlignmentWorker::SectorData::p_y_diffFN_vs_y_F

Definition at line 69 of file PPSAlignmentWorker.cc.

PPSAlignmentConfiguration::SectorConfig PPSAlignmentWorker::SectorData::scfg_

Definition at line 47 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

std::map<unsigned int, SlicePlots> PPSAlignmentWorker::SectorData::x_slice_plots_F

Definition at line 80 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().

std::map<unsigned int, SlicePlots> PPSAlignmentWorker::SectorData::x_slice_plots_N

Definition at line 80 of file PPSAlignmentWorker.cc.

Referenced by init(), and process().