ZIterativeAlgorithmWithFit Class Reference

#include <ZIterativeAlgorithmWithFit.h>

Classes
struct	ZIterativeAlgorithmWithFitPlots

Public Member Functions
bool	addEvent (calib::CalibElectron *, calib::CalibElectron *, float)
const std::vector< float > &	getEpsilonSum () const
const ZIterativeAlgorithmWithFitPlots *	getHistos () const
int	getNumberOfChannels () const
int	getNumberOfIterations () const
const std::vector< float > &	getOptimizedChiSquare () const
const std::vector< float > &	getOptimizedCoefficients () const
const std::vector< float > &	getOptimizedCoefficientsError () const
const std::vector< int > &	getOptimizedIterations () const
const std::vector< float > &	getWeightSum () const
bool	iterate ()
ZIterativeAlgorithmWithFit &	operator= (const ZIterativeAlgorithmWithFit &r)
	Assignment operator. More...
bool	resetIteration ()
	ZIterativeAlgorithmWithFit ()
	Default constructor. More...
	ZIterativeAlgorithmWithFit (const edm::ParameterSet &ps)
	Constructor with explicit iterations & exponent. More...
virtual	~ZIterativeAlgorithmWithFit ()
	Destructor. More...

Static Public Member Functions
static float	cosTheta12 (float Eta1, float Phi1, float Eta2, float Phi2)
static void	gausfit (TH1F *histoou, double *par, double *errpar, float nsigmalow, float nsigmaup, double *mychi2, int *iterations)
static float	invMassCalc (float Energy1, float Eta1, float Phi1, float Energy2, float Eta2, float Phi2)

Private Member Functions
void	addWeightsCorrections (unsigned int event_id)
void	bookHistograms ()
float	getEventWeight (unsigned int event_id)
void	getStatWeights (const std::string &file)
void	getWeight (unsigned int evid, std::pair< calib::CalibElectron *, calib::CalibElectron *>, float)
void	getWeight (unsigned int evid, calib::CalibElectron *ele, float)
void	recalculateMasses ()
void	recalculateWeightsEnergies ()
void	recalculateWeightsEnergies (calib::CalibElectron *electron)

Private Attributes
std::vector< float >	calib_fac_
TString	calibType_
unsigned int	channels_
unsigned int	currentEvent_
unsigned int	currentIteration_
std::vector< std::pair< calib::CalibElectron *, calib::CalibElectron * > >	electrons_
std::vector< float >	Event_Weight_
std::string	massMethod
std::vector< float >	massReco_
int	nCrystalCut_
unsigned int	numberOfIterations_
std::vector< float >	optimizedChiSquare_
std::vector< float >	optimizedCoefficients_
std::vector< float >	optimizedCoefficientsError_
std::vector< int >	optimizedIterations_
std::vector< float >	StatWeights_
ZIterativeAlgorithmWithFitPlots *	thePlots_
unsigned int	totalEvents_
bool	UseStatWeights_
std::vector< float >	weight_sum_
std::string	WeightFileName_

Static Private Attributes
static const double	M_Z_ = 91.187

Detailed Description

Class that implements an iterative in situ calibration algorithm using Z events
Author: paolo.nosp@m..mer.nosp@m.idian.nosp@m.i@ro.nosp@m.ma1.i.nosp@m.nfn..nosp@m.it

Definition at line 28 of file ZIterativeAlgorithmWithFit.h.

Constructor & Destructor Documentation

ZIterativeAlgorithmWithFit() [1/2]

ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit

(

)

Default constructor.

Definition at line 46 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, currentEvent_, currentIteration_, electrons_, massReco_, numberOfIterations_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, totalEvents_, and weight_sum_.

                                                       {
  // std::cout<< "ZIterativeAlgorithmWithFit::Called Construnctor" << std::endl;
  numberOfIterations_ = 10;
  channels_ = 1;
  totalEvents_ = 0;
  currentEvent_ = 0;
  currentIteration_ = 0;
  optimizedCoefficients_.resize(channels_);
  optimizedCoefficientsError_.resize(channels_);
  optimizedChiSquare_.resize(channels_);
  optimizedIterations_.resize(channels_);
  calib_fac_.resize(channels_);
  weight_sum_.resize(channels_);
  electrons_.resize(1);
  massReco_.resize(1);
}

ZIterativeAlgorithmWithFit() [2/2]

ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit

(

const edm::ParameterSet &

ps

)

Constructor with explicit iterations & exponent.

