ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitProd/TreeFiller/src/FillMitTree.cc
(Generate patch)

Comparing UserCode/MitProd/TreeFiller/src/FillMitTree.cc (file contents):
Revision 1.9 by loizides, Thu Jul 3 07:56:14 2008 UTC vs.
Revision 1.22 by sixie, Tue Sep 16 18:21:33 2008 UTC

# Line 4 | Line 4
4   #include "FWCore/MessageLogger/interface/MessageLogger.h"
5   #include "FWCore/ServiceRegistry/interface/Service.h"
6   #include "MitProd/TreeService/interface/TreeService.h"
7 + #include "MitProd/ObjectService/interface/ObjectService.h"
8   #include "MitProd/TreeFiller/interface/AssociationMaps.h"
9   #include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
9 – #include "MitProd/TreeFiller/interface/FillerSimParticles.h"
10   #include "MitProd/TreeFiller/interface/FillerTracks.h"
11   #include "MitProd/TreeFiller/interface/FillerGsfTracks.h"
12 + #include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
13 + #include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
14 + #include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
15   #include "MitProd/TreeFiller/interface/FillerMuons.h"
16   #include "MitProd/TreeFiller/interface/FillerElectrons.h"
17 < #include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
17 > #include "MitProd/TreeFiller/interface/FillerGenJets.h"
18 > #include "MitProd/TreeFiller/interface/FillerCaloJets.h"
19 > #include "MitProd/TreeFiller/interface/FillerCaloMet.h"
20   #include "MitProd/TreeFiller/interface/FillerConversions.h"
21 + #include "MitProd/TreeFiller/interface/FillerConversionElectrons.h"
22   #include "MitProd/TreeFiller/interface/FillerPhotons.h"
23 < #include "MitProd/TreeFiller/interface/FillerGenParts.h"
23 > #include "MitProd/TreeFiller/interface/FillerMCParticles.h"
24 > #include "MitProd/TreeFiller/interface/FillerDecayParts.h"
25 > #include "MitProd/TreeFiller/interface/FillerStableParts.h"
26 > #include "MitProd/TreeFiller/interface/FillerPATMuons.h"
27 > #include "MitProd/TreeFiller/interface/FillerPATElectrons.h"
28  
29   using namespace std;
30   using namespace edm;
31   using namespace mithep;
32  
33 + mithep::ObjectService *mithep::FillMitTree::os_ = 0;
34 +
35   //--------------------------------------------------------------------------------------------------
36   FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
37    defactive_(cfg.getUntrackedParameter<bool>("defactive",1))
38   {
39    // Constructor.
40 <    
40 >
41    if (!configure(cfg)) {
42      throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
43        << "Could not configure fillers." << "\n";
# Line 39 | Line 51 | FillMitTree::~FillMitTree()
51   }
52  
53   //--------------------------------------------------------------------------------------------------
54 + bool FillMitTree::addActiveFiller(BaseFiller *bf)
55 + {
56 +  // Check if filler is active and add it to list of fillers. Otherwise delete it.
57 +
58 +  if (bf->Active()) {
59 +    fillers_.push_back(bf);
60 +    return 1;
61 +  }
62 +
63 +  delete bf;
64 +  bf = 0;
65 +  return 0;
66 + }
67 +
68 + //--------------------------------------------------------------------------------------------------
69   void FillMitTree::analyze(const edm::Event      &event,
70                            const edm::EventSetup &setup)
71   {
# Line 64 | Line 91 | void FillMitTree::beginJob(const edm::Ev
91    TreeWriter *tws = ts->get();
92    if (! tws) {
93      throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
94 <      << "Could not get pointer to tree." << "\n";
94 >      << "Could not get pointer to tree. "
95 >      << "Do you have the TreeServie define in your config?" << "\n";
96      return;
97    }
98 <  
98 >
99 >  if (os_==0) {
100 >    Service<ObjectService> os;
101 >    if (!os.isAvailable()) {
102 >      throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
103 >        << "Could not get object service. "
104 >        << "Do you have the ObjectService defined in your config?" << "\n";
105 >      return;
106 >    }
107 >    os_ = &(*os);
108 >  }
109 >
110    // Loop over the various components and book the branches
111    for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
112 +    edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
113      (*iF)->BookDataBlock(*tws);
114    }
115   }
# Line 79 | Line 119 | bool FillMitTree::configure(const edm::P
119   {
120    // Configure our fillers.
121  
122 <  FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg);
123 <  if (fillerMetaInfos->Active())
124 <    fillers_.push_back(fillerMetaInfos);
125 <  else
126 <    delete fillerMetaInfos;
127 <
128 <  FillerGenParts *fillerGenParts = new FillerGenParts(cfg,defactive_);
129 <  if (fillerGenParts->Active())
130 <    fillers_.push_back(fillerGenParts);
131 <  else
132 <    delete fillerGenParts;  
133 <    
134 <  FillerSimParticles *fillerSimParticles = new FillerSimParticles(cfg,defactive_);
135 <  const SimParticleMap* simParticleMap=0;
136 <  if (fillerSimParticles->Active()) {
137 <    fillers_.push_back(fillerSimParticles);
138 <    simParticleMap = fillerSimParticles->GetSimParticleMap();
139 <  }
140 <  else
141 <    delete fillerSimParticles;  
142 <  
143 <  FillerTracks *fillerGeneralTracks =
144 <    new FillerTracks(cfg,"GeneralTracks",defactive_,simParticleMap);
145 <  const TrackMap* generalTrackMap=0;
146 <  if (fillerGeneralTracks->Active()) {
147 <    fillers_.push_back(fillerGeneralTracks);
148 <    generalTrackMap = fillerGeneralTracks->GetTrackMap();
149 <  }
110 <  else
111 <    delete fillerGeneralTracks;
112 <    
122 >  FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg,defactive_);
123 >  addActiveFiller(fillerMetaInfos);
124 >
125 >  FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg,"MCParticles",defactive_);
126 >  addActiveFiller(fillerMCParticles);
127 >
128 >  FillerCaloTowers *fillerCaloTowers =
129 >    new FillerCaloTowers(cfg, "CaloTowers", defactive_);
130 >  addActiveFiller(fillerCaloTowers);
131 >
132 >  FillerGenJets *fillerIC5GenJets = new FillerGenJets(cfg,"IC5GenJets",defactive_);
133 >  addActiveFiller(fillerIC5GenJets);
134 >
135 >  FillerGenJets *fillerSC5GenJets = new FillerGenJets(cfg,"SC5GenJets",defactive_);
136 >  addActiveFiller(fillerSC5GenJets);
137 >
138 >  FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg,"CaloJets",defactive_);
139 >  addActiveFiller(fillerCaloJets);
140 >
141 >  FillerCaloJets *fillerSisCone5Jets = new FillerCaloJets(cfg,"SisCone5Jets",defactive_);
142 >  addActiveFiller(fillerSisCone5Jets);
143 >
144 >  FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg,"CaloMet",defactive_);
145 >  addActiveFiller(fillerCaloMet);
146 >
147 >  FillerTracks *fillerGeneralTracks = new FillerTracks(cfg,"GeneralTracks",defactive_);
148 >  addActiveFiller(fillerGeneralTracks);
149 >
150    FillerTracks *fillerStandaloneMuonTracks =
151      new FillerTracks(cfg,"StandaloneMuonTracks",defactive_);
152 <  const TrackMap* standaloneMuonTrackMap=0;
116 <  if (fillerStandaloneMuonTracks->Active()) {
117 <    fillers_.push_back(fillerStandaloneMuonTracks);
118 <    standaloneMuonTrackMap = fillerStandaloneMuonTracks->GetTrackMap();
119 <  }
120 <  else
121 <    delete fillerStandaloneMuonTracks;
152 >  addActiveFiller(fillerStandaloneMuonTracks);
153  
154    FillerTracks *fillerStandaloneMuonTracksVtx =
155      new FillerTracks(cfg,"StandaloneMuonTracksWVtxConstraint",defactive_);
156 <  const TrackMap* standaloneMuonTrackVtxMap=0;
157 <  if (fillerStandaloneMuonTracksVtx->Active()) {
127 <    fillers_.push_back(fillerStandaloneMuonTracksVtx);
128 <    standaloneMuonTrackVtxMap = fillerStandaloneMuonTracksVtx->GetTrackMap();
129 <  }
130 <  else
131 <    delete fillerStandaloneMuonTracksVtx;
132 <    
156 >  addActiveFiller(fillerStandaloneMuonTracksVtx);
157 >
158    FillerTracks *fillerGlobalMuonTracks = new FillerTracks(cfg,"GlobalMuonTracks",defactive_);
159 <  const TrackMap* globalMuonTrackMap=0;
135 <  if (fillerGlobalMuonTracks->Active()) {
136 <    fillers_.push_back(fillerGlobalMuonTracks);
137 <    globalMuonTrackMap = fillerGlobalMuonTracks->GetTrackMap();
138 <  }
139 <  else
140 <    delete fillerGlobalMuonTracks;  
159 >  addActiveFiller(fillerGlobalMuonTracks);
160      
161    FillerTracks *fillerConversionInOutTracks =
162 <    new FillerTracks(cfg,"ConversionInOutTracks",defactive_,simParticleMap);
163 <  const TrackMap* conversionInOutTrackMap=0;
164 <  const TrackCol* conversionInOutTracks=0;
146 <  if (fillerConversionInOutTracks->Active()) {
147 <    fillers_.push_back(fillerConversionInOutTracks);
148 <    conversionInOutTrackMap = fillerConversionInOutTracks->GetTrackMap();
149 <    conversionInOutTracks = fillerConversionInOutTracks->GetTrackCol();
150 <  }
151 <  else
152 <    delete fillerConversionInOutTracks;
153 <    
162 >    new FillerTracks(cfg,"ConversionInOutTracks",defactive_);
163 >  addActiveFiller(fillerConversionInOutTracks);
164 >
165    FillerTracks *fillerConversionOutInTracks =
166 <    new FillerTracks(cfg,"ConversionOutInTracks",defactive_,simParticleMap);
167 <  const TrackMap* conversionOutInTrackMap=0;
168 <  const TrackCol* conversionOutInTracks=0;
169 <  if (fillerConversionOutInTracks->Active()) {
170 <    fillers_.push_back(fillerConversionOutInTracks);
171 <    conversionOutInTrackMap = fillerConversionOutInTracks->GetTrackMap();
172 <    conversionOutInTracks = fillerConversionOutInTracks->GetTrackCol();
173 <  }
174 <  else
175 <    delete fillerConversionOutInTracks;
176 <    
177 <  FillerGsfTracks *fillerGsfTracks =
178 <    new FillerGsfTracks(cfg,"GsfTracks",defactive_,simParticleMap);
179 <  const GsfTrackMap* gsfTrackMap=0;
180 <  if (fillerGsfTracks->Active()) {
181 <    fillers_.push_back(fillerGsfTracks);
182 <    gsfTrackMap = (GsfTrackMap*)fillerGsfTracks->GetTrackMap();
183 <  }
184 <  else
185 <    delete fillerGsfTracks;
186 <    
176 <  FillerMuons *fillerMuons =
177 <    new FillerMuons(cfg,defactive_,globalMuonTrackMap,standaloneMuonTrackMap,
178 <                    standaloneMuonTrackVtxMap,generalTrackMap);
179 <  if (fillerMuons->Active())
180 <    fillers_.push_back(fillerMuons);
181 <  else
182 <    delete fillerMuons;
183 <    
184 <  FillerElectrons *fillerElectrons =
185 <    new FillerElectrons(cfg,defactive_,gsfTrackMap,generalTrackMap);
186 <  if (fillerElectrons->Active())
187 <    fillers_.push_back(fillerElectrons);
188 <  else
189 <    delete fillerElectrons;
166 >    new FillerTracks(cfg,"ConversionOutInTracks",defactive_);
167 >  addActiveFiller(fillerConversionOutInTracks);
168 >
169 >  FillerGsfTracks *fillerGsfTracks = new FillerGsfTracks(cfg,"GsfTracks",defactive_);
170 >  addActiveFiller(fillerGsfTracks);
171 >
172 >  FillerBasicClusters *fillerBarrelBasicClusters =
173 >    new FillerBasicClusters(cfg, "BarrelBasicClusters", defactive_);
174 >  addActiveFiller(fillerBarrelBasicClusters);
175 >
176 >  FillerSuperClusters *fillerBarrelSuperClusters =  
177 >    new FillerSuperClusters(cfg,"BarrelSuperClusters", defactive_);
178 >  addActiveFiller(fillerBarrelSuperClusters);
179 >
180 >  FillerBasicClusters *fillerEndcapBasicClusters =
181 >    new FillerBasicClusters(cfg,"EndcapBasicClusters", defactive_);
182 >  addActiveFiller(fillerEndcapBasicClusters);
183 >  
184 >  FillerSuperClusters *fillerEndcapSuperClusters =  
185 >    new FillerSuperClusters(cfg,"EndcapSuperClusters", defactive_);
186 >  addActiveFiller(fillerEndcapSuperClusters);
187    
188 +  FillerMuons *fillerMuons = new FillerMuons(cfg,defactive_);
189 +  addActiveFiller(fillerMuons);
190 +  
191 +  FillerElectrons *fillerElectrons = new FillerElectrons(cfg,defactive_);
192 +  addActiveFiller(fillerElectrons);
193 +
194    FillerConversionElectrons *fillerConversionElectrons =
195 <    new FillerConversionElectrons(cfg, defactive_, conversionInOutTracks, conversionOutInTracks,
196 <                                  conversionInOutTrackMap, conversionOutInTrackMap);
194 <  const ConversionElectronMap* convElectronMap=0;
195 <  if (fillerConversionElectrons->Active()) {
196 <    fillers_.push_back(fillerConversionElectrons);
197 <    convElectronMap = fillerConversionElectrons->GetConversionElectronMap();
198 <  }
199 <  else
200 <    delete fillerConversionElectrons;
201 <    
202 <  FillerConversions *fillerConversions = new FillerConversions(cfg, defactive_, convElectronMap);
203 <  const ConversionMap* conversionMap=0;
204 <  if (fillerConversions->Active()) {
205 <    fillers_.push_back(fillerConversions);
206 <    conversionMap = fillerConversions->GetConversionMap();
207 <  }
208 <  else
209 <    delete fillerConversions;
210 <    
211 <  FillerPhotons *fillerPhotons = new FillerPhotons(cfg, defactive_, conversionMap);
212 <  if (fillerPhotons->Active())
213 <    fillers_.push_back(fillerPhotons);
214 <  else
215 <    delete fillerPhotons;
195 >    new FillerConversionElectrons(cfg,defactive_);
196 >  addActiveFiller(fillerConversionElectrons);
197  
198 +  FillerConversions *fillerConversions = new FillerConversions(cfg,defactive_);
199 +  addActiveFiller(fillerConversions);
200 +
201 +  FillerPhotons *fillerPhotons = new FillerPhotons(cfg,defactive_);
202 +  addActiveFiller(fillerPhotons);
203 +
204 +  FillerStableParts *fillerStableParts = new FillerStableParts(cfg,"StableParts",defactive_);
205 +  addActiveFiller(fillerStableParts);
206 +  
207 +  FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg,"DecayParts",defactive_);
208 +  addActiveFiller(fillerDecayParts);
209  
210    return 1;
211   }

Diff Legend

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