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
#	User	Rev	Content
1	rkogler	1.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	peiffer	1.5	m_primlep = NULL;
29	peiffer	1.6	m_ttgen = NULL;
30	rkogler	1.1	}
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	rkogler	1.2	b_HTlep = false;
52	peiffer	1.6	b_Reconstruction = false;
53	rkogler	1.2
54	mmeyer	1.7	m_TotalWeight = 1.;
55
56	peiffer	1.5	m_primlep = NULL;
57	peiffer	1.6	m_ttgen = NULL;
58	mmeyer	1.7
59	rkogler	1.1	}
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	peiffer	1.5	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	peiffer	1.6	TTbarGen* EventCalc::GetTTbarGen(){
161
162			if(!m_ttgen){
163			m_ttgen = new TTbarGen();
164			}
165
166			return m_ttgen;
167			}
168
169	peiffer	1.5
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	peiffer	1.6	if(b_Reconstruction) return;
233			b_Reconstruction=true;
234
235	peiffer	1.5	//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	peiffer	1.6	//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	peiffer	1.5
301	peiffer	1.6	//fill only hypotheses with at least one jet assigned to each top quark
302	peiffer	1.5	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	peiffer	1.3	void EventCalc::PrintEventContent(){
314	rkogler	1.1
315	peiffer	1.3	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	peiffer	1.5	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	peiffer	1.3	}
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	peiffer	1.4	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	peiffer	1.3	}
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	mmeyer	1.7
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