Definition at line 63 of file ZIterativeAlgorithmWithFit.cc.

References bookHistograms(), calib_fac_, calibType_, channels_, gather_cfg::cout, currentEvent_, currentIteration_, EcalIndexingTools::getInstance(), EcalIndexingTools::getNumberOfChannels(), getStatWeights(), edm::ParameterSet::getUntrackedParameter(), massMethod, EcalRingCalibrationTools::N_MODULES_BARREL, EcalRingCalibrationTools::N_RING_TOTAL, nCrystalCut_, numberOfIterations_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, StatWeights_, AlCaHLTBitMon_QueryRunRegistry::string, thePlots_, totalEvents_, UseStatWeights_, weight_sum_, and WeightFileName_.

{
  //std::cout<< "ZIterativeAlgorithmWithFit::Called Constructor" << std::endl;
  numberOfIterations_ = ps.getUntrackedParameter<unsigned int>("maxLoops", 0);
  massMethod = ps.getUntrackedParameter<std::string>("ZCalib_InvMass", "SCMass");
  calibType_ = ps.getUntrackedParameter<std::string>("ZCalib_CalibType", "RING");

  if (calibType_ == "RING")
    channels_ = EcalRingCalibrationTools::N_RING_TOTAL;
  else if (calibType_ == "MODULE")

    channels_ = EcalRingCalibrationTools::N_MODULES_BARREL;
  else if (calibType_ == "ABS_SCALE")
    channels_ = 1;
  else if (calibType_ == "ETA_ET_MODE")
    channels_ = EcalIndexingTools::getInstance()->getNumberOfChannels();

  std::cout << "[ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFit] channels_ = " << channels_ << std::endl;

  nCrystalCut_ = ps.getUntrackedParameter<int>("ZCalib_nCrystalCut", -1);

  //Resetting currentEvent & iteration
  currentEvent_ = 0;
  currentIteration_ = 0;
  totalEvents_ = 0;

  optimizedCoefficients_.resize(channels_);
  optimizedCoefficientsError_.resize(channels_);
  optimizedChiSquare_.resize(channels_);
  optimizedIterations_.resize(channels_);
  calib_fac_.resize(channels_);
  weight_sum_.resize(channels_);

  //Creating and booking histograms
  thePlots_ = new ZIterativeAlgorithmWithFitPlots;
  bookHistograms();

  //Setting up rescaling if needed
  UseStatWeights_ = ps.getUntrackedParameter<bool>("ZCalib_UseStatWeights", false);
  if (UseStatWeights_) {
    WeightFileName_ = "weights.txt";
    StatWeights_.resize(channels_);
    getStatWeights(WeightFileName_);
    //    Event_Weight_.resize(events);
  }
}

~ZIterativeAlgorithmWithFit()

ZIterativeAlgorithmWithFit::~ZIterativeAlgorithmWithFit ( )

virtual

Destructor.

Definition at line 353 of file ZIterativeAlgorithmWithFit.cc.

{}

Member Function Documentation

addEvent()

bool ZIterativeAlgorithmWithFit::addEvent	(	calib::CalibElectron *	ele1,
		calib::CalibElectron *	ele2,
		float	invMassRescFactor
	)

Definition at line 250 of file ZIterativeAlgorithmWithFit.cc.

References gather_cfg::cout, currentEvent_, HLTTauDQMOffline_cfi::Electrons, reco::LeafCandidate::eta(), calib::CalibElectron::getRecoElectron(), getWeight(), invMassCalc(), massMethod, massReco_, reco::LeafCandidate::phi(), reco::GsfElectron::superCluster(), and totalEvents_.

