PixelROCMapHelper Namespace Reference

Functions
void	draw_line (double x1, double x2, double y1, double y2, int width, int style, int color)
void	dress_plot (TPad *&canv, TH2 *h, int lay, int ring, int phase, bool half_shift, bool mark_zero, bool standard_palette)

Function Documentation

draw_line()

void PixelROCMapHelper::draw_line ( double  x1, double  x2, double  y1, double  y2, int  width = 2, int  style = 1, int  color = 1  )

inline

Definition at line 280 of file Phase1PixelROCMaps.cc.

{
  TLine* l = new TLine(x1, y1, x2, y2);
  l->SetBit(kCanDelete);
  l->SetLineWidth(width);
  l->SetLineStyle(style);
  l->SetLineColor(color);
  l->Draw();
}

References cmsLHEtoEOSManager::l, ApeEstimator_cff::width, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

Referenced by SiPixelPI::dress_occup_plot(), and dress_plot().

dress_plot()

void PixelROCMapHelper::dress_plot	(	TPad *&	canv,
		TH2 *	h,
		int	lay,
		int	ring = 0,
		int	phase = 0,
		bool	half_shift = true,
		bool	mark_zero = true,
		bool	standard_palette = true
	)

Definition at line 293 of file Phase1PixelROCMaps.cc.

