reco::MustacheKernel Namespace Reference

Functions
bool	inDynamicDPhiWindow (const EcalSCDynamicDPhiParameters *params, const float seedEta, const float seedPhi, const float ClustE, const float ClusEta, const float clusPhi)
bool	inMustache (const EcalMustacheSCParameters *params, const float maxEta, const float maxPhi, const float ClustE, const float ClusEta, const float ClusPhi)

Function Documentation

inDynamicDPhiWindow()

bool reco::MustacheKernel::inDynamicDPhiWindow	(	const EcalSCDynamicDPhiParameters *	params,
		const float	seedEta,
		const float	seedPhi,
		const float	ClustE,
		const float	ClusEta,
		const float	clusPhi
	)

Definition at line 64 of file Mustache.cc.

References funct::abs(), JetChargeProducer_cfi::exp, SiStripPI::max, mkfit::Config::maxdphi, SiStripPI::min, and submitPVValidationJobs::params.

                                                  {
      const double absSeedEta = std::abs(seedEta);
      const double logClustEt = std::log10(ClustE / std::cosh(ClusEta));
      const double clusDphi = std::abs(TVector2::Phi_mpi_pi(seedPhi - ClusPhi));

      const auto dynamicDPhiParams = params->dynamicDPhiParameters(ClustE, absSeedEta);
      if (!dynamicDPhiParams) {
        return false;
      }

      auto maxdphi = dynamicDPhiParams->yoffset +
                     dynamicDPhiParams->scale /
                         (1. + std::exp((logClustEt - dynamicDPhiParams->xoffset) / dynamicDPhiParams->width));
      maxdphi = std::min(maxdphi, dynamicDPhiParams->cutoff);
      maxdphi = std::max(maxdphi, dynamicDPhiParams->saturation);

      return clusDphi < maxdphi;
    }

inMustache()

bool reco::MustacheKernel::inMustache	(	const EcalMustacheSCParameters *	params,
		const float	maxEta,
		const float	maxPhi,
		const float	ClustE,
		const float	ClusEta,
		const float	ClusPhi
	)

Definition at line 8 of file Mustache.cc.

References funct::abs(), SiStripPI::max, maxEta, HLT_2022v12_cff::maxPhi, SiStripPI::min, submitPVValidationJobs::params, funct::sin(), and mathSSE::sqrt().

Referenced by reco::Mustache::MustacheClust(), and reco::Mustache::MustacheID().

                                         {
      const auto log10ClustE = std::log10(ClustE);
      const auto parabola_params = params->parabolaParameters(log10ClustE, std::abs(ClusEta));
      if (!parabola_params) {
        return false;
      }

      const float sineta0 = std::sin(maxEta);
      const float eta0xsineta0 = maxEta * sineta0;

      //2 parabolas (upper and lower)
      //of the form: y = a*x*x + b

      //b comes from a fit to the width
      //and has a slight dependence on E on the upper edge
      // this only works because of fine tuning :-D
      const float sqrt_log10_clustE = std::sqrt(log10ClustE + params->sqrtLogClustETuning());
      const float b_upper =
          parabola_params->w1Up[0] * eta0xsineta0 + parabola_params->w1Up[1] / sqrt_log10_clustE -
          0.5 * (parabola_params->w1Up[0] * eta0xsineta0 + parabola_params->w1Up[1] / sqrt_log10_clustE +
                 parabola_params->w0Up[0] * eta0xsineta0 + parabola_params->w0Up[1] / sqrt_log10_clustE);
      const float b_lower =
          parabola_params->w0Low[0] * eta0xsineta0 + parabola_params->w0Low[1] / sqrt_log10_clustE -
          0.5 * (parabola_params->w1Low[0] * eta0xsineta0 + parabola_params->w1Low[1] / sqrt_log10_clustE +
                 parabola_params->w0Low[0] * eta0xsineta0 + parabola_params->w0Low[1] / sqrt_log10_clustE);

      //the curvature comes from a parabolic
      //fit for many slices in eta given a
      //slice -0.1 < log10(Et) < 0.1
      const float curv_up =
          eta0xsineta0 * (parabola_params->pUp[0] * eta0xsineta0 + parabola_params->pUp[1]) + parabola_params->pUp[2];
      const float curv_low = eta0xsineta0 * (parabola_params->pLow[0] * eta0xsineta0 + parabola_params->pLow[1]) +
                             parabola_params->pLow[2];

      //solving for the curviness given the width of this particular point
      const float a_upper = (1. / (4. * curv_up)) - std::abs(b_upper);
      const float a_lower = (1. / (4. * curv_low)) - std::abs(b_lower);

      const double dphi = TVector2::Phi_mpi_pi(ClusPhi - maxPhi);
      const double dphi2 = dphi * dphi;
      // minimum offset is half a crystal width in either direction
      // because science.
      constexpr float half_crystal_width = 0.0087;
      const float upper_cut =
          (std::max((1. / (4. * a_upper)), 0.0) * dphi2 + std::max(b_upper, half_crystal_width)) + half_crystal_width;
      const float lower_cut = (std::max((1. / (4. * a_lower)), 0.0) * dphi2 + std::min(b_lower, -half_crystal_width));

      const float deta = (1 - 2 * (maxEta < 0)) * (ClusEta - maxEta);  // sign flip deta
      return (deta < upper_cut && deta > lower_cut);
    }