Referenced by ZeeCalibration::duringLoop().

                                                                   {
  totalEvents_++;
  std::pair<calib::CalibElectron*, calib::CalibElectron*> Electrons(ele1, ele2);
#ifdef DEBUG
  std::cout << "In addEvent ";
  std::cout << ele1->getRecoElectron()->superCluster()->rawEnergy() << " ";
  std::cout << ele1->getRecoElectron()->superCluster()->position().eta() << " ";
  std::cout << ele2->getRecoElectron()->superCluster()->rawEnergy() << " ";
  std::cout << ele2->getRecoElectron()->superCluster()->position().eta() << " ";
  std::cout << std::endl;
#endif

  if (massMethod == "SCTRMass") {
    massReco_.push_back(invMassCalc(ele1->getRecoElectron()->superCluster()->energy(),
                                    ele1->getRecoElectron()->eta(),
                                    ele1->getRecoElectron()->phi(),
                                    ele2->getRecoElectron()->superCluster()->energy(),
                                    ele2->getRecoElectron()->eta(),
                                    ele2->getRecoElectron()->phi()));
  }

  else if (massMethod == "SCMass") {
    massReco_.push_back(invMassCalc(ele1->getRecoElectron()->superCluster()->energy(),
                                    ele1->getRecoElectron()->superCluster()->position().eta(),
                                    ele1->getRecoElectron()->superCluster()->position().phi(),
                                    ele2->getRecoElectron()->superCluster()->energy(),
                                    ele2->getRecoElectron()->superCluster()->position().eta(),
                                    ele2->getRecoElectron()->superCluster()->position().phi()));
  }

#ifdef DEBUG
  std::cout << "Mass calculated " << massReco_[currentEvent_] << std::endl;
#endif

  if ((ele2->getRecoElectron()->superCluster()->position().eta() > -10.) &&
      (ele2->getRecoElectron()->superCluster()->position().eta() < 10.) &&
      (ele2->getRecoElectron()->superCluster()->position().phi() > -10.) &&
      (ele2->getRecoElectron()->superCluster()->position().phi() < 10.)) {
    getWeight(currentEvent_, Electrons, invMassRescFactor);
  }

  currentEvent_++;
  return kTRUE;
}

addWeightsCorrections()

void ZIterativeAlgorithmWithFit::addWeightsCorrections ( unsigned int  event_id )

private

bookHistograms()

void ZIterativeAlgorithmWithFit::bookHistograms ( )

private

Definition at line 111 of file ZIterativeAlgorithmWithFit.cc.

References channels_, HltBtagPostValidation_cff::histoName, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, MAX_RESCALE, MIN_RESCALE, NBINS_HIGHETA, NBINS_LOWETA, numberOfIterations_, thePlots_, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::unweightedRescaleFactor, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weight, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

Referenced by ZIterativeAlgorithmWithFit().

                                                {
  if (!thePlots_)
    return;

  for (unsigned int i2 = 0; i2 < numberOfIterations_; i2++) {
    for (unsigned int i1 = 0; i1 < channels_; i1++) {
      char histoName[200];
      char histoTitle[200];

      //WeightedRescaling factor
      sprintf(histoName, "WeightedRescaleFactor_channel_%d_Iteration_%d", i1, i2);
      sprintf(histoTitle, "WeightedRescaleFactor Channel_%d Iteration %d", i1, i2);
      if (i1 > 15 && i1 < 155)
        thePlots_->weightedRescaleFactor[i2][i1] =
            new TH1F(histoName, histoTitle, NBINS_LOWETA, MIN_RESCALE, MAX_RESCALE);
      else
        thePlots_->weightedRescaleFactor[i2][i1] =
            new TH1F(histoName, histoTitle, NBINS_HIGHETA, MIN_RESCALE, MAX_RESCALE);
      thePlots_->weightedRescaleFactor[i2][i1]->GetXaxis()->SetTitle("Rescale factor");
      thePlots_->weightedRescaleFactor[i2][i1]->GetYaxis()->SetTitle("a.u.");

      //UnweightedRescaling factor
      sprintf(histoName, "UnweightedRescaleFactor_channel_%d_Iteration_%d", i1, i2);
      sprintf(histoTitle, "UnweightedRescaleFactor Channel_%d Iteration %d", i1, i2);
      if (i1 > 15 && i1 < 155)
        thePlots_->unweightedRescaleFactor[i2][i1] =
            new TH1F(histoName, histoTitle, NBINS_LOWETA, MIN_RESCALE, MAX_RESCALE);
      else
        thePlots_->unweightedRescaleFactor[i2][i1] =
            new TH1F(histoName, histoTitle, NBINS_HIGHETA, MIN_RESCALE, MAX_RESCALE);
      thePlots_->unweightedRescaleFactor[i2][i1]->GetXaxis()->SetTitle("Rescale factor");
      thePlots_->unweightedRescaleFactor[i2][i1]->GetYaxis()->SetTitle("a.u.");

      //Weights
      sprintf(histoName, "Weight_channel_%d_Iteration_%d", i1, i2);
      sprintf(histoTitle, "Weight Channel_%d Iteration %d", i1, i2);
      thePlots_->weight[i2][i1] = new TH1F(histoName, histoTitle, 100, 0., 1.);
      thePlots_->weight[i2][i1]->GetXaxis()->SetTitle("Weight");
      thePlots_->weight[i2][i1]->GetYaxis()->SetTitle("a.u.");
    }
  }
}

