ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/Vuko/WZAnalysis/src/MuonAnalyzer.cc

Comparing UserCode/Vuko/WZAnalysis/src/MuonAnalyzer.cc (file contents):
Revision 1.3 by senka, Fri Apr 4 08:51:22 2008 UTC vs.
Revision 1.9 by ymaravin, Fri Jul 4 18:52:23 2008 UTC

#	Line 17 | Line 17
17		//
18		//
19
20	–
21	–
20		// system include files
21		#include <memory>
22
#	Line 52 | Line 50
50
51		#include "DataFormats/METReco/interface/CaloMET.h"
52
53	+	#include "DataFormats/DTRecHit/interface/DTRecHit1D.h"
54	+	#include "DataFormats/CSCRecHit/interface/CSCRecHit2DCollection.h"
55	+	#include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h"
56	+
57	+	//#include "MuonPOG/RecoMuonTools/SegmentTrackAssociator/interface/SegmentsTrackAssociator.h"
58
59		#include "TFile.h"
60		#include "TH1F.h"
#	Line 236 | Line 239 | MuonAnalyzer::analyze(const edm::Event&
239		nb_jet=0;
240		nb_jet_eta_cut=0;
241		nb_jet_eta_and_pt_cut=0;
242	<	for (int i=0;i<jetCands->size();i++){
242	>	for (unsigned int i=0;i<jetCands->size();i++){
243		nb_jet++;
244		if (fabs((*jetCands)[i].eta())<2.5 ){
245		nb_jet_eta_cut++;
#	Line 247 | Line 250 | MuonAnalyzer::analyze(const edm::Event&
250		}
251
252		nb_muon=0;
253	<	for (int i=0;i<looseMuonCands->size();i++){
253	>	for (unsigned int i=0;i<looseMuonCands->size();i++){
254		if (fabs((*looseMuonCands)[i].eta())<2.5 ){
255		nb_muon++;
256		}
257		}
258
259	<	for (int i=0;i<jetCands->size();i++){
259	>	for (unsigned int i=0;i<jetCands->size();i++){
260
261		//  cout <<" # jets ="<<jetCands->size() <<endl;
262		JetmatchedMuon=0;
#	Line 264 | Line 267 | MuonAnalyzer::analyze(const edm::Event&
267		dr_B=0.;
268		dr_C=0.;
269		//    cout <<"       dr na pocetku="<<dr << endl;
270	+	Jet_E=-10.;
271		Jet_Et=-10.;
272		Jet_eta=-10.;
273	+	Jet_theta=-10.;
274		Jet_phi=-10.;
275	+	Jet_P=-10.;
276		Jet_Pt=-10.;
277	+	Jet_Py=-10.;
278
279		Jet_maxEInEmTowers=-10.;
280		Jet_maxEInHadTowers=-10.;
#	Line 286 | Line 293 | MuonAnalyzer::analyze(const edm::Event&
293
294		muon_Et=-10.;
295		muon_eta=-10.;
296	+	muon_theta=-10.;
297	+	muon_P=-10.;
298		muon_Pt=-10.;
299	+	muon_Pt_jet=-10.;
300	+	muon_Py=-10.;
301		B_Et=-10.;
302		B_eta=-10.;
303		B_Pt=-10.;
#	Line 295 | Line 306 | MuonAnalyzer::analyze(const edm::Event&
306		C_Pt=-10.;
307		gen_muon_Et=-10.;
308		gen_muon_eta=-10.;
309	+	gen_muon_P=-10.;
310		gen_muon_Pt=-10.;
311		muon_mother=0;
312		muon_mother_id=0;
313		W_mother_id=0;
314
315	+	muon_global=0;
316
317		muon_global_chi2=-10.;
318		muon_global_p=-10.;
#	Line 308 | Line 321 | MuonAnalyzer::analyze(const edm::Event&
321		muon_global_outerPt=-10.;
322		muon_global_ndof=-10.;
323		muon_global_normalizedChi2=-10.;
324	<	muon_global_recHitsSize=-10;
324	>	muon_global_recHitsSize=1000;
325		muon_global_numberOfLostHits=-10;
326		muon_global_numberOfValidHits=-10;
327		muon_global_innerPosition_x=-10.;
#	Line 317 | Line 330 | MuonAnalyzer::analyze(const edm::Event&
330		muon_global_outerPosition_x=-10.;
331		muon_global_outerPosition_y=-10.;
332		muon_global_outerPosition_z=-10.;
333	+	muon_global_outerPosition_layerId=-10.;
334	+	muon_global_outerPosition_superlayerId=-10.;
335	+	muon_global_outerPosition_chamberId=-10.;
336	+	muon_global_dz=-10.;
337	+	muon_global_dz_error=-10.;
338	+	muon_global_lasthit_x=-10.;
339	+	muon_global_lasthit_y=-10.;
340	+	muon_global_lasthit_z=-10.;
341	+
342	+	muon_STA=0;
343
344		muon_STA_chi2=-10.;
345		muon_STA_p=-10.;
#	Line 325 | Line 348 | MuonAnalyzer::analyze(const edm::Event&
348		muon_STA_outerPt=-10.;
349		muon_STA_ndof=-10.;
350		muon_STA_normalizedChi2=-10.;
351	<	muon_STA_recHitsSize=-10;
351	>	muon_STA_recHitsSize=1000;
352		muon_STA_numberOfLostHits=-10;
353		muon_STA_numberOfValidHits=-10;
354		muon_STA_innerPosition_x=-10.;
#	Line 334 | Line 357 | MuonAnalyzer::analyze(const edm::Event&
357		muon_STA_outerPosition_x=-10.;
358		muon_STA_outerPosition_y=-10.;
359		muon_STA_outerPosition_z=-10.;
360	+	muon_STA_outerPosition_layerId=-10.;
361	+	muon_STA_outerPosition_superlayerId=-10.;
362	+	muon_STA_outerPosition_chamberId=-10.;
363	+	muon_STA_dz=-10.;
364	+	muon_STA_dz_error=-10.;
365	+
366
367	+	muon_track=0;
368	+
369		muon_track_chi2=-10.;
370		muon_track_p=-10.;
371		muon_track_pt=-10.;
#	Line 342 | Line 373 | MuonAnalyzer::analyze(const edm::Event&
373		muon_track_outerPt=-10.;
374		muon_track_ndof=-10.;
375		muon_track_normalizedChi2=-10.;
376	<	muon_track_recHitsSize=-10;
376	>	muon_track_recHitsSize=1000;
377		muon_track_numberOfLostHits=-10;
378		muon_track_numberOfValidHits=-10;
379		muon_track_innerPosition_x=-10.;
#	Line 351 | Line 382 | MuonAnalyzer::analyze(const edm::Event&
382		muon_track_outerPosition_x=-10.;
383		muon_track_outerPosition_y=-10.;
384		muon_track_outerPosition_z=-10.;
385	+	muon_track_outerPosition_layerId=-10.;
386	+	muon_track_outerPosition_superlayerId=-10.;
387	+	muon_track_outerPosition_chamberId=-10.;
388	+	muon_track_dz=-10.;
389	+	muon_track_dz_error=-10.;
390	+
391	+	DT=0;
392	+	DT_wheel = -10;
393	+	DT_sector = -10;
394	+	DT_station = -10;
395	+	DT_superlayer = -10;
396	+	DT_layer = -10;
397	+	CSC=0;
398	+	CSC_ring = -10;
399	+	CSC_station = -10;
400	+	CSC_endcap = -10;
401	+	CSC_chamber = -10;
402	+	CSC_layer = -10;
403	+	RPC=0;
404	+	RPC_layer=-10;
405	+	RPC_region=-10;
406	+	RPC_ring=-10;
407	+	RPC_sector=-10;
408	+	RPC_station=-10;
409	+	RPC_subsector=-10;
410	+
411	+
412	+	Jet_E=(*jetCands)[i].energy();
413	+	Jet_Et=(*jetCands)[i].et();
414	+	Jet_eta=(*jetCands)[i].eta();
415	+	//      cout<<"" <<endl;
416	+	//      cout<<"Jet_eta="<<Jet_eta<<endl;
417	+	Jet_theta=(*jetCands)[i].theta();
418	+	//      cout<<"Jet_theta="<<Jet_theta<<endl;
419	+	Jet_phi=(*jetCands)[i].phi();
420	+	Jet_P=(*jetCands)[i].p();
421	+	Jet_Pt=(*jetCands)[i].pt();
422	+	Jet_Py=(*jetCands)[i].py();
423	+	//      cout<<"Jet_Py="<<Jet_Py<<endl;
424	+
425	+	Jet_maxEInEmTowers=(*jetCands)[i].maxEInEmTowers();
426	+	Jet_maxEInHadTowers=(*jetCands)[i].maxEInHadTowers();
427	+	Jet_energyFractionHadronic=(*jetCands)[i].energyFractionHadronic();
428	+	Jet_emEnergyFraction=(*jetCands)[i].emEnergyFraction();
429	+	Jet_hadEnergyInHB=(*jetCands)[i].hadEnergyInHB();
430	+	Jet_hadEnergyInHO=(*jetCands)[i].hadEnergyInHO();
431	+	Jet_hadEnergyInHE=(*jetCands)[i].hadEnergyInHE();
432	+	Jet_hadEnergyInHF=(*jetCands)[i].hadEnergyInHF();
433	+	Jet_emEnergyInEB=(*jetCands)[i].emEnergyInEB();
434	+	Jet_emEnergyInEE=(*jetCands)[i].emEnergyInEE();
435	+	Jet_emEnergyInHF=(*jetCands)[i].emEnergyInHF();
436	+	Jet_towersArea=(*jetCands)[i].towersArea();
437	+	Jet_n90=(*jetCands)[i].n90();
438	+	Jet_n60=(*jetCands)[i].n60();
439
440
356	–	//    if (fabs((*jetCands)[i].eta())<2.5) {
357	–	//      cout <<" jet passing eta cut" <<endl;
358	–	// if jet has matched muon and eta(muon)<2.5
359	–
441		const reco::Candidate * matchedmuon=MatchedMuonWithJet(&(*jetCands)[i]);
442
443		if (MatchedMuonWithJet(&(*jetCands)[i])) {
444	<	cout <<" jet IMA matched muon !!!!!!!!!!!!!!" <<endl;
444	>	//      cout <<" jet IMA matched muon !!!!!!!!!!!!!!" <<endl;
445		JetmatchedMuon=1;
446		dr_muon=dR_Muon_Jet(&(*jetCands)[i]);
447	<	cout <<"       dr="<< dr_muon << "  dR_Muon_Jet(&(*jetCands)[i])="<<dR_Muon_Jet(&(*jetCands)[i])<< endl;
447	>	//      cout <<"       dr="<< dr_muon << "  dR_Muon_Jet(&(*jetCands)[i])="<<dR_Muon_Jet(&(*jetCands)[i])<< endl;
448		//        muon_Et=MatchedMuonWithJet(&(*jetCands)[i])->et();
449		//        muon_eta=MatchedMuonWithJet(&(*jetCands)[i])->eta();
450		//        muon_Pt=MatchedMuonWithJet(&(*jetCands)[i])->pt();
451		//        muon_STA_chi2=MatchedMuonWithJet(&(*jetCands)[i])->standAloneMuon()->chi2();
452		muon_Et = matchedmuon->et();
453	+	muon_theta = matchedmuon->theta();
454	+	//      cout<<"" <<endl;
455	+	//      cout << "muon_theta="<<muon_theta<< endl;
456		muon_eta = matchedmuon->eta();
457	+	//      cout << "muon_eta="<<muon_eta<< endl;
458		muon_Pt = matchedmuon->pt();
459	+	muon_Py = matchedmuon->py();
460	+	//      cout << "muon_Py="<<muon_Py<< endl;
461	+	muon_P = matchedmuon->p();
462	+
463
464	+	if((muon_Py>0 && Jet_Py>0) || (muon_Py<0 && Jet_Py<0)) theta=abs(muon_theta-Jet_theta);
465	+	else if((muon_Py>0 && Jet_Py<0) || (muon_Py<0 && Jet_Py>0)) theta=abs(muon_theta+Jet_theta);
466	+	else if(muon_Py==0) theta=abs(Jet_theta);
467	+	else if(Jet_Py==0) theta=abs(muon_theta);
468	+	else theta=0;
469	+	//      else theta=-10;
470	+	//      cout <<"  theta="<<theta << endl;
471	+	if (theta!=0) muon_Pt_jet=abs(muon_P*TMath::Sin(theta));
472	+	else muon_Pt_jet=-10;
473	+	//       cout <<"  muon_P="<< muon_P << endl;
474	+	//       cout <<"  muon_Pt_jet="<<muon_Pt_jet << endl;
475	+	//       cout <<""<< endl;
476		const reco::Muon* matchedmuon_recoMuon = dynamic_cast<const reco::Muon *> (matchedmuon); // conversion of matchedmuon from reco::Candidate to reco::Muon
477	+	//       reco::TrackRef combined_muon = new reco::Track::Track();
478	+	//       combined_muon = matchedmuon_recoMuon->combinedMuon();
479
480	<	muon_global_chi2 = matchedmuon_recoMuon->combinedMuon()->chi2();
481	<	muon_global_p = matchedmuon_recoMuon->combinedMuon()->p();
482	<	muon_global_pt = matchedmuon_recoMuon->combinedMuon()->pt();
483	<	muon_global_outerP = matchedmuon_recoMuon->combinedMuon()->outerP();
484	<	muon_global_outerPt = matchedmuon_recoMuon->combinedMuon()->outerPt();
485	<	muon_global_ndof = matchedmuon_recoMuon->combinedMuon()->ndof();
486	<	muon_global_normalizedChi2 = matchedmuon_recoMuon->combinedMuon()->normalizedChi2();
487	<	muon_global_recHitsSize = matchedmuon_recoMuon->combinedMuon()->recHitsSize();
488	<	muon_global_numberOfLostHits = matchedmuon_recoMuon->combinedMuon()->numberOfLostHits();
489	<	muon_global_numberOfValidHits = matchedmuon_recoMuon->combinedMuon()->numberOfValidHits();
490	<	muon_global_innerPosition_x = matchedmuon_recoMuon->combinedMuon()->innerPosition().x();
491	<	muon_global_innerPosition_y = matchedmuon_recoMuon->combinedMuon()->innerPosition().y();
492	<	muon_global_innerPosition_z = matchedmuon_recoMuon->combinedMuon()->innerPosition().z();
493	<	muon_global_outerPosition_x = matchedmuon_recoMuon->combinedMuon()->outerPosition().x();
494	<	muon_global_outerPosition_y = matchedmuon_recoMuon->combinedMuon()->outerPosition().y();
495	<	muon_global_outerPosition_z = matchedmuon_recoMuon->combinedMuon()->outerPosition().z();
496	<
497	<	muon_STA_chi2 = matchedmuon_recoMuon->standAloneMuon()->chi2();
498	<	muon_STA_p = matchedmuon_recoMuon->standAloneMuon()->p();
499	<	muon_STA_pt = matchedmuon_recoMuon->standAloneMuon()->pt();
500	<	muon_STA_outerP = matchedmuon_recoMuon->standAloneMuon()->outerP();
501	<	muon_STA_outerPt = matchedmuon_recoMuon->standAloneMuon()->outerPt();
502	<	muon_STA_ndof = matchedmuon_recoMuon->standAloneMuon()->ndof();
503	<	muon_STA_normalizedChi2 = matchedmuon_recoMuon->standAloneMuon()->normalizedChi2();
504	<	muon_STA_recHitsSize = matchedmuon_recoMuon->standAloneMuon()->recHitsSize();
505	<	muon_STA_numberOfLostHits = matchedmuon_recoMuon->standAloneMuon()->numberOfLostHits();
506	<	muon_STA_numberOfValidHits = matchedmuon_recoMuon->standAloneMuon()->numberOfValidHits();
507	<	muon_STA_innerPosition_x = matchedmuon_recoMuon->standAloneMuon()->innerPosition().x();
508	<	muon_STA_innerPosition_y = matchedmuon_recoMuon->standAloneMuon()->innerPosition().y();
509	<	muon_STA_innerPosition_z = matchedmuon_recoMuon->standAloneMuon()->innerPosition().z();
510	<	muon_STA_outerPosition_x = matchedmuon_recoMuon->standAloneMuon()->outerPosition().x();
511	<	muon_STA_outerPosition_y = matchedmuon_recoMuon->standAloneMuon()->outerPosition().y();
512	<	muon_STA_outerPosition_z = matchedmuon_recoMuon->standAloneMuon()->outerPosition().z();
513	<
514	<	muon_track_chi2 = matchedmuon_recoMuon->track()->chi2();
515	<	muon_track_p = matchedmuon_recoMuon->track()->p();
516	<	muon_track_pt = matchedmuon_recoMuon->track()->pt();
517	<	muon_track_outerP = matchedmuon_recoMuon->track()->outerP();
518	<	muon_track_outerPt = matchedmuon_recoMuon->track()->outerPt();
519	<	muon_track_ndof = matchedmuon_recoMuon->track()->ndof();
520	<	muon_track_normalizedChi2 = matchedmuon_recoMuon->track()->normalizedChi2();
521	<	muon_track_recHitsSize = matchedmuon_recoMuon->track()->recHitsSize();
522	<	muon_track_numberOfLostHits = matchedmuon_recoMuon->track()->numberOfLostHits();
523	<	muon_track_numberOfValidHits = matchedmuon_recoMuon->track()->numberOfValidHits();
524	<	muon_track_innerPosition_x = matchedmuon_recoMuon->track()->innerPosition().x();
525	<	muon_track_innerPosition_y = matchedmuon_recoMuon->track()->innerPosition().y();
526	<	muon_track_innerPosition_z = matchedmuon_recoMuon->track()->innerPosition().z();
527	<	muon_track_outerPosition_x = matchedmuon_recoMuon->track()->outerPosition().x();
528	<	muon_track_outerPosition_y = matchedmuon_recoMuon->track()->outerPosition().y();
529	<	muon_track_outerPosition_z = matchedmuon_recoMuon->track()->outerPosition().z();
530	<
480	>	if (&(matchedmuon_recoMuon->combinedMuon())!=0){
481	>	//      if (combined_muon==0){
482	>	muon_global=1;
483	>	muon_global_chi2 = matchedmuon_recoMuon->combinedMuon()->chi2();
484	>	muon_global_p = matchedmuon_recoMuon->combinedMuon()->p();
485	>	muon_global_pt = matchedmuon_recoMuon->combinedMuon()->pt();
486	>	muon_global_outerP = matchedmuon_recoMuon->combinedMuon()->outerP();
487	>	muon_global_outerPt = matchedmuon_recoMuon->combinedMuon()->outerPt();
488	>	muon_global_ndof = matchedmuon_recoMuon->combinedMuon()->ndof();
489	>	muon_global_normalizedChi2 = matchedmuon_recoMuon->combinedMuon()->normalizedChi2();
490	>	muon_global_recHitsSize = matchedmuon_recoMuon->combinedMuon()->recHitsSize();
491	>	muon_global_numberOfLostHits = matchedmuon_recoMuon->combinedMuon()->numberOfLostHits();
492	>	muon_global_numberOfValidHits = matchedmuon_recoMuon->combinedMuon()->numberOfValidHits();
493	>	muon_global_innerPosition_x = matchedmuon_recoMuon->combinedMuon()->innerPosition().x();
494	>	muon_global_innerPosition_y = matchedmuon_recoMuon->combinedMuon()->innerPosition().y();
495	>	muon_global_innerPosition_z = matchedmuon_recoMuon->combinedMuon()->innerPosition().z();
496	>	muon_global_outerPosition_x = matchedmuon_recoMuon->combinedMuon()->outerPosition().x();
497	>	muon_global_outerPosition_y = matchedmuon_recoMuon->combinedMuon()->outerPosition().y();
498	>	muon_global_outerPosition_z = matchedmuon_recoMuon->combinedMuon()->outerPosition().z();
499	>	muon_global_dz=matchedmuon_recoMuon->combinedMuon()->dz();
500	>	muon_global_dz_error=matchedmuon_recoMuon->combinedMuon()->dzError();
501	>
502	>	////////////////////////////////////////////////
503	>	//      chamber, layer, superlayer
504	>
505	>	//      cout <<"prije rechit"<<endl;
506	>	int recHit_size= matchedmuon_recoMuon->combinedMuon()-> recHitsSize();
507	>	//      trackingRecHit_iterator recHit = matchedmuon_recoMuon->combinedMuon()->recHitsEnd();
508	>	TrackingRecHitRef recHit_last= matchedmuon_recoMuon->combinedMuon()->recHit(recHit_size-1);
509	>	double last_hit_distance=sqrt(recHit_last->localPosition().x()*recHit_last->localPosition().x()+
510	>	recHit_last->localPosition().y()*recHit_last->localPosition().y()+
511	>	recHit_last->localPosition().z()*recHit_last->localPosition().z());
512	>	//      cout <<"last hit distance="<<last_hit_distance <<endl;
513	>
514	>	trackingRecHit_iterator rhbegin =  matchedmuon_recoMuon->combinedMuon()->recHitsBegin();
515	>	trackingRecHit_iterator rhend =  matchedmuon_recoMuon->combinedMuon()->recHitsEnd();
516	>	double distance,distance_r,max;
517	>	int max_i=0;
518	>	int i=0;
519	>	int j=0;
520	>
521	>	//loop over recHit
522	>	// trazim zadnji hit (najveca udaljenost od IP)
523	>
524	>	//      for(trackingRecHit_iterator recHit = rhbegin; recHit != rhend; ++recHit){
525	>
526	>	//        distance=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
527	>	//                             +((*recHit)->localPosition().y())*((*recHit)->localPosition().y())
528	>	//                             +((*recHit)->localPosition().z())*((*recHit)->localPosition().z()));
529	>	//        distance_r=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
530	>	//                             +((*recHit)->localPosition().y())*((*recHit)->localPosition().y()));
531	>	//        if (recHit==rhbegin) {
532	>	//          max=distance;
533	>	//        }
534	>	//        if (distance>max) {
535	>	//          max=distance;
536	>	//          max_i=i;
537	>	//        }
538	>	// //     cout<< "i="<< i<< endl;
539	>	// //     cout <<"hit distance="<< distance << endl;
540	>	// //     cout <<"hit distance_x="<< (*recHit)->localPosition().x() << endl;
541	>	// //     cout <<"hit distance_r="<< distance_r << endl;
542	>	// //     cout <<"hit valid="<< (*recHit)->isValid() << endl;
543	>	//        i++;
544	>	//      }
545	>	//      cout << "max="<< max<< endl;
546	>	//      cout << "i of max="<< max_i<<endl;
547	>
548	>	//      DT_station=0;
549	>	//      DT_superlayer=0;
550	>	//      DT_layer=0;
551	>
552	>	//      for(trackingRecHit_iterator recHit = rhbegin; recHit != rhend; ++recHit){
553	>	//        j++;
554	>	//        cout << "j="<< j<< endl;
555	>	//      if (j-1!=max_i) continue;      // kada uzimam onaj najdalji (PAZI: lokalne varijable su u pitanju!)
556	>	//      if (j!=recHit_size) continue;  // kada uzimam zadnji po redu recHit
557	>
558	>	//      TrackingRecHitRef recHit=recHit_last;
559	>	//        cout <<" last hit !!!!" <<endl;
560	>	//        cout << "j="<<j <<endl;
561	>
562	>
563	>	// NAPOMENA: kada imam iterator preko svih recHitova onda (*recHit)->localPosition(), a kada imam lastHit onda (recHit_last)->localPosition()
564	>
565	>
566	>	//        muon_global_lasthit_r=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
567	>	//                                   +((*recHit)->localPosition().y())*((*recHit)->localPosition().y()));
568	>	//        muon_global_lasthit_distance=sqrt(((*recHit)->localPosition().x())*((*recHit)->localPosition().x())
569	>	//                                          +((*recHit)->localPosition().y())*((*recHit)->localPosition().y())
570	>	//                                          +((*recHit)->localPosition().z())*((*recHit)->localPosition().z()));
571	>	muon_global_lasthit_x=(recHit_last)->localPosition().x();
572	>	cout <<"hit x="<<muon_global_lasthit_x <<endl;
573	>	muon_global_lasthit_y=(recHit_last)->localPosition().y();
574	>	muon_global_lasthit_z=(recHit_last)->localPosition().z();
575	>
576	>	cout <<" distance="<<sqrt(((recHit_last)->localPosition().x())*((recHit_last)->localPosition().x())
577	>	+((recHit_last)->localPosition().y())*((recHit_last)->localPosition().y())
578	>	+((recHit_last)->localPosition().z())*((recHit_last)->localPosition().z())) <<endl;
579	>	//      cout <<"rechit"<<endl;
580	>	DetId IdRivHit = (recHit_last)->geographicalId();
581	>	//      cout <<"IdRivHit"<<endl;
582	>
583	>	if (IdRivHit.det() == DetId::Muon) {
584	>	cout <<" is in muon detector" <<endl;
585	>
586	>	//if the recHit belong to a DT
587	>	if (IdRivHit.subdetId() == MuonSubdetId::DT ) {
588	>	cout <<"  is in DT" <<endl;
589	>	//LogTrace(metname) <<"The recHit belong to a DT";
590	>	// get the chamber Id
591	>	cout <<"cudno="<<IdRivHit.rawId() <<endl;
592	>	DTChamberId chamberId(IdRivHit.rawId());
593	>	cout <<"   DTChamberId" << endl;
594	>
595	>	DTWireId ch_id(IdRivHit.rawId());
596	>	cout <<"     DTWireId" << endl;
597	>	cout <<"     proba!" << endl;
598	>	DT=1;
599	>	//              if(DT_station>ch_id.station()) continue;
600	>	DT_station = ch_id.station();
601	>	//              if(DT_superlayer>ch_id.superlayer()) continue;
602	>	DT_superlayer = ch_id.superlayer();
603	>	cout <<"     proba 2!" << endl;
604	>	//              if(DT_layer>ch_id.layer()) continue;
605	>	DT_layer = ch_id.layer();
606	>	DT_wheel= ch_id.wheel();
607	>	DT_sector= ch_id.sector();
608	>
609	>	cout <<"       wheel="<< DT_wheel << endl;
610	>	cout <<"       station="<< DT_station << endl;
611	>	cout <<"       layer="<< DT_layer << endl;
612	>	cout <<"       super="<< DT_superlayer << endl;
613	>	cout <<"       sector="<< DT_sector << endl;
614	>
615	>
616	>	//          DTWireId  = dynamic_cast<TrackingRecHit *> (&rechit); // ne radi
617	>
618	>	//    }
619	>
620	>	}
621	>
622	>	if (IdRivHit.subdetId() == MuonSubdetId::CSC ) {
623	>	cout <<"  is in CSC" <<endl;
624	>	CSC=1;
625	>	CSCDetId  tempchamberId(IdRivHit.rawId());
626	>	CSC_ring = tempchamberId.ring();
627	>	CSC_station = tempchamberId.station();
628	>	CSC_endcap = tempchamberId.endcap();
629	>	CSC_chamber = tempchamberId.chamber();
630	>	CSC_layer = tempchamberId.layer();
631	>
632	>	cout <<"    CSC   ring="<< CSC_ring << endl;
633	>	cout <<"    CSC   station="<< CSC_station << endl;
634	>	cout <<"    CSC   layer="<< CSC_layer << endl;
635	>
636	>	cout <<"    CSC   endcap="<< CSC_endcap << endl;
637	>
638	>	cout <<"    CSC   chamber="<< CSC_chamber << endl;
639	>	}
640	>
641	>	if (IdRivHit.subdetId() == MuonSubdetId::RPC ) {
642	>	cout <<"  is in RPC" <<endl;
643	>	RPCDetId  tempRPCId(IdRivHit.rawId());
644	>	RPC=1;
645	>	RPC_layer=tempRPCId.layer();
646	>	RPC_region=tempRPCId.region();
647	>	RPC_ring=tempRPCId.ring();
648	>	RPC_sector=tempRPCId.sector();
649	>	RPC_station=tempRPCId.station();
650	>	RPC_subsector=tempRPCId.subsector();
651	>
652	>	cout <<"    RPC   ring="<< RPC_ring << endl;
653	>	cout <<"    RPC   station="<< RPC_station << endl;
654	>	cout <<"    RPC   layer="<< RPC_layer << endl;
655	>	cout <<"    RPC   region="<< RPC_region << endl;
656	>	cout <<"    RPC   sector="<< RPC_sector << endl;
657	>	cout <<"    RPC   subsector="<< RPC_subsector << endl;
658	>	}
659	>	}
660	>	else cout <<" is not in muon det" << endl;
661	>	//    }
662	>
663	>	//      TrackingRecHitRef *recHit= matchedmuon_recoMuon->combinedMuon()->recHit(recHit_size-1);
664	>	cout <<"last hit function" << endl;
665	>	cout <<" distance="<<sqrt(((recHit_last)->localPosition().x())*((recHit_last)->localPosition().x())
666	>	+((recHit_last)->localPosition().y())*((recHit_last)->localPosition().y())
667	>	+((recHit_last)->localPosition().z())*((recHit_last)->localPosition().z())) << endl;
668	>	//      for(CandidateCollection::const_iterator z1 = zllCands->begin();
669	>	//          z1 != zllCands->end(); ++ z1 ) {
670	>	//      }
671	>
672	>	//      TrackingRecHitRef rechit = matchedmuon_recoMuon->combinedMuon()->recHit(3); // radi!!
673	>	// //   trackingRecHit_iterator rechit = matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); // radi!!
674	>	//      //      TrackingRecHit * rechit_noref = dynamic_cast<TrackingRecHit *> (&rechit); // ne radi
675	>	//      //      DTRecHit1D * rechit_1d = dynamic_cast<DTRecHit1D *> (&rechit); // ne radi
676	>	//      //      DTRecHit1D * rechit_1d = dynamic_cast<DTRecHit1D *> (&rechit); // ne radi
677	>	//      //      DTRecHit1D * rechit_1d;
678	>	//      //      rechit_1d = (&rechit);
679	>	//      muon_global_outerPosition_layerId=0;
680	>
681	>
682	>	//////////////////////////////////////
683	>
684	>	//      for (pa_sim = simHits->begin(); pa_sim != simHits->end(); ++pa_sim ) {
685	>	//      trackingRecHit_iterator pa_sim;
686	>	//      for (trackingRecHit_iterator pa_sim = matchedmuon_recoMuon->combinedMuon()->recHitsBegin(); pa_sim != matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); ++pa_sim ) {
687	>	for (unsigned int i=1;i<matchedmuon_recoMuon->combinedMuon()->recHitsSize()+1;i++){
688	>	//TrackingRecHit pa_sim = matchedmuon_recoMuon->combinedMuon()->recHitsBegin(); pa_sim != matchedmuon_recoMuon->combinedMuon()->recHitsEnd(); ++pa_sim ) {
689	>
690	>	//      cout <<" --------------------- analiza?:"<<endl;
691	>
692	>	if (i!=matchedmuon_recoMuon->combinedMuon()->recHitsSize()) continue;
693	>
694	>	//      cout <<" --------------------- rec hits analiza:"<<endl;
695	>	}
696	>
697	>	///////////////////////////////////////
698	>
699	>	}
700	>
701	>	if (&(matchedmuon_recoMuon->standAloneMuon())!=0){
702	>	muon_STA=1;
703	>	muon_STA_chi2 = matchedmuon_recoMuon->standAloneMuon()->chi2();
704	>	muon_STA_p = matchedmuon_recoMuon->standAloneMuon()->p();
705	>	muon_STA_pt = matchedmuon_recoMuon->standAloneMuon()->pt();
706	>	muon_STA_outerP = matchedmuon_recoMuon->standAloneMuon()->outerP();
707	>	muon_STA_outerPt = matchedmuon_recoMuon->standAloneMuon()->outerPt();
708	>	muon_STA_ndof = matchedmuon_recoMuon->standAloneMuon()->ndof();
709	>	muon_STA_normalizedChi2 = matchedmuon_recoMuon->standAloneMuon()->normalizedChi2();
710	>	muon_STA_recHitsSize = matchedmuon_recoMuon->standAloneMuon()->recHitsSize();
711	>	muon_STA_numberOfLostHits = matchedmuon_recoMuon->standAloneMuon()->numberOfLostHits();
712	>	muon_STA_numberOfValidHits = matchedmuon_recoMuon->standAloneMuon()->numberOfValidHits();
713	>	muon_STA_innerPosition_x = matchedmuon_recoMuon->standAloneMuon()->innerPosition().x();
714	>	muon_STA_innerPosition_y = matchedmuon_recoMuon->standAloneMuon()->innerPosition().y();
715	>	muon_STA_innerPosition_z = matchedmuon_recoMuon->standAloneMuon()->innerPosition().z();
716	>	muon_STA_outerPosition_x = matchedmuon_recoMuon->standAloneMuon()->outerPosition().x();
717	>	muon_STA_outerPosition_y = matchedmuon_recoMuon->standAloneMuon()->outerPosition().y();
718	>	muon_STA_outerPosition_z = matchedmuon_recoMuon->standAloneMuon()->outerPosition().z();
719	>	muon_STA_dz=matchedmuon_recoMuon->standAloneMuon()->dz();
720	>	muon_STA_dz_error=matchedmuon_recoMuon->standAloneMuon()->dzError();
721	>	}
722	>
723	>	if (&(matchedmuon_recoMuon->track())!=0){
724	>	muon_track=1;
725	>	muon_track_chi2 = matchedmuon_recoMuon->track()->chi2();
726	>	muon_track_p = matchedmuon_recoMuon->track()->p();
727	>	muon_track_pt = matchedmuon_recoMuon->track()->pt();
728	>	muon_track_outerP = matchedmuon_recoMuon->track()->outerP();
729	>	muon_track_outerPt = matchedmuon_recoMuon->track()->outerPt();
730	>	muon_track_ndof = matchedmuon_recoMuon->track()->ndof();
731	>	muon_track_normalizedChi2 = matchedmuon_recoMuon->track()->normalizedChi2();
732	>	muon_track_recHitsSize = matchedmuon_recoMuon->track()->recHitsSize();
733	>	muon_track_numberOfLostHits = matchedmuon_recoMuon->track()->numberOfLostHits();
734	>	muon_track_numberOfValidHits = matchedmuon_recoMuon->track()->numberOfValidHits();
735	>	muon_track_innerPosition_x = matchedmuon_recoMuon->track()->innerPosition().x();
736	>	muon_track_innerPosition_y = matchedmuon_recoMuon->track()->innerPosition().y();
737	>	muon_track_innerPosition_z = matchedmuon_recoMuon->track()->innerPosition().z();
738	>	muon_track_outerPosition_x = matchedmuon_recoMuon->track()->outerPosition().x();
739	>	muon_track_outerPosition_y = matchedmuon_recoMuon->track()->outerPosition().y();
740	>	muon_track_outerPosition_z = matchedmuon_recoMuon->track()->outerPosition().z();
741	>	muon_track_dz=matchedmuon_recoMuon->track()->dz();
742	>	muon_track_dz_error=matchedmuon_recoMuon->track()->dzError();
743	>	}
744		//        if (fabs(MatchedMuonWithJet(&(*jetCands)[i])->eta())<2.5) {
745		//          cout <<"   muon prolazi eta cut" <<endl;
746
#	Line 437 | Line 753 | MuonAnalyzer::analyze(const edm::Event&
753
754		if ((iter->first)==13)
755		cout <<"IDE PO CIJELOJ MAPI 13" << endl;
756	+	cout <<"-----------------------------------------------------" << endl;
757		//        }
758		}
759
760		// ako muon (matched with jet) ima matched gen_muon
761
762		if (MatchedGenParticle(matchedmuon)){
763	<	cout <<" muon has matched gen muon !!!!!!!!!!" <<endl;
763	>	//      cout <<" muon has matched gen muon !!!!!!!!!!" <<endl;
764		MuonmatchedGenMuon=1;
765		gen_muon_Et=MatchedGenParticle(matchedmuon)->et();
766		gen_muon_eta=MatchedGenParticle(matchedmuon)->eta();
767	+	gen_muon_P=MatchedGenParticle(matchedmuon)->p();
768		gen_muon_Pt=MatchedGenParticle(matchedmuon)->pt();
769		MuonAnalyzer::LeptonOrigin origin = getMother(MatchedGenParticle(matchedmuon));
770
771		if (origin == MuonAnalyzer::wboson ){
772		muon_mother=1;
773	<	cout << "MatchedGenFromW=true" <<endl;
773	>	//      cout << "MatchedGenFromW=true" <<endl;
774		W_mother_id = getMother_Id(getMother_particle(MatchedGenParticle(matchedmuon)));
775		}
776		else if (origin == MuonAnalyzer::zboson ){
777		muon_mother=2;
778	<	cout << "MatchedGenFromZ=true" <<endl;
778	>	//      cout << "MatchedGenFromZ=true" <<endl;
779		}
780		else if (origin == MuonAnalyzer::bdecay )    {
781		muon_mother = 3;
782	<	cout << "MatchedGenFromB=true" <<endl;
782	>	//        cout << "MatchedGenFromB=true" <<endl;
783		}
784		else if (origin == MuonAnalyzer::cdecay )    {
785		muon_mother = 4;
786	<	cout << "MatchedGenFromC=true" <<endl;
786	>	//      cout << "MatchedGenFromC=true" <<endl;
787		}
788		else if (origin == MuonAnalyzer::tdecay )    {
789		muon_mother = 5;
790	<	cout << "MatchedGenFromT=true" <<endl;
790	>	//      cout << "MatchedGenFromT=true" <<endl;
791		}
792		muon_mother_id=getMother_Id(MatchedGenParticle(matchedmuon));
793
#	Line 477 | Line 795 | MuonAnalyzer::analyze(const edm::Event&
795		//      }
796		}
797		//      }
798	<	cout <<" jet nema matched muon" <<endl;
798	>	//      cout <<" jet nema matched muon" <<endl;
799		}
800
801		if (MatchedBhadronWithJet(&(*jetCands)[i])) {
802	<	cout <<" ima matched B hadron !!!!!!!!" << endl;
802	>	//        cout <<" ima matched B hadron !!!!!!!!" << endl;
803		/////////////////
804
805		JetmatchedB=1;
806		dr_B=dR_B_Jet(&(*jetCands)[i]);
807	<	cout <<"       dr="<< dr_B << "  dR_B_Jet(&(*jetCands)[i])="<<dR_B_Jet(&(*jetCands)[i])<< endl;
807	>	//      cout <<"       dr="<< dr_B << "  dR_B_Jet(&(*jetCands)[i])="<<dR_B_Jet(&(*jetCands)[i])<< endl;
808		B_Et=MatchedBhadronWithJet(&(*jetCands)[i])->et();
809		B_eta=MatchedBhadronWithJet(&(*jetCands)[i])->eta();
810		B_Pt=MatchedBhadronWithJet(&(*jetCands)[i])->pt();
811
812	<	}
812	>	}
813
814		if (MatchedChadronWithJet(&(*jetCands)[i])) {
815	<	cout <<" ima matched C hadron !!!!!!!!" << endl;
815	>	//      cout <<" ima matched C hadron !!!!!!!!" << endl;
816		/////////////////
817
818		JetmatchedC=1;
819		dr_C=dR_C_Jet(&(*jetCands)[i]);
820	<	cout <<"       dr="<< dr_C << "  dR_C_Jet(&(*jetCands)[i])="<<dR_C_Jet(&(*jetCands)[i])<< endl;
820	>	//      cout <<"       dr="<< dr_C << "  dR_C_Jet(&(*jetCands)[i])="<<dR_C_Jet(&(*jetCands)[i])<< endl;
821		C_Et=MatchedChadronWithJet(&(*jetCands)[i])->et();
822		C_eta=MatchedChadronWithJet(&(*jetCands)[i])->eta();
823		C_Pt=MatchedChadronWithJet(&(*jetCands)[i])->pt();
824	<
824	>
825		}
826
827	<	Jet_Et=(*jetCands)[i].et();
828	<	Jet_eta=(*jetCands)[i].eta();
829	<	Jet_phi=(*jetCands)[i].phi();
830	<	Jet_Pt=(*jetCands)[i].pt();
827	>	//       Jet_E=(*jetCands)[i].energy();
828	>	//       Jet_Et=(*jetCands)[i].et();
829	>	//       Jet_eta=(*jetCands)[i].eta();
830	>	//       cout<<"" <<endl;
831	>	//       cout<<"Jet_eta="<<Jet_eta<<endl;
832	>	//       Jet_theta=(*jetCands)[i].theta();
833	>	//       cout<<"Jet_theta="<<Jet_theta<<endl;
834	>	//       Jet_phi=(*jetCands)[i].phi();
835	>	//       Jet_P=(*jetCands)[i].p();
836	>	//       Jet_Pt=(*jetCands)[i].pt();
837	>	//       Jet_Py=(*jetCands)[i].py();
838	>	//       cout<<"Jet_Py="<<Jet_Py<<endl;
839
840	<	Jet_maxEInEmTowers=(*jetCands)[i].maxEInEmTowers();
841	<	Jet_maxEInHadTowers=(*jetCands)[i].maxEInHadTowers();
842	<	Jet_energyFractionHadronic=(*jetCands)[i].energyFractionHadronic();
843	<	Jet_emEnergyFraction=(*jetCands)[i].emEnergyFraction();
844	<	Jet_hadEnergyInHB=(*jetCands)[i].hadEnergyInHB();
845	<	Jet_hadEnergyInHO=(*jetCands)[i].hadEnergyInHO();
846	<	Jet_hadEnergyInHE=(*jetCands)[i].hadEnergyInHE();
847	<	Jet_hadEnergyInHF=(*jetCands)[i].hadEnergyInHF();
848	<	Jet_emEnergyInEB=(*jetCands)[i].emEnergyInEB();
849	<	Jet_emEnergyInEE=(*jetCands)[i].emEnergyInEE();
850	<	Jet_emEnergyInHF=(*jetCands)[i].emEnergyInHF();
851	<	Jet_towersArea=(*jetCands)[i].towersArea();
852	<	Jet_n90=(*jetCands)[i].n90();
853	<	Jet_n60=(*jetCands)[i].n60();
840	>	//       Jet_maxEInEmTowers=(*jetCands)[i].maxEInEmTowers();
841	>	//       Jet_maxEInHadTowers=(*jetCands)[i].maxEInHadTowers();
842	>	//       Jet_energyFractionHadronic=(*jetCands)[i].energyFractionHadronic();
843	>	//       Jet_emEnergyFraction=(*jetCands)[i].emEnergyFraction();
844	>	//       Jet_hadEnergyInHB=(*jetCands)[i].hadEnergyInHB();
845	>	//       Jet_hadEnergyInHO=(*jetCands)[i].hadEnergyInHO();
846	>	//       Jet_hadEnergyInHE=(*jetCands)[i].hadEnergyInHE();
847	>	//       Jet_hadEnergyInHF=(*jetCands)[i].hadEnergyInHF();
848	>	//       Jet_emEnergyInEB=(*jetCands)[i].emEnergyInEB();
849	>	//       Jet_emEnergyInEE=(*jetCands)[i].emEnergyInEE();
850	>	//       Jet_emEnergyInHF=(*jetCands)[i].emEnergyInHF();
851	>	//       Jet_towersArea=(*jetCands)[i].towersArea();
852	>	//       Jet_n90=(*jetCands)[i].n90();
853	>	//       Jet_n60=(*jetCands)[i].n60();
854
855		//      cout <<" muon mother="<< muon_mother <<endl;
856
#	Line 598 | Line 924 | void MuonAnalyzer::initialiseTree() {
924		muonTree->Branch("JetmatchedC",&JetmatchedC,"JetmatchedC/I");
925		muonTree->Branch("MuonmatchedGenMuon",&MuonmatchedGenMuon,"MuonmatchedGenMuon/I");
926
927	+	muonTree->Branch("Jet_E",&Jet_E,"Jet_E/F");
928		muonTree->Branch("Jet_Et",&Jet_Et,"Jet_Et/F");
929	<	muonTree->Branch("Jet_eta",&Jet_eta,"Jet_eta/F");
929	>	muonTree->Branch("Jet_eta",&Jet_eta,"Jet_eta/F");
930	>	muonTree->Branch("Jet_theta",&Jet_theta,"Jet_theta/F");
931	>	muonTree->Branch("Jet_P",&Jet_P,"Jet_P/F");
932		muonTree->Branch("Jet_Pt",&Jet_Pt,"Jet_Pt/F");
933	+	muonTree->Branch("Jet_Py",&Jet_Py,"Jet_Py/F");
934		muonTree->Branch("Jet_maxEInEmTowers",&Jet_maxEInEmTowers,"Jet_maxEInEmTowers/F");
935		muonTree->Branch("Jet_maxEInHadTowers",&Jet_maxEInHadTowers,"Jet_maxEInHadTowers/F");
936		muonTree->Branch("Jet_energyFractionHadronic",&Jet_energyFractionHadronic,"Jet_energyFractionHadronic/F");
#	Line 618 | Line 948 | void MuonAnalyzer::initialiseTree() {
948
949		muonTree->Branch("muon_Et",&muon_Et,"muon_Et/F");
950		muonTree->Branch("muon_eta",&muon_eta,"muon_eta/F");
951	<	muonTree->Branch("muon_Pt",&muon_Pt,"muon_Pt/F");
951	>	muonTree->Branch("muon_theta",&muon_theta,"muon_theta/F");
952	>	muonTree->Branch("muon_P",&muon_P,"muon_P/F");
953	>	muonTree->Branch("muon_Pt",&muon_Pt,"muon_Pt/F");
954	>	muonTree->Branch("muon_Pt_jet",&muon_Pt_jet,"muon_Pt_jet/F");
955	>	muonTree->Branch("muon_Py",&muon_Py,"muon_Py/F");
956
957		muonTree->Branch("B_Et",&B_Et,"B_Et/F");
958		muonTree->Branch("B_eta",&B_eta,"B_eta/F");
#	Line 630 | Line 964 | void MuonAnalyzer::initialiseTree() {
964
965		muonTree->Branch("gen_muon_Et",&gen_muon_Et,"gen_muon_Et/F");
966		muonTree->Branch("gen_muon_eta",&gen_muon_eta,"gen_muon_eta/F");
967	+	muonTree->Branch("gen_muon_P",&gen_muon_P,"gen_muon_P/F");
968		muonTree->Branch("gen_muon_Pt",&gen_muon_Pt,"gen_muon_Pt/F");
969
970		muonTree->Branch("dr_muon",&dr_muon,"dr_muon/F");
#	Line 641 | Line 976 | void MuonAnalyzer::initialiseTree() {
976
977		muonTree->Branch("W_mother_id",&W_mother_id,"W_mother_id/I");
978
979	<	muonTree->Branch("muon_global_chi2", &muon_global_chi2 , "muon_global_chi2/F");
980	<	muonTree->Branch("muon_global_p",&muon_global_p," muon_global_p/F");
981	<	muonTree->Branch("muon_global_pt",&muon_global_pt,  "muon_global_pt/F");
982	<	muonTree->Branch("muon_global_outerP",& muon_global_outerP,"muon_global_outerP/F");
983	<	muonTree->Branch("muon_global_outerPt",& muon_global_outerPt,"muon_global_outerPt/F");
984	<	muonTree->Branch("muon_global_ndof",&muon_global_ndof,"muon_global_ndof/F");
985	<	muonTree->Branch("muon_global_normalizedChi2",& muon_global_normalizedChi2,"muon_global_normalizedChi2/F");
979	>	muonTree->Branch("DT", &DT , "DT/I");
980	>	muonTree->Branch("DT_wheel", &DT_wheel , "DT_wheel/I");
981	>	muonTree->Branch("DT_sector", &DT_sector , "DT_sector/I");
982	>	muonTree->Branch("DT_station", &DT_station , "DT_station/I");
983	>	muonTree->Branch("DT_layer", &DT_layer , "DT_layer/I");
984	>	muonTree->Branch("DT_superlayer",&DT_superlayer," DT_superlayer/I");
985	>	muonTree->Branch("CSC", &CSC , "CSC/I");
986	>	muonTree->Branch("CSC_ring",& CSC_ring,"CSC_ring/I");
987	>	muonTree->Branch("CSC_station",& CSC_station,"CSC_station/I");
988	>	muonTree->Branch("CSC_endcap",& CSC_endcap,"CSC_endcap/I");
989	>	muonTree->Branch("CSC_chamber" ,& CSC_chamber,"CSC_chamber/I");
990	>	muonTree->Branch("SC_layer",& CSC_layer,"CSC_layer/I");
991	>	muonTree->Branch("RPC", &RPC , "RPC/I");
992	>	muonTree->Branch("RPC_layer",&RPC_layer,"RPC_layer/I");
993	>	muonTree->Branch("RPC_region",&RPC_region,"RPC_region/I");
994	>	muonTree->Branch("RPC_ring",&RPC_ring,"RPC_ring/I");
995	>	muonTree->Branch("RPC_sector",&RPC_sector,"RPC_sector/I");
996	>	muonTree->Branch("RPC_station",&RPC_station,"RPC_station/I");
997	>	muonTree->Branch("RPC_subsector",&RPC_subsector,"RPC_subsector/I");
998	>
999	>	muonTree->Branch("muon_global", &muon_global , "muon_global/I");
1000	>	muonTree->Branch("muon_global_chi2", &muon_global_chi2 , "muon_global_chi2/D");
1001	>	muonTree->Branch("muon_global_p",&muon_global_p," muon_global_p/D");
1002	>	muonTree->Branch("muon_global_pt",&muon_global_pt,  "muon_global_pt/D");
1003	>	muonTree->Branch("muon_global_outerP",& muon_global_outerP,"muon_global_outerP/D");
1004	>	muonTree->Branch("muon_global_outerPt",& muon_global_outerPt,"muon_global_outerPt/D");
1005	>	muonTree->Branch("muon_global_ndof",&muon_global_ndof,"muon_global_ndof/D");
1006	>	muonTree->Branch("muon_global_normalizedChi2",& muon_global_normalizedChi2,"muon_global_normalizedChi2/D");
1007		muonTree->Branch("muon_global_recHitsSize",&muon_global_recHitsSize,"muon_global_recHitsSize/I");
1008		muonTree->Branch("muon_global_numberOfLostHits",& muon_global_numberOfLostHits,"muon_global_numberOfLostHits/I");
1009		muonTree->Branch("muon_global_numberOfValidHits",&muon_global_numberOfValidHits,"muon_global_numberOfValidHits/I");
1010	<	muonTree->Branch("muon_global_innerPosition_x",& muon_global_innerPosition_x,"muon_global_innerPosition_x/F");
1011	<	muonTree->Branch("muon_global_innerPosition_y",& muon_global_innerPosition_y,"muon_global_innerPosition_y/F");
1012	<	muonTree->Branch("muon_global_innerPosition_z",& muon_global_innerPosition_z,"muon_global_innerPosition_z/F");
1013	<	muonTree->Branch("muon_global_outerPosition_x",& muon_global_outerPosition_x,"muon_global_outerPosition_x/F");
1014	<	muonTree->Branch("muon_global_outerPosition_y",& muon_global_outerPosition_y,"muon_global_outerPosition_y/F");
1015	<	muonTree->Branch("muon_global_outerPosition_z",& muon_global_outerPosition_z,"muon_global_outerPosition_z/F");
1016	<
1017	<	muonTree->Branch("muon_STA_chi2", &muon_STA_chi2 , "muon_STA_chi2/F");
1018	<	muonTree->Branch("muon_STA_p",&muon_STA_p," muon_STA_p/F");
1019	<	muonTree->Branch("muon_STA_pt",&muon_STA_pt,  "muon_STA_pt/F");
1020	<	muonTree->Branch("muon_STA_outerP",& muon_STA_outerP,"muon_STA_outerP/F");
1021	<	muonTree->Branch("muon_STA_outerPt",& muon_STA_outerPt,"muon_STA_outerPt/F");
1022	<	muonTree->Branch("muon_STA_ndof",&muon_STA_ndof,"muon_STA_ndof/F");
1023	<	muonTree->Branch("muon_STA_normalizedChi2",& muon_STA_normalizedChi2,"muon_STA_normalizedChi2/F");
1010	>	muonTree->Branch("muon_global_innerPosition_x",& muon_global_innerPosition_x,"muon_global_innerPosition_x/D");
1011	>	muonTree->Branch("muon_global_innerPosition_y",& muon_global_innerPosition_y,"muon_global_innerPosition_y/D");
1012	>	muonTree->Branch("muon_global_innerPosition_z",& muon_global_innerPosition_z,"muon_global_innerPosition_z/D");
1013	>	muonTree->Branch("muon_global_outerPosition_x",& muon_global_outerPosition_x,"muon_global_outerPosition_x/D");
1014	>	muonTree->Branch("muon_global_outerPosition_y",& muon_global_outerPosition_y,"muon_global_outerPosition_y/D");
1015	>	muonTree->Branch("muon_global_outerPosition_z",& muon_global_outerPosition_z,"muon_global_outerPosition_z/D");
1016	>	muonTree->Branch("muon_global_dz",&muon_global_dz,"muon_global_dz/D");
1017	>	muonTree->Branch("muon_global_dz_error",&muon_global_dz_error,"muon_global_dz_error/D");
1018	>	muonTree->Branch("muon_global_lasthit_x",&muon_global_lasthit_x,"muon_global_lasthit_x/D");
1019	>	muonTree->Branch("muon_global_lasthit_y",&muon_global_lasthit_y,"muon_global_lasthit_y/D");
1020	>	muonTree->Branch("muon_global_lasthit_z",&muon_global_lasthit_z,"muon_global_lasthit_z/D");
1021	>
1022	>	muonTree->Branch("muon_STA", &muon_STA , "muon_STA/I");
1023	>	muonTree->Branch("muon_STA_chi2", &muon_STA_chi2 , "muon_STA_chi2/D");
1024	>	muonTree->Branch("muon_STA_p",&muon_STA_p," muon_STA_p/D");
1025	>	muonTree->Branch("muon_STA_pt",&muon_STA_pt,  "muon_STA_pt/D");
1026	>	muonTree->Branch("muon_STA_outerP",& muon_STA_outerP,"muon_STA_outerP/D");
1027	>	muonTree->Branch("muon_STA_outerPt",& muon_STA_outerPt,"muon_STA_outerPt/D");
1028	>	muonTree->Branch("muon_STA_ndof",&muon_STA_ndof,"muon_STA_ndof/D");
1029	>	muonTree->Branch("muon_STA_normalizedChi2",& muon_STA_normalizedChi2,"muon_STA_normalizedChi2/D");
1030		muonTree->Branch("muon_STA_recHitsSize",&muon_STA_recHitsSize,"muon_STA_recHitsSize/I");
1031		muonTree->Branch("muon_STA_numberOfLostHits",& muon_STA_numberOfLostHits,"muon_STA_numberOfLostHits/I");
1032		muonTree->Branch("muon_STA_numberOfValidHits",&muon_STA_numberOfValidHits,"muon_STA_numberOfValidHits/I");
1033	<	muonTree->Branch("muon_STA_innerPosition_x",& muon_STA_innerPosition_x,"muon_STA_innerPosition_x/F");
1034	<	muonTree->Branch("muon_STA_innerPosition_y",& muon_STA_innerPosition_y,"muon_STA_innerPosition_y/F");
1035	<	muonTree->Branch("muon_STA_innerPosition_z",& muon_STA_innerPosition_z,"muon_STA_innerPosition_z/F");
1036	<	muonTree->Branch("muon_STA_outerPosition_x",& muon_STA_outerPosition_x,"muon_STA_outerPosition_x/F");
1037	<	muonTree->Branch("muon_STA_outerPosition_y",& muon_STA_outerPosition_y,"muon_STA_outerPosition_y/F");
1038	<	muonTree->Branch("muon_STA_outerPosition_z",& muon_STA_outerPosition_z,"muon_STA_outerPosition_z/F");
1039	<
1040	<	muonTree->Branch("muon_track_chi2", &muon_track_chi2 , "muon_track_chi2/F");
1041	<	muonTree->Branch("muon_track_p",&muon_track_p," muon_track_p/F");
1042	<	muonTree->Branch("muon_track_pt",&muon_track_pt,  "muon_track_pt/F");
1043	<	muonTree->Branch("muon_track_outerP",& muon_track_outerP,"muon_track_outerP/F");
1044	<	muonTree->Branch("muon_track_outerPt",& muon_track_outerPt,"muon_track_outerPt/F");
1045	<	muonTree->Branch("muon_track_ndof",&muon_track_ndof,"muon_track_ndof/F");
1046	<	muonTree->Branch("muon_track_normalizedChi2",& muon_track_normalizedChi2,"muon_track_normalizedChi2/F");
1033	>	muonTree->Branch("muon_STA_innerPosition_x",& muon_STA_innerPosition_x,"muon_STA_innerPosition_x/D");
1034	>	muonTree->Branch("muon_STA_innerPosition_y",& muon_STA_innerPosition_y,"muon_STA_innerPosition_y/D");
1035	>	muonTree->Branch("muon_STA_innerPosition_z",& muon_STA_innerPosition_z,"muon_STA_innerPosition_z/D");
1036	>	muonTree->Branch("muon_STA_outerPosition_x",& muon_STA_outerPosition_x,"muon_STA_outerPosition_x/D");
1037	>	muonTree->Branch("muon_STA_outerPosition_y",& muon_STA_outerPosition_y,"muon_STA_outerPosition_y/D");
1038	>	muonTree->Branch("muon_STA_outerPosition_z",& muon_STA_outerPosition_z,"muon_STA_outerPosition_z/D");
1039	>	muonTree->Branch("muon_STA_dz",&muon_STA_dz,"muon_STA_dz/D");
1040	>	muonTree->Branch("muon_STA_dz_error",&muon_STA_dz_error,"muon_STA_dz_error/D");
1041	>
1042	>	muonTree->Branch("muon_track", &muon_track , "muon_track/I");
1043	>	muonTree->Branch("muon_track_chi2", &muon_track_chi2 , "muon_track_chi2/D");
1044	>	muonTree->Branch("muon_track_p",&muon_track_p," muon_track_p/D");
1045	>	muonTree->Branch("muon_track_pt",&muon_track_pt,  "muon_track_pt/D");
1046	>	muonTree->Branch("muon_track_outerP",& muon_track_outerP,"muon_track_outerP/D");
1047	>	muonTree->Branch("muon_track_outerPt",& muon_track_outerPt,"muon_track_outerPt/D");
1048	>	muonTree->Branch("muon_track_ndof",&muon_track_ndof,"muon_track_ndof/D");
1049	>	muonTree->Branch("muon_track_normalizedChi2",& muon_track_normalizedChi2,"muon_track_normalizedChi2/D");
1050		muonTree->Branch("muon_track_recHitsSize",&muon_track_recHitsSize,"muon_track_recHitsSize/I");
1051		muonTree->Branch("muon_track_numberOfLostHits",& muon_track_numberOfLostHits,"muon_track_numberOfLostHits/I");
1052		muonTree->Branch("muon_track_numberOfValidHits",&muon_track_numberOfValidHits,"muon_track_numberOfValidHits/I");
1053	<	muonTree->Branch("muon_track_innerPosition_x",& muon_track_innerPosition_x,"muon_track_innerPosition_x/F");
1054	<	muonTree->Branch("muon_track_innerPosition_y",& muon_track_innerPosition_y,"muon_track_innerPosition_y/F");
1055	<	muonTree->Branch("muon_track_innerPosition_z",& muon_track_innerPosition_z,"muon_track_innerPosition_z/F");
1056	<	muonTree->Branch("muon_track_outerPosition_x",& muon_track_outerPosition_x,"muon_track_outerPosition_x/F");
1057	<	muonTree->Branch("muon_track_outerPosition_y",& muon_track_outerPosition_y,"muon_track_outerPosition_y/F");
1058	<	muonTree->Branch("muon_track_outerPosition_z",& muon_track_outerPosition_z,"muon_track_outerPosition_z/F");
1053	>	muonTree->Branch("muon_track_innerPosition_x",& muon_track_innerPosition_x,"muon_track_innerPosition_x/D");
1054	>	muonTree->Branch("muon_track_innerPosition_y",& muon_track_innerPosition_y,"muon_track_innerPosition_y/D");
1055	>	muonTree->Branch("muon_track_innerPosition_z",& muon_track_innerPosition_z,"muon_track_innerPosition_z/D");
1056	>	muonTree->Branch("muon_track_outerPosition_x",& muon_track_outerPosition_x,"muon_track_outerPosition_x/D");
1057	>	muonTree->Branch("muon_track_outerPosition_y",& muon_track_outerPosition_y,"muon_track_outerPosition_y/D");
1058	>	muonTree->Branch("muon_track_outerPosition_z",& muon_track_outerPosition_z,"muon_track_outerPosition_z/D");
1059	>	muonTree->Branch("muon_track_dz",&muon_track_dz,"muon_track_dz/D");
1060	>	muonTree->Branch("muon_track_dz_error",&muon_track_dz_error,"muon_track_dz_error/D");
1061	>
1062
1063		JetMuTree->Branch("nb_jet",&nb_jet,"nb_jet/I");
1064		JetMuTree->Branch("nb_jet_eta_cut",&nb_jet_eta_cut,"nb_jet_eta_cut/I");
#	Line 830 | Line 1198 | void MuonAnalyzer::matching_JetsWithMuon
1198		using namespace reco;
1199		using namespace std;
1200
1201	<	cout <<" ulazi u matching_JetsWithMuons" <<endl;
1201	>	//  cout <<" ulazi u matching_JetsWithMuons" <<endl;
1202
1203		int n1=0;
1204		vector<MatchingInfo> matching_Infos;
1205	<	cout <<"# jets="<<jets->size()<< "  # muons="<<cands->size() << endl;
1205	>	//  cout <<"# jets="<<jets->size()<< "  # muons="<<cands->size() << endl;
1206		for ( unsigned int i=0; i<jets->size(); i++ ) // po svim jetovima
1207		{
1208		//      cout <<"    next jet" <<endl;
#	Line 889 | Line 1257 | void MuonAnalyzer::matching_JetsWithMuon
1257
1258		}
1259
1260	<	cout <<" nakon pisanja u Muon_Jet_Matching[1]" << endl;
1260	>	//   cout <<" nakon pisanja u Muon_Jet_Matching[1]" << endl;
1261		for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
1262		match !=matching_Infos.end(); match++) { // po tablici dr,i,j
1263		//    cout <<" nakon pisanja u Muon_Jet_Matching[1]" << endl;
#	Line 901 | Line 1269 | void MuonAnalyzer::matching_JetsWithMuon
1269		const reco::Candidate * nesto=iter->second[j].pair.second;
1270		//      ::OverlapChecker overlap;
1271		//      if (overlap(*nesto,*daughter)){
1272	<	cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1272	>	//      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1273		//      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1274		//    }
1275		}
#	Line 922 | Line 1290 | void MuonAnalyzer::matching_JetsWithMuon
1290
1291		void MuonAnalyzer::matching_JetsWithB(const edm::Event& iEvent, Handle<reco::CaloJetCollection> jets){
1292
1293	<	cout <<" ulazi u matching_JetsWithB" <<endl;
1293	>	//  cout <<" ulazi u matching_JetsWithB" <<endl;
1294
1295		using namespace edm;
1296		using namespace reco;
#	Line 982 | Line 1350 | void MuonAnalyzer::matching_JetsWithB(co
1350
1351		int n1=0;
1352		vector<MatchingInfo> matching_Infos;
1353	<	cout <<"# jets="<<jets->size()<< "  # B hadrons="<<genBparticles.size() << endl;
1353	>	//  cout <<"# jets="<<jets->size()<< "  # B hadrons="<<genBparticles.size() << endl;
1354		for ( unsigned int i=0; i<genBparticles.size(); i++ ) // po svim MC B hadronima
1355		{
1356		//      cout <<"    next B hadron" <<endl;
#	Line 1037 | Line 1405 | void MuonAnalyzer::matching_JetsWithB(co
1405
1406		}
1407
1408	<	cout <<" nakon pisanja u B_Jet_Matching[1]" << endl;
1408	>	//   cout <<" nakon pisanja u B_Jet_Matching[1]" << endl;
1409		for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
1410		match !=matching_Infos.end(); match++) { // po tablici dr,i,j
1411		//    int j=0;
#	Line 1049 | Line 1417 | void MuonAnalyzer::matching_JetsWithB(co
1417		const reco::Candidate * nesto=iter->second[j].pair.second;
1418		//      ::OverlapChecker overlap;
1419		//      if (overlap(*nesto,*daughter)){
1420	<	cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1420	>	//      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1421		//        cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1422		//      }
1423		}
#	Line 1066 | Line 1434 | void MuonAnalyzer::matching_JetsWithB(co
1434
1435		void MuonAnalyzer::matching_JetsWithC(const edm::Event& iEvent, Handle<reco::CaloJetCollection> jets){
1436
1437	<	cout <<" ulazi u matching_JetsWithC" <<endl;
1437	>	//  cout <<" ulazi u matching_JetsWithC" <<endl;
1438
1439		using namespace edm;
1440		using namespace reco;
#	Line 1119 | Line 1487 | void MuonAnalyzer::matching_JetsWithC(co
1487
1488		int n1=0;
1489		vector<MatchingInfo> matching_Infos;
1490	<	cout <<"# jets="<<jets->size()<< "  # C hadrons="<<genCparticles.size() << endl;
1490	>	//  cout <<"# jets="<<jets->size()<< "  # C hadrons="<<genCparticles.size() << endl;
1491		for ( unsigned int i=0; i<genCparticles.size(); i++ ) // po svim MC B hadronima
1492		{
1493		//      cout <<"    next B hadron" <<endl;
#	Line 1174 | Line 1542 | void MuonAnalyzer::matching_JetsWithC(co
1542
1543		}
1544
1545	<	cout <<" nakon pisanja u C_Jet_Matching[1]" << endl;
1545	>	//   cout <<" nakon pisanja u C_Jet_Matching[1]" << endl;
1546		for (vector<MatchingInfo>::iterator match=matching_Infos.begin();
1547		match !=matching_Infos.end(); match++) { // po tablici dr,i,j
1548		for (map< int,
#	Line 1185 | Line 1553 | void MuonAnalyzer::matching_JetsWithC(co
1553		const reco::Candidate * nesto=iter->second[j].pair.second;
1554		//      ::OverlapChecker overlap;
1555		//      if (overlap(*nesto,*daughter)){
1556	<	cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1556	>	//      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1557		//      cout <<"*****dr="<< iter->second[j].delta_R<<endl;
1558		//    }
1559		}
#	Line 1258 | Line 1626 | const reco::Candidate * MuonAnalyzer::ge
1626		}
1627		}
1628
1629	<	//  return ;
1629	>	return 0;
1630		}
1631
1632

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines