SFrameTools/src/EventCalc.cxx

// Dear emacs, this is -*- c++ -*-

#include "include/EventCalc.h"

#include <iostream>

EventCalc* EventCalc::m_instance = NULL;

EventCalc* EventCalc::Instance()
{
  // Get a pointer to the object handler.
  // This is the only way to access this class, 
  // since it's a singleton. This method is accessible
  // from everywhere.

  if (m_instance == NULL){
    m_instance = new EventCalc();
  }
  return m_instance;    
}

EventCalc::EventCalc() : m_logger( "EventCalc" )
{
  // constructor: initialise all variables
  m_logger << DEBUG << "Constructor called." << SLogger::endmsg;
  m_bcc = NULL;
  m_lumi = NULL;
  m_primlep = NULL;
  m_ttgen = NULL;
}

EventCalc::~EventCalc()
{
  // default destructor
}

void EventCalc::Reset()
{
  // reset: set all booleans to false
  // this has to be done at the beginning of each event
  // after a call to reset all quantities will be re-calculated 
  // when they are accessed
  
  // (re-)set the pointers using the ObjectHandler
  ObjectHandler* objs = ObjectHandler::Instance();
  m_bcc = objs->GetBaseCycleContainer();
  m_lumi = objs->GetLumiHandler();

  // reset booleans
  b_HT = false;
  b_HTlep = false;
  b_Reconstruction = false;

  m_TotalWeight = 1.;
  
  m_primlep = NULL;
  m_ttgen = NULL;

}

BaseCycleContainer* EventCalc::GetBaseCycleContainer()
{
  // return the pointer to the container with all objects
  if (!m_bcc){
    m_logger << WARNING << "Pointer to BaseCycleContainer is NULL." << SLogger::endmsg;
  }
  return m_bcc;
}

LuminosityHandler* EventCalc::GetLumiHandler()
{
  // return the pointer to the container with all objects
  if (!m_lumi){
    m_logger << WARNING << "Pointer to LumiHandler is NULL." << SLogger::endmsg;
  }
  return m_lumi;
}

double EventCalc::GetHT()
{
  // calculate HT, which is defined as the scalar sum of all
  // jets, leptons and missing transverse momentum in the event
  if (!b_HT){

    b_HT = true;
    m_HT = 0;

    // add lepton pt and MET 
    m_HT += GetHTlep();

    // sum over pt of all jets
    if(m_bcc->jets){
      for(unsigned int i=0; i<m_bcc->jets->size(); ++i){
        m_HT += m_bcc->jets->at(i).pt();
      }
    }

  }
  return m_HT;
}

double EventCalc::GetHTlep()
{
  // calculate HT_lep, which is defined as the scalar sum of all
  // leptons and missing transverse momentum in the event
  if (!b_HTlep){

    b_HTlep = true;
    m_HTlep=0;

    // sum over pt of all electrons
    if(m_bcc->electrons){
      for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
        m_HTlep += m_bcc->electrons->at(i).pt();
      }
    }

    // sum over pt of all muons
    if(m_bcc->muons){
      for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
        m_HTlep += m_bcc->muons->at(i).pt();
      }
    }

    // sum over pt of all taus
    if(m_bcc->taus){
      for(unsigned int i=0; i<m_bcc->taus->size(); ++i){
        m_HTlep += m_bcc->taus->at(i).pt();
      }
    }
    
    // add MET
    if(m_bcc->met) m_HTlep += m_bcc->met->pt();   

  }
  return m_HTlep;
}

Particle* EventCalc::GetPrimaryLepton(){

  if(!m_primlep){
    double ptmax = -999;
    for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
      if(m_bcc->electrons->at(i).pt()>ptmax){
        ptmax = m_bcc->electrons->at(i).pt();
        m_primlep = &m_bcc->electrons->at(i);
      }
    }
    for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
      if(m_bcc->muons->at(i).pt()>ptmax){
        ptmax = m_bcc->muons->at(i).pt();
        m_primlep = &m_bcc->muons->at(i);
      }
    }
  }

  return m_primlep;
}

TTbarGen* EventCalc::GetTTbarGen(){

  if(!m_ttgen){
    m_ttgen = new TTbarGen();
  }

  return m_ttgen;
}