cosTheta12()

static float ZIterativeAlgorithmWithFit::cosTheta12 ( float  Eta1, float  Phi1, float  Eta2, float  Phi2  )

inlinestatic

Definition at line 79 of file ZIterativeAlgorithmWithFit.h.

References funct::cos(), and calostep_cfi::Eta1.

Referenced by invMassCalc().

                                                                                 {
    return ((cos(Phi1 - Phi2) + sinh(Eta1) * sinh(Eta2)) / (cosh(Eta1) * cosh(Eta2)));
  }

gausfit()

void ZIterativeAlgorithmWithFit::gausfit ( TH1F *  histoou, double *  par, double *  errpar, float  nsigmalow, float  nsigmaup, double *  mychi2, int *  iterations  )

static

Definition at line 355 of file ZIterativeAlgorithmWithFit.cc.

References hltPixelTracks_cff::chi2, gather_cfg::cout, LaserDQM_cfg::p1, and makePlotsFromDump::suffix.

Referenced by ZeeCalibration::endOfLoop(), and iterate().

                                                                                                                  {
  auto gausa = std::make_unique<TF1>(
      "gausa", "gaus", histoou->GetMean() - 3 * histoou->GetRMS(), histoou->GetMean() + 3 * histoou->GetRMS());

  gausa->SetParameters(histoou->GetMaximum(), histoou->GetMean(), histoou->GetRMS());

  histoou->Fit(gausa.get(), "qR0N");

  double p1 = gausa->GetParameter(1);
  double sigma = gausa->GetParameter(2);
  double nor = gausa->GetParameter(0);

  double xmi, xma, xmin_fit, xmax_fit;
  double chi2 = 100;
  int iter = 0;

  while ((chi2 > 1. && iter < 5) || iter < 2) {
    xmin_fit = p1 - nsigmalow * sigma;
    xmax_fit = p1 + nsigmaup * sigma;
    xmi = p1 - 5 * sigma;
    xma = p1 + 5 * sigma;

    char suffix[20];
    sprintf(suffix, "_iter_%d", iter);
    auto fitFunc = std::make_unique<TF1>("FitFunc" + TString(suffix), "gaus", xmin_fit, xmax_fit);
    fitFunc->SetParameters(nor, p1, sigma);
    fitFunc->SetLineColor((int)(iter + 1));
    fitFunc->SetLineWidth(1);
    //histoou->Fit("FitFunc","lR+","");
    histoou->Fit(fitFunc.get(), "qR0+", "");

    histoou->GetXaxis()->SetRangeUser(xmi, xma);
    histoou->GetXaxis()->SetLabelSize(0.055);

    //      std::cout << fitFunc->GetParameters() << "," << par << std::endl;
    par[0] = (fitFunc->GetParameters())[0];
    par[1] = (fitFunc->GetParameters())[1];
    par[2] = (fitFunc->GetParameters())[2];
    errpar[0] = (fitFunc->GetParErrors())[0];
    errpar[1] = (fitFunc->GetParErrors())[1];
    errpar[2] = (fitFunc->GetParErrors())[2];
    if (fitFunc->GetNDF() != 0) {
      chi2 = fitFunc->GetChisquare() / (fitFunc->GetNDF());
      *myChi2 = chi2;

    } else {
      chi2 = 100.;
      //           par[0]=-99;
      //           par[1]=-99;
      //           par[2]=-99;
      std::cout << "WARNING: Not enough NDF" << std::endl;
      //           return 0;
    }

    // Non visualizzare
    //      histoou->Draw();
    //      c1->Update();

    //      std::cout << "iter " << iter << " chi2 " << chi2 << std::endl;
    nor = par[0];
    p1 = par[1];
    sigma = par[2];
    iter++;
    *iterations = iter;
  }
  return;
}

getEpsilonSum()

const std::vector<float>& ZIterativeAlgorithmWithFit::getEpsilonSum ( ) const

inline

Definition at line 71 of file ZIterativeAlgorithmWithFit.h.

References calib_fac_.

{ return calib_fac_; }

getEventWeight()

float ZIterativeAlgorithmWithFit::getEventWeight ( unsigned int  event_id )

private

Definition at line 304 of file ZIterativeAlgorithmWithFit.cc.

