SiPixelUtils Namespace Reference

Functions
float	generic_position_formula (int size, int q_f, int q_l, float upper_edge_first_pix, float lower_edge_last_pix, float lorentz_shift, float theThickness, float cot_angle, float pitch, bool first_is_big, bool last_is_big, float eff_charge_cut_low, float eff_charge_cut_high, float size_cut)
float	generic_position_formula_y_bricked (int size, int q_f, int q_l, int q_f_b, int q_l_b, float upper_edge_first_pix, float lower_edge_last_pix, float lorentz_shift, float theThickness, float cot_angle, float pitch, bool first_is_big, bool last_is_big, float eff_charge_cut_low, float eff_charge_cut_high, float size_cut)

Function Documentation

generic_position_formula()

float SiPixelUtils::generic_position_formula	(	int	size,
		int	q_f,
		int	q_l,
		float	upper_edge_first_pix,
		float	lower_edge_last_pix,
		float	lorentz_shift,
		float	theThickness,
		float	cot_angle,
		float	pitch,
		bool	first_is_big,
		bool	last_is_big,
		float	eff_charge_cut_low,
		float	eff_charge_cut_high,
		float	size_cut
	)

A generic version of the position formula. Since it works for both X and Y, in the interest of the simplicity of the code, all parameters are passed by the caller.

Parameters

size	Size of this projection.
q_f	Charge in the first pixel.
q_l	Charge in the last pixel.
upper_edge_first_pix	As the name says.
lower_edge_last_pix	As the name says.
lorentz_shift	L-shift at half thickness
cot_angle	cot of alpha_ or beta_
pitch	thePitchX or thePitchY
first_is_big	true if the first is big
last_is_big	true if the last is big
eff_charge_cut_low	Use edge if > w_eff &&&
eff_charge_cut_high	Use edge if < w_eff &&&
size_cut	Use edge when size == cuts

Definition at line 16 of file SiPixelUtils.cc.

References funct::abs(), and findQualityFiles::size.

Referenced by PixelCPEGenericForBricked::localPosition(), and PixelCPEGeneric::localPosition().

    {
    float geom_center = 0.5f * (upper_edge_first_pix + lower_edge_last_pix);

    //--- The case of only one pixel in this projection is separate.  Note that
    //--- here first_pix == last_pix, so the average of the two is still the
    //--- center of the pixel.
    if (size == 1) {
      return geom_center;
    }

    //--- Width of the clusters minus the edge (first and last) pixels.
    //--- In the note, they are denoted x_F and x_L (and y_F and y_L)
    float w_inner = lower_edge_last_pix - upper_edge_first_pix;  // in cm

    //--- Predicted charge width from geometry
    float w_pred = theThickness * cot_angle  // geometric correction (in cm)
                   - lorentz_shift;          // (in cm) &&& check fpix!

    //--- Total length of the two edge pixels (first+last)
    float sum_of_edge = 2.0f;
    if (first_is_big)
      sum_of_edge += 1.0f;
    if (last_is_big)
      sum_of_edge += 1.0f;

    //--- The `effective' charge width -- particle's path in first and last pixels only
    float w_eff = std::abs(w_pred) - w_inner;

    //--- If the observed charge width is inconsistent with the expectations
    //--- based on the track, do *not* use w_pred-w_innner.  Instead, replace
    //--- it with an *average* effective charge width, which is the average
    //--- length of the edge pixels.
    //
    //  bool usedEdgeAlgo = false;
    if ((size >= size_cut) || ((w_eff / pitch < eff_charge_cut_low) | (w_eff / pitch > eff_charge_cut_high))) {
      w_eff = pitch * 0.5f * sum_of_edge;  // ave. length of edge pixels (first+last) (cm)
                                           //  usedEdgeAlgo = true;
    }

    //--- Finally, compute the position in this projection
    float q_diff = q_l - q_f;
    float q_sum = q_l + q_f;

    //--- Temporary fix for clusters with both first and last pixel with charge = 0
    if (q_sum == 0)
      q_sum = 1.0f;

    float hit_pos = geom_center + 0.5f * (q_diff / q_sum) * w_eff;

    return hit_pos;
  }

