BeamFitter.h

Go to the documentation of this file.

#ifndef BeamFitter_H
#define BeamFitter_H

#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/Provenance/interface/Timestamp.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/TrackReco/interface/TrackBase.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidate.h"
#include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
#include "RecoVertex/BeamSpotProducer/interface/BSTrkParameters.h"
#include "RecoVertex/BeamSpotProducer/interface/BSFitter.h"
#include "RecoVertex/BeamSpotProducer/interface/PVFitter.h"

// ROOT
#include "TFile.h"
#include "TTree.h"
#include "TH1F.h"

#include <fstream>

namespace edm {
  class ConsumesCollector;
}

class BeamFitter {
public:
  BeamFitter() {}
  BeamFitter(const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iColl);
  virtual ~BeamFitter();

  void readEvent(const edm::Event &iEvent);

  bool runFitter();
  bool runBeamWidthFitter();
  bool runPVandTrkFitter();
  bool runFitterNoTxt();

  reco::BeamSpot getBeamWidth() { return fbeamWidthFit; }
  void runAllFitter();
  void resetTrkVector() { fBSvector.clear(); }
  void resetTotTrk() { ftotal_tracks = 0; }
  void resetLSRange() { fbeginLumiOfFit = fendLumiOfFit = -1; }
  void resetRefTime() { freftime[0] = freftime[1] = 0; }
  void setRefTime(time_t t0, time_t t1) {
    freftime[0] = t0;
    freftime[1] = t1;
    // Make sure the string representation of the time
    // is up-to-date
    updateBTime();
  }

  std::pair<time_t, time_t> getRefTime() { return std::make_pair(freftime[0], freftime[1]); }

  void resetPVFitter() { MyPVFitter->resetAll(); }

  //---these are added to fasciliate BeamMonitor stuff for DIP
  std::size_t getPVvectorSize() { return (MyPVFitter->getpvStore()).size(); }
  //sc
  void resizeBSvector(unsigned int nsize) { fBSvector.erase(fBSvector.begin(), fBSvector.begin() + nsize); }

  //ssc
  void resizePVvector(unsigned int npvsize) { MyPVFitter->resizepvStore(npvsize); }

  //ssc
  void SetPVInfo(const std::vector<float> &v1_) {
    ForDIPPV_.clear();
    ForDIPPV_.assign(v1_.begin(), v1_.end());
  }

  //----------------

  void dumpTxtFile(std::string &, bool);
  void dumpBWTxtFile(std::string &);
  void write2DB();
  reco::BeamSpot getBeamSpot() { return fbeamspot; }
  std::map<int, reco::BeamSpot> getBeamSpotMap() { return fbspotPVMap; }
  std::vector<BSTrkParameters> getBSvector() { return fBSvector; }
  TH1F *getCutFlow() { return h1cutFlow; }
  void subtractFromCutFlow(const TH1F *toSubtract) {
    h1cutFlow->Add(toSubtract, -1.0);
    for (unsigned int i = 0; i < sizeof(countPass) / sizeof(countPass[0]); i++) {
      countPass[i] = h1cutFlow->GetBinContent(i + 1);
    }
  }

  void resetCutFlow() {
    h1cutFlow->Reset();
    ftotal_tracks = 0;
    for (unsigned int i = 0; i < sizeof(countPass) / sizeof(countPass[0]); i++)
      countPass[i] = 0;
  }

  //ssc
  int getRunNumber() { return frun; }

  std::pair<int, int> getFitLSRange() { return std::make_pair(fbeginLumiOfFit, fendLumiOfFit); }
  void setFitLSRange(int ls0, int ls1) {
    fbeginLumiOfFit = ls0;
    fendLumiOfFit = ls1;
  }
  void setRun(int run) { frun = run; }

  int getNTracks() { return fBSvector.size(); }
  int getNPVs() { return MyPVFitter->getNPVs(); }
  const std::map<int, int> &getNPVsperBX() { return MyPVFitter->getNPVsperBX(); }

private:
  // Update the fbeginTimeOfFit etc from the refTime
  void updateBTime();
  std::vector<BSTrkParameters> fBSvector;
  reco::BeamSpot fbeamspot;
  reco::BeamSpot fbeamWidthFit;
  std::map<int, reco::BeamSpot> fbspotPVMap;
  //  BSFitter *fmyalgo;
  std::ofstream fasciiFile;
  std::ofstream fasciiDIP;

  bool debug_;
  bool appendRunTxt_;
  edm::EDGetTokenT<reco::TrackCollection> tracksToken_;
  edm::EDGetTokenT<edm::View<reco::Vertex> > vertexToken_;
  edm::EDGetTokenT<reco::BeamSpot> beamSpotToken_;  //offlineBeamSpot
  bool writeTxt_;
  bool writeDIPTxt_;
  bool writeDIPBadFit_;
  std::string outputTxt_;
  std::string outputDIPTxt_;
  double trk_MinpT_;
  double trk_MaxZ_;
  double trk_MaxEta_;
  double trk_MaxIP_;
  int trk_MinNTotLayers_;
  int trk_MinNPixLayers_;
  double trk_MaxNormChi2_;
  std::vector<std::string> trk_Algorithm_;
  std::vector<std::string> trk_Quality_;
  std::vector<reco::TrackBase::TrackQuality> quality_;
  std::vector<reco::TrackBase::TrackAlgorithm> algorithm_;
  double inputBeamWidth_;
  double convergence_;
  int ftotal_tracks;
  int min_Ntrks_;
  bool isMuon_;
  bool fitted_;
  bool ffilename_changed;

  //ssc
  std::vector<float> ForDIPPV_;

  // ntuple
  TH1F *h1z;
  bool saveNtuple_;
  bool saveBeamFit_;
  bool savePVVertices_;
  std::string outputfilename_;
  TFile *file_;
  TTree *ftree_;
  double ftheta;
  double fpt;
  double feta;
  int fcharge;
  double fnormchi2;
  double fphi0;
  double fd0;
  double fd0bs;
  double fsigmad0;
  double fz0;
  double fsigmaz0;
  int fnTotLayerMeas;
  int fnPixelLayerMeas;
  int fnStripLayerMeas;
  int fnTIBLayerMeas;
  int fnTIDLayerMeas;
  int fnTOBLayerMeas;
  int fnTECLayerMeas;
  int fnPXBLayerMeas;
  int fnPXFLayerMeas;
  //  double fd0phi_chi2;
  //  double fd0phi_d0;
  double fcov[7][7];
  double fvx;
  double fvy;
  int frun;
  int flumi;
  bool fquality;
  bool falgo;
  bool fpvValid;
  double fpvx, fpvy, fpvz;
  std::time_t freftime[2];

  //beam fit results
  TTree *ftreeFit_;
  int frunFit;
  int fbeginLumiOfFit;
  int fendLumiOfFit;
  char fbeginTimeOfFit[32];
  char fendTimeOfFit[32];
  double fx;
  double fy;
  double fz;
  double fsigmaZ;
  double fdxdz;
  double fdydz;
  double fxErr;
  double fyErr;
  double fzErr;
  double fsigmaZErr;
  double fdxdzErr;
  double fdydzErr;
  double fwidthX;
  double fwidthY;
  double fwidthXErr;
  double fwidthYErr;

  TH1F *h1ntrks;
  TH1F *h1vz_event;
  TH1F *h1cutFlow;
  int countPass[9];

  PVFitter *MyPVFitter;
  TTree *fPVTree_;
};

#endif