{ return 1.; }

getHistos()

const ZIterativeAlgorithmWithFitPlots* ZIterativeAlgorithmWithFit::getHistos ( ) const

inline

Definition at line 55 of file ZIterativeAlgorithmWithFit.h.

References thePlots_.

Referenced by ZeeCalibration::endOfJob(), and ZeeRescaleFactorPlots::writeHistograms().

{ return thePlots_; }

getNumberOfChannels()

int ZIterativeAlgorithmWithFit::getNumberOfChannels ( ) const

inline

Definition at line 59 of file ZIterativeAlgorithmWithFit.h.

References channels_.

Referenced by ZeeCalibration::duringLoop(), ZeeCalibration::endOfJob(), ZeeCalibration::endOfLoop(), and ZeeRescaleFactorPlots::writeHistograms().

{ return channels_; }

getNumberOfIterations()

int ZIterativeAlgorithmWithFit::getNumberOfIterations ( ) const

inline

Definition at line 57 of file ZIterativeAlgorithmWithFit.h.

References numberOfIterations_.

Referenced by ZeeCalibration::endOfJob(), and ZeeRescaleFactorPlots::writeHistograms().

{ return numberOfIterations_; }

getOptimizedChiSquare()

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedChiSquare ( ) const

inline

Definition at line 65 of file ZIterativeAlgorithmWithFit.h.

References optimizedChiSquare_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedChiSquare_; }

getOptimizedCoefficients()

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedCoefficients ( ) const

inline

Definition at line 61 of file ZIterativeAlgorithmWithFit.h.

References optimizedCoefficients_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedCoefficients_; }

getOptimizedCoefficientsError()

const std::vector<float>& ZIterativeAlgorithmWithFit::getOptimizedCoefficientsError ( ) const

inline

Definition at line 63 of file ZIterativeAlgorithmWithFit.h.

References optimizedCoefficientsError_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedCoefficientsError_; }

getOptimizedIterations()

const std::vector<int>& ZIterativeAlgorithmWithFit::getOptimizedIterations ( ) const

inline

Definition at line 67 of file ZIterativeAlgorithmWithFit.h.

References optimizedIterations_.

Referenced by ZeeCalibration::endOfLoop().

{ return optimizedIterations_; }

getStatWeights()

void ZIterativeAlgorithmWithFit::getStatWeights ( const std::string &  file )

private

Definition at line 154 of file ZIterativeAlgorithmWithFit.cc.

References channels_, gather_cfg::cout, beamvalidation::exit(), geometryDiff::file, mps_fire::i, and StatWeights_.

Referenced by ZIterativeAlgorithmWithFit().

                                                                     {
  std::ifstream statfile;
  statfile.open(file.c_str());
  if (!statfile) {
    std::cout << "ZIterativeAlgorithmWithFit::FATAL: stat weight  file " << file << " not found" << std::endl;
    exit(-1);
  }
  for (unsigned int i = 0; i < channels_; i++) {
    int imod;
    statfile >> imod >> StatWeights_[i];
    //std::cout << "Read Stat Weight for module " << imod << ": " <<  StatWeights_[i] << std::endl;
  }
}

getWeight() [1/2]

void ZIterativeAlgorithmWithFit::getWeight ( unsigned int  evid, std::pair< calib::CalibElectron *, calib::CalibElectron *>  elepair, float  invMassRescFactor  )

private

Definition at line 297 of file ZIterativeAlgorithmWithFit.cc.

Referenced by addEvent().

                                                                    {
  getWeight(event_id, elepair.first, invMassRescFactor);
  getWeight(event_id, elepair.second, invMassRescFactor);
}

getWeight() [2/2]

void ZIterativeAlgorithmWithFit::getWeight ( unsigned int  evid, calib::CalibElectron *  ele, float  evweight  )

private

