TreeFiller/src/FillerEmbedWeight.cc

// $Id: FillerEmbedWeight.cc,v 1.3 2012/12/28 17:27:21 pharris Exp $

#include "MitProd/TreeFiller/interface/FillerEmbedWeight.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/EmbedWeightCol.h"
#include "MitProd/ObjectService/interface/ObjectService.h"
#include "SimDataFormats/GeneratorProducts/interface/GenFilterInfo.h"

using namespace std;
using namespace edm;
using namespace mithep;

//--------------------------------------------------------------------------------------------------
FillerEmbedWeight::FillerEmbedWeight(const ParameterSet &cfg, const char *name, bool active) : 
  BaseFiller(cfg,name,active),
  edmName_       (Conf().getUntrackedParameter<string>("edmName"       ,"generator_weight")),
  edmSpinnerName_(Conf().getUntrackedParameter<string>("edmSpinnerName","TauSpinnerRec")),
  edmMuEffName_  (Conf().getUntrackedParameter<string>("edmMuEffName"  ,"ZmumuEvtSelEffCorrWeightProducer")),
  edmMuRadName_  (Conf().getUntrackedParameter<string>("edmMuRadName"  ,"muonRadiationCorrWeightProducer")),
  edmKineReweightGenName_ (Conf().getUntrackedParameter<string>("edmKineReweightGenName"  ,"embeddingKineReweightGENembedding")),
  edmKineReweightRecName_ (Conf().getUntrackedParameter<string>("edmKineReweightRecName"  ,"embeddingKineReweightRECembedding")),

  genInfo_(Conf().getUntrackedParameter<bool>  ("useGenInfo","True")),
  recHit_ (Conf().getUntrackedParameter<bool>  ("useRecHit","True")),
  mitName_(Conf().getUntrackedParameter<string>("mitName",Names::gkEmbedWeightBrn)),
  embedWeight_(new mithep::EmbedWeightArr)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
FillerEmbedWeight::~FillerEmbedWeight()
{
  // Destructor.

   delete embedWeight_;
}

//--------------------------------------------------------------------------------------------------
void FillerEmbedWeight::BookDataBlock(TreeWriter &tws)
{
  // Add mets branch to tree.

  tws.AddBranch(mitName_,&embedWeight_);
  OS()->add<mithep::EmbedWeightArr>(embedWeight_,mitName_);
}

