ZIterativeAlgorithmWithFit.h

Go to the documentation of this file.

#ifndef ZITERATIVEALGORITHMWITHFIT_H
#define ZITERATIVEALGORITHMWITHFIT_H

/* ******************************************
 * ZIterativeAlgorithmWithFit.h 
 *
 * Paolo Meridiani 06/03/2003
 ********************************************/

#include <TROOT.h>
#include <TClonesArray.h>
#include <vector>
#include <string>
#include <TH1.h>

#include "Calibration/Tools/interface/CalibElectron.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#define nMaxIterations 50
#define nMaxChannels 250

class ZIterativeAlgorithmWithFit {
public:
  struct ZIterativeAlgorithmWithFitPlots {
    TH1* weightedRescaleFactor[nMaxIterations][nMaxChannels];
    TH1* unweightedRescaleFactor[nMaxIterations][nMaxChannels];
    TH1* weight[nMaxIterations][nMaxChannels];
  };

  ZIterativeAlgorithmWithFit();

  ZIterativeAlgorithmWithFit(const edm::ParameterSet& ps);
  //, unsigned int events);

  ZIterativeAlgorithmWithFit& operator=(const ZIterativeAlgorithmWithFit& r) { return *this; }

  virtual ~ZIterativeAlgorithmWithFit();

  bool resetIteration();

  bool iterate();

  bool addEvent(calib::CalibElectron*, calib::CalibElectron*, float);

  const ZIterativeAlgorithmWithFitPlots* getHistos() const { return thePlots_; }

  int getNumberOfIterations() const { return numberOfIterations_; }

  int getNumberOfChannels() const { return channels_; }

  const std::vector<float>& getOptimizedCoefficients() const { return optimizedCoefficients_; }

  const std::vector<float>& getOptimizedCoefficientsError() const { return optimizedCoefficientsError_; }

  const std::vector<float>& getOptimizedChiSquare() const { return optimizedChiSquare_; }

  const std::vector<int>& getOptimizedIterations() const { return optimizedIterations_; }

  const std::vector<float>& getWeightSum() const { return weight_sum_; }

  const std::vector<float>& getEpsilonSum() const { return calib_fac_; }

  //Helper Methods

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

  static inline float cosTheta12(float Eta1, float Phi1, float Eta2, float Phi2) {
    return ((cos(Phi1 - Phi2) + sinh(Eta1) * sinh(Eta2)) / (cosh(Eta1) * cosh(Eta2)));
  }

  /*
  static TF1* gausfit(TH1F * histoou,double* par,double* errpar) {
    return gausfit(histoou,par,errpar,1.,2.);
  }
  */

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

private:
  void addWeightsCorrections(unsigned int event_id);

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

  float getEventWeight(unsigned int event_id);

  void recalculateWeightsEnergies();

  void recalculateMasses();

  void recalculateWeightsEnergies(calib::CalibElectron* electron);

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

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

  void bookHistograms();

  ZIterativeAlgorithmWithFitPlots* thePlots_;

  int nCrystalCut_;

  unsigned int channels_;
  unsigned int totalEvents_;
  unsigned int numberOfIterations_;

  unsigned int currentEvent_;
  unsigned int currentIteration_;

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

  std::vector<float> optimizedCoefficients_;
  std::vector<float> optimizedCoefficientsError_;
  std::vector<float> calib_fac_;
  std::vector<float> weight_sum_;
  std::vector<float> massReco_;
  std::vector<float> optimizedChiSquare_;
  std::vector<int> optimizedIterations_;

  std::string massMethod;

  bool UseStatWeights_;
  std::string WeightFileName_;

  std::vector<float> StatWeights_;
  std::vector<float> Event_Weight_;

  TString calibType_;

  static const double M_Z_;
};

#endif  // ZIterativeAlgorithmWithFit_H