Definition at line 306 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, calibType_, channels_, gather_cfg::cout, currentIteration_, first, calib::CalibElectron::getRecoElectron(), createfilelist::int, massReco_, MAX_RESCALE, MIN_RESCALE, mod(), nCrystalCut_, edm::second(), reco::GsfElectron::superCluster(), thePlots_, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::unweightedRescaleFactor, ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weight, weight_sum_, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

                                                                                                         {
  //  std::cout<< "getting weight for module " << module << " in electron " << ele << std::endl;

  std::vector<std::pair<int, float> > modules = (*ele).getCalibModulesWeights(calibType_);

  for (int imod = 0; imod < (int)modules.size(); imod++) {
    int mod = (int)modules[imod].first;

    if (mod < (int)channels_ && mod >= 0) {
      if (modules[imod].second >= 0.12 && modules[imod].second < 10000.) {
        if ((nCrystalCut_ == -1) ||
            ((!(mod <= nCrystalCut_ - 1)) && !((mod > (19 - nCrystalCut_)) && (mod <= (19 + nCrystalCut_))) &&
             !((mod > (39 - nCrystalCut_)) && (mod <= (39 + nCrystalCut_))) &&
             !((mod > (59 - nCrystalCut_)) && (mod <= (59 + nCrystalCut_))) &&
             !((mod > (84 - nCrystalCut_)) && (mod <= (84 + nCrystalCut_))) &&
             !((mod > (109 - nCrystalCut_)) && (mod <= (109 + nCrystalCut_))) &&
             !((mod > (129 - nCrystalCut_)) && (mod <= (129 + nCrystalCut_))) &&
             !((mod > (149 - nCrystalCut_)) && (mod <= (149 + nCrystalCut_))) && !(mod > (169 - nCrystalCut_)))) {
          float weight2 = modules[imod].second / ele->getRecoElectron()->superCluster()->rawEnergy();
#ifdef DEBUG
          std::cout << "w2 " << weight2 << std::endl;
#endif
          if (weight2 >= 0. && weight2 <= 1.) {
            float rescale = (TMath::Power((massReco_[event_id] / evweight), 2.) - 1) / 2.;
#ifdef DEBUG
            std::cout << "rescale " << rescale << std::endl;
#endif
            if (rescale >= MIN_RESCALE && rescale <= MAX_RESCALE) {
              calib_fac_[mod] += weight2 * rescale;
              weight_sum_[mod] += weight2;

              thePlots_->weightedRescaleFactor[currentIteration_][mod]->Fill(rescale, weight2);
              thePlots_->unweightedRescaleFactor[currentIteration_][mod]->Fill(rescale, 1.);
              thePlots_->weight[currentIteration_][mod]->Fill(weight2, 1.);
            } else {
              std::cout << "[ZIterativeAlgorithmWithFit]::[getWeight]::rescale out " << rescale << std::endl;
            }
          }
        }
      }
    } else {
      std::cout << "ZIterativeAlgorithmWithFit::FATAL:found a wrong module_id " << mod << " channels " << channels_
                << std::endl;
    }
  }
}

getWeightSum()

const std::vector<float>& ZIterativeAlgorithmWithFit::getWeightSum ( ) const

inline

Definition at line 69 of file ZIterativeAlgorithmWithFit.h.

References weight_sum_.

{ return weight_sum_; }

invMassCalc()

static float ZIterativeAlgorithmWithFit::invMassCalc ( float  Energy1, float  Eta1, float  Phi1, float  Energy2, float  Eta2, float  Phi2  )

inlinestatic

Definition at line 75 of file ZIterativeAlgorithmWithFit.h.

References cosTheta12(), calostep_cfi::Eta1, and mathSSE::sqrt().

Referenced by addEvent(), ZeeKinematicTools::calculateZMass_noTK(), ZeeKinematicTools::calculateZMass_withTK(), ZeeKinematicTools::calculateZMassWithCorrectedElectrons_noTK(), and ZeeKinematicTools::calculateZMassWithCorrectedElectrons_withTK().

                                                                                                                {
    return (sqrt(2 * Energy1 * Energy2 * (1 - cosTheta12(Eta1, Phi1, Eta2, Phi2))));
  }

iterate()

bool ZIterativeAlgorithmWithFit::iterate

(

)

Definition at line 182 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, hltPixelTracks_cff::chi2, gather_cfg::cout, currentIteration_, gausfit(), mps_fire::i, createfilelist::int, MAX_RESCALE, MIN_RESCALE, nCrystalCut_, optimizedChiSquare_, optimizedCoefficients_, optimizedCoefficientsError_, optimizedIterations_, thePlots_, weight_sum_, and ZIterativeAlgorithmWithFit::ZIterativeAlgorithmWithFitPlots::weightedRescaleFactor.