//--------------------------------------------------------------------------------------------------
void FillerEmbedWeight::FillDataBlock(const edm::Event      &event, 
                                      const edm::EventSetup &setup)  
{
  // Fill missing energy from edm collection into our collection.
  embedWeight_->Delete();
  
  double inEmbedWeightValue              = 0;
  double inSpinnerWeightValue            = 0;
  double inSpinnerFlipWeightValue        = 0;
  double inSpinnerPlusWeightValue        = 0;
  double inSpinnerMinusWeightValue       = 0;
  double inMuEffWeightValue              = 0;
  double inMuEffWeightUpValue            = 0;
  double inMuEffWeightDownValue          = 0;
  double inMuRadWeightValue              = 0;
  double inMuRadWeightUpValue            = 0;
  double inMuRadWeightDownValue          = 0;
  double inGenTau2PtVsGenTau1PtGenValue  = 0;
  double inGenTau2EtaVsGenTau1EtaGenValue = 0;
  double inDiTauMassVsGenDiTauPtGenValue = 0;
  double inGenTau2PtVsGenTau1PtRecValue  = 0;
  double inGenTau2EtaVsGenTau1EtaRecValue= 0;
  double inDiTauMassVsGenDiTauPtRecValue = 0;

  if(!genInfo_) { 
    Handle<double> hEmbedWeight;
    event.getByLabel(edm::InputTag(edmName_,"weight","EmbeddedRECO"),hEmbedWeight);
    inEmbedWeightValue = *(hEmbedWeight.product());  
  } else { 
    edm::Handle<GenFilterInfo> hGenFilterInfo;
    event.getByLabel(edm::InputTag(edmName_, "minVisPtFilter", "EmbeddedRECO"), hGenFilterInfo);
    inEmbedWeightValue = hGenFilterInfo->filterEfficiency();
  }    
  if(recHit_) { 
    Handle<double> hSpinnerWeight;
    event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWT","EmbeddedSPIN"),hSpinnerWeight);
    inSpinnerWeightValue = *(hSpinnerWeight.product());  

    Handle<double> hSpinnerWeightFlip;
    event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWTFlip","EmbeddedSPIN"),hSpinnerWeightFlip);
    inSpinnerFlipWeightValue = *(hSpinnerWeightFlip.product());  

    Handle<double> hSpinnerWeightMinus;
    event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWThplus","EmbeddedSPIN"),hSpinnerWeightMinus);
    inSpinnerMinusWeightValue = *(hSpinnerWeightMinus.product());  

    Handle<double> hSpinnerWeightPlus;
    event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWThminus","EmbeddedSPIN"),hSpinnerWeightPlus);
    inSpinnerPlusWeightValue = *(hSpinnerWeightPlus.product());  

    Handle<double> hMuEffWeight;
    event.getByLabel(edm::InputTag(edmMuEffName_,"weight","EmbeddedRECO"),hMuEffWeight);
    inMuEffWeightValue = *(hMuEffWeight.product());  

    Handle<double> hMuEffWeightUp;
    event.getByLabel(edm::InputTag(edmMuEffName_,"weightUp","EmbeddedRECO"),hMuEffWeightUp);
    inMuEffWeightUpValue = *(hMuEffWeightUp.product());  

    Handle<double> hMuEffWeightDown;
    event.getByLabel(edm::InputTag(edmMuEffName_,"weightDown","EmbeddedRECO"),hMuEffWeightDown);
    inMuEffWeightDownValue = *(hMuEffWeightDown.product());  

    Handle<double> hMuRadWeight;
    event.getByLabel(edm::InputTag(edmMuRadName_,"weight","EmbeddedRECO"),hMuRadWeight);
    inMuRadWeightValue = *(hMuRadWeight.product());  

    Handle<double> hMuRadWeightUp;
    event.getByLabel(edm::InputTag(edmMuRadName_,"weightUp","EmbeddedRECO"),hMuRadWeightUp);
    inMuRadWeightUpValue = *(hMuRadWeightUp.product());  

    Handle<double> hMuRadWeightDown;
    event.getByLabel(edm::InputTag(edmMuRadName_,"weightDown","EmbeddedRECO"),hMuRadWeightDown);
    inMuRadWeightDownValue = *(hMuRadWeightDown.product());  

    Handle<double> hGenTau2PtVsGenTau1PtGen;
    event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genTau2PtVsGenTau1Pt"),hGenTau2PtVsGenTau1PtGen);
    inGenTau2PtVsGenTau1PtGenValue = *(hGenTau2PtVsGenTau1PtGen.product());  

    Handle<double> hGenTau2EtaVsGenTau1EtaGen;
    event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genTau2EtaVsGenTau1Eta"),hGenTau2EtaVsGenTau1EtaGen);
    inGenTau2EtaVsGenTau1EtaGenValue = *(hGenTau2EtaVsGenTau1EtaGen.product());  

    Handle<double> hDiTauMassVsGenDiTauPtGen;
    event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genDiTauMassVsGenDiTauPt"),hDiTauMassVsGenDiTauPtGen);
    inDiTauMassVsGenDiTauPtGenValue = *(hDiTauMassVsGenDiTauPtGen.product());  

    Handle<double> hGenTau2PtVsGenTau1PtRec;
    event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genTau2PtVsGenTau1Pt"),hGenTau2PtVsGenTau1PtRec);
    inGenTau2PtVsGenTau1PtRecValue = *(hGenTau2PtVsGenTau1PtRec.product());  

    Handle<double> hGenTau2EtaVsGenTau1EtaRec;
    event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genTau2EtaVsGenTau1Eta"),hGenTau2EtaVsGenTau1EtaRec);
    inGenTau2EtaVsGenTau1EtaRecValue = *(hGenTau2EtaVsGenTau1EtaRec.product());  

    Handle<double> hDiTauMassVsGenDiTauPtRec;
    event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genDiTauMassVsGenDiTauPt"),hDiTauMassVsGenDiTauPtRec);
    inDiTauMassVsGenDiTauPtRecValue = *(hDiTauMassVsGenDiTauPtRec.product());  
  }
  const double inEmbedWeight        = inEmbedWeightValue;
  const double inSpinnerWeight      = inSpinnerWeightValue;
  const double inSpinnerFlipWeight  = inSpinnerFlipWeightValue;
  const double inSpinnerPlusWeight  = inSpinnerPlusWeightValue;
  const double inSpinnerMinusWeight = inSpinnerMinusWeightValue;
  const double inMuEffWeight        = inMuEffWeightValue;
  const double inMuEffWeightUp      = inMuEffWeightUpValue;
  const double inMuEffWeightDown    = inMuEffWeightDownValue;
  const double inMuRadWeight        = inMuRadWeightValue;
  const double inMuRadWeightUp      = inMuRadWeightUpValue;
  const double inMuRadWeightDown    = inMuRadWeightDownValue;
  const double inGenTau2PtVsGenTau1PtGen        = inGenTau2PtVsGenTau1PtGenValue;
  const double inGenTau2EtaVsGenTau1EtaGen      = inGenTau2EtaVsGenTau1EtaGenValue;
  const double inDiTauMassVsGenDiTauPtGen       = inDiTauMassVsGenDiTauPtGenValue;
  const double inGenTau2PtVsGenTau1PtRec        = inGenTau2PtVsGenTau1PtRecValue;
  const double inGenTau2EtaVsGenTau1EtaRec      = inGenTau2EtaVsGenTau1EtaRecValue;
  const double inDiTauMassVsGenDiTauPtRec       = inDiTauMassVsGenDiTauPtRecValue;
  
  mithep::EmbedWeight *embedWeight = embedWeight_->Allocate();
  new (embedWeight) mithep::EmbedWeight();

  embedWeight->SetGenWeight                (inEmbedWeight);
  embedWeight->SetSpinnerWeight            (inSpinnerWeight);
  embedWeight->SetSpinnerFlipWeight        (inSpinnerFlipWeight);
  embedWeight->SetSpinnerPlusWeight        (inSpinnerPlusWeight);
  embedWeight->SetSpinnerMinusWeight       (inSpinnerMinusWeight);
  embedWeight->SetMuEffWeight              (inMuEffWeight);
  embedWeight->SetMuEffWeightUp            (inMuEffWeightUp);
  embedWeight->SetMuEffWeightDown          (inMuEffWeightDown);
  embedWeight->SetMuRadWeight              (inMuRadWeight);
  embedWeight->SetMuRadWeightUp            (inMuRadWeightUp);
  embedWeight->SetMuRadWeightDown          (inMuRadWeightDown);
  embedWeight->SetGenTau2VsGenTau1PtGen    (inGenTau2PtVsGenTau1PtGen);
  embedWeight->SetGenTau2VsGenTau1EtaGen   (inGenTau2EtaVsGenTau1EtaGen);
  embedWeight->SetDiTauMassVsGenDiTauPtGen (inDiTauMassVsGenDiTauPtGen);
  embedWeight->SetGenTau2VsGenTau1PtRec    (inGenTau2PtVsGenTau1PtRec);
  embedWeight->SetGenTau2VsGenTau1EtaRec   (inGenTau2EtaVsGenTau1EtaRec);
  embedWeight->SetDiTauMassVsGenDiTauPtRec (inDiTauMassVsGenDiTauPtRec);
  embedWeight->SetWeight();
  embedWeight_->Trim();
}
Revision:	1.4
Committed:	Mon May 6 18:27:49 2013 UTC (12 years ago) by pharris
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_031, Mit_030, Mit_029c, Mit_029b
Changes since 1.3:	+130 -6 lines
Log Message:	Added RecHit Embedded Functionality
#	User	Rev	Content
1	pharris	1.4	// $Id: FillerEmbedWeight.cc,v 1.3 2012/12/28 17:27:21 pharris Exp $
2	pharris	1.1
3			#include "MitProd/TreeFiller/interface/FillerEmbedWeight.h"
4			#include "MitAna/DataTree/interface/Names.h"
5			#include "MitAna/DataTree/interface/EmbedWeightCol.h"
6			#include "MitProd/ObjectService/interface/ObjectService.h"
7	pharris	1.3	#include "SimDataFormats/GeneratorProducts/interface/GenFilterInfo.h"
8	pharris	1.1
9			using namespace std;
10			using namespace edm;
11			using namespace mithep;
12
13			//--------------------------------------------------------------------------------------------------
14			FillerEmbedWeight::FillerEmbedWeight(const ParameterSet &cfg, const char *name, bool active) :
15			BaseFiller(cfg,name,active),
16	pharris	1.4	edmName_ (Conf().getUntrackedParameter<string>("edmName" ,"generator_weight")),
17			edmSpinnerName_(Conf().getUntrackedParameter<string>("edmSpinnerName","TauSpinnerRec")),
18			edmMuEffName_ (Conf().getUntrackedParameter<string>("edmMuEffName" ,"ZmumuEvtSelEffCorrWeightProducer")),
19			edmMuRadName_ (Conf().getUntrackedParameter<string>("edmMuRadName" ,"muonRadiationCorrWeightProducer")),
20			edmKineReweightGenName_ (Conf().getUntrackedParameter<string>("edmKineReweightGenName" ,"embeddingKineReweightGENembedding")),
21			edmKineReweightRecName_ (Conf().getUntrackedParameter<string>("edmKineReweightRecName" ,"embeddingKineReweightRECembedding")),
22
23	pharris	1.3	genInfo_(Conf().getUntrackedParameter<bool> ("useGenInfo","True")),
24	pharris	1.4	recHit_ (Conf().getUntrackedParameter<bool> ("useRecHit","True")),
25	pharris	1.1	mitName_(Conf().getUntrackedParameter<string>("mitName",Names::gkEmbedWeightBrn)),
26			embedWeight_(new mithep::EmbedWeightArr)
27			{
28			// Constructor.
29			}
30
31			//--------------------------------------------------------------------------------------------------
32			FillerEmbedWeight::~FillerEmbedWeight()
33			{
34			// Destructor.
35
36			delete embedWeight_;
37			}
38
39			//--------------------------------------------------------------------------------------------------
40			void FillerEmbedWeight::BookDataBlock(TreeWriter &tws)
41			{
42			// Add mets branch to tree.
43
44			tws.AddBranch(mitName_,&embedWeight_);
45			OS()->add<mithep::EmbedWeightArr>(embedWeight_,mitName_);
46			}
47
48			//--------------------------------------------------------------------------------------------------
49			void FillerEmbedWeight::FillDataBlock(const edm::Event &event,
50			const edm::EventSetup &setup)
51			{
52			// Fill missing energy from edm collection into our collection.
53	pharris	1.2	embedWeight_->Delete();
54	pharris	1.3
55	pharris	1.4	double inEmbedWeightValue = 0;
56			double inSpinnerWeightValue = 0;
57			double inSpinnerFlipWeightValue = 0;
58			double inSpinnerPlusWeightValue = 0;
59			double inSpinnerMinusWeightValue = 0;
60			double inMuEffWeightValue = 0;
61			double inMuEffWeightUpValue = 0;
62			double inMuEffWeightDownValue = 0;
63			double inMuRadWeightValue = 0;
64			double inMuRadWeightUpValue = 0;
65			double inMuRadWeightDownValue = 0;
66			double inGenTau2PtVsGenTau1PtGenValue = 0;
67			double inGenTau2EtaVsGenTau1EtaGenValue = 0;
68			double inDiTauMassVsGenDiTauPtGenValue = 0;
69			double inGenTau2PtVsGenTau1PtRecValue = 0;
70			double inGenTau2EtaVsGenTau1EtaRecValue= 0;
71			double inDiTauMassVsGenDiTauPtRecValue = 0;
72
73	pharris	1.3	if(!genInfo_) {
74			Handle<double> hEmbedWeight;
75			event.getByLabel(edm::InputTag(edmName_,"weight","EmbeddedRECO"),hEmbedWeight);
76			inEmbedWeightValue = *(hEmbedWeight.product());
77			} else {
78			edm::Handle<GenFilterInfo> hGenFilterInfo;
79			event.getByLabel(edm::InputTag(edmName_, "minVisPtFilter", "EmbeddedRECO"), hGenFilterInfo);
80			inEmbedWeightValue = hGenFilterInfo->filterEfficiency();
81	pharris	1.4	}
82			if(recHit_) {
83			Handle<double> hSpinnerWeight;
84			event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWT","EmbeddedSPIN"),hSpinnerWeight);
85			inSpinnerWeightValue = *(hSpinnerWeight.product());
86
87			Handle<double> hSpinnerWeightFlip;
88			event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWTFlip","EmbeddedSPIN"),hSpinnerWeightFlip);
89			inSpinnerFlipWeightValue = *(hSpinnerWeightFlip.product());
90
91			Handle<double> hSpinnerWeightMinus;
92			event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWThplus","EmbeddedSPIN"),hSpinnerWeightMinus);
93			inSpinnerMinusWeightValue = *(hSpinnerWeightMinus.product());
94
95			Handle<double> hSpinnerWeightPlus;
96			event.getByLabel(edm::InputTag(edmSpinnerName_,"TauSpinnerWThminus","EmbeddedSPIN"),hSpinnerWeightPlus);
97			inSpinnerPlusWeightValue = *(hSpinnerWeightPlus.product());
98
99			Handle<double> hMuEffWeight;
100			event.getByLabel(edm::InputTag(edmMuEffName_,"weight","EmbeddedRECO"),hMuEffWeight);
101			inMuEffWeightValue = *(hMuEffWeight.product());
102
103			Handle<double> hMuEffWeightUp;
104			event.getByLabel(edm::InputTag(edmMuEffName_,"weightUp","EmbeddedRECO"),hMuEffWeightUp);
105			inMuEffWeightUpValue = *(hMuEffWeightUp.product());
106
107			Handle<double> hMuEffWeightDown;
108			event.getByLabel(edm::InputTag(edmMuEffName_,"weightDown","EmbeddedRECO"),hMuEffWeightDown);
109			inMuEffWeightDownValue = *(hMuEffWeightDown.product());
110
111			Handle<double> hMuRadWeight;
112			event.getByLabel(edm::InputTag(edmMuRadName_,"weight","EmbeddedRECO"),hMuRadWeight);
113			inMuRadWeightValue = *(hMuRadWeight.product());
114
115			Handle<double> hMuRadWeightUp;
116			event.getByLabel(edm::InputTag(edmMuRadName_,"weightUp","EmbeddedRECO"),hMuRadWeightUp);
117			inMuRadWeightUpValue = *(hMuRadWeightUp.product());
118
119			Handle<double> hMuRadWeightDown;
120			event.getByLabel(edm::InputTag(edmMuRadName_,"weightDown","EmbeddedRECO"),hMuRadWeightDown);
121			inMuRadWeightDownValue = *(hMuRadWeightDown.product());
122
123			Handle<double> hGenTau2PtVsGenTau1PtGen;
124			event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genTau2PtVsGenTau1Pt"),hGenTau2PtVsGenTau1PtGen);
125			inGenTau2PtVsGenTau1PtGenValue = *(hGenTau2PtVsGenTau1PtGen.product());
126
127			Handle<double> hGenTau2EtaVsGenTau1EtaGen;
128			event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genTau2EtaVsGenTau1Eta"),hGenTau2EtaVsGenTau1EtaGen);
129			inGenTau2EtaVsGenTau1EtaGenValue = *(hGenTau2EtaVsGenTau1EtaGen.product());
130
131			Handle<double> hDiTauMassVsGenDiTauPtGen;
132			event.getByLabel(edm::InputTag(edmKineReweightGenName_,"genDiTauMassVsGenDiTauPt"),hDiTauMassVsGenDiTauPtGen);
133			inDiTauMassVsGenDiTauPtGenValue = *(hDiTauMassVsGenDiTauPtGen.product());
134
135			Handle<double> hGenTau2PtVsGenTau1PtRec;
136			event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genTau2PtVsGenTau1Pt"),hGenTau2PtVsGenTau1PtRec);
137			inGenTau2PtVsGenTau1PtRecValue = *(hGenTau2PtVsGenTau1PtRec.product());
138
139			Handle<double> hGenTau2EtaVsGenTau1EtaRec;
140			event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genTau2EtaVsGenTau1Eta"),hGenTau2EtaVsGenTau1EtaRec);
141			inGenTau2EtaVsGenTau1EtaRecValue = *(hGenTau2EtaVsGenTau1EtaRec.product());
142
143			Handle<double> hDiTauMassVsGenDiTauPtRec;
144			event.getByLabel(edm::InputTag(edmKineReweightRecName_,"genDiTauMassVsGenDiTauPt"),hDiTauMassVsGenDiTauPtRec);
145			inDiTauMassVsGenDiTauPtRecValue = *(hDiTauMassVsGenDiTauPtRec.product());
146	pharris	1.3	}
147	pharris	1.4	const double inEmbedWeight = inEmbedWeightValue;
148			const double inSpinnerWeight = inSpinnerWeightValue;
149			const double inSpinnerFlipWeight = inSpinnerFlipWeightValue;
150			const double inSpinnerPlusWeight = inSpinnerPlusWeightValue;
151			const double inSpinnerMinusWeight = inSpinnerMinusWeightValue;
152			const double inMuEffWeight = inMuEffWeightValue;
153			const double inMuEffWeightUp = inMuEffWeightUpValue;
154			const double inMuEffWeightDown = inMuEffWeightDownValue;
155			const double inMuRadWeight = inMuRadWeightValue;
156			const double inMuRadWeightUp = inMuRadWeightUpValue;
157			const double inMuRadWeightDown = inMuRadWeightDownValue;
158			const double inGenTau2PtVsGenTau1PtGen = inGenTau2PtVsGenTau1PtGenValue;
159			const double inGenTau2EtaVsGenTau1EtaGen = inGenTau2EtaVsGenTau1EtaGenValue;
160			const double inDiTauMassVsGenDiTauPtGen = inDiTauMassVsGenDiTauPtGenValue;
161			const double inGenTau2PtVsGenTau1PtRec = inGenTau2PtVsGenTau1PtRecValue;
162			const double inGenTau2EtaVsGenTau1EtaRec = inGenTau2EtaVsGenTau1EtaRecValue;
163			const double inDiTauMassVsGenDiTauPtRec = inDiTauMassVsGenDiTauPtRecValue;
164
165	pharris	1.1	mithep::EmbedWeight *embedWeight = embedWeight_->Allocate();
166	pharris	1.4	new (embedWeight) mithep::EmbedWeight();
167
168			embedWeight->SetGenWeight (inEmbedWeight);
169			embedWeight->SetSpinnerWeight (inSpinnerWeight);
170			embedWeight->SetSpinnerFlipWeight (inSpinnerFlipWeight);
171			embedWeight->SetSpinnerPlusWeight (inSpinnerPlusWeight);
172			embedWeight->SetSpinnerMinusWeight (inSpinnerMinusWeight);
173			embedWeight->SetMuEffWeight (inMuEffWeight);
174			embedWeight->SetMuEffWeightUp (inMuEffWeightUp);
175			embedWeight->SetMuEffWeightDown (inMuEffWeightDown);
176			embedWeight->SetMuRadWeight (inMuRadWeight);
177			embedWeight->SetMuRadWeightUp (inMuRadWeightUp);
178			embedWeight->SetMuRadWeightDown (inMuRadWeightDown);
179			embedWeight->SetGenTau2VsGenTau1PtGen (inGenTau2PtVsGenTau1PtGen);
180			embedWeight->SetGenTau2VsGenTau1EtaGen (inGenTau2EtaVsGenTau1EtaGen);
181			embedWeight->SetDiTauMassVsGenDiTauPtGen (inDiTauMassVsGenDiTauPtGen);
182			embedWeight->SetGenTau2VsGenTau1PtRec (inGenTau2PtVsGenTau1PtRec);
183			embedWeight->SetGenTau2VsGenTau1EtaRec (inGenTau2EtaVsGenTau1EtaRec);
184			embedWeight->SetDiTauMassVsGenDiTauPtRec (inDiTauMassVsGenDiTauPtRec);
185			embedWeight->SetWeight();
186	pharris	1.1	embedWeight_->Trim();
187			}