std::vector<LorentzVector> EventCalc::NeutrinoReconstruction(const LorentzVector lepton, const LorentzVector met){

  
  TVector3 lepton_pT = toVector(lepton);
  lepton_pT.SetZ(0);
  
  TVector3 neutrino_pT = toVector(met);
  neutrino_pT.SetZ(0);
  
  const float mass_w = 80.399;
  float mu = mass_w * mass_w / 2 + lepton_pT * neutrino_pT;
  
  float A = - (lepton_pT * lepton_pT);
  float B = mu * lepton.pz();
  float C = mu * mu - lepton.e() * lepton.e() * (neutrino_pT * neutrino_pT);
  
  float discriminant = B * B - A * C;
  
  std::vector<LorentzVector> solutions;
  
  if (0 >= discriminant)
    {
      // Take only real part of the solution
      //
      LorentzVectorXYZE solution (0,0,0,0);
      solution.SetPx(met.Px());
      solution.SetPy(met.Py());
      solution.SetPz(-B / A);
      solution.SetE(toVector(solution).Mag());
      
      solutions.push_back(toPtEtaPhi(solution));
      
      //_solutions = 0 > discriminant ? 0 : 1;
    }
  else
    {
      discriminant = sqrt(discriminant);
      
      LorentzVectorXYZE solution (0,0,0,0);
      solution.SetPx(met.Px());
      solution.SetPy(met.Py());
      solution.SetPz((-B - discriminant) / A);
      solution.SetE(toVector(solution).Mag());
      
      solutions.push_back(toPtEtaPhi(solution));
      
      LorentzVectorXYZE solution2 (0,0,0,0);
      solution2.SetPx(met.Px());
      solution2.SetPy(met.Py());
      solution2.SetPz((-B + discriminant) / A);
      solution2.SetE(toVector(solution2).Mag());
      
      solutions.push_back(toPtEtaPhi(solution2));
      
      //_solutions = 2;
    }
  
  return solutions;
}

void EventCalc::FillHighMassTTbarHypotheses(){

  if(b_Reconstruction) return;
  b_Reconstruction=true;

  //clear hypothesis list
  m_bcc->recoHyps->clear();

  //find primary charged lepton
  Particle* lepton = GetPrimaryLepton();

  //reconstruct neutrino
  std::vector<LorentzVector> neutrinos = NeutrinoReconstruction( lepton->v4(), m_bcc->met->v4());
  
  ReconstructionHypothesis hyp;

  hyp.set_lepton(*lepton);

  //loop over neutrino solutions and jet assignments to fill hyotheses
  for(unsigned int i=0; i< neutrinos.size();++i){

    hyp.set_neutrino_v4(neutrinos[i]);
    LorentzVector wlep_v4 = lepton->v4()+neutrinos[i];

    unsigned int n_jets = m_bcc->jets->size();
    unsigned int max_j = myPow(3, n_jets);
    for (unsigned int j=0; j < max_j; j++) {
      LorentzVector tophad_v4(0,0,0,0);
      LorentzVector toplep_v4 = wlep_v4;
      int hadjets=0;
      int lepjets=0;
      int num = j;
      hyp.clear_jetindices();
      for (unsigned int k=0; k<n_jets; k++) {
        // num is the k-th digit of j if you
        // write j in a base-3 system. According
        // to the value of this digit (which takes
        // values from 0 to 2,
        // in all possible combinations with the other digits),
        // decide how to treat the jet.
        
        if(num%3==0) {
          tophad_v4 = tophad_v4 + m_bcc->jets->at(k).v4();
          hyp.add_tophad_jet_index(k);
          hadjets++;
        }
        
        if(num%3==1) {
          toplep_v4 = toplep_v4 + m_bcc->jets->at(k).v4();
          hyp.add_toplep_jet_index(k);
          lepjets++;
        }
        //if(num%3==2); //do not take this jet
        
        //shift the trigits of num to the right:
        num /= 3;
      }
      
      //search jet with highest pt assigned to leptonic top
      float maxpt=-999;
      int maxind=-1;
      for(unsigned int i=0; i<hyp.toplep_jets_indices().size(); ++i){
        float pt = m_bcc->jets->at(hyp.toplep_jets_indices().at(i)).pt();
        if(pt>maxpt){
          maxpt=pt;
          maxind=hyp.toplep_jets_indices().at(i);
        }
      }
      hyp.set_blep_index(maxind);

      
      //fill only hypotheses with at least one jet assigned to each top quark
      if(hadjets>0 && lepjets>0){
        hyp.set_tophad_v4(tophad_v4);
        hyp.set_toplep_v4(toplep_v4);
        m_bcc->recoHyps->push_back(hyp);
      }
    }
  }
  
}


