PatAlgos/plugins/PATMHTProducer.cc

//
// $Id: PATMHTProducer.cc,v 1.4 2008/10/17 22:32:20 gpetrucc Exp $
//

#include "PhysicsTools/PatAlgos/plugins/PATMHTProducer.h"
#include "DataFormats/Candidate/interface/Particle.h"

pat::PATMHTProducer::PATMHTProducer(const edm::ParameterSet & iConfig){

  // Initialize the configurables
  jetLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("jetTag");
  eleLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("electronTag");
  muoLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("muonTag");
  tauLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("tauTag");
  phoLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("photonTag");
  
  uncertaintyScaleFactor_ = iConfig.getParameter<double>( "uncertaintyScaleFactor") ;

  produces<pat::MHTCollection>();

}


pat::PATMHTProducer::~PATMHTProducer() {
}

void pat::PATMHTProducer::beginJob(const edm::EventSetup& iSetup) {
}
void pat::PATMHTProducer::beginRun(const edm::EventSetup& iSetup) {
}

void pat::PATMHTProducer::endJob() {
}


void pat::PATMHTProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSetup) {
  // make sure the SigInputObj container is empty
  while(physobjvector_.size()>0){
    physobjvector_.erase(physobjvector_.begin(),physobjvector_.end());

  }
  // Get the jet object

  edm::Handle<edm::View<pat::Jet> > jetHandle;
  iEvent.getByLabel(jetLabel_,jetHandle);
  edm::View<pat::Jet> jets = *jetHandle;

  // Fill Input Vector with Jets 
  std::string objectname="";
  for(edm::View<pat::Jet>::const_iterator jet_iter = jets.begin(); jet_iter!=jets.end(); ++jet_iter){
    double jet_et = jet_iter->et();
    double jet_phi = jet_iter->phi();
    double sigma_et = 0.;// no longer valid: jet_iter->resolutionEt();
    double sigma_phi =  0.;// no longer valid: jet_iter->resolutionPhi();
    objectname="jet";
    if(sigma_et<=0 || sigma_phi<=0)
      edm::LogWarning("PATMHTProducer") << 
        " uncertainties for "  << objectname <<
        " are (et, phi): " << sigma_et << "," << sigma_phi << " (et,phi): " << jet_et << "," << jet_phi;
    // try to read out the jet resolution from the root file at PatUtils
    //-- Store jet for Significance Calculation --//
    
    if (uncertaintyScaleFactor_ != 1.0){
      sigma_et  = sigma_et  * uncertaintyScaleFactor_;
      sigma_phi = sigma_phi * uncertaintyScaleFactor_;
      // edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
      //" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi; 
    }

    metsig::SigInputObj tmp_jet(objectname,jet_et,jet_phi,sigma_et,sigma_phi);
    physobjvector_.push_back(tmp_jet);
     
  }

  edm::Handle<edm::View<pat::Electron> > electronHandle;
  iEvent.getByLabel(eleLabel_,electronHandle);
  edm::View<pat::Electron> electrons = *electronHandle;

  // Fill Input Vector with Electrons 
  for(edm::View<pat::Electron>::const_iterator electron_iter = electrons.begin(); electron_iter!=electrons.end(); ++electron_iter){
    double electron_et = electron_iter->et();
    double electron_phi = electron_iter->phi();
    double sigma_et = 0.;// no longer valid:  electron_iter->resolutionEt();
    double sigma_phi = 0.;// no longer valid:  electron_iter->resolutionPhi();
    objectname="electron";
    if(sigma_et<=0 || sigma_phi<=0)
      edm::LogWarning("PATMHTProducer") <<
        " uncertainties for "  << objectname <<
        " are (et, phi): " << sigma_et << "," << sigma_phi << 
        " (et,phi): " << electron_et << "," << electron_phi;
    // try to read out the electron resolution from the root file at PatUtils
    //-- Store electron for Significance Calculation --//
    
    if (uncertaintyScaleFactor_ != 1.0){
      sigma_et  = sigma_et  * uncertaintyScaleFactor_;
      sigma_phi = sigma_phi * uncertaintyScaleFactor_;
      // edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
      //" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi; 
    }


    metsig::SigInputObj tmp_electron(objectname,electron_et,electron_phi,sigma_et,sigma_phi);
    physobjvector_.push_back(tmp_electron);
     
  }

  edm::Handle<edm::View<pat::Muon> > muonHandle;
  iEvent.getByLabel(muoLabel_,muonHandle);
  edm::View<pat::Muon> muons = *muonHandle;

  // Fill Input Vector with Muons 
  for(edm::View<pat::Muon>::const_iterator muon_iter = muons.begin(); muon_iter!=muons.end(); ++muon_iter){
    double muon_pt = muon_iter->pt();
    double muon_phi = muon_iter->phi();
    double sigma_et = 0.;// no longer valid:  muon_iter->resolutionEt();
    double sigma_phi = 0.;// no longer valid:  muon_iter->resolutionPhi();
    objectname="muon";
    if(sigma_et<=0 || sigma_phi<=0)
      edm::LogWarning("PATMHTProducer") << 
        " uncertainties for "  << objectname << 
        " are (et, phi): " << sigma_et << "," <<
        sigma_phi << " (pt,phi): " << muon_pt << "," << muon_phi;
    // try to read out the muon resolution from the root file at PatUtils
    //-- Store muon for Significance Calculation --//

    if (uncertaintyScaleFactor_ != 1.0){
      sigma_et  = sigma_et  * uncertaintyScaleFactor_;
      sigma_phi = sigma_phi * uncertaintyScaleFactor_;
      //edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
      //" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi; 
    }

    metsig::SigInputObj tmp_muon(objectname,muon_pt,muon_phi,sigma_et,sigma_phi);
    physobjvector_.push_back(tmp_muon);
     
  }
  
  /* We'll deal with photons and taus later for sure :)


  edm::Handle<edm::View<pat::Photon> > photonHandle;
  iEvent.getByLabel(phoLabel_,photonHandle);
  edm::View<pat::Photon> photons = *photonHandle;

  // Fill Input Vector with Photons 
  for(edm::View<pat::Photon>::const_iterator photon_iter = photons.begin(); photon_iter!=photons.end(); ++photon_iter){
    double photon_et = photon_iter->et();
    double photon_phi = photon_iter->phi();
    double sigma_et = 0.;// no longer valid:  photon_iter->resolutionEt();
    double sigma_phi = 0.;// no longer valid:  photon_iter->resolutionPhi();
    objectname="photon";
    if(sigma_et<=0 || sigma_phi<=0)
      edm::LogWarning("PATMHTProducer") << " uncertainties for "  << objectname << " are (et, phi): " << sigma_et << "," << sigma_phi << " (et,phi): " << photon_et << "," << photon_phi;
    // try to read out the photon resolution from the root file at PatUtils
    //-- Store photon for Significance Calculation --//
    metsig::SigInputObj tmp_photon(objectname,photon_et,photon_phi,sigma_et,sigma_phi);
    physobjvector_.push_back(tmp_photon);
     
  }

  edm::Handle<edm::View<pat::Tau> > tauHandle;
  iEvent.getByLabel(tauLabel_,tauHandle);
  edm::View<pat::Tau> taus = *tauHandle;

  // Fill Input Vector with Taus 
  for(edm::View<pat::Tau>::const_iterator tau_iter = taus.begin(); tau_iter!=taus.end(); ++tau_iter){
    double tau_pt = tau_iter->pt();
    double tau_phi = tau_iter->phi();
    double sigma_et =  0.;// no longer valid: tau_iter->resolutionEt();
    double sigma_phi =  0.;// no longer valid: tau_iter->resolutionPhi();
    objectname="tau";
    if(sigma_et<=0 || sigma_phi<=0)
      edm::LogWarning("PATMHTProducer") << " uncertainties for "  << objectname << " are (et, phi): " << sigma_et << "," << sigma_phi << " (pt,phi): " << tau_pt << "," << tau_phi;
    // try to read out the tau resolution from the root file at PatUtils
    //-- Store tau for Significance Calculation --//
    metsig::SigInputObj tmp_tau(objectname,tau_pt,tau_phi,sigma_et,sigma_phi);
    physobjvector_.push_back(tmp_tau);
     
  }
  
  */


  double met_x=0;
  double met_y=0;
  double met_et=0;
  double met_phi=0;
  double met_set=0;
  
  // calculate the significance

  double significance = ASignificance(physobjvector_, met_et, met_phi, met_set);
  met_x=met_et*cos(met_phi);
  met_y=met_et*sin(met_phi);
  edm::LogInfo("PATMHTProducer")    << " met x,y: " << met_x << "," << met_y << " met_set: " << met_set << " met_et/sqrt(met_set): " << met_et/sqrt(met_set) << " met_phi: " << met_phi << " met_et: " << met_et << " met_et/sqrt(x,y): " << met_et/sqrt(met_x*met_x+met_y*met_y) << " met_sign: " << significance << std::endl;
  // and fill the output into the event..
  std::auto_ptr<pat::MHTCollection>  themetsigcoll (new pat::MHTCollection);
  pat::MHT themetsigobj(reco::Particle::LorentzVector(met_x,met_y,0,met_et),met_set,significance);
  themetsigcoll->push_back(themetsigobj);

  iEvent.put( themetsigcoll);

}  