Referenced by ZeeCalibration::endOfLoop().

                                         {
  //Found optimized coefficients
  for (int i = 0; i < (int)channels_; i++) {
    //RP      if (weight_sum_[i]!=0. && calib_fac_[i]!=0.) {
    if ((nCrystalCut_ == -1) ||
        ((!(i <= nCrystalCut_ - 1)) && !((i > (19 - nCrystalCut_)) && (i <= (19 + nCrystalCut_))) &&
         !((i > (39 - nCrystalCut_)) && (i <= (39 + nCrystalCut_))) &&
         !((i > (59 - nCrystalCut_)) && (i <= (59 + nCrystalCut_))) &&
         !((i > (84 - nCrystalCut_)) && (i <= (84 + nCrystalCut_))) &&
         !((i > (109 - nCrystalCut_)) && (i <= (109 + nCrystalCut_))) &&
         !((i > (129 - nCrystalCut_)) && (i <= (129 + nCrystalCut_))) &&
         !((i > (149 - nCrystalCut_)) && (i <= (149 + nCrystalCut_))) && !(i > (169 - nCrystalCut_)))) {
      if (weight_sum_[i] != 0.) {
        //optimizedCoefficients_[i] = calib_fac_[i]/weight_sum_[i];

        double gausFitParameters[3], gausFitParameterErrors[3], gausFitChi2;
        int gausFitIterations;

        gausfit((TH1F*)thePlots_->weightedRescaleFactor[currentIteration_][i],
                gausFitParameters,
                gausFitParameterErrors,
                2.5,
                2.5,
                &gausFitChi2,
                &gausFitIterations);

        float peak = gausFitParameters[1];
        float peakError = gausFitParameterErrors[1];
        float chi2 = gausFitChi2;

        int iters = gausFitIterations;

        optimizedCoefficientsError_[i] = peakError;
        optimizedChiSquare_[i] = chi2;
        optimizedIterations_[i] = iters;

        if (peak >= MIN_RESCALE && peak <= MAX_RESCALE)
          optimizedCoefficients_[i] = 1 / (1 + peak);
        else
          optimizedCoefficients_[i] = 1 / (1 + calib_fac_[i] / weight_sum_[i]);

      } else {
        optimizedCoefficients_[i] = 1.;
        optimizedCoefficientsError_[i] = 0.;
        optimizedChiSquare_[i] = -1.;
        optimizedIterations_[i] = 0;
      }

    }

    else {
      optimizedCoefficientsError_[i] = 0.;
      optimizedCoefficients_[i] = 1.;
      optimizedChiSquare_[i] = -1.;
      optimizedIterations_[i] = 0;
      //      EcalCalibMap::getMap()->setRingCalib(i, optimizedCoefficients_[i]);
      //      //      initialCoefficients_[i] *= optimizedCoefficients_[i];
    }

    std::cout << "ZIterativeAlgorithmWithFit::run():Energy Rescaling Coefficient for region " << i << " is "
              << optimizedCoefficients_[i] << ", with error " << optimizedCoefficientsError_[i]
              << " - number of events: " << weight_sum_[i] << std::endl;
  }

  currentIteration_++;
  return kTRUE;
}

operator=()

ZIterativeAlgorithmWithFit& ZIterativeAlgorithmWithFit::operator= ( const ZIterativeAlgorithmWithFit &  r )

inline

Assignment operator.

Definition at line 44 of file ZIterativeAlgorithmWithFit.h.

{ return *this; }

recalculateMasses()

void ZIterativeAlgorithmWithFit::recalculateMasses ( )

private

recalculateWeightsEnergies() [1/2]

void ZIterativeAlgorithmWithFit::recalculateWeightsEnergies ( )

private

recalculateWeightsEnergies() [2/2]

void ZIterativeAlgorithmWithFit::recalculateWeightsEnergies ( calib::CalibElectron *  electron )

private

resetIteration()

bool ZIterativeAlgorithmWithFit::resetIteration

(

)

Definition at line 168 of file ZIterativeAlgorithmWithFit.cc.

References calib_fac_, channels_, currentEvent_, mps_fire::i, massReco_, totalEvents_, and weight_sum_.

Referenced by ZeeCalibration::startingNewLoop().

                                                {
  totalEvents_ = 0;
  currentEvent_ = 0;

  //Reset correction
  massReco_.clear();
  for (unsigned int i = 0; i < channels_; i++)
    calib_fac_[i] = 0.;
  for (unsigned int i = 0; i < channels_; i++)
    weight_sum_[i] = 0.;

  return kTRUE;
}

Member Data Documentation

calib_fac_

std::vector<float> ZIterativeAlgorithmWithFit::calib_fac_

private

