TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.42 2009/03/23 22:13:33 loizides Exp $

#include "MitProd/TreeFiller/interface/FillMitTree.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "MitProd/TreeService/interface/TreeService.h"
#include "MitProd/ObjectService/interface/ObjectService.h"
#include "MitProd/TreeFiller/interface/AssociationMaps.h"
#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
#include "MitProd/TreeFiller/interface/FillerCaloTaus.h"
#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerGenJets.h"
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "MitProd/TreeFiller/interface/FillerMCEventInfo.h"
#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
#include "MitProd/TreeFiller/interface/FillerMet.h"
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "MitProd/TreeFiller/interface/FillerMuons.h"
#include "MitProd/TreeFiller/interface/FillerPFCandidates.h"
#include "MitProd/TreeFiller/interface/FillerPFJets.h"
#include "MitProd/TreeFiller/interface/FillerPFMet.h"
#include "MitProd/TreeFiller/interface/FillerPFTaus.h"
#include "MitProd/TreeFiller/interface/FillerPhotons.h"
#include "MitProd/TreeFiller/interface/FillerStableParts.h"
#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
#include "MitProd/TreeFiller/interface/FillerTracks.h"
#include "MitProd/TreeFiller/interface/FillerVertexes.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/BranchTable.h"

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

mithep::ObjectService *mithep::FillMitTree::os_ = 0;