generic_position_formula_y_bricked()

float SiPixelUtils::generic_position_formula_y_bricked	(	int	size,
		int	q_f,
		int	q_l,
		int	q_f_b,
		int	q_l_b,
		float	upper_edge_first_pix,
		float	lower_edge_last_pix,
		float	lorentz_shift,
		float	theThickness,
		float	cot_angle,
		float	pitch,
		bool	first_is_big,
		bool	last_is_big,
		float	eff_charge_cut_low,
		float	eff_charge_cut_high,
		float	size_cut
	)

Parameters

size	Size of this projection.
q_f	Charge in the first pixel.
q_l	Charge in the last pixel.
q_f_b	Charge in pixels that are "dented" compared to the lowest pixel of the cluster.
q_l_b	Charge in pixels that are "dented" compared to the highest pixel of the cluster.
upper_edge_first_pix	As the name says.
lower_edge_last_pix	As the name says.
lorentz_shift	L-width
cot_angle	cot of alpha_ or beta_
pitch	thePitchX or thePitchY
first_is_big	true if the first is big
last_is_big	true if the last is big
eff_charge_cut_low	Use edge if > W_eff (in pix) &&&
eff_charge_cut_high	Use edge if < W_eff (in pix) &&&
size_cut	Use edge when size == cuts

Definition at line 82 of file SiPixelUtils.cc.

References funct::abs(), f, and findQualityFiles::size.

Referenced by PixelCPEGenericForBricked::localPosition().

    {
    const auto geom_center = 0.5f * (upper_edge_first_pix + lower_edge_last_pix);

    //--- The case of only one pixel in this projection is separate.  Note that
    //--- here first_pix == last_pix, so the average of the two is still the
    //--- center of the pixel.

    //--- Width of the clusters minus the edge (first and last) pixels.
    //--- In the note, they are denoted x_F and x_L (and y_F and y_L)
    const auto w_inner = lower_edge_last_pix - upper_edge_first_pix;  // in cm

    //--- Predicted charge width from geometry
    const auto w_pred = theThickness * cot_angle  // geometric correction (in cm)
                        - lorentz_shift;          // (in cm) &&& check fpix!

    //--- Total length of the two edge pixels (first+last)
    auto sum_of_edge = 2.0f;
    if (first_is_big)
      sum_of_edge += 1.0f;
    if (last_is_big)
      sum_of_edge += 1.0f;

    //--- The `effective' charge width -- particle's path in first and last pixels only
    auto w_eff = std::abs(w_pred) - std::abs(w_inner);

    //--- If the observed charge width is inconsistent with the expectations
    //--- based on the track, do *not* use w_pred-w_innner.  Instead, replace
    //--- it with an *average* effective charge width, which is the average
    //--- length of the edge pixels.
    //
    //  bool usedEdgeAlgo = false;
    //Modified cut to make use of the w_eff in the bricked geometry
    if (size >= size_cut) {
      w_eff = pitch * 0.5f * sum_of_edge;  // ave. length of edge pixels (first+last) (cm)
                                           //  usedEdgeAlgo = true;
    }

    //--- Finally, compute the position in this projection
    const auto q_diff = q_l - q_f;
    auto q_sum = q_l + q_f;
    const auto q_b_corr = q_l_b + q_f_b;

    //--- Temporary fix for clusters with both first and last pixel with charge = 0
    if (q_sum == 0)
      q_sum = 1.0f;

    float hit_pos =
        geom_center + 0.5f * (q_diff / q_sum) * w_eff + 0.5f * (q_b_corr / q_sum) * w_eff;  //bricked correction

    return hit_pos;
  }