hgcalsimclustertime::ComputeClusterTime Class Reference

#include <ComputeClusterTime.h>

Public Member Functions
	ComputeClusterTime (float Xmix, float Xmax, float Cterm, float Aterm)
	ComputeClusterTime ()
std::pair< float, float >	fixSizeHighestDensity (std::vector< float > &time, std::vector< float > weight=std::vector< float >(), unsigned int minNhits=3, float deltaT=0.210, float timeWidthBy=0.5)
float	getTimeError (std::string type, float xVal)
void	setParameters (float Xmix, float Xmax, float Cterm, float Aterm)
float	timeResolution (float xVal)

Private Attributes
float	aTerm_
float	cTerm_
float	xMax_
float	xMin_

Detailed Description

Definition at line 23 of file ComputeClusterTime.h.

Constructor & Destructor Documentation

ComputeClusterTime() [1/2]

ComputeClusterTime::ComputeClusterTime	(	float	Xmix,
		float	Xmax,
		float	Cterm,
		float	Aterm
	)

Definition at line 24 of file ComputeClusterTime.cc.

References xMin_.

    : xMin_(Xmin), xMax_(Xmax), cTerm_(Cterm), aTerm_(Aterm) {
  if (xMin_ <= 0)
    xMin_ = 0.1;
};

ComputeClusterTime() [2/2]

ComputeClusterTime::ComputeClusterTime

(

)

Definition at line 30 of file ComputeClusterTime.cc.

: xMin_(1.), xMax_(5.), cTerm_(0), aTerm_(0){};

Member Function Documentation

fixSizeHighestDensity()

std::pair< float, float > ComputeClusterTime::fixSizeHighestDensity	(	std::vector< float > &	time,
		std::vector< float >	weight = std::vector<float>(),
		unsigned int	minNhits = 3,
		float	deltaT = 0.210,
		float	timeWidthBy = 0.5
	)

Definition at line 66 of file ComputeClusterTime.cc.

References funct::abs(), HltBtagPostValidation_cff::c, decrease_sorted_indices(), HLT_2024v11_cff::distance, mps_fire::i, EgammaValidation_cff::num, mathSSE::sqrt(), command_line::start, submitPVValidationJobs::t, hcalRecHitTable_cff::time, tolerance, cms::cuda::totSize, and w().

Referenced by ticl::assignPCAtoTracksters(), RealisticSimClusterMapper::buildClusters(), and HGCalLayerClusterProducer::calculateTime().

                                                                                                             {
  if (time.size() < minNhits)
    return std::pair<float, float>(-99., -1.);

  if (weight.empty())
    weight.resize(time.size(), 1.);

  std::vector<float> t(time.size(), 0.);
  std::vector<float> w(time.size(), 0.);
  std::vector<size_t> sortedIndex = decrease_sorted_indices(time);
  for (std::size_t i = 0; i < sortedIndex.size(); ++i) {
    t[i] = time[sortedIndex[i]];
    w[i] = weight[sortedIndex[i]];
  }

  int max_elements = 0;
  int start_el = 0;
  int end_el = 0;
  float timeW = 0.f;
  float tolerance = 0.05f;

  for (auto start = t.begin(); start != t.end(); ++start) {
    const auto startRef = *start;
    int c = count_if(start, t.end(), [&](float el) { return el - startRef <= deltaT + tolerance; });
    if (c > max_elements) {
      max_elements = c;
      auto last_el = find_if_not(start, t.end(), [&](float el) { return el - startRef <= deltaT + tolerance; });
      auto valTostartDiff = *(--last_el) - startRef;
      if (std::abs(deltaT - valTostartDiff) < tolerance) {
        tolerance = std::abs(deltaT - valTostartDiff);
      }
      start_el = distance(t.begin(), start);
      end_el = distance(t.begin(), last_el);
      timeW = valTostartDiff;
    }
  }

  // further adjust time width around the chosen one based on the hits density
  // proved to improve the resolution: get as many hits as possible provided they are close in time
  float HalfTimeDiff = timeW * timeWidthBy;
  float sum = 0.;
  float num = 0;
  int totSize = t.size();

  for (int ij = 0; ij <= start_el; ++ij) {
    if (t[ij] > (t[start_el] - HalfTimeDiff)) {
      for (int kl = ij; kl < totSize; ++kl) {
        if (t[kl] < (t[end_el] + HalfTimeDiff)) {
          sum += t[kl] * w[kl];
          num += w[kl];
        } else
          break;
      }
      break;
    }
  }

  if (num == 0) {
    return std::pair<float, float>(-99., -1.);
  }
  return std::pair<float, float>(sum / num, 1. / sqrt(num));
}

getTimeError()

float ComputeClusterTime::getTimeError	(	std::string	type,
		float	xVal
	)

Definition at line 46 of file ComputeClusterTime.cc.

References cTerm_, timeResolution(), xMax_, and xMin_.

Referenced by HGCalRecHitWorkerSimple::run().

                                                                 {
  if (type == "recHit") {
    //xVal is S/N
    //time is in ns units
    //std::cout << type << ", " << xVal << ", " << xMax_ << ", " < xMin_ << ", " << timeResolution(xMin_) << ", " << timeResolution(xVal) << std::endl;

    if (xVal < xMin_)
      return timeResolution(xMin_);
    else if (xVal > xMax_)
      return cTerm_;
    else
      return timeResolution(xVal);

    return -1;
  }
  return -1;
}

setParameters()

void ComputeClusterTime::setParameters	(	float	Xmix,
		float	Xmax,
		float	Cterm,
		float	Aterm
	)

Definition at line 32 of file ComputeClusterTime.cc.

References aTerm_, cTerm_, PixelVTXMonitor_cfi::Xmax, xMax_, PixelVTXMonitor_cfi::Xmin, and xMin_.

                                                                                       {
  xMin_ = (Xmin > 0) ? Xmin : 0.1;
  xMax_ = Xmax;
  cTerm_ = Cterm;
  aTerm_ = Aterm;
  return;
}

timeResolution()

float ComputeClusterTime::timeResolution

(

float

xVal

)

Definition at line 41 of file ComputeClusterTime.cc.

References aTerm_, cTerm_, funct::pow(), mathSSE::sqrt(), and x.

Referenced by getTimeError().

                                                {
  float funcVal = pow(aTerm_ / x, 2) + pow(cTerm_, 2);
  return sqrt(funcVal);
}

Member Data Documentation

aTerm_

float hgcalsimclustertime::ComputeClusterTime::aTerm_

private

Definition at line 49 of file ComputeClusterTime.h.

Referenced by setParameters(), and timeResolution().

cTerm_

float hgcalsimclustertime::ComputeClusterTime::cTerm_

private

Definition at line 48 of file ComputeClusterTime.h.

Referenced by getTimeError(), setParameters(), and timeResolution().

xMax_

float hgcalsimclustertime::ComputeClusterTime::xMax_

private

Definition at line 47 of file ComputeClusterTime.h.

Referenced by getTimeError(), and setParameters().

xMin_

float hgcalsimclustertime::ComputeClusterTime::xMin_

private

Definition at line 46 of file ComputeClusterTime.h.

Referenced by ComputeClusterTime(), getTimeError(), and setParameters().