//--------------------------------------------------------------------------------------------------
FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
  defactive_(cfg.getUntrackedParameter<bool>("defactive",1)),
  brtable_(0),
  acfnumber_(-1)
{
  // Constructor.

  if (!configure(cfg)) {
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
      << "Could not configure fillers." << "\n";
  }
}

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

  delete brtable_;
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::addActiveFiller(BaseFiller *bf)
{
  // Check if filler is active and add it to list of fillers. Otherwise delete it.

  if (!bf)
    return 0;

  if (bf->Active()) {
    fillers_.push_back(bf);
    return 1;
  }

  delete bf;
  bf = 0;
  return 0;
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::analyze(const edm::Event      &event, 
                          const edm::EventSetup &setup)
{
  // Access and copy event content.

  // first step: Loop over the data fillers of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->FillDataBlock(event,setup);
  }

  // second step: Loop over the link resolution of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->ResolveLinks(event,setup);
  }

  if (brtable_) { // only the first FillMitTree object has to deal with the branch table
    if (acfnumber_==-1) {
      brtable_->Rehash(brtable_->GetSize());
      if (0)
        brtable_->Print();
    }
    if (acfnumber_ != tws_->GetFileNumber()) {
      tws_->StoreObject(brtable_);
      acfnumber_ = tws_->GetFileNumber();
    }
  }
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::beginJob(const edm::EventSetup &event)
{
  // Access the tree and book branches.

  Service<TreeService> ts;
  tws_ = ts->get();
  if (!tws_) {
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
      << "Could not get pointer to tree. " 
      << "Do you have the TreeServie define in your config?" << "\n";
    return;
  }

  if (os_==0) { // only the first FillMitTree object has to deal with this
    Service<ObjectService> os;
    if (!os.isAvailable()) {
      throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
        << "Could not get object service. " 
        << "Do you have the ObjectService defined in your config?" << "\n";
      return;
    }
    os_ = &(*os);
    brtable_ = new BranchTable;
    brtable_->SetName(Names::gkBranchTable);
    brtable_->SetOwner();
    os->add(brtable_, brtable_->GetName());
  }

  // loop over the various components and book the branches
  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
    (*iF)->BookDataBlock(*tws_);
  }
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::configure(const edm::ParameterSet &cfg)
{
  // Configure our fillers according to given parameter ("fillers").

  std::vector<std::string> pars;
  if (cfg.exists("fillers"))
    pars=cfg.getUntrackedParameter<vector<string> >("fillers");
  else
    cfg.getParameterSetNames(pars, false);

  // loop over psets
  for (unsigned int i = 0; i<pars.size(); ++i) {

    const string name(pars.at(i));

    string ftype("Filler" + name);
    if (cfg.existsAs<ParameterSet>(name,0)) {
      ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
      if (!next.exists("fillerType")) {
        edm::LogError("FillMitTree") << "Cannot determine fillerType for pset named "
                                     << name << std::endl;
        throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
          << "Cannot determine fillerType for pset named "
          << name << std::endl;
      }
      ftype = next.getUntrackedParameter<string>("fillerType");
    }

    edm::LogInfo("FillMitTree") << "Attempting to configure '" << ftype 
                                << "' for '" << name << "'" << std::endl;

    if (ftype.compare("FillerMetaInfos")==0) {
      FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMetaInfos);
      continue;
    }

    if (ftype.compare("FillerMCParticles")==0) {
      FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCParticles);
      continue;
    }

    if (ftype.compare("FillerMCEventInfo")==0) {
      FillerMCEventInfo *fillerMCEventInfo = new FillerMCEventInfo(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCEventInfo);
      continue;
    }

    if (ftype.compare("FillerBeamSpot")==0) {
      FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBeamSpot);
      continue;
    }
   
    if (ftype.compare("FillerVertexes")==0) {
      FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerVertexes);
      continue;
    }  

    if (ftype.compare("FillerCaloTowers")==0) {
      FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloTowers);
      continue;
    }  

    if (ftype.compare("FillerGenJets")==0) {
      FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerGenJets);
      continue;
    }  

    if (ftype.compare("FillerCaloJets")==0) {
      FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloJets);
      continue;
    }  
    
    if (ftype.compare("FillerMet")==0) {
      FillerMet *fillerMet = new FillerMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMet);
      continue;
    }  

    if (ftype.compare("FillerCaloMet")==0) {
      FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloMet);
      continue;
    }
    
    if (ftype.compare("FillerPFMet")==0) {
      FillerPFMet *fillerPFMet = new FillerPFMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFMet);
      continue;
    }  

    if (ftype.compare("FillerBasicClusters")==0) {
      FillerBasicClusters *fillerBasicClusters = 
        new FillerBasicClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBasicClusters);
      continue;
    }  

    if (ftype.compare("FillerSuperClusters")==0) {
      FillerSuperClusters *fillerSuperClusters =  
        new FillerSuperClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerSuperClusters);
      continue;
    }  

    if (ftype.compare("FillerTracks")==0) {
      FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerTracks);
      continue;
    }  

    if (ftype.compare("FillerMuons")==0) {
      FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMuons);
      continue;
    }  

    if (ftype.compare("FillerElectrons")==0) {
      FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerElectrons);
      continue;
    }  

    if (ftype.compare("FillerConversions")==0) {
      FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerConversions);
      continue;
    }  

    if (ftype.compare("FillerPhotons")==0) { 
      FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPhotons);
      continue;
    }  

    if (ftype.compare("FillerStableParts")==0) {
      FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerStableParts);
      continue;
    }  

    if (ftype.compare("FillerDecayParts")==0) {
      FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerDecayParts);
      continue;
    }  
    
    if (ftype.compare("FillerPFCandidates")==0) {
      FillerPFCandidates *fillerPFCands = new FillerPFCandidates(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFCands);
      continue;
    }  

    if (ftype.compare("FillerPFJets")==0) {
      FillerPFJets *fillerPFJets = new FillerPFJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFJets);
      continue;
    }  

    if (ftype.compare("FillerCaloTaus")==0) {
      FillerCaloTaus *fillerCaloTaus = new FillerCaloTaus(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloTaus);
      continue;
    }
    
    if (ftype.compare("FillerPFTaus")==0) {
      FillerPFTaus *fillerPFTaus = new FillerPFTaus(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFTaus);
      continue;
    }  
    
    edm::LogError("FillMitTree") 
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
  }

  return 1;
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::endJob()
{
  // Delete fillers.

  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    delete *iF;
  }

  edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
}
Revision:	1.43
Committed:	Thu Jun 18 23:10:01 2009 UTC (15 years, 10 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
Changes since 1.42:	+1 -9 lines
Log Message:	Finally removed godaweful hack FillerConversionElectrons class
#	User	Rev	Content
1	bendavid	1.43	// $Id: FillMitTree.cc,v 1.42 2009/03/23 22:13:33 loizides Exp $
2	paus	1.1
3	loizides	1.3	#include "MitProd/TreeFiller/interface/FillMitTree.h"
4	paus	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
5	loizides	1.32	#include "FWCore/ParameterSet/interface/ParameterSet.h"
6	paus	1.1	#include "FWCore/ServiceRegistry/interface/Service.h"
7	loizides	1.3	#include "MitProd/TreeService/interface/TreeService.h"
8	loizides	1.16	#include "MitProd/ObjectService/interface/ObjectService.h"
9	loizides	1.6	#include "MitProd/TreeFiller/interface/AssociationMaps.h"
10	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
11	bendavid	1.28	#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
12	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
13			#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
14	bendavid	1.41	#include "MitProd/TreeFiller/interface/FillerCaloTaus.h"
15	sixie	1.20	#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
16	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerConversions.h"
17			#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
18	loizides	1.6	#include "MitProd/TreeFiller/interface/FillerElectrons.h"
19	sixie	1.22	#include "MitProd/TreeFiller/interface/FillerGenJets.h"
20	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
21			#include "MitProd/TreeFiller/interface/FillerMCEventInfo.h"
22			#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
23			#include "MitProd/TreeFiller/interface/FillerMet.h"
24			#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
25			#include "MitProd/TreeFiller/interface/FillerMuons.h"
26			#include "MitProd/TreeFiller/interface/FillerPFCandidates.h"
27	bendavid	1.33	#include "MitProd/TreeFiller/interface/FillerPFJets.h"
28	bendavid	1.34	#include "MitProd/TreeFiller/interface/FillerPFMet.h"
29	bendavid	1.41	#include "MitProd/TreeFiller/interface/FillerPFTaus.h"
30	bendavid	1.8	#include "MitProd/TreeFiller/interface/FillerPhotons.h"
31	paus	1.13	#include "MitProd/TreeFiller/interface/FillerStableParts.h"
32	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
33			#include "MitProd/TreeFiller/interface/FillerTracks.h"
34			#include "MitProd/TreeFiller/interface/FillerVertexes.h"
35	loizides	1.35	#include "MitAna/DataTree/interface/Names.h"
36			#include "MitAna/DataTree/interface/BranchTable.h"
37	loizides	1.21
38	paus	1.1	using namespace std;
39			using namespace edm;
40			using namespace mithep;
41
42	loizides	1.16	mithep::ObjectService *mithep::FillMitTree::os_ = 0;
43
44	loizides	1.9	//--------------------------------------------------------------------------------------------------
45	loizides	1.7	FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
46	loizides	1.35	defactive_(cfg.getUntrackedParameter<bool>("defactive",1)),
47	loizides	1.40	brtable_(0),
48			acfnumber_(-1)
49	paus	1.1	{
50	loizides	1.6	// Constructor.
51	loizides	1.15
52	loizides	1.3	if (!configure(cfg)) {
53			throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
54			<< "Could not configure fillers." << "\n";
55			}
56	paus	1.1	}
57
58	loizides	1.9	//--------------------------------------------------------------------------------------------------
59	paus	1.1	FillMitTree::~FillMitTree()
60			{
61	loizides	1.35	// Destructor.
62
63			delete brtable_;
64	paus	1.1	}
65
66	loizides	1.9	//--------------------------------------------------------------------------------------------------
67	loizides	1.17	bool FillMitTree::addActiveFiller(BaseFiller *bf)
68			{
69			// Check if filler is active and add it to list of fillers. Otherwise delete it.
70
71	loizides	1.35	if (!bf)
72			return 0;
73
74	loizides	1.17	if (bf->Active()) {
75			fillers_.push_back(bf);
76			return 1;
77			}
78
79			delete bf;
80			bf = 0;
81			return 0;
82			}
83
84			//--------------------------------------------------------------------------------------------------
85	loizides	1.3	void FillMitTree::analyze(const edm::Event &event,
86			const edm::EventSetup &setup)
87			{
88			// Access and copy event content.
89
90	loizides	1.32	// first step: Loop over the data fillers of the various components
91	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
92			(*iF)->FillDataBlock(event,setup);
93			}
94
95	loizides	1.32	// second step: Loop over the link resolution of the various components
96	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
97			(*iF)->ResolveLinks(event,setup);
98			}
99	loizides	1.38
100	loizides	1.40	if (brtable_) { // only the first FillMitTree object has to deal with the branch table
101			if (acfnumber_==-1) {
102			brtable_->Rehash(brtable_->GetSize());
103			if (0)
104			brtable_->Print();
105			}
106			if (acfnumber_ != tws_->GetFileNumber()) {
107			tws_->StoreObject(brtable_);
108			acfnumber_ = tws_->GetFileNumber();
109			}
110			}
111	loizides	1.3	}
112
113	loizides	1.9	//--------------------------------------------------------------------------------------------------
114	loizides	1.3	void FillMitTree::beginJob(const edm::EventSetup &event)
115	paus	1.1	{
116	loizides	1.2	// Access the tree and book branches.
117
118	paus	1.1	Service<TreeService> ts;
119	loizides	1.40	tws_ = ts->get();
120			if (!tws_) {
121	paus	1.1	throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
122	loizides	1.17	<< "Could not get pointer to tree. "
123			<< "Do you have the TreeServie define in your config?" << "\n";
124	paus	1.1	return;
125			}
126	loizides	1.16
127	loizides	1.40	if (os_==0) { // only the first FillMitTree object has to deal with this
128	loizides	1.16	Service<ObjectService> os;
129			if (!os.isAvailable()) {
130			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
131	loizides	1.17	<< "Could not get object service. "
132			<< "Do you have the ObjectService defined in your config?" << "\n";
133	loizides	1.16	return;
134			}
135			os_ = &(*os);
136	loizides	1.40	brtable_ = new BranchTable;
137			brtable_->SetName(Names::gkBranchTable);
138			brtable_->SetOwner();
139	loizides	1.35	os->add(brtable_, brtable_->GetName());
140	loizides	1.16	}
141
142	loizides	1.32	// loop over the various components and book the branches
143	paus	1.1	for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
144	loizides	1.16	edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
145	loizides	1.40	(iF)->BookDataBlock(tws_);
146	paus	1.1	}
147			}
148
149	loizides	1.9	//--------------------------------------------------------------------------------------------------
150	loizides	1.3	bool FillMitTree::configure(const edm::ParameterSet &cfg)
151	paus	1.1	{
152	loizides	1.36	// Configure our fillers according to given parameter ("fillers").
153	loizides	1.3
154	bendavid	1.33	std::vector<std::string> pars;
155	loizides	1.36	if (cfg.exists("fillers"))
156			pars=cfg.getUntrackedParameter<vector<string> >("fillers");
157	bendavid	1.33	else
158			cfg.getParameterSetNames(pars, false);
159	loizides	1.32
160			// loop over psets
161			for (unsigned int i = 0; i<pars.size(); ++i) {
162
163			const string name(pars.at(i));
164
165	loizides	1.37	string ftype("Filler" + name);
166			if (cfg.existsAs<ParameterSet>(name,0)) {
167			ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
168			if (!next.exists("fillerType")) {
169	loizides	1.42	edm::LogError("FillMitTree") << "Cannot determine fillerType for pset named "
170	loizides	1.37	<< name << std::endl;
171			throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
172	loizides	1.42	<< "Cannot determine fillerType for pset named "
173	loizides	1.37	<< name << std::endl;
174			}
175			ftype = next.getUntrackedParameter<string>("fillerType");
176	loizides	1.32	}
177	loizides	1.2
178	loizides	1.37	edm::LogInfo("FillMitTree") << "Attempting to configure '" << ftype
179			<< "' for '" << name << "'" << std::endl;
180	loizides	1.35
181	loizides	1.32	if (ftype.compare("FillerMetaInfos")==0) {
182			FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
183			addActiveFiller(fillerMetaInfos);
184			continue;
185			}
186	loizides	1.37
187	loizides	1.32	if (ftype.compare("FillerMCParticles")==0) {
188			FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
189			addActiveFiller(fillerMCParticles);
190			continue;
191			}
192	loizides	1.37
193			if (ftype.compare("FillerMCEventInfo")==0) {
194			FillerMCEventInfo *fillerMCEventInfo = new FillerMCEventInfo(cfg, name.c_str(), defactive_);
195			addActiveFiller(fillerMCEventInfo);
196			continue;
197			}
198
199	loizides	1.32	if (ftype.compare("FillerBeamSpot")==0) {
200			FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
201			addActiveFiller(fillerBeamSpot);
202			continue;
203			}
204	loizides	1.40
205	loizides	1.32	if (ftype.compare("FillerVertexes")==0) {
206			FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
207			addActiveFiller(fillerVertexes);
208			continue;
209			}
210
211			if (ftype.compare("FillerCaloTowers")==0) {
212			FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
213			addActiveFiller(fillerCaloTowers);
214			continue;
215			}
216
217			if (ftype.compare("FillerGenJets")==0) {
218			FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
219			addActiveFiller(fillerGenJets);
220			continue;
221			}
222
223			if (ftype.compare("FillerCaloJets")==0) {
224			FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
225			addActiveFiller(fillerCaloJets);
226			continue;
227			}
228	bendavid	1.34
229			if (ftype.compare("FillerMet")==0) {
230			FillerMet *fillerMet = new FillerMet(cfg, name.c_str(), defactive_);
231			addActiveFiller(fillerMet);
232			continue;
233			}
234
235	loizides	1.32	if (ftype.compare("FillerCaloMet")==0) {
236			FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
237			addActiveFiller(fillerCaloMet);
238			continue;
239	bendavid	1.34	}
240
241			if (ftype.compare("FillerPFMet")==0) {
242			FillerPFMet *fillerPFMet = new FillerPFMet(cfg, name.c_str(), defactive_);
243			addActiveFiller(fillerPFMet);
244			continue;
245	loizides	1.32	}
246
247			if (ftype.compare("FillerBasicClusters")==0) {
248			FillerBasicClusters *fillerBasicClusters =
249			new FillerBasicClusters(cfg, name.c_str(), defactive_);
250			addActiveFiller(fillerBasicClusters);
251			continue;
252			}
253
254			if (ftype.compare("FillerSuperClusters")==0) {
255			FillerSuperClusters *fillerSuperClusters =
256			new FillerSuperClusters(cfg, name.c_str(), defactive_);
257			addActiveFiller(fillerSuperClusters);
258			continue;
259			}
260
261			if (ftype.compare("FillerTracks")==0) {
262			FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
263			addActiveFiller(fillerTracks);
264			continue;
265			}
266
267			if (ftype.compare("FillerMuons")==0) {
268			FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
269			addActiveFiller(fillerMuons);
270			continue;
271			}
272
273			if (ftype.compare("FillerElectrons")==0) {
274			FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
275			addActiveFiller(fillerElectrons);
276			continue;
277			}
278
279			if (ftype.compare("FillerConversions")==0) {
280			FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
281			addActiveFiller(fillerConversions);
282			continue;
283			}
284
285			if (ftype.compare("FillerPhotons")==0) {
286			FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
287			addActiveFiller(fillerPhotons);
288			continue;
289			}
290
291			if (ftype.compare("FillerStableParts")==0) {
292			FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
293			addActiveFiller(fillerStableParts);
294			continue;
295			}
296
297			if (ftype.compare("FillerDecayParts")==0) {
298			FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
299			addActiveFiller(fillerDecayParts);
300			continue;
301			}
302	bendavid	1.33
303			if (ftype.compare("FillerPFCandidates")==0) {
304	loizides	1.35	FillerPFCandidates *fillerPFCands = new FillerPFCandidates(cfg, name.c_str(), defactive_);
305			addActiveFiller(fillerPFCands);
306	bendavid	1.33	continue;
307			}
308	loizides	1.32
309	bendavid	1.33	if (ftype.compare("FillerPFJets")==0) {
310			FillerPFJets *fillerPFJets = new FillerPFJets(cfg, name.c_str(), defactive_);
311			addActiveFiller(fillerPFJets);
312			continue;
313			}
314	bendavid	1.41
315			if (ftype.compare("FillerCaloTaus")==0) {
316			FillerCaloTaus *fillerCaloTaus = new FillerCaloTaus(cfg, name.c_str(), defactive_);
317			addActiveFiller(fillerCaloTaus);
318			continue;
319			}
320
321			if (ftype.compare("FillerPFTaus")==0) {
322			FillerPFTaus *fillerPFTaus = new FillerPFTaus(cfg, name.c_str(), defactive_);
323			addActiveFiller(fillerPFTaus);
324			continue;
325			}
326	bendavid	1.33
327	loizides	1.32	edm::LogError("FillMitTree")
328			<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
329			throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
330			<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
331			}
332	paus	1.13
333	loizides	1.3	return 1;
334	paus	1.1	}
335
336	loizides	1.9	//--------------------------------------------------------------------------------------------------
337	paus	1.1	void FillMitTree::endJob()
338			{
339	loizides	1.2	// Delete fillers.
340
341			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
342			delete *iF;
343			}
344
345	paus	1.1	edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
346			}