TCMETAlgo Class Reference

#include <TCMETAlgo.h>

Public Types
typedef std::vector< const reco::Candidate >	InputCollection

Public Member Functions
reco::MET	CalculateTCMET (edm::Event &event, const edm::EventSetup &setup)
void	configure (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iConsumesCollector)
TH2D *	getResponseFunction_fit ()
TH2D *	getResponseFunction_mode ()
TH2D *	getResponseFunction_noshower ()
TH2D *	getResponseFunction_shower ()
	TCMETAlgo ()
virtual	~TCMETAlgo ()

Private Member Functions
bool	closeToElectron (const reco::TrackRef)
void	correct_MET_for_Muons ()
void	correct_MET_for_Tracks ()
void	correctMETforMuon (const reco::TrackRef, reco::MuonRef &muonRef)
void	correctMETforMuon (reco::MuonRef &muonRef)
void	correctMETforTrack (const reco::TrackRef, TH2D *rf, const TVector3 &)
void	correctSumEtForTrack (const reco::TrackRef, TH2D *rf, const TVector3 &)
void	findDuplicateTracks ()
void	findGoodShowerTracks (std::vector< int > &goodShowerTracks)
void	initialize_MET_with_CaloMET (edm::Event &event)
void	initialize_MET_with_PFClusters (edm::Event &event)
bool	isElectron (const reco::TrackRef &trackRef)
bool	isGoodTrack (const reco::TrackRef trackRef)
bool	isMuon (const reco::TrackRef &trackRef)
bool	isValidVertex ()
bool	nearGoodShowerTrack (const reco::TrackRef, const std::vector< int > &goodShowerTracks)
int	nExpectedInnerHits (const reco::TrackRef)
int	nExpectedOuterHits (const reco::TrackRef)
int	nLayers (const reco::TrackRef)
class TVector3	propagateTrackToCalorimeterFace (const reco::TrackRef trackRef)
int	vetoTrack (int i1, int i2)

Private Attributes
edm::Handle< reco::BeamSpot >	beamSpotHandle_
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_
bool	checkTrackPropagation_
edm::EDGetTokenT< reco::PFClusterCollection >	clustersECALToken_
edm::EDGetTokenT< reco::PFClusterCollection >	clustersHCALToken_
edm::EDGetTokenT< reco::PFClusterCollection >	clustersHFToken_
double	corner_
bool	correctShowerTracks_
double	d0cuta_
double	d0cutb_
double	deltaRShower_
double	dupDCotTh_
double	dupDPhi_
std::vector< int >	duplicateTracks_
double	dupMinPt_
edm::Handle< reco::GsfElectronCollection >	electronHandle_
edm::EDGetTokenT< reco::GsfElectronCollection >	electronToken_
bool	electronVetoCone_
double	eVetoDeltaCotTheta_
double	eVetoDeltaPhi_
double	eVetoDeltaR_
double	eVetoMinElectronPt_
bool	hasValidVertex_
double	hOverECut_
bool	isCosmics_
edm::ESHandle< MagneticField >	magneticFieldHandle_
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldToken_
double	maxchi2_
double	maxchi2_tight_
double	maxd0cut_
double	maxeta_
double	maxpt_
double	maxpt_eta20_
double	maxpt_eta25_
double	maxPtErr_
double	maxPtErr_tight_
double	met_x_
double	met_y_
edm::EDGetTokenT< edm::View< reco::MET > >	metToken_
double	minhits_
double	minhits_tight_
double	minpt_
edm::Handle< edm::ValueMap< reco::MuonMETCorrectionData > >	muonDepValueMapHandle_
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > >	muonDepValueMapToken_
edm::Handle< reco::MuonCollection >	muonHandle_
edm::EDGetTokenT< reco::MuonCollection >	muonToken_
int	nLayers_
int	nLayersTight_
int	nMinOuterHits_
double	radius_
class TH2D *	response_function_
class TH2D *	showerRF_
double	sumEt_
edm::Handle< edm::ValueMap< reco::MuonMETCorrectionData > >	tcmetDepValueMapHandle_
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > >	tcmetDepValueMapToken_
std::vector< reco::TrackBase::TrackAlgorithm >	trackAlgos_
edm::Handle< reco::TrackCollection >	trackHandle_
edm::EDGetTokenT< reco::TrackCollection >	trackToken_
std::vector< reco::TrackBase::TrackAlgorithm >	trkAlgos_
std::vector< int >	trkQuality_
double	usedeltaRRejection_
bool	usePFClusters_
bool	usePvtxd0_
const reco::VertexCollection *	vertexColl_
edm::Handle< reco::VertexCollection >	vertexHandle_
double	vertexMaxDZ_
int	vertexNdof_
double	vertexRho_
edm::EDGetTokenT< reco::VertexCollection >	vertexToken_
double	vertexZ_
bool	vetoDuplicates_
double	zdist_

Detailed Description

Calculates TCMET based on detector response to charged paricles using the tracker to correct for the non-linearity of the calorimeter and the displacement of charged particles by the B-field. Given a track pt, eta the expected energy deposited in the calorimeter is obtained from a lookup table, removed from the calorimeter, and replaced with the track at the vertex.

Definition at line 68 of file TCMETAlgo.h.

Member Typedef Documentation

InputCollection

typedef std::vector<const reco::Candidate> TCMETAlgo::InputCollection

Definition at line 70 of file TCMETAlgo.h.

Constructor & Destructor Documentation

TCMETAlgo()

TCMETAlgo::TCMETAlgo

(

)

Definition at line 59 of file TCMETAlgo.cc.

: response_function_(nullptr), showerRF_(nullptr) {}

~TCMETAlgo()

TCMETAlgo::~TCMETAlgo ( )

virtual

Definition at line 164 of file TCMETAlgo.cc.

References response_function_, and showerRF_.

                      {
  delete response_function_;
  delete showerRF_;
}

Member Function Documentation

CalculateTCMET()

reco::MET TCMETAlgo::CalculateTCMET	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

Definition at line 170 of file TCMETAlgo.cc.

References beamSpotHandle_, beamSpotToken_, correct_MET_for_Muons(), correct_MET_for_Tracks(), electronHandle_, electronToken_, initialize_MET_with_CaloMET(), initialize_MET_with_PFClusters(), magneticFieldHandle_, magneticFieldToken_, BTaggingMonitor_cfi::met, met_x_, met_y_, muonDepValueMapHandle_, muonDepValueMapToken_, muonHandle_, muonToken_, singleTopDQM_cfi::setup, sumEt_, tcmetDepValueMapHandle_, tcmetDepValueMapToken_, trackHandle_, trackToken_, usePFClusters_, vertexHandle_, vertexToken_, and L1BJetProducer_cff::vtx.

Referenced by cms::TCMETProducer::produce().

                                                                             {
  if (usePFClusters_)
    initialize_MET_with_PFClusters(event);
  else
    initialize_MET_with_CaloMET(event);

  event.getByToken(muonToken_, muonHandle_);
  event.getByToken(trackToken_, trackHandle_);
  event.getByToken(electronToken_, electronHandle_);
  event.getByToken(vertexToken_, vertexHandle_);
  event.getByToken(beamSpotToken_, beamSpotHandle_);
  event.getByToken(muonDepValueMapToken_, muonDepValueMapHandle_);
  event.getByToken(tcmetDepValueMapToken_, tcmetDepValueMapHandle_);
  magneticFieldHandle_ = setup.getHandle(magneticFieldToken_);

  correct_MET_for_Muons();
  correct_MET_for_Tracks();

  math::XYZTLorentzVector p4(met_x_, met_y_, 0, TMath::Sqrt(met_x_ * met_x_ + met_y_ * met_y_));
  math::XYZPointD vtx(0, 0, 0);
  reco::MET met(sumEt_, p4, vtx);

  return met;
}

closeToElectron()

bool TCMETAlgo::closeToElectron ( const reco::TrackRef  track )

private

Definition at line 456 of file TCMETAlgo.cc.

References spr::deltaEta, srCondWrite_cfg::deltaPhi, eleIsoSequence_cff::deltaR, electronHandle_, eVetoDeltaCotTheta_, eVetoDeltaPhi_, eVetoDeltaR_, eVetoMinElectronPt_, hOverECut_, edm::Ref< C, T, F >::isNonnull(), Pi, mathSSE::sqrt(), funct::tan(), HLT_2024v14_cff::track, run3scouting_cff::trk_eta, run3scouting_cff::trk_phi, and TwoPi.

Referenced by correct_MET_for_Tracks().

                                                        {
  float trk_eta = track->eta();
  float trk_phi = track->phi();
  LorentzVector tk_p4(track->px(), track->py(), track->pz(), track->p());

  for (reco::GsfElectronCollection::const_iterator electron_it = electronHandle_->begin();
       electron_it != electronHandle_->end();
       ++electron_it) {
    if (electron_it->hadronicOverEm() > hOverECut_)
      continue;

    reco::TrackRef el_track = electron_it->closestCtfTrackRef();

    if (!el_track.isNonnull())
      continue;

    if (el_track->pt() < eVetoMinElectronPt_)
      continue;

    LorentzVector el_p4(el_track->px(), el_track->py(), el_track->pz(), el_track->p());

    float deltaPhi = fabs(el_track->phi() - trk_phi);
    if (deltaPhi > TMath::Pi())
      deltaPhi = TMath::TwoPi() - deltaPhi;
    float deltaEta = el_track->eta() - trk_eta;
    float deltaR = sqrt(deltaPhi * deltaPhi + deltaEta * deltaEta);
    float deltaCotTh = 1. / tan(el_p4.theta()) - 1. / tan(tk_p4.theta());

    if (deltaPhi < eVetoDeltaPhi_ && deltaCotTh < eVetoDeltaCotTheta_ && deltaR < eVetoDeltaR_)
      return true;
  }

  return false;
}

configure()

void TCMETAlgo::configure	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	iConsumesCollector
	)

Definition at line 62 of file TCMETAlgo.cc.

References a, reco::TrackBase::algoByName(), Puppi_cff::algos, beamSpotToken_, checkTrackPropagation_, clustersECALToken_, clustersHCALToken_, clustersHFToken_, corner_, correctShowerTracks_, d0cuta_, d0cutb_, deltaRShower_, dupDCotTh_, dupDPhi_, dupMinPt_, electronToken_, electronVetoCone_, eVetoDeltaCotTheta_, eVetoDeltaPhi_, eVetoDeltaR_, eVetoMinElectronPt_, edm::ParameterSet::getParameter(), getResponseFunction_fit(), getResponseFunction_mode(), getResponseFunction_noshower(), getResponseFunction_shower(), hOverECut_, isCosmics_, magneticFieldToken_, maxchi2_, maxchi2_tight_, maxd0cut_, maxeta_, maxpt_, maxpt_eta20_, maxpt_eta25_, maxPtErr_, maxPtErr_tight_, metToken_, minhits_, minhits_tight_, minpt_, muonDepValueMapToken_, muonToken_, mergeVDriftHistosByStation::name, nLayers_, nLayersTight_, nMinOuterHits_, radius_, response_function_, showerRF_, AlCaHLTBitMon_QueryRunRegistry::string, tcmetDepValueMapToken_, trackAlgos_, trackToken_, HcalDetIdTransform::transform(), trkAlgos_, trkQuality_, usedeltaRRejection_, usePFClusters_, usePvtxd0_, vertexMaxDZ_, vertexNdof_, vertexRho_, vertexToken_, vertexZ_, vetoDuplicates_, and zdist_.

Referenced by cms::TCMETProducer::TCMETProducer().

                                                                                                   {
  muonToken_ = iConsumesCollector.consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("muonInputTag"));
  electronToken_ =
      iConsumesCollector.consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("electronInputTag"));
  metToken_ = iConsumesCollector.consumes<edm::View<reco::MET>>(iConfig.getParameter<edm::InputTag>("metInputTag"));
  trackToken_ =
      iConsumesCollector.consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("trackInputTag"));
  beamSpotToken_ = iConsumesCollector.consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpotInputTag"));
  vertexToken_ =
      iConsumesCollector.consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexInputTag"));

  usePFClusters_ = iConfig.getParameter<bool>("usePFClusters");

  if (usePFClusters_) {
    clustersECALToken_ =
        iConsumesCollector.consumes<reco::PFClusterCollection>(iConfig.getParameter<edm::InputTag>("PFClustersECAL"));
    clustersHCALToken_ =
        iConsumesCollector.consumes<reco::PFClusterCollection>(iConfig.getParameter<edm::InputTag>("PFClustersHCAL"));
    clustersHFToken_ =
        iConsumesCollector.consumes<reco::PFClusterCollection>(iConfig.getParameter<edm::InputTag>("PFClustersHF"));
  }

  muonDepValueMapToken_ = iConsumesCollector.consumes<edm::ValueMap<reco::MuonMETCorrectionData>>(
      iConfig.getParameter<edm::InputTag>("muonDepValueMap"));
  tcmetDepValueMapToken_ = iConsumesCollector.consumes<edm::ValueMap<reco::MuonMETCorrectionData>>(
      iConfig.getParameter<edm::InputTag>("tcmetDepValueMap"));

  magneticFieldToken_ = iConsumesCollector.esConsumes();

  nLayers_ = iConfig.getParameter<int>("nLayers");
  nLayersTight_ = iConfig.getParameter<int>("nLayersTight");
  vertexNdof_ = iConfig.getParameter<int>("vertexNdof");
  vertexZ_ = iConfig.getParameter<double>("vertexZ");
  vertexRho_ = iConfig.getParameter<double>("vertexRho");
  vertexMaxDZ_ = iConfig.getParameter<double>("vertexMaxDZ");
  maxpt_eta20_ = iConfig.getParameter<double>("maxpt_eta20");
  maxpt_eta25_ = iConfig.getParameter<double>("maxpt_eta25");
  vetoDuplicates_ = iConfig.getParameter<bool>("vetoDuplicates");
  dupMinPt_ = iConfig.getParameter<double>("dupMinPt");
  dupDPhi_ = iConfig.getParameter<double>("dupDPhi");
  dupDCotTh_ = iConfig.getParameter<double>("dupDCotTh");

  electronVetoCone_ = iConfig.getParameter<bool>("electronVetoCone");
  eVetoDeltaR_ = iConfig.getParameter<double>("eVetoDeltaR");
  eVetoDeltaPhi_ = iConfig.getParameter<double>("eVetoDeltaPhi");
  eVetoDeltaCotTheta_ = iConfig.getParameter<double>("eVetoDeltaCotTheta");
  eVetoMinElectronPt_ = iConfig.getParameter<double>("eVetoMinElectronPt");
  correctShowerTracks_ = iConfig.getParameter<bool>("correctShowerTracks");
  checkTrackPropagation_ = iConfig.getParameter<bool>("checkTrackPropagation");
  usePvtxd0_ = iConfig.getParameter<bool>("usePvtxd0");
  nMinOuterHits_ = iConfig.getParameter<int>("nMinOuterHits");
  usedeltaRRejection_ = iConfig.getParameter<bool>("usedeltaRRejection");
  deltaRShower_ = iConfig.getParameter<double>("deltaRShower");
  radius_ = iConfig.getParameter<double>("radius");
  zdist_ = iConfig.getParameter<double>("zdist");
  corner_ = iConfig.getParameter<double>("corner");
  d0cuta_ = iConfig.getParameter<double>("d0cuta");
  d0cutb_ = iConfig.getParameter<double>("d0cutb");
  maxd0cut_ = iConfig.getParameter<double>("maxd0cut");
  maxchi2_tight_ = iConfig.getParameter<double>("chi2_tight_max");
  minhits_tight_ = iConfig.getParameter<double>("nhits_tight_min");
  maxPtErr_tight_ = iConfig.getParameter<double>("ptErr_tight_max");
  std::vector<std::string> trackAlgoNames = iConfig.getParameter<std::vector<std::string>>("trackAlgos");
  std::transform(
      trackAlgoNames.begin(), trackAlgoNames.end(), std::back_inserter(trackAlgos_), [](const std::string& name) {
        return reco::TrackBase::algoByName(name);
      });

  isCosmics_ = iConfig.getParameter<bool>("isCosmics");
  minpt_ = iConfig.getParameter<double>("pt_min");
  maxpt_ = iConfig.getParameter<double>("pt_max");
  maxeta_ = iConfig.getParameter<double>("eta_max");
  maxchi2_ = iConfig.getParameter<double>("chi2_max");
  minhits_ = iConfig.getParameter<double>("nhits_min");
  maxPtErr_ = iConfig.getParameter<double>("ptErr_max");
  hOverECut_ = iConfig.getParameter<double>("hOverECut");

  trkQuality_ = iConfig.getParameter<std::vector<int>>("track_quality");
  std::vector<std::string> algos = iConfig.getParameter<std::vector<std::string>>("track_algos");
  std::transform(algos.begin(), algos.end(), std::back_inserter(trkAlgos_), [](const std::string& a) {
    return reco::TrackBase::algoByName(a);
  });

  showerRF_ = getResponseFunction_shower();
  response_function_ = nullptr;

  int rfType = iConfig.getParameter<int>("rf_type");

  if (correctShowerTracks_) {
    response_function_ = getResponseFunction_noshower();
  } else {
    if (rfType == 1) {
      response_function_ = getResponseFunction_fit();
    } else if (rfType == 2) {
      response_function_ = getResponseFunction_mode();
    } else {
      /* probably error */
    }
  }
}

correct_MET_for_Muons()

void TCMETAlgo::correct_MET_for_Muons ( )

private

Definition at line 249 of file TCMETAlgo.cc.

References correctMETforMuon(), correctMETforTrack(), correctSumEtForTrack(), mps_fire::i, muonHandle_, propagateTrackToCalorimeterFace(), response_function_, HLT_2024v14_cff::track, and reco::MuonMETCorrectionData::type().

Referenced by CalculateTCMET().

                                      {
  for (unsigned int i = 0; i < muonHandle_->size(); ++i) {
    reco::MuonRef muonRef(muonHandle_, i);

    reco::MuonMETCorrectionData muCorrData = (*tcmetDepValueMapHandle_)[muonRef];

    reco::MuonMETCorrectionData::Type muCorrType = muCorrData.type();
    if (muCorrType == reco::MuonMETCorrectionData::Type::CombinedTrackUsed ||
        muCorrType == reco::MuonMETCorrectionData::Type::GlobalTrackUsed) {
      if (!muonRef->isGlobalMuon()) {
        edm::LogError("TCMETAlgo") << "This is not a global muon, but is flagged as one by the TCMET ValueMap.  "
                                   << "Not correcting for this muon.  Check your collection!!!" << std::endl;
        continue;
      }

      reco::TrackRef track = muonRef->globalTrack();
      correctMETforMuon(track, muonRef);
    } else if (muCorrType == reco::MuonMETCorrectionData::Type::InnerTrackUsed ||
               muCorrType == reco::MuonMETCorrectionData::Type::TrackUsed) {
      if (!muonRef->isTrackerMuon()) {
        edm::LogError("TCMETAlgo") << "This is not a tracker muon, but is flagged as one by the TCMET ValueMap.  "
                                   << "Not correcting for this muon.  Check your collection!!!" << std::endl;
        continue;
      }

      reco::TrackRef track = muonRef->innerTrack();
      correctMETforMuon(track, muonRef);
    } else if (muCorrType == reco::MuonMETCorrectionData::Type::OuterTrackUsed ||
               muCorrType == reco::MuonMETCorrectionData::Type::StandAloneTrackUsed) {
      edm::LogVerbatim("TCMETAlgo") << "Are you sure you want to correct using the StandAlone fit??" << std::endl;
      if (!muonRef->isStandAloneMuon()) {
        edm::LogError("TCMETAlgo") << "This is not a standalone muon, but is flagged as one by the TCMET ValueMap.  "
                                   << "Not correcting for this muon.  Check your collection!!!" << std::endl;
        continue;
      }

      reco::TrackRef track = muonRef->outerTrack();
      correctMETforMuon(track, muonRef);
    } else if (muCorrType == reco::MuonMETCorrectionData::Type::TreatedAsPion) {
      reco::TrackRef track;
      if (muonRef->isGlobalMuon())
        track = muonRef->innerTrack();
      else if (muonRef->isTrackerMuon())
        track = muonRef->innerTrack();
      else if (muonRef->isCaloMuon())
        track = muonRef->innerTrack();
      else {
        edm::LogError("TCMETAlgo")
            << "You are attempting to correct a muon that does not have an associated track as a pion!"
            << "Check your value map!" << std::endl;
        continue;
      }

      const TVector3 outerTrackPosition = propagateTrackToCalorimeterFace(track);
      correctMETforTrack(track, response_function_, outerTrackPosition);
      correctSumEtForTrack(track, response_function_, outerTrackPosition);
    } else if (muCorrType == reco::MuonMETCorrectionData::Type::MuonP4V4QUsed ||
               muCorrType == reco::MuonMETCorrectionData::Type::MuonCandidateValuesUsed) {
      if (!muonRef->isGlobalMuon() && !muonRef->isTrackerMuon() && muonRef->isStandAloneMuon())
        edm::LogVerbatim("TCMETAlgo") << "Are you sure you want to correct using the StandAlone fit??" << std::endl;

      correctMETforMuon(muonRef);
    } else if (muCorrType == reco::MuonMETCorrectionData::Type::NotUsed)
      continue;
    else
      edm::LogError("TCMETAlgo") << "Invalid muon flag from TCMET ValueMap.  Check your value map." << std::endl;
  }
}

correct_MET_for_Tracks()

void TCMETAlgo::correct_MET_for_Tracks ( )

private

Definition at line 319 of file TCMETAlgo.cc.

References closeToElectron(), correctMETforTrack(), correctShowerTracks_, correctSumEtForTrack(), duplicateTracks_, electronVetoCone_, findDuplicateTracks(), findGoodShowerTracks(), hasValidVertex_, mps_fire::i, isCosmics_, isElectron(), isGoodTrack(), isMuon(), edm::HandleBase::isValid(), isValidVertex(), nearGoodShowerTrack(), nExpectedOuterHits(), nMinOuterHits_, beamSpotPI::nTracks, edm::Handle< T >::product(), propagateTrackToCalorimeterFace(), response_function_, showerRF_, trackHandle_, usedeltaRRejection_, usePvtxd0_, vertexColl_, vertexHandle_, and vetoDuplicates_.

Referenced by CalculateTCMET().

                                       {
  hasValidVertex_ = false;
  if (usePvtxd0_ && vertexHandle_.isValid()) {
    vertexColl_ = vertexHandle_.product();
    hasValidVertex_ = isValidVertex();
  }

  if (vetoDuplicates_) {
    duplicateTracks_.clear();
    findDuplicateTracks();
  }

  //find tracks which satisfy track quality cuts and nExpectedOuterHits cut
  std::vector<int> goodShowerTracks;
  if (usedeltaRRejection_) {
    findGoodShowerTracks(goodShowerTracks);
  }

  unsigned int nTracks = trackHandle_->size();

  for (unsigned int i = 0; i < nTracks; ++i) {
    reco::TrackRef trackRef(trackHandle_, i);

    if (isMuon(trackRef))
      continue;

    if ((!isCosmics_) && isElectron(trackRef))
      continue;

    if (!isGoodTrack(trackRef))
      continue;

    if (electronVetoCone_ && closeToElectron(trackRef))
      continue;

    const TVector3 outerTrackPosition = propagateTrackToCalorimeterFace(trackRef);

    if (correctShowerTracks_) {
      if (usedeltaRRejection_ && nearGoodShowerTrack(trackRef, goodShowerTracks))
        continue;

      if (nExpectedOuterHits(trackRef) >= nMinOuterHits_) {
        correctMETforTrack(trackRef, showerRF_, outerTrackPosition);
        correctSumEtForTrack(trackRef, showerRF_, outerTrackPosition);
      } else {
        correctMETforTrack(trackRef, response_function_, outerTrackPosition);
        correctSumEtForTrack(trackRef, response_function_, outerTrackPosition);
      }
    } else {
      correctMETforTrack(trackRef, response_function_, outerTrackPosition);
      correctSumEtForTrack(trackRef, response_function_, outerTrackPosition);
    }
  }
}

correctMETforMuon() [1/2]

void TCMETAlgo::correctMETforMuon ( const reco::TrackRef  track, reco::MuonRef &  muonRef  )

private

Definition at line 678 of file TCMETAlgo.cc.

References reco::MuonMETCorrectionData::corrX(), reco::MuonMETCorrectionData::corrY(), met_x_, met_y_, sumEt_, and HLT_2024v14_cff::track.

Referenced by correct_MET_for_Muons().

                                                                                {
  reco::MuonMETCorrectionData muCorrData = (*muonDepValueMapHandle_)[muonRef];

  double delx = muCorrData.corrX();
  double dely = muCorrData.corrY();

  met_x_ -= (track->px() - delx);
  met_y_ -= (track->py() - dely);
  sumEt_ += (track->pt() - TMath::Sqrt(delx * delx + dely * dely));
}

correctMETforMuon() [2/2]

void TCMETAlgo::correctMETforMuon ( reco::MuonRef &  muonRef )

private

Definition at line 690 of file TCMETAlgo.cc.

References reco::MuonMETCorrectionData::corrX(), reco::MuonMETCorrectionData::corrY(), met_x_, met_y_, and sumEt_.

                                                      {
  reco::MuonMETCorrectionData muCorrData = (*muonDepValueMapHandle_)[muonRef];

  double delx = muCorrData.corrX();
  double dely = muCorrData.corrY();

  met_x_ -= (muonRef->px() - delx);
  met_y_ -= (muonRef->py() - dely);
  sumEt_ += (muonRef->pt() - TMath::Sqrt(delx * delx + dely * dely));
}

correctMETforTrack()

void TCMETAlgo::correctMETforTrack ( const reco::TrackRef  track, TH2D *  rf, const TVector3 &  outerTrackPosition  )

private

Definition at line 702 of file TCMETAlgo.cc.

References checkTrackPropagation_, funct::cos(), met_x_, met_y_, minpt_, hcal_runs::rf, funct::sin(), and HLT_2024v14_cff::track.

Referenced by correct_MET_for_Muons(), and correct_MET_for_Tracks().

                                                                                                         {
  if (track->pt() < minpt_) {
    met_x_ -= track->pt() * cos(track->phi());
    met_y_ -= track->pt() * sin(track->phi());
  } else {
    if (checkTrackPropagation_ && outerTrackPosition.Theta() < -9.99) {
      //fail track propagation check
    } else {
      int bin_index = rf->FindBin(track->eta(), track->pt());
      double fracTrackEnergy = rf->GetBinContent(bin_index);  //get correction factor from response function

      met_x_ += (fracTrackEnergy * track->p() * sin(outerTrackPosition.Theta()) *
                     cos(outerTrackPosition.Phi())    //remove expected amount of energy track deposited in calorimeter
                 - track->pt() * cos(track->phi()));  //add track at vertex

      met_y_ += (fracTrackEnergy * track->p() * sin(outerTrackPosition.Theta()) *
                     sin(outerTrackPosition.Phi())    //remove expected amount of energy track deposited in calorimeter
                 - track->pt() * sin(track->phi()));  //add track at vertex
    }
  }
}

correctSumEtForTrack()

void TCMETAlgo::correctSumEtForTrack ( const reco::TrackRef  track, TH2D *  rf, const TVector3 &  outerTrackPosition  )

private

Definition at line 725 of file TCMETAlgo.cc.

References checkTrackPropagation_, minpt_, hcal_runs::rf, sumEt_, and HLT_2024v14_cff::track.

Referenced by correct_MET_for_Muons(), and correct_MET_for_Tracks().

                                                                                                           {
  if (track->pt() < minpt_) {
    sumEt_ += track->pt();
  } else {
    if (checkTrackPropagation_ && outerTrackPosition.Theta() < -9.99) {
      //fail track propagation check
    } else {
      int bin_index = rf->FindBin(track->eta(), track->pt());
      double fracTrackEnergy = rf->GetBinContent(bin_index);  //get correction factor from response function
      sumEt_ += (1 - fracTrackEnergy) * track->pt();
    }
  }
}

findDuplicateTracks()

void TCMETAlgo::findDuplicateTracks ( )

private

Definition at line 375 of file TCMETAlgo.cc.

References dupDCotTh_, dupDPhi_, duplicateTracks_, dupMinPt_, isCosmics_, isElectron(), isMuon(), beamSpotPI::nTracks, Pi, funct::tan(), trackHandle_, TwoPi, and vetoTrack().

Referenced by correct_MET_for_Tracks().

                                    {
  unsigned int nTracks = trackHandle_->size();

  for (unsigned int trk_idx = 0; trk_idx < nTracks; trk_idx++) {
    reco::TrackRef trkref(trackHandle_, trk_idx);

    if (isMuon(trkref))
      continue;
    if (!isCosmics_ && isElectron(trkref))
      continue;

    if (trkref->pt() < dupMinPt_)
      continue;

    for (unsigned int trk_idx2 = trk_idx + 1; trk_idx2 < nTracks; trk_idx2++) {
      reco::TrackRef trkref2(trackHandle_, trk_idx2);

      if (isMuon(trkref2))
        continue;
      if (!isCosmics_ && isElectron(trkref2))
        continue;

      if (trkref->charge() * trkref2->charge() < 0)
        continue;
      if (trkref2->pt() < dupMinPt_)
        continue;

      float dphi = fabs(trkref->phi() - trkref2->phi());
      if (dphi > TMath::Pi())
        dphi = TMath::TwoPi() - dphi;

      float dcotth = fabs(1. / tan(trkref->theta()) - 1. / tan(trkref2->theta()));

      if (dphi > dupDPhi_)
        continue;
      if (dcotth > dupDCotTh_)
        continue;

      int iVeto = vetoTrack(trk_idx, trk_idx2);
      duplicateTracks_.push_back(iVeto);
    }
  }
}

findGoodShowerTracks()

void TCMETAlgo::findGoodShowerTracks ( std::vector< int > &  goodShowerTracks )

private

Definition at line 511 of file TCMETAlgo.cc.

References isCosmics_, isElectron(), isGoodTrack(), isMuon(), nExpectedOuterHits(), nMinOuterHits_, and trackHandle_.

Referenced by correct_MET_for_Tracks().

                                                                     {
  //stores the indices of tracks which pass quality selection and
  //nMinOuterHits cut in goodShowerTracks vector
  for (unsigned int trk_idx = 0; trk_idx < trackHandle_->size(); trk_idx++) {
    reco::TrackRef trkref(trackHandle_, trk_idx);

    if (isMuon(trkref))
      continue;

    if (!isCosmics_)
      if (isElectron(trkref))
        continue;

    if (!isGoodTrack(trkref))
      continue;

    if (nExpectedOuterHits(trkref) < nMinOuterHits_)
      continue;

    goodShowerTracks.push_back(trk_idx);
  }
}

getResponseFunction_fit()

TH2D * TCMETAlgo::getResponseFunction_fit

(

)

Definition at line 3523 of file TCMETAlgo.cc.

References MillePedeFileConverter_cfg::e.

Referenced by configure(), and cms::MuonTCMETValueMapProducer::MuonTCMETValueMapProducer().

                                         {
  // single pion response function from fit

  Double_t xAxis1[53] = {-2.5,   -2.322, -2.172, -2.043, -1.93,  -1.83,  -1.74,  -1.653, -1.566, -1.479, -1.392,
                         -1.305, -1.218, -1.131, -1.044, -0.957, -0.879, -0.783, -0.696, -0.609, -0.522, -0.435,
                         -0.348, -0.261, -0.174, -0.087, 0,      0.087,  0.174,  0.261,  0.348,  0.435,  0.522,
                         0.609,  0.696,  0.783,  0.879,  0.957,  1.044,  1.131,  1.218,  1.305,  1.392,  1.479,
                         1.566,  1.653,  1.74,   1.83,   1.93,   2.043,  2.172,  2.322,  2.5};

  Double_t yAxis1[29] = {0,  0.5, 1,  1.5, 2,  3,  4,  5,  6,  7,  8,  9,  10, 12, 14,
                         16, 18,  20, 25,  30, 35, 40, 45, 50, 60, 70, 80, 90, 100};

  TH2D* hrf = new TH2D("hrf", "RF  (fit)", 52, xAxis1, 28, yAxis1);

  hrf->SetBinContent(55, 0.9014105);
  hrf->SetBinContent(56, 1.234047);
  hrf->SetBinContent(57, 1.404987);
  hrf->SetBinContent(58, 1.576149);
  hrf->SetBinContent(59, 1.677449);
  hrf->SetBinContent(60, 1.419812);
  hrf->SetBinContent(61, 1.318056);
  hrf->SetBinContent(62, 1.287693);
  hrf->SetBinContent(63, 1.158259);
  hrf->SetBinContent(64, 8.160139e-14);
  hrf->SetBinContent(65, 0.9419115);
  hrf->SetBinContent(66, 2.235989e-13);
  hrf->SetBinContent(67, 0.4986045);
  hrf->SetBinContent(68, 2.420397e-12);
  hrf->SetBinContent(69, 6.139533e-14);
  hrf->SetBinContent(70, 6.894485e-13);
  hrf->SetBinContent(71, 3.603784e-13);
  hrf->SetBinContent(72, 3.894685e-11);
  hrf->SetBinContent(73, 2.43805e-13);
  hrf->SetBinContent(74, 0.78136);
  hrf->SetBinContent(75, 0.9358564);
  hrf->SetBinContent(76, 5.687018e-11);
  hrf->SetBinContent(77, 8.881784e-16);
  hrf->SetBinContent(78, 1.287748e-12);
  hrf->SetBinContent(79, 1.624256e-13);
  hrf->SetBinContent(80, 1.099121e-14);
  hrf->SetBinContent(81, 3.390954e-12);
  hrf->SetBinContent(82, 2.581269e-13);
  hrf->SetBinContent(83, 7.549517e-15);
  hrf->SetBinContent(84, 6.168399e-13);
  hrf->SetBinContent(85, 1.135092e-11);
  hrf->SetBinContent(86, 2.553513e-15);
  hrf->SetBinContent(87, 0.2588152);
  hrf->SetBinContent(88, 1.04361e-14);
  hrf->SetBinContent(89, 0.7345221);
  hrf->SetBinContent(90, 1.224243e-12);
  hrf->SetBinContent(91, 1.110223e-16);
  hrf->SetBinContent(92, 8.375522e-13);
  hrf->SetBinContent(93, 1.509903e-14);
  hrf->SetBinContent(94, 3.907652e-12);
  hrf->SetBinContent(95, 1.110223e-16);
  hrf->SetBinContent(96, 0.8778926);
  hrf->SetBinContent(97, 5.440093e-15);
  hrf->SetBinContent(98, 1.254552e-14);
  hrf->SetBinContent(99, 0.9284989);
  hrf->SetBinContent(100, 0.753942);
  hrf->SetBinContent(101, 1.103987);
  hrf->SetBinContent(102, 1.188931);
  hrf->SetBinContent(103, 1.080741);
  hrf->SetBinContent(104, 1.123484);
  hrf->SetBinContent(105, 0.96811);
  hrf->SetBinContent(106, 0.8889167);
  hrf->SetBinContent(109, 0.6210886);
  hrf->SetBinContent(110, 0.7505165);
  hrf->SetBinContent(111, 0.8426157);
  hrf->SetBinContent(112, 0.8893985);
  hrf->SetBinContent(113, 0.8655712);
  hrf->SetBinContent(114, 0.8169596);
  hrf->SetBinContent(115, 0.7972677);
  hrf->SetBinContent(116, 0.6298301);
  hrf->SetBinContent(117, 0.5066007);
  hrf->SetBinContent(118, 4.480217e-10);
  hrf->SetBinContent(119, 1.064704e-13);
  hrf->SetBinContent(120, 6.32161e-13);
  hrf->SetBinContent(121, 0.3865254);
  hrf->SetBinContent(122, 4.662937e-15);
  hrf->SetBinContent(123, 2.523537e-13);
  hrf->SetBinContent(124, 3.441691e-15);
  hrf->SetBinContent(125, 1.539324e-12);
  hrf->SetBinContent(126, 0.5198836);
  hrf->SetBinContent(127, 3.774758e-15);
  hrf->SetBinContent(128, 4.662937e-15);
  hrf->SetBinContent(129, 5.095924e-13);
  hrf->SetBinContent(130, 8.992806e-15);
  hrf->SetBinContent(131, 0.6979459);
  hrf->SetBinContent(132, 0.8410133);
  hrf->SetBinContent(133, 0.8820518);
  hrf->SetBinContent(134, 1.449095e-09);
  hrf->SetBinContent(135, 1.891825);
  hrf->SetBinContent(136, 3.736567e-12);
  hrf->SetBinContent(137, 2.171596e-13);
  hrf->SetBinContent(138, 3.58602e-14);
  hrf->SetBinContent(139, 8.401058e-13);
  hrf->SetBinContent(140, 6.661338e-16);
  hrf->SetBinContent(141, 6.228351e-14);
  hrf->SetBinContent(142, 4.440892e-16);
  hrf->SetBinContent(143, 0.5043001);
  hrf->SetBinContent(144, 2.950751e-12);
  hrf->SetBinContent(145, 7.44127e-12);
  hrf->SetBinContent(146, 4.440892e-16);
  hrf->SetBinContent(147, 0.415431);
  hrf->SetBinContent(148, 0.3341262);
  hrf->SetBinContent(149, 5.917489e-14);
  hrf->SetBinContent(150, 5.551115e-15);
  hrf->SetBinContent(151, 3.733125e-12);
  hrf->SetBinContent(152, 2.220446e-16);
  hrf->SetBinContent(153, 0.5875186);
  hrf->SetBinContent(154, 0.6020446);
  hrf->SetBinContent(155, 0.6340457);
  hrf->SetBinContent(156, 0.6748299);
  hrf->SetBinContent(157, 0.7500966);
  hrf->SetBinContent(158, 0.6613656);
  hrf->SetBinContent(159, 0.5764616);
  hrf->SetBinContent(160, 0.5013173);
  hrf->SetBinContent(163, 0.6392601);
  hrf->SetBinContent(164, 0.7223623);
  hrf->SetBinContent(165, 0.7522092);
  hrf->SetBinContent(166, 0.7454079);
  hrf->SetBinContent(167, 0.6907078);
  hrf->SetBinContent(168, 0.5840503);
  hrf->SetBinContent(169, 0.5802541);
  hrf->SetBinContent(170, 0.4497995);
  hrf->SetBinContent(171, 0.3261);
  hrf->SetBinContent(172, 0.2172562);
  hrf->SetBinContent(173, 0.04889038);
  hrf->SetBinContent(174, 0.1511836);
  hrf->SetBinContent(175, 0.1596252);
  hrf->SetBinContent(176, 0.2589621);
  hrf->SetBinContent(177, 4.440892e-16);
  hrf->SetBinContent(178, 1.110223e-16);
  hrf->SetBinContent(180, 1.733058e-13);
  hrf->SetBinContent(181, 3.145262e-13);
  hrf->SetBinContent(182, 0.3940507);
  hrf->SetBinContent(183, 0.4929505);
  hrf->SetBinContent(186, 8.437695e-14);
  hrf->SetBinContent(187, 4.527934e-12);
  hrf->SetBinContent(188, 3.481881e-12);
  hrf->SetBinContent(189, 1.54321e-14);
  hrf->SetBinContent(190, 1.998401e-15);
  hrf->SetBinContent(191, 2.557732e-12);
  hrf->SetBinContent(192, 5.314638e-13);
  hrf->SetBinContent(193, 1.465827e-12);
  hrf->SetBinContent(194, 0.4952829);
  hrf->SetBinContent(195, 0.3710457);
  hrf->SetBinContent(196, 7.058798e-13);
  hrf->SetBinContent(197, 1.065814e-14);
  hrf->SetBinContent(198, 3.330669e-16);
  hrf->SetBinContent(199, 3.552714e-15);
  hrf->SetBinContent(200, 2.58682e-14);
  hrf->SetBinContent(201, 3.330669e-16);
  hrf->SetBinContent(202, 0.2388499);
  hrf->SetBinContent(203, 1.232681e-12);
  hrf->SetBinContent(204, 3.28626e-14);
  hrf->SetBinContent(205, 4.372058e-13);
  hrf->SetBinContent(206, 1.764622e-11);
  hrf->SetBinContent(207, 0.2737416);
  hrf->SetBinContent(208, 0.3558382);
  hrf->SetBinContent(209, 0.4365672);
  hrf->SetBinContent(210, 0.5245328);
  hrf->SetBinContent(211, 0.5426048);
  hrf->SetBinContent(212, 0.5763847);
  hrf->SetBinContent(213, 0.5997939);
  hrf->SetBinContent(214, 0.5647634);
  hrf->SetBinContent(217, 0.6166065);
  hrf->SetBinContent(218, 0.6904591);
  hrf->SetBinContent(219, 0.7446713);
  hrf->SetBinContent(220, 0.7428927);
  hrf->SetBinContent(221, 0.7014583);
  hrf->SetBinContent(222, 0.6360658);
  hrf->SetBinContent(223, 0.5507807);
  hrf->SetBinContent(224, 0.4662885);
  hrf->SetBinContent(225, 0.2921537);
  hrf->SetBinContent(226, 0.2622769);
  hrf->SetBinContent(227, 0.2209838);
  hrf->SetBinContent(228, 0.109091);
  hrf->SetBinContent(229, 5.329071e-15);
  hrf->SetBinContent(230, 9.55902e-14);
  hrf->SetBinContent(231, 0.09094051);
  hrf->SetBinContent(232, 0.2690939);
  hrf->SetBinContent(233, 0.3311066);
  hrf->SetBinContent(234, 0.3870305);
  hrf->SetBinContent(235, 4.851675e-14);
  hrf->SetBinContent(236, 7.41629e-14);
  hrf->SetBinContent(237, 5.551115e-16);
  hrf->SetBinContent(238, 1.665335e-15);
  hrf->SetBinContent(239, 3.900213e-13);
  hrf->SetBinContent(240, 3.986922e-12);
  hrf->SetBinContent(241, 0.07189925);
  hrf->SetBinContent(242, 5.363154e-11);
  hrf->SetBinContent(243, 0.1681561);
  hrf->SetBinContent(244, 5.77316e-15);
  hrf->SetBinContent(245, 1.393652e-11);
  hrf->SetBinContent(246, 8.91287e-13);
  hrf->SetBinContent(247, 3.08642e-14);
  hrf->SetBinContent(248, 6.882273e-13);
  hrf->SetBinContent(249, 2.220446e-15);
  hrf->SetBinContent(250, 1.69631e-12);
  hrf->SetBinContent(251, 0.3618142);
  hrf->SetBinContent(252, 0.3173401);
  hrf->SetBinContent(253, 0.2427478);
  hrf->SetBinContent(254, 0.04446017);
  hrf->SetBinContent(255, 4.011236e-13);
  hrf->SetBinContent(256, 2.68674e-14);
  hrf->SetBinContent(257, 1.39222e-13);
  hrf->SetBinContent(258, 2.775558e-13);
  hrf->SetBinContent(259, 4.662937e-15);
  hrf->SetBinContent(260, 0.01799486);
  hrf->SetBinContent(261, 0.2536237);
  hrf->SetBinContent(262, 0.4121629);
  hrf->SetBinContent(263, 0.5030896);
  hrf->SetBinContent(264, 0.5291037);
  hrf->SetBinContent(265, 0.5938131);
  hrf->SetBinContent(266, 0.6105046);
  hrf->SetBinContent(267, 0.5962813);
  hrf->SetBinContent(268, 0.5595579);
  hrf->SetBinContent(271, 0.6526371);
  hrf->SetBinContent(272, 0.6718102);
  hrf->SetBinContent(273, 0.6971064);
  hrf->SetBinContent(274, 0.715696);
  hrf->SetBinContent(275, 0.6756563);
  hrf->SetBinContent(276, 0.6536352);
  hrf->SetBinContent(277, 0.6298154);
  hrf->SetBinContent(278, 0.5889418);
  hrf->SetBinContent(279, 0.5101216);
  hrf->SetBinContent(280, 0.4338073);
  hrf->SetBinContent(281, 0.4037817);
  hrf->SetBinContent(282, 0.3741269);
  hrf->SetBinContent(283, 0.3506718);
  hrf->SetBinContent(284, 0.3315757);
  hrf->SetBinContent(285, 0.3424355);
  hrf->SetBinContent(286, 0.3468707);
  hrf->SetBinContent(287, 0.3521713);
  hrf->SetBinContent(288, 0.3655425);
  hrf->SetBinContent(289, 0.3903866);
  hrf->SetBinContent(290, 0.42171);
  hrf->SetBinContent(291, 0.4440749);
  hrf->SetBinContent(292, 0.436104);
  hrf->SetBinContent(293, 0.4834715);
  hrf->SetBinContent(294, 0.4727529);
  hrf->SetBinContent(295, 0.503675);
  hrf->SetBinContent(296, 0.5256206);
  hrf->SetBinContent(297, 0.5077537);
  hrf->SetBinContent(298, 0.5060191);
  hrf->SetBinContent(299, 0.4839341);
  hrf->SetBinContent(300, 0.4730944);
  hrf->SetBinContent(301, 0.4377449);
  hrf->SetBinContent(302, 0.4008532);
  hrf->SetBinContent(303, 0.3935297);
  hrf->SetBinContent(304, 0.3723053);
  hrf->SetBinContent(305, 0.3553247);
  hrf->SetBinContent(306, 0.3426032);
  hrf->SetBinContent(307, 0.3302374);
  hrf->SetBinContent(308, 0.3205566);
  hrf->SetBinContent(309, 0.3008779);
  hrf->SetBinContent(310, 0.3194912);
  hrf->SetBinContent(311, 0.3341432);
  hrf->SetBinContent(312, 0.3293249);
  hrf->SetBinContent(313, 0.3298494);
  hrf->SetBinContent(314, 0.376054);
  hrf->SetBinContent(315, 0.4665582);
  hrf->SetBinContent(316, 0.4961285);
  hrf->SetBinContent(317, 0.5445178);
  hrf->SetBinContent(318, 0.5630735);
  hrf->SetBinContent(319, 0.5911169);
  hrf->SetBinContent(320, 0.6053321);
  hrf->SetBinContent(321, 0.6138202);
  hrf->SetBinContent(322, 0.5993208);
  hrf->SetBinContent(325, 0.7072042);
  hrf->SetBinContent(326, 0.7170147);
  hrf->SetBinContent(327, 0.7079694);
  hrf->SetBinContent(328, 0.7087873);
  hrf->SetBinContent(329, 0.6794895);
  hrf->SetBinContent(330, 0.6620911);
  hrf->SetBinContent(331, 0.6368085);
  hrf->SetBinContent(332, 0.6167822);
  hrf->SetBinContent(333, 0.5804145);
  hrf->SetBinContent(334, 0.5311387);
  hrf->SetBinContent(335, 0.4996493);
  hrf->SetBinContent(336, 0.4774897);
  hrf->SetBinContent(337, 0.4508032);
  hrf->SetBinContent(338, 0.4407316);
  hrf->SetBinContent(339, 0.4488528);
  hrf->SetBinContent(340, 0.4668958);
  hrf->SetBinContent(341, 0.4631993);
  hrf->SetBinContent(342, 0.4832653);
  hrf->SetBinContent(343, 0.5049595);
  hrf->SetBinContent(344, 0.5156142);
  hrf->SetBinContent(345, 0.5251185);
  hrf->SetBinContent(346, 0.5349182);
  hrf->SetBinContent(347, 0.5429661);
  hrf->SetBinContent(348, 0.5488337);
  hrf->SetBinContent(349, 0.5663636);
  hrf->SetBinContent(350, 0.5653254);
  hrf->SetBinContent(351, 0.5707994);
  hrf->SetBinContent(352, 0.5582824);
  hrf->SetBinContent(353, 0.5500923);
  hrf->SetBinContent(354, 0.5360044);
  hrf->SetBinContent(355, 0.5443032);
  hrf->SetBinContent(356, 0.5130047);
  hrf->SetBinContent(357, 0.496836);
  hrf->SetBinContent(358, 0.5037468);
  hrf->SetBinContent(359, 0.4914352);
  hrf->SetBinContent(360, 0.4690715);
  hrf->SetBinContent(361, 0.4548738);
  hrf->SetBinContent(362, 0.4484025);
  hrf->SetBinContent(363, 0.4367421);
  hrf->SetBinContent(364, 0.4432692);
  hrf->SetBinContent(365, 0.4540293);
  hrf->SetBinContent(366, 0.4528085);
  hrf->SetBinContent(367, 0.4793456);
  hrf->SetBinContent(368, 0.5333259);
  hrf->SetBinContent(369, 0.5224165);
  hrf->SetBinContent(370, 0.5335762);
  hrf->SetBinContent(371, 0.5766528);
  hrf->SetBinContent(372, 0.5914772);
  hrf->SetBinContent(373, 0.6361837);
  hrf->SetBinContent(374, 0.6511061);
  hrf->SetBinContent(375, 0.6729068);
  hrf->SetBinContent(376, 0.6693861);
  hrf->SetBinContent(379, 0.749916);
  hrf->SetBinContent(380, 0.7597389);
  hrf->SetBinContent(381, 0.7507262);
  hrf->SetBinContent(382, 0.7387256);
  hrf->SetBinContent(383, 0.7146781);
  hrf->SetBinContent(384, 0.6706957);
  hrf->SetBinContent(385, 0.6562388);
  hrf->SetBinContent(386, 0.6451488);
  hrf->SetBinContent(387, 0.6257445);
  hrf->SetBinContent(388, 0.5541511);
  hrf->SetBinContent(389, 0.5267816);
  hrf->SetBinContent(390, 0.5050932);
  hrf->SetBinContent(391, 0.498381);
  hrf->SetBinContent(392, 0.4985682);
  hrf->SetBinContent(393, 0.5024638);
  hrf->SetBinContent(394, 0.5153883);
  hrf->SetBinContent(395, 0.5194017);
  hrf->SetBinContent(396, 0.5463501);
  hrf->SetBinContent(397, 0.5520073);
  hrf->SetBinContent(398, 0.5520941);
  hrf->SetBinContent(399, 0.5610467);
  hrf->SetBinContent(400, 0.5676893);
  hrf->SetBinContent(401, 0.5760659);
  hrf->SetBinContent(402, 0.5787081);
  hrf->SetBinContent(403, 0.6006499);
  hrf->SetBinContent(404, 0.6000866);
  hrf->SetBinContent(405, 0.606465);
  hrf->SetBinContent(406, 0.5974886);
  hrf->SetBinContent(407, 0.5776305);
  hrf->SetBinContent(408, 0.5754585);
  hrf->SetBinContent(409, 0.5686907);
  hrf->SetBinContent(410, 0.5632511);
  hrf->SetBinContent(411, 0.5433577);
  hrf->SetBinContent(412, 0.5414782);
  hrf->SetBinContent(413, 0.5409556);
  hrf->SetBinContent(414, 0.5249445);
  hrf->SetBinContent(415, 0.509481);
  hrf->SetBinContent(416, 0.4860629);
  hrf->SetBinContent(417, 0.4814033);
  hrf->SetBinContent(418, 0.4881889);
  hrf->SetBinContent(419, 0.4892032);
  hrf->SetBinContent(420, 0.4967099);
  hrf->SetBinContent(421, 0.5080456);
  hrf->SetBinContent(422, 0.5725561);
  hrf->SetBinContent(423, 0.5688643);
  hrf->SetBinContent(424, 0.5783035);
  hrf->SetBinContent(425, 0.608463);
  hrf->SetBinContent(426, 0.6477233);
  hrf->SetBinContent(427, 0.678503);
  hrf->SetBinContent(428, 0.6974414);
  hrf->SetBinContent(429, 0.7161245);
  hrf->SetBinContent(430, 0.7179291);
  hrf->SetBinContent(433, 0.7649254);
  hrf->SetBinContent(434, 0.7875582);
  hrf->SetBinContent(435, 0.7829209);
  hrf->SetBinContent(436, 0.7632096);
  hrf->SetBinContent(437, 0.7486479);
  hrf->SetBinContent(438, 0.7155891);
  hrf->SetBinContent(439, 0.681989);
  hrf->SetBinContent(440, 0.6651565);
  hrf->SetBinContent(441, 0.6493679);
  hrf->SetBinContent(442, 0.5650414);
  hrf->SetBinContent(443, 0.5358658);
  hrf->SetBinContent(444, 0.5266296);
  hrf->SetBinContent(445, 0.5113901);
  hrf->SetBinContent(446, 0.5254153);
  hrf->SetBinContent(447, 0.5273484);
  hrf->SetBinContent(448, 0.5369164);
  hrf->SetBinContent(449, 0.5409524);
  hrf->SetBinContent(450, 0.5658296);
  hrf->SetBinContent(451, 0.5776091);
  hrf->SetBinContent(452, 0.5741496);
  hrf->SetBinContent(453, 0.5962785);
  hrf->SetBinContent(454, 0.5996542);
  hrf->SetBinContent(455, 0.5980803);
  hrf->SetBinContent(456, 0.6063);
  hrf->SetBinContent(457, 0.6241938);
  hrf->SetBinContent(458, 0.6266866);
  hrf->SetBinContent(459, 0.6175104);
  hrf->SetBinContent(460, 0.6188141);
  hrf->SetBinContent(461, 0.6151288);
  hrf->SetBinContent(462, 0.5934609);
  hrf->SetBinContent(463, 0.590576);
  hrf->SetBinContent(464, 0.5800966);
  hrf->SetBinContent(465, 0.5787441);
  hrf->SetBinContent(466, 0.5729356);
  hrf->SetBinContent(467, 0.5677129);
  hrf->SetBinContent(468, 0.5537542);
  hrf->SetBinContent(469, 0.5355842);
  hrf->SetBinContent(470, 0.5196738);
  hrf->SetBinContent(471, 0.5210825);
  hrf->SetBinContent(472, 0.5059826);
  hrf->SetBinContent(473, 0.5146358);
  hrf->SetBinContent(474, 0.5194442);
  hrf->SetBinContent(475, 0.5423242);
  hrf->SetBinContent(476, 0.6041303);
  hrf->SetBinContent(477, 0.6131922);
  hrf->SetBinContent(478, 0.6294447);
  hrf->SetBinContent(479, 0.6581404);
  hrf->SetBinContent(480, 0.682565);
  hrf->SetBinContent(481, 0.7175475);
  hrf->SetBinContent(482, 0.732161);
  hrf->SetBinContent(483, 0.7473059);
  hrf->SetBinContent(484, 0.7463843);
  hrf->SetBinContent(487, 0.7733338);
  hrf->SetBinContent(488, 0.7914098);
  hrf->SetBinContent(489, 0.7922547);
  hrf->SetBinContent(490, 0.7975932);
  hrf->SetBinContent(491, 0.7624868);
  hrf->SetBinContent(492, 0.7416359);
  hrf->SetBinContent(493, 0.723097);
  hrf->SetBinContent(494, 0.7061391);
  hrf->SetBinContent(495, 0.6900467);
  hrf->SetBinContent(496, 0.6053169);
  hrf->SetBinContent(497, 0.5709425);
  hrf->SetBinContent(498, 0.5451863);
  hrf->SetBinContent(499, 0.5321503);
  hrf->SetBinContent(500, 0.5324251);
  hrf->SetBinContent(501, 0.5397416);
  hrf->SetBinContent(502, 0.575781);
  hrf->SetBinContent(503, 0.5632829);
  hrf->SetBinContent(504, 0.5976698);
  hrf->SetBinContent(505, 0.5966061);
  hrf->SetBinContent(506, 0.6016284);
  hrf->SetBinContent(507, 0.5992189);
  hrf->SetBinContent(508, 0.6216044);
  hrf->SetBinContent(509, 0.6149693);
  hrf->SetBinContent(510, 0.6312055);
  hrf->SetBinContent(511, 0.6368536);
  hrf->SetBinContent(512, 0.6376288);
  hrf->SetBinContent(513, 0.6294262);
  hrf->SetBinContent(514, 0.6308918);
  hrf->SetBinContent(515, 0.6290194);
  hrf->SetBinContent(516, 0.6216436);
  hrf->SetBinContent(517, 0.6144779);
  hrf->SetBinContent(518, 0.6137364);
  hrf->SetBinContent(519, 0.6026688);
  hrf->SetBinContent(520, 0.6069801);
  hrf->SetBinContent(521, 0.5848015);
  hrf->SetBinContent(522, 0.5748533);
  hrf->SetBinContent(523, 0.5508263);
  hrf->SetBinContent(524, 0.5483323);
  hrf->SetBinContent(525, 0.5322801);
  hrf->SetBinContent(526, 0.5254273);
  hrf->SetBinContent(527, 0.5410626);
  hrf->SetBinContent(528, 0.5529507);
  hrf->SetBinContent(529, 0.5857173);
  hrf->SetBinContent(530, 0.6527883);
  hrf->SetBinContent(531, 0.6530318);
  hrf->SetBinContent(532, 0.6672208);
  hrf->SetBinContent(533, 0.7044364);
  hrf->SetBinContent(534, 0.7190105);
  hrf->SetBinContent(535, 0.7483566);
  hrf->SetBinContent(536, 0.7548751);
  hrf->SetBinContent(537, 0.7652832);
  hrf->SetBinContent(538, 0.7529632);
  hrf->SetBinContent(541, 0.779761);
  hrf->SetBinContent(542, 0.7991457);
  hrf->SetBinContent(543, 0.8038527);
  hrf->SetBinContent(544, 0.7977124);
  hrf->SetBinContent(545, 0.7917452);
  hrf->SetBinContent(546, 0.7720835);
  hrf->SetBinContent(547, 0.7327496);
  hrf->SetBinContent(548, 0.7359458);
  hrf->SetBinContent(549, 0.7209811);
  hrf->SetBinContent(550, 0.6282369);
  hrf->SetBinContent(551, 0.6037263);
  hrf->SetBinContent(552, 0.5729901);
  hrf->SetBinContent(553, 0.5664849);
  hrf->SetBinContent(554, 0.5590503);
  hrf->SetBinContent(555, 0.5610377);
  hrf->SetBinContent(556, 0.5755157);
  hrf->SetBinContent(557, 0.5890701);
  hrf->SetBinContent(558, 0.6107467);
  hrf->SetBinContent(559, 0.6061065);
  hrf->SetBinContent(560, 0.6135439);
  hrf->SetBinContent(561, 0.6336191);
  hrf->SetBinContent(562, 0.6395465);
  hrf->SetBinContent(563, 0.6450207);
  hrf->SetBinContent(564, 0.6457672);
  hrf->SetBinContent(565, 0.6570385);
  hrf->SetBinContent(566, 0.6614696);
  hrf->SetBinContent(567, 0.6429687);
  hrf->SetBinContent(568, 0.6491577);
  hrf->SetBinContent(569, 0.6464563);
  hrf->SetBinContent(570, 0.6443511);
  hrf->SetBinContent(571, 0.6264946);
  hrf->SetBinContent(572, 0.6210324);
  hrf->SetBinContent(573, 0.6074563);
  hrf->SetBinContent(574, 0.6162496);
  hrf->SetBinContent(575, 0.6052733);
  hrf->SetBinContent(576, 0.5810783);
  hrf->SetBinContent(577, 0.5706381);
  hrf->SetBinContent(578, 0.5627378);
  hrf->SetBinContent(579, 0.5527847);
  hrf->SetBinContent(580, 0.5641665);
  hrf->SetBinContent(581, 0.5694626);
  hrf->SetBinContent(582, 0.5749119);
  hrf->SetBinContent(583, 0.6263555);
  hrf->SetBinContent(584, 0.7097491);
  hrf->SetBinContent(585, 0.6947002);
  hrf->SetBinContent(586, 0.7008479);
  hrf->SetBinContent(587, 0.7207282);
  hrf->SetBinContent(588, 0.7500328);
  hrf->SetBinContent(589, 0.7644583);
  hrf->SetBinContent(590, 0.7729988);
  hrf->SetBinContent(591, 0.774512);
  hrf->SetBinContent(592, 0.766691);
  hrf->SetBinContent(595, 0.7877997);
  hrf->SetBinContent(596, 0.808685);
  hrf->SetBinContent(597, 0.8098472);
  hrf->SetBinContent(598, 0.7990698);
  hrf->SetBinContent(599, 0.7913377);
  hrf->SetBinContent(600, 0.7841092);
  hrf->SetBinContent(601, 0.7699786);
  hrf->SetBinContent(602, 0.7508966);
  hrf->SetBinContent(603, 0.7446558);
  hrf->SetBinContent(604, 0.6604987);
  hrf->SetBinContent(605, 0.6226556);
  hrf->SetBinContent(606, 0.6059709);
  hrf->SetBinContent(607, 0.5917993);
  hrf->SetBinContent(608, 0.5969635);
  hrf->SetBinContent(609, 0.5934169);
  hrf->SetBinContent(610, 0.5916147);
  hrf->SetBinContent(611, 0.6020344);
  hrf->SetBinContent(612, 0.617125);
  hrf->SetBinContent(613, 0.6127092);
  hrf->SetBinContent(614, 0.6242438);
  hrf->SetBinContent(615, 0.6382228);
  hrf->SetBinContent(616, 0.6551722);
  hrf->SetBinContent(617, 0.6591862);
  hrf->SetBinContent(618, 0.6545591);
  hrf->SetBinContent(619, 0.6651771);
  hrf->SetBinContent(620, 0.6659877);
  hrf->SetBinContent(621, 0.6619171);
  hrf->SetBinContent(622, 0.6770883);
  hrf->SetBinContent(623, 0.6546994);
  hrf->SetBinContent(624, 0.6580142);
  hrf->SetBinContent(625, 0.6535073);
  hrf->SetBinContent(626, 0.6343181);
  hrf->SetBinContent(627, 0.6272753);
  hrf->SetBinContent(628, 0.6205974);
  hrf->SetBinContent(629, 0.6180187);
  hrf->SetBinContent(630, 0.5955703);
  hrf->SetBinContent(631, 0.5950559);
  hrf->SetBinContent(632, 0.5859662);
  hrf->SetBinContent(633, 0.5825738);
  hrf->SetBinContent(634, 0.5839396);
  hrf->SetBinContent(635, 0.59145);
  hrf->SetBinContent(636, 0.6092284);
  hrf->SetBinContent(637, 0.6343765);
  hrf->SetBinContent(638, 0.7176949);
  hrf->SetBinContent(639, 0.7168224);
  hrf->SetBinContent(640, 0.7343724);
  hrf->SetBinContent(641, 0.7428303);
  hrf->SetBinContent(642, 0.7552095);
  hrf->SetBinContent(643, 0.7756618);
  hrf->SetBinContent(644, 0.7788388);
  hrf->SetBinContent(645, 0.7845942);
  hrf->SetBinContent(646, 0.7718939);
  hrf->SetBinContent(649, 0.7944824);
  hrf->SetBinContent(650, 0.8055041);
  hrf->SetBinContent(651, 0.8163133);
  hrf->SetBinContent(652, 0.8026978);
  hrf->SetBinContent(653, 0.790246);
  hrf->SetBinContent(654, 0.7957031);
  hrf->SetBinContent(655, 0.7770987);
  hrf->SetBinContent(656, 0.7683768);
  hrf->SetBinContent(657, 0.7810934);
  hrf->SetBinContent(658, 0.6743879);
  hrf->SetBinContent(659, 0.6436225);
  hrf->SetBinContent(660, 0.632295);
  hrf->SetBinContent(661, 0.6136842);
  hrf->SetBinContent(662, 0.6152433);
  hrf->SetBinContent(663, 0.6258261);
  hrf->SetBinContent(664, 0.6237895);
  hrf->SetBinContent(665, 0.6237429);
  hrf->SetBinContent(666, 0.6365916);
  hrf->SetBinContent(667, 0.6370676);
  hrf->SetBinContent(668, 0.6374596);
  hrf->SetBinContent(669, 0.6477762);
  hrf->SetBinContent(670, 0.6613339);
  hrf->SetBinContent(671, 0.6717926);
  hrf->SetBinContent(672, 0.6676553);
  hrf->SetBinContent(673, 0.6750093);
  hrf->SetBinContent(674, 0.6722414);
  hrf->SetBinContent(675, 0.6776585);
  hrf->SetBinContent(676, 0.6800311);
  hrf->SetBinContent(677, 0.665933);
  hrf->SetBinContent(678, 0.6588035);
  hrf->SetBinContent(679, 0.6570917);
  hrf->SetBinContent(680, 0.6399373);
  hrf->SetBinContent(681, 0.6336509);
  hrf->SetBinContent(682, 0.6271339);
  hrf->SetBinContent(683, 0.6279051);
  hrf->SetBinContent(684, 0.6140663);
  hrf->SetBinContent(685, 0.6070532);
  hrf->SetBinContent(686, 0.6170091);
  hrf->SetBinContent(687, 0.6174384);
  hrf->SetBinContent(688, 0.6121793);
  hrf->SetBinContent(689, 0.6064191);
  hrf->SetBinContent(690, 0.6193621);
  hrf->SetBinContent(691, 0.6625033);
  hrf->SetBinContent(692, 0.7497195);
  hrf->SetBinContent(693, 0.7461648);
  hrf->SetBinContent(694, 0.7443557);
  hrf->SetBinContent(695, 0.7535318);
  hrf->SetBinContent(696, 0.7649554);
  hrf->SetBinContent(697, 0.7840306);
  hrf->SetBinContent(698, 0.7808634);
  hrf->SetBinContent(699, 0.7844161);
  hrf->SetBinContent(700, 0.7727049);
  hrf->SetBinContent(703, 0.79143);
  hrf->SetBinContent(704, 0.8175707);
  hrf->SetBinContent(705, 0.8097944);
  hrf->SetBinContent(706, 0.8196373);
  hrf->SetBinContent(707, 0.8037912);
  hrf->SetBinContent(708, 0.8060334);
  hrf->SetBinContent(709, 0.7844828);
  hrf->SetBinContent(710, 0.7781734);
  hrf->SetBinContent(711, 0.7990621);
  hrf->SetBinContent(712, 0.6977159);
  hrf->SetBinContent(713, 0.6567251);
  hrf->SetBinContent(714, 0.6458738);
  hrf->SetBinContent(715, 0.6391681);
  hrf->SetBinContent(716, 0.6486698);
  hrf->SetBinContent(717, 0.6482897);
  hrf->SetBinContent(718, 0.6564287);
  hrf->SetBinContent(719, 0.647959);
  hrf->SetBinContent(720, 0.6545083);
  hrf->SetBinContent(721, 0.6605134);
  hrf->SetBinContent(722, 0.654643);
  hrf->SetBinContent(723, 0.6720995);
  hrf->SetBinContent(724, 0.674703);
  hrf->SetBinContent(725, 0.6736486);
  hrf->SetBinContent(726, 0.6720003);
  hrf->SetBinContent(727, 0.6716139);
  hrf->SetBinContent(728, 0.6925032);
  hrf->SetBinContent(729, 0.6797168);
  hrf->SetBinContent(730, 0.6764894);
  hrf->SetBinContent(731, 0.6712697);
  hrf->SetBinContent(732, 0.6748146);
  hrf->SetBinContent(733, 0.6764159);
  hrf->SetBinContent(734, 0.6675547);
  hrf->SetBinContent(735, 0.6499624);
  hrf->SetBinContent(736, 0.6558874);
  hrf->SetBinContent(737, 0.655924);
  hrf->SetBinContent(738, 0.6442464);
  hrf->SetBinContent(739, 0.6524487);
  hrf->SetBinContent(740, 0.6406163);
  hrf->SetBinContent(741, 0.6279376);
  hrf->SetBinContent(742, 0.6354516);
  hrf->SetBinContent(743, 0.631308);
  hrf->SetBinContent(744, 0.6505761);
  hrf->SetBinContent(745, 0.6879659);
  hrf->SetBinContent(746, 0.7664913);
  hrf->SetBinContent(747, 0.7509025);
  hrf->SetBinContent(748, 0.7499993);
  hrf->SetBinContent(749, 0.7594694);
  hrf->SetBinContent(750, 0.7788361);
  hrf->SetBinContent(751, 0.7906924);
  hrf->SetBinContent(752, 0.7932374);
  hrf->SetBinContent(753, 0.7901082);
  hrf->SetBinContent(754, 0.7791761);
  hrf->SetBinContent(757, 0.8110717);
  hrf->SetBinContent(758, 0.8380142);
  hrf->SetBinContent(759, 0.8261526);
  hrf->SetBinContent(760, 0.8238212);
  hrf->SetBinContent(761, 0.8191666);
  hrf->SetBinContent(762, 0.8118178);
  hrf->SetBinContent(763, 0.8026837);
  hrf->SetBinContent(764, 0.7950587);
  hrf->SetBinContent(765, 0.8015642);
  hrf->SetBinContent(766, 0.7203518);
  hrf->SetBinContent(767, 0.7126079);
  hrf->SetBinContent(768, 0.6955605);
  hrf->SetBinContent(769, 0.6856663);
  hrf->SetBinContent(770, 0.6942785);
  hrf->SetBinContent(771, 0.6787785);
  hrf->SetBinContent(772, 0.6844447);
  hrf->SetBinContent(773, 0.6898586);
  hrf->SetBinContent(774, 0.700813);
  hrf->SetBinContent(775, 0.7038191);
  hrf->SetBinContent(776, 0.6954153);
  hrf->SetBinContent(777, 0.706893);
  hrf->SetBinContent(778, 0.707776);
  hrf->SetBinContent(779, 0.710542);
  hrf->SetBinContent(780, 0.6989855);
  hrf->SetBinContent(781, 0.6987113);
  hrf->SetBinContent(782, 0.7227745);
  hrf->SetBinContent(783, 0.7161766);
  hrf->SetBinContent(784, 0.6978431);
  hrf->SetBinContent(785, 0.703478);
  hrf->SetBinContent(786, 0.7087042);
  hrf->SetBinContent(787, 0.7052461);
  hrf->SetBinContent(788, 0.6980579);
  hrf->SetBinContent(789, 0.7004423);
  hrf->SetBinContent(790, 0.688938);
  hrf->SetBinContent(791, 0.6870395);
  hrf->SetBinContent(792, 0.6967018);
  hrf->SetBinContent(793, 0.7004873);
  hrf->SetBinContent(794, 0.6929513);
  hrf->SetBinContent(795, 0.6701168);
  hrf->SetBinContent(796, 0.6766522);
  hrf->SetBinContent(797, 0.6715191);
  hrf->SetBinContent(798, 0.6891941);
  hrf->SetBinContent(799, 0.7155854);
  hrf->SetBinContent(800, 0.8024459);
  hrf->SetBinContent(801, 0.7730235);
  hrf->SetBinContent(802, 0.7852777);
  hrf->SetBinContent(803, 0.7864005);
  hrf->SetBinContent(804, 0.8006655);
  hrf->SetBinContent(805, 0.8060328);
  hrf->SetBinContent(806, 0.8051929);
  hrf->SetBinContent(807, 0.8088812);
  hrf->SetBinContent(808, 0.8048784);
  hrf->SetBinContent(811, 0.828478);
  hrf->SetBinContent(812, 0.8300321);
  hrf->SetBinContent(813, 0.8421991);
  hrf->SetBinContent(814, 0.8365502);
  hrf->SetBinContent(815, 0.8302338);
  hrf->SetBinContent(816, 0.830529);
  hrf->SetBinContent(817, 0.8107802);
  hrf->SetBinContent(818, 0.8061959);
  hrf->SetBinContent(819, 0.8248827);
  hrf->SetBinContent(820, 0.7303534);
  hrf->SetBinContent(821, 0.7015954);
  hrf->SetBinContent(822, 0.6989409);
  hrf->SetBinContent(823, 0.7031218);
  hrf->SetBinContent(824, 0.7116248);
  hrf->SetBinContent(825, 0.7116616);
  hrf->SetBinContent(826, 0.7064694);
  hrf->SetBinContent(827, 0.721562);
  hrf->SetBinContent(828, 0.7237493);
  hrf->SetBinContent(829, 0.7249997);
  hrf->SetBinContent(830, 0.7241992);
  hrf->SetBinContent(831, 0.7378653);
  hrf->SetBinContent(832, 0.7348103);
  hrf->SetBinContent(833, 0.7233974);
  hrf->SetBinContent(834, 0.7464554);
  hrf->SetBinContent(835, 0.7290223);
  hrf->SetBinContent(836, 0.7406547);
  hrf->SetBinContent(837, 0.7428466);
  hrf->SetBinContent(838, 0.7317876);
  hrf->SetBinContent(839, 0.7378644);
  hrf->SetBinContent(840, 0.7383478);
  hrf->SetBinContent(841, 0.7281325);
  hrf->SetBinContent(842, 0.7139049);
  hrf->SetBinContent(843, 0.7221135);
  hrf->SetBinContent(844, 0.7124106);
  hrf->SetBinContent(845, 0.7245829);
  hrf->SetBinContent(846, 0.7148562);
  hrf->SetBinContent(847, 0.7135551);
  hrf->SetBinContent(848, 0.711857);
  hrf->SetBinContent(849, 0.7122115);
  hrf->SetBinContent(850, 0.6893438);
  hrf->SetBinContent(851, 0.6891645);
  hrf->SetBinContent(852, 0.6930996);
  hrf->SetBinContent(853, 0.7186014);
  hrf->SetBinContent(854, 0.8179576);
  hrf->SetBinContent(855, 0.7949426);
  hrf->SetBinContent(856, 0.7879985);
  hrf->SetBinContent(857, 0.8009133);
  hrf->SetBinContent(858, 0.7969646);
  hrf->SetBinContent(859, 0.8221051);
  hrf->SetBinContent(860, 0.8201365);
  hrf->SetBinContent(861, 0.8227643);
  hrf->SetBinContent(862, 0.8171785);
  hrf->SetBinContent(865, 0.8372037);
  hrf->SetBinContent(866, 0.8434036);
  hrf->SetBinContent(867, 0.8394099);
  hrf->SetBinContent(868, 0.85263);
  hrf->SetBinContent(869, 0.8264552);
  hrf->SetBinContent(870, 0.8431022);
  hrf->SetBinContent(871, 0.8168057);
  hrf->SetBinContent(872, 0.8267195);
  hrf->SetBinContent(873, 0.8416439);
  hrf->SetBinContent(874, 0.7480366);
  hrf->SetBinContent(875, 0.7120796);
  hrf->SetBinContent(876, 0.7131553);
  hrf->SetBinContent(877, 0.7088758);
  hrf->SetBinContent(878, 0.7136126);
  hrf->SetBinContent(879, 0.7403855);
  hrf->SetBinContent(880, 0.742373);
  hrf->SetBinContent(881, 0.7468469);
  hrf->SetBinContent(882, 0.7468605);
  hrf->SetBinContent(883, 0.7480819);
  hrf->SetBinContent(884, 0.7456565);
  hrf->SetBinContent(885, 0.7563028);
  hrf->SetBinContent(886, 0.7579337);
  hrf->SetBinContent(887, 0.7524621);
  hrf->SetBinContent(888, 0.7615474);
  hrf->SetBinContent(889, 0.7591589);
  hrf->SetBinContent(890, 0.7580302);
  hrf->SetBinContent(891, 0.7588596);
  hrf->SetBinContent(892, 0.7566364);
  hrf->SetBinContent(893, 0.7544942);
  hrf->SetBinContent(894, 0.7538131);
  hrf->SetBinContent(895, 0.7591716);
  hrf->SetBinContent(896, 0.7503425);
  hrf->SetBinContent(897, 0.7677357);
  hrf->SetBinContent(898, 0.7441401);
  hrf->SetBinContent(899, 0.7495831);
  hrf->SetBinContent(900, 0.7336878);
  hrf->SetBinContent(901, 0.7278067);
  hrf->SetBinContent(902, 0.7370681);
  hrf->SetBinContent(903, 0.7159551);
  hrf->SetBinContent(904, 0.7108493);
  hrf->SetBinContent(905, 0.7052596);
  hrf->SetBinContent(906, 0.70617);
  hrf->SetBinContent(907, 0.7400752);
  hrf->SetBinContent(908, 0.828081);
  hrf->SetBinContent(909, 0.8022696);
  hrf->SetBinContent(910, 0.7955783);
  hrf->SetBinContent(911, 0.8050228);
  hrf->SetBinContent(912, 0.8143564);
  hrf->SetBinContent(913, 0.8210121);
  hrf->SetBinContent(914, 0.8313174);
  hrf->SetBinContent(915, 0.8341477);
  hrf->SetBinContent(916, 0.8276628);
  hrf->SetBinContent(919, 0.8357379);
  hrf->SetBinContent(920, 0.8381479);
  hrf->SetBinContent(921, 0.8444386);
  hrf->SetBinContent(922, 0.8521889);
  hrf->SetBinContent(923, 0.8359455);
  hrf->SetBinContent(924, 0.8334427);
  hrf->SetBinContent(925, 0.8269944);
  hrf->SetBinContent(926, 0.8278334);
  hrf->SetBinContent(927, 0.8484597);
  hrf->SetBinContent(928, 0.7543424);
  hrf->SetBinContent(929, 0.7237014);
  hrf->SetBinContent(930, 0.7300712);
  hrf->SetBinContent(931, 0.7255344);
  hrf->SetBinContent(932, 0.7279992);
  hrf->SetBinContent(933, 0.7446671);
  hrf->SetBinContent(934, 0.757793);
  hrf->SetBinContent(935, 0.7646086);
  hrf->SetBinContent(936, 0.7726059);
  hrf->SetBinContent(937, 0.7719304);
  hrf->SetBinContent(938, 0.7673779);
  hrf->SetBinContent(939, 0.7615338);
  hrf->SetBinContent(940, 0.7828174);
  hrf->SetBinContent(941, 0.7761256);
  hrf->SetBinContent(942, 0.7770767);
  hrf->SetBinContent(943, 0.7809832);
  hrf->SetBinContent(944, 0.775672);
  hrf->SetBinContent(945, 0.7823281);
  hrf->SetBinContent(946, 0.7677814);
  hrf->SetBinContent(947, 0.7777502);
  hrf->SetBinContent(948, 0.7756031);
  hrf->SetBinContent(949, 0.7791944);
  hrf->SetBinContent(950, 0.7667066);
  hrf->SetBinContent(951, 0.7644495);
  hrf->SetBinContent(952, 0.7643178);
  hrf->SetBinContent(953, 0.758558);
  hrf->SetBinContent(954, 0.7542499);
  hrf->SetBinContent(955, 0.7594551);
  hrf->SetBinContent(956, 0.7431659);
  hrf->SetBinContent(957, 0.7187039);
  hrf->SetBinContent(958, 0.7167979);
  hrf->SetBinContent(959, 0.7137383);
  hrf->SetBinContent(960, 0.7135442);
  hrf->SetBinContent(961, 0.7386492);
  hrf->SetBinContent(962, 0.8410811);
  hrf->SetBinContent(963, 0.8221065);
  hrf->SetBinContent(964, 0.8045056);
  hrf->SetBinContent(965, 0.8089661);
  hrf->SetBinContent(966, 0.8274295);
  hrf->SetBinContent(967, 0.8327056);
  hrf->SetBinContent(968, 0.8339137);
  hrf->SetBinContent(969, 0.8401244);
  hrf->SetBinContent(970, 0.8328208);
  hrf->SetBinContent(973, 0.8514778);
  hrf->SetBinContent(974, 0.8586817);
  hrf->SetBinContent(975, 0.8520512);
  hrf->SetBinContent(976, 0.8530916);
  hrf->SetBinContent(977, 0.8531001);
  hrf->SetBinContent(978, 0.8351443);
  hrf->SetBinContent(979, 0.8395857);
  hrf->SetBinContent(980, 0.8349355);
  hrf->SetBinContent(981, 0.8600548);
  hrf->SetBinContent(982, 0.7740794);
  hrf->SetBinContent(983, 0.7398908);
  hrf->SetBinContent(984, 0.730821);
  hrf->SetBinContent(985, 0.7287126);
  hrf->SetBinContent(986, 0.7518275);
  hrf->SetBinContent(987, 0.7515175);
  hrf->SetBinContent(988, 0.7600703);
  hrf->SetBinContent(989, 0.7720006);
  hrf->SetBinContent(990, 0.7799897);
  hrf->SetBinContent(991, 0.7874361);
  hrf->SetBinContent(992, 0.8000161);
  hrf->SetBinContent(993, 0.7943968);
  hrf->SetBinContent(994, 0.7992765);
  hrf->SetBinContent(995, 0.8026219);
  hrf->SetBinContent(996, 0.8092993);
  hrf->SetBinContent(997, 0.8061416);
  hrf->SetBinContent(998, 0.7979919);
  hrf->SetBinContent(999, 0.807699);
  hrf->SetBinContent(1000, 0.8014735);
  hrf->SetBinContent(1001, 0.7990585);
  hrf->SetBinContent(1002, 0.800338);
  hrf->SetBinContent(1003, 0.8032897);
  hrf->SetBinContent(1004, 0.8062115);
  hrf->SetBinContent(1005, 0.7816278);
  hrf->SetBinContent(1006, 0.7867376);
  hrf->SetBinContent(1007, 0.7911171);
  hrf->SetBinContent(1008, 0.7713616);
  hrf->SetBinContent(1009, 0.7612013);
  hrf->SetBinContent(1010, 0.7483594);
  hrf->SetBinContent(1011, 0.7335092);
  hrf->SetBinContent(1012, 0.7379464);
  hrf->SetBinContent(1013, 0.7298684);
  hrf->SetBinContent(1014, 0.7319131);
  hrf->SetBinContent(1015, 0.7636759);
  hrf->SetBinContent(1016, 0.8397166);
  hrf->SetBinContent(1017, 0.8313021);
  hrf->SetBinContent(1018, 0.8312497);
  hrf->SetBinContent(1019, 0.8293538);
  hrf->SetBinContent(1020, 0.8377833);
  hrf->SetBinContent(1021, 0.8391762);
  hrf->SetBinContent(1022, 0.8472521);
  hrf->SetBinContent(1023, 0.8437346);
  hrf->SetBinContent(1024, 0.8413609);
  hrf->SetBinContent(1027, 0.8706501);
  hrf->SetBinContent(1028, 0.8708884);
  hrf->SetBinContent(1029, 0.8596638);
  hrf->SetBinContent(1030, 0.8669677);
  hrf->SetBinContent(1031, 0.8618272);
  hrf->SetBinContent(1032, 0.8499665);
  hrf->SetBinContent(1033, 0.8595119);
  hrf->SetBinContent(1034, 0.8574477);
  hrf->SetBinContent(1035, 0.8665594);
  hrf->SetBinContent(1036, 0.7836786);
  hrf->SetBinContent(1037, 0.7570157);
  hrf->SetBinContent(1038, 0.7496819);
  hrf->SetBinContent(1039, 0.7568184);
  hrf->SetBinContent(1040, 0.7622727);
  hrf->SetBinContent(1041, 0.7782569);
  hrf->SetBinContent(1042, 0.7813501);
  hrf->SetBinContent(1043, 0.7854785);
  hrf->SetBinContent(1044, 0.8024394);
  hrf->SetBinContent(1045, 0.8006565);
  hrf->SetBinContent(1046, 0.8093139);
  hrf->SetBinContent(1047, 0.8140576);
  hrf->SetBinContent(1048, 0.8294069);
  hrf->SetBinContent(1049, 0.8265017);
  hrf->SetBinContent(1050, 0.8219708);
  hrf->SetBinContent(1051, 0.8306177);
  hrf->SetBinContent(1052, 0.8356077);
  hrf->SetBinContent(1053, 0.821778);
  hrf->SetBinContent(1054, 0.8324773);
  hrf->SetBinContent(1055, 0.8327084);
  hrf->SetBinContent(1056, 0.8280543);
  hrf->SetBinContent(1057, 0.8213516);
  hrf->SetBinContent(1058, 0.8111429);
  hrf->SetBinContent(1059, 0.8049538);
  hrf->SetBinContent(1060, 0.7954642);
  hrf->SetBinContent(1061, 0.7925411);
  hrf->SetBinContent(1062, 0.7914885);
  hrf->SetBinContent(1063, 0.7779347);
  hrf->SetBinContent(1064, 0.7610781);
  hrf->SetBinContent(1065, 0.7743629);
  hrf->SetBinContent(1066, 0.7556941);
  hrf->SetBinContent(1067, 0.740801);
  hrf->SetBinContent(1068, 0.756769);
  hrf->SetBinContent(1069, 0.7749262);
  hrf->SetBinContent(1070, 0.8637108);
  hrf->SetBinContent(1071, 0.8421297);
  hrf->SetBinContent(1072, 0.8345889);
  hrf->SetBinContent(1073, 0.8484675);
  hrf->SetBinContent(1074, 0.8509088);
  hrf->SetBinContent(1075, 0.8528676);
  hrf->SetBinContent(1076, 0.8609979);
  hrf->SetBinContent(1077, 0.863323);
  hrf->SetBinContent(1078, 0.8613247);
  hrf->SetBinContent(1081, 0.8834211);
  hrf->SetBinContent(1082, 0.8786597);
  hrf->SetBinContent(1083, 0.8725045);
  hrf->SetBinContent(1084, 0.8704908);
  hrf->SetBinContent(1085, 0.8642075);
  hrf->SetBinContent(1086, 0.8703049);
  hrf->SetBinContent(1087, 0.8612224);
  hrf->SetBinContent(1088, 0.8590188);
  hrf->SetBinContent(1089, 0.8811834);
  hrf->SetBinContent(1090, 0.8036878);
  hrf->SetBinContent(1091, 0.7733839);
  hrf->SetBinContent(1092, 0.7577583);
  hrf->SetBinContent(1093, 0.7661267);
  hrf->SetBinContent(1094, 0.7779632);
  hrf->SetBinContent(1095, 0.7867661);
  hrf->SetBinContent(1096, 0.7944651);
  hrf->SetBinContent(1097, 0.8083544);
  hrf->SetBinContent(1098, 0.8107268);
  hrf->SetBinContent(1099, 0.8189852);
  hrf->SetBinContent(1100, 0.8153532);
  hrf->SetBinContent(1101, 0.8240046);
  hrf->SetBinContent(1102, 0.8384827);
  hrf->SetBinContent(1103, 0.8322271);
  hrf->SetBinContent(1104, 0.8422883);
  hrf->SetBinContent(1105, 0.8423601);
  hrf->SetBinContent(1106, 0.8466352);
  hrf->SetBinContent(1107, 0.8430629);
  hrf->SetBinContent(1108, 0.8358093);
  hrf->SetBinContent(1109, 0.837386);
  hrf->SetBinContent(1110, 0.8362738);
  hrf->SetBinContent(1111, 0.8342865);
  hrf->SetBinContent(1112, 0.8284599);
  hrf->SetBinContent(1113, 0.8158783);
  hrf->SetBinContent(1114, 0.8194523);
  hrf->SetBinContent(1115, 0.8146015);
  hrf->SetBinContent(1116, 0.8001814);
  hrf->SetBinContent(1117, 0.8017688);
  hrf->SetBinContent(1118, 0.7813054);
  hrf->SetBinContent(1119, 0.7750396);
  hrf->SetBinContent(1120, 0.758478);
  hrf->SetBinContent(1121, 0.7584834);
  hrf->SetBinContent(1122, 0.7688718);
  hrf->SetBinContent(1123, 0.787861);
  hrf->SetBinContent(1124, 0.8688133);
  hrf->SetBinContent(1125, 0.8533958);
  hrf->SetBinContent(1126, 0.8537074);
  hrf->SetBinContent(1127, 0.8606731);
  hrf->SetBinContent(1128, 0.8661022);
  hrf->SetBinContent(1129, 0.8672564);
  hrf->SetBinContent(1130, 0.8706612);
  hrf->SetBinContent(1131, 0.8754287);
  hrf->SetBinContent(1132, 0.8721613);
  hrf->SetBinContent(1135, 0.8926414);
  hrf->SetBinContent(1136, 0.8838556);
  hrf->SetBinContent(1137, 0.8809255);
  hrf->SetBinContent(1138, 0.8815078);
  hrf->SetBinContent(1139, 0.8786798);
  hrf->SetBinContent(1140, 0.8731456);
  hrf->SetBinContent(1141, 0.8755729);
  hrf->SetBinContent(1142, 0.8755569);
  hrf->SetBinContent(1143, 0.8917107);
  hrf->SetBinContent(1144, 0.8022393);
  hrf->SetBinContent(1145, 0.7890468);
  hrf->SetBinContent(1146, 0.7707567);
  hrf->SetBinContent(1147, 0.7820282);
  hrf->SetBinContent(1148, 0.797209);
  hrf->SetBinContent(1149, 0.8015469);
  hrf->SetBinContent(1150, 0.7989428);
  hrf->SetBinContent(1151, 0.81494);
  hrf->SetBinContent(1152, 0.8054802);
  hrf->SetBinContent(1153, 0.8292938);
  hrf->SetBinContent(1154, 0.8191403);
  hrf->SetBinContent(1155, 0.8357392);
  hrf->SetBinContent(1156, 0.8420494);
  hrf->SetBinContent(1157, 0.8470226);
  hrf->SetBinContent(1158, 0.8452826);
  hrf->SetBinContent(1159, 0.8380713);
  hrf->SetBinContent(1160, 0.8519661);
  hrf->SetBinContent(1161, 0.8480266);
  hrf->SetBinContent(1162, 0.8431207);
  hrf->SetBinContent(1163, 0.8380831);
  hrf->SetBinContent(1164, 0.8396802);
  hrf->SetBinContent(1165, 0.8437529);
  hrf->SetBinContent(1166, 0.8442971);
  hrf->SetBinContent(1167, 0.8320925);
  hrf->SetBinContent(1168, 0.8239457);
  hrf->SetBinContent(1169, 0.8274932);
  hrf->SetBinContent(1170, 0.8114532);
  hrf->SetBinContent(1171, 0.7998323);
  hrf->SetBinContent(1172, 0.7996237);
  hrf->SetBinContent(1173, 0.792009);
  hrf->SetBinContent(1174, 0.7787869);
  hrf->SetBinContent(1175, 0.7690356);
  hrf->SetBinContent(1176, 0.775647);
  hrf->SetBinContent(1177, 0.814122);
  hrf->SetBinContent(1178, 0.884719);
  hrf->SetBinContent(1179, 0.8670786);
  hrf->SetBinContent(1180, 0.8654112);
  hrf->SetBinContent(1181, 0.8604522);
  hrf->SetBinContent(1182, 0.8731483);
  hrf->SetBinContent(1183, 0.8786311);
  hrf->SetBinContent(1184, 0.8848958);
  hrf->SetBinContent(1185, 0.8810438);
  hrf->SetBinContent(1186, 0.8841771);
  hrf->SetBinContent(1189, 0.8891022);
  hrf->SetBinContent(1190, 0.8870587);
  hrf->SetBinContent(1191, 0.8841472);
  hrf->SetBinContent(1192, 0.8857799);
  hrf->SetBinContent(1193, 0.8845335);
  hrf->SetBinContent(1194, 0.8843443);
  hrf->SetBinContent(1195, 0.8777463);
  hrf->SetBinContent(1196, 0.880188);
  hrf->SetBinContent(1197, 0.8909612);
  hrf->SetBinContent(1198, 0.8178039);
  hrf->SetBinContent(1199, 0.790151);
  hrf->SetBinContent(1200, 0.7816035);
  hrf->SetBinContent(1201, 0.7839964);
  hrf->SetBinContent(1202, 0.7903005);
  hrf->SetBinContent(1203, 0.8072708);
  hrf->SetBinContent(1204, 0.8133928);
  hrf->SetBinContent(1205, 0.8225427);
  hrf->SetBinContent(1206, 0.833207);
  hrf->SetBinContent(1207, 0.8298087);
  hrf->SetBinContent(1208, 0.8389301);
  hrf->SetBinContent(1209, 0.8460385);
  hrf->SetBinContent(1210, 0.8437337);
  hrf->SetBinContent(1211, 0.8557595);
  hrf->SetBinContent(1212, 0.8491873);
  hrf->SetBinContent(1213, 0.8516658);
  hrf->SetBinContent(1214, 0.8624567);
  hrf->SetBinContent(1215, 0.8594553);
  hrf->SetBinContent(1216, 0.8509933);
  hrf->SetBinContent(1217, 0.8471743);
  hrf->SetBinContent(1218, 0.857959);
  hrf->SetBinContent(1219, 0.8493754);
  hrf->SetBinContent(1220, 0.8466064);
  hrf->SetBinContent(1221, 0.8371781);
  hrf->SetBinContent(1222, 0.8358744);
  hrf->SetBinContent(1223, 0.8226563);
  hrf->SetBinContent(1224, 0.8172606);
  hrf->SetBinContent(1225, 0.8109908);
  hrf->SetBinContent(1226, 0.806832);
  hrf->SetBinContent(1227, 0.7952395);
  hrf->SetBinContent(1228, 0.7979003);
  hrf->SetBinContent(1229, 0.7853494);
  hrf->SetBinContent(1230, 0.7877384);
  hrf->SetBinContent(1231, 0.8165073);
  hrf->SetBinContent(1232, 0.8852444);
  hrf->SetBinContent(1233, 0.8795059);
  hrf->SetBinContent(1234, 0.8737102);
  hrf->SetBinContent(1235, 0.8798409);
  hrf->SetBinContent(1236, 0.8834345);
  hrf->SetBinContent(1237, 0.8831002);
  hrf->SetBinContent(1238, 0.8838814);
  hrf->SetBinContent(1239, 0.8873666);
  hrf->SetBinContent(1240, 0.8796175);
  hrf->SetBinContent(1243, 0.8699931);
  hrf->SetBinContent(1244, 0.880556);
  hrf->SetBinContent(1245, 0.8857679);
  hrf->SetBinContent(1246, 0.8867575);
  hrf->SetBinContent(1247, 0.8872436);
  hrf->SetBinContent(1248, 0.8805988);
  hrf->SetBinContent(1249, 0.8760417);
  hrf->SetBinContent(1250, 0.8839202);
  hrf->SetBinContent(1251, 0.8939078);
  hrf->SetBinContent(1252, 0.8196212);
  hrf->SetBinContent(1253, 0.7951305);
  hrf->SetBinContent(1254, 0.7839375);
  hrf->SetBinContent(1255, 0.7964276);
  hrf->SetBinContent(1256, 0.8000515);
  hrf->SetBinContent(1257, 0.8042353);
  hrf->SetBinContent(1258, 0.8224838);
  hrf->SetBinContent(1259, 0.8265044);
  hrf->SetBinContent(1260, 0.842755);
  hrf->SetBinContent(1261, 0.8381351);
  hrf->SetBinContent(1262, 0.8499912);
  hrf->SetBinContent(1263, 0.8451387);
  hrf->SetBinContent(1264, 0.8538584);
  hrf->SetBinContent(1265, 0.8548691);
  hrf->SetBinContent(1266, 0.8640006);
  hrf->SetBinContent(1267, 0.8592045);
  hrf->SetBinContent(1268, 0.8652804);
  hrf->SetBinContent(1269, 0.8636556);
  hrf->SetBinContent(1270, 0.8597942);
  hrf->SetBinContent(1271, 0.8495367);
  hrf->SetBinContent(1272, 0.8544548);
  hrf->SetBinContent(1273, 0.8598359);
  hrf->SetBinContent(1274, 0.8494906);
  hrf->SetBinContent(1275, 0.8489674);
  hrf->SetBinContent(1276, 0.8405565);
  hrf->SetBinContent(1277, 0.8359114);
  hrf->SetBinContent(1278, 0.8236802);
  hrf->SetBinContent(1279, 0.8239701);
  hrf->SetBinContent(1280, 0.8109244);
  hrf->SetBinContent(1281, 0.8064739);
  hrf->SetBinContent(1282, 0.7994598);
  hrf->SetBinContent(1283, 0.7857624);
  hrf->SetBinContent(1284, 0.7976);
  hrf->SetBinContent(1285, 0.817425);
  hrf->SetBinContent(1286, 0.8980819);
  hrf->SetBinContent(1287, 0.8794962);
  hrf->SetBinContent(1288, 0.8744811);
  hrf->SetBinContent(1289, 0.8777318);
  hrf->SetBinContent(1290, 0.8769578);
  hrf->SetBinContent(1291, 0.8837912);
  hrf->SetBinContent(1292, 0.8830451);
  hrf->SetBinContent(1293, 0.8832207);
  hrf->SetBinContent(1294, 0.8726093);
  hrf->SetBinContent(1297, 0.8833746);
  hrf->SetBinContent(1298, 0.8892896);
  hrf->SetBinContent(1299, 0.8946407);
  hrf->SetBinContent(1300, 0.886827);
  hrf->SetBinContent(1301, 0.8873971);
  hrf->SetBinContent(1302, 0.8878529);
  hrf->SetBinContent(1303, 0.8882861);
  hrf->SetBinContent(1304, 0.8945645);
  hrf->SetBinContent(1305, 0.9100397);
  hrf->SetBinContent(1306, 0.8372028);
  hrf->SetBinContent(1307, 0.8102537);
  hrf->SetBinContent(1308, 0.8034006);
  hrf->SetBinContent(1309, 0.8103142);
  hrf->SetBinContent(1310, 0.809669);
  hrf->SetBinContent(1311, 0.8221305);
  hrf->SetBinContent(1312, 0.8360682);
  hrf->SetBinContent(1313, 0.8428956);
  hrf->SetBinContent(1314, 0.8529904);
  hrf->SetBinContent(1315, 0.8403449);
  hrf->SetBinContent(1316, 0.847197);
  hrf->SetBinContent(1317, 0.8571557);
  hrf->SetBinContent(1318, 0.8633579);
  hrf->SetBinContent(1319, 0.8623986);
  hrf->SetBinContent(1320, 0.8692189);
  hrf->SetBinContent(1321, 0.8681874);
  hrf->SetBinContent(1322, 0.8733714);
  hrf->SetBinContent(1323, 0.8649191);
  hrf->SetBinContent(1324, 0.8690168);
  hrf->SetBinContent(1325, 0.8687195);
  hrf->SetBinContent(1326, 0.8682766);
  hrf->SetBinContent(1327, 0.8630986);
  hrf->SetBinContent(1328, 0.8554676);
  hrf->SetBinContent(1329, 0.8457834);
  hrf->SetBinContent(1330, 0.8468786);
  hrf->SetBinContent(1331, 0.8466587);
  hrf->SetBinContent(1332, 0.8327401);
  hrf->SetBinContent(1333, 0.8289707);
  hrf->SetBinContent(1334, 0.8209063);
  hrf->SetBinContent(1335, 0.8148324);
  hrf->SetBinContent(1336, 0.8016603);
  hrf->SetBinContent(1337, 0.8032823);
  hrf->SetBinContent(1338, 0.8121458);
  hrf->SetBinContent(1339, 0.8311667);
  hrf->SetBinContent(1340, 0.9000667);
  hrf->SetBinContent(1341, 0.8870225);
  hrf->SetBinContent(1342, 0.8807783);
  hrf->SetBinContent(1343, 0.8867585);
  hrf->SetBinContent(1344, 0.887088);
  hrf->SetBinContent(1345, 0.8945184);
  hrf->SetBinContent(1346, 0.8915095);
  hrf->SetBinContent(1347, 0.8958459);
  hrf->SetBinContent(1348, 0.8770605);
  hrf->SetBinContent(1351, 0.9107674);
  hrf->SetBinContent(1352, 0.901845);
  hrf->SetBinContent(1353, 0.9046344);
  hrf->SetBinContent(1354, 0.9028492);
  hrf->SetBinContent(1355, 0.9029417);
  hrf->SetBinContent(1356, 0.9025894);
  hrf->SetBinContent(1357, 0.9009511);
  hrf->SetBinContent(1358, 0.9044149);
  hrf->SetBinContent(1359, 0.9154013);
  hrf->SetBinContent(1360, 0.8367298);
  hrf->SetBinContent(1361, 0.8242673);
  hrf->SetBinContent(1362, 0.8122698);
  hrf->SetBinContent(1363, 0.8129655);
  hrf->SetBinContent(1364, 0.8246857);
  hrf->SetBinContent(1365, 0.8306041);
  hrf->SetBinContent(1366, 0.8359771);
  hrf->SetBinContent(1367, 0.8536226);
  hrf->SetBinContent(1368, 0.8658685);
  hrf->SetBinContent(1369, 0.866558);
  hrf->SetBinContent(1370, 0.8651952);
  hrf->SetBinContent(1371, 0.8684635);
  hrf->SetBinContent(1372, 0.8754547);
  hrf->SetBinContent(1373, 0.8689093);
  hrf->SetBinContent(1374, 0.8794907);
  hrf->SetBinContent(1375, 0.8772472);
  hrf->SetBinContent(1376, 0.8768589);
  hrf->SetBinContent(1377, 0.8863833);
  hrf->SetBinContent(1378, 0.8752023);
  hrf->SetBinContent(1379, 0.8694621);
  hrf->SetBinContent(1380, 0.8833391);
  hrf->SetBinContent(1381, 0.8768603);
  hrf->SetBinContent(1382, 0.869158);
  hrf->SetBinContent(1383, 0.8667737);
  hrf->SetBinContent(1384, 0.8611507);
  hrf->SetBinContent(1385, 0.8608423);
  hrf->SetBinContent(1386, 0.8516886);
  hrf->SetBinContent(1387, 0.8415661);
  hrf->SetBinContent(1388, 0.8409142);
  hrf->SetBinContent(1389, 0.8235896);
  hrf->SetBinContent(1390, 0.8184434);
  hrf->SetBinContent(1391, 0.8097028);
  hrf->SetBinContent(1392, 0.8229869);
  hrf->SetBinContent(1393, 0.8520653);
  hrf->SetBinContent(1394, 0.91498);
  hrf->SetBinContent(1395, 0.9005948);
  hrf->SetBinContent(1396, 0.8929456);
  hrf->SetBinContent(1397, 0.8981298);
  hrf->SetBinContent(1398, 0.903121);
  hrf->SetBinContent(1399, 0.9075835);
  hrf->SetBinContent(1400, 0.9140153);
  hrf->SetBinContent(1401, 0.9101715);
  hrf->SetBinContent(1402, 0.911872);
  hrf->SetBinContent(1405, 0.9039399);
  hrf->SetBinContent(1406, 0.9063057);
  hrf->SetBinContent(1407, 0.9046811);
  hrf->SetBinContent(1408, 0.9110272);
  hrf->SetBinContent(1409, 0.9117368);
  hrf->SetBinContent(1410, 0.9076403);
  hrf->SetBinContent(1411, 0.9033728);
  hrf->SetBinContent(1412, 0.908191);
  hrf->SetBinContent(1413, 0.9208092);
  hrf->SetBinContent(1414, 0.8550934);
  hrf->SetBinContent(1415, 0.8329291);
  hrf->SetBinContent(1416, 0.8214185);
  hrf->SetBinContent(1417, 0.8256217);
  hrf->SetBinContent(1418, 0.8495316);
  hrf->SetBinContent(1419, 0.8494883);
  hrf->SetBinContent(1420, 0.8567852);
  hrf->SetBinContent(1421, 0.8572022);
  hrf->SetBinContent(1422, 0.8683975);
  hrf->SetBinContent(1423, 0.8678761);
  hrf->SetBinContent(1424, 0.8731164);
  hrf->SetBinContent(1425, 0.8683652);
  hrf->SetBinContent(1426, 0.8794419);
  hrf->SetBinContent(1427, 0.8815932);
  hrf->SetBinContent(1428, 0.8864079);
  hrf->SetBinContent(1429, 0.8836783);
  hrf->SetBinContent(1430, 0.8894901);
  hrf->SetBinContent(1431, 0.8901763);
  hrf->SetBinContent(1432, 0.8808558);
  hrf->SetBinContent(1433, 0.8784434);
  hrf->SetBinContent(1434, 0.8785816);
  hrf->SetBinContent(1435, 0.8881973);
  hrf->SetBinContent(1436, 0.8753826);
  hrf->SetBinContent(1437, 0.8633127);
  hrf->SetBinContent(1438, 0.8630874);
  hrf->SetBinContent(1439, 0.8581874);
  hrf->SetBinContent(1440, 0.8548054);
  hrf->SetBinContent(1441, 0.8631837);
  hrf->SetBinContent(1442, 0.8439391);
  hrf->SetBinContent(1443, 0.83869);
  hrf->SetBinContent(1444, 0.8351945);
  hrf->SetBinContent(1445, 0.8259542);
  hrf->SetBinContent(1446, 0.8348157);
  hrf->SetBinContent(1447, 0.8657665);
  hrf->SetBinContent(1448, 0.919937);
  hrf->SetBinContent(1449, 0.9106402);
  hrf->SetBinContent(1450, 0.9066347);
  hrf->SetBinContent(1451, 0.9057992);
  hrf->SetBinContent(1452, 0.9104689);
  hrf->SetBinContent(1453, 0.9105675);
  hrf->SetBinContent(1454, 0.917769);
  hrf->SetBinContent(1455, 0.9100168);
  hrf->SetBinContent(1456, 0.9122199);
  hrf->SetBinContent(1459, 0.8731261);
  hrf->SetBinContent(1460, 0.8929094);
  hrf->SetBinContent(1461, 0.9041327);
  hrf->SetBinContent(1462, 0.9131415);
  hrf->SetBinContent(1463, 0.9066501);
  hrf->SetBinContent(1464, 0.907663);
  hrf->SetBinContent(1465, 0.9030681);
  hrf->SetBinContent(1466, 0.9116143);
  hrf->SetBinContent(1467, 0.924934);
  hrf->SetBinContent(1468, 0.8582804);
  hrf->SetBinContent(1469, 0.8448771);
  hrf->SetBinContent(1470, 0.8322512);
  hrf->SetBinContent(1471, 0.8413401);
  hrf->SetBinContent(1472, 0.8452342);
  hrf->SetBinContent(1473, 0.8499962);
  hrf->SetBinContent(1474, 0.8578755);
  hrf->SetBinContent(1475, 0.870818);
  hrf->SetBinContent(1476, 0.8684161);
  hrf->SetBinContent(1477, 0.8717569);
  hrf->SetBinContent(1478, 0.8661126);
  hrf->SetBinContent(1479, 0.8748658);
  hrf->SetBinContent(1480, 0.8945366);
  hrf->SetBinContent(1481, 0.887479);
  hrf->SetBinContent(1482, 0.8910479);
  hrf->SetBinContent(1483, 0.8878255);
  hrf->SetBinContent(1484, 0.8889695);
  hrf->SetBinContent(1485, 0.8869578);
  hrf->SetBinContent(1486, 0.8927147);
  hrf->SetBinContent(1487, 0.893798);
  hrf->SetBinContent(1488, 0.889362);
  hrf->SetBinContent(1489, 0.8875631);
  hrf->SetBinContent(1490, 0.890229);
  hrf->SetBinContent(1491, 0.8816059);
  hrf->SetBinContent(1492, 0.8668377);
  hrf->SetBinContent(1493, 0.869731);
  hrf->SetBinContent(1494, 0.8621845);
  hrf->SetBinContent(1495, 0.8679706);
  hrf->SetBinContent(1496, 0.8502749);
  hrf->SetBinContent(1497, 0.8427823);
  hrf->SetBinContent(1498, 0.8440582);
  hrf->SetBinContent(1499, 0.8246489);
  hrf->SetBinContent(1500, 0.838813);
  hrf->SetBinContent(1501, 0.8574219);
  hrf->SetBinContent(1502, 0.9263051);
  hrf->SetBinContent(1503, 0.9140279);
  hrf->SetBinContent(1504, 0.9136851);
  hrf->SetBinContent(1505, 0.9010017);
  hrf->SetBinContent(1506, 0.9108002);
  hrf->SetBinContent(1507, 0.9104546);
  hrf->SetBinContent(1508, 0.9128228);
  hrf->SetBinContent(1509, 0.8955492);
  hrf->SetBinContent(1510, 0.895875);
  hrf->SetBinContent(1513, 0.8521476);
  hrf->SetBinContent(1514, 0.8678765);
  hrf->SetBinContent(1515, 0.8819187);
  hrf->SetBinContent(1516, 0.8971331);
  hrf->SetBinContent(1517, 0.8997292);
  hrf->SetBinContent(1518, 0.9004843);
  hrf->SetBinContent(1519, 0.9072738);
  hrf->SetBinContent(1520, 0.9154096);
  hrf->SetBinContent(1521, 0.9255536);
  hrf->SetBinContent(1522, 0.8642027);
  hrf->SetBinContent(1523, 0.8448632);
  hrf->SetBinContent(1524, 0.8316462);
  hrf->SetBinContent(1525, 0.8349957);
  hrf->SetBinContent(1526, 0.8407539);
  hrf->SetBinContent(1527, 0.850341);
  hrf->SetBinContent(1528, 0.8542346);
  hrf->SetBinContent(1529, 0.8641542);
  hrf->SetBinContent(1530, 0.8824866);
  hrf->SetBinContent(1531, 0.875233);
  hrf->SetBinContent(1532, 0.8747888);
  hrf->SetBinContent(1533, 0.8876879);
  hrf->SetBinContent(1534, 0.8921785);
  hrf->SetBinContent(1535, 0.8959677);
  hrf->SetBinContent(1536, 0.8927501);
  hrf->SetBinContent(1537, 0.8898901);
  hrf->SetBinContent(1538, 0.8942666);
  hrf->SetBinContent(1539, 0.892297);
  hrf->SetBinContent(1540, 0.8892371);
  hrf->SetBinContent(1541, 0.892962);
  hrf->SetBinContent(1542, 0.8810925);
  hrf->SetBinContent(1543, 0.8918186);
  hrf->SetBinContent(1544, 0.8845227);
  hrf->SetBinContent(1545, 0.8848883);
  hrf->SetBinContent(1546, 0.8825886);
  hrf->SetBinContent(1547, 0.8737018);
  hrf->SetBinContent(1548, 0.8694548);
  hrf->SetBinContent(1549, 0.8615527);
  hrf->SetBinContent(1550, 0.8557075);
  hrf->SetBinContent(1551, 0.8527821);
  hrf->SetBinContent(1552, 0.8239888);
  hrf->SetBinContent(1553, 0.8215376);
  hrf->SetBinContent(1554, 0.8346367);
  hrf->SetBinContent(1555, 0.8683265);
  hrf->SetBinContent(1556, 0.9221479);
  hrf->SetBinContent(1557, 0.9117818);
  hrf->SetBinContent(1558, 0.9093716);
  hrf->SetBinContent(1559, 0.9003564);
  hrf->SetBinContent(1560, 0.8994485);
  hrf->SetBinContent(1561, 0.8900582);
  hrf->SetBinContent(1562, 0.8851296);
  hrf->SetBinContent(1563, 0.8711704);
  hrf->SetBinContent(1564, 0.8568475);

  return hrf;
}

getResponseFunction_mode()

TH2D * TCMETAlgo::getResponseFunction_mode

(

)

Definition at line 4995 of file TCMETAlgo.cc.

Referenced by configure(), and cms::MuonTCMETValueMapProducer::MuonTCMETValueMapProducer().

                                          {
  // single pion response function from mode

  Double_t xAxis2[53] = {-2.5,   -2.322, -2.172, -2.043, -1.93,  -1.83,  -1.74,  -1.653, -1.566, -1.479, -1.392,
                         -1.305, -1.218, -1.131, -1.044, -0.957, -0.879, -0.783, -0.696, -0.609, -0.522, -0.435,
                         -0.348, -0.261, -0.174, -0.087, 0,      0.087,  0.174,  0.261,  0.348,  0.435,  0.522,
                         0.609,  0.696,  0.783,  0.879,  0.957,  1.044,  1.131,  1.218,  1.305,  1.392,  1.479,
                         1.566,  1.653,  1.74,   1.83,   1.93,   2.043,  2.172,  2.322,  2.5};

  Double_t yAxis2[29] = {0,  0.5, 1,  1.5, 2,  3,  4,  5,  6,  7,  8,  9,  10, 12, 14,
                         16, 18,  20, 25,  30, 35, 40, 45, 50, 60, 70, 80, 90, 100};

  TH2D* hrf = new TH2D("hrf", "RF  (mode)", 52, xAxis2, 28, yAxis2);

  hrf->SetBinContent(163, 0.5);
  hrf->SetBinContent(164, 0.58);
  hrf->SetBinContent(165, 0.62);
  hrf->SetBinContent(166, 0.54);
  hrf->SetBinContent(167, 0.46);
  hrf->SetBinContent(168, 0.14);
  hrf->SetBinContent(169, 0.14);
  hrf->SetBinContent(170, 0.02);
  hrf->SetBinContent(171, 0.02);
  hrf->SetBinContent(172, 0.02);
  hrf->SetBinContent(173, 0.02);
  hrf->SetBinContent(174, 0.02);
  hrf->SetBinContent(175, 0.02);
  hrf->SetBinContent(176, 0.02);
  hrf->SetBinContent(177, 0.02);
  hrf->SetBinContent(178, 0.02);
  hrf->SetBinContent(179, 0.02);
  hrf->SetBinContent(180, 0.02);
  hrf->SetBinContent(181, 0.02);
  hrf->SetBinContent(182, 0.02);
  hrf->SetBinContent(183, 0.02);
  hrf->SetBinContent(184, 0.02);
  hrf->SetBinContent(185, 0.02);
  hrf->SetBinContent(186, 0.02);
  hrf->SetBinContent(187, 0.02);
  hrf->SetBinContent(188, 0.02);
  hrf->SetBinContent(189, 0.02);
  hrf->SetBinContent(190, 0.02);
  hrf->SetBinContent(191, 0.02);
  hrf->SetBinContent(192, 0.02);
  hrf->SetBinContent(193, 0.02);
  hrf->SetBinContent(194, 0.02);
  hrf->SetBinContent(195, 0.02);
  hrf->SetBinContent(196, 0.02);
  hrf->SetBinContent(197, 0.02);
  hrf->SetBinContent(198, 0.02);
  hrf->SetBinContent(199, 0.02);
  hrf->SetBinContent(200, 0.02);
  hrf->SetBinContent(201, 0.02);
  hrf->SetBinContent(202, 0.02);
  hrf->SetBinContent(203, 0.02);
  hrf->SetBinContent(204, 0.02);
  hrf->SetBinContent(205, 0.02);
  hrf->SetBinContent(206, 0.02);
  hrf->SetBinContent(207, 0.02);
  hrf->SetBinContent(208, 0.02);
  hrf->SetBinContent(209, 0.02);
  hrf->SetBinContent(210, 0.14);
  hrf->SetBinContent(211, 0.1);
  hrf->SetBinContent(212, 0.34);
  hrf->SetBinContent(213, 0.34);
  hrf->SetBinContent(214, 0.38);
  hrf->SetBinContent(217, 0.5);
  hrf->SetBinContent(218, 0.54);
  hrf->SetBinContent(219, 0.5);
  hrf->SetBinContent(220, 0.58);
  hrf->SetBinContent(221, 0.46);
  hrf->SetBinContent(222, 0.5);
  hrf->SetBinContent(223, 0.1);
  hrf->SetBinContent(224, 0.22);
  hrf->SetBinContent(225, 0.02);
  hrf->SetBinContent(226, 0.02);
  hrf->SetBinContent(227, 0.02);
  hrf->SetBinContent(228, 0.02);
  hrf->SetBinContent(229, 0.02);
  hrf->SetBinContent(230, 0.02);
  hrf->SetBinContent(231, 0.02);
  hrf->SetBinContent(232, 0.02);
  hrf->SetBinContent(233, 0.02);
  hrf->SetBinContent(234, 0.02);
  hrf->SetBinContent(235, 0.02);
  hrf->SetBinContent(236, 0.02);
  hrf->SetBinContent(237, 0.02);
  hrf->SetBinContent(238, 0.02);
  hrf->SetBinContent(239, 0.02);
  hrf->SetBinContent(240, 0.02);
  hrf->SetBinContent(241, 0.02);
  hrf->SetBinContent(242, 0.02);
  hrf->SetBinContent(243, 0.02);
  hrf->SetBinContent(244, 0.02);
  hrf->SetBinContent(245, 0.02);
  hrf->SetBinContent(246, 0.02);
  hrf->SetBinContent(247, 0.02);
  hrf->SetBinContent(248, 0.02);
  hrf->SetBinContent(249, 0.02);
  hrf->SetBinContent(250, 0.02);
  hrf->SetBinContent(251, 0.02);
  hrf->SetBinContent(252, 0.02);
  hrf->SetBinContent(253, 0.02);
  hrf->SetBinContent(254, 0.02);
  hrf->SetBinContent(255, 0.02);
  hrf->SetBinContent(256, 0.02);
  hrf->SetBinContent(257, 0.02);
  hrf->SetBinContent(258, 0.02);
  hrf->SetBinContent(259, 0.02);
  hrf->SetBinContent(260, 0.02);
  hrf->SetBinContent(261, 0.02);
  hrf->SetBinContent(262, 0.1);
  hrf->SetBinContent(263, 0.1);
  hrf->SetBinContent(264, 0.18);
  hrf->SetBinContent(265, 0.38);
  hrf->SetBinContent(266, 0.38);
  hrf->SetBinContent(267, 0.42);
  hrf->SetBinContent(268, 0.38);
  hrf->SetBinContent(271, 0.5);
  hrf->SetBinContent(272, 0.58);
  hrf->SetBinContent(273, 0.58);
  hrf->SetBinContent(274, 0.58);
  hrf->SetBinContent(275, 0.42);
  hrf->SetBinContent(276, 0.42);
  hrf->SetBinContent(277, 0.38);
  hrf->SetBinContent(278, 0.38);
  hrf->SetBinContent(279, 0.18);
  hrf->SetBinContent(280, 0.38);
  hrf->SetBinContent(281, 0.38);
  hrf->SetBinContent(282, 0.3);
  hrf->SetBinContent(283, 0.3);
  hrf->SetBinContent(284, 0.06);
  hrf->SetBinContent(285, 0.06);
  hrf->SetBinContent(286, 0.02);
  hrf->SetBinContent(287, 0.02);
  hrf->SetBinContent(288, 0.3);
  hrf->SetBinContent(289, 0.02);
  hrf->SetBinContent(290, 0.02);
  hrf->SetBinContent(291, 0.02);
  hrf->SetBinContent(292, 0.02);
  hrf->SetBinContent(293, 0.02);
  hrf->SetBinContent(294, 0.02);
  hrf->SetBinContent(295, 0.02);
  hrf->SetBinContent(296, 0.02);
  hrf->SetBinContent(297, 0.02);
  hrf->SetBinContent(298, 0.02);
  hrf->SetBinContent(299, 0.02);
  hrf->SetBinContent(300, 0.02);
  hrf->SetBinContent(301, 0.02);
  hrf->SetBinContent(302, 0.02);
  hrf->SetBinContent(303, 0.02);
  hrf->SetBinContent(304, 0.02);
  hrf->SetBinContent(305, 0.02);
  hrf->SetBinContent(306, 0.02);
  hrf->SetBinContent(307, 0.02);
  hrf->SetBinContent(308, 0.02);
  hrf->SetBinContent(309, 0.02);
  hrf->SetBinContent(310, 0.02);
  hrf->SetBinContent(311, 0.3);
  hrf->SetBinContent(312, 0.06);
  hrf->SetBinContent(313, 0.02);
  hrf->SetBinContent(314, 0.02);
  hrf->SetBinContent(315, 0.3);
  hrf->SetBinContent(316, 0.18);
  hrf->SetBinContent(317, 0.26);
  hrf->SetBinContent(318, 0.22);
  hrf->SetBinContent(319, 0.34);
  hrf->SetBinContent(320, 0.38);
  hrf->SetBinContent(321, 0.5);
  hrf->SetBinContent(322, 0.38);
  hrf->SetBinContent(325, 0.66);
  hrf->SetBinContent(326, 0.54);
  hrf->SetBinContent(327, 0.58);
  hrf->SetBinContent(328, 0.5);
  hrf->SetBinContent(329, 0.38);
  hrf->SetBinContent(330, 0.58);
  hrf->SetBinContent(331, 0.42);
  hrf->SetBinContent(332, 0.38);
  hrf->SetBinContent(333, 0.38);
  hrf->SetBinContent(334, 0.3);
  hrf->SetBinContent(335, 0.3);
  hrf->SetBinContent(336, 0.38);
  hrf->SetBinContent(337, 0.3);
  hrf->SetBinContent(338, 0.3);
  hrf->SetBinContent(339, 0.34);
  hrf->SetBinContent(340, 0.3);
  hrf->SetBinContent(341, 0.26);
  hrf->SetBinContent(342, 0.3);
  hrf->SetBinContent(343, 0.34);
  hrf->SetBinContent(344, 0.34);
  hrf->SetBinContent(345, 0.34);
  hrf->SetBinContent(346, 0.3);
  hrf->SetBinContent(347, 0.46);
  hrf->SetBinContent(348, 0.34);
  hrf->SetBinContent(349, 0.38);
  hrf->SetBinContent(350, 0.38);
  hrf->SetBinContent(351, 0.3);
  hrf->SetBinContent(352, 0.34);
  hrf->SetBinContent(353, 0.34);
  hrf->SetBinContent(354, 0.34);
  hrf->SetBinContent(355, 0.38);
  hrf->SetBinContent(356, 0.3);
  hrf->SetBinContent(357, 0.3);
  hrf->SetBinContent(358, 0.34);
  hrf->SetBinContent(359, 0.34);
  hrf->SetBinContent(360, 0.34);
  hrf->SetBinContent(361, 0.34);
  hrf->SetBinContent(362, 0.26);
  hrf->SetBinContent(363, 0.38);
  hrf->SetBinContent(364, 0.3);
  hrf->SetBinContent(365, 0.3);
  hrf->SetBinContent(366, 0.26);
  hrf->SetBinContent(367, 0.3);
  hrf->SetBinContent(368, 0.26);
  hrf->SetBinContent(369, 0.3);
  hrf->SetBinContent(370, 0.34);
  hrf->SetBinContent(371, 0.5);
  hrf->SetBinContent(372, 0.46);
  hrf->SetBinContent(373, 0.46);
  hrf->SetBinContent(374, 0.42);
  hrf->SetBinContent(375, 0.54);
  hrf->SetBinContent(376, 0.5);
  hrf->SetBinContent(379, 0.74);
  hrf->SetBinContent(380, 0.66);
  hrf->SetBinContent(381, 0.74);
  hrf->SetBinContent(382, 0.62);
  hrf->SetBinContent(383, 0.54);
  hrf->SetBinContent(384, 0.46);
  hrf->SetBinContent(385, 0.46);
  hrf->SetBinContent(386, 0.38);
  hrf->SetBinContent(387, 0.34);
  hrf->SetBinContent(388, 0.42);
  hrf->SetBinContent(389, 0.46);
  hrf->SetBinContent(390, 0.38);
  hrf->SetBinContent(391, 0.42);
  hrf->SetBinContent(392, 0.34);
  hrf->SetBinContent(393, 0.42);
  hrf->SetBinContent(394, 0.46);
  hrf->SetBinContent(395, 0.38);
  hrf->SetBinContent(396, 0.38);
  hrf->SetBinContent(397, 0.5);
  hrf->SetBinContent(398, 0.38);
  hrf->SetBinContent(399, 0.42);
  hrf->SetBinContent(400, 0.5);
  hrf->SetBinContent(401, 0.38);
  hrf->SetBinContent(402, 0.46);
  hrf->SetBinContent(403, 0.42);
  hrf->SetBinContent(404, 0.46);
  hrf->SetBinContent(405, 0.38);
  hrf->SetBinContent(406, 0.42);
  hrf->SetBinContent(407, 0.46);
  hrf->SetBinContent(408, 0.46);
  hrf->SetBinContent(409, 0.46);
  hrf->SetBinContent(410, 0.34);
  hrf->SetBinContent(411, 0.46);
  hrf->SetBinContent(412, 0.46);
  hrf->SetBinContent(413, 0.46);
  hrf->SetBinContent(414, 0.46);
  hrf->SetBinContent(415, 0.34);
  hrf->SetBinContent(416, 0.46);
  hrf->SetBinContent(417, 0.42);
  hrf->SetBinContent(418, 0.3);
  hrf->SetBinContent(419, 0.46);
  hrf->SetBinContent(420, 0.42);
  hrf->SetBinContent(421, 0.38);
  hrf->SetBinContent(422, 0.38);
  hrf->SetBinContent(423, 0.5);
  hrf->SetBinContent(424, 0.38);
  hrf->SetBinContent(425, 0.46);
  hrf->SetBinContent(426, 0.5);
  hrf->SetBinContent(427, 0.58);
  hrf->SetBinContent(428, 0.5);
  hrf->SetBinContent(429, 0.54);
  hrf->SetBinContent(430, 0.62);
  hrf->SetBinContent(433, 0.74);
  hrf->SetBinContent(434, 0.74);
  hrf->SetBinContent(435, 0.74);
  hrf->SetBinContent(436, 0.66);
  hrf->SetBinContent(437, 0.58);
  hrf->SetBinContent(438, 0.62);
  hrf->SetBinContent(439, 0.54);
  hrf->SetBinContent(440, 0.54);
  hrf->SetBinContent(441, 0.46);
  hrf->SetBinContent(442, 0.42);
  hrf->SetBinContent(443, 0.46);
  hrf->SetBinContent(444, 0.46);
  hrf->SetBinContent(445, 0.34);
  hrf->SetBinContent(446, 0.42);
  hrf->SetBinContent(447, 0.38);
  hrf->SetBinContent(448, 0.46);
  hrf->SetBinContent(449, 0.38);
  hrf->SetBinContent(450, 0.38);
  hrf->SetBinContent(451, 0.5);
  hrf->SetBinContent(452, 0.42);
  hrf->SetBinContent(453, 0.46);
  hrf->SetBinContent(454, 0.54);
  hrf->SetBinContent(455, 0.5);
  hrf->SetBinContent(456, 0.54);
  hrf->SetBinContent(457, 0.46);
  hrf->SetBinContent(458, 0.5);
  hrf->SetBinContent(459, 0.46);
  hrf->SetBinContent(460, 0.5);
  hrf->SetBinContent(461, 0.42);
  hrf->SetBinContent(462, 0.46);
  hrf->SetBinContent(463, 0.5);
  hrf->SetBinContent(464, 0.42);
  hrf->SetBinContent(465, 0.42);
  hrf->SetBinContent(466, 0.42);
  hrf->SetBinContent(467, 0.46);
  hrf->SetBinContent(468, 0.38);
  hrf->SetBinContent(469, 0.5);
  hrf->SetBinContent(470, 0.38);
  hrf->SetBinContent(471, 0.46);
  hrf->SetBinContent(472, 0.42);
  hrf->SetBinContent(473, 0.46);
  hrf->SetBinContent(474, 0.46);
  hrf->SetBinContent(475, 0.34);
  hrf->SetBinContent(476, 0.34);
  hrf->SetBinContent(477, 0.5);
  hrf->SetBinContent(478, 0.42);
  hrf->SetBinContent(479, 0.5);
  hrf->SetBinContent(480, 0.54);
  hrf->SetBinContent(481, 0.62);
  hrf->SetBinContent(482, 0.58);
  hrf->SetBinContent(483, 0.66);
  hrf->SetBinContent(484, 0.74);
  hrf->SetBinContent(487, 0.82);
  hrf->SetBinContent(488, 0.7);
  hrf->SetBinContent(489, 0.66);
  hrf->SetBinContent(490, 0.74);
  hrf->SetBinContent(491, 0.7);
  hrf->SetBinContent(492, 0.62);
  hrf->SetBinContent(493, 0.62);
  hrf->SetBinContent(494, 0.5);
  hrf->SetBinContent(495, 0.46);
  hrf->SetBinContent(496, 0.5);
  hrf->SetBinContent(497, 0.5);
  hrf->SetBinContent(498, 0.46);
  hrf->SetBinContent(499, 0.5);
  hrf->SetBinContent(500, 0.5);
  hrf->SetBinContent(501, 0.42);
  hrf->SetBinContent(502, 0.38);
  hrf->SetBinContent(503, 0.42);
  hrf->SetBinContent(504, 0.5);
  hrf->SetBinContent(505, 0.5);
  hrf->SetBinContent(506, 0.42);
  hrf->SetBinContent(507, 0.5);
  hrf->SetBinContent(508, 0.38);
  hrf->SetBinContent(509, 0.54);
  hrf->SetBinContent(510, 0.46);
  hrf->SetBinContent(511, 0.54);
  hrf->SetBinContent(512, 0.42);
  hrf->SetBinContent(513, 0.5);
  hrf->SetBinContent(514, 0.46);
  hrf->SetBinContent(515, 0.42);
  hrf->SetBinContent(516, 0.5);
  hrf->SetBinContent(517, 0.46);
  hrf->SetBinContent(518, 0.42);
  hrf->SetBinContent(519, 0.42);
  hrf->SetBinContent(520, 0.54);
  hrf->SetBinContent(521, 0.42);
  hrf->SetBinContent(522, 0.5);
  hrf->SetBinContent(523, 0.46);
  hrf->SetBinContent(524, 0.46);
  hrf->SetBinContent(525, 0.38);
  hrf->SetBinContent(526, 0.5);
  hrf->SetBinContent(527, 0.5);
  hrf->SetBinContent(528, 0.38);
  hrf->SetBinContent(529, 0.46);
  hrf->SetBinContent(530, 0.5);
  hrf->SetBinContent(531, 0.42);
  hrf->SetBinContent(532, 0.5);
  hrf->SetBinContent(533, 0.58);
  hrf->SetBinContent(534, 0.58);
  hrf->SetBinContent(535, 0.66);
  hrf->SetBinContent(536, 0.7);
  hrf->SetBinContent(537, 0.66);
  hrf->SetBinContent(538, 0.7);
  hrf->SetBinContent(541, 0.74);
  hrf->SetBinContent(542, 0.74);
  hrf->SetBinContent(543, 0.74);
  hrf->SetBinContent(544, 0.66);
  hrf->SetBinContent(545, 0.74);
  hrf->SetBinContent(546, 0.66);
  hrf->SetBinContent(547, 0.58);
  hrf->SetBinContent(548, 0.58);
  hrf->SetBinContent(549, 0.54);
  hrf->SetBinContent(550, 0.5);
  hrf->SetBinContent(551, 0.54);
  hrf->SetBinContent(552, 0.54);
  hrf->SetBinContent(553, 0.46);
  hrf->SetBinContent(554, 0.42);
  hrf->SetBinContent(555, 0.46);
  hrf->SetBinContent(556, 0.54);
  hrf->SetBinContent(557, 0.5);
  hrf->SetBinContent(558, 0.54);
  hrf->SetBinContent(559, 0.46);
  hrf->SetBinContent(560, 0.42);
  hrf->SetBinContent(561, 0.5);
  hrf->SetBinContent(562, 0.5);
  hrf->SetBinContent(563, 0.62);
  hrf->SetBinContent(564, 0.5);
  hrf->SetBinContent(565, 0.62);
  hrf->SetBinContent(566, 0.42);
  hrf->SetBinContent(567, 0.46);
  hrf->SetBinContent(568, 0.5);
  hrf->SetBinContent(569, 0.5);
  hrf->SetBinContent(570, 0.5);
  hrf->SetBinContent(571, 0.5);
  hrf->SetBinContent(572, 0.58);
  hrf->SetBinContent(573, 0.42);
  hrf->SetBinContent(574, 0.46);
  hrf->SetBinContent(575, 0.58);
  hrf->SetBinContent(576, 0.42);
  hrf->SetBinContent(577, 0.46);
  hrf->SetBinContent(578, 0.5);
  hrf->SetBinContent(579, 0.5);
  hrf->SetBinContent(580, 0.46);
  hrf->SetBinContent(581, 0.42);
  hrf->SetBinContent(582, 0.5);
  hrf->SetBinContent(583, 0.46);
  hrf->SetBinContent(584, 0.5);
  hrf->SetBinContent(585, 0.58);
  hrf->SetBinContent(586, 0.58);
  hrf->SetBinContent(587, 0.62);
  hrf->SetBinContent(588, 0.7);
  hrf->SetBinContent(589, 0.66);
  hrf->SetBinContent(590, 0.7);
  hrf->SetBinContent(591, 0.7);
  hrf->SetBinContent(592, 0.7);
  hrf->SetBinContent(595, 0.74);
  hrf->SetBinContent(596, 0.74);
  hrf->SetBinContent(597, 0.7);
  hrf->SetBinContent(598, 0.78);
  hrf->SetBinContent(599, 0.7);
  hrf->SetBinContent(600, 0.7);
  hrf->SetBinContent(601, 0.66);
  hrf->SetBinContent(602, 0.54);
  hrf->SetBinContent(603, 0.7);
  hrf->SetBinContent(604, 0.54);
  hrf->SetBinContent(605, 0.58);
  hrf->SetBinContent(606, 0.54);
  hrf->SetBinContent(607, 0.46);
  hrf->SetBinContent(608, 0.58);
  hrf->SetBinContent(609, 0.58);
  hrf->SetBinContent(610, 0.5);
  hrf->SetBinContent(611, 0.5);
  hrf->SetBinContent(612, 0.5);
  hrf->SetBinContent(613, 0.58);
  hrf->SetBinContent(614, 0.46);
  hrf->SetBinContent(615, 0.54);
  hrf->SetBinContent(616, 0.58);
  hrf->SetBinContent(617, 0.5);
  hrf->SetBinContent(618, 0.5);
  hrf->SetBinContent(619, 0.5);
  hrf->SetBinContent(620, 0.5);
  hrf->SetBinContent(621, 0.5);
  hrf->SetBinContent(622, 0.54);
  hrf->SetBinContent(623, 0.46);
  hrf->SetBinContent(624, 0.54);
  hrf->SetBinContent(625, 0.54);
  hrf->SetBinContent(626, 0.54);
  hrf->SetBinContent(627, 0.54);
  hrf->SetBinContent(628, 0.54);
  hrf->SetBinContent(629, 0.5);
  hrf->SetBinContent(630, 0.5);
  hrf->SetBinContent(631, 0.46);
  hrf->SetBinContent(632, 0.46);
  hrf->SetBinContent(633, 0.46);
  hrf->SetBinContent(634, 0.5);
  hrf->SetBinContent(635, 0.46);
  hrf->SetBinContent(636, 0.46);
  hrf->SetBinContent(637, 0.5);
  hrf->SetBinContent(638, 0.66);
  hrf->SetBinContent(639, 0.62);
  hrf->SetBinContent(640, 0.62);
  hrf->SetBinContent(641, 0.66);
  hrf->SetBinContent(642, 0.66);
  hrf->SetBinContent(643, 0.58);
  hrf->SetBinContent(644, 0.66);
  hrf->SetBinContent(645, 0.66);
  hrf->SetBinContent(646, 0.74);
  hrf->SetBinContent(649, 0.7);
  hrf->SetBinContent(650, 0.74);
  hrf->SetBinContent(651, 0.74);
  hrf->SetBinContent(652, 0.78);
  hrf->SetBinContent(653, 0.7);
  hrf->SetBinContent(654, 0.7);
  hrf->SetBinContent(655, 0.62);
  hrf->SetBinContent(656, 0.66);
  hrf->SetBinContent(657, 0.74);
  hrf->SetBinContent(658, 0.46);
  hrf->SetBinContent(659, 0.54);
  hrf->SetBinContent(660, 0.5);
  hrf->SetBinContent(661, 0.54);
  hrf->SetBinContent(662, 0.58);
  hrf->SetBinContent(663, 0.42);
  hrf->SetBinContent(664, 0.54);
  hrf->SetBinContent(665, 0.58);
  hrf->SetBinContent(666, 0.62);
  hrf->SetBinContent(667, 0.58);
  hrf->SetBinContent(668, 0.58);
  hrf->SetBinContent(669, 0.58);
  hrf->SetBinContent(670, 0.62);
  hrf->SetBinContent(671, 0.46);
  hrf->SetBinContent(672, 0.5);
  hrf->SetBinContent(673, 0.62);
  hrf->SetBinContent(674, 0.62);
  hrf->SetBinContent(675, 0.66);
  hrf->SetBinContent(676, 0.5);
  hrf->SetBinContent(677, 0.66);
  hrf->SetBinContent(678, 0.5);
  hrf->SetBinContent(679, 0.5);
  hrf->SetBinContent(680, 0.58);
  hrf->SetBinContent(681, 0.54);
  hrf->SetBinContent(682, 0.54);
  hrf->SetBinContent(683, 0.58);
  hrf->SetBinContent(684, 0.62);
  hrf->SetBinContent(685, 0.5);
  hrf->SetBinContent(686, 0.5);
  hrf->SetBinContent(687, 0.54);
  hrf->SetBinContent(688, 0.54);
  hrf->SetBinContent(689, 0.66);
  hrf->SetBinContent(690, 0.58);
  hrf->SetBinContent(691, 0.54);
  hrf->SetBinContent(692, 0.7);
  hrf->SetBinContent(693, 0.7);
  hrf->SetBinContent(694, 0.62);
  hrf->SetBinContent(695, 0.62);
  hrf->SetBinContent(696, 0.66);
  hrf->SetBinContent(697, 0.74);
  hrf->SetBinContent(698, 0.7);
  hrf->SetBinContent(699, 0.74);
  hrf->SetBinContent(700, 0.74);
  hrf->SetBinContent(703, 0.7);
  hrf->SetBinContent(704, 0.78);
  hrf->SetBinContent(705, 0.66);
  hrf->SetBinContent(706, 0.66);
  hrf->SetBinContent(707, 0.66);
  hrf->SetBinContent(708, 0.74);
  hrf->SetBinContent(709, 0.7);
  hrf->SetBinContent(710, 0.66);
  hrf->SetBinContent(711, 0.58);
  hrf->SetBinContent(712, 0.54);
  hrf->SetBinContent(713, 0.58);
  hrf->SetBinContent(714, 0.5);
  hrf->SetBinContent(715, 0.54);
  hrf->SetBinContent(716, 0.66);
  hrf->SetBinContent(717, 0.54);
  hrf->SetBinContent(718, 0.58);
  hrf->SetBinContent(719, 0.66);
  hrf->SetBinContent(720, 0.46);
  hrf->SetBinContent(721, 0.58);
  hrf->SetBinContent(722, 0.5);
  hrf->SetBinContent(723, 0.58);
  hrf->SetBinContent(724, 0.54);
  hrf->SetBinContent(725, 0.58);
  hrf->SetBinContent(726, 0.66);
  hrf->SetBinContent(727, 0.58);
  hrf->SetBinContent(728, 0.62);
  hrf->SetBinContent(729, 0.58);
  hrf->SetBinContent(730, 0.54);
  hrf->SetBinContent(731, 0.54);
  hrf->SetBinContent(732, 0.66);
  hrf->SetBinContent(733, 0.5);
  hrf->SetBinContent(734, 0.62);
  hrf->SetBinContent(735, 0.62);
  hrf->SetBinContent(736, 0.5);
  hrf->SetBinContent(737, 0.54);
  hrf->SetBinContent(738, 0.62);
  hrf->SetBinContent(739, 0.62);
  hrf->SetBinContent(740, 0.58);
  hrf->SetBinContent(741, 0.58);
  hrf->SetBinContent(742, 0.46);
  hrf->SetBinContent(743, 0.46);
  hrf->SetBinContent(744, 0.58);
  hrf->SetBinContent(745, 0.5);
  hrf->SetBinContent(746, 0.66);
  hrf->SetBinContent(747, 0.66);
  hrf->SetBinContent(748, 0.54);
  hrf->SetBinContent(749, 0.78);
  hrf->SetBinContent(750, 0.62);
  hrf->SetBinContent(751, 0.7);
  hrf->SetBinContent(752, 0.66);
  hrf->SetBinContent(753, 0.66);
  hrf->SetBinContent(754, 0.78);
  hrf->SetBinContent(757, 0.82);
  hrf->SetBinContent(758, 0.74);
  hrf->SetBinContent(759, 0.7);
  hrf->SetBinContent(760, 0.78);
  hrf->SetBinContent(761, 0.7);
  hrf->SetBinContent(762, 0.62);
  hrf->SetBinContent(763, 0.78);
  hrf->SetBinContent(764, 0.78);
  hrf->SetBinContent(765, 0.7);
  hrf->SetBinContent(766, 0.62);
  hrf->SetBinContent(767, 0.58);
  hrf->SetBinContent(768, 0.62);
  hrf->SetBinContent(769, 0.66);
  hrf->SetBinContent(770, 0.58);
  hrf->SetBinContent(771, 0.66);
  hrf->SetBinContent(772, 0.54);
  hrf->SetBinContent(773, 0.7);
  hrf->SetBinContent(774, 0.58);
  hrf->SetBinContent(775, 0.58);
  hrf->SetBinContent(776, 0.62);
  hrf->SetBinContent(777, 0.7);
  hrf->SetBinContent(778, 0.62);
  hrf->SetBinContent(779, 0.66);
  hrf->SetBinContent(780, 0.74);
  hrf->SetBinContent(781, 0.54);
  hrf->SetBinContent(782, 0.58);
  hrf->SetBinContent(783, 0.54);
  hrf->SetBinContent(784, 0.62);
  hrf->SetBinContent(785, 0.62);
  hrf->SetBinContent(786, 0.54);
  hrf->SetBinContent(787, 0.54);
  hrf->SetBinContent(788, 0.62);
  hrf->SetBinContent(789, 0.5);
  hrf->SetBinContent(790, 0.58);
  hrf->SetBinContent(791, 0.74);
  hrf->SetBinContent(792, 0.54);
  hrf->SetBinContent(793, 0.58);
  hrf->SetBinContent(794, 0.58);
  hrf->SetBinContent(795, 0.54);
  hrf->SetBinContent(796, 0.62);
  hrf->SetBinContent(797, 0.58);
  hrf->SetBinContent(798, 0.58);
  hrf->SetBinContent(799, 0.7);
  hrf->SetBinContent(800, 0.62);
  hrf->SetBinContent(801, 0.7);
  hrf->SetBinContent(802, 0.7);
  hrf->SetBinContent(803, 0.82);
  hrf->SetBinContent(804, 0.74);
  hrf->SetBinContent(805, 0.74);
  hrf->SetBinContent(806, 0.74);
  hrf->SetBinContent(807, 0.74);
  hrf->SetBinContent(808, 0.74);
  hrf->SetBinContent(811, 0.78);
  hrf->SetBinContent(812, 0.78);
  hrf->SetBinContent(813, 0.86);
  hrf->SetBinContent(814, 0.78);
  hrf->SetBinContent(815, 0.78);
  hrf->SetBinContent(816, 0.82);
  hrf->SetBinContent(817, 0.82);
  hrf->SetBinContent(818, 0.7);
  hrf->SetBinContent(819, 0.7);
  hrf->SetBinContent(820, 0.58);
  hrf->SetBinContent(821, 0.58);
  hrf->SetBinContent(822, 0.66);
  hrf->SetBinContent(823, 0.62);
  hrf->SetBinContent(824, 0.7);
  hrf->SetBinContent(825, 0.58);
  hrf->SetBinContent(826, 0.66);
  hrf->SetBinContent(827, 0.54);
  hrf->SetBinContent(828, 0.62);
  hrf->SetBinContent(829, 0.62);
  hrf->SetBinContent(830, 0.7);
  hrf->SetBinContent(831, 0.78);
  hrf->SetBinContent(832, 0.66);
  hrf->SetBinContent(833, 0.62);
  hrf->SetBinContent(834, 0.66);
  hrf->SetBinContent(835, 0.66);
  hrf->SetBinContent(836, 0.62);
  hrf->SetBinContent(837, 0.66);
  hrf->SetBinContent(838, 0.66);
  hrf->SetBinContent(839, 0.66);
  hrf->SetBinContent(840, 0.78);
  hrf->SetBinContent(841, 0.66);
  hrf->SetBinContent(842, 0.62);
  hrf->SetBinContent(843, 0.66);
  hrf->SetBinContent(844, 0.66);
  hrf->SetBinContent(845, 0.7);
  hrf->SetBinContent(846, 0.7);
  hrf->SetBinContent(847, 0.58);
  hrf->SetBinContent(848, 0.66);
  hrf->SetBinContent(849, 0.78);
  hrf->SetBinContent(850, 0.7);
  hrf->SetBinContent(851, 0.62);
  hrf->SetBinContent(852, 0.62);
  hrf->SetBinContent(853, 0.7);
  hrf->SetBinContent(854, 0.82);
  hrf->SetBinContent(855, 0.66);
  hrf->SetBinContent(856, 0.7);
  hrf->SetBinContent(857, 0.74);
  hrf->SetBinContent(858, 0.66);
  hrf->SetBinContent(859, 0.74);
  hrf->SetBinContent(860, 0.7);
  hrf->SetBinContent(861, 0.78);
  hrf->SetBinContent(862, 0.82);
  hrf->SetBinContent(865, 0.78);
  hrf->SetBinContent(866, 0.74);
  hrf->SetBinContent(867, 0.78);
  hrf->SetBinContent(868, 0.82);
  hrf->SetBinContent(869, 0.78);
  hrf->SetBinContent(870, 0.66);
  hrf->SetBinContent(871, 0.74);
  hrf->SetBinContent(872, 0.7);
  hrf->SetBinContent(873, 0.86);
  hrf->SetBinContent(874, 0.58);
  hrf->SetBinContent(875, 0.62);
  hrf->SetBinContent(876, 0.62);
  hrf->SetBinContent(877, 0.74);
  hrf->SetBinContent(878, 0.66);
  hrf->SetBinContent(879, 0.66);
  hrf->SetBinContent(880, 0.58);
  hrf->SetBinContent(881, 0.66);
  hrf->SetBinContent(882, 0.62);
  hrf->SetBinContent(883, 0.7);
  hrf->SetBinContent(884, 0.66);
  hrf->SetBinContent(885, 0.74);
  hrf->SetBinContent(886, 0.7);
  hrf->SetBinContent(887, 0.62);
  hrf->SetBinContent(888, 0.58);
  hrf->SetBinContent(889, 0.66);
  hrf->SetBinContent(890, 0.62);
  hrf->SetBinContent(891, 0.66);
  hrf->SetBinContent(892, 0.66);
  hrf->SetBinContent(893, 0.74);
  hrf->SetBinContent(894, 0.7);
  hrf->SetBinContent(895, 0.58);
  hrf->SetBinContent(896, 0.7);
  hrf->SetBinContent(897, 0.66);
  hrf->SetBinContent(898, 0.7);
  hrf->SetBinContent(899, 0.66);
  hrf->SetBinContent(900, 0.7);
  hrf->SetBinContent(901, 0.62);
  hrf->SetBinContent(902, 0.58);
  hrf->SetBinContent(903, 0.7);
  hrf->SetBinContent(904, 0.7);
  hrf->SetBinContent(905, 0.7);
  hrf->SetBinContent(906, 0.66);
  hrf->SetBinContent(907, 0.7);
  hrf->SetBinContent(908, 0.74);
  hrf->SetBinContent(909, 0.7);
  hrf->SetBinContent(910, 0.74);
  hrf->SetBinContent(911, 0.74);
  hrf->SetBinContent(912, 0.66);
  hrf->SetBinContent(913, 0.82);
  hrf->SetBinContent(914, 0.78);
  hrf->SetBinContent(915, 0.78);
  hrf->SetBinContent(916, 0.82);
  hrf->SetBinContent(919, 0.86);
  hrf->SetBinContent(920, 0.78);
  hrf->SetBinContent(921, 0.78);
  hrf->SetBinContent(922, 0.78);
  hrf->SetBinContent(923, 0.86);
  hrf->SetBinContent(924, 0.78);
  hrf->SetBinContent(925, 0.7);
  hrf->SetBinContent(926, 0.78);
  hrf->SetBinContent(927, 0.74);
  hrf->SetBinContent(928, 0.62);
  hrf->SetBinContent(929, 0.62);
  hrf->SetBinContent(930, 0.7);
  hrf->SetBinContent(931, 0.78);
  hrf->SetBinContent(932, 0.66);
  hrf->SetBinContent(933, 0.7);
  hrf->SetBinContent(934, 0.7);
  hrf->SetBinContent(935, 0.66);
  hrf->SetBinContent(936, 0.62);
  hrf->SetBinContent(937, 0.7);
  hrf->SetBinContent(938, 0.7);
  hrf->SetBinContent(939, 0.62);
  hrf->SetBinContent(940, 0.74);
  hrf->SetBinContent(941, 0.66);
  hrf->SetBinContent(942, 0.62);
  hrf->SetBinContent(943, 0.66);
  hrf->SetBinContent(944, 0.74);
  hrf->SetBinContent(945, 0.66);
  hrf->SetBinContent(946, 0.66);
  hrf->SetBinContent(947, 0.74);
  hrf->SetBinContent(948, 0.66);
  hrf->SetBinContent(949, 0.66);
  hrf->SetBinContent(950, 0.62);
  hrf->SetBinContent(951, 0.74);
  hrf->SetBinContent(952, 0.74);
  hrf->SetBinContent(953, 0.66);
  hrf->SetBinContent(954, 0.66);
  hrf->SetBinContent(955, 0.7);
  hrf->SetBinContent(956, 0.58);
  hrf->SetBinContent(957, 0.7);
  hrf->SetBinContent(958, 0.66);
  hrf->SetBinContent(959, 0.7);
  hrf->SetBinContent(960, 0.62);
  hrf->SetBinContent(961, 0.7);
  hrf->SetBinContent(962, 0.82);
  hrf->SetBinContent(963, 0.66);
  hrf->SetBinContent(964, 0.74);
  hrf->SetBinContent(965, 0.7);
  hrf->SetBinContent(966, 0.74);
  hrf->SetBinContent(967, 0.78);
  hrf->SetBinContent(968, 0.86);
  hrf->SetBinContent(969, 0.78);
  hrf->SetBinContent(970, 0.78);
  hrf->SetBinContent(973, 0.82);
  hrf->SetBinContent(974, 0.82);
  hrf->SetBinContent(975, 0.74);
  hrf->SetBinContent(976, 0.7);
  hrf->SetBinContent(977, 0.78);
  hrf->SetBinContent(978, 0.74);
  hrf->SetBinContent(979, 0.82);
  hrf->SetBinContent(980, 0.7);
  hrf->SetBinContent(981, 0.74);
  hrf->SetBinContent(982, 0.62);
  hrf->SetBinContent(983, 0.7);
  hrf->SetBinContent(984, 0.7);
  hrf->SetBinContent(985, 0.66);
  hrf->SetBinContent(986, 0.78);
  hrf->SetBinContent(987, 0.62);
  hrf->SetBinContent(988, 0.74);
  hrf->SetBinContent(989, 0.7);
  hrf->SetBinContent(990, 0.7);
  hrf->SetBinContent(991, 0.7);
  hrf->SetBinContent(992, 0.7);
  hrf->SetBinContent(993, 0.82);
  hrf->SetBinContent(994, 0.86);
  hrf->SetBinContent(995, 0.7);
  hrf->SetBinContent(996, 0.7);
  hrf->SetBinContent(997, 0.78);
  hrf->SetBinContent(998, 0.66);
  hrf->SetBinContent(999, 0.74);
  hrf->SetBinContent(1000, 0.86);
  hrf->SetBinContent(1001, 0.66);
  hrf->SetBinContent(1002, 0.66);
  hrf->SetBinContent(1003, 0.74);
  hrf->SetBinContent(1004, 0.7);
  hrf->SetBinContent(1005, 0.62);
  hrf->SetBinContent(1006, 0.66);
  hrf->SetBinContent(1007, 0.78);
  hrf->SetBinContent(1008, 0.7);
  hrf->SetBinContent(1009, 0.74);
  hrf->SetBinContent(1010, 0.66);
  hrf->SetBinContent(1011, 0.78);
  hrf->SetBinContent(1012, 0.62);
  hrf->SetBinContent(1013, 0.7);
  hrf->SetBinContent(1014, 0.58);
  hrf->SetBinContent(1015, 0.74);
  hrf->SetBinContent(1016, 0.74);
  hrf->SetBinContent(1017, 0.7);
  hrf->SetBinContent(1018, 0.7);
  hrf->SetBinContent(1019, 0.74);
  hrf->SetBinContent(1020, 0.78);
  hrf->SetBinContent(1021, 0.74);
  hrf->SetBinContent(1022, 0.86);
  hrf->SetBinContent(1023, 0.86);
  hrf->SetBinContent(1024, 0.82);
  hrf->SetBinContent(1027, 0.82);
  hrf->SetBinContent(1028, 0.82);
  hrf->SetBinContent(1029, 0.78);
  hrf->SetBinContent(1030, 0.78);
  hrf->SetBinContent(1031, 0.78);
  hrf->SetBinContent(1032, 0.78);
  hrf->SetBinContent(1033, 0.78);
  hrf->SetBinContent(1034, 0.78);
  hrf->SetBinContent(1035, 0.9);
  hrf->SetBinContent(1036, 0.74);
  hrf->SetBinContent(1037, 0.62);
  hrf->SetBinContent(1038, 0.7);
  hrf->SetBinContent(1039, 0.66);
  hrf->SetBinContent(1040, 0.7);
  hrf->SetBinContent(1041, 0.74);
  hrf->SetBinContent(1042, 0.74);
  hrf->SetBinContent(1043, 0.74);
  hrf->SetBinContent(1044, 0.7);
  hrf->SetBinContent(1045, 0.62);
  hrf->SetBinContent(1046, 0.74);
  hrf->SetBinContent(1047, 0.78);
  hrf->SetBinContent(1048, 0.74);
  hrf->SetBinContent(1049, 0.78);
  hrf->SetBinContent(1050, 0.78);
  hrf->SetBinContent(1051, 0.78);
  hrf->SetBinContent(1052, 0.74);
  hrf->SetBinContent(1053, 0.74);
  hrf->SetBinContent(1054, 0.78);
  hrf->SetBinContent(1055, 0.74);
  hrf->SetBinContent(1056, 0.78);
  hrf->SetBinContent(1057, 0.74);
  hrf->SetBinContent(1058, 0.74);
  hrf->SetBinContent(1059, 0.74);
  hrf->SetBinContent(1060, 0.74);
  hrf->SetBinContent(1061, 0.7);
  hrf->SetBinContent(1062, 0.7);
  hrf->SetBinContent(1063, 0.66);
  hrf->SetBinContent(1064, 0.74);
  hrf->SetBinContent(1065, 0.74);
  hrf->SetBinContent(1066, 0.7);
  hrf->SetBinContent(1067, 0.7);
  hrf->SetBinContent(1068, 0.62);
  hrf->SetBinContent(1069, 0.74);
  hrf->SetBinContent(1070, 0.7);
  hrf->SetBinContent(1071, 0.74);
  hrf->SetBinContent(1072, 0.74);
  hrf->SetBinContent(1073, 0.82);
  hrf->SetBinContent(1074, 0.82);
  hrf->SetBinContent(1075, 0.86);
  hrf->SetBinContent(1076, 0.78);
  hrf->SetBinContent(1077, 0.82);
  hrf->SetBinContent(1078, 0.86);
  hrf->SetBinContent(1081, 0.86);
  hrf->SetBinContent(1082, 0.82);
  hrf->SetBinContent(1083, 0.78);
  hrf->SetBinContent(1084, 0.78);
  hrf->SetBinContent(1085, 0.82);
  hrf->SetBinContent(1086, 0.82);
  hrf->SetBinContent(1087, 0.82);
  hrf->SetBinContent(1088, 0.78);
  hrf->SetBinContent(1089, 0.86);
  hrf->SetBinContent(1090, 0.74);
  hrf->SetBinContent(1091, 0.78);
  hrf->SetBinContent(1092, 0.74);
  hrf->SetBinContent(1093, 0.7);
  hrf->SetBinContent(1094, 0.66);
  hrf->SetBinContent(1095, 0.78);
  hrf->SetBinContent(1096, 0.74);
  hrf->SetBinContent(1097, 0.78);
  hrf->SetBinContent(1098, 0.78);
  hrf->SetBinContent(1099, 0.78);
  hrf->SetBinContent(1100, 0.74);
  hrf->SetBinContent(1101, 0.7);
  hrf->SetBinContent(1102, 0.82);
  hrf->SetBinContent(1103, 0.78);
  hrf->SetBinContent(1104, 0.86);
  hrf->SetBinContent(1105, 0.78);
  hrf->SetBinContent(1106, 0.74);
  hrf->SetBinContent(1107, 0.78);
  hrf->SetBinContent(1108, 0.74);
  hrf->SetBinContent(1109, 0.82);
  hrf->SetBinContent(1110, 0.74);
  hrf->SetBinContent(1111, 0.82);
  hrf->SetBinContent(1112, 0.74);
  hrf->SetBinContent(1113, 0.86);
  hrf->SetBinContent(1114, 0.82);
  hrf->SetBinContent(1115, 0.74);
  hrf->SetBinContent(1116, 0.78);
  hrf->SetBinContent(1117, 0.74);
  hrf->SetBinContent(1118, 0.7);
  hrf->SetBinContent(1119, 0.66);
  hrf->SetBinContent(1120, 0.66);
  hrf->SetBinContent(1121, 0.74);
  hrf->SetBinContent(1122, 0.66);
  hrf->SetBinContent(1123, 0.7);
  hrf->SetBinContent(1124, 0.82);
  hrf->SetBinContent(1125, 0.86);
  hrf->SetBinContent(1126, 0.74);
  hrf->SetBinContent(1127, 0.78);
  hrf->SetBinContent(1128, 0.82);
  hrf->SetBinContent(1129, 0.78);
  hrf->SetBinContent(1130, 0.82);
  hrf->SetBinContent(1131, 0.86);
  hrf->SetBinContent(1132, 0.82);
  hrf->SetBinContent(1135, 0.86);
  hrf->SetBinContent(1136, 0.86);
  hrf->SetBinContent(1137, 0.9);
  hrf->SetBinContent(1138, 0.78);
  hrf->SetBinContent(1139, 0.9);
  hrf->SetBinContent(1140, 0.86);
  hrf->SetBinContent(1141, 0.82);
  hrf->SetBinContent(1142, 0.78);
  hrf->SetBinContent(1143, 0.86);
  hrf->SetBinContent(1144, 0.7);
  hrf->SetBinContent(1145, 0.7);
  hrf->SetBinContent(1146, 0.74);
  hrf->SetBinContent(1147, 0.62);
  hrf->SetBinContent(1148, 0.74);
  hrf->SetBinContent(1149, 0.74);
  hrf->SetBinContent(1150, 0.78);
  hrf->SetBinContent(1151, 0.74);
  hrf->SetBinContent(1152, 0.74);
  hrf->SetBinContent(1153, 0.78);
  hrf->SetBinContent(1154, 0.78);
  hrf->SetBinContent(1155, 0.78);
  hrf->SetBinContent(1156, 0.82);
  hrf->SetBinContent(1157, 0.74);
  hrf->SetBinContent(1158, 0.78);
  hrf->SetBinContent(1159, 0.78);
  hrf->SetBinContent(1160, 0.74);
  hrf->SetBinContent(1161, 0.78);
  hrf->SetBinContent(1162, 0.82);
  hrf->SetBinContent(1163, 0.78);
  hrf->SetBinContent(1164, 0.78);
  hrf->SetBinContent(1165, 0.82);
  hrf->SetBinContent(1166, 0.7);
  hrf->SetBinContent(1167, 0.78);
  hrf->SetBinContent(1168, 0.7);
  hrf->SetBinContent(1169, 0.82);
  hrf->SetBinContent(1170, 0.74);
  hrf->SetBinContent(1171, 0.74);
  hrf->SetBinContent(1172, 0.78);
  hrf->SetBinContent(1173, 0.74);
  hrf->SetBinContent(1174, 0.66);
  hrf->SetBinContent(1175, 0.7);
  hrf->SetBinContent(1176, 0.7);
  hrf->SetBinContent(1177, 0.74);
  hrf->SetBinContent(1178, 0.86);
  hrf->SetBinContent(1179, 0.86);
  hrf->SetBinContent(1180, 0.78);
  hrf->SetBinContent(1181, 0.78);
  hrf->SetBinContent(1182, 0.82);
  hrf->SetBinContent(1183, 0.82);
  hrf->SetBinContent(1184, 0.86);
  hrf->SetBinContent(1185, 0.86);
  hrf->SetBinContent(1186, 0.82);
  hrf->SetBinContent(1189, 0.86);
  hrf->SetBinContent(1190, 0.82);
  hrf->SetBinContent(1191, 0.86);
  hrf->SetBinContent(1192, 0.82);
  hrf->SetBinContent(1193, 0.86);
  hrf->SetBinContent(1194, 0.86);
  hrf->SetBinContent(1195, 0.78);
  hrf->SetBinContent(1196, 0.86);
  hrf->SetBinContent(1197, 0.82);
  hrf->SetBinContent(1198, 0.74);
  hrf->SetBinContent(1199, 0.74);
  hrf->SetBinContent(1200, 0.74);
  hrf->SetBinContent(1201, 0.74);
  hrf->SetBinContent(1202, 0.7);
  hrf->SetBinContent(1203, 0.7);
  hrf->SetBinContent(1204, 0.82);
  hrf->SetBinContent(1205, 0.74);
  hrf->SetBinContent(1206, 0.82);
  hrf->SetBinContent(1207, 0.82);
  hrf->SetBinContent(1208, 0.78);
  hrf->SetBinContent(1209, 0.82);
  hrf->SetBinContent(1210, 0.82);
  hrf->SetBinContent(1211, 0.82);
  hrf->SetBinContent(1212, 0.78);
  hrf->SetBinContent(1213, 0.82);
  hrf->SetBinContent(1214, 0.78);
  hrf->SetBinContent(1215, 0.82);
  hrf->SetBinContent(1216, 0.86);
  hrf->SetBinContent(1217, 0.74);
  hrf->SetBinContent(1218, 0.82);
  hrf->SetBinContent(1219, 0.82);
  hrf->SetBinContent(1220, 0.78);
  hrf->SetBinContent(1221, 0.78);
  hrf->SetBinContent(1222, 0.7);
  hrf->SetBinContent(1223, 0.74);
  hrf->SetBinContent(1224, 0.82);
  hrf->SetBinContent(1225, 0.7);
  hrf->SetBinContent(1226, 0.78);
  hrf->SetBinContent(1227, 0.74);
  hrf->SetBinContent(1228, 0.7);
  hrf->SetBinContent(1229, 0.7);
  hrf->SetBinContent(1230, 0.66);
  hrf->SetBinContent(1231, 0.74);
  hrf->SetBinContent(1232, 0.78);
  hrf->SetBinContent(1233, 0.82);
  hrf->SetBinContent(1234, 0.82);
  hrf->SetBinContent(1235, 0.78);
  hrf->SetBinContent(1236, 0.82);
  hrf->SetBinContent(1237, 0.82);
  hrf->SetBinContent(1238, 0.82);
  hrf->SetBinContent(1239, 0.82);
  hrf->SetBinContent(1240, 0.86);
  hrf->SetBinContent(1243, 0.86);
  hrf->SetBinContent(1244, 0.86);
  hrf->SetBinContent(1245, 0.82);
  hrf->SetBinContent(1246, 0.86);
  hrf->SetBinContent(1247, 0.9);
  hrf->SetBinContent(1248, 0.82);
  hrf->SetBinContent(1249, 0.86);
  hrf->SetBinContent(1250, 0.82);
  hrf->SetBinContent(1251, 0.82);
  hrf->SetBinContent(1252, 0.78);
  hrf->SetBinContent(1253, 0.78);
  hrf->SetBinContent(1254, 0.66);
  hrf->SetBinContent(1255, 0.7);
  hrf->SetBinContent(1256, 0.74);
  hrf->SetBinContent(1257, 0.78);
  hrf->SetBinContent(1258, 0.78);
  hrf->SetBinContent(1259, 0.82);
  hrf->SetBinContent(1260, 0.86);
  hrf->SetBinContent(1261, 0.82);
  hrf->SetBinContent(1262, 0.82);
  hrf->SetBinContent(1263, 0.82);
  hrf->SetBinContent(1264, 0.78);
  hrf->SetBinContent(1265, 0.9);
  hrf->SetBinContent(1266, 0.78);
  hrf->SetBinContent(1267, 0.82);
  hrf->SetBinContent(1268, 0.78);
  hrf->SetBinContent(1269, 0.78);
  hrf->SetBinContent(1270, 0.78);
  hrf->SetBinContent(1271, 0.78);
  hrf->SetBinContent(1272, 0.78);
  hrf->SetBinContent(1273, 0.86);
  hrf->SetBinContent(1274, 0.78);
  hrf->SetBinContent(1275, 0.78);
  hrf->SetBinContent(1276, 0.74);
  hrf->SetBinContent(1277, 0.78);
  hrf->SetBinContent(1278, 0.7);
  hrf->SetBinContent(1279, 0.7);
  hrf->SetBinContent(1280, 0.74);
  hrf->SetBinContent(1281, 0.74);
  hrf->SetBinContent(1282, 0.74);
  hrf->SetBinContent(1283, 0.78);
  hrf->SetBinContent(1284, 0.82);
  hrf->SetBinContent(1285, 0.74);
  hrf->SetBinContent(1286, 0.86);
  hrf->SetBinContent(1287, 0.78);
  hrf->SetBinContent(1288, 0.86);
  hrf->SetBinContent(1289, 0.78);
  hrf->SetBinContent(1290, 0.82);
  hrf->SetBinContent(1291, 0.86);
  hrf->SetBinContent(1292, 0.82);
  hrf->SetBinContent(1293, 0.86);
  hrf->SetBinContent(1294, 0.82);
  hrf->SetBinContent(1297, 0.86);
  hrf->SetBinContent(1298, 0.86);
  hrf->SetBinContent(1299, 0.82);
  hrf->SetBinContent(1300, 0.82);
  hrf->SetBinContent(1301, 0.86);
  hrf->SetBinContent(1302, 0.82);
  hrf->SetBinContent(1303, 0.82);
  hrf->SetBinContent(1304, 0.86);
  hrf->SetBinContent(1305, 0.86);
  hrf->SetBinContent(1306, 0.78);
  hrf->SetBinContent(1307, 0.74);
  hrf->SetBinContent(1308, 0.7);
  hrf->SetBinContent(1309, 0.66);
  hrf->SetBinContent(1310, 0.74);
  hrf->SetBinContent(1311, 0.74);
  hrf->SetBinContent(1312, 0.78);
  hrf->SetBinContent(1313, 0.78);
  hrf->SetBinContent(1314, 0.78);
  hrf->SetBinContent(1315, 0.82);
  hrf->SetBinContent(1316, 0.78);
  hrf->SetBinContent(1317, 0.82);
  hrf->SetBinContent(1318, 0.78);
  hrf->SetBinContent(1319, 0.78);
  hrf->SetBinContent(1320, 0.78);
  hrf->SetBinContent(1321, 0.82);
  hrf->SetBinContent(1322, 0.86);
  hrf->SetBinContent(1323, 0.82);
  hrf->SetBinContent(1324, 0.82);
  hrf->SetBinContent(1325, 0.82);
  hrf->SetBinContent(1326, 0.74);
  hrf->SetBinContent(1327, 0.78);
  hrf->SetBinContent(1328, 0.82);
  hrf->SetBinContent(1329, 0.78);
  hrf->SetBinContent(1330, 0.74);
  hrf->SetBinContent(1331, 0.82);
  hrf->SetBinContent(1332, 0.78);
  hrf->SetBinContent(1333, 0.78);
  hrf->SetBinContent(1334, 0.78);
  hrf->SetBinContent(1335, 0.74);
  hrf->SetBinContent(1336, 0.78);
  hrf->SetBinContent(1337, 0.78);
  hrf->SetBinContent(1338, 0.7);
  hrf->SetBinContent(1339, 0.7);
  hrf->SetBinContent(1340, 0.86);
  hrf->SetBinContent(1341, 0.82);
  hrf->SetBinContent(1342, 0.82);
  hrf->SetBinContent(1343, 0.82);
  hrf->SetBinContent(1344, 0.86);
  hrf->SetBinContent(1345, 0.86);
  hrf->SetBinContent(1346, 0.86);
  hrf->SetBinContent(1347, 0.9);
  hrf->SetBinContent(1348, 0.86);
  hrf->SetBinContent(1351, 0.86);
  hrf->SetBinContent(1352, 0.82);
  hrf->SetBinContent(1353, 0.9);
  hrf->SetBinContent(1354, 0.86);
  hrf->SetBinContent(1355, 0.86);
  hrf->SetBinContent(1356, 0.9);
  hrf->SetBinContent(1357, 0.82);
  hrf->SetBinContent(1358, 0.86);
  hrf->SetBinContent(1359, 0.9);
  hrf->SetBinContent(1360, 0.74);
  hrf->SetBinContent(1361, 0.78);
  hrf->SetBinContent(1362, 0.78);
  hrf->SetBinContent(1363, 0.74);
  hrf->SetBinContent(1364, 0.78);
  hrf->SetBinContent(1365, 0.74);
  hrf->SetBinContent(1366, 0.82);
  hrf->SetBinContent(1367, 0.82);
  hrf->SetBinContent(1368, 0.86);
  hrf->SetBinContent(1369, 0.82);
  hrf->SetBinContent(1370, 0.82);
  hrf->SetBinContent(1371, 0.78);
  hrf->SetBinContent(1372, 0.82);
  hrf->SetBinContent(1373, 0.78);
  hrf->SetBinContent(1374, 0.78);
  hrf->SetBinContent(1375, 0.82);
  hrf->SetBinContent(1376, 0.78);
  hrf->SetBinContent(1377, 0.78);
  hrf->SetBinContent(1378, 0.82);
  hrf->SetBinContent(1379, 0.78);
  hrf->SetBinContent(1380, 0.82);
  hrf->SetBinContent(1381, 0.86);
  hrf->SetBinContent(1382, 0.82);
  hrf->SetBinContent(1383, 0.82);
  hrf->SetBinContent(1384, 0.78);
  hrf->SetBinContent(1385, 0.82);
  hrf->SetBinContent(1386, 0.82);
  hrf->SetBinContent(1387, 0.86);
  hrf->SetBinContent(1388, 0.74);
  hrf->SetBinContent(1389, 0.82);
  hrf->SetBinContent(1390, 0.7);
  hrf->SetBinContent(1391, 0.7);
  hrf->SetBinContent(1392, 0.78);
  hrf->SetBinContent(1393, 0.78);
  hrf->SetBinContent(1394, 0.9);
  hrf->SetBinContent(1395, 0.86);
  hrf->SetBinContent(1396, 0.86);
  hrf->SetBinContent(1397, 0.9);
  hrf->SetBinContent(1398, 0.86);
  hrf->SetBinContent(1399, 0.9);
  hrf->SetBinContent(1400, 0.82);
  hrf->SetBinContent(1401, 0.9);
  hrf->SetBinContent(1402, 0.9);
  hrf->SetBinContent(1405, 0.9);
  hrf->SetBinContent(1406, 0.86);
  hrf->SetBinContent(1407, 0.86);
  hrf->SetBinContent(1408, 0.94);
  hrf->SetBinContent(1409, 0.86);
  hrf->SetBinContent(1410, 0.86);
  hrf->SetBinContent(1411, 0.86);
  hrf->SetBinContent(1412, 0.86);
  hrf->SetBinContent(1413, 0.86);
  hrf->SetBinContent(1414, 0.82);
  hrf->SetBinContent(1415, 0.74);
  hrf->SetBinContent(1416, 0.7);
  hrf->SetBinContent(1417, 0.78);
  hrf->SetBinContent(1418, 0.74);
  hrf->SetBinContent(1419, 0.78);
  hrf->SetBinContent(1420, 0.78);
  hrf->SetBinContent(1421, 0.78);
  hrf->SetBinContent(1422, 0.86);
  hrf->SetBinContent(1423, 0.78);
  hrf->SetBinContent(1424, 0.82);
  hrf->SetBinContent(1425, 0.82);
  hrf->SetBinContent(1426, 0.82);
  hrf->SetBinContent(1427, 0.78);
  hrf->SetBinContent(1428, 0.78);
  hrf->SetBinContent(1429, 0.86);
  hrf->SetBinContent(1430, 0.82);
  hrf->SetBinContent(1431, 0.86);
  hrf->SetBinContent(1432, 0.86);
  hrf->SetBinContent(1433, 0.82);
  hrf->SetBinContent(1434, 0.9);
  hrf->SetBinContent(1435, 0.82);
  hrf->SetBinContent(1436, 0.86);
  hrf->SetBinContent(1437, 0.82);
  hrf->SetBinContent(1438, 0.9);
  hrf->SetBinContent(1439, 0.82);
  hrf->SetBinContent(1440, 0.78);
  hrf->SetBinContent(1441, 0.78);
  hrf->SetBinContent(1442, 0.82);
  hrf->SetBinContent(1443, 0.74);
  hrf->SetBinContent(1444, 0.82);
  hrf->SetBinContent(1445, 0.78);
  hrf->SetBinContent(1446, 0.82);
  hrf->SetBinContent(1447, 0.78);
  hrf->SetBinContent(1448, 0.9);
  hrf->SetBinContent(1449, 0.82);
  hrf->SetBinContent(1450, 0.86);
  hrf->SetBinContent(1451, 0.86);
  hrf->SetBinContent(1452, 0.86);
  hrf->SetBinContent(1453, 0.86);
  hrf->SetBinContent(1454, 0.86);
  hrf->SetBinContent(1455, 0.86);
  hrf->SetBinContent(1456, 0.86);
  hrf->SetBinContent(1459, 0.9);
  hrf->SetBinContent(1460, 0.86);
  hrf->SetBinContent(1461, 0.9);
  hrf->SetBinContent(1462, 0.9);
  hrf->SetBinContent(1463, 0.9);
  hrf->SetBinContent(1464, 0.9);
  hrf->SetBinContent(1465, 0.86);
  hrf->SetBinContent(1466, 0.86);
  hrf->SetBinContent(1467, 0.9);
  hrf->SetBinContent(1468, 0.78);
  hrf->SetBinContent(1469, 0.82);
  hrf->SetBinContent(1470, 0.7);
  hrf->SetBinContent(1471, 0.78);
  hrf->SetBinContent(1472, 0.78);
  hrf->SetBinContent(1473, 0.78);
  hrf->SetBinContent(1474, 0.82);
  hrf->SetBinContent(1475, 0.82);
  hrf->SetBinContent(1476, 0.86);
  hrf->SetBinContent(1477, 0.82);
  hrf->SetBinContent(1478, 0.86);
  hrf->SetBinContent(1479, 0.82);
  hrf->SetBinContent(1480, 0.82);
  hrf->SetBinContent(1481, 0.9);
  hrf->SetBinContent(1482, 0.9);
  hrf->SetBinContent(1483, 0.82);
  hrf->SetBinContent(1484, 0.86);
  hrf->SetBinContent(1485, 0.9);
  hrf->SetBinContent(1486, 0.86);
  hrf->SetBinContent(1487, 0.78);
  hrf->SetBinContent(1488, 0.9);
  hrf->SetBinContent(1489, 0.86);
  hrf->SetBinContent(1490, 0.86);
  hrf->SetBinContent(1491, 0.82);
  hrf->SetBinContent(1492, 0.78);
  hrf->SetBinContent(1493, 0.86);
  hrf->SetBinContent(1494, 0.82);
  hrf->SetBinContent(1495, 0.78);
  hrf->SetBinContent(1496, 0.82);
  hrf->SetBinContent(1497, 0.78);
  hrf->SetBinContent(1498, 0.74);
  hrf->SetBinContent(1499, 0.74);
  hrf->SetBinContent(1500, 0.78);
  hrf->SetBinContent(1501, 0.78);
  hrf->SetBinContent(1502, 0.86);
  hrf->SetBinContent(1503, 0.86);
  hrf->SetBinContent(1504, 0.82);
  hrf->SetBinContent(1505, 0.86);
  hrf->SetBinContent(1506, 0.86);
  hrf->SetBinContent(1507, 0.86);
  hrf->SetBinContent(1508, 0.86);
  hrf->SetBinContent(1509, 0.9);
  hrf->SetBinContent(1510, 0.9);
  hrf->SetBinContent(1513, 0.86);
  hrf->SetBinContent(1514, 0.9);
  hrf->SetBinContent(1515, 0.9);
  hrf->SetBinContent(1516, 0.9);
  hrf->SetBinContent(1517, 0.9);
  hrf->SetBinContent(1518, 0.86);
  hrf->SetBinContent(1519, 0.86);
  hrf->SetBinContent(1520, 0.9);
  hrf->SetBinContent(1521, 0.9);
  hrf->SetBinContent(1522, 0.78);
  hrf->SetBinContent(1523, 0.78);
  hrf->SetBinContent(1524, 0.78);
  hrf->SetBinContent(1525, 0.74);
  hrf->SetBinContent(1526, 0.78);
  hrf->SetBinContent(1527, 0.82);
  hrf->SetBinContent(1528, 0.78);
  hrf->SetBinContent(1529, 0.82);
  hrf->SetBinContent(1530, 0.86);
  hrf->SetBinContent(1531, 0.82);
  hrf->SetBinContent(1532, 0.86);
  hrf->SetBinContent(1533, 0.86);
  hrf->SetBinContent(1534, 0.78);
  hrf->SetBinContent(1535, 0.86);
  hrf->SetBinContent(1536, 0.82);
  hrf->SetBinContent(1537, 0.82);
  hrf->SetBinContent(1538, 0.82);
  hrf->SetBinContent(1539, 0.9);
  hrf->SetBinContent(1540, 0.82);
  hrf->SetBinContent(1541, 0.82);
  hrf->SetBinContent(1542, 0.82);
  hrf->SetBinContent(1543, 0.9);
  hrf->SetBinContent(1544, 0.9);
  hrf->SetBinContent(1545, 0.82);
  hrf->SetBinContent(1546, 0.82);
  hrf->SetBinContent(1547, 0.82);
  hrf->SetBinContent(1548, 0.82);
  hrf->SetBinContent(1549, 0.82);
  hrf->SetBinContent(1550, 0.82);
  hrf->SetBinContent(1551, 0.82);
  hrf->SetBinContent(1552, 0.78);
  hrf->SetBinContent(1553, 0.82);
  hrf->SetBinContent(1554, 0.82);
  hrf->SetBinContent(1555, 0.82);
  hrf->SetBinContent(1556, 0.86);
  hrf->SetBinContent(1557, 0.86);
  hrf->SetBinContent(1558, 0.86);
  hrf->SetBinContent(1559, 0.9);
  hrf->SetBinContent(1560, 0.86);
  hrf->SetBinContent(1561, 0.86);
  hrf->SetBinContent(1562, 0.86);
  hrf->SetBinContent(1563, 0.86);
  hrf->SetBinContent(1564, 0.82);

  return hrf;
}

getResponseFunction_noshower()

TH2D * TCMETAlgo::getResponseFunction_noshower

(

)

Definition at line 2153 of file TCMETAlgo.cc.

References MillePedeFileConverter_cfg::e.

Referenced by configure().

                                              {
  // single pion response function from shower track

  Double_t xAxis1[53] = {-2.5,   -2.322, -2.172, -2.043, -1.93,  -1.83,  -1.74,  -1.653, -1.566, -1.479, -1.392,
                         -1.305, -1.218, -1.131, -1.044, -0.957, -0.879, -0.783, -0.696, -0.609, -0.522, -0.435,
                         -0.348, -0.261, -0.174, -0.087, 0,      0.087,  0.174,  0.261,  0.348,  0.435,  0.522,
                         0.609,  0.696,  0.783,  0.879,  0.957,  1.044,  1.131,  1.218,  1.305,  1.392,  1.479,
                         1.566,  1.653,  1.74,   1.83,   1.93,   2.043,  2.172,  2.322,  2.5};

  Double_t yAxis1[29] = {0,  0.5, 1,  1.5, 2,  3,  4,  5,  6,  7,  8,  9,  10, 12, 14,
                         16, 18,  20, 25,  30, 35, 40, 45, 50, 60, 70, 80, 90, 100};

  TH2D* hrf = new TH2D("hrf", "non-shower RF (fit)", 52, xAxis1, 28, yAxis1);
  hrf->SetBinContent(163, 0.6400471);
  hrf->SetBinContent(164, 0.7197217);
  hrf->SetBinContent(165, 0.7705277);
  hrf->SetBinContent(166, 0.7689679);
  hrf->SetBinContent(167, 0.7037262);
  hrf->SetBinContent(168, 0.6097692);
  hrf->SetBinContent(169, 0.6026249);
  hrf->SetBinContent(170, 0.4880021);
  hrf->SetBinContent(171, 0.3787266);
  hrf->SetBinContent(172, 0.2350156);
  hrf->SetBinContent(173, 0.219073);
  hrf->SetBinContent(174, 0.2191393);
  hrf->SetBinContent(175, 0.2753591);
  hrf->SetBinContent(176, 1.366886e-14);
  hrf->SetBinContent(177, 3.453943e-15);
  hrf->SetBinContent(178, 1.380731e-16);
  hrf->SetBinContent(179, 3.279169e-16);
  hrf->SetBinContent(180, 8.452717e-14);
  hrf->SetBinContent(181, 3.328501e-17);
  hrf->SetBinContent(182, 0.3409182);
  hrf->SetBinContent(183, 0.4767957);
  hrf->SetBinContent(184, 1.951564e-18);
  hrf->SetBinContent(185, 2.900783e-15);
  hrf->SetBinContent(186, 1.296576e-14);
  hrf->SetBinContent(187, 2.832803e-15);
  hrf->SetBinContent(188, 7.610557e-16);
  hrf->SetBinContent(189, 3.546542e-13);
  hrf->SetBinContent(190, 8.606939e-16);
  hrf->SetBinContent(191, 8.730876e-12);
  hrf->SetBinContent(192, 4.470491e-15);
  hrf->SetBinContent(193, 2.456455e-13);
  hrf->SetBinContent(194, 2.170573e-16);
  hrf->SetBinContent(195, 0.3464883);
  hrf->SetBinContent(196, 0.0206337);
  hrf->SetBinContent(197, 3.021008e-12);
  hrf->SetBinContent(198, 4.707796e-13);
  hrf->SetBinContent(199, 4.0623e-14);
  hrf->SetBinContent(200, 4.115198e-15);
  hrf->SetBinContent(201, 8.337408e-13);
  hrf->SetBinContent(202, 0.228919);
  hrf->SetBinContent(203, 1.267038e-12);
  hrf->SetBinContent(204, 2.175747e-13);
  hrf->SetBinContent(205, 3.821724e-13);
  hrf->SetBinContent(206, 0.1894161);
  hrf->SetBinContent(207, 0.3402959);
  hrf->SetBinContent(208, 0.4059051);
  hrf->SetBinContent(209, 0.4614792);
  hrf->SetBinContent(210, 0.5189589);
  hrf->SetBinContent(211, 0.6140491);
  hrf->SetBinContent(212, 0.6395754);
  hrf->SetBinContent(213, 0.6345313);
  hrf->SetBinContent(214, 0.5764959);
  hrf->SetBinContent(217, 0.6154265);
  hrf->SetBinContent(218, 0.6812514);
  hrf->SetBinContent(219, 0.7334445);
  hrf->SetBinContent(220, 0.752498);
  hrf->SetBinContent(221, 0.7265755);
  hrf->SetBinContent(222, 0.6524332);
  hrf->SetBinContent(223, 0.5913962);
  hrf->SetBinContent(224, 0.4738731);
  hrf->SetBinContent(225, 0.3398328);
  hrf->SetBinContent(226, 0.3320888);
  hrf->SetBinContent(227, 0.3050285);
  hrf->SetBinContent(228, 0.09497643);
  hrf->SetBinContent(229, 0.01537557);
  hrf->SetBinContent(230, 7.661648e-11);
  hrf->SetBinContent(231, 0.1108151);
  hrf->SetBinContent(232, 0.2663473);
  hrf->SetBinContent(233, 0.3121616);
  hrf->SetBinContent(234, 0.3571696);
  hrf->SetBinContent(235, 1.152347e-13);
  hrf->SetBinContent(236, 1.753052e-14);
  hrf->SetBinContent(237, 1.055517e-13);
  hrf->SetBinContent(238, 4.32909e-12);
  hrf->SetBinContent(239, 2.708879e-16);
  hrf->SetBinContent(240, 1.884276e-12);
  hrf->SetBinContent(241, 1.287943e-13);
  hrf->SetBinContent(242, 1.157993e-11);
  hrf->SetBinContent(243, 6.523176e-13);
  hrf->SetBinContent(244, 6.855802e-12);
  hrf->SetBinContent(245, 3.4108e-13);
  hrf->SetBinContent(246, 1.608902e-15);
  hrf->SetBinContent(247, 1.088044e-12);
  hrf->SetBinContent(248, 9.624121e-14);
  hrf->SetBinContent(249, 6.370772e-16);
  hrf->SetBinContent(250, 1.301799e-12);
  hrf->SetBinContent(251, 0.3605876);
  hrf->SetBinContent(252, 0.2917439);
  hrf->SetBinContent(253, 0.2356352);
  hrf->SetBinContent(254, 0.00659433);
  hrf->SetBinContent(255, 3.909949e-12);
  hrf->SetBinContent(256, 4.166508e-14);
  hrf->SetBinContent(257, 1.350189e-14);
  hrf->SetBinContent(258, 1.414884e-17);
  hrf->SetBinContent(259, 0.06061962);
  hrf->SetBinContent(260, 0.08133564);
  hrf->SetBinContent(261, 0.3266752);
  hrf->SetBinContent(262, 0.4730967);
  hrf->SetBinContent(263, 0.5211827);
  hrf->SetBinContent(264, 0.5929002);
  hrf->SetBinContent(265, 0.6360459);
  hrf->SetBinContent(266, 0.6585686);
  hrf->SetBinContent(267, 0.6288643);
  hrf->SetBinContent(268, 0.5756851);
  hrf->SetBinContent(271, 0.6387249);
  hrf->SetBinContent(272, 0.677789);
  hrf->SetBinContent(273, 0.7180347);
  hrf->SetBinContent(274, 0.7297289);
  hrf->SetBinContent(275, 0.720934);
  hrf->SetBinContent(276, 0.6819276);
  hrf->SetBinContent(277, 0.6652455);
  hrf->SetBinContent(278, 0.6041919);
  hrf->SetBinContent(279, 0.5153493);
  hrf->SetBinContent(280, 0.4806414);
  hrf->SetBinContent(281, 0.4495209);
  hrf->SetBinContent(282, 0.4227853);
  hrf->SetBinContent(283, 0.3837889);
  hrf->SetBinContent(284, 0.341496);
  hrf->SetBinContent(285, 0.3296164);
  hrf->SetBinContent(286, 0.3421705);
  hrf->SetBinContent(287, 0.360976);
  hrf->SetBinContent(288, 0.3551224);
  hrf->SetBinContent(289, 0.3728781);
  hrf->SetBinContent(290, 0.3965779);
  hrf->SetBinContent(291, 0.4305746);
  hrf->SetBinContent(292, 0.4374409);
  hrf->SetBinContent(293, 0.4483791);
  hrf->SetBinContent(294, 0.4764922);
  hrf->SetBinContent(295, 0.4992606);
  hrf->SetBinContent(296, 0.5098206);
  hrf->SetBinContent(297, 0.4798357);
  hrf->SetBinContent(298, 0.4897116);
  hrf->SetBinContent(299, 0.4734376);
  hrf->SetBinContent(300, 0.4570703);
  hrf->SetBinContent(301, 0.3906605);
  hrf->SetBinContent(302, 0.3914719);
  hrf->SetBinContent(303, 0.3596696);
  hrf->SetBinContent(304, 0.3133957);
  hrf->SetBinContent(305, 0.3382987);
  hrf->SetBinContent(306, 0.3336977);
  hrf->SetBinContent(307, 0.3240096);
  hrf->SetBinContent(308, 0.3258908);
  hrf->SetBinContent(309, 0.3156744);
  hrf->SetBinContent(310, 0.3435096);
  hrf->SetBinContent(311, 0.363777);
  hrf->SetBinContent(312, 0.384053);
  hrf->SetBinContent(313, 0.3947456);
  hrf->SetBinContent(314, 0.4252563);
  hrf->SetBinContent(315, 0.499156);
  hrf->SetBinContent(316, 0.5335806);
  hrf->SetBinContent(317, 0.5937738);
  hrf->SetBinContent(318, 0.6133472);
  hrf->SetBinContent(319, 0.6376735);
  hrf->SetBinContent(320, 0.6410248);
  hrf->SetBinContent(321, 0.6319933);
  hrf->SetBinContent(322, 0.6076105);
  hrf->SetBinContent(325, 0.695102);
  hrf->SetBinContent(326, 0.7317864);
  hrf->SetBinContent(327, 0.7151045);
  hrf->SetBinContent(328, 0.7259061);
  hrf->SetBinContent(329, 0.7057022);
  hrf->SetBinContent(330, 0.6724814);
  hrf->SetBinContent(331, 0.6533089);
  hrf->SetBinContent(332, 0.6532331);
  hrf->SetBinContent(333, 0.6235004);
  hrf->SetBinContent(334, 0.572711);
  hrf->SetBinContent(335, 0.5225867);
  hrf->SetBinContent(336, 0.5148557);
  hrf->SetBinContent(337, 0.4962895);
  hrf->SetBinContent(338, 0.4901881);
  hrf->SetBinContent(339, 0.468125);
  hrf->SetBinContent(340, 0.4836966);
  hrf->SetBinContent(341, 0.4867525);
  hrf->SetBinContent(342, 0.4971446);
  hrf->SetBinContent(343, 0.5154772);
  hrf->SetBinContent(344, 0.5200015);
  hrf->SetBinContent(345, 0.5336372);
  hrf->SetBinContent(346, 0.5606785);
  hrf->SetBinContent(347, 0.5553446);
  hrf->SetBinContent(348, 0.5552243);
  hrf->SetBinContent(349, 0.5668997);
  hrf->SetBinContent(350, 0.5681084);
  hrf->SetBinContent(351, 0.5711104);
  hrf->SetBinContent(352, 0.5574954);
  hrf->SetBinContent(353, 0.5491828);
  hrf->SetBinContent(354, 0.5546041);
  hrf->SetBinContent(355, 0.5383464);
  hrf->SetBinContent(356, 0.5327404);
  hrf->SetBinContent(357, 0.4987473);
  hrf->SetBinContent(358, 0.4961591);
  hrf->SetBinContent(359, 0.5059707);
  hrf->SetBinContent(360, 0.5101573);
  hrf->SetBinContent(361, 0.469202);
  hrf->SetBinContent(362, 0.4601543);
  hrf->SetBinContent(363, 0.4857516);
  hrf->SetBinContent(364, 0.4750769);
  hrf->SetBinContent(365, 0.4731531);
  hrf->SetBinContent(366, 0.4951779);
  hrf->SetBinContent(367, 0.5101241);
  hrf->SetBinContent(368, 0.5601708);
  hrf->SetBinContent(369, 0.5669625);
  hrf->SetBinContent(370, 0.5919175);
  hrf->SetBinContent(371, 0.6129183);
  hrf->SetBinContent(372, 0.6149203);
  hrf->SetBinContent(373, 0.6737269);
  hrf->SetBinContent(374, 0.6934542);
  hrf->SetBinContent(375, 0.6893013);
  hrf->SetBinContent(376, 0.6782404);
  hrf->SetBinContent(379, 0.7620484);
  hrf->SetBinContent(380, 0.7767984);
  hrf->SetBinContent(381, 0.768586);
  hrf->SetBinContent(382, 0.7613204);
  hrf->SetBinContent(383, 0.7180475);
  hrf->SetBinContent(384, 0.6963158);
  hrf->SetBinContent(385, 0.6779983);
  hrf->SetBinContent(386, 0.6694171);
  hrf->SetBinContent(387, 0.6588553);
  hrf->SetBinContent(388, 0.5652842);
  hrf->SetBinContent(389, 0.5554783);
  hrf->SetBinContent(390, 0.5424839);
  hrf->SetBinContent(391, 0.5428849);
  hrf->SetBinContent(392, 0.5169798);
  hrf->SetBinContent(393, 0.5124087);
  hrf->SetBinContent(394, 0.5164254);
  hrf->SetBinContent(395, 0.528432);
  hrf->SetBinContent(396, 0.5428852);
  hrf->SetBinContent(397, 0.5517648);
  hrf->SetBinContent(398, 0.5576946);
  hrf->SetBinContent(399, 0.5750021);
  hrf->SetBinContent(400, 0.6002611);
  hrf->SetBinContent(401, 0.5966565);
  hrf->SetBinContent(402, 0.5943705);
  hrf->SetBinContent(403, 0.6145469);
  hrf->SetBinContent(404, 0.607985);
  hrf->SetBinContent(405, 0.6166915);
  hrf->SetBinContent(406, 0.5980629);
  hrf->SetBinContent(407, 0.5841091);
  hrf->SetBinContent(408, 0.5817078);
  hrf->SetBinContent(409, 0.5839701);
  hrf->SetBinContent(410, 0.5622407);
  hrf->SetBinContent(411, 0.5501884);
  hrf->SetBinContent(412, 0.5395579);
  hrf->SetBinContent(413, 0.5392244);
  hrf->SetBinContent(414, 0.5121037);
  hrf->SetBinContent(415, 0.5086905);
  hrf->SetBinContent(416, 0.5099881);
  hrf->SetBinContent(417, 0.5213704);
  hrf->SetBinContent(418, 0.518967);
  hrf->SetBinContent(419, 0.5217742);
  hrf->SetBinContent(420, 0.5308712);
  hrf->SetBinContent(421, 0.533509);
  hrf->SetBinContent(422, 0.6000783);
  hrf->SetBinContent(423, 0.6004054);
  hrf->SetBinContent(424, 0.618421);
  hrf->SetBinContent(425, 0.6403746);
  hrf->SetBinContent(426, 0.6749609);
  hrf->SetBinContent(427, 0.7049621);
  hrf->SetBinContent(428, 0.7251113);
  hrf->SetBinContent(429, 0.746736);
  hrf->SetBinContent(430, 0.7463733);
  hrf->SetBinContent(433, 0.7768439);
  hrf->SetBinContent(434, 0.7947442);
  hrf->SetBinContent(435, 0.7912208);
  hrf->SetBinContent(436, 0.7809728);
  hrf->SetBinContent(437, 0.7551434);
  hrf->SetBinContent(438, 0.7318185);
  hrf->SetBinContent(439, 0.7093385);
  hrf->SetBinContent(440, 0.678341);
  hrf->SetBinContent(441, 0.6670629);
  hrf->SetBinContent(442, 0.5887975);
  hrf->SetBinContent(443, 0.5729458);
  hrf->SetBinContent(444, 0.5542971);
  hrf->SetBinContent(445, 0.5496716);
  hrf->SetBinContent(446, 0.5606599);
  hrf->SetBinContent(447, 0.5490948);
  hrf->SetBinContent(448, 0.5593737);
  hrf->SetBinContent(449, 0.5700086);
  hrf->SetBinContent(450, 0.5800818);
  hrf->SetBinContent(451, 0.5875502);
  hrf->SetBinContent(452, 0.5939422);
  hrf->SetBinContent(453, 0.6040691);
  hrf->SetBinContent(454, 0.6150405);
  hrf->SetBinContent(455, 0.6234732);
  hrf->SetBinContent(456, 0.6227227);
  hrf->SetBinContent(457, 0.6343882);
  hrf->SetBinContent(458, 0.6272793);
  hrf->SetBinContent(459, 0.632639);
  hrf->SetBinContent(460, 0.6219652);
  hrf->SetBinContent(461, 0.6143699);
  hrf->SetBinContent(462, 0.6189308);
  hrf->SetBinContent(463, 0.6092473);
  hrf->SetBinContent(464, 0.5857328);
  hrf->SetBinContent(465, 0.585558);
  hrf->SetBinContent(466, 0.5719752);
  hrf->SetBinContent(467, 0.5688713);
  hrf->SetBinContent(468, 0.5660589);
  hrf->SetBinContent(469, 0.5587242);
  hrf->SetBinContent(470, 0.5392494);
  hrf->SetBinContent(471, 0.5389499);
  hrf->SetBinContent(472, 0.54435);
  hrf->SetBinContent(473, 0.5380881);
  hrf->SetBinContent(474, 0.5513711);
  hrf->SetBinContent(475, 0.5579215);
  hrf->SetBinContent(476, 0.6440697);
  hrf->SetBinContent(477, 0.6357275);
  hrf->SetBinContent(478, 0.6576046);
  hrf->SetBinContent(479, 0.6791567);
  hrf->SetBinContent(480, 0.720274);
  hrf->SetBinContent(481, 0.7455162);
  hrf->SetBinContent(482, 0.7641031);
  hrf->SetBinContent(483, 0.7731579);
  hrf->SetBinContent(484, 0.7527794);
  hrf->SetBinContent(487, 0.7882684);
  hrf->SetBinContent(488, 0.8060328);
  hrf->SetBinContent(489, 0.822098);
  hrf->SetBinContent(490, 0.8099838);
  hrf->SetBinContent(491, 0.7939186);
  hrf->SetBinContent(492, 0.7642311);
  hrf->SetBinContent(493, 0.7266155);
  hrf->SetBinContent(494, 0.7093141);
  hrf->SetBinContent(495, 0.7159176);
  hrf->SetBinContent(496, 0.6176301);
  hrf->SetBinContent(497, 0.5909266);
  hrf->SetBinContent(498, 0.5775011);
  hrf->SetBinContent(499, 0.5636105);
  hrf->SetBinContent(500, 0.5605077);
  hrf->SetBinContent(501, 0.5591629);
  hrf->SetBinContent(502, 0.572946);
  hrf->SetBinContent(503, 0.588539);
  hrf->SetBinContent(504, 0.6028153);
  hrf->SetBinContent(505, 0.6043608);
  hrf->SetBinContent(506, 0.6062418);
  hrf->SetBinContent(507, 0.6114499);
  hrf->SetBinContent(508, 0.638523);
  hrf->SetBinContent(509, 0.6267287);
  hrf->SetBinContent(510, 0.645672);
  hrf->SetBinContent(511, 0.6506661);
  hrf->SetBinContent(512, 0.6475296);
  hrf->SetBinContent(513, 0.6484878);
  hrf->SetBinContent(514, 0.6513461);
  hrf->SetBinContent(515, 0.6442053);
  hrf->SetBinContent(516, 0.63371);
  hrf->SetBinContent(517, 0.6322624);
  hrf->SetBinContent(518, 0.6110942);
  hrf->SetBinContent(519, 0.6043542);
  hrf->SetBinContent(520, 0.6015413);
  hrf->SetBinContent(521, 0.6036028);
  hrf->SetBinContent(522, 0.5700738);
  hrf->SetBinContent(523, 0.5581338);
  hrf->SetBinContent(524, 0.5535045);
  hrf->SetBinContent(525, 0.5559112);
  hrf->SetBinContent(526, 0.5493221);
  hrf->SetBinContent(527, 0.5585357);
  hrf->SetBinContent(528, 0.5609397);
  hrf->SetBinContent(529, 0.5869038);
  hrf->SetBinContent(530, 0.6756232);
  hrf->SetBinContent(531, 0.6767399);
  hrf->SetBinContent(532, 0.674344);
  hrf->SetBinContent(533, 0.7147918);
  hrf->SetBinContent(534, 0.7455071);
  hrf->SetBinContent(535, 0.7640942);
  hrf->SetBinContent(536, 0.7841354);
  hrf->SetBinContent(537, 0.7800902);
  hrf->SetBinContent(538, 0.7629985);
  hrf->SetBinContent(541, 0.7825245);
  hrf->SetBinContent(542, 0.8104852);
  hrf->SetBinContent(543, 0.8185261);
  hrf->SetBinContent(544, 0.8149938);
  hrf->SetBinContent(545, 0.8051406);
  hrf->SetBinContent(546, 0.7840108);
  hrf->SetBinContent(547, 0.7692546);
  hrf->SetBinContent(548, 0.7316672);
  hrf->SetBinContent(549, 0.7493926);
  hrf->SetBinContent(550, 0.6496075);
  hrf->SetBinContent(551, 0.61375);
  hrf->SetBinContent(552, 0.5973386);
  hrf->SetBinContent(553, 0.5833439);
  hrf->SetBinContent(554, 0.5823619);
  hrf->SetBinContent(555, 0.575554);
  hrf->SetBinContent(556, 0.5877919);
  hrf->SetBinContent(557, 0.6007444);
  hrf->SetBinContent(558, 0.6090866);
  hrf->SetBinContent(559, 0.6100489);
  hrf->SetBinContent(560, 0.6170378);
  hrf->SetBinContent(561, 0.6346263);
  hrf->SetBinContent(562, 0.6551198);
  hrf->SetBinContent(563, 0.6504108);
  hrf->SetBinContent(564, 0.6529323);
  hrf->SetBinContent(565, 0.6615734);
  hrf->SetBinContent(566, 0.6708243);
  hrf->SetBinContent(567, 0.6619729);
  hrf->SetBinContent(568, 0.6477604);
  hrf->SetBinContent(569, 0.6553877);
  hrf->SetBinContent(570, 0.6341878);
  hrf->SetBinContent(571, 0.6327103);
  hrf->SetBinContent(572, 0.6286492);
  hrf->SetBinContent(573, 0.6085496);
  hrf->SetBinContent(574, 0.6167193);
  hrf->SetBinContent(575, 0.6131056);
  hrf->SetBinContent(576, 0.5831536);
  hrf->SetBinContent(577, 0.5811253);
  hrf->SetBinContent(578, 0.5723613);
  hrf->SetBinContent(579, 0.572602);
  hrf->SetBinContent(580, 0.5616767);
  hrf->SetBinContent(581, 0.5828878);
  hrf->SetBinContent(582, 0.6059858);
  hrf->SetBinContent(583, 0.6168311);
  hrf->SetBinContent(584, 0.7131738);
  hrf->SetBinContent(585, 0.7072036);
  hrf->SetBinContent(586, 0.7213496);
  hrf->SetBinContent(587, 0.7446843);
  hrf->SetBinContent(588, 0.7663606);
  hrf->SetBinContent(589, 0.789193);
  hrf->SetBinContent(590, 0.788421);
  hrf->SetBinContent(591, 0.792608);
  hrf->SetBinContent(592, 0.7788052);
  hrf->SetBinContent(595, 0.7937253);
  hrf->SetBinContent(596, 0.8081693);
  hrf->SetBinContent(597, 0.8123267);
  hrf->SetBinContent(598, 0.8186647);
  hrf->SetBinContent(599, 0.8086275);
  hrf->SetBinContent(600, 0.7988818);
  hrf->SetBinContent(601, 0.7764101);
  hrf->SetBinContent(602, 0.7557399);
  hrf->SetBinContent(603, 0.761918);
  hrf->SetBinContent(604, 0.6849239);
  hrf->SetBinContent(605, 0.6502788);
  hrf->SetBinContent(606, 0.6258788);
  hrf->SetBinContent(607, 0.599966);
  hrf->SetBinContent(608, 0.6106513);
  hrf->SetBinContent(609, 0.5952777);
  hrf->SetBinContent(610, 0.6028936);
  hrf->SetBinContent(611, 0.6079224);
  hrf->SetBinContent(612, 0.6182185);
  hrf->SetBinContent(613, 0.6233015);
  hrf->SetBinContent(614, 0.635029);
  hrf->SetBinContent(615, 0.6358883);
  hrf->SetBinContent(616, 0.6600642);
  hrf->SetBinContent(617, 0.6560737);
  hrf->SetBinContent(618, 0.6716946);
  hrf->SetBinContent(619, 0.6668878);
  hrf->SetBinContent(620, 0.6739189);
  hrf->SetBinContent(621, 0.67208);
  hrf->SetBinContent(622, 0.6692014);
  hrf->SetBinContent(623, 0.655094);
  hrf->SetBinContent(624, 0.6634452);
  hrf->SetBinContent(625, 0.6670687);
  hrf->SetBinContent(626, 0.6318665);
  hrf->SetBinContent(627, 0.625158);
  hrf->SetBinContent(628, 0.6202428);
  hrf->SetBinContent(629, 0.615028);
  hrf->SetBinContent(630, 0.5908931);
  hrf->SetBinContent(631, 0.5965393);
  hrf->SetBinContent(632, 0.5950192);
  hrf->SetBinContent(633, 0.5927112);
  hrf->SetBinContent(634, 0.591261);
  hrf->SetBinContent(635, 0.6102637);
  hrf->SetBinContent(636, 0.6186118);
  hrf->SetBinContent(637, 0.6456433);
  hrf->SetBinContent(638, 0.730924);
  hrf->SetBinContent(639, 0.7337946);
  hrf->SetBinContent(640, 0.7463949);
  hrf->SetBinContent(641, 0.7606013);
  hrf->SetBinContent(642, 0.7666355);
  hrf->SetBinContent(643, 0.7872874);
  hrf->SetBinContent(644, 0.8022897);
  hrf->SetBinContent(645, 0.7985926);
  hrf->SetBinContent(646, 0.783218);
  hrf->SetBinContent(649, 0.7833578);
  hrf->SetBinContent(650, 0.8143964);
  hrf->SetBinContent(651, 0.8124664);
  hrf->SetBinContent(652, 0.8186299);
  hrf->SetBinContent(653, 0.8080379);
  hrf->SetBinContent(654, 0.798955);
  hrf->SetBinContent(655, 0.7926162);
  hrf->SetBinContent(656, 0.7792218);
  hrf->SetBinContent(657, 0.7937103);
  hrf->SetBinContent(658, 0.6792807);
  hrf->SetBinContent(659, 0.6521104);
  hrf->SetBinContent(660, 0.6379001);
  hrf->SetBinContent(661, 0.6214611);
  hrf->SetBinContent(662, 0.6116367);
  hrf->SetBinContent(663, 0.6241148);
  hrf->SetBinContent(664, 0.6239313);
  hrf->SetBinContent(665, 0.6303791);
  hrf->SetBinContent(666, 0.6271608);
  hrf->SetBinContent(667, 0.6191924);
  hrf->SetBinContent(668, 0.6274444);
  hrf->SetBinContent(669, 0.6410729);
  hrf->SetBinContent(670, 0.6506072);
  hrf->SetBinContent(671, 0.6596943);
  hrf->SetBinContent(672, 0.6771609);
  hrf->SetBinContent(673, 0.6872007);
  hrf->SetBinContent(674, 0.6858186);
  hrf->SetBinContent(675, 0.6733634);
  hrf->SetBinContent(676, 0.6770326);
  hrf->SetBinContent(677, 0.6721333);
  hrf->SetBinContent(678, 0.6590305);
  hrf->SetBinContent(679, 0.6456032);
  hrf->SetBinContent(680, 0.6410897);
  hrf->SetBinContent(681, 0.6299676);
  hrf->SetBinContent(682, 0.6255311);
  hrf->SetBinContent(683, 0.6248432);
  hrf->SetBinContent(684, 0.6123951);
  hrf->SetBinContent(685, 0.6165767);
  hrf->SetBinContent(686, 0.6150315);
  hrf->SetBinContent(687, 0.6173973);
  hrf->SetBinContent(688, 0.6240689);
  hrf->SetBinContent(689, 0.6187074);
  hrf->SetBinContent(690, 0.6461738);
  hrf->SetBinContent(691, 0.6547161);
  hrf->SetBinContent(692, 0.7550126);
  hrf->SetBinContent(693, 0.7437691);
  hrf->SetBinContent(694, 0.7466658);
  hrf->SetBinContent(695, 0.7647577);
  hrf->SetBinContent(696, 0.775592);
  hrf->SetBinContent(697, 0.8015463);
  hrf->SetBinContent(698, 0.796218);
  hrf->SetBinContent(699, 0.7938139);
  hrf->SetBinContent(700, 0.7877747);
  hrf->SetBinContent(703, 0.7938337);
  hrf->SetBinContent(704, 0.8112386);
  hrf->SetBinContent(705, 0.8210182);
  hrf->SetBinContent(706, 0.8071941);
  hrf->SetBinContent(707, 0.8099721);
  hrf->SetBinContent(708, 0.8184054);
  hrf->SetBinContent(709, 0.7795862);
  hrf->SetBinContent(710, 0.781167);
  hrf->SetBinContent(711, 0.8112692);
  hrf->SetBinContent(712, 0.7050076);
  hrf->SetBinContent(713, 0.6961941);
  hrf->SetBinContent(714, 0.6431594);
  hrf->SetBinContent(715, 0.6518742);
  hrf->SetBinContent(716, 0.6676597);
  hrf->SetBinContent(717, 0.6348912);
  hrf->SetBinContent(718, 0.6320897);
  hrf->SetBinContent(719, 0.6619865);
  hrf->SetBinContent(720, 0.6408801);
  hrf->SetBinContent(721, 0.6611646);
  hrf->SetBinContent(722, 0.6469863);
  hrf->SetBinContent(723, 0.6624107);
  hrf->SetBinContent(724, 0.6726641);
  hrf->SetBinContent(725, 0.6769128);
  hrf->SetBinContent(726, 0.6586064);
  hrf->SetBinContent(727, 0.6795991);
  hrf->SetBinContent(728, 0.6835785);
  hrf->SetBinContent(729, 0.6803078);
  hrf->SetBinContent(730, 0.6512326);
  hrf->SetBinContent(731, 0.6668034);
  hrf->SetBinContent(732, 0.6699911);
  hrf->SetBinContent(733, 0.6659495);
  hrf->SetBinContent(734, 0.656548);
  hrf->SetBinContent(735, 0.6311177);
  hrf->SetBinContent(736, 0.6385864);
  hrf->SetBinContent(737, 0.6526698);
  hrf->SetBinContent(738, 0.639952);
  hrf->SetBinContent(739, 0.6367444);
  hrf->SetBinContent(740, 0.6429572);
  hrf->SetBinContent(741, 0.6484692);
  hrf->SetBinContent(742, 0.6525394);
  hrf->SetBinContent(743, 0.6626204);
  hrf->SetBinContent(744, 0.6566104);
  hrf->SetBinContent(745, 0.6963196);
  hrf->SetBinContent(746, 0.7744267);
  hrf->SetBinContent(747, 0.7619394);
  hrf->SetBinContent(748, 0.7550142);
  hrf->SetBinContent(749, 0.7694419);
  hrf->SetBinContent(750, 0.7913394);
  hrf->SetBinContent(751, 0.7817686);
  hrf->SetBinContent(752, 0.8011637);
  hrf->SetBinContent(753, 0.8001197);
  hrf->SetBinContent(754, 0.7766893);
  hrf->SetBinContent(757, 0.820311);
  hrf->SetBinContent(758, 0.8292386);
  hrf->SetBinContent(759, 0.8256704);
  hrf->SetBinContent(760, 0.829048);
  hrf->SetBinContent(761, 0.8125483);
  hrf->SetBinContent(762, 0.7970028);
  hrf->SetBinContent(763, 0.7941346);
  hrf->SetBinContent(764, 0.7978353);
  hrf->SetBinContent(765, 0.8145937);
  hrf->SetBinContent(766, 0.7018598);
  hrf->SetBinContent(767, 0.7004585);
  hrf->SetBinContent(768, 0.7196865);
  hrf->SetBinContent(769, 0.6887961);
  hrf->SetBinContent(770, 0.6803226);
  hrf->SetBinContent(771, 0.6630092);
  hrf->SetBinContent(772, 0.6932864);
  hrf->SetBinContent(773, 0.706134);
  hrf->SetBinContent(774, 0.696236);
  hrf->SetBinContent(775, 0.6888376);
  hrf->SetBinContent(776, 0.6966027);
  hrf->SetBinContent(777, 0.6895446);
  hrf->SetBinContent(778, 0.7041351);
  hrf->SetBinContent(779, 0.6794392);
  hrf->SetBinContent(780, 0.7072135);
  hrf->SetBinContent(781, 0.7116039);
  hrf->SetBinContent(782, 0.6892277);
  hrf->SetBinContent(783, 0.706095);
  hrf->SetBinContent(784, 0.6947418);
  hrf->SetBinContent(785, 0.6904655);
  hrf->SetBinContent(786, 0.7099751);
  hrf->SetBinContent(787, 0.6884425);
  hrf->SetBinContent(788, 0.6930832);
  hrf->SetBinContent(789, 0.6803646);
  hrf->SetBinContent(790, 0.6844568);
  hrf->SetBinContent(791, 0.7109603);
  hrf->SetBinContent(792, 0.6615306);
  hrf->SetBinContent(793, 0.6706332);
  hrf->SetBinContent(794, 0.6790296);
  hrf->SetBinContent(795, 0.6676587);
  hrf->SetBinContent(796, 0.6811136);
  hrf->SetBinContent(797, 0.6759658);
  hrf->SetBinContent(798, 0.674715);
  hrf->SetBinContent(799, 0.6981677);
  hrf->SetBinContent(800, 0.8118564);
  hrf->SetBinContent(801, 0.7796713);
  hrf->SetBinContent(802, 0.763272);
  hrf->SetBinContent(803, 0.802313);
  hrf->SetBinContent(804, 0.7997385);
  hrf->SetBinContent(805, 0.8228589);
  hrf->SetBinContent(806, 0.8193119);
  hrf->SetBinContent(807, 0.8061456);
  hrf->SetBinContent(808, 0.8093062);
  hrf->SetBinContent(811, 0.8216234);
  hrf->SetBinContent(812, 0.8354314);
  hrf->SetBinContent(813, 0.8415214);
  hrf->SetBinContent(814, 0.8391747);
  hrf->SetBinContent(815, 0.8323319);
  hrf->SetBinContent(816, 0.8270521);
  hrf->SetBinContent(817, 0.8224217);
  hrf->SetBinContent(818, 0.8044508);
  hrf->SetBinContent(819, 0.8186831);
  hrf->SetBinContent(820, 0.7421715);
  hrf->SetBinContent(821, 0.7278701);
  hrf->SetBinContent(822, 0.7248921);
  hrf->SetBinContent(823, 0.7085358);
  hrf->SetBinContent(824, 0.7273098);
  hrf->SetBinContent(825, 0.7099549);
  hrf->SetBinContent(826, 0.7194818);
  hrf->SetBinContent(827, 0.7102996);
  hrf->SetBinContent(828, 0.7120496);
  hrf->SetBinContent(829, 0.6897885);
  hrf->SetBinContent(830, 0.7198567);
  hrf->SetBinContent(831, 0.7074706);
  hrf->SetBinContent(832, 0.7436482);
  hrf->SetBinContent(833, 0.7269113);
  hrf->SetBinContent(834, 0.7285385);
  hrf->SetBinContent(835, 0.7222486);
  hrf->SetBinContent(836, 0.7284775);
  hrf->SetBinContent(837, 0.7315693);
  hrf->SetBinContent(838, 0.7165666);
  hrf->SetBinContent(839, 0.7153305);
  hrf->SetBinContent(840, 0.7235847);
  hrf->SetBinContent(841, 0.7258299);
  hrf->SetBinContent(842, 0.6954121);
  hrf->SetBinContent(843, 0.7152382);
  hrf->SetBinContent(844, 0.7054994);
  hrf->SetBinContent(845, 0.7109909);
  hrf->SetBinContent(846, 0.7096459);
  hrf->SetBinContent(847, 0.7089959);
  hrf->SetBinContent(848, 0.7104192);
  hrf->SetBinContent(849, 0.7059513);
  hrf->SetBinContent(850, 0.7137704);
  hrf->SetBinContent(851, 0.6904989);
  hrf->SetBinContent(852, 0.6933109);
  hrf->SetBinContent(853, 0.6949823);
  hrf->SetBinContent(854, 0.8213119);
  hrf->SetBinContent(855, 0.7834505);
  hrf->SetBinContent(856, 0.7924478);
  hrf->SetBinContent(857, 0.8016196);
  hrf->SetBinContent(858, 0.8097603);
  hrf->SetBinContent(859, 0.8196169);
  hrf->SetBinContent(860, 0.8230559);
  hrf->SetBinContent(861, 0.8199641);
  hrf->SetBinContent(862, 0.8192365);
  hrf->SetBinContent(865, 0.8382419);
  hrf->SetBinContent(866, 0.845595);
  hrf->SetBinContent(867, 0.8503338);
  hrf->SetBinContent(868, 0.8361135);
  hrf->SetBinContent(869, 0.8315856);
  hrf->SetBinContent(870, 0.8295157);
  hrf->SetBinContent(871, 0.8086463);
  hrf->SetBinContent(872, 0.8109902);
  hrf->SetBinContent(873, 0.8548921);
  hrf->SetBinContent(874, 0.7384512);
  hrf->SetBinContent(875, 0.7409762);
  hrf->SetBinContent(876, 0.7325699);
  hrf->SetBinContent(877, 0.7097699);
  hrf->SetBinContent(878, 0.7247443);
  hrf->SetBinContent(879, 0.7235974);
  hrf->SetBinContent(880, 0.7174981);
  hrf->SetBinContent(881, 0.7266588);
  hrf->SetBinContent(882, 0.7376115);
  hrf->SetBinContent(883, 0.7187032);
  hrf->SetBinContent(884, 0.7486984);
  hrf->SetBinContent(885, 0.7418073);
  hrf->SetBinContent(886, 0.7484841);
  hrf->SetBinContent(887, 0.751286);
  hrf->SetBinContent(888, 0.7288724);
  hrf->SetBinContent(889, 0.7500471);
  hrf->SetBinContent(890, 0.7496704);
  hrf->SetBinContent(891, 0.7595446);
  hrf->SetBinContent(892, 0.7479168);
  hrf->SetBinContent(893, 0.728943);
  hrf->SetBinContent(894, 0.7336915);
  hrf->SetBinContent(895, 0.7499863);
  hrf->SetBinContent(896, 0.7286334);
  hrf->SetBinContent(897, 0.7333577);
  hrf->SetBinContent(898, 0.7461608);
  hrf->SetBinContent(899, 0.7439096);
  hrf->SetBinContent(900, 0.7328548);
  hrf->SetBinContent(901, 0.7203813);
  hrf->SetBinContent(902, 0.7064649);
  hrf->SetBinContent(903, 0.7314181);
  hrf->SetBinContent(904, 0.7103841);
  hrf->SetBinContent(905, 0.7173302);
  hrf->SetBinContent(906, 0.7135867);
  hrf->SetBinContent(907, 0.741744);
  hrf->SetBinContent(908, 0.818104);
  hrf->SetBinContent(909, 0.8024629);
  hrf->SetBinContent(910, 0.7906242);
  hrf->SetBinContent(911, 0.8110136);
  hrf->SetBinContent(912, 0.8172796);
  hrf->SetBinContent(913, 0.8291269);
  hrf->SetBinContent(914, 0.8308977);
  hrf->SetBinContent(915, 0.8352684);
  hrf->SetBinContent(916, 0.8211952);
  hrf->SetBinContent(919, 0.8330466);
  hrf->SetBinContent(920, 0.8527036);
  hrf->SetBinContent(921, 0.8498238);
  hrf->SetBinContent(922, 0.827491);
  hrf->SetBinContent(923, 0.8453093);
  hrf->SetBinContent(924, 0.8489227);
  hrf->SetBinContent(925, 0.8275191);
  hrf->SetBinContent(926, 0.8346153);
  hrf->SetBinContent(927, 0.8487738);
  hrf->SetBinContent(928, 0.742582);
  hrf->SetBinContent(929, 0.7093365);
  hrf->SetBinContent(930, 0.7261602);
  hrf->SetBinContent(931, 0.7267539);
  hrf->SetBinContent(932, 0.73264);
  hrf->SetBinContent(933, 0.7330359);
  hrf->SetBinContent(934, 0.7598708);
  hrf->SetBinContent(935, 0.7562078);
  hrf->SetBinContent(936, 0.7556384);
  hrf->SetBinContent(937, 0.7403131);
  hrf->SetBinContent(938, 0.7492656);
  hrf->SetBinContent(939, 0.7432143);
  hrf->SetBinContent(940, 0.7788419);
  hrf->SetBinContent(941, 0.7632285);
  hrf->SetBinContent(942, 0.7679126);
  hrf->SetBinContent(943, 0.763468);
  hrf->SetBinContent(944, 0.777601);
  hrf->SetBinContent(945, 0.7735646);
  hrf->SetBinContent(946, 0.7563925);
  hrf->SetBinContent(947, 0.7574112);
  hrf->SetBinContent(948, 0.7594496);
  hrf->SetBinContent(949, 0.7542186);
  hrf->SetBinContent(950, 0.7722836);
  hrf->SetBinContent(951, 0.7630916);
  hrf->SetBinContent(952, 0.7554187);
  hrf->SetBinContent(953, 0.7640414);
  hrf->SetBinContent(954, 0.7528413);
  hrf->SetBinContent(955, 0.7536849);
  hrf->SetBinContent(956, 0.7522911);
  hrf->SetBinContent(957, 0.7423979);
  hrf->SetBinContent(958, 0.708038);
  hrf->SetBinContent(959, 0.7218878);
  hrf->SetBinContent(960, 0.7022091);
  hrf->SetBinContent(961, 0.7171525);
  hrf->SetBinContent(962, 0.8275716);
  hrf->SetBinContent(963, 0.8115073);
  hrf->SetBinContent(964, 0.8072334);
  hrf->SetBinContent(965, 0.821391);
  hrf->SetBinContent(966, 0.8269891);
  hrf->SetBinContent(967, 0.819416);
  hrf->SetBinContent(968, 0.8243529);
  hrf->SetBinContent(969, 0.8403612);
  hrf->SetBinContent(970, 0.8189063);
  hrf->SetBinContent(973, 0.8403836);
  hrf->SetBinContent(974, 0.8490381);
  hrf->SetBinContent(975, 0.8456935);
  hrf->SetBinContent(976, 0.8505681);
  hrf->SetBinContent(977, 0.8546844);
  hrf->SetBinContent(978, 0.8301553);
  hrf->SetBinContent(979, 0.8285958);
  hrf->SetBinContent(980, 0.8272412);
  hrf->SetBinContent(981, 0.8588659);
  hrf->SetBinContent(982, 0.772503);
  hrf->SetBinContent(983, 0.725534);
  hrf->SetBinContent(984, 0.7240637);
  hrf->SetBinContent(985, 0.7158327);
  hrf->SetBinContent(986, 0.7553988);
  hrf->SetBinContent(987, 0.7408262);
  hrf->SetBinContent(988, 0.7482234);
  hrf->SetBinContent(989, 0.7603509);
  hrf->SetBinContent(990, 0.7626927);
  hrf->SetBinContent(991, 0.7681577);
  hrf->SetBinContent(992, 0.7773151);
  hrf->SetBinContent(993, 0.783787);
  hrf->SetBinContent(994, 0.8194669);
  hrf->SetBinContent(995, 0.7892821);
  hrf->SetBinContent(996, 0.7875675);
  hrf->SetBinContent(997, 0.8082216);
  hrf->SetBinContent(998, 0.7857646);
  hrf->SetBinContent(999, 0.7933624);
  hrf->SetBinContent(1000, 0.7899764);
  hrf->SetBinContent(1001, 0.7918435);
  hrf->SetBinContent(1002, 0.7880425);
  hrf->SetBinContent(1003, 0.803874);
  hrf->SetBinContent(1004, 0.7770123);
  hrf->SetBinContent(1005, 0.7597779);
  hrf->SetBinContent(1006, 0.7721595);
  hrf->SetBinContent(1007, 0.781916);
  hrf->SetBinContent(1008, 0.7635601);
  hrf->SetBinContent(1009, 0.7448658);
  hrf->SetBinContent(1010, 0.7392351);
  hrf->SetBinContent(1011, 0.750661);
  hrf->SetBinContent(1012, 0.7487038);
  hrf->SetBinContent(1013, 0.7231168);
  hrf->SetBinContent(1014, 0.7470311);
  hrf->SetBinContent(1015, 0.7612622);
  hrf->SetBinContent(1016, 0.8279294);
  hrf->SetBinContent(1017, 0.8297408);
  hrf->SetBinContent(1018, 0.8170992);
  hrf->SetBinContent(1019, 0.8319517);
  hrf->SetBinContent(1020, 0.8270144);
  hrf->SetBinContent(1021, 0.8398628);
  hrf->SetBinContent(1022, 0.8434333);
  hrf->SetBinContent(1023, 0.8495445);
  hrf->SetBinContent(1024, 0.8397221);
  hrf->SetBinContent(1027, 0.8584861);
  hrf->SetBinContent(1028, 0.8705266);
  hrf->SetBinContent(1029, 0.8648553);
  hrf->SetBinContent(1030, 0.8693198);
  hrf->SetBinContent(1031, 0.8604742);
  hrf->SetBinContent(1032, 0.8419744);
  hrf->SetBinContent(1033, 0.8488627);
  hrf->SetBinContent(1034, 0.8596818);
  hrf->SetBinContent(1035, 0.8761161);
  hrf->SetBinContent(1036, 0.7735379);
  hrf->SetBinContent(1037, 0.7636802);
  hrf->SetBinContent(1038, 0.7415009);
  hrf->SetBinContent(1039, 0.7392672);
  hrf->SetBinContent(1040, 0.7662926);
  hrf->SetBinContent(1041, 0.7740963);
  hrf->SetBinContent(1042, 0.7629296);
  hrf->SetBinContent(1043, 0.7746271);
  hrf->SetBinContent(1044, 0.7922689);
  hrf->SetBinContent(1045, 0.7945601);
  hrf->SetBinContent(1046, 0.8078181);
  hrf->SetBinContent(1047, 0.7982591);
  hrf->SetBinContent(1048, 0.8149709);
  hrf->SetBinContent(1049, 0.8178119);
  hrf->SetBinContent(1050, 0.8224007);
  hrf->SetBinContent(1051, 0.8259245);
  hrf->SetBinContent(1052, 0.8287166);
  hrf->SetBinContent(1053, 0.8284407);
  hrf->SetBinContent(1054, 0.8248709);
  hrf->SetBinContent(1055, 0.8112228);
  hrf->SetBinContent(1056, 0.8003991);
  hrf->SetBinContent(1057, 0.7915207);
  hrf->SetBinContent(1058, 0.7917442);
  hrf->SetBinContent(1059, 0.8076987);
  hrf->SetBinContent(1060, 0.784733);
  hrf->SetBinContent(1061, 0.7987387);
  hrf->SetBinContent(1062, 0.7665949);
  hrf->SetBinContent(1063, 0.7750866);
  hrf->SetBinContent(1064, 0.7578187);
  hrf->SetBinContent(1065, 0.7470792);
  hrf->SetBinContent(1066, 0.7387265);
  hrf->SetBinContent(1067, 0.7308708);
  hrf->SetBinContent(1068, 0.7565303);
  hrf->SetBinContent(1069, 0.7838886);
  hrf->SetBinContent(1070, 0.8566341);
  hrf->SetBinContent(1071, 0.8414668);
  hrf->SetBinContent(1072, 0.8493964);
  hrf->SetBinContent(1073, 0.8408482);
  hrf->SetBinContent(1074, 0.8442303);
  hrf->SetBinContent(1075, 0.8555998);
  hrf->SetBinContent(1076, 0.8573167);
  hrf->SetBinContent(1077, 0.8615545);
  hrf->SetBinContent(1078, 0.8546741);
  hrf->SetBinContent(1081, 0.8591975);
  hrf->SetBinContent(1082, 0.8709853);
  hrf->SetBinContent(1083, 0.8771328);
  hrf->SetBinContent(1084, 0.8763101);
  hrf->SetBinContent(1085, 0.8515683);
  hrf->SetBinContent(1086, 0.8732017);
  hrf->SetBinContent(1087, 0.8560926);
  hrf->SetBinContent(1088, 0.8562469);
  hrf->SetBinContent(1089, 0.8875264);
  hrf->SetBinContent(1090, 0.7832932);
  hrf->SetBinContent(1091, 0.7675187);
  hrf->SetBinContent(1092, 0.7683659);
  hrf->SetBinContent(1093, 0.7504796);
  hrf->SetBinContent(1094, 0.7859329);
  hrf->SetBinContent(1095, 0.7694483);
  hrf->SetBinContent(1096, 0.7806211);
  hrf->SetBinContent(1097, 0.7954605);
  hrf->SetBinContent(1098, 0.8084871);
  hrf->SetBinContent(1099, 0.8044314);
  hrf->SetBinContent(1100, 0.7899461);
  hrf->SetBinContent(1101, 0.8162944);
  hrf->SetBinContent(1102, 0.8343187);
  hrf->SetBinContent(1103, 0.8230114);
  hrf->SetBinContent(1104, 0.812171);
  hrf->SetBinContent(1105, 0.8203622);
  hrf->SetBinContent(1106, 0.8227281);
  hrf->SetBinContent(1107, 0.8324733);
  hrf->SetBinContent(1108, 0.8200341);
  hrf->SetBinContent(1109, 0.8198539);
  hrf->SetBinContent(1110, 0.830998);
  hrf->SetBinContent(1111, 0.8143437);
  hrf->SetBinContent(1112, 0.8231221);
  hrf->SetBinContent(1113, 0.8290741);
  hrf->SetBinContent(1114, 0.8044104);
  hrf->SetBinContent(1115, 0.8085917);
  hrf->SetBinContent(1116, 0.7965005);
  hrf->SetBinContent(1117, 0.7736762);
  hrf->SetBinContent(1118, 0.7865528);
  hrf->SetBinContent(1119, 0.7845833);
  hrf->SetBinContent(1120, 0.7356455);
  hrf->SetBinContent(1121, 0.7719955);
  hrf->SetBinContent(1122, 0.7799032);
  hrf->SetBinContent(1123, 0.7859467);
  hrf->SetBinContent(1124, 0.8770262);
  hrf->SetBinContent(1125, 0.847388);
  hrf->SetBinContent(1126, 0.8384124);
  hrf->SetBinContent(1127, 0.8508531);
  hrf->SetBinContent(1128, 0.8527084);
  hrf->SetBinContent(1129, 0.8647637);
  hrf->SetBinContent(1130, 0.8652126);
  hrf->SetBinContent(1131, 0.8690927);
  hrf->SetBinContent(1132, 0.8697549);
  hrf->SetBinContent(1135, 0.8678578);
  hrf->SetBinContent(1136, 0.8721905);
  hrf->SetBinContent(1137, 0.8771986);
  hrf->SetBinContent(1138, 0.8798792);
  hrf->SetBinContent(1139, 0.8788907);
  hrf->SetBinContent(1140, 0.8633229);
  hrf->SetBinContent(1141, 0.8740997);
  hrf->SetBinContent(1142, 0.856037);
  hrf->SetBinContent(1143, 0.887048);
  hrf->SetBinContent(1144, 0.8030304);
  hrf->SetBinContent(1145, 0.7964841);
  hrf->SetBinContent(1146, 0.7718329);
  hrf->SetBinContent(1147, 0.7641056);
  hrf->SetBinContent(1148, 0.7686037);
  hrf->SetBinContent(1149, 0.7824436);
  hrf->SetBinContent(1150, 0.7878762);
  hrf->SetBinContent(1151, 0.8071508);
  hrf->SetBinContent(1152, 0.8079754);
  hrf->SetBinContent(1153, 0.8146648);
  hrf->SetBinContent(1154, 0.8261297);
  hrf->SetBinContent(1155, 0.8238618);
  hrf->SetBinContent(1156, 0.8342342);
  hrf->SetBinContent(1157, 0.8386516);
  hrf->SetBinContent(1158, 0.8238772);
  hrf->SetBinContent(1159, 0.8355077);
  hrf->SetBinContent(1160, 0.8530656);
  hrf->SetBinContent(1161, 0.8270102);
  hrf->SetBinContent(1162, 0.8280492);
  hrf->SetBinContent(1163, 0.8212458);
  hrf->SetBinContent(1164, 0.8266846);
  hrf->SetBinContent(1165, 0.8268626);
  hrf->SetBinContent(1166, 0.8331493);
  hrf->SetBinContent(1167, 0.813269);
  hrf->SetBinContent(1168, 0.8189407);
  hrf->SetBinContent(1169, 0.803855);
  hrf->SetBinContent(1170, 0.7985492);
  hrf->SetBinContent(1171, 0.8035755);
  hrf->SetBinContent(1172, 0.7932234);
  hrf->SetBinContent(1173, 0.7919983);
  hrf->SetBinContent(1174, 0.7780269);
  hrf->SetBinContent(1175, 0.7745364);
  hrf->SetBinContent(1176, 0.7764118);
  hrf->SetBinContent(1177, 0.8024556);
  hrf->SetBinContent(1178, 0.8828636);
  hrf->SetBinContent(1179, 0.8603634);
  hrf->SetBinContent(1180, 0.8476664);
  hrf->SetBinContent(1181, 0.8649756);
  hrf->SetBinContent(1182, 0.8686491);
  hrf->SetBinContent(1183, 0.879);
  hrf->SetBinContent(1184, 0.8710791);
  hrf->SetBinContent(1185, 0.8777198);
  hrf->SetBinContent(1186, 0.8720512);
  hrf->SetBinContent(1189, 0.8738415);
  hrf->SetBinContent(1190, 0.8861113);
  hrf->SetBinContent(1191, 0.8809734);
  hrf->SetBinContent(1192, 0.8953835);
  hrf->SetBinContent(1193, 0.8797553);
  hrf->SetBinContent(1194, 0.8663118);
  hrf->SetBinContent(1195, 0.8772114);
  hrf->SetBinContent(1196, 0.8705546);
  hrf->SetBinContent(1197, 0.8862349);
  hrf->SetBinContent(1198, 0.8061298);
  hrf->SetBinContent(1199, 0.7902361);
  hrf->SetBinContent(1200, 0.778208);
  hrf->SetBinContent(1201, 0.7780085);
  hrf->SetBinContent(1202, 0.8111438);
  hrf->SetBinContent(1203, 0.7892882);
  hrf->SetBinContent(1204, 0.8093601);
  hrf->SetBinContent(1205, 0.8006216);
  hrf->SetBinContent(1206, 0.8030534);
  hrf->SetBinContent(1207, 0.8418001);
  hrf->SetBinContent(1208, 0.8177408);
  hrf->SetBinContent(1209, 0.836045);
  hrf->SetBinContent(1210, 0.8453377);
  hrf->SetBinContent(1211, 0.8403149);
  hrf->SetBinContent(1212, 0.8373511);
  hrf->SetBinContent(1213, 0.8503633);
  hrf->SetBinContent(1214, 0.8382619);
  hrf->SetBinContent(1215, 0.8430184);
  hrf->SetBinContent(1216, 0.8487076);
  hrf->SetBinContent(1217, 0.8495836);
  hrf->SetBinContent(1218, 0.8313101);
  hrf->SetBinContent(1219, 0.837076);
  hrf->SetBinContent(1220, 0.835078);
  hrf->SetBinContent(1221, 0.8362027);
  hrf->SetBinContent(1222, 0.8226167);
  hrf->SetBinContent(1223, 0.8357954);
  hrf->SetBinContent(1224, 0.816876);
  hrf->SetBinContent(1225, 0.8086238);
  hrf->SetBinContent(1226, 0.7925934);
  hrf->SetBinContent(1227, 0.7871425);
  hrf->SetBinContent(1228, 0.7787439);
  hrf->SetBinContent(1229, 0.7699108);
  hrf->SetBinContent(1230, 0.7912937);
  hrf->SetBinContent(1231, 0.8084047);
  hrf->SetBinContent(1232, 0.8865966);
  hrf->SetBinContent(1233, 0.8652479);
  hrf->SetBinContent(1234, 0.8537798);
  hrf->SetBinContent(1235, 0.86984);
  hrf->SetBinContent(1236, 0.8673007);
  hrf->SetBinContent(1237, 0.8768569);
  hrf->SetBinContent(1238, 0.8813039);
  hrf->SetBinContent(1239, 0.8832306);
  hrf->SetBinContent(1240, 0.878592);
  hrf->SetBinContent(1243, 0.8715378);
  hrf->SetBinContent(1244, 0.8861935);
  hrf->SetBinContent(1245, 0.8852835);
  hrf->SetBinContent(1246, 0.8787801);
  hrf->SetBinContent(1247, 0.8783889);
  hrf->SetBinContent(1248, 0.8855093);
  hrf->SetBinContent(1249, 0.8748751);
  hrf->SetBinContent(1250, 0.8728771);
  hrf->SetBinContent(1251, 0.9018467);
  hrf->SetBinContent(1252, 0.8249069);
  hrf->SetBinContent(1253, 0.8002755);
  hrf->SetBinContent(1254, 0.7838525);
  hrf->SetBinContent(1255, 0.7903357);
  hrf->SetBinContent(1256, 0.7916073);
  hrf->SetBinContent(1257, 0.7985547);
  hrf->SetBinContent(1258, 0.8262318);
  hrf->SetBinContent(1259, 0.8094212);
  hrf->SetBinContent(1260, 0.8267502);
  hrf->SetBinContent(1261, 0.8316746);
  hrf->SetBinContent(1262, 0.8368371);
  hrf->SetBinContent(1263, 0.8482142);
  hrf->SetBinContent(1264, 0.8502672);
  hrf->SetBinContent(1265, 0.8363052);
  hrf->SetBinContent(1266, 0.8458726);
  hrf->SetBinContent(1267, 0.8617958);
  hrf->SetBinContent(1268, 0.8571753);
  hrf->SetBinContent(1269, 0.8481821);
  hrf->SetBinContent(1270, 0.8443859);
  hrf->SetBinContent(1271, 0.8364177);
  hrf->SetBinContent(1272, 0.8381643);
  hrf->SetBinContent(1273, 0.8412254);
  hrf->SetBinContent(1274, 0.8447568);
  hrf->SetBinContent(1275, 0.8186399);
  hrf->SetBinContent(1276, 0.8319127);
  hrf->SetBinContent(1277, 0.8139984);
  hrf->SetBinContent(1278, 0.8199334);
  hrf->SetBinContent(1279, 0.8115138);
  hrf->SetBinContent(1280, 0.801327);
  hrf->SetBinContent(1281, 0.7812868);
  hrf->SetBinContent(1282, 0.7778735);
  hrf->SetBinContent(1283, 0.7987794);
  hrf->SetBinContent(1284, 0.7824721);
  hrf->SetBinContent(1285, 0.8182753);
  hrf->SetBinContent(1286, 0.8761631);
  hrf->SetBinContent(1287, 0.877906);
  hrf->SetBinContent(1288, 0.8828306);
  hrf->SetBinContent(1289, 0.8631628);
  hrf->SetBinContent(1290, 0.8747018);
  hrf->SetBinContent(1291, 0.8816374);
  hrf->SetBinContent(1292, 0.8905643);
  hrf->SetBinContent(1293, 0.8805439);
  hrf->SetBinContent(1294, 0.8729373);
  hrf->SetBinContent(1297, 0.8870085);
  hrf->SetBinContent(1298, 0.8991774);
  hrf->SetBinContent(1299, 0.8926399);
  hrf->SetBinContent(1300, 0.8870129);
  hrf->SetBinContent(1301, 0.8906647);
  hrf->SetBinContent(1302, 0.8820221);
  hrf->SetBinContent(1303, 0.8845586);
  hrf->SetBinContent(1304, 0.8838417);
  hrf->SetBinContent(1305, 0.8976349);
  hrf->SetBinContent(1306, 0.8372204);
  hrf->SetBinContent(1307, 0.8087633);
  hrf->SetBinContent(1308, 0.7906018);
  hrf->SetBinContent(1309, 0.7978083);
  hrf->SetBinContent(1310, 0.8068362);
  hrf->SetBinContent(1311, 0.8253238);
  hrf->SetBinContent(1312, 0.8308318);
  hrf->SetBinContent(1313, 0.830837);
  hrf->SetBinContent(1314, 0.843081);
  hrf->SetBinContent(1315, 0.8388117);
  hrf->SetBinContent(1316, 0.8409643);
  hrf->SetBinContent(1317, 0.8563442);
  hrf->SetBinContent(1318, 0.8509172);
  hrf->SetBinContent(1319, 0.8564285);
  hrf->SetBinContent(1320, 0.8673294);
  hrf->SetBinContent(1321, 0.8626825);
  hrf->SetBinContent(1322, 0.8700428);
  hrf->SetBinContent(1323, 0.8636473);
  hrf->SetBinContent(1324, 0.8590862);
  hrf->SetBinContent(1325, 0.8522475);
  hrf->SetBinContent(1326, 0.8558971);
  hrf->SetBinContent(1327, 0.8603112);
  hrf->SetBinContent(1328, 0.842573);
  hrf->SetBinContent(1329, 0.8557246);
  hrf->SetBinContent(1330, 0.8234622);
  hrf->SetBinContent(1331, 0.8358622);
  hrf->SetBinContent(1332, 0.8263366);
  hrf->SetBinContent(1333, 0.8189109);
  hrf->SetBinContent(1334, 0.816338);
  hrf->SetBinContent(1335, 0.8143541);
  hrf->SetBinContent(1336, 0.7975664);
  hrf->SetBinContent(1337, 0.7881635);
  hrf->SetBinContent(1338, 0.7916959);
  hrf->SetBinContent(1339, 0.8189511);
  hrf->SetBinContent(1340, 0.8926195);
  hrf->SetBinContent(1341, 0.8730372);
  hrf->SetBinContent(1342, 0.8798155);
  hrf->SetBinContent(1343, 0.8815677);
  hrf->SetBinContent(1344, 0.8766184);
  hrf->SetBinContent(1345, 0.8825352);
  hrf->SetBinContent(1346, 0.8861911);
  hrf->SetBinContent(1347, 0.8899728);
  hrf->SetBinContent(1348, 0.8807881);
  hrf->SetBinContent(1351, 0.8982675);
  hrf->SetBinContent(1352, 0.9019269);
  hrf->SetBinContent(1353, 0.9040346);
  hrf->SetBinContent(1354, 0.9019893);
  hrf->SetBinContent(1355, 0.8894359);
  hrf->SetBinContent(1356, 0.891537);
  hrf->SetBinContent(1357, 0.8923806);
  hrf->SetBinContent(1358, 0.9037331);
  hrf->SetBinContent(1359, 0.9070863);
  hrf->SetBinContent(1360, 0.8309636);
  hrf->SetBinContent(1361, 0.8082155);
  hrf->SetBinContent(1362, 0.801677);
  hrf->SetBinContent(1363, 0.8170729);
  hrf->SetBinContent(1364, 0.8248354);
  hrf->SetBinContent(1365, 0.8357266);
  hrf->SetBinContent(1366, 0.8433401);
  hrf->SetBinContent(1367, 0.8358836);
  hrf->SetBinContent(1368, 0.8491398);
  hrf->SetBinContent(1369, 0.8511904);
  hrf->SetBinContent(1370, 0.8482686);
  hrf->SetBinContent(1371, 0.8513967);
  hrf->SetBinContent(1372, 0.8541074);
  hrf->SetBinContent(1373, 0.8674045);
  hrf->SetBinContent(1374, 0.8624163);
  hrf->SetBinContent(1375, 0.8562872);
  hrf->SetBinContent(1376, 0.8609194);
  hrf->SetBinContent(1377, 0.8690702);
  hrf->SetBinContent(1378, 0.866069);
  hrf->SetBinContent(1379, 0.8622828);
  hrf->SetBinContent(1380, 0.8604844);
  hrf->SetBinContent(1381, 0.8772358);
  hrf->SetBinContent(1382, 0.8641567);
  hrf->SetBinContent(1383, 0.8457034);
  hrf->SetBinContent(1384, 0.8491502);
  hrf->SetBinContent(1385, 0.8494045);
  hrf->SetBinContent(1386, 0.8261307);
  hrf->SetBinContent(1387, 0.8288372);
  hrf->SetBinContent(1388, 0.8187173);
  hrf->SetBinContent(1389, 0.8281093);
  hrf->SetBinContent(1390, 0.8122792);
  hrf->SetBinContent(1391, 0.8135304);
  hrf->SetBinContent(1392, 0.8265573);
  hrf->SetBinContent(1393, 0.8462977);
  hrf->SetBinContent(1394, 0.8973685);
  hrf->SetBinContent(1395, 0.8940501);
  hrf->SetBinContent(1396, 0.8864163);
  hrf->SetBinContent(1397, 0.8840707);
  hrf->SetBinContent(1398, 0.8922193);
  hrf->SetBinContent(1399, 0.8833568);
  hrf->SetBinContent(1400, 0.9008134);
  hrf->SetBinContent(1401, 0.8976256);
  hrf->SetBinContent(1402, 0.8968597);
  hrf->SetBinContent(1405, 0.9096515);
  hrf->SetBinContent(1406, 0.9079437);
  hrf->SetBinContent(1407, 0.9061902);
  hrf->SetBinContent(1408, 0.9073185);
  hrf->SetBinContent(1409, 0.9017385);
  hrf->SetBinContent(1410, 0.8944538);
  hrf->SetBinContent(1411, 0.8994409);
  hrf->SetBinContent(1412, 0.9050456);
  hrf->SetBinContent(1413, 0.9051073);
  hrf->SetBinContent(1414, 0.8376052);
  hrf->SetBinContent(1415, 0.8213562);
  hrf->SetBinContent(1416, 0.8097429);
  hrf->SetBinContent(1417, 0.8100043);
  hrf->SetBinContent(1418, 0.8337875);
  hrf->SetBinContent(1419, 0.8238248);
  hrf->SetBinContent(1420, 0.8488808);
  hrf->SetBinContent(1421, 0.8444864);
  hrf->SetBinContent(1422, 0.8627045);
  hrf->SetBinContent(1423, 0.8644162);
  hrf->SetBinContent(1424, 0.8556103);
  hrf->SetBinContent(1425, 0.860347);
  hrf->SetBinContent(1426, 0.8722144);
  hrf->SetBinContent(1427, 0.8769311);
  hrf->SetBinContent(1428, 0.8707542);
  hrf->SetBinContent(1429, 0.8762311);
  hrf->SetBinContent(1430, 0.8832279);
  hrf->SetBinContent(1431, 0.8578157);
  hrf->SetBinContent(1432, 0.8768555);
  hrf->SetBinContent(1433, 0.85926);
  hrf->SetBinContent(1434, 0.8674991);
  hrf->SetBinContent(1435, 0.8800728);
  hrf->SetBinContent(1436, 0.8607219);
  hrf->SetBinContent(1437, 0.8539656);
  hrf->SetBinContent(1438, 0.8611016);
  hrf->SetBinContent(1439, 0.8641738);
  hrf->SetBinContent(1440, 0.832441);
  hrf->SetBinContent(1441, 0.845636);
  hrf->SetBinContent(1442, 0.8253812);
  hrf->SetBinContent(1443, 0.8277629);
  hrf->SetBinContent(1444, 0.8094488);
  hrf->SetBinContent(1445, 0.8102607);
  hrf->SetBinContent(1446, 0.8374236);
  hrf->SetBinContent(1447, 0.846537);
  hrf->SetBinContent(1448, 0.9172034);
  hrf->SetBinContent(1449, 0.897105);
  hrf->SetBinContent(1450, 0.8886965);
  hrf->SetBinContent(1451, 0.8842038);
  hrf->SetBinContent(1452, 0.8968773);
  hrf->SetBinContent(1453, 0.9054415);
  hrf->SetBinContent(1454, 0.9000773);
  hrf->SetBinContent(1455, 0.9038355);
  hrf->SetBinContent(1456, 0.9064714);
  hrf->SetBinContent(1459, 0.899802);
  hrf->SetBinContent(1460, 0.9145996);
  hrf->SetBinContent(1461, 0.905336);
  hrf->SetBinContent(1462, 0.9158605);
  hrf->SetBinContent(1463, 0.9068455);
  hrf->SetBinContent(1464, 0.9052793);
  hrf->SetBinContent(1465, 0.8971553);
  hrf->SetBinContent(1466, 0.9086646);
  hrf->SetBinContent(1467, 0.9164911);
  hrf->SetBinContent(1468, 0.8460912);
  hrf->SetBinContent(1469, 0.832617);
  hrf->SetBinContent(1470, 0.8152063);
  hrf->SetBinContent(1471, 0.8263153);
  hrf->SetBinContent(1472, 0.8475915);
  hrf->SetBinContent(1473, 0.8360038);
  hrf->SetBinContent(1474, 0.8411368);
  hrf->SetBinContent(1475, 0.8615639);
  hrf->SetBinContent(1476, 0.8607904);
  hrf->SetBinContent(1477, 0.8632756);
  hrf->SetBinContent(1478, 0.8569868);
  hrf->SetBinContent(1479, 0.8715767);
  hrf->SetBinContent(1480, 0.8791357);
  hrf->SetBinContent(1481, 0.8727834);
  hrf->SetBinContent(1482, 0.8654918);
  hrf->SetBinContent(1483, 0.8727071);
  hrf->SetBinContent(1484, 0.8726125);
  hrf->SetBinContent(1485, 0.8807337);
  hrf->SetBinContent(1486, 0.871381);
  hrf->SetBinContent(1487, 0.8743151);
  hrf->SetBinContent(1488, 0.8673596);
  hrf->SetBinContent(1489, 0.8709635);
  hrf->SetBinContent(1490, 0.8562741);
  hrf->SetBinContent(1491, 0.8762439);
  hrf->SetBinContent(1492, 0.8603385);
  hrf->SetBinContent(1493, 0.8584014);
  hrf->SetBinContent(1494, 0.852763);
  hrf->SetBinContent(1495, 0.8577563);
  hrf->SetBinContent(1496, 0.8450456);
  hrf->SetBinContent(1497, 0.8433108);
  hrf->SetBinContent(1498, 0.8130884);
  hrf->SetBinContent(1499, 0.8139271);
  hrf->SetBinContent(1500, 0.829942);
  hrf->SetBinContent(1501, 0.8460317);
  hrf->SetBinContent(1502, 0.9045847);
  hrf->SetBinContent(1503, 0.8994192);
  hrf->SetBinContent(1504, 0.898507);
  hrf->SetBinContent(1505, 0.895317);
  hrf->SetBinContent(1506, 0.8913231);
  hrf->SetBinContent(1507, 0.9042838);
  hrf->SetBinContent(1508, 0.9118587);
  hrf->SetBinContent(1509, 0.9111838);
  hrf->SetBinContent(1510, 0.8987202);
  hrf->SetBinContent(1513, 0.8786432);
  hrf->SetBinContent(1514, 0.9071894);
  hrf->SetBinContent(1515, 0.9054747);
  hrf->SetBinContent(1516, 0.895092);
  hrf->SetBinContent(1517, 0.9013143);
  hrf->SetBinContent(1518, 0.895817);
  hrf->SetBinContent(1519, 0.9064602);
  hrf->SetBinContent(1520, 0.9189001);
  hrf->SetBinContent(1521, 0.9224745);
  hrf->SetBinContent(1522, 0.8556603);
  hrf->SetBinContent(1523, 0.8297648);
  hrf->SetBinContent(1524, 0.8396801);
  hrf->SetBinContent(1525, 0.8185809);
  hrf->SetBinContent(1526, 0.8336468);
  hrf->SetBinContent(1527, 0.8319675);
  hrf->SetBinContent(1528, 0.8543238);
  hrf->SetBinContent(1529, 0.8597329);
  hrf->SetBinContent(1530, 0.8805091);
  hrf->SetBinContent(1531, 0.864668);
  hrf->SetBinContent(1532, 0.8604107);
  hrf->SetBinContent(1533, 0.8609409);
  hrf->SetBinContent(1534, 0.8793934);
  hrf->SetBinContent(1535, 0.8839759);
  hrf->SetBinContent(1536, 0.8776876);
  hrf->SetBinContent(1537, 0.8795961);
  hrf->SetBinContent(1538, 0.8815914);
  hrf->SetBinContent(1539, 0.8900957);
  hrf->SetBinContent(1540, 0.8764424);
  hrf->SetBinContent(1541, 0.8734661);
  hrf->SetBinContent(1542, 0.8842787);
  hrf->SetBinContent(1543, 0.8839705);
  hrf->SetBinContent(1544, 0.8786647);
  hrf->SetBinContent(1545, 0.8700674);
  hrf->SetBinContent(1546, 0.8745763);
  hrf->SetBinContent(1547, 0.8782504);
  hrf->SetBinContent(1548, 0.8584328);
  hrf->SetBinContent(1549, 0.8362831);
  hrf->SetBinContent(1550, 0.838657);
  hrf->SetBinContent(1551, 0.8478499);
  hrf->SetBinContent(1552, 0.8168967);
  hrf->SetBinContent(1553, 0.8343195);
  hrf->SetBinContent(1554, 0.8338705);
  hrf->SetBinContent(1555, 0.8557371);
  hrf->SetBinContent(1556, 0.912061);
  hrf->SetBinContent(1557, 0.8975816);
  hrf->SetBinContent(1558, 0.8948125);
  hrf->SetBinContent(1559, 0.8940022);
  hrf->SetBinContent(1560, 0.8982707);
  hrf->SetBinContent(1561, 0.9042674);
  hrf->SetBinContent(1562, 0.9041132);
  hrf->SetBinContent(1563, 0.9016004);
  hrf->SetBinContent(1564, 0.871017);

  return hrf;
}

getResponseFunction_shower()

TH2D * TCMETAlgo::getResponseFunction_shower

(

)

Definition at line 785 of file TCMETAlgo.cc.

References MillePedeFileConverter_cfg::e.

Referenced by configure().

                                            {
  Double_t xAxis1[53] = {-2.5,   -2.322, -2.172, -2.043, -1.93,  -1.83,  -1.74,  -1.653, -1.566, -1.479, -1.392,
                         -1.305, -1.218, -1.131, -1.044, -0.957, -0.879, -0.783, -0.696, -0.609, -0.522, -0.435,
                         -0.348, -0.261, -0.174, -0.087, 0,      0.087,  0.174,  0.261,  0.348,  0.435,  0.522,
                         0.609,  0.696,  0.783,  0.879,  0.957,  1.044,  1.131,  1.218,  1.305,  1.392,  1.479,
                         1.566,  1.653,  1.74,   1.83,   1.93,   2.043,  2.172,  2.322,  2.5};

  Double_t yAxis1[29] = {0,  0.5, 1,  1.5, 2,  3,  4,  5,  6,  7,  8,  9,  10, 12, 14,
                         16, 18,  20, 25,  30, 35, 40, 45, 50, 60, 70, 80, 90, 100};

  TH2D* hrf = new TH2D("hrf", "shower RF (fit)", 52, xAxis1, 28, yAxis1);
  hrf->SetBinContent(163, 0.4499661);
  hrf->SetBinContent(164, 0.5115394);
  hrf->SetBinContent(165, 0.5748767);
  hrf->SetBinContent(166, 0.6531988);
  hrf->SetBinContent(167, 0.6228076);
  hrf->SetBinContent(168, 0.54419);
  hrf->SetBinContent(169, 0.5556401);
  hrf->SetBinContent(170, 0.5216789);
  hrf->SetBinContent(171, 0.3942387);
  hrf->SetBinContent(172, 0.3166006);
  hrf->SetBinContent(173, 0.2794519);
  hrf->SetBinContent(174, 0.2712919);
  hrf->SetBinContent(175, 0.2809297);
  hrf->SetBinContent(176, 3.501783e-12);
  hrf->SetBinContent(177, 1.395287e-14);
  hrf->SetBinContent(178, 1.002659e-14);
  hrf->SetBinContent(179, 1.996966e-13);
  hrf->SetBinContent(180, 1.185354e-12);
  hrf->SetBinContent(181, 0.1562845);
  hrf->SetBinContent(182, 0.3277632);
  hrf->SetBinContent(183, 9.387774e-12);
  hrf->SetBinContent(184, 1.936981e-15);
  hrf->SetBinContent(185, 1.395151e-15);
  hrf->SetBinContent(186, 6.578116e-13);
  hrf->SetBinContent(187, 3.868433e-16);
  hrf->SetBinContent(188, 4.808265e-13);
  hrf->SetBinContent(189, 1.502861e-11);
  hrf->SetBinContent(190, 9.644046e-12);
  hrf->SetBinContent(191, 1.371502e-10);
  hrf->SetBinContent(192, 1.107704e-13);
  hrf->SetBinContent(193, 4.781223e-15);
  hrf->SetBinContent(194, 2.42137e-12);
  hrf->SetBinContent(195, 7.183598e-15);
  hrf->SetBinContent(196, 7.702724e-11);
  hrf->SetBinContent(197, 7.081141e-15);
  hrf->SetBinContent(198, 4.414546e-15);
  hrf->SetBinContent(199, 6.467266e-14);
  hrf->SetBinContent(200, 4.396606e-13);
  hrf->SetBinContent(201, 1.255334e-13);
  hrf->SetBinContent(202, 0.2490428);
  hrf->SetBinContent(203, 0.1774015);
  hrf->SetBinContent(204, 0.03958736);
  hrf->SetBinContent(205, 0.173943);
  hrf->SetBinContent(206, 2.754122e-09);
  hrf->SetBinContent(207, 0.3376317);
  hrf->SetBinContent(208, 0.379734);
  hrf->SetBinContent(209, 0.4411897);
  hrf->SetBinContent(210, 0.4646802);
  hrf->SetBinContent(211, 0.4630073);
  hrf->SetBinContent(212, 0.4258874);
  hrf->SetBinContent(213, 0.4351387);
  hrf->SetBinContent(214, 0.3997094);
  hrf->SetBinContent(217, 0.4259718);
  hrf->SetBinContent(218, 0.4852031);
  hrf->SetBinContent(219, 0.5131704);
  hrf->SetBinContent(220, 0.5269414);
  hrf->SetBinContent(221, 0.5275139);
  hrf->SetBinContent(222, 0.4957667);
  hrf->SetBinContent(223, 0.4246427);
  hrf->SetBinContent(224, 0.3784586);
  hrf->SetBinContent(225, 0.3247786);
  hrf->SetBinContent(226, 0.2571901);
  hrf->SetBinContent(227, 0.1693018);
  hrf->SetBinContent(228, 2.160257e-12);
  hrf->SetBinContent(229, 8.770899e-13);
  hrf->SetBinContent(230, 5.012884e-13);
  hrf->SetBinContent(231, 2.994393e-14);
  hrf->SetBinContent(232, 3.153311e-11);
  hrf->SetBinContent(233, 0.2774436);
  hrf->SetBinContent(234, 0.2977051);
  hrf->SetBinContent(235, 4.19017e-15);
  hrf->SetBinContent(236, 7.045583e-13);
  hrf->SetBinContent(237, 7.671467e-13);
  hrf->SetBinContent(238, 6.307742e-14);
  hrf->SetBinContent(239, 1.032541e-13);
  hrf->SetBinContent(240, 6.584719e-11);
  hrf->SetBinContent(241, 1.218903e-12);
  hrf->SetBinContent(242, 1.369637e-11);
  hrf->SetBinContent(243, 8.558079e-14);
  hrf->SetBinContent(244, 4.513987e-13);
  hrf->SetBinContent(245, 2.556831e-10);
  hrf->SetBinContent(246, 1.420917e-11);
  hrf->SetBinContent(247, 6.229907e-14);
  hrf->SetBinContent(248, 1.40826e-12);
  hrf->SetBinContent(249, 1.143873e-12);
  hrf->SetBinContent(250, 6.677059e-16);
  hrf->SetBinContent(251, 3.113288e-12);
  hrf->SetBinContent(252, 0.2333517);
  hrf->SetBinContent(253, 0.1787967);
  hrf->SetBinContent(254, 5.41192e-13);
  hrf->SetBinContent(255, 6.694948e-17);
  hrf->SetBinContent(256, 2.782238e-13);
  hrf->SetBinContent(257, 3.274193e-14);
  hrf->SetBinContent(258, 5.731716e-14);
  hrf->SetBinContent(259, 1.739033e-13);
  hrf->SetBinContent(260, 0.1770892);
  hrf->SetBinContent(261, 0.1898742);
  hrf->SetBinContent(262, 0.3387461);
  hrf->SetBinContent(263, 0.3859385);
  hrf->SetBinContent(264, 0.439089);
  hrf->SetBinContent(265, 0.4233858);
  hrf->SetBinContent(266, 0.4308124);
  hrf->SetBinContent(267, 0.4063357);
  hrf->SetBinContent(268, 0.407559);
  hrf->SetBinContent(271, 0.4507765);
  hrf->SetBinContent(272, 0.4278911);
  hrf->SetBinContent(273, 0.447516);
  hrf->SetBinContent(274, 0.4947385);
  hrf->SetBinContent(275, 0.4755806);
  hrf->SetBinContent(276, 0.3945268);
  hrf->SetBinContent(277, 0.4245627);
  hrf->SetBinContent(278, 0.3956718);
  hrf->SetBinContent(279, 0.2930262);
  hrf->SetBinContent(280, 0.282435);
  hrf->SetBinContent(281, 0.1969091);
  hrf->SetBinContent(282, 2.725097e-10);
  hrf->SetBinContent(283, 1.408023e-12);
  hrf->SetBinContent(284, 1.613806e-12);
  hrf->SetBinContent(285, 0.06278097);
  hrf->SetBinContent(286, 2.576515e-13);
  hrf->SetBinContent(287, 2.583938e-11);
  hrf->SetBinContent(288, 0.02207314);
  hrf->SetBinContent(289, 4.17668e-11);
  hrf->SetBinContent(290, 1.201223e-13);
  hrf->SetBinContent(291, 0.202147);
  hrf->SetBinContent(292, 0.213694);
  hrf->SetBinContent(293, 0.3833649);
  hrf->SetBinContent(294, 0.3896363);
  hrf->SetBinContent(295, 0.4015322);
  hrf->SetBinContent(296, 0.06830335);
  hrf->SetBinContent(297, 0.3644076);
  hrf->SetBinContent(298, 0.3335945);
  hrf->SetBinContent(299, 0.1969689);
  hrf->SetBinContent(300, 0.2202647);
  hrf->SetBinContent(301, 0.2408156);
  hrf->SetBinContent(302, 0.08467747);
  hrf->SetBinContent(303, 0.1732237);
  hrf->SetBinContent(304, 2.88671e-12);
  hrf->SetBinContent(305, 1.474949e-15);
  hrf->SetBinContent(306, 3.611305e-13);
  hrf->SetBinContent(307, 7.968386e-12);
  hrf->SetBinContent(308, 0.07609402);
  hrf->SetBinContent(309, 2.35158e-15);
  hrf->SetBinContent(310, 3.144875e-14);
  hrf->SetBinContent(311, 7.413513e-11);
  hrf->SetBinContent(312, 3.648529e-10);
  hrf->SetBinContent(313, 0.161564);
  hrf->SetBinContent(314, 0.1703132);
  hrf->SetBinContent(315, 0.2463829);
  hrf->SetBinContent(316, 0.2828567);
  hrf->SetBinContent(317, 0.3274342);
  hrf->SetBinContent(318, 0.3545384);
  hrf->SetBinContent(319, 0.3461392);
  hrf->SetBinContent(320, 0.383806);
  hrf->SetBinContent(321, 0.4001317);
  hrf->SetBinContent(322, 0.3859067);
  hrf->SetBinContent(325, 0.4965547);
  hrf->SetBinContent(326, 0.4298636);
  hrf->SetBinContent(327, 0.4675876);
  hrf->SetBinContent(328, 0.4448023);
  hrf->SetBinContent(329, 0.404866);
  hrf->SetBinContent(330, 0.3958093);
  hrf->SetBinContent(331, 0.3955818);
  hrf->SetBinContent(332, 0.4272344);
  hrf->SetBinContent(333, 0.3596729);
  hrf->SetBinContent(334, 0.3546307);
  hrf->SetBinContent(335, 0.3180164);
  hrf->SetBinContent(336, 0.2714837);
  hrf->SetBinContent(337, 0.248644);
  hrf->SetBinContent(338, 0.2589674);
  hrf->SetBinContent(339, 0.2311552);
  hrf->SetBinContent(340, 0.2332692);
  hrf->SetBinContent(341, 0.2837152);
  hrf->SetBinContent(342, 0.2119901);
  hrf->SetBinContent(343, 0.290872);
  hrf->SetBinContent(344, 0.2252947);
  hrf->SetBinContent(345, 0.3002172);
  hrf->SetBinContent(346, 0.2519063);
  hrf->SetBinContent(347, 0.3656891);
  hrf->SetBinContent(348, 0.366923);
  hrf->SetBinContent(349, 0.3425266);
  hrf->SetBinContent(350, 0.3963153);
  hrf->SetBinContent(351, 0.4658033);
  hrf->SetBinContent(352, 0.2195605);
  hrf->SetBinContent(353, 0.3869674);
  hrf->SetBinContent(354, 0.3218271);
  hrf->SetBinContent(355, 0.287984);
  hrf->SetBinContent(356, 0.2912856);
  hrf->SetBinContent(357, 0.2681426);
  hrf->SetBinContent(358, 0.04988411);
  hrf->SetBinContent(359, 0.2593921);
  hrf->SetBinContent(360, 0.2092704);
  hrf->SetBinContent(361, 0.2379719);
  hrf->SetBinContent(362, 0.3087997);
  hrf->SetBinContent(363, 0.2041179);
  hrf->SetBinContent(364, 0.1946624);
  hrf->SetBinContent(365, 0.2187801);
  hrf->SetBinContent(366, 0.1256377);
  hrf->SetBinContent(367, 0.2779986);
  hrf->SetBinContent(368, 0.2988263);
  hrf->SetBinContent(369, 0.2804917);
  hrf->SetBinContent(370, 0.2762815);
  hrf->SetBinContent(371, 0.3480896);
  hrf->SetBinContent(372, 0.3402267);
  hrf->SetBinContent(373, 0.3655252);
  hrf->SetBinContent(374, 0.4143132);
  hrf->SetBinContent(375, 0.4424044);
  hrf->SetBinContent(376, 0.4635657);
  hrf->SetBinContent(379, 0.5328001);
  hrf->SetBinContent(380, 0.5040566);
  hrf->SetBinContent(381, 0.4762677);
  hrf->SetBinContent(382, 0.4729804);
  hrf->SetBinContent(383, 0.4241441);
  hrf->SetBinContent(384, 0.3924028);
  hrf->SetBinContent(385, 0.3985717);
  hrf->SetBinContent(386, 0.3816867);
  hrf->SetBinContent(387, 0.3967448);
  hrf->SetBinContent(388, 0.3603249);
  hrf->SetBinContent(389, 0.3489972);
  hrf->SetBinContent(390, 0.3275993);
  hrf->SetBinContent(391, 0.3116674);
  hrf->SetBinContent(392, 0.3572989);
  hrf->SetBinContent(393, 0.3118418);
  hrf->SetBinContent(394, 0.3412188);
  hrf->SetBinContent(395, 0.3356509);
  hrf->SetBinContent(396, 0.3173708);
  hrf->SetBinContent(397, 0.328909);
  hrf->SetBinContent(398, 0.399799);
  hrf->SetBinContent(399, 0.311187);
  hrf->SetBinContent(400, 0.4324506);
  hrf->SetBinContent(401, 0.44069);
  hrf->SetBinContent(402, 0.393832);
  hrf->SetBinContent(403, 0.456211);
  hrf->SetBinContent(404, 0.3807082);
  hrf->SetBinContent(405, 0.4484331);
  hrf->SetBinContent(406, 0.4281936);
  hrf->SetBinContent(407, 0.4100697);
  hrf->SetBinContent(408, 0.372774);
  hrf->SetBinContent(409, 0.3635768);
  hrf->SetBinContent(410, 0.4071924);
  hrf->SetBinContent(411, 0.3974379);
  hrf->SetBinContent(412, 0.2703223);
  hrf->SetBinContent(413, 0.2532525);
  hrf->SetBinContent(414, 0.3434703);
  hrf->SetBinContent(415, 0.3486526);
  hrf->SetBinContent(416, 0.427386);
  hrf->SetBinContent(417, 0.3239493);
  hrf->SetBinContent(418, 0.2804846);
  hrf->SetBinContent(419, 0.2903942);
  hrf->SetBinContent(420, 0.3247145);
  hrf->SetBinContent(421, 0.3359192);
  hrf->SetBinContent(422, 0.3475888);
  hrf->SetBinContent(423, 0.3163865);
  hrf->SetBinContent(424, 0.3598666);
  hrf->SetBinContent(425, 0.3568181);
  hrf->SetBinContent(426, 0.4099707);
  hrf->SetBinContent(427, 0.4081352);
  hrf->SetBinContent(428, 0.4393944);
  hrf->SetBinContent(429, 0.4858226);
  hrf->SetBinContent(430, 0.5145534);
  hrf->SetBinContent(433, 0.5637426);
  hrf->SetBinContent(434, 0.5091262);
  hrf->SetBinContent(435, 0.5162247);
  hrf->SetBinContent(436, 0.4999508);
  hrf->SetBinContent(437, 0.4846284);
  hrf->SetBinContent(438, 0.4485746);
  hrf->SetBinContent(439, 0.4452571);
  hrf->SetBinContent(440, 0.4383303);
  hrf->SetBinContent(441, 0.4147619);
  hrf->SetBinContent(442, 0.3845302);
  hrf->SetBinContent(443, 0.3643234);
  hrf->SetBinContent(444, 0.3162651);
  hrf->SetBinContent(445, 0.3629169);
  hrf->SetBinContent(446, 0.3550237);
  hrf->SetBinContent(447, 0.3773867);
  hrf->SetBinContent(448, 0.3870859);
  hrf->SetBinContent(449, 0.4489362);
  hrf->SetBinContent(450, 0.4199947);
  hrf->SetBinContent(451, 0.3942634);
  hrf->SetBinContent(452, 0.4190169);
  hrf->SetBinContent(453, 0.4352544);
  hrf->SetBinContent(454, 0.5414081);
  hrf->SetBinContent(455, 0.4886461);
  hrf->SetBinContent(456, 0.491399);
  hrf->SetBinContent(457, 0.4949853);
  hrf->SetBinContent(458, 0.4736267);
  hrf->SetBinContent(459, 0.4950338);
  hrf->SetBinContent(460, 0.4496278);
  hrf->SetBinContent(461, 0.3453094);
  hrf->SetBinContent(462, 0.4956175);
  hrf->SetBinContent(463, 0.471592);
  hrf->SetBinContent(464, 0.4388095);
  hrf->SetBinContent(465, 0.4260533);
  hrf->SetBinContent(466, 0.4375692);
  hrf->SetBinContent(467, 0.3561876);
  hrf->SetBinContent(468, 0.3865653);
  hrf->SetBinContent(469, 0.4240963);
  hrf->SetBinContent(470, 0.4478125);
  hrf->SetBinContent(471, 0.3761102);
  hrf->SetBinContent(472, 0.3078025);
  hrf->SetBinContent(473, 0.3128132);
  hrf->SetBinContent(474, 0.3092445);
  hrf->SetBinContent(475, 0.3537644);
  hrf->SetBinContent(476, 0.3810261);
  hrf->SetBinContent(477, 0.3454433);
  hrf->SetBinContent(478, 0.3760064);
  hrf->SetBinContent(479, 0.3942058);
  hrf->SetBinContent(480, 0.3767672);
  hrf->SetBinContent(481, 0.4661797);
  hrf->SetBinContent(482, 0.496105);
  hrf->SetBinContent(483, 0.5421373);
  hrf->SetBinContent(484, 0.5835976);
  hrf->SetBinContent(487, 0.6251767);
  hrf->SetBinContent(488, 0.5533592);
  hrf->SetBinContent(489, 0.5539129);
  hrf->SetBinContent(490, 0.5571011);
  hrf->SetBinContent(491, 0.461241);
  hrf->SetBinContent(492, 0.4907266);
  hrf->SetBinContent(493, 0.4790399);
  hrf->SetBinContent(494, 0.4644649);
  hrf->SetBinContent(495, 0.4707908);
  hrf->SetBinContent(496, 0.4255725);
  hrf->SetBinContent(497, 0.3789675);
  hrf->SetBinContent(498, 0.3281609);
  hrf->SetBinContent(499, 0.3849);
  hrf->SetBinContent(500, 0.396543);
  hrf->SetBinContent(501, 0.4355485);
  hrf->SetBinContent(502, 0.4392651);
  hrf->SetBinContent(503, 0.4460491);
  hrf->SetBinContent(504, 0.4662225);
  hrf->SetBinContent(505, 0.4714942);
  hrf->SetBinContent(506, 0.4849604);
  hrf->SetBinContent(507, 0.5304947);
  hrf->SetBinContent(508, 0.4402863);
  hrf->SetBinContent(509, 0.4548508);
  hrf->SetBinContent(510, 0.5050853);
  hrf->SetBinContent(511, 0.6225156);
  hrf->SetBinContent(512, 0.5070591);
  hrf->SetBinContent(513, 0.5783269);
  hrf->SetBinContent(514, 0.4485723);
  hrf->SetBinContent(515, 0.4288994);
  hrf->SetBinContent(516, 0.5294365);
  hrf->SetBinContent(517, 0.4040891);
  hrf->SetBinContent(518, 0.45381);
  hrf->SetBinContent(519, 0.4817017);
  hrf->SetBinContent(520, 0.4337503);
  hrf->SetBinContent(521, 0.4618663);
  hrf->SetBinContent(522, 0.4487967);
  hrf->SetBinContent(523, 0.4660794);
  hrf->SetBinContent(524, 0.4697885);
  hrf->SetBinContent(525, 0.3807916);
  hrf->SetBinContent(526, 0.3590573);
  hrf->SetBinContent(527, 0.3666168);
  hrf->SetBinContent(528, 0.3436687);
  hrf->SetBinContent(529, 0.4094553);
  hrf->SetBinContent(530, 0.4075274);
  hrf->SetBinContent(531, 0.4259284);
  hrf->SetBinContent(532, 0.3687154);
  hrf->SetBinContent(533, 0.4227276);
  hrf->SetBinContent(534, 0.4622007);
  hrf->SetBinContent(535, 0.5158547);
  hrf->SetBinContent(536, 0.5761781);
  hrf->SetBinContent(537, 0.5306279);
  hrf->SetBinContent(538, 0.604239);
  hrf->SetBinContent(541, 0.6505255);
  hrf->SetBinContent(542, 0.5818751);
  hrf->SetBinContent(543, 0.5867255);
  hrf->SetBinContent(544, 0.5710145);
  hrf->SetBinContent(545, 0.5583379);
  hrf->SetBinContent(546, 0.5236275);
  hrf->SetBinContent(547, 0.5103479);
  hrf->SetBinContent(548, 0.512406);
  hrf->SetBinContent(549, 0.4958769);
  hrf->SetBinContent(550, 0.4828178);
  hrf->SetBinContent(551, 0.455934);
  hrf->SetBinContent(552, 0.4250835);
  hrf->SetBinContent(553, 0.3992001);
  hrf->SetBinContent(554, 0.4200533);
  hrf->SetBinContent(555, 0.4249736);
  hrf->SetBinContent(556, 0.4012719);
  hrf->SetBinContent(557, 0.44089);
  hrf->SetBinContent(558, 0.4337474);
  hrf->SetBinContent(559, 0.5332403);
  hrf->SetBinContent(560, 0.5280592);
  hrf->SetBinContent(561, 0.5309546);
  hrf->SetBinContent(562, 0.481916);
  hrf->SetBinContent(563, 0.5310268);
  hrf->SetBinContent(564, 0.607914);
  hrf->SetBinContent(565, 0.5324617);
  hrf->SetBinContent(566, 0.4308392);
  hrf->SetBinContent(567, 0.657365);
  hrf->SetBinContent(568, 0.4871463);
  hrf->SetBinContent(569, 0.48493);
  hrf->SetBinContent(570, 0.5643647);
  hrf->SetBinContent(571, 0.5080062);
  hrf->SetBinContent(572, 0.4948668);
  hrf->SetBinContent(573, 0.4924461);
  hrf->SetBinContent(574, 0.4836232);
  hrf->SetBinContent(575, 0.4820425);
  hrf->SetBinContent(576, 0.432751);
  hrf->SetBinContent(577, 0.429387);
  hrf->SetBinContent(578, 0.4894068);
  hrf->SetBinContent(579, 0.4042509);
  hrf->SetBinContent(580, 0.4011929);
  hrf->SetBinContent(581, 0.3912144);
  hrf->SetBinContent(582, 0.45584);
  hrf->SetBinContent(583, 0.4647456);
  hrf->SetBinContent(584, 0.4363243);
  hrf->SetBinContent(585, 0.4958702);
  hrf->SetBinContent(586, 0.448495);
  hrf->SetBinContent(587, 0.4895967);
  hrf->SetBinContent(588, 0.4973783);
  hrf->SetBinContent(589, 0.5330777);
  hrf->SetBinContent(590, 0.5669274);
  hrf->SetBinContent(591, 0.5922648);
  hrf->SetBinContent(592, 0.6050142);
  hrf->SetBinContent(595, 0.6630494);
  hrf->SetBinContent(596, 0.6159285);
  hrf->SetBinContent(597, 0.5922346);
  hrf->SetBinContent(598, 0.5935339);
  hrf->SetBinContent(599, 0.5428941);
  hrf->SetBinContent(600, 0.5687385);
  hrf->SetBinContent(601, 0.5268369);
  hrf->SetBinContent(602, 0.5169364);
  hrf->SetBinContent(603, 0.5499318);
  hrf->SetBinContent(604, 0.5111216);
  hrf->SetBinContent(605, 0.4888227);
  hrf->SetBinContent(606, 0.4605286);
  hrf->SetBinContent(607, 0.4351951);
  hrf->SetBinContent(608, 0.431736);
  hrf->SetBinContent(609, 0.414758);
  hrf->SetBinContent(610, 0.4670523);
  hrf->SetBinContent(611, 0.4953657);
  hrf->SetBinContent(612, 0.4818059);
  hrf->SetBinContent(613, 0.4936583);
  hrf->SetBinContent(614, 0.5290911);
  hrf->SetBinContent(615, 0.5340177);
  hrf->SetBinContent(616, 0.5672857);
  hrf->SetBinContent(617, 0.5451307);
  hrf->SetBinContent(618, 0.5898654);
  hrf->SetBinContent(619, 0.5992702);
  hrf->SetBinContent(620, 0.4388121);
  hrf->SetBinContent(621, 0.595104);
  hrf->SetBinContent(622, 0.5084654);
  hrf->SetBinContent(623, 0.6126072);
  hrf->SetBinContent(624, 0.5215501);
  hrf->SetBinContent(625, 0.5714918);
  hrf->SetBinContent(626, 0.4984477);
  hrf->SetBinContent(627, 0.5079408);
  hrf->SetBinContent(628, 0.4234431);
  hrf->SetBinContent(629, 0.506642);
  hrf->SetBinContent(630, 0.4792702);
  hrf->SetBinContent(631, 0.4516811);
  hrf->SetBinContent(632, 0.5039279);
  hrf->SetBinContent(633, 0.4617087);
  hrf->SetBinContent(634, 0.4193281);
  hrf->SetBinContent(635, 0.4421038);
  hrf->SetBinContent(636, 0.4526195);
  hrf->SetBinContent(637, 0.4948348);
  hrf->SetBinContent(638, 0.4953995);
  hrf->SetBinContent(639, 0.5809821);
  hrf->SetBinContent(640, 0.4407834);
  hrf->SetBinContent(641, 0.5614265);
  hrf->SetBinContent(642, 0.5175495);
  hrf->SetBinContent(643, 0.5785159);
  hrf->SetBinContent(644, 0.5824267);
  hrf->SetBinContent(645, 0.5995645);
  hrf->SetBinContent(646, 0.6183428);
  hrf->SetBinContent(649, 0.6631703);
  hrf->SetBinContent(650, 0.6168774);
  hrf->SetBinContent(651, 0.616705);
  hrf->SetBinContent(652, 0.5804244);
  hrf->SetBinContent(653, 0.5667811);
  hrf->SetBinContent(654, 0.580375);
  hrf->SetBinContent(655, 0.5548614);
  hrf->SetBinContent(656, 0.5549967);
  hrf->SetBinContent(657, 0.5488238);
  hrf->SetBinContent(658, 0.5271744);
  hrf->SetBinContent(659, 0.4692591);
  hrf->SetBinContent(660, 0.4657117);
  hrf->SetBinContent(661, 0.4465269);
  hrf->SetBinContent(662, 0.483284);
  hrf->SetBinContent(663, 0.4731859);
  hrf->SetBinContent(664, 0.4757599);
  hrf->SetBinContent(665, 0.5269416);
  hrf->SetBinContent(666, 0.4791626);
  hrf->SetBinContent(667, 0.4767701);
  hrf->SetBinContent(668, 0.5280282);
  hrf->SetBinContent(669, 0.471336);
  hrf->SetBinContent(670, 0.5383868);
  hrf->SetBinContent(671, 0.5317252);
  hrf->SetBinContent(672, 0.5230907);
  hrf->SetBinContent(673, 0.4193349);
  hrf->SetBinContent(674, 0.6367785);
  hrf->SetBinContent(675, 0.6116676);
  hrf->SetBinContent(676, 5.204643e-13);
  hrf->SetBinContent(677, 0.5735268);
  hrf->SetBinContent(678, 0.5120812);
  hrf->SetBinContent(679, 0.4439629);
  hrf->SetBinContent(680, 0.5699995);
  hrf->SetBinContent(681, 0.5074403);
  hrf->SetBinContent(682, 0.4576817);
  hrf->SetBinContent(683, 0.4833942);
  hrf->SetBinContent(684, 0.4536599);
  hrf->SetBinContent(685, 0.4731807);
  hrf->SetBinContent(686, 0.5279117);
  hrf->SetBinContent(687, 0.4941469);
  hrf->SetBinContent(688, 0.4646718);
  hrf->SetBinContent(689, 0.4673952);
  hrf->SetBinContent(690, 0.475842);
  hrf->SetBinContent(691, 0.5299788);
  hrf->SetBinContent(692, 0.4936431);
  hrf->SetBinContent(693, 0.5203316);
  hrf->SetBinContent(694, 0.5046751);
  hrf->SetBinContent(695, 0.5557889);
  hrf->SetBinContent(696, 0.5674751);
  hrf->SetBinContent(697, 0.561456);
  hrf->SetBinContent(698, 0.6104691);
  hrf->SetBinContent(699, 0.6169875);
  hrf->SetBinContent(700, 0.6246719);
  hrf->SetBinContent(703, 0.6720862);
  hrf->SetBinContent(704, 0.502434);
  hrf->SetBinContent(705, 0.6276976);
  hrf->SetBinContent(706, 0.6421635);
  hrf->SetBinContent(707, 0.5878988);
  hrf->SetBinContent(708, 0.6358813);
  hrf->SetBinContent(709, 0.5334384);
  hrf->SetBinContent(710, 0.542926);
  hrf->SetBinContent(711, 0.5346153);
  hrf->SetBinContent(712, 0.5575447);
  hrf->SetBinContent(713, 0.4793544);
  hrf->SetBinContent(714, 0.4965635);
  hrf->SetBinContent(715, 0.5001614);
  hrf->SetBinContent(716, 0.4393831);
  hrf->SetBinContent(717, 0.5190095);
  hrf->SetBinContent(718, 0.5219466);
  hrf->SetBinContent(719, 0.5569022);
  hrf->SetBinContent(720, 0.4912303);
  hrf->SetBinContent(721, 0.6012073);
  hrf->SetBinContent(722, 0.5118117);
  hrf->SetBinContent(723, 0.5313371);
  hrf->SetBinContent(724, 0.4380699);
  hrf->SetBinContent(725, 0.6676616);
  hrf->SetBinContent(726, 0.5728767);
  hrf->SetBinContent(727, 4.375616e-11);
  hrf->SetBinContent(728, 0.6977555);
  hrf->SetBinContent(729, 0.5195935);
  hrf->SetBinContent(730, 0.5479189);
  hrf->SetBinContent(731, 0.5616662);
  hrf->SetBinContent(732, 0.4898259);
  hrf->SetBinContent(733, 0.5331113);
  hrf->SetBinContent(734, 0.3613676);
  hrf->SetBinContent(735, 1.001784);
  hrf->SetBinContent(736, 0.5572338);
  hrf->SetBinContent(737, 0.5393934);
  hrf->SetBinContent(738, 0.5284588);
  hrf->SetBinContent(739, 0.4695196);
  hrf->SetBinContent(740, 0.5750146);
  hrf->SetBinContent(741, 0.4554707);
  hrf->SetBinContent(742, 0.4129654);
  hrf->SetBinContent(743, 0.5072033);
  hrf->SetBinContent(744, 0.507525);
  hrf->SetBinContent(745, 0.5350967);
  hrf->SetBinContent(746, 0.4791084);
  hrf->SetBinContent(747, 0.5860431);
  hrf->SetBinContent(748, 0.5185009);
  hrf->SetBinContent(749, 0.5168303);
  hrf->SetBinContent(750, 0.5707769);
  hrf->SetBinContent(751, 0.5804498);
  hrf->SetBinContent(752, 0.5760176);
  hrf->SetBinContent(753, 0.6006478);
  hrf->SetBinContent(754, 0.6306959);
  hrf->SetBinContent(757, 0.6969504);
  hrf->SetBinContent(758, 0.6633195);
  hrf->SetBinContent(759, 0.6902606);
  hrf->SetBinContent(760, 0.7143407);
  hrf->SetBinContent(761, 0.5924193);
  hrf->SetBinContent(762, 0.6372157);
  hrf->SetBinContent(763, 0.5941344);
  hrf->SetBinContent(764, 0.6490987);
  hrf->SetBinContent(765, 0.589569);
  hrf->SetBinContent(766, 0.6097816);
  hrf->SetBinContent(767, 0.6370956);
  hrf->SetBinContent(768, 0.5543383);
  hrf->SetBinContent(769, 0.5394284);
  hrf->SetBinContent(770, 0.5702426);
  hrf->SetBinContent(771, 0.5809673);
  hrf->SetBinContent(772, 0.6057459);
  hrf->SetBinContent(773, 0.5444764);
  hrf->SetBinContent(774, 0.5634755);
  hrf->SetBinContent(775, 0.5966855);
  hrf->SetBinContent(776, 0.1905186);
  hrf->SetBinContent(777, 0.5290856);
  hrf->SetBinContent(778, 0.560666);
  hrf->SetBinContent(779, 0.6940724);
  hrf->SetBinContent(780, 0.568481);
  hrf->SetBinContent(781, 5.137732e-09);
  hrf->SetBinContent(782, 0.6693913);
  hrf->SetBinContent(783, 2);
  hrf->SetBinContent(784, 0.5789571);
  hrf->SetBinContent(785, 5.583899e-10);
  hrf->SetBinContent(786, 0.7291753);
  hrf->SetBinContent(787, 0.6024151);
  hrf->SetBinContent(788, 0.4010713);
  hrf->SetBinContent(789, 0.5439928);
  hrf->SetBinContent(790, 0.557969);
  hrf->SetBinContent(791, 0.463603);
  hrf->SetBinContent(792, 0.5785179);
  hrf->SetBinContent(793, 0.6177458);
  hrf->SetBinContent(794, 0.593899);
  hrf->SetBinContent(795, 0.5544063);
  hrf->SetBinContent(796, 0.5700239);
  hrf->SetBinContent(797, 0.5639662);
  hrf->SetBinContent(798, 0.499365);
  hrf->SetBinContent(799, 0.5454815);
  hrf->SetBinContent(800, 0.5449318);
  hrf->SetBinContent(801, 0.9383752);
  hrf->SetBinContent(802, 0.5473474);
  hrf->SetBinContent(803, 0.5602657);
  hrf->SetBinContent(804, 0.5743401);
  hrf->SetBinContent(805, 0.6341625);
  hrf->SetBinContent(806, 0.6491289);
  hrf->SetBinContent(807, 0.6202378);
  hrf->SetBinContent(808, 0.6635697);
  hrf->SetBinContent(811, 0.68841);
  hrf->SetBinContent(812, 0.6655799);
  hrf->SetBinContent(813, 0.5721935);
  hrf->SetBinContent(814, 0.6535349);
  hrf->SetBinContent(815, 0.7027519);
  hrf->SetBinContent(816, 0.6477481);
  hrf->SetBinContent(817, 0.648778);
  hrf->SetBinContent(818, 0.6354568);
  hrf->SetBinContent(819, 0.5172462);
  hrf->SetBinContent(820, 0.5781944);
  hrf->SetBinContent(821, 0.6477975);
  hrf->SetBinContent(822, 0.6004694);
  hrf->SetBinContent(823, 0.6332108);
  hrf->SetBinContent(824, 0.5979394);
  hrf->SetBinContent(825, 0.6150681);
  hrf->SetBinContent(826, 0.5580107);
  hrf->SetBinContent(827, 0.6403232);
  hrf->SetBinContent(828, 0.6658844);
  hrf->SetBinContent(829, 0.7569863);
  hrf->SetBinContent(830, 0.6020923);
  hrf->SetBinContent(831, 2.16818e-07);
  hrf->SetBinContent(832, 0.7211751);
  hrf->SetBinContent(833, 0.7200035);
  hrf->SetBinContent(834, 0.6769444);
  hrf->SetBinContent(835, 0.6245867);
  hrf->SetBinContent(836, 0.6035547);
  hrf->SetBinContent(837, 0.6902707);
  hrf->SetBinContent(838, 0.5134299);
  hrf->SetBinContent(839, 2.329299e-08);
  hrf->SetBinContent(840, 2);
  hrf->SetBinContent(841, 0.6745621);
  hrf->SetBinContent(842, 0.676607);
  hrf->SetBinContent(843, 2);
  hrf->SetBinContent(844, 0.6654628);
  hrf->SetBinContent(845, 0.6554278);
  hrf->SetBinContent(846, 0.5387945);
  hrf->SetBinContent(847, 0.6195349);
  hrf->SetBinContent(848, 0.6509743);
  hrf->SetBinContent(849, 0.5995178);
  hrf->SetBinContent(850, 0.5589016);
  hrf->SetBinContent(851, 0.584215);
  hrf->SetBinContent(852, 0.5316675);
  hrf->SetBinContent(853, 0.5770031);
  hrf->SetBinContent(854, 0.6059638);
  hrf->SetBinContent(855, 0.7237309);
  hrf->SetBinContent(856, 0.4882735);
  hrf->SetBinContent(857, 0.5033463);
  hrf->SetBinContent(858, 0.6661474);
  hrf->SetBinContent(859, 0.6508684);
  hrf->SetBinContent(860, 0.6549551);
  hrf->SetBinContent(861, 0.6838532);
  hrf->SetBinContent(862, 0.742049);
  hrf->SetBinContent(865, 0.7438933);
  hrf->SetBinContent(866, 0.6990814);
  hrf->SetBinContent(867, 0.6386996);
  hrf->SetBinContent(868, 0.6660725);
  hrf->SetBinContent(869, 0.6112747);
  hrf->SetBinContent(870, 0.6274318);
  hrf->SetBinContent(871, 0.6963621);
  hrf->SetBinContent(872, 0.685574);
  hrf->SetBinContent(873, 0.5979159);
  hrf->SetBinContent(874, 0.6452025);
  hrf->SetBinContent(875, 0.6139266);
  hrf->SetBinContent(876, 0.6035063);
  hrf->SetBinContent(877, 0.612106);
  hrf->SetBinContent(878, 0.5961891);
  hrf->SetBinContent(879, 0.6140286);
  hrf->SetBinContent(880, 0.6286171);
  hrf->SetBinContent(881, 0.7334413);
  hrf->SetBinContent(882, 0.697404);
  hrf->SetBinContent(883, 0.6126003);
  hrf->SetBinContent(884, 0.6123802);
  hrf->SetBinContent(885, 1.288313e-10);
  hrf->SetBinContent(886, 0.6302402);
  hrf->SetBinContent(887, 0.6052687);
  hrf->SetBinContent(888, 0.7380156);
  hrf->SetBinContent(889, 2.948208e-09);
  hrf->SetBinContent(890, 0.724287);
  hrf->SetBinContent(891, 0.6359965);
  hrf->SetBinContent(892, 0.6981551);
  hrf->SetBinContent(893, 2);
  hrf->SetBinContent(894, 0.7462012);
  hrf->SetBinContent(895, 0.6442341);
  hrf->SetBinContent(896, 0.7292137);
  hrf->SetBinContent(897, 0.7199974);
  hrf->SetBinContent(898, 0.621317);
  hrf->SetBinContent(899, 0.5854515);
  hrf->SetBinContent(900, 0.5760161);
  hrf->SetBinContent(901, 0.6657082);
  hrf->SetBinContent(902, 0.6135329);
  hrf->SetBinContent(903, 0.608986);
  hrf->SetBinContent(904, 0.549113);
  hrf->SetBinContent(905, 0.5866095);
  hrf->SetBinContent(906, 0.6221043);
  hrf->SetBinContent(907, 0.6219515);
  hrf->SetBinContent(908, 0.4862638);
  hrf->SetBinContent(909, 0.6301283);
  hrf->SetBinContent(910, 0.555077);
  hrf->SetBinContent(911, 0.6804049);
  hrf->SetBinContent(912, 0.5539804);
  hrf->SetBinContent(913, 0.6536226);
  hrf->SetBinContent(914, 0.6983255);
  hrf->SetBinContent(915, 0.6382693);
  hrf->SetBinContent(916, 0.754311);
  hrf->SetBinContent(919, 0.7099376);
  hrf->SetBinContent(920, 0.8623501);
  hrf->SetBinContent(921, 0.7260902);
  hrf->SetBinContent(922, 0.6643114);
  hrf->SetBinContent(923, 0.6502191);
  hrf->SetBinContent(924, 0.7040369);
  hrf->SetBinContent(925, 0.6131998);
  hrf->SetBinContent(926, 0.7646526);
  hrf->SetBinContent(927, 0.5962986);
  hrf->SetBinContent(928, 0.674045);
  hrf->SetBinContent(929, 0.6392841);
  hrf->SetBinContent(930, 0.6779032);
  hrf->SetBinContent(931, 0.6079232);
  hrf->SetBinContent(932, 0.6311303);
  hrf->SetBinContent(933, 0.610688);
  hrf->SetBinContent(934, 0.6147182);
  hrf->SetBinContent(935, 1.551637e-10);
  hrf->SetBinContent(936, 4.418874e-10);
  hrf->SetBinContent(937, 0.7821836);
  hrf->SetBinContent(938, 1.62191);
  hrf->SetBinContent(939, 0.6386381);
  hrf->SetBinContent(940, 0.7198481);
  hrf->SetBinContent(941, 0.6799192);
  hrf->SetBinContent(942, 0.6402811);
  hrf->SetBinContent(943, 1.357403e-09);
  hrf->SetBinContent(944, 0.7030411);
  hrf->SetBinContent(945, 0.6865827);
  hrf->SetBinContent(946, 0.5293041);
  hrf->SetBinContent(947, 4.159337e-10);
  hrf->SetBinContent(948, 6.025262e-08);
  hrf->SetBinContent(949, 0.5823747);
  hrf->SetBinContent(950, 0.5866954);
  hrf->SetBinContent(951, 0.6885952);
  hrf->SetBinContent(952, 0.298851);
  hrf->SetBinContent(953, 0.6920147);
  hrf->SetBinContent(954, 0.6756617);
  hrf->SetBinContent(955, 0.5811628);
  hrf->SetBinContent(956, 0.5984484);
  hrf->SetBinContent(957, 0.5995011);
  hrf->SetBinContent(958, 0.5685067);
  hrf->SetBinContent(959, 0.6030776);
  hrf->SetBinContent(960, 0.5949068);
  hrf->SetBinContent(961, 0.6138204);
  hrf->SetBinContent(962, 0.7262517);
  hrf->SetBinContent(963, 0.7460917);
  hrf->SetBinContent(964, 0.7254511);
  hrf->SetBinContent(965, 0.7218192);
  hrf->SetBinContent(966, 0.636579);
  hrf->SetBinContent(967, 0.6403494);
  hrf->SetBinContent(968, 0.7431021);
  hrf->SetBinContent(969, 0.6745241);
  hrf->SetBinContent(970, 0.7573865);
  hrf->SetBinContent(973, 0.6918843);
  hrf->SetBinContent(974, 0.7262695);
  hrf->SetBinContent(975, 0.7153355);
  hrf->SetBinContent(976, 0.690676);
  hrf->SetBinContent(977, 0.7087989);
  hrf->SetBinContent(978, 0.7161497);
  hrf->SetBinContent(979, 0.7017328);
  hrf->SetBinContent(980, 0.7252781);
  hrf->SetBinContent(981, 0.7966533);
  hrf->SetBinContent(982, 0.688317);
  hrf->SetBinContent(983, 0.5986019);
  hrf->SetBinContent(984, 0.6506643);
  hrf->SetBinContent(985, 0.637751);
  hrf->SetBinContent(986, 0.6715163);
  hrf->SetBinContent(987, 0.6517788);
  hrf->SetBinContent(988, 0.734043);
  hrf->SetBinContent(989, 0.7398574);
  hrf->SetBinContent(990, 0.6567512);
  hrf->SetBinContent(991, 0.7622219);
  hrf->SetBinContent(992, 0.7801381);
  hrf->SetBinContent(993, 6.677729e-11);
  hrf->SetBinContent(994, 0.584604);
  hrf->SetBinContent(995, 0.8659359);
  hrf->SetBinContent(996, 0.4751396);
  hrf->SetBinContent(997, 0.6154816);
  hrf->SetBinContent(998, 0.8736457);
  hrf->SetBinContent(999, 0.6989418);
  hrf->SetBinContent(1000, 0.534987);
  hrf->SetBinContent(1001, 0.7178237);
  hrf->SetBinContent(1002, 0.6590059);
  hrf->SetBinContent(1003, 0.6578107);
  hrf->SetBinContent(1004, 0.6319634);
  hrf->SetBinContent(1005, 0.729422);
  hrf->SetBinContent(1006, 0.7260677);
  hrf->SetBinContent(1007, 0.5859498);
  hrf->SetBinContent(1008, 0.6200585);
  hrf->SetBinContent(1009, 0.69023);
  hrf->SetBinContent(1010, 0.6844075);
  hrf->SetBinContent(1011, 0.6791952);
  hrf->SetBinContent(1012, 0.6411185);
  hrf->SetBinContent(1013, 0.6361954);
  hrf->SetBinContent(1014, 0.6158186);
  hrf->SetBinContent(1015, 0.6525335);
  hrf->SetBinContent(1016, 0.6840788);
  hrf->SetBinContent(1017, 0.6705694);
  hrf->SetBinContent(1018, 0.6812602);
  hrf->SetBinContent(1019, 0.7209173);
  hrf->SetBinContent(1020, 0.6611741);
  hrf->SetBinContent(1021, 0.5270574);
  hrf->SetBinContent(1022, 0.6960925);
  hrf->SetBinContent(1023, 0.7432538);
  hrf->SetBinContent(1024, 0.7469128);
  hrf->SetBinContent(1027, 0.7886937);
  hrf->SetBinContent(1028, 0.7728928);
  hrf->SetBinContent(1029, 0.734811);
  hrf->SetBinContent(1030, 0.7348018);
  hrf->SetBinContent(1031, 0.7228283);
  hrf->SetBinContent(1032, 0.6900923);
  hrf->SetBinContent(1033, 0.7324901);
  hrf->SetBinContent(1034, 0.818476);
  hrf->SetBinContent(1035, 0.7755879);
  hrf->SetBinContent(1036, 0.7029133);
  hrf->SetBinContent(1037, 0.6488961);
  hrf->SetBinContent(1038, 0.643996);
  hrf->SetBinContent(1039, 0.6234887);
  hrf->SetBinContent(1040, 0.665674);
  hrf->SetBinContent(1041, 0.6890448);
  hrf->SetBinContent(1042, 0.7474747);
  hrf->SetBinContent(1043, 0.6217731);
  hrf->SetBinContent(1044, 0.7594035);
  hrf->SetBinContent(1045, 0.7606437);
  hrf->SetBinContent(1046, 0.8798572);
  hrf->SetBinContent(1047, 1.523508e-12);
  hrf->SetBinContent(1048, 0.7667443);
  hrf->SetBinContent(1049, 8.919419e-10);
  hrf->SetBinContent(1050, 0.7775083);
  hrf->SetBinContent(1051, 0.7051193);
  hrf->SetBinContent(1052, 0.7821314);
  hrf->SetBinContent(1053, 0.3696456);
  hrf->SetBinContent(1054, 0.7040802);
  hrf->SetBinContent(1055, 0.7243683);
  hrf->SetBinContent(1056, 2);
  hrf->SetBinContent(1057, 1.910918e-09);
  hrf->SetBinContent(1058, 0.6928734);
  hrf->SetBinContent(1059, 0.6995317);
  hrf->SetBinContent(1060, 0.707352);
  hrf->SetBinContent(1061, 0.7905835);
  hrf->SetBinContent(1062, 0.7529305);
  hrf->SetBinContent(1063, 0.6234255);
  hrf->SetBinContent(1064, 0.6901059);
  hrf->SetBinContent(1065, 0.6871264);
  hrf->SetBinContent(1066, 0.6963648);
  hrf->SetBinContent(1067, 0.6620449);
  hrf->SetBinContent(1068, 0.6847797);
  hrf->SetBinContent(1069, 0.6602038);
  hrf->SetBinContent(1070, 0.6530365);
  hrf->SetBinContent(1071, 0.6900207);
  hrf->SetBinContent(1072, 0.6818995);
  hrf->SetBinContent(1073, 0.7123579);
  hrf->SetBinContent(1074, 0.7515758);
  hrf->SetBinContent(1075, 0.7347609);
  hrf->SetBinContent(1076, 0.7230546);
  hrf->SetBinContent(1077, 0.7335827);
  hrf->SetBinContent(1078, 0.7987013);
  hrf->SetBinContent(1081, 0.8701817);
  hrf->SetBinContent(1082, 0.7909325);
  hrf->SetBinContent(1083, 0.7988487);
  hrf->SetBinContent(1084, 0.7315447);
  hrf->SetBinContent(1085, 0.7445458);
  hrf->SetBinContent(1086, 0.719189);
  hrf->SetBinContent(1087, 0.6976324);
  hrf->SetBinContent(1088, 0.7098625);
  hrf->SetBinContent(1089, 0.7585338);
  hrf->SetBinContent(1090, 0.7951381);
  hrf->SetBinContent(1091, 0.6906781);
  hrf->SetBinContent(1092, 0.6984041);
  hrf->SetBinContent(1093, 0.7071833);
  hrf->SetBinContent(1094, 0.7389575);
  hrf->SetBinContent(1095, 0.6932821);
  hrf->SetBinContent(1096, 0.7635614);
  hrf->SetBinContent(1097, 0.735354);
  hrf->SetBinContent(1098, 0.6733291);
  hrf->SetBinContent(1099, 0.6815611);
  hrf->SetBinContent(1100, 0.7698269);
  hrf->SetBinContent(1101, 7.031095e-10);
  hrf->SetBinContent(1102, 0.902009);
  hrf->SetBinContent(1103, 0.7199787);
  hrf->SetBinContent(1104, 0.8753546);
  hrf->SetBinContent(1105, 0.7691409);
  hrf->SetBinContent(1106, 0.8032231);
  hrf->SetBinContent(1107, 0.7608244);
  hrf->SetBinContent(1108, 0.6909539);
  hrf->SetBinContent(1109, 0.75949);
  hrf->SetBinContent(1110, 0.6740589);
  hrf->SetBinContent(1111, 0.8500618);
  hrf->SetBinContent(1112, 0.3840883);
  hrf->SetBinContent(1113, 0.8179412);
  hrf->SetBinContent(1114, 0.756898);
  hrf->SetBinContent(1115, 0.7581729);
  hrf->SetBinContent(1116, 0.7334068);
  hrf->SetBinContent(1117, 0.6974013);
  hrf->SetBinContent(1118, 0.7137154);
  hrf->SetBinContent(1119, 0.7129677);
  hrf->SetBinContent(1120, 0.6707702);
  hrf->SetBinContent(1121, 0.6722126);
  hrf->SetBinContent(1122, 0.6974467);
  hrf->SetBinContent(1123, 0.7031453);
  hrf->SetBinContent(1124, 0.657684);
  hrf->SetBinContent(1125, 0.7449268);
  hrf->SetBinContent(1126, 0.874833);
  hrf->SetBinContent(1127, 0.9745963);
  hrf->SetBinContent(1128, 0.7741645);
  hrf->SetBinContent(1129, 0.7339757);
  hrf->SetBinContent(1130, 0.777975);
  hrf->SetBinContent(1131, 0.7915074);
  hrf->SetBinContent(1132, 0.6136767);
  hrf->SetBinContent(1135, 0.8755973);
  hrf->SetBinContent(1136, 0.7700605);
  hrf->SetBinContent(1137, 0.8033186);
  hrf->SetBinContent(1138, 0.7555612);
  hrf->SetBinContent(1139, 0.7591759);
  hrf->SetBinContent(1140, 0.7519722);
  hrf->SetBinContent(1141, 0.7289418);
  hrf->SetBinContent(1142, 1.346851);
  hrf->SetBinContent(1143, 0.6687253);
  hrf->SetBinContent(1144, 0.717847);
  hrf->SetBinContent(1145, 0.7011801);
  hrf->SetBinContent(1146, 0.6966033);
  hrf->SetBinContent(1147, 0.6946036);
  hrf->SetBinContent(1148, 0.7405895);
  hrf->SetBinContent(1149, 0.7328261);
  hrf->SetBinContent(1150, 0.7192682);
  hrf->SetBinContent(1151, 0.8046057);
  hrf->SetBinContent(1152, 0.7620371);
  hrf->SetBinContent(1153, 0.7501711);
  hrf->SetBinContent(1154, 0.6792978);
  hrf->SetBinContent(1155, 0.7581177);
  hrf->SetBinContent(1156, 0.8915533);
  hrf->SetBinContent(1157, 0.7304667);
  hrf->SetBinContent(1158, 1.778186e-08);
  hrf->SetBinContent(1159, 0.7876914);
  hrf->SetBinContent(1160, 0.8167171);
  hrf->SetBinContent(1161, 0.799203);
  hrf->SetBinContent(1162, 1.564839);
  hrf->SetBinContent(1163, 1.932414);
  hrf->SetBinContent(1164, 0.6999876);
  hrf->SetBinContent(1165, 0.8222277);
  hrf->SetBinContent(1166, 0.7073811);
  hrf->SetBinContent(1167, 0.760646);
  hrf->SetBinContent(1168, 0.8145632);
  hrf->SetBinContent(1169, 0.6570073);
  hrf->SetBinContent(1170, 0.7903656);
  hrf->SetBinContent(1171, 0.7055761);
  hrf->SetBinContent(1172, 0.7324432);
  hrf->SetBinContent(1173, 0.6906474);
  hrf->SetBinContent(1174, 0.7016042);
  hrf->SetBinContent(1175, 0.6910746);
  hrf->SetBinContent(1176, 0.6489437);
  hrf->SetBinContent(1177, 0.7277918);
  hrf->SetBinContent(1178, 0.8176938);
  hrf->SetBinContent(1179, 0.7668142);
  hrf->SetBinContent(1180, 0.6988779);
  hrf->SetBinContent(1181, 4.715625e-10);
  hrf->SetBinContent(1182, 0.7289456);
  hrf->SetBinContent(1183, 0.8265013);
  hrf->SetBinContent(1184, 0.7507662);
  hrf->SetBinContent(1185, 0.7896848);
  hrf->SetBinContent(1186, 0.7976325);
  hrf->SetBinContent(1189, 0.8057601);
  hrf->SetBinContent(1190, 1.370117);
  hrf->SetBinContent(1191, 0.77344);
  hrf->SetBinContent(1192, 0.7452468);
  hrf->SetBinContent(1193, 1.108199);
  hrf->SetBinContent(1194, 3.7291e-08);
  hrf->SetBinContent(1195, 0.7778447);
  hrf->SetBinContent(1196, 0.7805797);
  hrf->SetBinContent(1197, 0.8029034);
  hrf->SetBinContent(1198, 0.7143188);
  hrf->SetBinContent(1199, 0.7026921);
  hrf->SetBinContent(1200, 0.689998);
  hrf->SetBinContent(1201, 0.7199291);
  hrf->SetBinContent(1202, 0.749867);
  hrf->SetBinContent(1203, 0.7412875);
  hrf->SetBinContent(1204, 0.7532368);
  hrf->SetBinContent(1205, 0.7416354);
  hrf->SetBinContent(1206, 0.7788702);
  hrf->SetBinContent(1207, 0.75921);
  hrf->SetBinContent(1208, 0.9899771);
  hrf->SetBinContent(1209, 0.8028721);
  hrf->SetBinContent(1210, 0.7613076);
  hrf->SetBinContent(1211, 0.8038316);
  hrf->SetBinContent(1212, 2);
  hrf->SetBinContent(1213, 0.8121575);
  hrf->SetBinContent(1214, 0.7813477);
  hrf->SetBinContent(1215, 0.7840589);
  hrf->SetBinContent(1216, 0.8885684);
  hrf->SetBinContent(1217, 2.145997e-08);
  hrf->SetBinContent(1218, 0.7463155);
  hrf->SetBinContent(1219, 0.7435377);
  hrf->SetBinContent(1220, 1.193651);
  hrf->SetBinContent(1221, 0.8411264);
  hrf->SetBinContent(1222, 0.8833549);
  hrf->SetBinContent(1223, 0.8037913);
  hrf->SetBinContent(1224, 0.7233331);
  hrf->SetBinContent(1225, 0.7553903);
  hrf->SetBinContent(1226, 0.8175085);
  hrf->SetBinContent(1227, 0.7190688);
  hrf->SetBinContent(1228, 0.7042091);
  hrf->SetBinContent(1229, 0.7236426);
  hrf->SetBinContent(1230, 0.7486491);
  hrf->SetBinContent(1231, 0.6273947);
  hrf->SetBinContent(1232, 0.7902668);
  hrf->SetBinContent(1233, 0.7747761);
  hrf->SetBinContent(1234, 1.884267e-08);
  hrf->SetBinContent(1235, 0.7297846);
  hrf->SetBinContent(1236, 0.7674142);
  hrf->SetBinContent(1237, 0.7560349);
  hrf->SetBinContent(1238, 0.7615343);
  hrf->SetBinContent(1239, 0.8092088);
  hrf->SetBinContent(1240, 0.837832);
  hrf->SetBinContent(1243, 0.8410632);
  hrf->SetBinContent(1244, 0.8284886);
  hrf->SetBinContent(1245, 0.8323252);
  hrf->SetBinContent(1246, 0.7917008);
  hrf->SetBinContent(1247, 0.8252153);
  hrf->SetBinContent(1248, 0.7736288);
  hrf->SetBinContent(1249, 2.79689e-08);
  hrf->SetBinContent(1250, 0.8256513);
  hrf->SetBinContent(1251, 0.788981);
  hrf->SetBinContent(1252, 0.7069463);
  hrf->SetBinContent(1253, 0.7353773);
  hrf->SetBinContent(1254, 0.7264474);
  hrf->SetBinContent(1255, 0.709739);
  hrf->SetBinContent(1256, 0.6967523);
  hrf->SetBinContent(1257, 0.7593404);
  hrf->SetBinContent(1258, 0.6857809);
  hrf->SetBinContent(1259, 0.7538165);
  hrf->SetBinContent(1260, 0.8193203);
  hrf->SetBinContent(1261, 1.12253);
  hrf->SetBinContent(1262, 0.8099769);
  hrf->SetBinContent(1263, 0.7968184);
  hrf->SetBinContent(1264, 0.7165168);
  hrf->SetBinContent(1265, 0.841195);
  hrf->SetBinContent(1266, 0.7307236);
  hrf->SetBinContent(1267, 0.7757208);
  hrf->SetBinContent(1268, 1.175732);
  hrf->SetBinContent(1269, 0.7950296);
  hrf->SetBinContent(1270, 2.153397e-08);
  hrf->SetBinContent(1271, 0.7121626);
  hrf->SetBinContent(1272, 0.7998994);
  hrf->SetBinContent(1273, 0.7731178);
  hrf->SetBinContent(1274, 2);
  hrf->SetBinContent(1275, 0.6647769);
  hrf->SetBinContent(1276, 0.7917477);
  hrf->SetBinContent(1277, 0.797781);
  hrf->SetBinContent(1278, 0.7394993);
  hrf->SetBinContent(1279, 0.7469406);
  hrf->SetBinContent(1280, 0.7587091);
  hrf->SetBinContent(1281, 0.7714839);
  hrf->SetBinContent(1282, 0.7415178);
  hrf->SetBinContent(1283, 0.6940494);
  hrf->SetBinContent(1284, 0.6900583);
  hrf->SetBinContent(1285, 0.744396);
  hrf->SetBinContent(1286, 0.7567286);
  hrf->SetBinContent(1287, 0.7837025);
  hrf->SetBinContent(1288, 0.7640251);
  hrf->SetBinContent(1289, 2);
  hrf->SetBinContent(1290, 0.7397066);
  hrf->SetBinContent(1291, 0.6930763);
  hrf->SetBinContent(1292, 0.7849539);
  hrf->SetBinContent(1293, 0.7758456);
  hrf->SetBinContent(1294, 0.8567303);
  hrf->SetBinContent(1297, 0.8105354);
  hrf->SetBinContent(1298, 0.8642945);
  hrf->SetBinContent(1299, 0.8043556);
  hrf->SetBinContent(1300, 0.819859);
  hrf->SetBinContent(1301, 0.7584703);
  hrf->SetBinContent(1302, 0.7616698);
  hrf->SetBinContent(1303, 0.7812502);
  hrf->SetBinContent(1304, 0.8144913);
  hrf->SetBinContent(1305, 0.8069767);
  hrf->SetBinContent(1306, 0.7869472);
  hrf->SetBinContent(1307, 0.7356938);
  hrf->SetBinContent(1308, 0.7303469);
  hrf->SetBinContent(1309, 0.7237442);
  hrf->SetBinContent(1310, 0.7893888);
  hrf->SetBinContent(1311, 0.7743256);
  hrf->SetBinContent(1312, 0.7478973);
  hrf->SetBinContent(1313, 0.7472924);
  hrf->SetBinContent(1314, 0.7928523);
  hrf->SetBinContent(1315, 0.6974202);
  hrf->SetBinContent(1316, 0.8026988);
  hrf->SetBinContent(1317, 0.8257939);
  hrf->SetBinContent(1318, 0.831494);
  hrf->SetBinContent(1319, 0.7945051);
  hrf->SetBinContent(1320, 0.761869);
  hrf->SetBinContent(1321, 0.7518338);
  hrf->SetBinContent(1322, 0.7769849);
  hrf->SetBinContent(1323, 0.7716518);
  hrf->SetBinContent(1324, 0.7334756);
  hrf->SetBinContent(1325, 0.8503541);
  hrf->SetBinContent(1326, 0.8200087);
  hrf->SetBinContent(1327, 0.7371234);
  hrf->SetBinContent(1328, 0.852895);
  hrf->SetBinContent(1329, 0.8021988);
  hrf->SetBinContent(1330, 1.039027);
  hrf->SetBinContent(1331, 0.7118308);
  hrf->SetBinContent(1332, 0.7804436);
  hrf->SetBinContent(1333, 0.7621835);
  hrf->SetBinContent(1334, 0.7786251);
  hrf->SetBinContent(1335, 0.7262275);
  hrf->SetBinContent(1336, 0.7599275);
  hrf->SetBinContent(1337, 0.7669863);
  hrf->SetBinContent(1338, 0.7006092);
  hrf->SetBinContent(1339, 0.7275499);
  hrf->SetBinContent(1340, 0.8066881);
  hrf->SetBinContent(1341, 8.082332e-09);
  hrf->SetBinContent(1342, 0.8027337);
  hrf->SetBinContent(1343, 0.7597497);
  hrf->SetBinContent(1344, 0.7935027);
  hrf->SetBinContent(1345, 0.763325);
  hrf->SetBinContent(1346, 0.7717389);
  hrf->SetBinContent(1347, 0.7577329);
  hrf->SetBinContent(1348, 0.88808);
  hrf->SetBinContent(1351, 0.8976908);
  hrf->SetBinContent(1352, 0.8423946);
  hrf->SetBinContent(1353, 0.8284513);
  hrf->SetBinContent(1354, 0.8412279);
  hrf->SetBinContent(1355, 0.8500894);
  hrf->SetBinContent(1356, 9.257798e-11);
  hrf->SetBinContent(1357, 0.7810383);
  hrf->SetBinContent(1358, 0.8704037);
  hrf->SetBinContent(1359, 0.8300052);
  hrf->SetBinContent(1360, 0.7825852);
  hrf->SetBinContent(1361, 0.816828);
  hrf->SetBinContent(1362, 0.7973738);
  hrf->SetBinContent(1363, 0.7527605);
  hrf->SetBinContent(1364, 0.7771426);
  hrf->SetBinContent(1365, 0.9042388);
  hrf->SetBinContent(1366, 0.8078419);
  hrf->SetBinContent(1367, 0.7744836);
  hrf->SetBinContent(1368, 0.8064706);
  hrf->SetBinContent(1369, 0.7996269);
  hrf->SetBinContent(1370, 0.8434137);
  hrf->SetBinContent(1371, 0.8069958);
  hrf->SetBinContent(1372, 0.8413141);
  hrf->SetBinContent(1373, 0.321352);
  hrf->SetBinContent(1374, 0.8889853);
  hrf->SetBinContent(1375, 0.4442552);
  hrf->SetBinContent(1376, 0.8282964);
  hrf->SetBinContent(1377, 0.6055968);
  hrf->SetBinContent(1378, 2);
  hrf->SetBinContent(1379, 0.758385);
  hrf->SetBinContent(1380, 0.8161163);
  hrf->SetBinContent(1381, 0.7797145);
  hrf->SetBinContent(1382, 0.826297);
  hrf->SetBinContent(1383, 0.8015526);
  hrf->SetBinContent(1384, 0.7983635);
  hrf->SetBinContent(1385, 0.7639591);
  hrf->SetBinContent(1386, 0.8086007);
  hrf->SetBinContent(1387, 0.8069662);
  hrf->SetBinContent(1388, 0.8426892);
  hrf->SetBinContent(1389, 0.7772759);
  hrf->SetBinContent(1390, 0.7175232);
  hrf->SetBinContent(1391, 0.782493);
  hrf->SetBinContent(1392, 0.7797878);
  hrf->SetBinContent(1393, 0.7351255);
  hrf->SetBinContent(1394, 0.7613439);
  hrf->SetBinContent(1395, 0.7944787);
  hrf->SetBinContent(1396, 0.842592);
  hrf->SetBinContent(1397, 0.7760797);
  hrf->SetBinContent(1398, 0.8138054);
  hrf->SetBinContent(1399, 0.8470539);
  hrf->SetBinContent(1400, 0.7994559);
  hrf->SetBinContent(1401, 0.8828442);
  hrf->SetBinContent(1402, 0.9125168);
  hrf->SetBinContent(1405, 0.7432123);
  hrf->SetBinContent(1406, 0.7924839);
  hrf->SetBinContent(1407, 0.8402076);
  hrf->SetBinContent(1408, 0.8734859);
  hrf->SetBinContent(1409, 0.8290992);
  hrf->SetBinContent(1410, 0.8127977);
  hrf->SetBinContent(1411, 0.8719417);
  hrf->SetBinContent(1412, 0.8320817);
  hrf->SetBinContent(1413, 0.8709081);
  hrf->SetBinContent(1414, 0.8365571);
  hrf->SetBinContent(1415, 0.7768795);
  hrf->SetBinContent(1416, 0.8100523);
  hrf->SetBinContent(1417, 0.7853265);
  hrf->SetBinContent(1418, 0.8136188);
  hrf->SetBinContent(1419, 0.7901163);
  hrf->SetBinContent(1420, 0.8603168);
  hrf->SetBinContent(1421, 0.8527932);
  hrf->SetBinContent(1422, 0.8367243);
  hrf->SetBinContent(1423, 0.8095203);
  hrf->SetBinContent(1424, 0.836165);
  hrf->SetBinContent(1425, 0.7613062);
  hrf->SetBinContent(1426, 1.108609);
  hrf->SetBinContent(1427, 0.1380128);
  hrf->SetBinContent(1428, 0.8434393);
  hrf->SetBinContent(1429, 0.929493);
  hrf->SetBinContent(1430, 0.891273);
  hrf->SetBinContent(1431, 0.9241241);
  hrf->SetBinContent(1432, 0.8175316);
  hrf->SetBinContent(1433, 0.8373544);
  hrf->SetBinContent(1434, 0.8248472);
  hrf->SetBinContent(1435, 0.9091666);
  hrf->SetBinContent(1436, 0.8176399);
  hrf->SetBinContent(1437, 1.605745);
  hrf->SetBinContent(1438, 0.3585472);
  hrf->SetBinContent(1439, 0.8094559);
  hrf->SetBinContent(1440, 0.8123945);
  hrf->SetBinContent(1441, 0.8034517);
  hrf->SetBinContent(1442, 0.7874666);
  hrf->SetBinContent(1443, 0.8026767);
  hrf->SetBinContent(1444, 0.7624008);
  hrf->SetBinContent(1445, 0.7767704);
  hrf->SetBinContent(1446, 0.7053043);
  hrf->SetBinContent(1447, 0.7737352);
  hrf->SetBinContent(1448, 0.8538612);
  hrf->SetBinContent(1449, 0.835044);
  hrf->SetBinContent(1450, 0.7230772);
  hrf->SetBinContent(1451, 0.8203293);
  hrf->SetBinContent(1452, 0.8326061);
  hrf->SetBinContent(1453, 0.838903);
  hrf->SetBinContent(1454, 0.8315706);
  hrf->SetBinContent(1455, 0.8732846);
  hrf->SetBinContent(1456, 0.7947215);
  hrf->SetBinContent(1459, 0.8947669);
  hrf->SetBinContent(1460, 0.8324007);
  hrf->SetBinContent(1461, 0.7979457);
  hrf->SetBinContent(1462, 2);
  hrf->SetBinContent(1463, 0.8209487);
  hrf->SetBinContent(1464, 0.8033738);
  hrf->SetBinContent(1465, 0.7823778);
  hrf->SetBinContent(1466, 0.8794152);
  hrf->SetBinContent(1467, 0.8407297);
  hrf->SetBinContent(1468, 0.8277702);
  hrf->SetBinContent(1469, 0.810888);
  hrf->SetBinContent(1470, 0.7680818);
  hrf->SetBinContent(1471, 0.8095968);
  hrf->SetBinContent(1472, 0.790924);
  hrf->SetBinContent(1473, 0.8457994);
  hrf->SetBinContent(1474, 0.8210438);
  hrf->SetBinContent(1475, 0.8473524);
  hrf->SetBinContent(1476, 2.701161e-08);
  hrf->SetBinContent(1477, 0.8416434);
  hrf->SetBinContent(1478, 0.8278685);
  hrf->SetBinContent(1479, 0.9409888);
  hrf->SetBinContent(1480, 0.8393762);
  hrf->SetBinContent(1481, 0.8670172);
  hrf->SetBinContent(1482, 0.8475037);
  hrf->SetBinContent(1483, 0.4279374);
  hrf->SetBinContent(1484, 0.9529459);
  hrf->SetBinContent(1485, 0.8614377);
  hrf->SetBinContent(1486, 2);
  hrf->SetBinContent(1487, 0.8818654);
  hrf->SetBinContent(1488, 0.8004858);
  hrf->SetBinContent(1489, 0.8546413);
  hrf->SetBinContent(1490, 1.999866);
  hrf->SetBinContent(1491, 0.815396);
  hrf->SetBinContent(1492, 0.7853104);
  hrf->SetBinContent(1493, 0.8461049);
  hrf->SetBinContent(1494, 0.8015136);
  hrf->SetBinContent(1495, 0.7569559);
  hrf->SetBinContent(1496, 0.8288024);
  hrf->SetBinContent(1497, 0.7886032);
  hrf->SetBinContent(1498, 0.7762703);
  hrf->SetBinContent(1499, 0.770609);
  hrf->SetBinContent(1500, 0.817199);
  hrf->SetBinContent(1501, 0.7620718);
  hrf->SetBinContent(1502, 0.8152385);
  hrf->SetBinContent(1503, 0.8691072);
  hrf->SetBinContent(1504, 0.8155018);
  hrf->SetBinContent(1505, 0.8496901);
  hrf->SetBinContent(1506, 0.7108539);
  hrf->SetBinContent(1507, 0.856768);
  hrf->SetBinContent(1508, 0.7733098);
  hrf->SetBinContent(1509, 0.8095035);
  hrf->SetBinContent(1510, 1.06417);
  hrf->SetBinContent(1513, 0.9013685);
  hrf->SetBinContent(1514, 0.7900718);
  hrf->SetBinContent(1515, 0.7571104);
  hrf->SetBinContent(1516, 0.797836);
  hrf->SetBinContent(1517, 0.8264311);
  hrf->SetBinContent(1518, 0.800528);
  hrf->SetBinContent(1519, 0.8707364);
  hrf->SetBinContent(1520, 0.8413364);
  hrf->SetBinContent(1521, 0.6594373);
  hrf->SetBinContent(1522, 0.8289098);
  hrf->SetBinContent(1523, 0.7821766);
  hrf->SetBinContent(1524, 0.8083399);
  hrf->SetBinContent(1525, 0.7758535);
  hrf->SetBinContent(1526, 0.8410822);
  hrf->SetBinContent(1527, 0.8526707);
  hrf->SetBinContent(1528, 0.8628933);
  hrf->SetBinContent(1529, 0.7811331);
  hrf->SetBinContent(1530, 0.8275476);
  hrf->SetBinContent(1531, 0.8609779);
  hrf->SetBinContent(1532, 0.8738233);
  hrf->SetBinContent(1533, 2);
  hrf->SetBinContent(1534, 1.538174e-08);
  hrf->SetBinContent(1535, 0.8223987);
  hrf->SetBinContent(1536, 0.8590292);
  hrf->SetBinContent(1537, 0.8364939);
  hrf->SetBinContent(1538, 0.8625243);
  hrf->SetBinContent(1539, 0.7879927);
  hrf->SetBinContent(1540, 0.8329675);
  hrf->SetBinContent(1541, 0.8196524);
  hrf->SetBinContent(1542, 0.889112);
  hrf->SetBinContent(1543, 0.9101152);
  hrf->SetBinContent(1544, 0.7899218);
  hrf->SetBinContent(1545, 0.8052071);
  hrf->SetBinContent(1546, 0.4351703);
  hrf->SetBinContent(1547, 0.8065562);
  hrf->SetBinContent(1548, 0.8227643);
  hrf->SetBinContent(1549, 0.8074349);
  hrf->SetBinContent(1550, 0.8329206);
  hrf->SetBinContent(1551, 0.7967104);
  hrf->SetBinContent(1552, 0.7832514);
  hrf->SetBinContent(1553, 0.768122);
  hrf->SetBinContent(1554, 0.814672);
  hrf->SetBinContent(1555, 0.7814745);
  hrf->SetBinContent(1556, 0.8296988);
  hrf->SetBinContent(1557, 0.8460507);
  hrf->SetBinContent(1558, 0.8453766);
  hrf->SetBinContent(1559, 1.394065);
  hrf->SetBinContent(1560, 0.8195785);
  hrf->SetBinContent(1561, 0.8590771);
  hrf->SetBinContent(1562, 0.7999985);
  hrf->SetBinContent(1563, 0.8421693);
  hrf->SetBinContent(1564, 0.8634927);

  return hrf;
}

initialize_MET_with_CaloMET()

void TCMETAlgo::initialize_MET_with_CaloMET ( edm::Event &  event )

private

Definition at line 240 of file TCMETAlgo.cc.

References met_x_, met_y_, metToken_, multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, EcalPhiSymFlatTableProducers_cfi::sumEt, and sumEt_.

Referenced by CalculateTCMET().

                                                           {
  edm::Handle<edm::View<reco::MET>> metHandle;
  event.getByToken(metToken_, metHandle);
  met_x_ = (metHandle->front()).px();
  met_y_ = (metHandle->front()).py();
  sumEt_ = (metHandle->front()).sumEt();
}

initialize_MET_with_PFClusters()

void TCMETAlgo::initialize_MET_with_PFClusters ( edm::Event &  event )

private

Definition at line 196 of file TCMETAlgo.cc.

References clustersECALToken_, clustersHCALToken_, clustersHFToken_, funct::cos(), l1tnanotables_cff::et, PFLayer::HCAL_BARREL2, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, met_x_, met_y_, funct::sin(), and sumEt_.

Referenced by CalculateTCMET().

                                                              {
  float pfcmet_x = 0.;
  float pfcmet_y = 0.;
  float pfcsumet = 0.;

  edm::Handle<reco::PFClusterCollection> clustersECAL;
  event.getByToken(clustersECALToken_, clustersECAL);
  for (reco::PFClusterCollection::const_iterator it = clustersECAL->begin(); it != clustersECAL->end(); it++) {
    const math::XYZPoint& cluster_pos = it->position();
    double et = it->energy() / cosh(cluster_pos.eta());
    pfcmet_x -= et * cos(cluster_pos.phi());
    pfcmet_y -= et * sin(cluster_pos.phi());
    pfcsumet += et;
  }

  edm::Handle<reco::PFClusterCollection> clustersHCAL;
  event.getByToken(clustersHCALToken_, clustersHCAL);
  for (reco::PFClusterCollection::const_iterator it = clustersHCAL->begin(); it != clustersHCAL->end(); it++) {
    if (it->layer() == PFLayer::HCAL_BARREL2)
      continue;  //skip HO

    const math::XYZPoint& cluster_pos = it->position();
    double et = it->energy() / cosh(cluster_pos.eta());
    pfcmet_x -= et * cos(cluster_pos.phi());
    pfcmet_y -= et * sin(cluster_pos.phi());
    pfcsumet += et;
  }

  edm::Handle<reco::PFClusterCollection> clustersHF;
  event.getByToken(clustersHFToken_, clustersHF);
  for (reco::PFClusterCollection::const_iterator it = clustersHF->begin(); it != clustersHF->end(); it++) {
    const math::XYZPoint& cluster_pos = it->position();
    double et = it->energy() / cosh(cluster_pos.eta());
    pfcmet_x -= et * cos(cluster_pos.phi());
    pfcmet_y -= et * sin(cluster_pos.phi());
    pfcsumet += et;
  }

  met_x_ = pfcmet_x;
  met_y_ = pfcmet_y;
  sumEt_ = pfcsumet;
}

isElectron()

bool TCMETAlgo::isElectron ( const reco::TrackRef &  trackRef )

private

Definition at line 559 of file TCMETAlgo.cc.

References electronHandle_, hOverECut_, edm::Ref< C, T, F >::isNonnull(), and edm::Ref< C, T, F >::key().

Referenced by correct_MET_for_Tracks(), findDuplicateTracks(), and findGoodShowerTracks().

                                                       {
  for (reco::GsfElectronCollection::const_iterator electron_it = electronHandle_->begin();
       electron_it != electronHandle_->end();
       ++electron_it) {
    reco::TrackRef el_track = electron_it->closestCtfTrackRef();

    unsigned int ele_idx = el_track.isNonnull() ? el_track.key() : 99999;

    if (ele_idx == trackRef.key()) {
      if (electron_it->hadronicOverEm() < hOverECut_)
        return true;
    }
  }

  return false;
}

isGoodTrack()

bool TCMETAlgo::isGoodTrack ( const reco::TrackRef  trackRef )

private

Definition at line 577 of file TCMETAlgo.cc.

References beamSpotHandle_, DMR_cfg::cut, d0, d0cuta_, d0cutb_, duplicateTracks_, PVValHelper::dz, spr::find(), hasValidVertex_, mps_fire::i, edm::HandleBase::isValid(), maxchi2_, maxchi2_tight_, maxd0cut_, maxeta_, maxpt_, maxpt_eta20_, maxpt_eta25_, maxPtErr_, maxPtErr_tight_, minhits_, minhits_tight_, nLayers(), nLayers_, nLayersTight_, reco::BeamSpot::position(), funct::pow(), mathSSE::sqrt(), HLT_2024v14_cff::track, trackAlgos_, trkAlgos_, trkQuality_, bphysicsOniaDQM_cfi::vertex, vertexMaxDZ_, and vetoDuplicates_.

Referenced by correct_MET_for_Tracks(), and findGoodShowerTracks().

                                                    {
  double d0 = 9999.;

  if (hasValidVertex_) {
    //get d0 corrected for primary vertex
    const reco::Vertex& vertex = (*vertexColl_)[0];
    const Point pvtx = Point(vertex.x(), vertex.y(), vertex.z());

    double dz = track->dz(pvtx);

    if (fabs(dz) < vertexMaxDZ_) {
      //get d0 corrected for pvtx
      d0 = -1 * track->dxy(pvtx);
    } else {
      // get d0 corrected for beam spot
      bool haveBeamSpot = true;
      if (!beamSpotHandle_.isValid())
        haveBeamSpot = false;

      Point bspot = haveBeamSpot ? beamSpotHandle_->position() : Point(0, 0, 0);
      d0 = -1 * track->dxy(bspot);
    }
  } else {
    // get d0 corrected for beam spot
    bool haveBeamSpot = true;
    if (!beamSpotHandle_.isValid())
      haveBeamSpot = false;

    Point bspot = haveBeamSpot ? beamSpotHandle_->position() : Point(0, 0, 0);
    d0 = -1 * track->dxy(bspot);
  }

  if (std::find(trackAlgos_.begin(), trackAlgos_.end(), track->algo()) != trackAlgos_.end()) {
    //1st 4 tracking iterations (pT-dependent d0 cut + nlayers cut)

    float d0cut = sqrt(pow(d0cuta_, 2) + pow(d0cutb_ / track->pt(), 2));
    if (d0cut > maxd0cut_)
      d0cut = maxd0cut_;

    if (fabs(d0) > d0cut)
      return false;
    if (nLayers(track) < nLayers_)
      return false;

  } else {
    //last 2 tracking iterations (tighten chi2, nhits, pt error, nlayers cuts)
    if (track->normalizedChi2() > maxchi2_tight_)
      return false;
    if (track->numberOfValidHits() < minhits_tight_)
      return false;
    if ((track->ptError() / track->pt()) > maxPtErr_tight_)
      return false;
    if (nLayers(track) < nLayersTight_)
      return false;
  }

  if (track->numberOfValidHits() < minhits_)
    return false;
  if (track->normalizedChi2() > maxchi2_)
    return false;
  if (fabs(track->eta()) > maxeta_)
    return false;
  if (track->pt() > maxpt_)
    return false;
  if ((track->ptError() / track->pt()) > maxPtErr_)
    return false;
  if (fabs(track->eta()) > 2.5 && track->pt() > maxpt_eta25_)
    return false;
  if (fabs(track->eta()) > 2.0 && track->pt() > maxpt_eta20_)
    return false;

  int cut = 0;
  for (unsigned int i = 0; i < trkQuality_.size(); i++) {
    cut |= (1 << trkQuality_.at(i));
  }

  if (!((track->qualityMask() & cut) == cut))
    return false;

  bool isGoodAlgo = false;
  if (trkAlgos_.empty())
    isGoodAlgo = true;
  for (unsigned int i = 0; i < trkAlgos_.size(); i++) {
    if (track->algo() == trkAlgos_.at(i))
      isGoodAlgo = true;
  }

  if (!isGoodAlgo)
    return false;

  if (vetoDuplicates_) {
    for (unsigned int iDup = 0; iDup < duplicateTracks_.size(); ++iDup) {
      if ((int)track.key() == duplicateTracks_.at(iDup))
        return false;
    }
  }

  return true;
}

isMuon()

bool TCMETAlgo::isMuon ( const reco::TrackRef &  trackRef )

private

Definition at line 548 of file TCMETAlgo.cc.

References edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), and muonHandle_.

Referenced by correct_MET_for_Tracks(), findDuplicateTracks(), and findGoodShowerTracks().

                                                   {
  for (reco::MuonCollection::const_iterator muon_it = muonHandle_->begin(); muon_it != muonHandle_->end(); ++muon_it) {
    reco::TrackRef mu_track = muon_it->innerTrack();
    unsigned int idxMuon = mu_track.isNonnull() ? mu_track.key() : 99999;
    if (idxMuon == trackRef.key())
      return true;
  }
  return false;
}

isValidVertex()

bool TCMETAlgo::isValidVertex ( )

private

Definition at line 442 of file TCMETAlgo.cc.

References funct::pow(), mathSSE::sqrt(), vertexColl_, vertexNdof_, vertexRho_, and vertexZ_.

Referenced by correct_MET_for_Tracks().

                              {
  if (vertexColl_->begin()->isFake())
    return false;
  if (vertexColl_->begin()->ndof() < vertexNdof_)
    return false;
  if (fabs(vertexColl_->begin()->z()) > vertexZ_)
    return false;
  if (sqrt(pow(vertexColl_->begin()->x(), 2) + pow(vertexColl_->begin()->y(), 2)) > vertexRho_)
    return false;

  return true;
}

nearGoodShowerTrack()

bool TCMETAlgo::nearGoodShowerTrack ( const reco::TrackRef  track, const std::vector< int > &  goodShowerTracks  )

private

Definition at line 492 of file TCMETAlgo.cc.

References deltaRShower_, HGC3DClusterGenMatchSelector_cfi::dR, HLT_2024v14_cff::eta1, HLT_2024v14_cff::eta2, funct::pow(), mathSSE::sqrt(), HLT_2024v14_cff::track, and trackHandle_.

Referenced by correct_MET_for_Tracks().

                                                                                                    {
  //checks if 'track' is within dR < deltaRShower_ of any good shower tracks
  float eta1 = track->eta();
  float phi1 = track->phi();

  for (unsigned int itrk = 0; itrk < goodShowerTracks.size(); itrk++) {
    reco::TrackRef trkref(trackHandle_, itrk);
    float eta2 = trkref->eta();
    float phi2 = trkref->phi();

    float dR = sqrt(pow(eta1 - eta2, 2) + pow(phi1 - phi2, 2));
    if (dR < deltaRShower_)
      return true;
  }

  return false;
}

nExpectedInnerHits()

int TCMETAlgo::nExpectedInnerHits ( const reco::TrackRef  track )

private

Definition at line 535 of file TCMETAlgo.cc.

References reco::HitPattern::MISSING_INNER_HITS, and HLT_2024v14_cff::track.

                                                          {
  return track->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
}

nExpectedOuterHits()

int TCMETAlgo::nExpectedOuterHits ( const reco::TrackRef  track )

private

Definition at line 540 of file TCMETAlgo.cc.

References reco::HitPattern::MISSING_OUTER_HITS, and HLT_2024v14_cff::track.

Referenced by correct_MET_for_Tracks(), and findGoodShowerTracks().

                                                          {
  return track->hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS);
}

nLayers()

int TCMETAlgo::nLayers ( const reco::TrackRef  track )

private

Definition at line 545 of file TCMETAlgo.cc.

References HLT_2024v14_cff::track.

Referenced by isGoodTrack().

{ return track->hitPattern().trackerLayersWithMeasurement(); }

propagateTrackToCalorimeterFace()

TVector3 TCMETAlgo::propagateTrackToCalorimeterFace ( const reco::TrackRef  trackRef )

private

Definition at line 740 of file TCMETAlgo.cc.

References alongMomentum, Reference_intrackfit_cff::barrel, Calorimetry_cff::bField, Plane::build(), Cylinder::build(), TCMET_cfi::corner, corner_, TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), M_PI, magneticFieldHandle_, Pi, edm::ESHandle< T >::product(), AnalyticalPropagator::propagate(), CosmicsPD_Skims::radius, radius_, HLT_2024v14_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), PV3DBase< T, PVType, FrameType >::z(), TCMET_cfi::zdist, and zdist_.

Referenced by correct_MET_for_Muons(), and correct_MET_for_Tracks().

                                                                            {
  const class MagneticField* bField = magneticFieldHandle_.product();

  TVector3 outerTrkPosition;

  outerTrkPosition.SetPtEtaPhi(999., -10., 2 * TMath::Pi());

  GlobalPoint tpVertex(track->vx(), track->vy(), track->vz());
  GlobalVector tpMomentum(track->px(), track->py(), track->pz());
  int tpCharge(track->charge());

  FreeTrajectoryState fts(tpVertex, tpMomentum, tpCharge, bField);

  const float zdist = zdist_;  //314.;

  const float radius = radius_;  //130.;

  const float corner = corner_;  //1.479;

  Plane::PlanePointer lendcap = Plane::build(Plane::PositionType(0, 0, -zdist), Plane::RotationType());
  Plane::PlanePointer rendcap = Plane::build(Plane::PositionType(0, 0, zdist), Plane::RotationType());

  Cylinder::CylinderPointer barrel = Cylinder::build(radius, Cylinder::PositionType(0, 0, 0), Cylinder::RotationType());

  AnalyticalPropagator myAP(bField, alongMomentum, 2 * M_PI);

  TrajectoryStateOnSurface tsos;

  if (track->eta() < -corner) {
    tsos = myAP.propagate(fts, *lendcap);
  } else if (fabs(track->eta()) < corner) {
    tsos = myAP.propagate(fts, *barrel);
  } else if (track->eta() > corner) {
    tsos = myAP.propagate(fts, *rendcap);
  }

  if (tsos.isValid())
    outerTrkPosition.SetXYZ(tsos.globalPosition().x(), tsos.globalPosition().y(), tsos.globalPosition().z());
  else
    outerTrkPosition.SetPtEtaPhi(999., -10., 2 * TMath::Pi());

  return outerTrkPosition;
}

vetoTrack()

int TCMETAlgo::vetoTrack ( int  i1, int  i2  )

private

Definition at line 420 of file TCMETAlgo.cc.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, RandomServiceHelper::t1, RandomServiceHelper::t2, and trackHandle_.

Referenced by findDuplicateTracks().

                                       {
  //given 2 tracks, decide which one to veto
  reco::TrackRef t1(trackHandle_, i1);
  reco::TrackRef t2(trackHandle_, i2);

  if (t1->numberOfValidHits() < t2->numberOfValidHits())
    return i1;
  else if (t1->numberOfValidHits() > t2->numberOfValidHits())
    return i2;
  else if (t1->chi2() / t1->ndof() > t2->chi2() / t2->ndof())
    return i1;
  else if (t1->chi2() / t1->ndof() < t2->chi2() / t2->ndof())
    return i2;
  else if (t1->ptError() > t2->ptError())
    return i1;
  else if (t1->ptError() < t2->ptError())
    return i2;
  else
    return i1;
}

Member Data Documentation

beamSpotHandle_

edm::Handle<reco::BeamSpot> TCMETAlgo::beamSpotHandle_

private

Definition at line 93 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and isGoodTrack().

beamSpotToken_

edm::EDGetTokenT<reco::BeamSpot> TCMETAlgo::beamSpotToken_

private

Definition at line 104 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

checkTrackPropagation_

bool TCMETAlgo::checkTrackPropagation_

private

Definition at line 159 of file TCMETAlgo.h.

Referenced by configure(), correctMETforTrack(), and correctSumEtForTrack().

clustersECALToken_

edm::EDGetTokenT<reco::PFClusterCollection> TCMETAlgo::clustersECALToken_

private

Definition at line 106 of file TCMETAlgo.h.

Referenced by configure(), and initialize_MET_with_PFClusters().

clustersHCALToken_

edm::EDGetTokenT<reco::PFClusterCollection> TCMETAlgo::clustersHCALToken_

private

Definition at line 107 of file TCMETAlgo.h.

Referenced by configure(), and initialize_MET_with_PFClusters().

clustersHFToken_

edm::EDGetTokenT<reco::PFClusterCollection> TCMETAlgo::clustersHFToken_

private

Definition at line 108 of file TCMETAlgo.h.

Referenced by configure(), and initialize_MET_with_PFClusters().

corner_

double TCMETAlgo::corner_

private

Definition at line 146 of file TCMETAlgo.h.

Referenced by configure(), and propagateTrackToCalorimeterFace().

correctShowerTracks_

bool TCMETAlgo::correctShowerTracks_

private

Definition at line 156 of file TCMETAlgo.h.

Referenced by configure(), and correct_MET_for_Tracks().

d0cuta_

double TCMETAlgo::d0cuta_

private

Definition at line 128 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

d0cutb_

double TCMETAlgo::d0cutb_

private

Definition at line 129 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

deltaRShower_

double TCMETAlgo::deltaRShower_

private

Definition at line 137 of file TCMETAlgo.h.

Referenced by configure(), and nearGoodShowerTrack().

dupDCotTh_

double TCMETAlgo::dupDCotTh_

private

Definition at line 125 of file TCMETAlgo.h.

Referenced by configure(), and findDuplicateTracks().

dupDPhi_

double TCMETAlgo::dupDPhi_

private

Definition at line 124 of file TCMETAlgo.h.

Referenced by configure(), and findDuplicateTracks().

duplicateTracks_

std::vector<int> TCMETAlgo::duplicateTracks_

private

Definition at line 126 of file TCMETAlgo.h.

Referenced by correct_MET_for_Tracks(), findDuplicateTracks(), and isGoodTrack().

dupMinPt_

double TCMETAlgo::dupMinPt_

private

Definition at line 123 of file TCMETAlgo.h.

Referenced by configure(), and findDuplicateTracks().

electronHandle_

edm::Handle<reco::GsfElectronCollection> TCMETAlgo::electronHandle_

private

Definition at line 91 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), closeToElectron(), and isElectron().

electronToken_

edm::EDGetTokenT<reco::GsfElectronCollection> TCMETAlgo::electronToken_

private

Definition at line 101 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

electronVetoCone_

bool TCMETAlgo::electronVetoCone_

private

Definition at line 157 of file TCMETAlgo.h.

Referenced by configure(), and correct_MET_for_Tracks().

eVetoDeltaCotTheta_

double TCMETAlgo::eVetoDeltaCotTheta_

private

Definition at line 149 of file TCMETAlgo.h.

Referenced by closeToElectron(), and configure().

eVetoDeltaPhi_

double TCMETAlgo::eVetoDeltaPhi_

private

Definition at line 148 of file TCMETAlgo.h.

Referenced by closeToElectron(), and configure().

eVetoDeltaR_

double TCMETAlgo::eVetoDeltaR_

private

Definition at line 147 of file TCMETAlgo.h.

Referenced by closeToElectron(), and configure().

eVetoMinElectronPt_

double TCMETAlgo::eVetoMinElectronPt_

private

Definition at line 150 of file TCMETAlgo.h.

Referenced by closeToElectron(), and configure().

hasValidVertex_

bool TCMETAlgo::hasValidVertex_

private

Definition at line 163 of file TCMETAlgo.h.

Referenced by correct_MET_for_Tracks(), and isGoodTrack().

hOverECut_

double TCMETAlgo::hOverECut_

private

Definition at line 151 of file TCMETAlgo.h.

Referenced by closeToElectron(), configure(), and isElectron().

isCosmics_

bool TCMETAlgo::isCosmics_

private

Definition at line 155 of file TCMETAlgo.h.

Referenced by configure(), correct_MET_for_Tracks(), findDuplicateTracks(), and findGoodShowerTracks().

magneticFieldHandle_

edm::ESHandle<MagneticField> TCMETAlgo::magneticFieldHandle_

private

Definition at line 98 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and propagateTrackToCalorimeterFace().

magneticFieldToken_

edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TCMETAlgo::magneticFieldToken_

private

Definition at line 111 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

maxchi2_

double TCMETAlgo::maxchi2_

private

Definition at line 141 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxchi2_tight_

double TCMETAlgo::maxchi2_tight_

private

Definition at line 131 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxd0cut_

double TCMETAlgo::maxd0cut_

private

Definition at line 130 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxeta_

double TCMETAlgo::maxeta_

private

Definition at line 140 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxpt_

double TCMETAlgo::maxpt_

private

Definition at line 139 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxpt_eta20_

double TCMETAlgo::maxpt_eta20_

private

Definition at line 121 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxpt_eta25_

double TCMETAlgo::maxpt_eta25_

private

Definition at line 120 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxPtErr_

double TCMETAlgo::maxPtErr_

private

Definition at line 143 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

maxPtErr_tight_

double TCMETAlgo::maxPtErr_tight_

private

Definition at line 133 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

met_x_

double TCMETAlgo::met_x_

private

Definition at line 81 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), correctMETforMuon(), correctMETforTrack(), initialize_MET_with_CaloMET(), and initialize_MET_with_PFClusters().

met_y_

double TCMETAlgo::met_y_

private

Definition at line 82 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), correctMETforMuon(), correctMETforTrack(), initialize_MET_with_CaloMET(), and initialize_MET_with_PFClusters().

metToken_

edm::EDGetTokenT<edm::View<reco::MET> > TCMETAlgo::metToken_

private

Definition at line 102 of file TCMETAlgo.h.

Referenced by configure(), and initialize_MET_with_CaloMET().

minhits_

double TCMETAlgo::minhits_

private

Definition at line 142 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

minhits_tight_

double TCMETAlgo::minhits_tight_

private

Definition at line 132 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

minpt_

double TCMETAlgo::minpt_

private

Definition at line 138 of file TCMETAlgo.h.

Referenced by configure(), correctMETforTrack(), and correctSumEtForTrack().

muonDepValueMapHandle_

edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData> > TCMETAlgo::muonDepValueMapHandle_

private

Definition at line 95 of file TCMETAlgo.h.

Referenced by CalculateTCMET().

muonDepValueMapToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > TCMETAlgo::muonDepValueMapToken_

private

Definition at line 109 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

muonHandle_

edm::Handle<reco::MuonCollection> TCMETAlgo::muonHandle_

private

Definition at line 90 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), correct_MET_for_Muons(), and isMuon().

muonToken_

edm::EDGetTokenT<reco::MuonCollection> TCMETAlgo::muonToken_

private

Definition at line 100 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

nLayers_

int TCMETAlgo::nLayers_

private

Definition at line 114 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

nLayersTight_

int TCMETAlgo::nLayersTight_

private

Definition at line 115 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

nMinOuterHits_

int TCMETAlgo::nMinOuterHits_

private

Definition at line 134 of file TCMETAlgo.h.

Referenced by configure(), correct_MET_for_Tracks(), and findGoodShowerTracks().

radius_

double TCMETAlgo::radius_

private

Definition at line 144 of file TCMETAlgo.h.

Referenced by configure(), and propagateTrackToCalorimeterFace().

response_function_

class TH2D* TCMETAlgo::response_function_

private

Definition at line 161 of file TCMETAlgo.h.

Referenced by configure(), correct_MET_for_Muons(), correct_MET_for_Tracks(), and ~TCMETAlgo().

showerRF_

class TH2D* TCMETAlgo::showerRF_

private

Definition at line 162 of file TCMETAlgo.h.

Referenced by configure(), correct_MET_for_Tracks(), and ~TCMETAlgo().

sumEt_

double TCMETAlgo::sumEt_

private

Definition at line 83 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), correctMETforMuon(), correctSumEtForTrack(), initialize_MET_with_CaloMET(), and initialize_MET_with_PFClusters().

tcmetDepValueMapHandle_

edm::Handle<edm::ValueMap<reco::MuonMETCorrectionData> > TCMETAlgo::tcmetDepValueMapHandle_

private

Definition at line 96 of file TCMETAlgo.h.

Referenced by CalculateTCMET().

tcmetDepValueMapToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonMETCorrectionData> > TCMETAlgo::tcmetDepValueMapToken_

private

Definition at line 110 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

trackAlgos_

std::vector<reco::TrackBase::TrackAlgorithm> TCMETAlgo::trackAlgos_

private

Definition at line 135 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

trackHandle_

edm::Handle<reco::TrackCollection> TCMETAlgo::trackHandle_

private

Definition at line 92 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), correct_MET_for_Tracks(), findDuplicateTracks(), findGoodShowerTracks(), nearGoodShowerTrack(), and vetoTrack().

trackToken_

edm::EDGetTokenT<reco::TrackCollection> TCMETAlgo::trackToken_

private

Definition at line 103 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

trkAlgos_

std::vector<reco::TrackBase::TrackAlgorithm> TCMETAlgo::trkAlgos_

private

Definition at line 153 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

trkQuality_

std::vector<int> TCMETAlgo::trkQuality_

private

Definition at line 152 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

usedeltaRRejection_

double TCMETAlgo::usedeltaRRejection_

private

Definition at line 136 of file TCMETAlgo.h.

Referenced by configure(), and correct_MET_for_Tracks().

usePFClusters_

bool TCMETAlgo::usePFClusters_

private

Definition at line 113 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

usePvtxd0_

bool TCMETAlgo::usePvtxd0_

private

Definition at line 158 of file TCMETAlgo.h.

Referenced by configure(), and correct_MET_for_Tracks().

vertexColl_

const reco::VertexCollection* TCMETAlgo::vertexColl_

private

Definition at line 164 of file TCMETAlgo.h.

Referenced by correct_MET_for_Tracks(), and isValidVertex().

vertexHandle_

edm::Handle<reco::VertexCollection> TCMETAlgo::vertexHandle_

private

Definition at line 94 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and correct_MET_for_Tracks().

vertexMaxDZ_

double TCMETAlgo::vertexMaxDZ_

private

Definition at line 119 of file TCMETAlgo.h.

Referenced by configure(), and isGoodTrack().

vertexNdof_

int TCMETAlgo::vertexNdof_

private

Definition at line 116 of file TCMETAlgo.h.

Referenced by configure(), and isValidVertex().

vertexRho_

double TCMETAlgo::vertexRho_

private

Definition at line 118 of file TCMETAlgo.h.

Referenced by configure(), and isValidVertex().

vertexToken_

edm::EDGetTokenT<reco::VertexCollection> TCMETAlgo::vertexToken_

private

Definition at line 105 of file TCMETAlgo.h.

Referenced by CalculateTCMET(), and configure().

vertexZ_

double TCMETAlgo::vertexZ_

private

Definition at line 117 of file TCMETAlgo.h.

Referenced by configure(), and isValidVertex().

vetoDuplicates_

bool TCMETAlgo::vetoDuplicates_

private

Definition at line 122 of file TCMETAlgo.h.

Referenced by configure(), correct_MET_for_Tracks(), and isGoodTrack().

zdist_

double TCMETAlgo::zdist_

private

Definition at line 145 of file TCMETAlgo.h.

Referenced by configure(), and propagateTrackToCalorimeterFace().