diff --git a/plugins/MiniEffiTree.cc b/plugins/MiniEffiTree.cc
new file mode 100644
index 0000000..ed68e35
--- /dev/null
+++ b/plugins/MiniEffiTree.cc
@@ -0,0 +1,540 @@
+/*
+ * =====================================================================================
+ *
+ *       Filename:  MiniEffiTree.cc
+ *        Company:  UW Madison
+ *
+ * =====================================================================================
+ */
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/EDAnalyzer.h"
+
+#include "DataFormats/Candidate/interface/Candidate.h"
+#include "DataFormats/L1Trigger/interface/L1JetParticle.h"
+#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
+
+#include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h"
+
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CommonTools/UtilAlgos/interface/TFileService.h"
+
+#include "DataFormats/Math/interface/deltaPhi.h"
+
+#include "TTree.h"
+
+typedef std::vector<edm::InputTag> VInputTag;
+
+class MiniEffiTree : public edm::EDAnalyzer {
+ public:
+  MiniEffiTree(const edm::ParameterSet& pset);
+  virtual ~MiniEffiTree();
+  void analyze(const edm::Event& evt, const edm::EventSetup& es);
+ private:
+  VInputTag src_;
+  VInputTag L1Src_;
+  VInputTag srcJet_;
+  VInputTag L1SrcJet_;
+  VInputTag srcEg_;
+  VInputTag L1SrcEg_;
+  VInputTag metSrc_;
+  VInputTag L1MetSrc_;
+
+  TTree* tree;
+  std::vector<Float_t>* pts_;
+  std::vector<Float_t>* etas_;
+  std::vector<Float_t>* phis_;
+  std::vector<Int_t>* L1matches_;
+
+  std::vector<Float_t>* L1pts_;
+  std::vector<Float_t>* L1etas_;
+  std::vector<Float_t>* L1phis_;
+  std::vector<Float_t>* L1charges_;
+
+  std::vector<Float_t>* L1Matchedpts_;
+  std::vector<Float_t>* L1Matchedetas_;
+  std::vector<Float_t>* L1Matchedphis_;
+  std::vector<Float_t>* L1Matchedcharges_;
+
+  std::vector<Float_t>* L1dRToJet_;
+  std::vector<Float_t>* L1MatchedJet_;
+
+  std::vector<Float_t>* jetpts_;
+  std::vector<Float_t>* jetetas_;
+  std::vector<Float_t>* jetphis_;
+  std::vector<Int_t>* L1Jetmatches_;
+
+  std::vector<Float_t>* L1Jetpts_;
+  std::vector<Float_t>* L1Jetetas_;
+  std::vector<Float_t>* L1Jetphis_;
+
+  std::vector<Float_t>* egpts_;
+  std::vector<Float_t>* egetas_;
+  std::vector<Float_t>* egphis_;
+  std::vector<Int_t>* egTaumatches_;
+  std::vector<Float_t>* dREgTau_;
+
+  std::vector<Float_t>* L1Egpts_;
+  std::vector<Float_t>* L1Egetas_;
+  std::vector<Float_t>* L1Egphis_;
+  std::vector<Int_t>* L1EgTaumatches_;
+  std::vector<Float_t>* dRL1EgTau_;
+
+  Float_t L1Met_Et_;
+  Float_t L1Met_Phi_;
+  Float_t met_Et_;
+  Float_t met_Phi_;
+
+
+  UInt_t run_;
+  UInt_t lumi_;
+  ULong64_t event_;
+  Int_t nPU_;
+ 
+  Int_t count_;
+};
+
+MiniEffiTree::MiniEffiTree(const edm::ParameterSet& pset) {
+ // Initialize the ntuple builder
+ edm::Service<TFileService> fs;
+ tree = fs->make<TTree>("Ntuple", "Ntuple");
+ pts_ = new std::vector<Float_t>();
+ etas_ = new std::vector<Float_t>();
+ phis_ = new std::vector<Float_t>();
+ L1matches_ = new std::vector<Int_t>();
+
+
+ L1pts_ = new std::vector<Float_t>();
+ L1etas_ = new std::vector<Float_t>();
+ L1phis_ = new std::vector<Float_t>();
+ L1charges_ = new std::vector<Float_t>();
+
+ L1Matchedpts_ = new std::vector<Float_t>();
+ L1Matchedetas_ = new std::vector<Float_t>();
+ L1Matchedphis_ = new std::vector<Float_t>();
+ L1Matchedcharges_ = new std::vector<Float_t>();
+
+ L1dRToJet_ = new std::vector<Float_t>();
+ L1MatchedJet_  = new std::vector<Float_t>();
+
+
+ jetpts_ = new std::vector<Float_t>();
+ jetetas_ = new std::vector<Float_t>();
+ jetphis_ = new std::vector<Float_t>();
+ L1Jetmatches_ = new std::vector<Int_t>();
+
+ L1Jetpts_ = new std::vector<Float_t>();
+ L1Jetetas_ = new std::vector<Float_t>();
+ L1Jetphis_ = new std::vector<Float_t>();
+
+ egpts_ = new std::vector<Float_t>();
+ egetas_ = new std::vector<Float_t>();
+ egphis_ = new std::vector<Float_t>();
+ egTaumatches_ = new std::vector<Int_t>();
+ dREgTau_ = new std::vector<Float_t>();
+
+ L1Egpts_ = new std::vector<Float_t>();
+ L1Egetas_ = new std::vector<Float_t>();
+ L1Egphis_ = new std::vector<Float_t>();
+ L1EgTaumatches_ = new std::vector<Int_t>();
+ dRL1EgTau_ = new std::vector<Float_t>();
+
+ tree->Branch("pt", "std::vector<float>", &pts_);
+ tree->Branch("eta", "std::vector<float>", &etas_);
+ tree->Branch("phi", "std::vector<float>", &phis_);
+ tree->Branch("L1matches", "std::vector<int>", &L1matches_);
+
+ tree->Branch("L1pt", "std::vector<float>", &L1pts_);
+ tree->Branch("L1eta", "std::vector<float>", &L1etas_);
+ tree->Branch("L1phi", "std::vector<float>", &L1phis_);
+ tree->Branch("L1charge", "std::vector<float>", &L1charges_);
+
+ tree->Branch("L1Matchedpt", "std::vector<float>", &L1Matchedpts_);
+ tree->Branch("L1Matchedeta", "std::vector<float>", &L1Matchedetas_);
+ tree->Branch("L1Matchedphi", "std::vector<float>", &L1Matchedphis_);
+ tree->Branch("L1Matchedcharge", "std::vector<float>", &L1Matchedcharges_);
+
+ tree->Branch("L1dRToJet", "std::vector<float>", &L1dRToJet_);
+ tree->Branch("L1MatchedJet", "std::vector<float>", &L1MatchedJet_);
+
+ tree->Branch("jetpt", "std::vector<float>", &jetpts_);
+ tree->Branch("jeteta", "std::vector<float>", &jetetas_);
+ tree->Branch("jetphi", "std::vector<float>", &jetphis_);
+ tree->Branch("L1Jetmatches", "std::vector<int>", &L1Jetmatches_);
+
+ tree->Branch("L1Jetpt", "std::vector<float>", &L1Jetpts_);
+ tree->Branch("L1Jeteta", "std::vector<float>", &L1Jetetas_);
+ tree->Branch("L1Jetphi", "std::vector<float>", &L1Jetphis_);
+
+ tree->Branch("egpt", "std::vector<float>", &egpts_);
+ tree->Branch("egeta", "std::vector<float>", &egetas_);
+ tree->Branch("egphi", "std::vector<float>", &egphis_);
+ tree->Branch("egTaumatches", "std::vector<int>", &egTaumatches_);
+ tree->Branch("dREgTau", "std::vector<float>", &dREgTau_);
+
+ tree->Branch("L1Egpt", "std::vector<float>", &L1Egpts_);
+ tree->Branch("L1Egeta", "std::vector<float>", &L1Egetas_);
+ tree->Branch("L1Egphi", "std::vector<float>", &L1Egphis_);
+ tree->Branch("L1EgTaumatches", "std::vector<int>", &L1EgTaumatches_);
+ tree->Branch("dRL1EgTau" , "std::vector<float>", &dRL1EgTau_);
+
+ tree->Branch("L1Met_Et", &L1Met_Et_, "L1Met_Et/F");
+ tree->Branch("L1Met_Phi", &L1Met_Phi_, "L1Met_Phi/F");
+ tree->Branch("met_Et", &met_Et_, "met_Et/F");
+ tree->Branch("met_Phi", &met_Phi_, "met_Phi/F");
+
+ tree->Branch("run", &run_, "run/i");
+ tree->Branch("lumi", &lumi_, "lumi/i");
+ tree->Branch("evt", &event_, "evt/l");
+ tree->Branch("nPU", &nPU_, "nPU/i");
+
+ src_ = pset.getParameter<VInputTag>("src");
+ L1Src_ = pset.getParameter<VInputTag>("L1Src");
+ srcJet_ = pset.getParameter<VInputTag>("srcJet");
+ L1SrcJet_ = pset.getParameter<VInputTag>("L1SrcJet");
+ srcEg_ = pset.getParameter<VInputTag>("srcEg");
+ L1SrcEg_ = pset.getParameter<VInputTag>("L1SrcEg");
+ metSrc_ = pset.getParameter<VInputTag>("metSrc");
+ L1MetSrc_ = pset.getParameter<VInputTag>("L1MetSrc");
+
+ count_=0;
+}
+
+MiniEffiTree::~MiniEffiTree() {
+ delete pts_;
+ delete etas_;
+ delete phis_;
+ delete L1matches_;
+ delete L1pts_;
+ delete L1phis_;
+ delete L1etas_;
+ delete L1charges_;
+ delete L1Matchedpts_;
+ delete L1Matchedphis_;
+ delete L1Matchedetas_;
+ delete L1Matchedcharges_;
+ delete jetpts_;
+ delete jetetas_;
+ delete jetphis_;
+ delete L1Jetmatches_;
+ delete L1Jetpts_;
+ delete L1Jetphis_;
+ delete L1Jetetas_;
+
+ delete egpts_;
+ delete egetas_;
+ delete egphis_;
+ delete egTaumatches_;
+ delete dREgTau_;
+ delete L1Egpts_;
+ delete L1Egphis_;
+ delete L1Egetas_;
+ delete L1EgTaumatches_;
+ delete dRL1EgTau_;
+
+ delete L1MatchedJet_;
+ delete L1dRToJet_;
+}
+
+
+namespace {
+
+ // Predicate to sort candidates by descending pt
+ class CandPtSorter {
+  public:
+   bool operator()(const reco::Candidate* candA, const reco::Candidate* candB)
+    const {
+     return candA->pt() > candB->pt();
+    }
+ };
+
+ // Turn a set of InputTags into a colleciton of candidate pointers.
+ std::vector<const reco::Candidate*> getCollections(
+   const edm::Event& evt, const VInputTag& collections) {
+  std::vector<const reco::Candidate*> output;
+  // Loop over collections
+  for (size_t i = 0; i < collections.size(); ++i) {
+   edm::Handle<edm::View<reco::Candidate> > handle;
+   evt.getByLabel(collections[i], handle);
+   // Loop over objects in current collection
+   for (size_t j = 0; j < handle->size(); ++j) {
+    const reco::Candidate& object = handle->at(j);
+    output.push_back(&object);
+   }
+  }
+  return output;
+ }
+
+}
+
+void MiniEffiTree::analyze(const edm::Event& evt, const edm::EventSetup& es) {
+
+ count_++;
+
+ // Get the objects.
+ std::vector<const reco::Candidate*> objects = getCollections(
+   evt, src_);
+ std::vector<const reco::Candidate*> L1Objects = getCollections(
+   evt, L1Src_);
+ std::vector<const reco::Candidate*> jetObjects = getCollections(
+   evt, srcJet_);
+ std::vector<const reco::Candidate*> L1JetObjects = getCollections(
+   evt, L1SrcJet_);
+ std::vector<const reco::Candidate*> egObjects = getCollections(
+   evt, srcEg_);
+ std::vector<const reco::Candidate*> L1EgObjects = getCollections(
+   evt, L1SrcEg_);
+ std::vector<const reco::Candidate*> metObject = getCollections(
+   evt, metSrc_);
+ std::vector<const reco::Candidate*> L1MetObject = getCollections(
+   evt, L1MetSrc_);
+
+ std::sort(objects.begin(), objects.end(), CandPtSorter());
+ std::sort(L1Objects.begin(), L1Objects.end(), CandPtSorter());
+
+
+
+
+ // Clear previous event's objects
+ pts_->clear();
+ etas_->clear();
+ phis_->clear();
+ L1matches_->clear();
+ L1pts_->clear();
+ L1etas_->clear();
+ L1phis_->clear();
+ L1charges_->clear();
+ L1Matchedpts_->clear();
+ L1Matchedetas_->clear();
+ L1Matchedphis_->clear();
+ L1Matchedcharges_->clear();
+ jetpts_->clear();
+ jetetas_->clear();
+ jetphis_->clear();
+ L1Jetmatches_->clear();
+ L1Jetpts_->clear();
+ L1Jetetas_->clear();
+ L1Jetphis_->clear();
+ egpts_->clear();
+ egetas_->clear();
+ egphis_->clear();
+ egTaumatches_->clear();
+ L1Egpts_->clear();
+ L1Egphis_->clear();
+ L1Egetas_->clear();
+ L1EgTaumatches_->clear();
+ L1dRToJet_->clear();
+ L1MatchedJet_->clear();
+
+ // Setup meta info
+ run_ = evt.id().run();
+ lumi_ = evt.id().luminosityBlock();
+ event_ = evt.id().event();
+
+ edm::Handle<std::vector<PileupSummaryInfo> > PupInfo;
+ evt.getByLabel("addPileupInfo", PupInfo);
+
+ nPU_=-1;
+ for(std::vector<PileupSummaryInfo>::const_iterator i = PupInfo->begin();
+   i!=PupInfo->end();++i) {
+  int BX = i->getBunchCrossing();
+  if(BX==0) {
+   nPU_ =i->getTrueNumInteractions();
+   nPU_=i->getPU_NumInteractions();
+  }
+ }
+ 
+
+// std::cout<<"----------------------------"<<count_<<std::endl;
+
+// std::cout<<"Trigger Objects!"<<std::endl;
+ for (size_t i = 0; i < objects.size(); ++i) {
+//  std::cout<<objects[i]->pt()<<"   "<<objects[i]->eta()<<"   "<<objects[i]->phi()<<std::endl;
+  pts_->push_back(objects[i]->pt());
+  etas_->push_back(objects[i]->eta());
+  phis_->push_back(objects[i]->phi());
+ }
+
+ //std::cout<<"L1 Objects!"<<std::endl;
+ for (size_t i = 0; i < L1Objects.size(); ++i) {
+  //std::cout<<L1Objects[i]->pt()<<"   "<<L1Objects[i]->eta()<<"   "<<L1Objects[i]->phi()<<std::endl;
+  L1pts_->push_back(L1Objects[i]->pt());
+  L1etas_->push_back(L1Objects[i]->eta());
+  L1phis_->push_back(L1Objects[i]->phi());
+  L1charges_->push_back(L1Objects[i]->charge());
+ }
+
+ for (size_t i = 0; i < egObjects.size(); ++i) {
+//  std::cout<<objects[i]->pt()<<"   "<<objects[i]->eta()<<"   "<<objects[i]->phi()<<std::endl;
+  egpts_->push_back(egObjects[i]->pt());
+  egetas_->push_back(egObjects[i]->eta());
+  egphis_->push_back(egObjects[i]->phi());
+ }
+
+// std::cout<<"Gen Objects!"<<std::endl;
+ for (size_t i = 0; i < L1EgObjects.size(); ++i) {
+//  std::cout<<L1Objects[i]->pt()<<"   "<<L1Objects[i]->eta()<<"   "<<L1Objects[i]->phi()<<std::endl;
+  L1Egpts_->push_back(L1EgObjects[i]->pt());
+  L1Egetas_->push_back(L1EgObjects[i]->eta());
+  L1Egphis_->push_back(L1EgObjects[i]->phi());
+ }
+
+ for (size_t i =0; i < objects.size(); ++i){
+  int matchj=-1;
+  double minAngle=0.5;
+  for (size_t j=0; j<L1Objects.size(); ++j){
+   //double deltaEta=(etas_->at(j) - L1Objects[i]->eta() );
+   //double deltaPhi=reco::deltaPhi(phis_->at(j),L1Objects[i]->phi()); 
+   //double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi)   ;
+   double deltaEta=(objects[i]->eta() - L1Objects[j]->eta() );
+   double deltaPhi=reco::deltaPhi(objects[i]->phi(),L1Objects[j]->phi()); 
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi);
+   std::cout << "pt, L1pt: " << objects[i]->pt() <<", "<<L1Objects[j]->pt() <<", "<<std::endl;
+
+   std::cout <<"dEta, dPhi, dR: " << deltaEta << ", " << deltaPhi << ", " << dR << std::endl;
+   if(dR<minAngle) {minAngle=dR; 
+      matchj = j;
+      std::cout << "dR < minAngle, matched!" << std::endl;}
+  }
+  for (size_t j=0; j<L1Objects.size(); ++j){
+    if (j == matchj){
+      L1matches_->push_back(1);
+      std::cout << "pushing back 1 for match pt, L1pt: " << objects[i]->pt() <<", "<<L1Objects[j]->pt() <<std::endl;
+      L1Matchedpts_->push_back(L1Objects[j]->pt());
+      L1Matchedetas_->push_back(L1Objects[j]->eta());
+      L1Matchedphis_->push_back(L1Objects[j]->phi());
+      L1Matchedcharges_->push_back(L1Objects[j]->charge());
+    }
+//    else{
+ //     L1matches_->push_back(-1);
+  //    std::cout << "pushing back -1 for nonmatch pt, L1pt :" << objects[i]->pt() <<", "<<L1Objects[j]->pt() <<std::endl;
+   // }
+  }
+ }
+
+
+ /*
+ for (size_t i =0; i < objects.size(); ++i){
+  int match=-1;
+  //double minAngle=0.5;
+  double minAngle = 6.0;
+  std::cout << "starting objects loop" << std::endl;
+  std::cout << egObjects.size() << std::endl;
+  for (size_t j=0; j<egObjects.size(); ++j){
+   std::cout << "starting eg objects loop" << std::endl;
+   double deltaEta=(objects[i]->eta() - egObjects[j]->eta() );
+   double deltaPhi=reco::deltaPhi(objects[i]->phi(),egObjects[j]->phi()); 
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi);
+
+   std::cout <<"EGdEta, EGdPhi, EGdR " << deltaEta << " " << deltaPhi << " " << dR << std::endl;
+   if(dR<minAngle) {minAngle=dR; match=j;}
+  }
+  egTaumatches_->push_back(match);
+  dREgTau_->push_back(minAngle);
+  
+ }
+ */
+
+
+ for (size_t i =0; i < L1Objects.size(); ++i){
+  int match=-1;
+  //double minAngle=0.5;
+  double minAngle = 6.0;
+  for (size_t j=0; j<L1EgObjects.size(); ++j){
+   double deltaEta=(L1Objects[i]->eta() - L1EgObjects[j]->eta() );
+   double deltaPhi=reco::deltaPhi(L1Objects[i]->phi(),L1EgObjects[j]->phi()); 
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi);
+
+   std::cout <<"L1EGdEta, L1EGdPhi, L1EGdR " << deltaEta << " " << deltaPhi << " " << dR << std::endl;
+   if(dR<minAngle) {minAngle=dR; match=j;}
+  }
+  //L1EgTaumatches_->push_back(match);
+  //dRL1EgTau_->push_back(minAngle);
+ }
+
+
+
+//  std::cout<<"-----> matched to"<<match<<std::endl;
+/*
+  double closestDR=10e6;
+  double JET=0;
+ for (size_t j = 0; j < L1JetObjects.size(); ++j) {
+   double deltaEta=(L1etas_->at(i) - L1JetObjects[j]->eta() );
+   double deltaPhi=reco::deltaPhi(L1phis_->at(i),L1JetObjects[j]->phi());
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi)   ;
+   if(dR<0.05) {
+                continue;
+   }  
+   if(dR<closestDR) {closestDR=dR;
+                    JET=L1JetObjects[j]->pt(); }
+ }
+ if (closestDR < 1000){
+   L1dRToJet_->push_back(closestDR);
+ }
+ else{
+   L1dRToJet_->push_back(-5);
+ }
+ L1MatchedJet_->push_back(JET);
+*/
+ 
+
+
+// std::cout<<"jet Objects!"<<std::endl;
+ for (size_t i = 0; i < jetObjects.size(); ++i) {
+//  std::cout<<jetObjects[i]->pt()<<"   "<<jetObjects[i]->eta()<<"   "<<jetObjects[i]->phi()<<std::endl;
+  jetpts_->push_back(jetObjects[i]->pt());
+  jetetas_->push_back(jetObjects[i]->eta());
+  jetphis_->push_back(jetObjects[i]->phi());
+ }
+
+// std::cout<<"Gen Jet Objects!"<<std::endl;
+ for (size_t i = 0; i < L1JetObjects.size(); ++i) {
+
+  bool isEle=false;
+  for (size_t j=0; j<L1etas_->size(); j++){
+   double deltaEta=(L1etas_->at(j) - L1JetObjects[i]->eta() );
+   double deltaPhi=reco::deltaPhi(L1phis_->at(j),L1JetObjects[i]->phi());
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi)   ;
+   if(dR<0.05) {isEle=true;}
+  }
+  if (isEle) continue;
+
+  if(L1JetObjects[i]->pt()<10) continue;
+//  std::cout<<L1JetObjects[i]->pt()<<"   "<<L1JetObjects[i]->eta()<<"   "<<L1JetObjects[i]->phi()<<std::endl;
+  L1Jetpts_->push_back(L1JetObjects[i]->pt());
+  L1Jetetas_->push_back(L1JetObjects[i]->eta());
+  L1Jetphis_->push_back(L1JetObjects[i]->phi());
+  int match=-1;
+  double minAngle=2;
+  for (size_t j=0; j<jetpts_->size(); j++){
+   double deltaEta=(jetetas_->at(j) - L1JetObjects[i]->eta() );
+   double deltaPhi=reco::deltaPhi(jetphis_->at(j),L1JetObjects[i]->phi());
+   double dR=sqrt( deltaEta*deltaEta + deltaPhi*deltaPhi)   ;
+   if(dR<minAngle) {minAngle=dR; match=j;}
+  }
+  L1Jetmatches_->push_back(match);
+//  std::cout<<"-----> matched to"<<match<<std::endl;
+ }
+
+// std::cout<<"MET ?"<<std::endl;
+ met_Et_=-10, met_Phi_=-10,L1Met_Et_=-10, L1Met_Phi_=-10;
+
+ if(metObject.size()==0) {std::cout<<"?????"<<std::endl;}
+ else{ met_Et_=metObject[0]->pt();
+       met_Phi_=metObject[0]->phi();
+  //     std::cout<<"MET: "<<met_Et_<<"   "<<met_Phi_<<std::endl;
+ }
+ if(L1MetObject.size()==0) { std::cout<<"?????"<<std::endl; }
+ else{ L1Met_Et_=L1MetObject[0]->pt();
+       L1Met_Phi_=L1MetObject[0]->phi();
+//       std::cout<<"GenMET: "<<L1Met_Et_<<"   "<<L1Met_Phi_<<std::endl;
+ }
+
+ tree->Fill();
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(MiniEffiTree);
diff --git a/plugins/RateTree.cc b/plugins/RateTree.cc
index a0ef56b..29a0b40 100644
--- a/plugins/RateTree.cc
+++ b/plugins/RateTree.cc
@@ -77,7 +77,9 @@ class RateTree : public edm::EDAnalyzer {
     std::vector<Float_t>* puEM_;
     std::vector<Float_t>* puUICEM_;
     std::vector<Float_t>* effArea_;
+    std::vector<Float_t>* eneighbor_;
     std::vector<bool>* taus_;
+    std::vector<bool>* tausneighbor_;
     std::vector<bool>* mips_;
 
 };