void EventCalc::PrintEventContent(){

  m_logger << INFO << "----------------- event content -----------------" << SLogger::endmsg;
  m_logger << INFO << "run: " << m_bcc->run <<  "   lumi block:" << m_bcc->luminosityBlock << "   event: " << m_bcc->event << SLogger::endmsg;
  m_logger << INFO << "MET = " << m_bcc->met->pt() << "   METphi = " << m_bcc->met->phi() <<  "   HTlep = " << GetHTlep() << SLogger::endmsg;
  if(m_bcc->electrons){m_logger << INFO << "Electrons:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->electrons->at(i).pt() <<"   eta = " << m_bcc->electrons->at(i).eta() 
               << "   supercluster eta = " <<m_bcc->electrons->at(i).supercluster_eta() << "   IP wrt bsp = " << fabs(m_bcc->electrons->at(i).gsfTrack_dxy_vertex(m_bcc->pvs->at(0).x(), m_bcc->pvs->at(0).y()))
               << "   pass conv veto = " << m_bcc->electrons->at(i).passconversionveto()  << "   mvaTrigV0 = " <<  m_bcc->electrons->at(i).mvaTrigV0()
               << "   dEtaIn = " << m_bcc->electrons->at(i).dEtaIn() << "   sigmaIEtaIEta = " << m_bcc->electrons->at(i).sigmaIEtaIEta()
               << "   HoverE = " << m_bcc->electrons->at(i).HoverE() << "   EcalEnergy = " << m_bcc->electrons->at(i).EcalEnergy() 
               << "   EoverPIn = " << m_bcc->electrons->at(i).EoverPIn() << "   trackMomentumAtVtx = " << m_bcc->electrons->at(i).EcalEnergy()/m_bcc->electrons->at(i).EoverPIn()
               << SLogger::endmsg;
    }
  }
  if(m_bcc->muons){m_logger << INFO << "Muons:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->muons->at(i).pt() <<"   eta = " << m_bcc->muons->at(i).eta() << SLogger::endmsg;
    }
  }
  if(m_bcc->taus){m_logger << INFO << "Taus:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->taus->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->taus->at(i).pt() <<"   eta = " << m_bcc->taus->at(i).eta() << SLogger::endmsg;
    }
  }
  if(m_bcc->jets){m_logger << INFO << "Jets:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->jets->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->jets->at(i).pt() <<"   eta = " << m_bcc->jets->at(i).eta() << "   genjet_pt = " << m_bcc->jets->at(i).genjet_pt() << "   genjet_eta = " <<   m_bcc->jets->at(i).genjet_eta() <<SLogger::endmsg;
    }
  }
  if(m_bcc->topjets){m_logger << INFO << "TopJets:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->topjets->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->topjets->at(i).pt() <<"   eta = " << m_bcc->topjets->at(i).eta() << SLogger::endmsg;
    }
  }
  if(m_bcc->photons){m_logger << INFO << "Photons:" << SLogger::endmsg;
    for(unsigned int i=0; i<m_bcc->photons->size(); ++i){
      m_logger << INFO << "     " << i+1 << " pt = " << m_bcc->photons->at(i).pt() <<"   eta = " << m_bcc->photons->at(i).eta() << SLogger::endmsg;
    }
  }
}


void EventCalc::ProduceWeight(double weight)
{
  m_TotalWeight = m_TotalWeight * weight;
}

double EventCalc::GetWeight()
{

return m_TotalWeight;
}