{
  std::string s_title;
  const auto zAxisTitle = fmt::sprintf("%s", h->GetZaxis()->GetTitle());
 
  if (lay > 0) {
    canv->cd(lay);
    canv->cd(lay)->SetTopMargin(0.05);
    canv->cd(lay)->SetBottomMargin(0.07);
    canv->cd(lay)->SetLeftMargin(0.1);
    if (!zAxisTitle.empty()) {
      h->GetZaxis()->SetTitleOffset(1.3);
      h->GetZaxis()->CenterTitle(true);
      canv->cd(lay)->SetRightMargin(0.14);
    } else {
      canv->cd(lay)->SetRightMargin(0.11);
    }
    s_title = "Barrel Pixel Layer " + std::to_string(lay);
  } else {
    canv->cd(ring);
    canv->cd(ring)->SetTopMargin(0.05);
    canv->cd(ring)->SetBottomMargin(0.07);
    canv->cd(ring)->SetLeftMargin(0.1);
    if (!zAxisTitle.empty()) {
      h->GetZaxis()->SetTitleOffset(1.3);
      h->GetZaxis()->CenterTitle(true);
      canv->cd(ring)->SetRightMargin(0.14);
    } else {
      canv->cd(ring)->SetRightMargin(0.11);
    }
    if (ring > 4) {
      ring = ring - 4;
    }
    s_title = "Forward Pixel Ring " + std::to_string(ring);
  }
 
  if (standard_palette) {
    gStyle->SetPalette(1);
  } else {
    /*
    const Int_t NRGBs = 5;
    const Int_t NCont = 255;
 
    Double_t stops[NRGBs] = {0.00, 0.34, 0.61, 0.84, 1.00};
    Double_t red[NRGBs] = {0.00, 0.00, 0.87, 1.00, 0.51};
    Double_t green[NRGBs] = {0.00, 0.81, 1.00, 0.20, 0.00};
    Double_t blue[NRGBs] = {0.51, 1.00, 0.12, 0.00, 0.00};
    TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
    gStyle->SetNumberContours(NCont);
    */
 
    // this is the fine gradient palette (blue to red)
    double max = h->GetMaximum();
    double min = h->GetMinimum();
    double val_white = 0.;
    double per_white = (max != min) ? ((val_white - min) / (max - min)) : 0.5;
 
    const int Number = 3;
    double Red[Number] = {0., 1., 1.};
    double Green[Number] = {0., 1., 0.};
    double Blue[Number] = {1., 1., 0.};
    double Stops[Number] = {0., per_white, 1.};
    int nb = 256;
    h->SetContour(nb);
    TColor::CreateGradientColorTable(Number, Stops, Red, Green, Blue, nb);
    // if max == min impose the range to be the same as it was a real diff
    if (max == min)
      h->GetZaxis()->SetRangeUser(-1., 1.);
  }
 
  h->SetMarkerSize(0.7);
  h->Draw("colz1");
 
  auto ltx = TLatex();
  ltx.SetTextFont(62);
  ltx.SetTextColor(1);
  ltx.SetTextSize(0.06);
  ltx.SetTextAlign(31);
  ltx.DrawLatexNDC(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, (s_title).c_str());
 
  // Draw Lines around modules
  if (lay > 0) {
    std::vector<std::vector<int>> nladder = {{10, 16, 22}, {6, 14, 22, 32}};
    int nlad = nladder[phase][lay - 1];
    for (int xsign = -1; xsign <= 1; xsign += 2)
      for (int ysign = -1; ysign <= 1; ysign += 2) {
        float xlow = xsign * (half_shift * 0.5);
        float xhigh = xsign * (half_shift * 0.5 + 4);
        float ylow = ysign * (half_shift * 0.5 + (phase == 0) * 0.5);
        float yhigh = ysign * (half_shift * 0.5 - (phase == 0) * 0.5 + nlad);
        // Outside box
        PixelROCMapHelper::draw_line(xlow, xhigh, ylow, ylow, 1);    // bottom
        PixelROCMapHelper::draw_line(xlow, xhigh, yhigh, yhigh, 1);  // top
        PixelROCMapHelper::draw_line(xlow, xlow, ylow, yhigh, 1);    // left
        PixelROCMapHelper::draw_line(xhigh, xhigh, ylow, yhigh, 1);  // right
        // Inner Horizontal lines
        for (int lad = 1; lad < nlad; ++lad) {
          float y = ysign * (lad + half_shift * 0.5);
          PixelROCMapHelper::draw_line(xlow, xhigh, y, y, 1);
        }
        for (int lad = 1; lad <= nlad; ++lad)
          if (!(phase == 0 && (lad == 1 || lad == nlad))) {
            float y = ysign * (lad + half_shift * 0.5 - 0.5);
            PixelROCMapHelper::draw_line(xlow, xhigh, y, y, 1, 3);
          }
        // Inner Vertical lines
        for (int mod = 1; mod < 4; ++mod) {
          float x = xsign * (mod + half_shift * 0.5);
          PixelROCMapHelper::draw_line(x, x, ylow, yhigh, 1);
        }
        // Make a BOX around ROC 0
        // Phase 0 - ladder +1 is always non-flipped
        // Phase 1 - ladder +1 is always     flipped
        if (mark_zero) {
          for (int mod = 1; mod <= 4; ++mod)
            for (int lad = 1; lad <= nlad; ++lad) {
              bool flipped = ysign == 1 ? lad % 2 == 0 : lad % 2 == 1;
              if (phase == 1)
                flipped = !flipped;
              int roc0_orientation = flipped ? -1 : 1;
              if (xsign == -1)
                roc0_orientation *= -1;
              if (ysign == -1)
                roc0_orientation *= -1;
              float x1 = xsign * (mod + half_shift * 0.5);
              float x2 = xsign * (mod + half_shift * 0.5 - 1. / 8);
              float y1 = ysign * (lad + half_shift * 0.5 - 0.5);
              float y2 = ysign * (lad + half_shift * 0.5 - 0.5 + roc0_orientation * 1. / 2);
              if (!(phase == 0 && (lad == 1 || lad == nlad) && xsign == -1)) {
                if (lay == 1 && xsign <= -1) {
                  float x1 = xsign * ((mod - 1) + half_shift * 0.5);
                  float x2 = xsign * ((mod - 1) + half_shift * 0.5 + 1. / 8);
                  float y1 = ysign * (lad + half_shift * 0.5 - 0.5 + roc0_orientation);
                  float y2 = ysign * (lad + half_shift * 0.5 - 0.5 + roc0_orientation * 3. / 2);
                  PixelROCMapHelper::draw_line(x1, x2, y1, y1, 1);
                  PixelROCMapHelper::draw_line(x2, x2, y1, y2, 1);
                } else {
                  PixelROCMapHelper::draw_line(x1, x2, y1, y1, 1);
                  //PixelROCMapHelper::draw_line(x1, x2, y2, y2, 1);
                  //PixelROCMapHelper::draw_line(x1, x1, y1, y2, 1);
                  PixelROCMapHelper::draw_line(x2, x2, y1, y2, 1);
                }
              }
            }
        }
      }
  } else {
    // FPIX
    for (int dsk = 1, ndsk = 2 + (phase == 1); dsk <= ndsk; ++dsk) {
      for (int xsign = -1; xsign <= 1; xsign += 2)
        for (int ysign = -1; ysign <= 1; ysign += 2) {
          if (phase == 0) {
            int first_roc = 3, nbin = 16;
            for (int bld = 1, nbld = 12; bld <= nbld; ++bld) {
              // Horizontal lines
              for (int plq = 1, nplq = 7; plq <= nplq; ++plq) {
                float xlow =
                    xsign * (half_shift * 0.5 + dsk - 1 + (first_roc - 3 + 2 * plq + (plq == 1)) / (float)nbin);
                float xhigh =
                    xsign * (half_shift * 0.5 + dsk - 1 + (first_roc - 3 + 2 * (plq + 1) - (plq == 7)) / (float)nbin);
                float ylow = ysign * (half_shift * 0.5 + (bld - 0.5) - (2 + plq / 2) * 0.1);
                float yhigh = ysign * (half_shift * 0.5 + (bld - 0.5) + (2 + plq / 2) * 0.1);
                PixelROCMapHelper::draw_line(xlow, xhigh, ylow, ylow, 1);    // bottom
                PixelROCMapHelper::draw_line(xlow, xhigh, yhigh, yhigh, 1);  // top
              }
              // Vertical lines
              for (int plq = 1, nplq = 7 + 1; plq <= nplq; ++plq) {
                float x = xsign * (half_shift * 0.5 + dsk - 1 +
                                   (first_roc - 3 + 2 * plq + (plq == 1) - (plq == 8)) / (float)nbin);
                float ylow = ysign * (half_shift * 0.5 + (bld - 0.5) - (2 + (plq - (plq == 8)) / 2) * 0.1);
                float yhigh = ysign * (half_shift * 0.5 + (bld - 0.5) + (2 + (plq - (plq == 8)) / 2) * 0.1);
                PixelROCMapHelper::draw_line(x, x, ylow, yhigh, 1);
              }
              // Panel 2 has dashed mid-plane
              for (int plq = 2, nplq = 6; plq <= nplq; ++plq)
                if (plq % 2 == 0) {
                  float x = xsign * (half_shift * 0.5 + dsk - 1 +
                                     (first_roc - 3 + 2 * plq + (plq == 1) - (plq == 8) + 1) / (float)nbin);
                  float ylow = ysign * (half_shift * 0.5 + (bld - 0.5) - (2 + (plq - (plq == 8)) / 2) * 0.1);
                  float yhigh = ysign * (half_shift * 0.5 + (bld - 0.5) + (2 + (plq - (plq == 8)) / 2) * 0.1);
                  PixelROCMapHelper::draw_line(x, x, ylow, yhigh, 1, 2);
                }
              // Make a BOX around ROC 0
              for (int plq = 1, nplq = 7; plq <= nplq; ++plq) {
                float x1 = xsign * (half_shift * 0.5 + dsk - 1 + (first_roc - 3 + 2 * plq + (plq == 1)) / (float)nbin);
                float x2 =
                    xsign * (half_shift * 0.5 + dsk - 1 + (first_roc - 3 + 2 * plq + (plq == 1) + 1) / (float)nbin);
                int sign = xsign * ysign * ((plq % 2) ? 1 : -1);
                float y1 = ysign * (half_shift * 0.5 + (bld - 0.5) + sign * (2 + plq / 2) * 0.1);
                float y2 = ysign * (half_shift * 0.5 + (bld - 0.5) + sign * (plq / 2) * 0.1);
                //PixelROCMapHelper::draw_line(x1, x2, y1, y1, 1);
                PixelROCMapHelper::draw_line(x1, x2, y2, y2, 1);
                //PixelROCMapHelper::draw_line(x1, x1, y1, y2, 1);
                PixelROCMapHelper::draw_line(x2, x2, y1, y2, 1);
              }
            }
          } else if (phase == 1) {
            if (ring == 0) {  // both
              for (int ring = 1; ring <= 2; ++ring)
                for (int bld = 1, nbld = 5 + ring * 6; bld <= nbld; ++bld) {
                  float scale = (ring == 1) ? 1.5 : 1;
                  Color_t p1_color = 1, p2_color = 1;
                  // Horizontal lines
                  // Panel 2 has dashed mid-plane
                  float x1 = xsign * (half_shift * 0.5 + dsk - 1 + (ring - 1) * 0.5);
                  float x2 = xsign * (half_shift * 0.5 + dsk - 1 + ring * 0.5);
                  int sign = ysign;
                  float y1 = ysign * (half_shift * 0.5 - 0.5 + scale * bld + sign * 0.5);
                  //float yp1_mid = ysign * (half_shift*0.5 - 0.5 + scale*bld + sign*0.25);
                  float y2 = ysign * (half_shift * 0.5 - 0.5 + scale * bld);
                  float yp2_mid = ysign * (half_shift * 0.5 - 0.5 + scale * bld - sign * 0.25);
                  float y3 = ysign * (half_shift * 0.5 - 0.5 + scale * bld - sign * 0.5);
                  PixelROCMapHelper::draw_line(x1, x2, y1, y1, 1, 1, p1_color);
                  //PixelROCMapHelper::draw_line(x1, x2, yp1_mid, yp1_mid, 1, 3);
                  PixelROCMapHelper::draw_line(x1, x2, y2, y2, 1, 1, p1_color);
                  PixelROCMapHelper::draw_line(x1, x2, yp2_mid, yp2_mid, 1, 2);
                  PixelROCMapHelper::draw_line(x1, x2, y3, y3, 1, 1, p2_color);
                  // Vertical lines
                  float x = xsign * (half_shift * 0.5 + dsk - 1 + (ring - 1) * 0.5);
                  PixelROCMapHelper::draw_line(x, x, y1, y2, 1, 1, p1_color);
                  PixelROCMapHelper::draw_line(x, x, y2, y3, 1, 1, p2_color);
                  if (ring == 2) {
                    //PixelROCMapHelper::draw_line(x,  x,  y2,  y3, 1, 1, p1_color);
                    x = xsign * (half_shift * 0.5 + dsk);
                    PixelROCMapHelper::draw_line(x, x, y1, y2, 1, 1, p1_color);
                    PixelROCMapHelper::draw_line(x, x, y2, y3, 1, 1, p2_color);
                  }
                  // Make a BOX around ROC 0
                  x1 = xsign * (half_shift * 0.5 + dsk - 1 + ring * 0.5 - 1 / 16.);
                  x2 = xsign * (half_shift * 0.5 + dsk - 1 + ring * 0.5);
                  float y1_p1 = ysign * (half_shift * 0.5 - 0.5 + scale * bld + sign * 0.25);
                  float y2_p1 = ysign * (half_shift * 0.5 - 0.5 + scale * bld + sign * 0.25 + xsign * ysign * 0.25);
                  PixelROCMapHelper::draw_line(x1, x2, y1_p1, y1_p1, 1);
                  //PixelROCMapHelper::draw_line(x1, x2, y2_p1, y2_p1, 1);
                  PixelROCMapHelper::draw_line(x1, x1, y1_p1, y2_p1, 1);
                  //PixelROCMapHelper::draw_line(x2, x2, y1_p1, y2_p1, 1);
                  float y1_p2 = ysign * (half_shift * 0.5 - 0.5 + scale * bld - sign * 0.25);
                  float y2_p2 = ysign * (half_shift * 0.5 - 0.5 + scale * bld - sign * 0.25 - xsign * ysign * 0.25);
                  PixelROCMapHelper::draw_line(x1, x2, y1_p2, y1_p2, 1);
                  //PixelROCMapHelper::draw_line(x1, x2, y2_p2, y2_p2, 1);
                  PixelROCMapHelper::draw_line(x1, x1, y1_p2, y2_p2, 1);
                  //PixelROCMapHelper::draw_line(x2, x2, y1_p2, y2_p2, 1);
                }
            } else {  // only one ring, 1 or 2
              for (int bld = 1, nbld = 5 + ring * 6; bld <= nbld; ++bld) {
                Color_t p1_color = 1, p2_color = 1;
                // Horizontal lines
                // Panel 2 has dashed mid-plane
                float x1 = xsign * (half_shift * 0.5 + dsk - 1);
                float x2 = xsign * (half_shift * 0.5 + dsk);
                int sign = ysign;
                float y1 = ysign * (half_shift * 0.5 - 0.5 + bld + sign * 0.5);
                //float yp1_mid = ysign * (half_shift*0.5 - 0.5 + bld + sign*0.25);
                float y2 = ysign * (half_shift * 0.5 - 0.5 + bld);
                float yp2_mid = ysign * (half_shift * 0.5 - 0.5 + bld - sign * 0.25);
                float y3 = ysign * (half_shift * 0.5 - 0.5 + bld - sign * 0.5);
                PixelROCMapHelper::draw_line(x1, x2, y1, y1, 1, 1, p1_color);
                //PixelROCMapHelper::draw_line(x1, x2, yp1_mid, yp1_mid, 1, 3);
                PixelROCMapHelper::draw_line(x1, x2, y2, y2, 1, 1, p1_color);
                PixelROCMapHelper::draw_line(x1, x2, yp2_mid, yp2_mid, 1, 2);
                PixelROCMapHelper::draw_line(x1, x2, y3, y3, 1, 1, p2_color);
                // Vertical lines
                float x = xsign * (half_shift * 0.5 + dsk - 1);
                PixelROCMapHelper::draw_line(x, x, y1, y2, 1, 1, p1_color);
                PixelROCMapHelper::draw_line(x, x, y2, y3, 1, 1, p2_color);
                if (ring == 2) {
                  //PixelROCMapHelper::draw_line(x,  x,  y2,  y3, 1, 1, p1_color);
                  x = xsign * (half_shift * 0.5 + dsk);
                  PixelROCMapHelper::draw_line(x, x, y1, y2, 1, 1, p1_color);
                  PixelROCMapHelper::draw_line(x, x, y2, y3, 1, 1, p2_color);
                }
                // Make a BOX around ROC 0
                x1 = xsign * (half_shift * 0.5 + dsk - 1 / 8.);
                x2 = xsign * (half_shift * 0.5 + dsk);
                float y1_p1 = ysign * (half_shift * 0.5 - 0.5 + bld + sign * 0.25);
                float y2_p1 = ysign * (half_shift * 0.5 - 0.5 + bld + sign * 0.25 + xsign * ysign * 0.25);
                PixelROCMapHelper::draw_line(x1, x2, y1_p1, y1_p1, 1);
                //PixelROCMapHelper::draw_line(x1, x2, y2_p1, y2_p1, 1);
                PixelROCMapHelper::draw_line(x1, x1, y1_p1, y2_p1, 1);
                //PixelROCMapHelper::draw_line(x2, x2, y1_p1, y2_p1, 1);
                float y1_p2 = ysign * (half_shift * 0.5 - 0.5 + bld - sign * 0.25);
                float y2_p2 = ysign * (half_shift * 0.5 - 0.5 + bld - sign * 0.25 - xsign * ysign * 0.25);
                PixelROCMapHelper::draw_line(x1, x2, y1_p2, y1_p2, 1);
                //PixelROCMapHelper::draw_line(x1, x2, y2_p2, y2_p2, 1);
                PixelROCMapHelper::draw_line(x1, x1, y1_p2, y2_p2, 1);
                //PixelROCMapHelper::draw_line(x2, x2, y1_p2, y2_p2, 1);
              }
            }
          }
        }
    }
    // Special shifted "rebin" for Phase 0
    // Y axis should always have at least half-roc granularity because
    // there are half-ROC size shifts implemented in the coordinates
    // To remove this and show full ROC granularity
    // We merge bin contents in each pair of bins corresponding to one ROC
    // TODO: make sure this works for Profiles
    if (phase == 0 && h->GetNbinsY() == 250 && h->GetNbinsX() == 80) {
      int nentries = h->GetEntries();
      for (int binx = 1; binx <= 80; ++binx) {
        double sum = 0;
        for (int biny = 1; biny <= 250; ++biny) {
          bool odd_nrocy = (binx - 1 < 40) != (((binx - 1) / 4) % 2);
          if (biny % 2 == odd_nrocy)
            sum += h->GetBinContent(binx, biny);
          else {
            sum += h->GetBinContent(binx, biny);
            if (sum) {
              h->SetBinContent(binx, biny, sum);
              h->SetBinContent(binx, biny - 1, sum);
            }
            sum = 0;
          }
        }
      }
      h->SetEntries(nentries);
    }
  }
}

References draw_line(), dqmMemoryStats::float, SiStripPI::max, min(), mod(), HcalTBWriter_cfi::Number, relativeConstraints::ring, L1EGammaCrystalsEmulatorProducer_cfi::scale, Validation_hcalonly_cfi::sign, AlCaHLTBitMon_QueryRunRegistry::string, genVertex_cff::x, testProducerWithPsetDescEmpty_cfi::x1, testProducerWithPsetDescEmpty_cfi::x2, detailsBasic3DVector::y, testProducerWithPsetDescEmpty_cfi::y1, and testProducerWithPsetDescEmpty_cfi::y2.

Referenced by Phase1PixelROCMaps::drawBarrelMaps(), Phase1PixelROCMaps::drawForwardMaps(), and Phase1PixelROCMaps::drawMaps().