using namespace pat; 
DEFINE_FWK_MODULE(PATMHTProducer);

Revision:	1.1.1.1 (vendor branch)
Committed:	Tue Oct 20 17:15:14 2009 UTC (15 years, 6 months ago) by dgele
Content type:	text/plain
Branch:	ANA
CVS Tags:	start
Changes since 1.1:	+0 -0 lines
Log Message:	version CMSSW_2_2_10
#	Content
1	//
2	// $Id: PATMHTProducer.cc,v 1.4 2008/10/17 22:32:20 gpetrucc Exp $
3	//
4
5	#include "PhysicsTools/PatAlgos/plugins/PATMHTProducer.h"
6	#include "DataFormats/Candidate/interface/Particle.h"
7
8	pat::PATMHTProducer::PATMHTProducer(const edm::ParameterSet & iConfig){
9
10	// Initialize the configurables
11	jetLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("jetTag");
12	eleLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("electronTag");
13	muoLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("muonTag");
14	tauLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("tauTag");
15	phoLabel_ = iConfig.getUntrackedParameter<edm::InputTag>("photonTag");
16
17	uncertaintyScaleFactor_ = iConfig.getParameter<double>( "uncertaintyScaleFactor") ;
18
19	produces<pat::MHTCollection>();
20
21	}
22
23
24	pat::PATMHTProducer::~PATMHTProducer() {
25	}
26
27	void pat::PATMHTProducer::beginJob(const edm::EventSetup& iSetup) {
28	}
29	void pat::PATMHTProducer::beginRun(const edm::EventSetup& iSetup) {
30	}
31
32	void pat::PATMHTProducer::endJob() {
33	}
34
35
36	void pat::PATMHTProducer::produce(edm::Event & iEvent, const edm::EventSetup & iSetup) {
37	// make sure the SigInputObj container is empty
38	while(physobjvector_.size()>0){
39	physobjvector_.erase(physobjvector_.begin(),physobjvector_.end());
40
41	}
42	// Get the jet object
43
44	edm::Handle<edm::View<pat::Jet> > jetHandle;
45	iEvent.getByLabel(jetLabel_,jetHandle);
46	edm::View<pat::Jet> jets = *jetHandle;
47
48	// Fill Input Vector with Jets
49	std::string objectname="";
50	for(edm::View<pat::Jet>::const_iterator jet_iter = jets.begin(); jet_iter!=jets.end(); ++jet_iter){
51	double jet_et = jet_iter->et();
52	double jet_phi = jet_iter->phi();
53	double sigma_et = 0.;// no longer valid: jet_iter->resolutionEt();
54	double sigma_phi = 0.;// no longer valid: jet_iter->resolutionPhi();
55	objectname="jet";
56	if(sigma_et<=0 \|\| sigma_phi<=0)
57	edm::LogWarning("PATMHTProducer") <<
58	" uncertainties for " << objectname <<
59	" are (et, phi): " << sigma_et << "," << sigma_phi << " (et,phi): " << jet_et << "," << jet_phi;
60	// try to read out the jet resolution from the root file at PatUtils
61	//-- Store jet for Significance Calculation --//
62
63	if (uncertaintyScaleFactor_ != 1.0){
64	sigma_et = sigma_et * uncertaintyScaleFactor_;
65	sigma_phi = sigma_phi * uncertaintyScaleFactor_;
66	// edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
67	//" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi;
68	}
69
70	metsig::SigInputObj tmp_jet(objectname,jet_et,jet_phi,sigma_et,sigma_phi);
71	physobjvector_.push_back(tmp_jet);
72
73	}
74
75	edm::Handle<edm::View<pat::Electron> > electronHandle;
76	iEvent.getByLabel(eleLabel_,electronHandle);
77	edm::View<pat::Electron> electrons = *electronHandle;
78
79	// Fill Input Vector with Electrons
80	for(edm::View<pat::Electron>::const_iterator electron_iter = electrons.begin(); electron_iter!=electrons.end(); ++electron_iter){
81	double electron_et = electron_iter->et();
82	double electron_phi = electron_iter->phi();
83	double sigma_et = 0.;// no longer valid: electron_iter->resolutionEt();
84	double sigma_phi = 0.;// no longer valid: electron_iter->resolutionPhi();
85	objectname="electron";
86	if(sigma_et<=0 \|\| sigma_phi<=0)
87	edm::LogWarning("PATMHTProducer") <<
88	" uncertainties for " << objectname <<
89	" are (et, phi): " << sigma_et << "," << sigma_phi <<
90	" (et,phi): " << electron_et << "," << electron_phi;
91	// try to read out the electron resolution from the root file at PatUtils
92	//-- Store electron for Significance Calculation --//
93
94	if (uncertaintyScaleFactor_ != 1.0){
95	sigma_et = sigma_et * uncertaintyScaleFactor_;
96	sigma_phi = sigma_phi * uncertaintyScaleFactor_;
97	// edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
98	//" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi;
99	}
100
101
102	metsig::SigInputObj tmp_electron(objectname,electron_et,electron_phi,sigma_et,sigma_phi);
103	physobjvector_.push_back(tmp_electron);
104
105	}
106
107	edm::Handle<edm::View<pat::Muon> > muonHandle;
108	iEvent.getByLabel(muoLabel_,muonHandle);
109	edm::View<pat::Muon> muons = *muonHandle;
110
111	// Fill Input Vector with Muons
112	for(edm::View<pat::Muon>::const_iterator muon_iter = muons.begin(); muon_iter!=muons.end(); ++muon_iter){
113	double muon_pt = muon_iter->pt();
114	double muon_phi = muon_iter->phi();
115	double sigma_et = 0.;// no longer valid: muon_iter->resolutionEt();
116	double sigma_phi = 0.;// no longer valid: muon_iter->resolutionPhi();
117	objectname="muon";
118	if(sigma_et<=0 \|\| sigma_phi<=0)
119	edm::LogWarning("PATMHTProducer") <<
120	" uncertainties for " << objectname <<
121	" are (et, phi): " << sigma_et << "," <<
122	sigma_phi << " (pt,phi): " << muon_pt << "," << muon_phi;
123	// try to read out the muon resolution from the root file at PatUtils
124	//-- Store muon for Significance Calculation --//
125
126	if (uncertaintyScaleFactor_ != 1.0){
127	sigma_et = sigma_et * uncertaintyScaleFactor_;
128	sigma_phi = sigma_phi * uncertaintyScaleFactor_;
129	//edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
130	//" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi;
131	}
132
133	metsig::SigInputObj tmp_muon(objectname,muon_pt,muon_phi,sigma_et,sigma_phi);
134	physobjvector_.push_back(tmp_muon);
135
136	}
137
138	/* We'll deal with photons and taus later for sure :)
139
140
141	edm::Handle<edm::View<pat::Photon> > photonHandle;
142	iEvent.getByLabel(phoLabel_,photonHandle);
143	edm::View<pat::Photon> photons = *photonHandle;
144
145	// Fill Input Vector with Photons
146	for(edm::View<pat::Photon>::const_iterator photon_iter = photons.begin(); photon_iter!=photons.end(); ++photon_iter){
147	double photon_et = photon_iter->et();
148	double photon_phi = photon_iter->phi();
149	double sigma_et = 0.;// no longer valid: photon_iter->resolutionEt();
150	double sigma_phi = 0.;// no longer valid: photon_iter->resolutionPhi();
151	objectname="photon";
152	if(sigma_et<=0 \|\| sigma_phi<=0)
153	edm::LogWarning("PATMHTProducer") << " uncertainties for " << objectname << " are (et, phi): " << sigma_et << "," << sigma_phi << " (et,phi): " << photon_et << "," << photon_phi;
154	// try to read out the photon resolution from the root file at PatUtils
155	//-- Store photon for Significance Calculation --//
156	metsig::SigInputObj tmp_photon(objectname,photon_et,photon_phi,sigma_et,sigma_phi);
157	physobjvector_.push_back(tmp_photon);
158
159	}
160
161	edm::Handle<edm::View<pat::Tau> > tauHandle;
162	iEvent.getByLabel(tauLabel_,tauHandle);
163	edm::View<pat::Tau> taus = *tauHandle;
164
165	// Fill Input Vector with Taus
166	for(edm::View<pat::Tau>::const_iterator tau_iter = taus.begin(); tau_iter!=taus.end(); ++tau_iter){
167	double tau_pt = tau_iter->pt();
168	double tau_phi = tau_iter->phi();
169	double sigma_et = 0.;// no longer valid: tau_iter->resolutionEt();
170	double sigma_phi = 0.;// no longer valid: tau_iter->resolutionPhi();
171	objectname="tau";
172	if(sigma_et<=0 \|\| sigma_phi<=0)
173	edm::LogWarning("PATMHTProducer") << " uncertainties for " << objectname << " are (et, phi): " << sigma_et << "," << sigma_phi << " (pt,phi): " << tau_pt << "," << tau_phi;
174	// try to read out the tau resolution from the root file at PatUtils
175	//-- Store tau for Significance Calculation --//
176	metsig::SigInputObj tmp_tau(objectname,tau_pt,tau_phi,sigma_et,sigma_phi);
177	physobjvector_.push_back(tmp_tau);
178
179	}
180
181	*/
182
183
184	double met_x=0;
185	double met_y=0;
186	double met_et=0;
187	double met_phi=0;
188	double met_set=0;
189
190	// calculate the significance
191
192	double significance = ASignificance(physobjvector_, met_et, met_phi, met_set);
193	met_x=met_et*cos(met_phi);
194	met_y=met_et*sin(met_phi);
195	edm::LogInfo("PATMHTProducer") << " met x,y: " << met_x << "," << met_y << " met_set: " << met_set << " met_et/sqrt(met_set): " << met_et/sqrt(met_set) << " met_phi: " << met_phi << " met_et: " << met_et << " met_et/sqrt(x,y): " << met_et/sqrt(met_xmet_x+met_ymet_y) << " met_sign: " << significance << std::endl;
196	// and fill the output into the event..
197	std::auto_ptr<pat::MHTCollection> themetsigcoll (new pat::MHTCollection);
198	pat::MHT themetsigobj(reco::Particle::LorentzVector(met_x,met_y,0,met_et),met_set,significance);
199	themetsigcoll->push_back(themetsigobj);
200
201	iEvent.put( themetsigcoll);
202
203	}
204
205
206	using namespace pat;
207	DEFINE_FWK_MODULE(PATMHTProducer);
208