BackgroundHandler.h

Go to the documentation of this file.

#ifndef BackgroundHandler_h
#define BackgroundHandler_h
 
#include "MuonAnalysis/MomentumScaleCalibration/interface/Functions.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <vector>
#include "MuonAnalysis/MomentumScaleCalibration/interface/MassWindow.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "DataFormats/Candidate/interface/LeafCandidate.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include <CLHEP/Vector/LorentzVector.h>
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
// Unit test for testing BackgroundHandler
class TestBackgroundHandler;
 
class BackgroundHandler {
  // For tests
  friend class TestBackgroundHandler;
 
public:
  BackgroundHandler(const std::vector<int>& identifiers,
                    const std::vector<double>& leftWindowBorders,
                    const std::vector<double>& rightWindowBorders,
                    const double* ResMass,
                    const double* massWindowHalfWidth);
  ~BackgroundHandler();
 
  void initializeParNums();
 
  inline int regionsParNum() { return parNumsResonances_[0]; }
 
  bool checkBackgroundWindow(const double& mass, const int iRegion) { return backgroundWindow_[iRegion].isIn(mass); }
 
  void countEventsInAllWindows(
      const std::vector<std::pair<reco::Particle::LorentzVector, reco::Particle::LorentzVector> >& muonPairs,
      const double& weight);
 
  void setParameters(double* Start,
                     double* Step,
                     double* Mini,
                     double* Maxi,
                     int* ind,
                     TString* parname,
                     const std::vector<double>& parBgr,
                     const std::vector<int>& parBgrOrder,
                     const int muonType);
 
  bool unlockParameter(const std::vector<int>& resfind, const unsigned int ipar);
 
  std::pair<double, double> windowBorders(const bool doBackgroundFit, const int ires);
 
  double resMass(const bool doBackgroundFit, const int ires);
 
  void rescale(std::vector<double>& parBgr,
               const double* ResMass,
               const double* massWindowHalfWidth,
               const std::vector<std::pair<reco::Particle::LorentzVector, reco::Particle::LorentzVector> >& muonPairs,
               const double& weight = 1.);
 
  std::pair<double, double> backgroundFunction(const bool doBackgroundFit,
                                               const double* parval,
                                               const int resTotNum,
                                               const int ires,
                                               const bool* resConsidered,
                                               const double* ResMass,
                                               const double ResHalfWidth[],
                                               /* const int MuonType, const double & mass, const double & resEta ); */
                                               const int MuonType,
                                               const double& mass,
                                               const double& eta1,
                                               const double& eta2);
 
private:
  void consistencyCheck(const std::vector<int>& identifiers,
                        const std::vector<double>& leftWindowBorders,
                        const std::vector<double>& rightWindowBorders) const noexcept(false);
 
  // Correspondence between regions and halfWidths used:
  // - for the Upsilons region we use the Upsilon
  // - for the J/Psi and Psi2S region we use the J/Psi
  int regToResHW_[3];
 
  // Correspondence between resonances and regions:
  // - Z -> region 0
  // - Uspilons -> region 1
  // - J/Psi and Psi2S -> region 2
  int resToReg_[6];
 
  // Used in the shifts of the parval
  // Contains 0 as the first number and Sum_0^(ires-1)(parNum(i)) for the rest,
  // so that calling parNums[ires] returns the sum of the number of parameters
  // of the previous functions (0 if none) and allows to shift the parval to the
  // parameters of the actual function.
  int parNumsRegions_[3];
  // These start from the correct parameters (take into account that the parRegions are
  // before the parResonances).
  int parNumsResonances_[6];
 
  // std::vector<double> leftWindowFactors_;
  // std::vector<double> rightWindowFactors_;
 
  std::vector<MassWindow> resonanceWindow_;
  std::vector<MassWindow> backgroundWindow_;
};
 
#endif  // BackgroundHandler_h