Definition at line 126 of file ZIterativeAlgorithmWithFit.h.

Referenced by getEpsilonSum(), getWeight(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

calibType_

TString ZIterativeAlgorithmWithFit::calibType_

private

Definition at line 140 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), and ZIterativeAlgorithmWithFit().

channels_

unsigned int ZIterativeAlgorithmWithFit::channels_

private

Definition at line 115 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getNumberOfChannels(), getStatWeights(), getWeight(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

currentEvent_

unsigned int ZIterativeAlgorithmWithFit::currentEvent_

private

Definition at line 119 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), resetIteration(), and ZIterativeAlgorithmWithFit().

currentIteration_

unsigned int ZIterativeAlgorithmWithFit::currentIteration_

private

Definition at line 120 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

electrons_

std::vector<std::pair<calib::CalibElectron*, calib::CalibElectron*> > ZIterativeAlgorithmWithFit::electrons_

private

Definition at line 122 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().

Event_Weight_

std::vector<float> ZIterativeAlgorithmWithFit::Event_Weight_

private

Definition at line 138 of file ZIterativeAlgorithmWithFit.h.

M_Z_

const double ZIterativeAlgorithmWithFit::M_Z_ = 91.187

staticprivate

Definition at line 142 of file ZIterativeAlgorithmWithFit.h.

massMethod

std::string ZIterativeAlgorithmWithFit::massMethod

private

Definition at line 132 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), and ZIterativeAlgorithmWithFit().

massReco_

std::vector<float> ZIterativeAlgorithmWithFit::massReco_

private

Definition at line 128 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), getWeight(), resetIteration(), and ZIterativeAlgorithmWithFit().

nCrystalCut_

int ZIterativeAlgorithmWithFit::nCrystalCut_

private

Definition at line 113 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

numberOfIterations_

unsigned int ZIterativeAlgorithmWithFit::numberOfIterations_

private

Definition at line 117 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getNumberOfIterations(), and ZIterativeAlgorithmWithFit().

optimizedChiSquare_

std::vector<float> ZIterativeAlgorithmWithFit::optimizedChiSquare_

private

Definition at line 129 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedChiSquare(), iterate(), and ZIterativeAlgorithmWithFit().

optimizedCoefficients_

std::vector<float> ZIterativeAlgorithmWithFit::optimizedCoefficients_

private

Definition at line 124 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedCoefficients(), iterate(), and ZIterativeAlgorithmWithFit().

optimizedCoefficientsError_

std::vector<float> ZIterativeAlgorithmWithFit::optimizedCoefficientsError_

private

Definition at line 125 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedCoefficientsError(), iterate(), and ZIterativeAlgorithmWithFit().

optimizedIterations_

std::vector<int> ZIterativeAlgorithmWithFit::optimizedIterations_

private

Definition at line 130 of file ZIterativeAlgorithmWithFit.h.

Referenced by getOptimizedIterations(), iterate(), and ZIterativeAlgorithmWithFit().

StatWeights_

std::vector<float> ZIterativeAlgorithmWithFit::StatWeights_

private

Definition at line 137 of file ZIterativeAlgorithmWithFit.h.

Referenced by getStatWeights(), and ZIterativeAlgorithmWithFit().

thePlots_

ZIterativeAlgorithmWithFitPlots* ZIterativeAlgorithmWithFit::thePlots_

private

Definition at line 111 of file ZIterativeAlgorithmWithFit.h.

Referenced by bookHistograms(), getHistos(), getWeight(), iterate(), and ZIterativeAlgorithmWithFit().

totalEvents_

unsigned int ZIterativeAlgorithmWithFit::totalEvents_

private

Definition at line 116 of file ZIterativeAlgorithmWithFit.h.

Referenced by addEvent(), resetIteration(), and ZIterativeAlgorithmWithFit().

UseStatWeights_

bool ZIterativeAlgorithmWithFit::UseStatWeights_

private

Definition at line 134 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().

weight_sum_

std::vector<float> ZIterativeAlgorithmWithFit::weight_sum_

private

Definition at line 127 of file ZIterativeAlgorithmWithFit.h.

Referenced by getWeight(), getWeightSum(), iterate(), resetIteration(), and ZIterativeAlgorithmWithFit().

WeightFileName_

std::string ZIterativeAlgorithmWithFit::WeightFileName_

private

Definition at line 135 of file ZIterativeAlgorithmWithFit.h.

Referenced by ZIterativeAlgorithmWithFit().