@@ -89,7 +91,9 @@ RateTree::RateTree(const edm::ParameterSet& pset) {
   pts_ = new std::vector<Float_t>();
   etas_ = new std::vector<Float_t>();
   phis_ = new std::vector<Float_t>();
+  eneighbor_ = new std::vector<Float_t>();
   taus_ = new std::vector<bool>();
+  tausneighbor_ = new std::vector<bool>();
   mips_ = new std::vector<bool>();
 
 
@@ -162,7 +166,9 @@ RateTree::RateTree(const edm::ParameterSet& pset) {
     tree->Branch("puEM", "std::vector<float>", &puEM_);
     tree->Branch("puUICEM", "std::vector<float>", &puUICEM_);
     tree->Branch("effArea", "std::vector<float>", &effArea_);
+    tree->Branch("associated4x4Et", "std::vector<float>",&eneighbor_);
     tree->Branch("tauVeto", "std::vector<bool>", &taus_);
+    tree->Branch("associated4x4Tau","std::vector<bool>",&tausneighbor_);
     tree->Branch("mipBit", "std::vector<bool>", &mips_);
 
     // Now add nice aliases so the same draw commands work for rate/eff
@@ -183,6 +189,7 @@ RateTree::RateTree(const edm::ParameterSet& pset) {
 
     tree->SetAlias("l1gEllIso", "ellIso");
     tree->SetAlias("l1gTauVeto", "tauVeto");
+    tree->SetAlias("l1gTauVetoNeighbor","associated4x4Tau");
     tree->SetAlias("l1gMIP", "mipBit");
 
     tree->SetAlias("l1gPU", "pu");
@@ -228,7 +235,9 @@ RateTree::~RateTree() {
   delete puUICEM_;
   delete effArea_;
   delete mips_;
+  delete eneighbor_;
   delete taus_;
+  delete tausneighbor_;
 }
 
 
@@ -303,7 +312,9 @@ void RateTree::analyze(const edm::Event& evt, const edm::EventSetup& es) {
   puEM_->clear();
   puUICEM_->clear();
   effArea_->clear();
+  eneighbor_->clear();
   taus_->clear();
+  tausneighbor_->clear();
   mips_->clear();
 
   // Setup meta info
@@ -359,7 +370,10 @@ void RateTree::analyze(const edm::Event& evt, const edm::EventSetup& es) {
       puUICEM_->push_back(uct->getFloat("puLevelUICEM", -4));
       effArea_->push_back(uct->getFloat("effArea", -4));
       mips_->push_back(uct->getInt("mipBit", -4));
+      eneighbor_->push_back(uct->getFloat("associated4x4Et",-4));
       taus_->push_back(uct->getInt("tauVeto", -4));
+      //std::cout << "tauVeto Rate Tree:" << uct->getFloat("tauVeto",-4) << std::endl;
+      tausneighbor_->push_back(uct->getInt("associated4x4Tau",-4));
       // UCT doesn't have a type
       type_->push_back(-1);
     } else {
@@ -409,7 +423,8 @@ void RateTree::analyze(const edm::Event& evt, const edm::EventSetup& es) {
   puUICEM_->push_back(-5);
   effArea_->push_back(-5);
   mips_->push_back(-5);
-  taus_->push_back(-5);
+  //taus_->push_back(-5);
+  //tausneighbor_->push_back(-5);
   type_->push_back(-5);
 
   tree->Fill();
diff --git a/plugins/RateTreeEmul.cc b/plugins/RateTreeEmul.cc
new file mode 100644
index 0000000..15bf800
--- /dev/null
+++ b/plugins/RateTreeEmul.cc
@@ -0,0 +1,167 @@
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Framework/interface/EDAnalyzer.h"
+
+#include "DataFormats/Candidate/interface/Candidate.h"
+
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CommonTools/UtilAlgos/interface/TFileService.h"
+
+#include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h"
+
+#include "DataFormats/L1Trigger/interface/L1EmParticle.h"
+#include "DataFormats/L1Trigger/interface/L1EmParticleFwd.h"
+#include "DataFormats/L1Trigger/interface/L1JetParticle.h"
+#include "DataFormats/L1Trigger/interface/L1JetParticleFwd.h"
+#include "DataFormats/L1Trigger/interface/L1EtMissParticle.h"
+#include "DataFormats/L1Trigger/interface/L1EtMissParticleFwd.h"
+
+#include "DataFormats/Scalers/interface/LumiScalers.h"
+
+#include "L1Trigger/L1TCalorimeter/interface/Stage1Layer2TauAlgorithmImp.h"
+#include "DataFormats/L1Trigger/interface/Tau.h"
+#include "DataFormats/L1Trigger/interface/L1Candidate.h"
+
+#include "TTree.h"
+
+typedef std::vector<edm::InputTag> VInputTag;
+
+class RateTreeEmul : public edm::EDAnalyzer {
+  public:
+    RateTreeEmul(const edm::ParameterSet& pset);
+    virtual ~RateTreeEmul();
+    void analyze(const edm::Event& evt, const edm::EventSetup& es);
+  private:
+    VInputTag src_;
+    TTree* tree;
+    std::vector<Float_t>* pts_;
+    std::vector<Float_t>* etas_;
+    std::vector<Float_t>* phis_;
+    std::vector<Int_t>* isoFlags_;
+    UInt_t run_;
+    UInt_t lumi_;
+    ULong64_t event_;
+    Int_t nPU_;
+};
+
+RateTreeEmul::RateTreeEmul(const edm::ParameterSet& pset) {
+  // Initialize the ntuple builder
+  edm::Service<TFileService> fs;
+  tree = fs->make<TTree>("Ntuple", "Ntuple");
+  pts_ = new std::vector<Float_t>();
+  etas_ = new std::vector<Float_t>();
+  phis_ = new std::vector<Float_t>();
+  isoFlags_ = new std::vector<Int_t>();
+
+  tree->Branch("pt", "std::vector<float>", &pts_);
+  tree->Branch("eta", "std::vector<float>", &etas_);
+  tree->Branch("phi", "std::vector<float>", &phis_);
+  tree->Branch("run", &run_, "run/i");
+  //tree->Branch("isoFlags", "std::vector<int>", &isoFlags_);
+  tree->Branch("lumi", &lumi_, "lumi/i");
+  tree->Branch("evt", &event_, "evt/l");
+  tree->Branch("nPU", &nPU_, "nPU/i");
+
+  src_ = pset.getParameter<VInputTag>("src");
+}
+
+RateTreeEmul::~RateTreeEmul() {
+  delete pts_;
+  delete etas_;
+  delete phis_;
+  delete isoFlags_;
+}
+
+
+namespace {
+
+  // Predicate to sort candidates by descending pt
+  class CandPtSorter {
+    public:
+      bool operator()(const reco::Candidate* candA, const reco::Candidate* candB)
+        const {
+          return candA->pt() > candB->pt();
+        }
+  };
+
+  // Turn a set of InputTags into a colleciton of candidate pointers.
+  std::vector<const reco::Candidate*> getCollections(
+      const edm::Event& evt, const VInputTag& collections) {
+    std::vector<const reco::Candidate*> output;
+    // Loop over collections
+    for (size_t i = 0; i < collections.size(); ++i) {
+      edm::Handle<edm::View<reco::Candidate> > handle;
+      evt.getByLabel(collections[i], handle);
+      // Loop over objects in current collection
+      for (size_t j = 0; j < handle->size(); ++j) {
+        const reco::Candidate& object = handle->at(j);
+        output.push_back(&object);
+      }
+    }
+    return output;
+  }
+
+}
+
+void RateTreeEmul::analyze(const edm::Event& evt, const edm::EventSetup& es) {
+  //std::cout << "getting objects" << std::endl;	
+  // Get the objects.
+  std::vector<const reco::Candidate*> objects = getCollections(
+      evt, src_);
+  //std::cout << "sorting objects" << std::endl;
+  std::sort(objects.begin(), objects.end(), CandPtSorter());
+
+  //std::cout << "clearing objects" << std::endl;
+  // Clear previous event's objects
+  pts_->clear();
+  etas_->clear();
+  phis_->clear();
+  isoFlags_->clear();
+  
+  
+  //std::cout << "setting up meta info" <<std::endl;
+  // Setup meta info
+  //  
+  run_ = evt.id().run();
+  lumi_ = evt.id().luminosityBlock();
+  event_ = evt.id().event();
+  
+  //std::cout << "event: " << event_ << std::endl;
+  
+  //std::cout << "getting pileup summary" << std::endl;
+  edm::Handle<std::vector<PileupSummaryInfo> > PupInfo;
+  evt.getByLabel("addPileupInfo", PupInfo);
+
+  nPU_=-1;
+  for(std::vector<PileupSummaryInfo>::const_iterator i = PupInfo->begin(); i!=PupInfo->end();++i) {
+   int BX = i->getBunchCrossing();
+   if(BX==0) {
+     nPU_ =i->getTrueNumInteractions();
+   }
+   else {
+     nPU_=i->getPU_NumInteractions();
+   }
+  }
+
+
+ 
+  //std::cout << "pushing back" << std::endl;
+  for (size_t i = 0; i < objects.size(); ++i) {
+    pts_->push_back(objects[i]->pt());
+    etas_->push_back(objects[i]->eta());
+    phis_->push_back(objects[i]->phi());
+    //std::cout <<"about to make dynamic cast"<<std::endl;
+    //const l1t::Tau* tau = dynamic_cast <const l1t::Tau*>(objects[i]);
+    //std::cout << "about to push back hwIso" <<std::endl;
+    //std::cout << tau[i].hwIso() << std::endl;
+    //isoFlags_->push_back(tau[i].hwIso());
+  }
+
+
+  tree->Fill();
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(RateTreeEmul);
diff --git a/python/recoObjects_cfi.py b/python/recoObjects_cfi.py
index 9bea532..642613e 100644
--- a/python/recoObjects_cfi.py
+++ b/python/recoObjects_cfi.py
@@ -33,7 +33,7 @@
     src = cms.InputTag( "gsfElectrons" ),
     cut = cms.string(
         " (et>20.0)"
-        " && (gsfTrack.trackerExpectedHitsInner.numberOfHits==0 && !(-0.02<convDist<0.02 && -0.02<convDcot<0.02))"
+        " && (!(-0.02<convDist<0.02 && -0.02<convDcot<0.02))"
         " && (  (isEB"
         " && abs(sigmaIetaIeta)<0.01 &&  abs(deltaPhiSuperClusterTrackAtVtx)<0.03 && abs(deltaEtaSuperClusterTrackAtVtx)<0.004 )"
         " || (isEE"
@@ -54,18 +54,18 @@
 )
 
 # Apply jet energy corrections - disabled until we can fix the global tag issue.
-calibratedAK5PFJets = cms.EDProducer(
-    'PFJetCorrectionProducer',
-    src = cms.InputTag('ak5PFJets'),
-    correctors = cms.vstring("ak5PFL1FastL2L3Residual")
-)
+#calibratedAK5PFJets = cms.EDProducer(
+#    'PFJetCorrectionProducer',
+#    src = cms.InputTag('ak5PFJets'),
+#    correctors = cms.vstring("ak5PFL1FastL2L3Residual")
+#)
 
 ##########################################################################
 ##-------- Remove electrons and muons from jet collection ----------------------
 ak5PFJetsNOMuons = cms.EDProducer(
     "PFJetCleaner",
-    srcJets = cms.InputTag("calibratedAK5PFJets"),
-    #srcJets = cms.InputTag("ak5PFJets"),
+    #srcJets = cms.InputTag("calibratedAK5PFJets"),
+    srcJets = cms.InputTag("ak5PFJets"),
     module_label = cms.string(""),
     idLevel = cms.int32(0), # No Jet Id Required
     etaMin  =  cms.double(0.0),
@@ -91,7 +91,7 @@
     tightMuons*
     recoElecs*
     isoElecs*
-    calibratedAK5PFJets*
+    #calibratedAK5PFJets*
     ak5PFJetsNOMuons*
     recoJets
 )
@@ -100,6 +100,7 @@
 from Configuration.StandardSequences.GeometryIdeal_cff import *
 from Configuration.StandardSequences.MagneticField_cff import *
 from RecoTauTag.Configuration.RecoPFTauTag_cff import *
+from PhysicsTools.PatAlgos.tools.tauTools import *
 from TrackingTools.TransientTrack.TransientTrackBuilder_cfi import * 
 
 # Select good taus
@@ -126,7 +127,8 @@
             selectionCut=cms.double(0.5)
         ),
         cms.PSet(
-            discriminator=cms.InputTag("hpsPFTauDiscriminationByLooseIsolationDBSumPtCorr"),
+            #discriminator=cms.InputTag("hpsPFTauDiscriminationByLooseIsolationDBSumPtCorr"),
+            discriminator=cms.InputTag("hpsPFTauDiscriminationByLooseCombinedIsolationDBSumPtCorr"),
             selectionCut=cms.double(0.5)
         ),
     ),
@@ -161,7 +163,7 @@
 
 recoObjects = cms.Sequence(
     cleanJets *
-    PFTau * 
+#    PFTau * 
     dmTaus *
     isoTaus*
     recoTaus
@@ -182,11 +184,11 @@
     matching = cms.InputTag("recoTauTruthMatcher")
 )
 
-recoObjects_truthMatched = cms.Sequence(
-    recoObjects *
-    genParticles *
-    tauGenJets *
-    trueHadronicTaus *
-    recoTauTruthMatcher *
-    trueTaus
-)
+#recoObjects_truthMatched = cms.Sequence(
+#    recoObjects *
+#    genParticles *
+#    tauGenJets *
+#    trueHadronicTaus *
+#    recoTauTruthMatcher *
+#    trueTaus
+#)
diff --git a/test/NtupilizeEmulatorEffi.py b/test/NtupilizeEmulatorEffi.py
new file mode 100644
index 0000000..cfc553b
--- /dev/null
+++ b/test/NtupilizeEmulatorEffi.py
@@ -0,0 +1,119 @@
+import FWCore.ParameterSet.Config as cms
+import os
+
+from FWCore.ParameterSet.VarParsing import VarParsing
+options = VarParsing('analysis')
+options.outputFile = "NtupilizeEmulatorEffi.root"
+options.parseArguments()
+process = cms.Process('EmulatorEffiNtupilizer')
+
+process.load('Configuration.StandardSequences.Services_cff')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
+process.load('Configuration.EventContent.EventContent_cff')
+process.load('Configuration.Geometry.GeometryIdeal_cff')\
+
+# Make the framework shut up.
+process.load("FWCore.MessageLogger.MessageLogger_cfi")
+process.MessageLogger.cerr.FwkReport.reportEvery = 100
+
+# Spit out filter efficiency at the end.
+#process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
+
+#Max Events
+process.maxEvents = cms.untracked.PSet(
+	input = cms.untracked.int32(options.maxEvents)
+	#input = cms.untracked.int32(100)
+)
+
+#Input
+process.source = cms.Source("PoolSource",
+	fileNames = cms.untracked.vstring(options.inputFiles)
+        #fileNames = cms.untracked.vstring("/store/mc/Fall13dr/Neutrino_Pt-2to20_gun/GEN-SIM-RAW/tsg_PU40bx25_POSTLS162_V2-v1/00005/C2D9064D-FB7F-E311-BFCC-003048679228.root")
+)
+
+#Output
+process.TFileService = cms.Service(
+	"TFileService",
+	fileName = cms.string(options.outputFile)
+)
+
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag.connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG')
+process.GlobalTag.globaltag = cms.string('POSTLS172_V2::All')
+
+process.load('L1Trigger.L1TCalorimeter.L1TCaloStage1_PPFromRaw_cff')
+process.load("L1Trigger.UWTriggerTools.recoObjects_cfi")
+
+from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
+process.newRCTConfig = cms.ESSource("PoolDBESSource",
+    CondDBSetup,
+    connect = cms.string('frontier://FrontierPrep/CMS_COND_L1T'),
+    DumpStat=cms.untracked.bool(True),
+    toGet = cms.VPSet(
+        cms.PSet(
+            record = cms.string('L1RCTParametersRcd'),
+            tag = cms.string('L1RCTParametersRcd_L1TDevelCollisions_ExtendedScaleFactorsV2')
+        ) 
+    ) 
+)
+process.prefer("newRCTConfig")
+
+reco_object_step = process.recoObjects
+process.p1 = cms.Path(
+        reco_object_step+
+	process.L1TCaloStage1_PPFromRaw
+	+process.l1ExtraLayer2
+)
+
+process.TauEmulEffi = cms.EDAnalyzer(
+	"MiniEffiTree",
+        src = cms.VInputTag("recoTaus"),
+        #src = cms.VInputTag("isoTaus"),
+        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Tau")),
+        #L1Src = cms.VInputTag(cms.InputTag("caloStage1Digis","rlxTaus")),
+        srcJet = cms.VInputTag("ak5PFJets"),
+        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+        srcEg = cms.VInputTag("recoElecs"),
+        L1SrcEg = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+        metSrc = cms.VInputTag("tcMet"),
+	L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+)
+process.TauEmulEffiIso =  cms.EDAnalyzer(
+        "MiniEffiTree",
+        src = cms.VInputTag("recoTaus"),
+        #src = cms.VInputTag("isoTaus"),
+        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","IsoTau")),
+        #L1Src = cms.VInputTag(cms.InputTag("caloStage1Digis","rlxTaus")),
+        srcJet = cms.VInputTag("ak5PFJets"),
+        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+        srcEg = cms.VInputTag("recoElecs"),
+        L1SrcEg = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+        metSrc = cms.VInputTag("tcMet"),
+        L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+)
+
+process.l1RCTParametersTest = cms.EDAnalyzer("L1RCTParametersTester")
+
+
+#process.EGEmulEffi = cms.EDAnalyzer(
+#	"MiniEffiTree",
+#        src = cms.VInputTag("recoElecs"),
+#        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+#        srcJet = cms.VInputTag("ak5PFJets"),
+#        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+#        metSrc = cms.VInputTag("tcMet"),
+#        L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+#)
+
+process.p2 = cms.Path(
+	process.TauEmulEffi
+	+process.TauEmulEffiIso
+	+process.l1RCTParametersTest
+ 	#+ process.EGEmulEffi
+)
+
+process.schedule = cms.Schedule(
+	process.p1,
+	process.p2
+)
diff --git a/test/NtupilizeEmulatorEffiModifyParams.py b/test/NtupilizeEmulatorEffiModifyParams.py
new file mode 100644
index 0000000..a7a9667
--- /dev/null
+++ b/test/NtupilizeEmulatorEffiModifyParams.py
@@ -0,0 +1,202 @@
+import FWCore.ParameterSet.Config as cms
+import os
+
+from FWCore.ParameterSet.VarParsing import VarParsing
+options = VarParsing('analysis')
+options.outputFile = "NtupilizeEmulatorEffiModifyParams.root"
+options.register ('eActivityCut',   4, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Veto HCAL Activity Threshold")
+options.register ('hActivityCut',   4, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Veto ECAL Activity Threshold")
+options.register ('tauThresh',      7, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Seed Threshold")
+options.register ('tauNThresh',     0, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Neighbor Seed Threshold")
+options.register ('maxPtTauVeto',  64, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau max Pt Tau Veto")
+options.register ('tauIsoLUTFile',  "/afs/hep.wisc.edu/cms/aglevine/L1Emulator/CMSSW_7_4_0_pre8/src/L1Trigger/L1TCalorimeter/data/tauIsoLutTest0.15Iso.txt", VarParsing.multiplicity.singleton, VarParsing.varType.string,
+                  "Tau Isolation Cut")
+
+options.parseArguments()
+print '========Tau Parameter Configuration======='
+print 'eActivityCut =   ',options.eActivityCut,' GeV'
+print 'hActivityCut =   ',options.hActivityCut,' GeV'
+print 'tauThresh    =   ',options.tauThresh,' GeV'
+print 'tauNThresh   =   ',options.tauNThresh,' GeV'
+print 'maxPtTauVeto =  ',options.maxPtTauVeto,' GeV'
+print 'tauIsoLUTFile = ',options.tauIsoLUTFile
+process = cms.Process('EmulatorEffiNtupilizer')
+
+process.load('Configuration.StandardSequences.Services_cff')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
+process.load('Configuration.EventContent.EventContent_cff')
+
+process.load('Configuration.Geometry.GeometryIdeal_cff')
+# Make the framework shut up.
+process.load("FWCore.MessageLogger.MessageLogger_cfi")
+process.MessageLogger.cerr.FwkReport.reportEvery = 100
+
+# Spit out filter efficiency at the end.
+#process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
+
+#Max Events
+process.maxEvents = cms.untracked.PSet(
+	input = cms.untracked.int32(options.maxEvents)
+	#input = cms.untracked.int32(100)
+)
+
+#Input
+process.source = cms.Source("PoolSource",
+	fileNames = cms.untracked.vstring(options.inputFiles)
+        #fileNames = cms.untracked.vstring("/store/mc/Fall13dr/Neutrino_Pt-2to20_gun/GEN-SIM-RAW/tsg_PU40bx25_POSTLS162_V2-v1/00005/C2D9064D-FB7F-E311-BFCC-003048679228.root")
+)
+
+#Output
+process.TFileService = cms.Service(
+	"TFileService",
+	fileName = cms.string(options.outputFile)
+)
+
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag.connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG')
+process.GlobalTag.globaltag = cms.string('POSTLS172_V2::All')
+#########################
+from L1Trigger.L1TCalorimeter.caloStage1Params_cfi import *
+process.load("L1Trigger.L1TCalorimeter.caloStage1Params_cfi")
+process.caloStage1Params.tauSeedThreshold         = cms.double(options.tauThresh)    #pre-RCT Calibration 7GeV
+process.caloStage1Params.tauNeighbourThreshold    = cms.double(options.tauNThresh)   #pre-RCT Calibration 0GeV
+process.caloStage1Params.tauMaxPtTauVeto          = cms.double(options.maxPtTauVeto) #pre-RCT Calibration 64GeV
+process.caloStage1Params.tauIsoLUTFile            = cms.FileInPath(options.tauIsoLUTFile)  #pre-RCT Calibration 0.1
+
+#process.load('L1Trigger.L1TCalorimeter.L1TCaloStage1_PPFromRaw_cff')
+# HCAL TP hack
+process.load("L1Trigger.L1TCalorimeter.L1TRerunHCALTP_FromRaw_cff")
+
+### Set RCT EG Activity Threshold and Hadronic Activity Threshold Here
+#process.load("L1Trigger.L1TCalorimeter.caloStage1RCTLuts_cff")
+process.load("L1Trigger.L1TCalorimeter.caloStage1RCTLuts_NewRCTCalib_cff")
+process.RCTConfigProducers.hActivityCut = options.hActivityCut
+process.RCTConfigProducers.eActivityCut = options.eActivityCut
+
+### RCT To Digi Sequence
+process.load("Configuration.StandardSequences.RawToDigi_Data_cff")
+
+# RCT
+# HCAL input would be from hcalDigis if hack not needed
+process.load("L1Trigger.Configuration.SimL1Emulator_cff");
+process.simRctDigis.ecalDigis = cms.VInputTag( cms.InputTag( 'ecalDigis:EcalTriggerPrimitives' ) )
+process.simRctDigis.hcalDigis = cms.VInputTag( cms.InputTag( 'simHcalTriggerPrimitiveDigis' ) )
+
+### stage 1 
+process.load("L1Trigger.L1TCalorimeter.L1TCaloStage1_cff")
+
+### L1Extra
+process.load("L1Trigger.Configuration.L1Extra_cff")
+process.l1ExtraLayer2 = L1Trigger.Configuration.L1Extra_cff.l1extraParticles.clone()
+process.l1ExtraLayer2.isolatedEmSource    = cms.InputTag("simCaloStage1LegacyFormatDigis","isoEm")
+process.l1ExtraLayer2.nonIsolatedEmSource = cms.InputTag("simCaloStage1LegacyFormatDigis","nonIsoEm")
+
+process.l1ExtraLayer2.forwardJetSource = cms.InputTag("simCaloStage1LegacyFormatDigis","forJets")
+process.l1ExtraLayer2.centralJetSource = cms.InputTag("simCaloStage1LegacyFormatDigis","cenJets")
+process.l1ExtraLayer2.tauJetSource     = cms.InputTag("simCaloStage1LegacyFormatDigis","tauJets")
+process.l1ExtraLayer2.isoTauJetSource  = cms.InputTag("simCaloStage1LegacyFormatDigis","isoTauJets")
+
+process.l1ExtraLayer2.etTotalSource = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.etHadSource   = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.etMissSource  = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.htMissSource  = cms.InputTag("simCaloStage1LegacyFormatDigis")
+
+process.l1ExtraLayer2.hfRingEtSumsSource    = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.hfRingBitCountsSource = cms.InputTag("simCaloStage1LegacyFormatDigis")
+
+## update l1ExtraLayer2 muon tag
+process.l1ExtraLayer2.muonSource = cms.InputTag("simGmtDigis")
+
+#########################
+
+# GT
+                     # GT
+from L1Trigger.Configuration.SimL1Emulator_cff import simGtDigis
+process.simGtDigis = simGtDigis.clone()
+process.simGtDigis.GmtInputTag = 'simGmtDigis'
+process.simGtDigis.GctInputTag = 'caloStage1LegacyFormatDigis'
+process.simGtDigis.TechnicalTriggersInputTags = cms.VInputTag( )
+
+process.load("L1Trigger.UWTriggerTools.recoObjects_cfi")
+
+#from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
+#process.newRCTConfig = cms.ESSource("PoolDBESSource",
+#    CondDBSetup,
+#    connect = cms.string('frontier://FrontierPrep/CMS_COND_L1T'),
+#    DumpStat=cms.untracked.bool(True),
+#    toGet = cms.VPSet(
+#        cms.PSet(
+#            record = cms.string('L1RCTParametersRcd'),
+#            tag = cms.string('L1RCTParametersRcd_L1TDevelCollisions_ExtendedScaleFactorsV1')
+#        ) 
+#    ) 
+#)
+#process.prefer("newRCTConfig")
+reco_object_step = process.recoObjects
+process.p1 = cms.Path(
+        reco_object_step+
+        process.L1TRerunHCALTP_FromRAW
+        +process.ecalDigis
+        +process.simRctDigis
+        +process.L1TCaloStage1
+        +process.simGtDigis
+        +process.l1ExtraLayer2
+)
+
+process.TauEmulEffi = cms.EDAnalyzer(
+	"MiniEffiTree",
+        src = cms.VInputTag("recoTaus"),
+        #src = cms.VInputTag("isoTaus"),
+        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Tau")),
+        #L1Src = cms.VInputTag(cms.InputTag("caloStage1Digis","rlxTaus")),
+        srcJet = cms.VInputTag("ak5PFJets"),
+        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+        srcEg = cms.VInputTag("recoElecs"),
+        L1SrcEg = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+        metSrc = cms.VInputTag("tcMet"),
+	L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+)
+process.TauEmulEffiIso =  cms.EDAnalyzer(
+        "MiniEffiTree",
+        src = cms.VInputTag("recoTaus"),
+        #src = cms.VInputTag("isoTaus"),
+        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","IsoTau")),
+        #L1Src = cms.VInputTag(cms.InputTag("caloStage1Digis","rlxTaus")),
+        srcJet = cms.VInputTag("ak5PFJets"),
+        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+        srcEg = cms.VInputTag("recoElecs"),
+        L1SrcEg = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+        metSrc = cms.VInputTag("tcMet"),
+        L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+)
+
+process.l1RCTParametersTest = cms.EDAnalyzer("L1RCTParametersTester")
+
+
+#process.EGEmulEffi = cms.EDAnalyzer(
+#	"MiniEffiTree",
+#        src = cms.VInputTag("recoElecs"),
+#        L1Src = cms.VInputTag(cms.InputTag("l1ExtraLayer2","NonIsolated")),
+#        srcJet = cms.VInputTag("ak5PFJets"),
+#        L1SrcJet = cms.VInputTag(cms.InputTag("l1ExtraLayer2","Central")),
+#        metSrc = cms.VInputTag("tcMet"),
+#        L1MetSrc = cms.VInputTag(cms.InputTag("l1ExtraLayer2","MET"))
+#)
+
+process.p2 = cms.Path(
+	process.TauEmulEffi
+	+process.TauEmulEffiIso
+	#+process.l1RCTParametersTest
+ 	#+ process.EGEmulEffi
+)
+
+process.schedule = cms.Schedule(
+	process.p1,
+	process.p2
+)
diff --git a/test/NtupilizeEmulatorRates.py b/test/NtupilizeEmulatorRates.py
new file mode 100644
index 0000000..b27cc44
--- /dev/null
+++ b/test/NtupilizeEmulatorRates.py
@@ -0,0 +1,96 @@
+import FWCore.ParameterSet.Config as cms
+import os
+
+from FWCore.ParameterSet.VarParsing import VarParsing
+options = VarParsing('analysis')
+options.outputFile = "NtupilizeEmulatorRates.root"
+options.parseArguments()
+process = cms.Process('EmulatorNtupilizer')
+
+process.load('Configuration.StandardSequences.Services_cff')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
+process.load('Configuration.EventContent.EventContent_cff')
+process.load('Configuration.Geometry.GeometryIdeal_cff')\
+
+# Make the framework shut up.
+#process.load("FWCore.MessageLogger.MessageLogger_cfi")
+#process.MessageLogger.cerr.FwkReport.reportEvery = 100
+# Spit out filter efficiency at the end.
+process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
+
+#Max Events
+process.maxEvents = cms.untracked.PSet(
+	input = cms.untracked.int32(options.maxEvents)
+	#input = cms.untracked.int32(10000)
+)
+
+#Input
+process.source = cms.Source("PoolSource",
+	fileNames = cms.untracked.vstring(options.inputFiles)
+#        fileNames = cms.untracked.vstring("/store/mc/Fall13dr/Neutrino_Pt-2to20_gun/GEN-SIM-RAW/tsg_PU40bx25_POSTLS162_V2-v1/00005/C2D9064D-FB7F-E311-BFCC-003048679228.root")
+)
+
+#Output
+#options.outputFile = "L1EmulatorTree.root"
+process.TFileService = cms.Service(
+	"TFileService",
+	fileName = cms.string(options.outputFile)
+)
+
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag.connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG')
+#process.GlobalTag.globaltag = cms.string('POSTLS162_V2::All')
+process.GlobalTag.globaltag = cms.string('POSTLS172_V2::All')
+
+
+process.load('L1Trigger.L1TCalorimeter.L1TCaloStage1_PPFromRaw_cff')
+
+from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
+process.newRCTConfig = cms.ESSource("PoolDBESSource",
+    CondDBSetup,
+    connect = cms.string('frontier://FrontierPrep/CMS_COND_L1T'),
+    DumpStat=cms.untracked.bool(True),
+    toGet = cms.VPSet(
+        cms.PSet(
+            record = cms.string('L1RCTParametersRcd'),
+	    tag = cms.string('L1RCTParametersRcd_L1TDevelCollisions_ExtendedScaleFactorsV2')
+        )
+    )
+)
+process.prefer("newRCTConfig")
+
+
+process.p1 = cms.Path(
+	process.L1TCaloStage1_PPFromRaw
+	+process.l1ExtraLayer2
+)
+
+process.TauEmul = cms.EDAnalyzer(
+	"RateTreeEmul",
+	#src = cms.VInputTag(cms.InputTag("L1TCaloRCTToUpgradeConverter","tauJets"))
+       # src = cms.VInputTag(cms.InputTag("CaloStage1FinalDigis", "rlxTaus"))
+        src = cms.VInputTag(cms.InputTag("l1ExtraLayer2", "Tau"))
+)
+process.TauEmulIso = cms.EDAnalyzer(
+        "RateTreeEmul",
+        #src = cms.VInputTag(cms.InputTag("L1TCaloRCTToUpgradeConverter","tauJets"))
+       # src = cms.VInputTag(cms.InputTag("CaloStage1FinalDigis", "rlxTaus"))
+        src = cms.VInputTag(cms.InputTag("l1ExtraLayer2", "IsoTau"))
+)
+
+
+
+process.l1RCTParametersTest = cms.EDAnalyzer("L1RCTParametersTester")
+
+
+process.p2 = cms.Path(
+	process.TauEmul
+	+process.TauEmulIso
+	+process.l1RCTParametersTest
+)
+
+process.schedule = cms.Schedule(
+	process.p1,
+	process.p2
+)
diff --git a/test/NtupilizeEmulatorRatesModifyParams.py b/test/NtupilizeEmulatorRatesModifyParams.py
new file mode 100644
index 0000000..3930e7a
--- /dev/null
+++ b/test/NtupilizeEmulatorRatesModifyParams.py
@@ -0,0 +1,178 @@
+import FWCore.ParameterSet.Config as cms
+import os
+
+from FWCore.ParameterSet.VarParsing import VarParsing
+options = VarParsing('analysis')
+options.outputFile = "NtupilizeEmulatorRatesModifyParams.root"
+options.register ('eActivityCut',   4, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Veto HCAL Activity Threshold")
+options.register ('hActivityCut',   4, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Veto ECAL Activity Threshold")
+options.register ('tauThresh',      7, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Seed Threshold")
+options.register ('tauNThresh',     0, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau Neighbor Seed Threshold")
+options.register ('maxPtTauVeto',  64, VarParsing.multiplicity.singleton, VarParsing.varType.int,
+                  "Tau max Pt Tau Veto")
+options.register ('tauIsoLUTFile',  "/afs/hep.wisc.edu/cms/aglevine/L1Emulator/CMSSW_7_4_0_pre8/src/L1Trigger/L1TCalorimeter/data/tauIsoLutTest0.15Iso.txt", VarParsing.multiplicity.singleton, VarParsing.varType.string,
+                  "Tau Isolation Cut")
+options.parseArguments()
+print '========Tau Parameter Configuration======='
+print 'eActivityCut =   ',options.eActivityCut,' GeV'
+print 'hActivityCut =   ',options.hActivityCut,' GeV'
+print 'tauThresh    =   ',options.tauThresh,' GeV'
+print 'tauNThresh   =   ',options.tauNThresh,' GeV'
+print 'maxPtTauVeto =  ',options.maxPtTauVeto,' GeV'
+print 'tauIsoLUTFile = ',options.tauIsoLUTFile
+
+
+process = cms.Process('EmulatorNtupilizer')
+
+process.load('Configuration.StandardSequences.Services_cff')
+process.load('FWCore.MessageService.MessageLogger_cfi')
+process.load('Configuration/StandardSequences/FrontierConditions_GlobalTag_cff')
+process.load('Configuration.EventContent.EventContent_cff')
+process.load('Configuration.Geometry.GeometryIdeal_cff')\
+
+# Make the framework shut up.
+process.load("FWCore.MessageLogger.MessageLogger_cfi")
+process.MessageLogger.cerr.FwkReport.reportEvery = 100
+# Spit out filter efficiency at the end.
+process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(True))
+
+#Max Events
+process.maxEvents = cms.untracked.PSet(
+	input = cms.untracked.int32(options.maxEvents)
+	#input = cms.untracked.int32(10000)
+)
+
+#Input
+process.source = cms.Source("PoolSource",
+	fileNames = cms.untracked.vstring(options.inputFiles)
+#        fileNames = cms.untracked.vstring("/store/mc/Fall13dr/Neutrino_Pt-2to20_gun/GEN-SIM-RAW/tsg_PU40bx25_POSTLS162_V2-v1/00005/C2D9064D-FB7F-E311-BFCC-003048679228.root")
+)
+
+#Output
+#options.outputFile = "L1EmulatorTree.root"
+process.TFileService = cms.Service(
+	"TFileService",
+	fileName = cms.string(options.outputFile)
+)
+
+from Configuration.AlCa.GlobalTag import GlobalTag
+process.GlobalTag.connect = cms.string('frontier://FrontierProd/CMS_COND_31X_GLOBALTAG')
+#process.GlobalTag.globaltag = cms.string('POSTLS162_V2::All')
+process.GlobalTag.globaltag = cms.string('POSTLS172_V2::All')
+
+
+from L1Trigger.L1TCalorimeter.caloStage1Params_cfi import *
+process.load("L1Trigger.L1TCalorimeter.caloStage1Params_cfi")
+process.caloStage1Params.tauSeedThreshold         = cms.double(options.tauThresh)    #pre-RCT Calibration 7GeV
+process.caloStage1Params.tauNeighbourThreshold    = cms.double(options.tauNThresh)   #pre-RCT Calibration 0GeV
+process.caloStage1Params.tauMaxPtTauVeto          = cms.double(options.maxPtTauVeto) #pre-RCT Calibration 64GeV
+process.caloStage1Params.tauIsoLUTFile            = cms.FileInPath(options.tauIsoLUTFile)   #pre-RCT Calibration 0.1 Iso, 192 GeV Turn Off Tau Iso
+
+#process.load('L1Trigger.L1TCalorimeter.L1TCaloStage1_PPFromRaw_cff')
+# HCAL TP hack
+process.load("L1Trigger.L1TCalorimeter.L1TRerunHCALTP_FromRaw_cff")
+
+### Set RCT EG Activity Threshold and Hadronic Activity Threshold Here
+#process.load("L1Trigger.L1TCalorimeter.caloStage1RCTLuts_cff")
+process.load("L1Trigger.L1TCalorimeter.caloStage1RCTLuts_NewRCTCalib_cff")
+process.RCTConfigProducers.hActivityCut = options.hActivityCut
+process.RCTConfigProducers.eActivityCut = options.eActivityCut
+
+### RCT To Digi Sequence
+process.load("Configuration.StandardSequences.RawToDigi_Data_cff")
+
+# RCT
+# HCAL input would be from hcalDigis if hack not needed
+process.load("L1Trigger.Configuration.SimL1Emulator_cff");
+process.simRctDigis.ecalDigis = cms.VInputTag( cms.InputTag( 'ecalDigis:EcalTriggerPrimitives' ) )
+process.simRctDigis.hcalDigis = cms.VInputTag( cms.InputTag( 'simHcalTriggerPrimitiveDigis' ) )
+
+### stage 1 
+process.load("L1Trigger.L1TCalorimeter.L1TCaloStage1_cff")
+
+### L1Extra
+process.load("L1Trigger.Configuration.L1Extra_cff")
+process.l1ExtraLayer2 = L1Trigger.Configuration.L1Extra_cff.l1extraParticles.clone()
+process.l1ExtraLayer2.isolatedEmSource    = cms.InputTag("simCaloStage1LegacyFormatDigis","isoEm")
+process.l1ExtraLayer2.nonIsolatedEmSource = cms.InputTag("simCaloStage1LegacyFormatDigis","nonIsoEm")
+
+process.l1ExtraLayer2.forwardJetSource = cms.InputTag("simCaloStage1LegacyFormatDigis","forJets")
+process.l1ExtraLayer2.centralJetSource = cms.InputTag("simCaloStage1LegacyFormatDigis","cenJets")
+process.l1ExtraLayer2.tauJetSource     = cms.InputTag("simCaloStage1LegacyFormatDigis","tauJets")
+process.l1ExtraLayer2.isoTauJetSource  = cms.InputTag("simCaloStage1LegacyFormatDigis","isoTauJets")
+process.l1ExtraLayer2.etTotalSource = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.etHadSource   = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.etMissSource  = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.htMissSource  = cms.InputTag("simCaloStage1LegacyFormatDigis")
+
+process.l1ExtraLayer2.hfRingEtSumsSource    = cms.InputTag("simCaloStage1LegacyFormatDigis")
+process.l1ExtraLayer2.hfRingBitCountsSource = cms.InputTag("simCaloStage1LegacyFormatDigis")
+
+## update l1ExtraLayer2 muon tag
+process.l1ExtraLayer2.muonSource = cms.InputTag("simGmtDigis")
+#########################
+
+# GT
+                     # GT
+from L1Trigger.Configuration.SimL1Emulator_cff import simGtDigis
+process.simGtDigis = simGtDigis.clone()
+process.simGtDigis.GmtInputTag = 'simGmtDigis'
+process.simGtDigis.GctInputTag = 'caloStage1LegacyFormatDigis'
+process.simGtDigis.TechnicalTriggersInputTags = cms.VInputTag( )
+
+
+#from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
+#process.newRCTConfig = cms.ESSource("PoolDBESSource",
+#    CondDBSetup,
+#    connect = cms.string('frontier://FrontierPrep/CMS_COND_L1T'),
+#    DumpStat=cms.untracked.bool(True),
+#    toGet = cms.VPSet(
+#        cms.PSet(
+#            record = cms.string('L1RCTParametersRcd'),
+#	    tag = cms.string('L1RCTParametersRcd_L1TDevelCollisions_ExtendedScaleFactorsV1')
+#        )
+#    )
+#)
+#process.prefer("newRCTConfig")
+process.p1 = cms.Path(
+	#process.L1TCaloStage1_PPFromRaw
+        process.L1TRerunHCALTP_FromRAW
+        +process.ecalDigis
+        +process.simRctDigis
+        +process.L1TCaloStage1
+        +process.simGtDigis
+        +process.l1ExtraLayer2
+)
+
+process.TauEmul = cms.EDAnalyzer(
+	"RateTreeEmul",
+	#src = cms.VInputTag(cms.InputTag("L1TCaloRCTToUpgradeConverter","tauJets"))
+       # src = cms.VInputTag(cms.InputTag("CaloStage1FinalDigis", "rlxTaus"))
+        src = cms.VInputTag(cms.InputTag("l1ExtraLayer2", "Tau"))
+)
+process.TauEmulIso = cms.EDAnalyzer(
+        "RateTreeEmul",
+        #src = cms.VInputTag(cms.InputTag("L1TCaloRCTToUpgradeConverter","tauJets"))
+       # src = cms.VInputTag(cms.InputTag("CaloStage1FinalDigis", "rlxTaus"))
+        src = cms.VInputTag(cms.InputTag("l1ExtraLayer2", "IsoTau"))
+)
+
+
+
+process.l1RCTParametersTest = cms.EDAnalyzer("L1RCTParametersTester")
+
+
+process.p2 = cms.Path(
+	process.TauEmul
+	+process.TauEmulIso
+	#+process.l1RCTParametersTest
+)
+
+process.schedule = cms.Schedule(
+	process.p1,
+	process.p2
+)
diff --git a/test/makeEfficiencyTree_cfg.py b/test/makeEfficiencyTree_cfg.py
index bb677bd..722a7b5 100755
--- a/test/makeEfficiencyTree_cfg.py
+++ b/test/makeEfficiencyTree_cfg.py
@@ -51,7 +51,7 @@
     'If 1, turn off the ECAL for the stage1 EGTau path.')
 options.register(
     'isMC',
-    0,
+    1,
     VarParsing.multiplicity.singleton,
     VarParsing.varType.int,
     'Set to 1 for simulated samples - updates GT, emulates HCAL TPGs.')
@@ -177,6 +177,7 @@
     l1gJetPt = cms.string("? l1gMatch ? l1g.getFloat('associatedJetPt', -4) : -2"),
     l1gEllIso = cms.string("? l1gMatch ? l1g.getInt('ellIsolation', -4) : -2"),
     l1gTauVeto = cms.string("? l1gMatch ? l1g.getInt('tauVeto', -4) : -2"),
+    l1gTauVetoNeighbor = cms.string("? l1gMatch ? l1g.getInt('associated4x4Tau', -4) : -2"),
     l1gMIP = cms.string("? l1gMatch ? l1g.getInt('mipBit', -4) : -2"),
     l1gIsEle = cms.string("? l1gMatch ? l1g.getInt('isEle', -4) : -2"),
 )
@@ -202,6 +203,24 @@
 
 process.isoTauEfficiency = cms.EDAnalyzer(
     "EfficiencyTree",
+    #recoSrc = cms.VInputTag("isoTaus"),
+    recoSrc = cms.VInputTag("recoTaus"),
+    l1Src = cms.VInputTag(cms.InputTag("l1extraParticles", "Tau")),
+    l1GSrc = cms.VInputTag(cms.InputTag("UCT2015Producer", "IsolatedTauUnpacked")),
+    l1GPUSrc = cms.InputTag("UCT2015Producer", "PULevelPUM0Unpacked"),
+    # Max DR for RECO-trigger matching
+    maxDR = cms.double(0.5),
+    # Ntuple configuration
+    ntuple = cms.PSet(
+        common_ntuple_branches,
+        egtau_branches,
+        tau_branches,
+    )
+)
+
+process.isoTauCheckEfficiency = cms.EDAnalyzer(
+    "EfficiencyTree",
+    #recoSrc = cms.VInputTag("isoTaus"),
     recoSrc = cms.VInputTag("isoTaus"),
     l1Src = cms.VInputTag(cms.InputTag("l1extraParticles", "Tau")),
     l1GSrc = cms.VInputTag(cms.InputTag("UCT2015Producer", "IsolatedTauUnpacked")),
@@ -315,6 +334,7 @@
 process.leptonEfficiencies = cms.Sequence(
 
     process.isoTauEfficiency *
+    process.isoTauCheckEfficiency *
     process.rlxTauEfficiency
     *process.rlxTauPlusJetEfficiency *
 
@@ -427,6 +447,7 @@
     process.isoTauEfficiency.recoSrc = cms.VInputTag("trueTaus")
     process.rlxTauEfficiency.recoSrc = cms.VInputTag("trueTaus")
     process.isoTauEfficiency.recoSrc = cms.VInputTag("trueTaus")
+    process.isoTauCheckEfficiency.recoSrc = cms.VInputTag("trueTaus")
     process.rlxTauEfficiency.recoSrc = cms.VInputTag("trueTaus")
     process.printTaus.src=cms.InputTag("trueTaus")
 
@@ -561,7 +582,7 @@
 
 # Make the framework shut up.
 process.load("FWCore.MessageLogger.MessageLogger_cfi")
-process.MessageLogger.cerr.FwkReport.reportEvery = 1000
+process.MessageLogger.cerr.FwkReport.reportEvery = 100
 
 # Spit out filter efficiency at the end.
 process.options = cms.untracked.PSet(wantSummary = cms.untracked.bool(False))