Revision:	1.7
Committed:	Mon Jul 2 15:04:15 2012 UTC (12 years, 10 months ago) by mmeyer
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+16 -0 lines
Log Message:	weights
#	Content
1	// Dear emacs, this is -- c++ --
2
3	#include "include/EventCalc.h"
4
5	#include <iostream>
6
7	EventCalc* EventCalc::m_instance = NULL;
8
9	EventCalc* EventCalc::Instance()
10	{
11	// Get a pointer to the object handler.
12	// This is the only way to access this class,
13	// since it's a singleton. This method is accessible
14	// from everywhere.
15
16	if (m_instance == NULL){
17	m_instance = new EventCalc();
18	}
19	return m_instance;
20	}
21
22	EventCalc::EventCalc() : m_logger( "EventCalc" )
23	{
24	// constructor: initialise all variables
25	m_logger << DEBUG << "Constructor called." << SLogger::endmsg;
26	m_bcc = NULL;
27	m_lumi = NULL;
28	m_primlep = NULL;
29	m_ttgen = NULL;
30	}
31
32	EventCalc::~EventCalc()
33	{
34	// default destructor
35	}
36
37	void EventCalc::Reset()
38	{
39	// reset: set all booleans to false
40	// this has to be done at the beginning of each event
41	// after a call to reset all quantities will be re-calculated
42	// when they are accessed
43
44	// (re-)set the pointers using the ObjectHandler
45	ObjectHandler* objs = ObjectHandler::Instance();
46	m_bcc = objs->GetBaseCycleContainer();
47	m_lumi = objs->GetLumiHandler();
48
49	// reset booleans
50	b_HT = false;
51	b_HTlep = false;
52	b_Reconstruction = false;
53
54	m_TotalWeight = 1.;
55
56	m_primlep = NULL;
57	m_ttgen = NULL;
58
59	}
60
61	BaseCycleContainer* EventCalc::GetBaseCycleContainer()
62	{
63	// return the pointer to the container with all objects
64	if (!m_bcc){
65	m_logger << WARNING << "Pointer to BaseCycleContainer is NULL." << SLogger::endmsg;
66	}
67	return m_bcc;
68	}
69
70	LuminosityHandler* EventCalc::GetLumiHandler()
71	{
72	// return the pointer to the container with all objects
73	if (!m_lumi){
74	m_logger << WARNING << "Pointer to LumiHandler is NULL." << SLogger::endmsg;
75	}
76	return m_lumi;
77	}
78
79	double EventCalc::GetHT()
80	{
81	// calculate HT, which is defined as the scalar sum of all
82	// jets, leptons and missing transverse momentum in the event
83	if (!b_HT){
84
85	b_HT = true;
86	m_HT = 0;
87
88	// add lepton pt and MET
89	m_HT += GetHTlep();
90
91	// sum over pt of all jets
92	if(m_bcc->jets){
93	for(unsigned int i=0; i<m_bcc->jets->size(); ++i){
94	m_HT += m_bcc->jets->at(i).pt();
95	}
96	}
97
98	}
99	return m_HT;
100	}
101
102	double EventCalc::GetHTlep()
103	{
104	// calculate HT_lep, which is defined as the scalar sum of all
105	// leptons and missing transverse momentum in the event
106	if (!b_HTlep){
107
108	b_HTlep = true;
109	m_HTlep=0;
110
111	// sum over pt of all electrons
112	if(m_bcc->electrons){
113	for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
114	m_HTlep += m_bcc->electrons->at(i).pt();
115	}
116	}
117
118	// sum over pt of all muons
119	if(m_bcc->muons){
120	for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
121	m_HTlep += m_bcc->muons->at(i).pt();
122	}
123	}
124
125	// sum over pt of all taus
126	if(m_bcc->taus){
127	for(unsigned int i=0; i<m_bcc->taus->size(); ++i){
128	m_HTlep += m_bcc->taus->at(i).pt();
129	}
130	}
131
132	// add MET
133	if(m_bcc->met) m_HTlep += m_bcc->met->pt();
134
135	}
136	return m_HTlep;
137	}
138
139	Particle* EventCalc::GetPrimaryLepton(){
140
141	if(!m_primlep){
142	double ptmax = -999;
143	for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
144	if(m_bcc->electrons->at(i).pt()>ptmax){
145	ptmax = m_bcc->electrons->at(i).pt();
146	m_primlep = &m_bcc->electrons->at(i);
147	}
148	}
149	for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
150	if(m_bcc->muons->at(i).pt()>ptmax){
151	ptmax = m_bcc->muons->at(i).pt();
152	m_primlep = &m_bcc->muons->at(i);
153	}
154	}
155	}
156
157	return m_primlep;
158	}
159
160	TTbarGen* EventCalc::GetTTbarGen(){
161
162	if(!m_ttgen){
163	m_ttgen = new TTbarGen();
164	}
165
166	return m_ttgen;
167	}
168
169
170	std::vector<LorentzVector> EventCalc::NeutrinoReconstruction(const LorentzVector lepton, const LorentzVector met){
171
172
173	TVector3 lepton_pT = toVector(lepton);
174	lepton_pT.SetZ(0);
175
176	TVector3 neutrino_pT = toVector(met);
177	neutrino_pT.SetZ(0);
178
179	const float mass_w = 80.399;
180	float mu = mass_w * mass_w / 2 + lepton_pT * neutrino_pT;
181
182	float A = - (lepton_pT * lepton_pT);
183	float B = mu * lepton.pz();
184	float C = mu * mu - lepton.e() * lepton.e() * (neutrino_pT * neutrino_pT);
185
186	float discriminant = B * B - A * C;
187
188	std::vector<LorentzVector> solutions;
189
190	if (0 >= discriminant)
191	{
192	// Take only real part of the solution
193	//
194	LorentzVectorXYZE solution (0,0,0,0);
195	solution.SetPx(met.Px());
196	solution.SetPy(met.Py());
197	solution.SetPz(-B / A);
198	solution.SetE(toVector(solution).Mag());
199
200	solutions.push_back(toPtEtaPhi(solution));
201
202	//_solutions = 0 > discriminant ? 0 : 1;
203	}
204	else
205	{
206	discriminant = sqrt(discriminant);
207
208	LorentzVectorXYZE solution (0,0,0,0);
209	solution.SetPx(met.Px());
210	solution.SetPy(met.Py());
211	solution.SetPz((-B - discriminant) / A);
212	solution.SetE(toVector(solution).Mag());
213
214	solutions.push_back(toPtEtaPhi(solution));
215
216	LorentzVectorXYZE solution2 (0,0,0,0);
217	solution2.SetPx(met.Px());
218	solution2.SetPy(met.Py());
219	solution2.SetPz((-B + discriminant) / A);
220	solution2.SetE(toVector(solution2).Mag());
221
222	solutions.push_back(toPtEtaPhi(solution2));
223
224	//_solutions = 2;
225	}
226
227	return solutions;
228	}
229
230	void EventCalc::FillHighMassTTbarHypotheses(){
231
232	if(b_Reconstruction) return;
233	b_Reconstruction=true;
234
235	//clear hypothesis list
236	m_bcc->recoHyps->clear();
237
238	//find primary charged lepton
239	Particle* lepton = GetPrimaryLepton();
240
241	//reconstruct neutrino
242	std::vector<LorentzVector> neutrinos = NeutrinoReconstruction( lepton->v4(), m_bcc->met->v4());
243
244	ReconstructionHypothesis hyp;
245
246	hyp.set_lepton(*lepton);
247
248	//loop over neutrino solutions and jet assignments to fill hyotheses
249	for(unsigned int i=0; i< neutrinos.size();++i){
250
251	hyp.set_neutrino_v4(neutrinos[i]);
252	LorentzVector wlep_v4 = lepton->v4()+neutrinos[i];
253
254	unsigned int n_jets = m_bcc->jets->size();
255	unsigned int max_j = myPow(3, n_jets);
256	for (unsigned int j=0; j < max_j; j++) {
257	LorentzVector tophad_v4(0,0,0,0);
258	LorentzVector toplep_v4 = wlep_v4;
259	int hadjets=0;
260	int lepjets=0;
261	int num = j;
262	hyp.clear_jetindices();
263	for (unsigned int k=0; k<n_jets; k++) {
264	// num is the k-th digit of j if you
265	// write j in a base-3 system. According
266	// to the value of this digit (which takes
267	// values from 0 to 2,
268	// in all possible combinations with the other digits),
269	// decide how to treat the jet.
270
271	if(num%3==0) {
272	tophad_v4 = tophad_v4 + m_bcc->jets->at(k).v4();
273	hyp.add_tophad_jet_index(k);
274	hadjets++;
275	}
276
277	if(num%3==1) {
278	toplep_v4 = toplep_v4 + m_bcc->jets->at(k).v4();
279	hyp.add_toplep_jet_index(k);
280	lepjets++;
281	}
282	//if(num%3==2); //do not take this jet
283
284	//shift the trigits of num to the right:
285	num /= 3;
286	}
287
288	//search jet with highest pt assigned to leptonic top
289	float maxpt=-999;
290	int maxind=-1;
291	for(unsigned int i=0; i<hyp.toplep_jets_indices().size(); ++i){
292	float pt = m_bcc->jets->at(hyp.toplep_jets_indices().at(i)).pt();
293	if(pt>maxpt){
294	maxpt=pt;
295	maxind=hyp.toplep_jets_indices().at(i);
296	}
297	}
298	hyp.set_blep_index(maxind);
299
300
301	//fill only hypotheses with at least one jet assigned to each top quark
302	if(hadjets>0 && lepjets>0){
303	hyp.set_tophad_v4(tophad_v4);
304	hyp.set_toplep_v4(toplep_v4);
305	m_bcc->recoHyps->push_back(hyp);
306	}
307	}
308	}
309
310	}
311
312
313	void EventCalc::PrintEventContent(){
314
315	m_logger << INFO << "----------------- event content -----------------" << SLogger::endmsg;
316	m_logger << INFO << "run: " << m_bcc->run << " lumi block:" << m_bcc->luminosityBlock << " event: " << m_bcc->event << SLogger::endmsg;
317	m_logger << INFO << "MET = " << m_bcc->met->pt() << " METphi = " << m_bcc->met->phi() << " HTlep = " << GetHTlep() << SLogger::endmsg;
318	if(m_bcc->electrons){m_logger << INFO << "Electrons:" << SLogger::endmsg;
319	for(unsigned int i=0; i<m_bcc->electrons->size(); ++i){
320	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->electrons->at(i).pt() <<" eta = " << m_bcc->electrons->at(i).eta()
321	<< " supercluster eta = " <<m_bcc->electrons->at(i).supercluster_eta() << " IP wrt bsp = " << fabs(m_bcc->electrons->at(i).gsfTrack_dxy_vertex(m_bcc->pvs->at(0).x(), m_bcc->pvs->at(0).y()))
322	<< " pass conv veto = " << m_bcc->electrons->at(i).passconversionveto() << " mvaTrigV0 = " << m_bcc->electrons->at(i).mvaTrigV0()
323	<< " dEtaIn = " << m_bcc->electrons->at(i).dEtaIn() << " sigmaIEtaIEta = " << m_bcc->electrons->at(i).sigmaIEtaIEta()
324	<< " HoverE = " << m_bcc->electrons->at(i).HoverE() << " EcalEnergy = " << m_bcc->electrons->at(i).EcalEnergy()
325	<< " EoverPIn = " << m_bcc->electrons->at(i).EoverPIn() << " trackMomentumAtVtx = " << m_bcc->electrons->at(i).EcalEnergy()/m_bcc->electrons->at(i).EoverPIn()
326	<< SLogger::endmsg;
327	}
328	}
329	if(m_bcc->muons){m_logger << INFO << "Muons:" << SLogger::endmsg;
330	for(unsigned int i=0; i<m_bcc->muons->size(); ++i){
331	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->muons->at(i).pt() <<" eta = " << m_bcc->muons->at(i).eta() << SLogger::endmsg;
332	}
333	}
334	if(m_bcc->taus){m_logger << INFO << "Taus:" << SLogger::endmsg;
335	for(unsigned int i=0; i<m_bcc->taus->size(); ++i){
336	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->taus->at(i).pt() <<" eta = " << m_bcc->taus->at(i).eta() << SLogger::endmsg;
337	}
338	}
339	if(m_bcc->jets){m_logger << INFO << "Jets:" << SLogger::endmsg;
340	for(unsigned int i=0; i<m_bcc->jets->size(); ++i){
341	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->jets->at(i).pt() <<" eta = " << m_bcc->jets->at(i).eta() << " genjet_pt = " << m_bcc->jets->at(i).genjet_pt() << " genjet_eta = " << m_bcc->jets->at(i).genjet_eta() <<SLogger::endmsg;
342	}
343	}
344	if(m_bcc->topjets){m_logger << INFO << "TopJets:" << SLogger::endmsg;
345	for(unsigned int i=0; i<m_bcc->topjets->size(); ++i){
346	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->topjets->at(i).pt() <<" eta = " << m_bcc->topjets->at(i).eta() << SLogger::endmsg;
347	}
348	}
349	if(m_bcc->photons){m_logger << INFO << "Photons:" << SLogger::endmsg;
350	for(unsigned int i=0; i<m_bcc->photons->size(); ++i){
351	m_logger << INFO << " " << i+1 << " pt = " << m_bcc->photons->at(i).pt() <<" eta = " << m_bcc->photons->at(i).eta() << SLogger::endmsg;
352	}
353	}
354	}
355
356
357	void EventCalc::ProduceWeight(double weight)
358	{
359	m_TotalWeight = m_TotalWeight * weight;
360	}
361
362	double EventCalc::GetWeight()
363	{
364
365	return m_TotalWeight;
366	}
367