ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/FastOpenGlDisplayer/src/Frog_Analyzer.cc

Comparing UserCode/FastOpenGlDisplayer/src/Frog_Analyzer.cc (file contents):
Revision 1.4 by querten, Sun Apr 27 07:27:30 2008 UTC vs.
Revision 1.29 by roberfro, Thu Aug 21 15:08:52 2008 UTC

#	Line 49 | Line 49
49		#include "Geometry/Records/interface/IdealGeometryRecord.h"
50		#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"
51		#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
52	<	#include "Geometry/EcalBarrelAlgo/interface/EcalBarrelGeometry.h"
53	<	#include "Geometry/EcalEndcapAlgo/interface/EcalEndcapGeometry.h"
52	>	//#include "Geometry/EcalBarrelAlgo/interface/EcalBarrelGeometry.h"
53	>	//#include "Geometry/EcalEndcapAlgo/interface/EcalEndcapGeometry.h"
54	>	#include "Geometry/Records/interface/CaloGeometryRecord.h"
55	>	#include "Geometry/EcalAlgo/interface/EcalBarrelGeometry.h"
56	>	#include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
57		#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
58		#include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
59
#	Line 79 | Line 82
82		#include "DataFormats/HepMCCandidate/interface/GenParticleCandidate.h"
83		#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
84		#include "DataFormats/TrackReco/interface/Track.h"
85	+	#include "TrackingTools/PatternTools/interface/Trajectory.h"
86	+	#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
87	+
88
89		#include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h"
90		#include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h"
#	Line 91 | Line 97
97		#include "DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h"
98		#include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
99
100	<	#include "Visualisation/Frog/interface/SimEvent.h"
101	<	#include "Visualisation/Frog/interface/Geometry.h"
100	>	#include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
101	>	#include "DataFormats/SiStripDetId/interface/StripSubdetector.h"
102	>	#include "DataFormats/SiPixelDetId/interface/PXBDetId.h"
103	>	#include "DataFormats/SiPixelDetId/interface/PXFDetId.h"
104	>	#include "DataFormats/SiStripDetId/interface/TIBDetId.h"
105	>	#include "DataFormats/SiStripDetId/interface/TIDDetId.h"
106	>	#include "DataFormats/SiStripDetId/interface/TOBDetId.h"
107	>	#include "DataFormats/SiStripDetId/interface/TECDetId.h"
108	>
109	>	#include "DataFormats/MuonDetId/interface/DTChamberId.h"
110	>	#include "DataFormats/MuonDetId/interface/CSCDetId.h"
111	>	#include "DataFormats/MuonDetId/interface/RPCDetId.h"
112	>
113	>	#include "DataFormats/EcalDetId/interface/EBDetId.h"
114	>	#include "DataFormats/EcalDetId/interface/EEDetId.h"
115	>	#include "DataFormats/EcalDetId/interface/ESDetId.h"
116	>	#include "DataFormats/HcalDetId/interface/HcalDetId.h"
117	>
118	>	#include "DataFormats/VertexReco/interface/NuclearInteraction.h"
119	>
120	>	#include "DataFormats/JetReco/interface/Jet.h"
121	>	#include "DataFormats/JetReco/interface/BasicJetCollection.h"
122	>	#include "DataFormats/JetReco/interface/GenJetCollection.h"
123	>	#include "DataFormats/JetReco/interface/CaloJetCollection.h"
124	>	#include "DataFormats/JetReco/interface/PFJetCollection.h"
125	>
126	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Element_Base_With_DetId.h"
127	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Element_Tools.h"
128	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Element_Tools.cpp"
129	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Element_Event_Track.h"
130	>
131	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Events.h"
132	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Events.cpp"
133	>
134	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Geometry.h"
135	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Geometry.cpp"
136	>
137	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_DetId.h"
138	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_ReadCards.cpp"
139	>	#include "Visualisation/Frog/soft/Includes/FROG/FROG_Element_Event_NuclInt.h"
140	>
141	>
142
143		using namespace edm;
144		using namespace std;
145	+	using namespace reco;
146
147		//
148		// class decleration
#	Line 112 | Line 159 | class Frog_Analyzer : public edm::EDAnal
159		virtual void analyze (const edm::Event&, const edm::EventSetup&);
160		virtual void endJob  ();
161
162	+	FROG_Element_Base*    events_prim;
163
164	<	MySimEvents* MyEvents;
117	<	Geometry*    Geom_Tracker;
118	<	Geometry*    Geom_ECAL;
119	<	Geometry*    Geom_HCAL;
120	<	Geometry*    Geom_Muon;
121	<
122	<
123	<	std::string              OutputFile;
164	>	std::string           OutputFile;
165
166		std::vector<InputTag> SimTrackProducers;
167		std::vector<InputTag> SimVertexProducers;
168		std::vector<InputTag> SimHitProducers;
169	+	std::vector<InputTag> SimCaloHitProducers;
170	+
171	+	std::vector<InputTag> NIProducers;
172
173		std::vector<InputTag> TrackProducers;
174	+	std::vector<InputTag> TrajectoryProducers;
175		std::vector<InputTag> EcalRecHitProducers;
176		std::vector<InputTag> HcalHBHERecHitProducers;
177		std::vector<InputTag> HcalHORecHitProducers;
#	Line 136 | Line 181 | class Frog_Analyzer : public edm::EDAnal
181
182		std::vector<InputTag> RPCHitsProducers;
183
184	+	std::vector<InputTag> CaloJetsProducers;
185
186	+	// ----------member data ---------------------------
187
188	+	bool                  ProduceGeom;
189	+	int                   NEventsInVisFile;
190	+	int                   NEvents;
191
192	<	// ----------member data ---------------------------
192	>	unsigned int          SRun;
193	>	unsigned int          SEvent;
194		};
195
196		//
#	Line 152 | Line 203 | Frog_Analyzer::Frog_Analyzer(const edm::
203		SimTrackProducers       = iConfig.getParameter<std::vector<InputTag> >("SimTrackProducers");
204		SimVertexProducers      = iConfig.getParameter<std::vector<InputTag> >("SimVertexProducers");
205		SimHitProducers         = iConfig.getParameter<std::vector<InputTag> >("SimHitProducers");
206	+	SimCaloHitProducers     = iConfig.getParameter<std::vector<InputTag> >("SimCaloHitProducers");
207	+
208
209		TrackProducers          = iConfig.getParameter<std::vector<InputTag> >("TrackProducers");
210	+	TrajectoryProducers     = iConfig.getParameter<std::vector<InputTag> >("TrajectoryProducers");
211		EcalRecHitProducers     = iConfig.getParameter<std::vector<InputTag> >("EcalRecHitProducers");
212		HcalHBHERecHitProducers = iConfig.getParameter<std::vector<InputTag> >("HcalHBHERecHitProducers");
213		HcalHORecHitProducers   = iConfig.getParameter<std::vector<InputTag> >("HcalHORecHitProducers");
214		HcalHFRecHitProducers   = iConfig.getParameter<std::vector<InputTag> >("HcalHFRecHitProducers");
215
216	+	NIProducers             = iConfig.getParameter<std::vector<InputTag> >("NIProducers");
217	+
218		DTSegmentProducers      = iConfig.getParameter<std::vector<InputTag> >("DTSegmentProducers");
219		CSCSegmentProducers     = iConfig.getParameter<std::vector<InputTag> >("CSCSegmentProducers");
220
221		RPCHitsProducers        = iConfig.getParameter<std::vector<InputTag> >("RPCHitsProducers");
222
223	+	CaloJetsProducers       = iConfig.getParameter<std::vector<InputTag> >("CaloJetsProducers");
224	+
225	+	ProduceGeom             = iConfig.getParameter<bool  >("ProduceGeom"       );
226	+	NEventsInVisFile        = iConfig.getParameter<int   >("NEventsInVisFile"  );
227	+
228	+	NEvents = 0;
229		}
230
231
#	Line 175 | Line 237 | Frog_Analyzer::~Frog_Analyzer()
237		void
238		Frog_Analyzer::beginJob(const edm::EventSetup& iSetup)
239		{
240	<	DetId  Detid;
241	<	int    SubDet;
240	>	if(ProduceGeom){
241	>	DetId  Detid;
242	>	unsigned int    SubDet;
243	>
244	>	unsigned int Frog_DetId;
245	>	FROG_Element_Base*            FEB      = NULL;
246	>	FROG_Element_Base_With_DetId* FEB_Temp = NULL;
247	>
248	>	FROG_Element_Base* prim               = new FROG_Element_Base(C_PRIMARY);
249	>	FROG_Element_Base* geom               = new FROG_Element_Base(C_GEOMETRY);                          prim->addDaughter(geom);
250	>	FROG_Element_Base_With_DetId* tracker = new FROG_Element_Base_With_DetId(C_FEB_DETID, DETID_TRK);   geom->addDaughter(tracker);
251	>	FROG_Element_Base_With_DetId* muon    = new FROG_Element_Base_With_DetId(C_FEB_DETID, DETID_MUON);  geom->addDaughter(muon);
252	>	FROG_Element_Base_With_DetId* ecal    = new FROG_Element_Base_With_DetId(C_FEB_DETID, DETID_ECAL);  geom->addDaughter(ecal);
253	>	FROG_Element_Base_With_DetId* hcal    = new FROG_Element_Base_With_DetId(C_FEB_DETID, DETID_HCAL);  geom->addDaughter(hcal);
254	>
255	>
256	>	// ### TRACKER GEOMETRY ###
257	>
258	>	edm::ESHandle<TrackerGeometry> tkGeom;
259	>	iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
260	>	vector<GeomDet*> TrackerDets = tkGeom->dets();
261	>
262	>	for(unsigned int i=0;i<TrackerDets.size();i++){
263	>	Detid  = TrackerDets[i]->geographicalId();
264	>	SubDet = Detid.subdetId();
265	>	if(SubDet<1 || SubDet>6) continue;
266	>
267	>
268	>	GeomDet* DetUnit = TrackerDets[i];
269	>	if(!DetUnit)continue;
270	>	const BoundPlane plane = DetUnit->surface();
271	>	const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
272	>	const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));
273	>
274	>	float width            = 0;
275	>	float length           = 0;
276	>	float thickness        = 0;
277	>	float TrapezoidalParam = 0;
278	>
279	>	if(trapezoidalBounds){
280	>	std::vector<float> const & parameters = (*trapezoidalBounds).parameters();
281	>	width            = parameters[0]*2;
282	>	length           = parameters[3]*2;
283	>	thickness        = (*trapezoidalBounds).thickness();
284	>	TrapezoidalParam = parameters[1]/parameters[0];
285	>	}else if(rectangularBounds){
286	>	width            = DetUnit->surface().bounds().width();
287	>	length           = DetUnit->surface().bounds().length();
288	>	thickness        = DetUnit->surface().bounds().thickness();
289	>	TrapezoidalParam = 1;
290	>	}
291	>
292	>	Surface::GlobalPoint WidthVector  = plane.toGlobal( LocalPoint(width/2, 0, 0) );
293	>	Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
294	>	Surface::GlobalPoint ThickVector  = plane.toGlobal( LocalPoint(0, 0, thickness/2) );
295	>
296	>	GlobalVector Pos =  GlobalVector(DetUnit->position().basicVector());
297	>
298	>	FROG_Element_Geom_TrackerMod* mod = new FROG_Element_Geom_TrackerMod(
299	>	Detid.rawId(),           TrapezoidalParam,
300	>	Pos.x(),                  Pos.y(),                  Pos.z(),
301	>	WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
302	>	LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
303	>	ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
304
181	–	MyEvents     = new MySimEvents();
182	–	Geom_Tracker = new Geometry();
183	–	Geom_ECAL    = new Geometry();
184	–	Geom_HCAL    = new Geometry();
185	–	Geom_Muon    = new Geometry();
305
306	+	Frog_DetId = DETID_TRK;
307	+	FEB        = tracker;
308	+
309	+	Frog_DetId += SubDet*100000;
310	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
311	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
312	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
313	+
314	+	if(SubDet==PixelSubdetector::PixelBarrel){
315	+	PXBDetId detid = PXBDetId(Detid);
316	+
317	+	Frog_DetId += detid.layer()*10000;
318	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
319	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
320	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
321	+
322	+	Frog_DetId += detid.ladder()*100;
323	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
324	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
325	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
326	+	}else if(SubDet==PixelSubdetector::PixelEndcap){
327	+	PXFDetId detid = PXFDetId(Detid);
328	+
329	+	Frog_DetId += detid.side()*10000;
330	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
331	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
332	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
333	+
334	+	Frog_DetId += detid.disk()*1000;
335	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
336	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
337	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
338	+
339	+	Frog_DetId += detid.blade()*10;
340	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
341	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
342	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
343	+
344	+	Frog_DetId += detid.panel()*1;
345	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
346	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
347	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
348	+	}else if(SubDet==StripSubdetector::TIB){
349	+	TIBDetId detid = TIBDetId(Detid);
350	+
351	+	Frog_DetId += detid.layer()*10000;
352	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
353	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
354	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
355	+
356	+	Frog_DetId += detid.stringNumber()*100;
357	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
358	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
359	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
360	+	}else if(SubDet==StripSubdetector::TID){
361	+	TIDDetId detid = TIDDetId(Detid);
362	+
363	+	Frog_DetId += detid.side()*10000;
364	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
365	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
366	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
367	+
368	+	Frog_DetId += detid.wheel()*1000;
369	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
370	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
371	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
372	+
373	+	Frog_DetId += detid.ring()*10;
374	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
375	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
376	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
377	+	}else if(SubDet==StripSubdetector::TOB){
378	+	TOBDetId detid = TOBDetId(Detid);
379	+
380	+	Frog_DetId += detid.layer()*10000;
381	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
382	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
383	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
384	+
385	+	Frog_DetId += detid.rodNumber()*100;
386	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
387	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
388	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
389	+	}else if(SubDet==StripSubdetector::TEC){
390	+	TECDetId detid = TECDetId(Detid);
391	+
392	+	Frog_DetId += detid.side()*10000;
393	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
394	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
395	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
396	+
397	+	Frog_DetId += detid.wheel()*1000;
398	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
399	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
400	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
401	+
402	+	Frog_DetId += detid.ring()*10;
403	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
404	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
405	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
406	+
407	+	Frog_DetId += detid.petalNumber();
408	+	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
409	+	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
410	+	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
411	+	}else{
412	+	if(mod)delete mod;
413	+	continue;
414	+	}
415	+	FEB->addDaughter(mod);
416	+	}
417
188	–	// ### TRACKER GEOMETRY ###
418
419	<	edm::ESHandle<TrackerGeometry> tkGeom;
191	<	iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
192	<	vector<GeomDet*> TrackerDets = tkGeom->dets();
419	>	// ### MUON GEOMETRY ###
420
421	<	for(unsigned int i=0;i<TrackerDets.size();i++){
422	<	Detid  = TrackerDets[i]->geographicalId();
423	<	//    SubDet = Detid.subdetId();
424	<
425	<	GeomDet* DetUnit = TrackerDets[i];
426	<	if(!DetUnit)continue;
427	<	const BoundPlane plane = DetUnit->surface();
428	<	const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
429	<	const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));
430	<
431	<	float width            = 0;
432	<	float length           = 0;
433	<	float thickness        = 0;
434	<	float TrapezoidalParam = 0;
421	>	edm::ESHandle<DTGeometry> DtGeom;
422	>	iSetup.get<MuonGeometryRecord>().get( DtGeom );
423	>	const vector<GeomDet*> DtDets = DtGeom->dets();
424	>
425	>	edm::ESHandle<CSCGeometry> CscGeom;
426	>	iSetup.get<MuonGeometryRecord>().get( CscGeom );
427	>	const vector<GeomDet*> CscDets = CscGeom->dets();
428	>
429	>	edm::ESHandle<RPCGeometry> RpcGeom;
430	>	iSetup.get<MuonGeometryRecord>().get( RpcGeom );
431	>	const vector<GeomDet*> RpcDets = RpcGeom->dets();
432	>
433	>	vector<GeomDet*> MuonDets;
434	>	for(unsigned int i=0;i<DtDets.size() ;i++){MuonDets.push_back(DtDets [i]);}
435	>	for(unsigned int i=0;i<CscDets.size();i++){MuonDets.push_back(CscDets[i]);}
436	>	for(unsigned int i=0;i<RpcDets.size();i++){MuonDets.push_back(RpcDets[i]);}
437
438	<	if(trapezoidalBounds)
438	>	for(unsigned int i=0;i<MuonDets.size();i++)
439		{
440	<	std::vector<float> const & parameters = (*trapezoidalBounds).parameters();
441	<	width            = parameters[0]*2;
213	<	length           = parameters[3]*2;
214	<	thickness        =  (*trapezoidalBounds).thickness();
215	<	TrapezoidalParam = parameters[1]/parameters[0];
216	<	}else if(rectangularBounds){
217	<	width            = DetUnit->surface().bounds().width();
218	<	length           = DetUnit->surface().bounds().length();
219	<	thickness        = DetUnit->surface().bounds().thickness();
220	<	TrapezoidalParam = 1;
221	<	}
440	>	Detid  = DetId(MuonDets[i]->geographicalId());
441	>	SubDet = Detid.subdetId();
442
443	<	Surface::GlobalPoint WidthVector  = plane.toGlobal( LocalPoint(width/2, 0, 0) );
444	<	Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
445	<	Surface::GlobalPoint ThickVector  = plane.toGlobal( LocalPoint(0, 0, thickness/2) );
446	<
447	<	GlobalVector Pos =  GlobalVector(DetUnit->position().basicVector());
448	<
449	<	Geom_Tracker->Add_TrackerDet(Detid.rawId(), TrapezoidalParam,
450	<	Pos.x(),                  Pos.y(),                  Pos.z(),
451	<	WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
452	<	LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
453	<	ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
454	<
443	>	GeomDet* DetUnit = MuonDets[i];
444	>	if(!DetUnit)continue;
445	>	const BoundPlane plane = DetUnit->surface();
446	>	const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
447	>	const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));
448	>
449	>	float width            = 0;
450	>	float length           = 0;
451	>	float thickness        = 0;
452	>	float TrapezoidalParam = 0;
453	>
454	>	if(trapezoidalBounds)
455	>	{
456	>	std::vector<float> const & parameters = (*trapezoidalBounds).parameters();
457	>	width            = parameters[0]*2;
458	>	length           = parameters[3]*2;
459	>	thickness        =  (*trapezoidalBounds).thickness();
460	>	TrapezoidalParam = parameters[1]/parameters[0];
461	>	}else if(rectangularBounds){
462	>	width            = DetUnit->surface().bounds().width();
463	>	length           = DetUnit->surface().bounds().length();
464	>	thickness        = DetUnit->surface().bounds().thickness();
465	>	TrapezoidalParam = 1;
466	>	}
467	>
468	>	Surface::GlobalPoint WidthVector  = plane.toGlobal( LocalPoint(width/2, 0, 0) );
469	>	Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
470	>	Surface::GlobalPoint ThickVector  = plane.toGlobal( LocalPoint(0, 0, thickness/2) );
471	>
472	>	GlobalVector Pos =  GlobalVector(DetUnit->position().basicVector());
473	>
474	>	FROG_Element_Geom_TrackerMod* mod = new FROG_Element_Geom_TrackerMod(
475	>	Detid.rawId(),           TrapezoidalParam,
476	>	Pos.x(),                  Pos.y(),                  Pos.z(),
477	>	WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
478	>	LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
479	>	ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
480	>
481	>	Frog_DetId = DETID_MUON;
482	>	FEB        = muon;
483	>
484	>	Frog_DetId += SubDet*100000;
485	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
486	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
487	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
488	>
489	>	if(SubDet==1){
490	>	DTChamberId detid = DTChamberId(Detid);
491	>
492	>	Frog_DetId += (detid.wheel()+3)*10000;
493	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
494	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
495	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
496	>
497	>	Frog_DetId += detid.station()*100;
498	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
499	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
500	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
501	>
502	>	Frog_DetId += detid.sector()*1;
503	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
504	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
505	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
506	>	}else if(SubDet==2){
507	>	CSCDetId detid = CSCDetId(Detid);
508	>
509	>	Frog_DetId += detid.endcap()*10000;
510	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
511	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
512	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
513	>
514	>	Frog_DetId += detid.station()*1000;
515	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
516	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
517	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
518	>
519	>	Frog_DetId += detid.ring()*100;
520	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
521	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
522	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
523	>
524	>	Frog_DetId += detid.chamber()*1;
525	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
526	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
527	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
528	>	}else if(SubDet==3){
529	>	RPCDetId detid = RPCDetId(Detid);
530	>
531	>	Frog_DetId += (detid.region()+2)*10000;
532	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
533	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
534	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
535	>
536	>	// Barrel
537	>	if(detid.region()==0){
538	>	Frog_DetId += (detid.ring()+3)*1000;
539	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
540	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
541	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
542	>	// Endcap
543	>	}else{
544	>	Frog_DetId += detid.ring()*1000;
545	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
546	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
547	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
548	>	}
549	>
550	>	Frog_DetId += detid.station()*100;
551	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
552	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
553	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
554	>
555	>	Frog_DetId += detid.sector()*1;
556	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
557	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
558	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
559	>	}
560
561	<	}
561	>	FEB->addDaughter(mod);
562	>	}
563
564
565	<	// ### CALO GEOMETRY ###
565	>
566	>	// ### CALO GEOMETRY ###
567
568	<	edm::ESHandle<CaloGeometry> CaloGeom;
569	<	iSetup.get<IdealGeometryRecord>().get( CaloGeom );
570	<	const vector<DetId> CaloDets = CaloGeom->getValidDetIds();
244	<
245	<	for(unsigned int i=0;i<CaloDets.size();i++)
246	<	{
247	<	Detid  = CaloDets[i];
248	<	SubDet = Detid.subdetId();
249	<
250	<	Geometry* Geom_temp = NULL;
251	<	if(Detid.det()==DetId::Ecal){
252	<	Geom_temp = Geom_ECAL;
253	<
254	<	if(SubDet<1 || SubDet>3){
255	<	printf("Don't Save EcalTriggerTower or EcalLaserPnDiode\n");
256	<	continue;
257	<	}
258	<	}else if(Detid.det()==DetId::Hcal){
259	<	Geom_temp = Geom_HCAL;
260	<
261	<	if(SubDet<1 || SubDet>4){
262	<	printf("Don't Save HcalEmpty, HcalTriggerTower, HcalOther\n");
263	<	continue;
264	<	}
265	<	}else{
266	<	continue;
267	<	}
568	>	edm::ESHandle<CaloGeometry> CaloGeom;
569	>	iSetup.get<CaloGeometryRecord>().get( CaloGeom );
570	>	const vector<DetId> CaloDets = CaloGeom->getValidDetIds();
571
572	<	const CaloCellGeometry* CellGeom = CaloGeom->getGeometry(Detid);
573	<	GlobalPoint CellPos =  CellGeom->getPosition();
574	<	const CaloCellGeometry::CornersVec CellCorners =  CellGeom->getCorners();
575	<
273	<	float cX = (CellCorners[0].x() + CellCorners[2].x())/2;
274	<	float cY = (CellCorners[0].y() + CellCorners[2].y())/2;
275	<	float cZ = (CellCorners[0].z() + CellCorners[2].z())/2;
276	<
277	<	float wX = (CellCorners[1].x() - CellCorners[0].x())/2;
278	<	float wY = (CellCorners[1].y() - CellCorners[0].y())/2;
279	<	float wZ = (CellCorners[1].z() - CellCorners[0].z())/2;
280	<
281	<	float hX = (CellCorners[3].x() - CellCorners[0].x())/2;
282	<	float hY = (CellCorners[3].y() - CellCorners[0].y())/2;
283	<	float hZ = (CellCorners[3].z() - CellCorners[0].z())/2;
284	<
285	<	float F  = sqrt( pow(CellCorners[4].x()+CellCorners[6].x(),2) + pow(CellCorners[4].y()+CellCorners[6].y(),2) + pow(CellCorners[4].z()+CellCorners[6].z(),2) );
286	<	F /= sqrt( pow(CellCorners[0].x()+CellCorners[2].x(),2) + pow(CellCorners[0].y()+CellCorners[2].y(),2) + pow(CellCorners[0].z()+CellCorners[2].z(),2) );
287	<
288	<	Geom_temp->Add_CaloDet(Detid.rawId(),
289	<	cX  ,   cY  , cZ ,
290	<	wX  ,   wY  , wZ ,
291	<	hX  ,   hY  , hZ ,  F );
292	<	}
572	>	for(unsigned int i=0;i<CaloDets.size();i++)
573	>	{
574	>	Detid  = CaloDets[i];
575	>	SubDet = Detid.subdetId();
576
577	<	// ### MUON GEOMETRY ###
577	>	if(Detid.det()==DetId::Ecal){
578	>	if(SubDet<1 || SubDet>3) continue;
579
580	<	edm::ESHandle<DTGeometry> DtGeom;
581	<	iSetup.get<MuonGeometryRecord>().get( DtGeom );
298	<	const vector<GeomDet*> DtDets = DtGeom->dets();
299	<
300	<	edm::ESHandle<CSCGeometry> CscGeom;
301	<	iSetup.get<MuonGeometryRecord>().get( CscGeom );
302	<	const vector<GeomDet*> CscDets = CscGeom->dets();
303	<
304	<	edm::ESHandle<RPCGeometry> RpcGeom;
305	<	iSetup.get<MuonGeometryRecord>().get( RpcGeom );
306	<	const vector<GeomDet*> RpcDets = RpcGeom->dets();
307	<
308	<	vector<GeomDet*> MuonDets;
309	<	for(unsigned int i=0;i<DtDets.size() ;i++){MuonDets.push_back(DtDets [i]);}
310	<	for(unsigned int i=0;i<CscDets.size();i++){MuonDets.push_back(CscDets[i]);}
311	<	for(unsigned int i=0;i<RpcDets.size();i++){MuonDets.push_back(RpcDets[i]);}
312	<
313	<
314	<	for(unsigned int i=0;i<MuonDets.size();i++)
315	<	{
316	<	Detid  = DetId(MuonDets[i]->geographicalId());
317	<	SubDet = Detid.subdetId();
318	<
319	<	GeomDet* DetUnit = MuonDets[i];
320	<	if(!DetUnit)continue;
321	<	const BoundPlane plane = DetUnit->surface();
322	<	const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
323	<	const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));
324	<
325	<	float width            = 0;
326	<	float length           = 0;
327	<	float thickness        = 0;
328	<	float TrapezoidalParam = 0;
580	>	Frog_DetId = DETID_ECAL;
581	>	FEB        = ecal;
582
583	<	if(trapezoidalBounds)
584	<	{
585	<	std::vector<float> const & parameters = (*trapezoidalBounds).parameters();
586	<	width            = parameters[0]*2;
587	<	length           = parameters[3]*2;
588	<	thickness        =  (*trapezoidalBounds).thickness();
589	<	TrapezoidalParam = parameters[1]/parameters[0];
590	<	}else if(rectangularBounds){
591	<	width            = DetUnit->surface().bounds().width();
592	<	length           = DetUnit->surface().bounds().length();
593	<	thickness        = DetUnit->surface().bounds().thickness();
594	<	TrapezoidalParam = 1;
595	<	}
583	>	Frog_DetId += SubDet*100000;
584	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
585	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
586	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
587	>
588	>	if(SubDet==1){
589	>	EBDetId detid = EBDetId(Detid);
590	>
591	>	Frog_DetId += ((detid.zside()==1)+1)*10000;
592	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
593	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
594	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
595	>
596	>	Frog_DetId += (detid.tower_ieta()*detid.zside())*100;
597	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
598	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
599	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
600	>
601	>	Frog_DetId += detid.tower_iphi()*1;
602	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
603	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
604	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
605	>	}else if(SubDet==2){
606	>	EEDetId detid = EEDetId(Detid);
607	>
608	>	Frog_DetId += ((detid.zside()==1)+1)*10000;
609	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
610	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
611	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
612	>
613	>	Frog_DetId += detid.iquadrant()*1000;
614	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
615	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
616	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
617	>
618	>	Frog_DetId += detid.isc();
619	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
620	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
621	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
622	>	}else if(SubDet==3){
623	>	ESDetId detid = ESDetId(Detid);
624	>
625	>	Frog_DetId += ((detid.zside()==1)+1)*10000;
626	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
627	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
628	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
629	>
630	>	Frog_DetId += detid.plane()*1000;
631	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
632	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
633	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
634	>
635	>	Frog_DetId += detid.six()*50;
636	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
637	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
638	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
639	>
640	>	Frog_DetId += detid.siy();
641	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
642	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
643	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
644	>	}
645	>	}else if(Detid.det()==DetId::Hcal){
646	>	if(SubDet<1 || SubDet>4) continue;
647	>
648	>	Frog_DetId = DETID_HCAL;
649	>	FEB        = hcal;
650	>
651	>	Frog_DetId += SubDet*100000;
652	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
653	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
654	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
655	>
656	>	if(true){
657	>	HcalDetId detid = HcalDetId(Detid);
658	>
659	>	Frog_DetId += ((detid.zside()==1)+1)*10000;
660	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
661	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
662	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
663	>
664	>	Frog_DetId += detid.ietaAbs()*100;
665	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
666	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
667	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
668	>
669	>	Frog_DetId += detid.iphi()*1;
670	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
671	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
672	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
673	>	}
674	>
675	>	}else if(Detid.det() == DetId::Calo){
676	>	continue;
677	>	/*
678	>	Frog_DetId = DETID_CALO + 1000000;
679	>	FEB        = hcal;
680	>
681	>	Frog_DetId += SubDet*100000;
682	>	FEB_Temp = dynamic_cast<FROG_Element_Base_With_DetId*>(FEB);
683	>	FEB = FEB_Temp->getDaughterWithDetId(Frog_DetId);
684	>	if(FEB==NULL){FEB = new FROG_Element_Base_With_DetId(C_FEB_DETID, Frog_DetId); FEB_Temp->addDaughter(FEB);}
685	>	*/
686	>	}
687	>
688	>	const CaloCellGeometry* CellGeom = CaloGeom->getGeometry(Detid);
689	>	GlobalPoint CellPos =  CellGeom->getPosition();
690	>	const CaloCellGeometry::CornersVec CellCorners =  CellGeom->getCorners();
691	>
692	>	float cX = (CellCorners[0].x() + CellCorners[2].x())/2;
693	>	float cY = (CellCorners[0].y() + CellCorners[2].y())/2;
694	>	float cZ = (CellCorners[0].z() + CellCorners[2].z())/2;
695	>
696	>	float wX = (CellCorners[1].x() - CellCorners[0].x())/2;
697	>	float wY = (CellCorners[1].y() - CellCorners[0].y())/2;
698	>	float wZ = (CellCorners[1].z() - CellCorners[0].z())/2;
699	>
700	>	float hX = (CellCorners[3].x() - CellCorners[0].x())/2;
701	>	float hY = (CellCorners[3].y() - CellCorners[0].y())/2;
702	>	float hZ = (CellCorners[3].z() - CellCorners[0].z())/2;
703	>
704	>	float F  = sqrt( pow(CellCorners[4].x()+CellCorners[6].x(),2) + pow(CellCorners[4].y()+CellCorners[6].y(),2) + pow(CellCorners[4].z()+CellCorners[6].z(),2) );
705	>	F /= sqrt( pow(CellCorners[0].x()+CellCorners[2].x(),2) + pow(CellCorners[0].y()+CellCorners[2].y(),2) + pow(CellCorners[0].z()+CellCorners[2].z(),2) );
706	>
707	>	FROG_Element_Geom_CaloMod* mod = new FROG_Element_Geom_CaloMod(
708	>	Detid.rawId(), F,
709	>	cX  ,   cY  , cZ ,
710	>	wX  ,   wY  , wZ ,
711	>	hX  ,   hY  , hZ );
712
713	<	Surface::GlobalPoint WidthVector  = plane.toGlobal( LocalPoint(width/2, 0, 0) );
714	<	Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
346	<	Surface::GlobalPoint ThickVector  = plane.toGlobal( LocalPoint(0, 0, thickness/2) );
347	<
348	<	GlobalVector Pos =  GlobalVector(DetUnit->position().basicVector());
349	<
350	<	Geom_Muon->Add_TrackerDet(Detid.rawId(), TrapezoidalParam,
351	<	Pos.x(),                  Pos.y(),                  Pos.z(),
352	<	WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
353	<	LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
354	<	ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
355	<	}
713	>	FEB->addDaughter(mod);
714	>	}
715
716	+	// ### Save .geom ###
717
718	<	// ### Save .geom ###
718	>	FROG_Geometry* CMS_Geom = new FROG_Geometry(prim);
719	>	CMS_Geom->Save("CMS.geom");
720	>	}
721
722	<	Geom_Tracker->Save("Tracker.geom");
361	<	Geom_ECAL   ->Save("Ecal.geom");
362	<	Geom_HCAL   ->Save("Hcal.geom");
363	<	Geom_Muon   ->Save("Muon.geom");
364	<
722	>	events_prim = new FROG_Element_Base(C_PRIMARY);
723		}
724
725		// ------------ method called once each job just after ending the event loop  ------------
726		void
727	<	Frog_Analyzer::endJob() {
728	<
729	<	MyEvents->Save((char*) OutputFile.c_str());
730	<	//   MyEvents->Load((char*) OutputFile.c_str());
727	>	Frog_Analyzer::endJob()
728	>	{
729	>	if(NEvents>0){
730	>	char OutputFileName[1024];
731	>	sprintf(OutputFileName,"%s",OutputFile.substr(0,OutputFile.size()-4).c_str());
732	>	if(NEventsInVisFile>=0)sprintf(OutputFileName,"%s_R%i_E%i.vis",OutputFileName,SRun,SEvent);
733	>	sprintf(OutputFileName,"%s.vis",OutputFileName);
734	>
735	>	FROG_Events* events = new FROG_Events(events_prim);
736	>	events->Save((char*) OutputFileName);
737	>	delete events;
738	>	delete events_prim;
739	>
740	>	events_prim = new FROG_Element_Base(C_PRIMARY);
741	>	NEvents=0;
742	>	}
743		}
744
745
#	Line 382 | Line 752 | Frog_Analyzer::endJob() {
752		void
753		Frog_Analyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
754		{
755	<	MySimEvent* MyEvent = new MySimEvent;
755	>	if(NEvents == 0){
756	>	SRun   = iEvent.id().run();
757	>	SEvent = iEvent.id().event();
758	>	}
759	>
760	>
761	>	FROG_Element_Event* event =  new FROG_Element_Event(iEvent.id().run(), iEvent.id().event(), iEvent.time().value() );
762	>	events_prim->addDaughter(event);
763
764		// access the tracker
765		edm::ESHandle<TrackerGeometry> tkGeom;
#	Line 397 | Line 774 | Frog_Analyzer::analyze(const edm::Event&
774		edm::ESHandle<RPCGeometry> RpcGeom;
775		iSetup.get<MuonGeometryRecord>().get( RpcGeom );
776
777	+	edm::ESHandle<CaloGeometry> CaloGeom;
778	+	iSetup.get<CaloGeometryRecord>().get( CaloGeom );
779
401	–	// Save Data
780		// ### SIMTRACK ###
781	+	FROG_Element_Base_With_DetId* frogSimTrkColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_SIMTRK);
782	+	event->addDaughter(frogSimTrkColl);
783	+
784		for(unsigned int i=0;i<SimTrackProducers.size();i++){
785		edm::Handle<std::vector< SimTrack > > h_SimTracks;
786		iEvent.getByLabel(SimTrackProducers[i], h_SimTracks);
787		std::vector< SimTrack > SimTrackColl = *h_SimTracks.product();
788
789		for ( unsigned int a = 0; a < SimTrackColl.size(); ++a ) {
409	–	MySimTrack*  MysimTrack = new MySimTrack;
790		SimTrack    simTrack    =SimTrackColl[a];
791
792	<	MysimTrack->track_id    =simTrack.trackId();
793	<	MysimTrack->Type        =simTrack.type();
794	<	MysimTrack->parent_vertex=simTrack.vertIndex();
795	<	MysimTrack->Px          =simTrack.momentum().x();
796	<	MysimTrack->Py          =simTrack.momentum().y();
417	<	MysimTrack->Pz          =simTrack.momentum().z();
418	<	MysimTrack->E           =simTrack.momentum().e();
419	<	MysimTrack->charge      =simTrack.charge();
420	<
421	<	MyEvent->MySimTrackCollection.push_back(MysimTrack);
792	>	FROG_Element_Event_Sim_Track* frogSimTrk =  new FROG_Element_Event_Sim_Track(simTrack.trackId(),
793	>	simTrack.momentum().x(),     simTrack.momentum().y(),     simTrack.momentum().z(),
794	>	simTrack.momentum().e(),     simTrack.type(),             simTrack.vertIndex(),
795	>	simTrack.charge() );
796	>	frogSimTrkColl->addDaughter(frogSimTrk);
797		}
798		}
799
800		// ### SIMVERTEX ###
801	+	FROG_Element_Base_With_DetId* frogSimVtx = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_SIMVTX);
802	+	event->addDaughter(frogSimVtx);
803	+
804		for(unsigned int i=0;i<SimVertexProducers.size();i++){
805		edm::Handle<std::vector< SimVertex > > h_Vertex;
806		iEvent.getByLabel(SimVertexProducers[i], h_Vertex);
807		std::vector< SimVertex > VertexColl = *h_Vertex.product();
808
809		for (unsigned int b = 0; b < VertexColl.size(); ++b ) {
432	–	MySimVertex*    MyVertex = new MySimVertex;
810		SimVertex       Vertex  =  VertexColl[b];
811
812	<	MyVertex->parentTrack_id=Vertex.parentIndex ();
813	<	MyVertex->x             =Vertex.position().x();
814	<	MyVertex->y             =Vertex.position().y();
438	<	MyVertex->z             =Vertex.position().z();
812	>	FROG_Element_Event_Sim_Vertex* frogSimVertex = new FROG_Element_Event_Sim_Vertex(
813	>	Vertex.position().x(),  Vertex.position().y(),  Vertex.position().z(),
814	>	Vertex.parentIndex());
815
816	<	MyEvent->MySimVertexCollection.push_back(MyVertex);
816	>	frogSimVtx->addDaughter(frogSimVertex);
817		}
818		}
819
820	+
821		// ### SIMHIT ###
822	+
823	+	FROG_Element_Base_With_DetId* frogSimHit = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_SIMHIT);
824	+	event->addDaughter(frogSimHit);
825		for(unsigned int i=0;i<SimHitProducers.size();i++){
826		edm::Handle<std::vector< PSimHit > > h_Hits;
827		iEvent.getByLabel(SimHitProducers[i], h_Hits);
828		std::vector< PSimHit > Hits = *h_Hits.product();
829
830	+	FROG_Element_Base_With_DetId* frogSimHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_SIMHIT + i + 1);
831	+	frogSimHit->addDaughter(frogSimHitColl);
832	+
833		for(unsigned int h=0; h<Hits.size(); h++)
834		{
835		DetId theDetUnitId(Hits[h].detUnitId());
836	<	const GeomDet* theDet = tkGeom->idToDet(theDetUnitId);
836	>	const GeomDet* theDet = NULL;
837	>	if(theDetUnitId.det() == DetId::Tracker)theDet = tkGeom->idToDet(theDetUnitId);
838	>	if(theDetUnitId.det() == DetId::Muon && theDetUnitId.subdetId() == MuonSubdetId::DT) theDet = DtGeom->idToDet(theDetUnitId);
839	>	if(theDetUnitId.det() == DetId::Muon && theDetUnitId.subdetId() == MuonSubdetId::CSC)theDet = CscGeom->idToDet(theDetUnitId);
840	>	if(theDetUnitId.det() == DetId::Muon && theDetUnitId.subdetId() == MuonSubdetId::RPC)theDet = RpcGeom->idToDet(theDetUnitId);
841	>
842	>
843	>	FROG_Element_Event_Sim_Hit* frogSimHit = new FROG_Element_Event_Sim_Hit(
844	>	theDet->surface().toGlobal(Hits[h].localPosition()).x(),theDet->surface().toGlobal(Hits[h].localPosition()).y(),theDet->surface().toGlobal(Hits[h].localPosition()).z(),
845	>	Hits[h].energyLoss(), Hits[h].processType() );
846	>	frogSimHitColl->addDaughter(frogSimHit);
847	>	}
848	>	}
849
850	<	MyPSimHit* Hit   = new MyPSimHit;
456	<	Hit->x           = theDet->surface().toGlobal(Hits[h].localPosition()).x();
457	<	Hit->y           = theDet->surface().toGlobal(Hits[h].localPosition()).y();
458	<	Hit->z           = theDet->surface().toGlobal(Hits[h].localPosition()).z();
459	<	Hit->ProcessType = Hits[h].processType();
460	<	Hit->dEdX        = Hits[h].energyLoss();
850	>	// ### SIMCALOHIT ###
851
852	<	MyEvent->MyPSimHitCollection.push_back(Hit);
852	>	for(unsigned int i=0;i<SimCaloHitProducers.size();i++){
853	>	edm::Handle<std::vector< PCaloHit > > h_CaloHits;
854	>	iEvent.getByLabel(SimCaloHitProducers[i], h_CaloHits);
855	>	std::vector< PCaloHit > CaloHits = *h_CaloHits.product();
856	>
857	>	FROG_Element_Base_With_DetId* frogSimHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_SIMHIT + SimHitProducers.size() + i + 1);
858	>	frogSimHit->addDaughter(frogSimHitColl);
859	>
860	>	for(unsigned int h=0; h<CaloHits.size(); h++)
861	>	{
862	>	DetId theDetUnitId(CaloHits[h].id());
863	>	const CaloCellGeometry* CellGeom = NULL;
864	>	if(theDetUnitId.det() == DetId::Ecal || theDetUnitId.det() == DetId::Hcal)CellGeom = CaloGeom->getGeometry(theDetUnitId);
865	>	if(CellGeom==NULL)continue;
866	>
867	>
868	>	FROG_Element_Event_Sim_Hit* frogSimCaloHit = new FROG_Element_Event_Sim_Hit(
869	>	CellGeom->getPosition().x(),CellGeom->getPosition().y(),CellGeom->getPosition().z(),
870	>	CaloHits[h].energy(), CaloHits[h].depth() );
871	>	frogSimHitColl->addDaughter(frogSimCaloHit);
872		}
873	<	}
873	>	}
874	>
875	>	// NUCLEAR INTERACTIONS
876	>	for(unsigned int i=0;i<NIProducers.size();i++) {
877	>	edm::Handle<std::vector<reco::NuclearInteraction> > h_NIs;
878	>	iEvent.getByLabel(NIProducers[i], h_NIs);
879	>	std::vector<reco::NuclearInteraction> NIs = *h_NIs.product();
880	>	FROG_Element_Base_With_DetId* frogNIColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_NUCLINT + i);
881	>	event->addDaughter(frogNIColl);
882	>
883	>	for(unsigned int h=0; h<NIs.size();h++){
884	>	reco::NuclearInteraction ni = NIs[i];
885	>	float vtx_x = ni.vertex().x();
886	>	float vtx_y = ni.vertex().y();
887	>	float vtx_z = ni.vertex().z();
888	>	float like  = ni.likelihood();
889	>	FROG_Element_Event_NuclInt*  frogNI = new FROG_Element_Event_NuclInt(vtx_x, vtx_y, vtx_z, like );
890	>	frogNIColl->addDaughter(frogNI);
891	>	}
892	>	}
893
894
895	<	// ### TRACKS ###
895	>
896	>	// ### TRAJECTORY ###
897	>	FROG_Element_Base_With_DetId* frogTrk = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_TRK);
898	>	event->addDaughter(frogTrk);
899	>
900	>	for(unsigned int i=0;i<TrajectoryProducers.size();i++){
901	>	Handle<TrajTrackAssociationCollection> trajTrackAssociationHandle;
902	>	iEvent.getByLabel(TrajectoryProducers[i], trajTrackAssociationHandle);
903	>	const TrajTrackAssociationCollection TrajToTrackMap = *trajTrackAssociationHandle.product();
904	>
905	>	FROG_Element_Base_With_DetId* frogTrkColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_TRK + i + 1);
906	>	frogTrk->addDaughter(frogTrkColl);
907	>
908	>	for(TrajTrackAssociationCollection::const_iterator it = TrajToTrackMap.begin(); it!=TrajToTrackMap.end(); ++it) {
909	>	Trajectory  recoTraj     = *it->key;
910	>	FROG_Element_Event_Track* frogTrk = new FROG_Element_Event_Track(i,it->val->p(),it->val->pt(),it->key->chiSquared());
911	>	frogTrkColl->addDaughter(frogTrk);
912	>
913	>	std::vector<TrajectoryMeasurement> measurements = recoTraj.measurements();
914	>	for(unsigned int h=0;h<measurements.size();h++){
915	>
916	>	TrajectoryMeasurement::ConstRecHitPointer h_it = measurements[h].recHit();
917	>	if(!h_it->isValid() )continue;
918	>	DetId detId                = h_it->geographicalId();
919	>	GlobalPoint globalPos      = measurements[h].updatedState().globalPosition();
920	>
921	>	FROG_Element_Event_Hit* frogHit = new FROG_Element_Event_Hit(detId.rawId(), globalPos.x(),globalPos.y(),  globalPos.z(), -1);
922	>	frogTrk->addDaughter(frogHit);
923	>	}
924	>	}
925	>	}
926	>
927	>	// ### TRACK ###
928	>
929		for(unsigned int i=0;i<TrackProducers.size();i++){
930		edm::Handle<std::vector< reco::Track > > h_Tracks;
931		iEvent.getByLabel(TrackProducers[i], h_Tracks);
932		std::vector< reco::Track > TrackColl = *h_Tracks.product();
933
934	+	FROG_Element_Base_With_DetId* frogTrkColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_TRK + TrajectoryProducers.size() + i + 1);
935	+	frogTrk->addDaughter(frogTrkColl);
936	+
937	+	//printf("Size of the TrackCOllection : %i = %i\n",i,TrackColl.size());
938		for ( unsigned int t = 0; t < TrackColl.size(); ++t ) {
939	<	MyRecoTrack* MyrecoTrack = new MyRecoTrack;
475	<	reco::Track  recoTrack  =TrackColl[t];
939	>	reco::Track  recoTrack  =TrackColl[t];
940
941	<	for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
942	<	TrackingRecHitRef h_it     = recoTrack.recHit(h);
479	<	if(!h_it->isValid() )continue;
480	<	DetId detId                = h_it->geographicalId();
481	<	const GeomDet * theDet     = tkGeom->idToDet(detId);
482	<	LocalPoint localPos        = h_it->localPosition();
941	>	FROG_Element_Event_Track* frogTrk = new FROG_Element_Event_Track(TrajectoryProducers.size()+i,recoTrack.p(),recoTrack.pt(), recoTrack.chi2());
942	>	frogTrkColl->addDaughter(frogTrk);
943
944	<	MyRecoHit* hit = new MyRecoHit;
945	<	hit->x        = theDet->surface().toGlobal(localPos).x();
946	<	hit->y        = theDet->surface().toGlobal(localPos).y();
947	<	hit->z        = theDet->surface().toGlobal(localPos).z();
948	<	hit->DetId    = detId.rawId();
949	<	hit->Charge   = -1;
950	<	MyrecoTrack->Hits.push_back(hit);
951	<	}
952	<	MyEvent->MyRecoTrackCollection.push_back(MyrecoTrack);
944	>	for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
945	>	TrackingRecHitRef h_it     = recoTrack.recHit(h);
946	>	if(!h_it->isValid() )continue;
947	>	DetId detId                = h_it->geographicalId();
948	>	const GeomDet * theDet = NULL;
949	>
950	>	if(detId.det()==DetId::Tracker)                        theDet = tkGeom->idToDet(detId);
951	>	if(detId.det()==DetId::Muon && detId.subdetId() == 1)  theDet = DtGeom->idToDet(detId);
952	>	if(detId.det()==DetId::Muon && detId.subdetId() == 2)  theDet = CscGeom->idToDet(detId);
953	>	if(detId.det()==DetId::Muon && detId.subdetId() == 3)  theDet = RpcGeom->idToDet(detId);
954	>
955	>	LocalPoint localPos        = h_it->localPosition();
956	>
957	>	FROG_Element_Event_Hit* frogHit = new FROG_Element_Event_Hit(
958	>	detId.rawId(),
959	>	theDet->surface().toGlobal(localPos).x(),
960	>	theDet->surface().toGlobal(localPos).y(),
961	>	theDet->surface().toGlobal(localPos).z(),
962	>	-1);
963	>	frogTrk->addDaughter(frogHit);
964	>	}
965		}
966		}
967
968
969		// ### ECALRecHits ###
970	+	FROG_Element_Base_With_DetId* frogEcalHit = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_ECALHIT);
971	+	event->addDaughter(frogEcalHit);
972		for(unsigned int i=0;i<EcalRecHitProducers.size();i++){
973		edm::Handle<EcalRecHitCollection > h_Ecal_RecHits;
974		iEvent.getByLabel(EcalRecHitProducers[i], h_Ecal_RecHits);
975		EcalRecHitCollection Ecal_RecHits = *h_Ecal_RecHits.product();
976
977	+	FROG_Element_Base_With_DetId* frogHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_ECALHIT + i + 1);
978	+	frogEcalHit->addDaughter(frogHitColl);
979	+
980		for(unsigned int eh=0;eh<Ecal_RecHits.size();eh++){
981	<	MyCaloHit* temp_EcalHit = new MyCaloHit;
982	<	temp_EcalHit->E     = Ecal_RecHits[eh].energy();
983	<	temp_EcalHit->t     = Ecal_RecHits[eh].time();
507	<	temp_EcalHit->DetId = (Ecal_RecHits[eh].detid()).rawId();
508	<
509	<	MyEvent->MyEcalCaloHitCollection.push_back(temp_EcalHit);
981	>	FROG_Element_Event_CaloHit* frogCaloHit = new FROG_Element_Event_CaloHit((Ecal_RecHits[eh].detid()).rawId(),
982	>	Ecal_RecHits[eh].energy(), Ecal_RecHits[eh].time());
983	>	frogHitColl->addDaughter(frogCaloHit);
984		}
985		}
986
987
988		// ### HCALRecHits ###
989	+	FROG_Element_Base_With_DetId* frogHcalHit = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_HCALHIT);
990	+	event->addDaughter(frogHcalHit);
991		for(unsigned int i=0;i<HcalHBHERecHitProducers.size();i++){
992		edm::Handle<HBHERecHitCollection > h_HcalHBHE_RecHits;
993		iEvent.getByLabel(HcalHBHERecHitProducers[i], h_HcalHBHE_RecHits);
994		HBHERecHitCollection HcalHBHE_RecHits = *h_HcalHBHE_RecHits.product();
995
996	<	for(unsigned int hh=0;hh<HcalHBHE_RecHits.size();hh++){
997	<	MyCaloHit* temp_HcalHBHEHit = new MyCaloHit;
522	<	temp_HcalHBHEHit->E      = HcalHBHE_RecHits[hh].energy();
523	<	temp_HcalHBHEHit->t      = HcalHBHE_RecHits[hh].time();
524	<	temp_HcalHBHEHit->DetId = (HcalHBHE_RecHits[hh].detid()).rawId();
996	>	FROG_Element_Base_With_DetId* frogHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_HCALHIT + i + 1);
997	>	frogHcalHit->addDaughter(frogHitColl);
998
999	<	MyEvent->MyHcalCaloHitCollection.push_back(temp_HcalHBHEHit);
999	>	for(unsigned int hh=0;hh<HcalHBHE_RecHits.size();hh++){
1000	>	FROG_Element_Event_CaloHit* frogCaloHit = new FROG_Element_Event_CaloHit((HcalHBHE_RecHits[hh].detid()).rawId(),
1001	>	HcalHBHE_RecHits[hh].energy(), HcalHBHE_RecHits[hh].time());
1002	>	frogHitColl->addDaughter(frogCaloHit);
1003		}
1004		}
1005
530	–
1006		for(unsigned int i=0;i<HcalHORecHitProducers.size();i++){
1007		edm::Handle<HORecHitCollection > h_HcalHO_RecHits;
1008		iEvent.getByLabel(HcalHORecHitProducers[i], h_HcalHO_RecHits);
1009		HORecHitCollection HcalHO_RecHits = *h_HcalHO_RecHits.product();
1010
1011	<	for(unsigned int hh=0;hh<HcalHO_RecHits.size();hh++){
1012	<	MyCaloHit* temp_HcalHOHit = new MyCaloHit;
538	<	temp_HcalHOHit->E      = HcalHO_RecHits[hh].energy();
539	<	temp_HcalHOHit->t      = HcalHO_RecHits[hh].time();
540	<	temp_HcalHOHit->DetId = (HcalHO_RecHits[hh].detid()).rawId();
1011	>	FROG_Element_Base_With_DetId* frogHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_HCALHIT + HcalHBHERecHitProducers.size() + i + 1);
1012	>	frogHcalHit->addDaughter(frogHitColl);
1013
1014	<	MyEvent->MyHcalCaloHitCollection.push_back(temp_HcalHOHit);
1014	>	for(unsigned int hh=0;hh<HcalHO_RecHits.size();hh++){
1015	>	FROG_Element_Event_CaloHit* frogCaloHit = new FROG_Element_Event_CaloHit((HcalHO_RecHits[hh].detid()).rawId(),
1016	>	HcalHO_RecHits[hh].energy(), HcalHO_RecHits[hh].time());
1017	>	frogHitColl->addDaughter(frogCaloHit);
1018		}
1019		}
1020
546	–
1021		for(unsigned int i=0;i<HcalHFRecHitProducers.size();i++){
1022		edm::Handle<HFRecHitCollection > h_HcalHF_RecHits;
1023		iEvent.getByLabel(HcalHFRecHitProducers[i], h_HcalHF_RecHits);
1024		HFRecHitCollection HcalHF_RecHits = *h_HcalHF_RecHits.product();
1025
1026	<	for(unsigned int hh=0;hh<HcalHF_RecHits.size();hh++){
1027	<	MyCaloHit* temp_HcalHFHit = new MyCaloHit;
554	<	temp_HcalHFHit->E      = HcalHF_RecHits[hh].energy();
555	<	temp_HcalHFHit->t      = HcalHF_RecHits[hh].time();
556	<	temp_HcalHFHit->DetId = (HcalHF_RecHits[hh].detid()).rawId();
1026	>	FROG_Element_Base_With_DetId* frogHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_HCALHIT + HcalHBHERecHitProducers.size() + HcalHORecHitProducers.size() + i + 1);
1027	>	frogHcalHit->addDaughter(frogHitColl);
1028
1029	<	MyEvent->MyHcalCaloHitCollection.push_back(temp_HcalHFHit);
1029	>	for(unsigned int hh=0;hh<HcalHF_RecHits.size();hh++){
1030	>	FROG_Element_Event_CaloHit* frogCaloHit = new FROG_Element_Event_CaloHit((HcalHF_RecHits[hh].detid()).rawId(),
1031	>	HcalHF_RecHits[hh].energy(), HcalHF_RecHits[hh].time());
1032	>	frogHitColl->addDaughter(frogCaloHit);
1033		}
1034		}
1035
1036	+
1037		// ### Muon Segments ###
1038	+	FROG_Element_Base_With_DetId* frogMuonSeg = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_MUONSEG);
1039	+	event->addDaughter(frogMuonSeg);
1040	+
1041		for(unsigned int i=0;i<CSCSegmentProducers.size();i++){
1042		edm::Handle<CSCSegmentCollection > h_CSC_Segments;
1043		iEvent.getByLabel(CSCSegmentProducers[i], h_CSC_Segments);
1044		CSCSegmentCollection CSC_Segments = *h_CSC_Segments.product();
1045
1046	+	FROG_Element_Base_With_DetId* frogSegColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_MUONSEG + i + 1);
1047	+	frogMuonSeg->addDaughter(frogSegColl);
1048	+
1049		for(unsigned int s=0;s<CSC_Segments.size();s++){
1050		DetId theDetUnitId = CSC_Segments[s].geographicalId();
1051		const GeomDet* theDet = CscGeom->idToDet(theDetUnitId);
1052
1053	<	MyMuonSegment* temp_CscSeg = new MyMuonSegment;
1054	<	temp_CscSeg->DetId = theDetUnitId.rawId();
1055	<	temp_CscSeg->PosX  = theDet->surface().toGlobal(CSC_Segments[s].localPosition()).x();
1056	<	temp_CscSeg->PosY  = theDet->surface().toGlobal(CSC_Segments[s].localPosition()).y();
576	<	temp_CscSeg->PosZ  = theDet->surface().toGlobal(CSC_Segments[s].localPosition()).z();
577	<	temp_CscSeg->DirX  = theDet->surface().toGlobal(CSC_Segments[s].localDirection()).x();
578	<	temp_CscSeg->DirY  = theDet->surface().toGlobal(CSC_Segments[s].localDirection()).y();
579	<	temp_CscSeg->DirZ  = theDet->surface().toGlobal(CSC_Segments[s].localDirection()).z();
580	<
581	<	MyEvent->MyMuonSegmentCollection.push_back(temp_CscSeg);
1053	>	FROG_Element_Event_Segment* frogSeg = new FROG_Element_Event_Segment(theDetUnitId.rawId(),
1054	>	theDet->surface().toGlobal(CSC_Segments[s].localPosition()).x() , theDet->surface().toGlobal(CSC_Segments[s].localPosition()).y() , theDet->surface().toGlobal(CSC_Segments[s].localPosition()).z()  ,
1055	>	theDet->surface().toGlobal(CSC_Segments[s].localDirection()).x(), theDet->surface().toGlobal(CSC_Segments[s].localDirection()).y(), theDet->surface().toGlobal(CSC_Segments[s].localDirection()).z() );
1056	>	frogSegColl->addDaughter(frogSeg);
1057		}
1058		}
1059
#	Line 587 | Line 1062 | Frog_Analyzer::analyze(const edm::Event&
1062		iEvent.getByLabel(DTSegmentProducers[i], h_DT_Segments);
1063		DTRecSegment4DCollection DT_Segments = *h_DT_Segments.product();
1064
1065	+	FROG_Element_Base_With_DetId* frogSegColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_MUONSEG + CSCSegmentProducers.size() + i + 1);
1066	+	frogMuonSeg->addDaughter(frogSegColl);
1067	+
1068		for(unsigned int s=0;s<DT_Segments.size();s++){
1069		DetId theDetUnitId = DT_Segments[s].geographicalId();
1070		const GeomDet* theDet = DtGeom->idToDet(theDetUnitId);
1071
1072	<	MyMuonSegment* temp_DtSeg = new MyMuonSegment;
1073	<	temp_DtSeg->DetId = theDetUnitId.rawId();
1074	<	temp_DtSeg->PosX  = theDet->surface().toGlobal(DT_Segments[s].localPosition()).x();
1075	<	temp_DtSeg->PosY  = theDet->surface().toGlobal(DT_Segments[s].localPosition()).y();
598	<	temp_DtSeg->PosZ  = theDet->surface().toGlobal(DT_Segments[s].localPosition()).z();
599	<	temp_DtSeg->DirX  = theDet->surface().toGlobal(DT_Segments[s].localDirection()).x();
600	<	temp_DtSeg->DirY  = theDet->surface().toGlobal(DT_Segments[s].localDirection()).y();
601	<	temp_DtSeg->DirZ  = theDet->surface().toGlobal(DT_Segments[s].localDirection()).z();
602	<
603	<	MyEvent->MyMuonSegmentCollection.push_back(temp_DtSeg);
1072	>	FROG_Element_Event_Segment* frogSeg = new FROG_Element_Event_Segment(theDetUnitId.rawId(),
1073	>	theDet->surface().toGlobal(DT_Segments[s].localPosition()).x() , theDet->surface().toGlobal(DT_Segments[s].localPosition()).y() , theDet->surface().toGlobal(DT_Segments[s].localPosition()).z()  ,
1074	>	theDet->surface().toGlobal(DT_Segments[s].localDirection()).x(), theDet->surface().toGlobal(DT_Segments[s].localDirection()).y(), theDet->surface().toGlobal(DT_Segments[s].localDirection()).z() );
1075	>	frogSegColl->addDaughter(frogSeg);
1076		}
1077		}
1078
1079		// ### Muon Hits ###
1080	+	FROG_Element_Base_With_DetId* frogMuonHit = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_MUONHIT);
1081	+	event->addDaughter(frogMuonHit);
1082		for(unsigned int i=0;i<RPCHitsProducers.size();i++){
1083		edm::Handle<RPCRecHitCollection > h_RPC_Hits;
1084		iEvent.getByLabel(RPCHitsProducers[i], h_RPC_Hits);
1085		RPCRecHitCollection RPC_Hits = *h_RPC_Hits.product();
1086
1087	+	FROG_Element_Base_With_DetId* frogHitColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_MUONHIT + i + 1);
1088	+	frogMuonHit->addDaughter(frogHitColl);
1089	+
1090		for(unsigned int h=0;h<RPC_Hits.size();h++){
1091		DetId theDetUnitId = RPC_Hits[h].geographicalId();
1092		const GeomDet* theDet = RpcGeom->idToDet(theDetUnitId);
1093
1094	<	MyMuonHit* temp_RpcHit = new MyMuonHit;
1095	<	temp_RpcHit->DetId = theDetUnitId.rawId();
1096	<	temp_RpcHit->x     = theDet->surface().toGlobal(RPC_Hits[h].localPosition()).x();
1097	<	temp_RpcHit->y     = theDet->surface().toGlobal(RPC_Hits[h].localPosition()).y();
1098	<	temp_RpcHit->z     = theDet->surface().toGlobal(RPC_Hits[h].localPosition()).z();
1094	>	FROG_Element_Event_Hit* frogHit = new FROG_Element_Event_Hit(theDetUnitId.rawId(),
1095	>	theDet->surface().toGlobal(RPC_Hits[h].localPosition()).x() , theDet->surface().toGlobal(RPC_Hits[h].localPosition()).y() , theDet->surface().toGlobal(RPC_Hits[h].localPosition()).z(), -1 );
1096	>	frogHitColl->addDaughter(frogHit);
1097	>	}
1098	>	}
1099	>
1100	>
1101	>
1102	>	// ### Calo Jets ###
1103	>	FROG_Element_Base_With_DetId* frogCaloJet = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_JET_CALO);
1104	>	event->addDaughter(frogCaloJet);
1105	>	for(unsigned int i=0;i<CaloJetsProducers.size();i++){
1106	>	edm::Handle<CaloJetCollection> h_Calo_Jets;
1107	>	iEvent.getByLabel(CaloJetsProducers[i], h_Calo_Jets);
1108	>	CaloJetCollection Calo_Jets = *h_Calo_Jets.product();
1109	>
1110	>	FROG_Element_Base_With_DetId* frogCaloJetColl = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_JET_CALO + i + 1);
1111	>	frogCaloJet->addDaughter(frogCaloJetColl);
1112	>
1113	>	for(unsigned int h=0;h<Calo_Jets.size();h++){
1114	>	//                DetId theDetUnitId = RPC_Hits[h].geographicalId();
1115	>	//                const GeomDet* theDet = RpcGeom->idToDet(theDetUnitId);
1116	>
1117	>	FROG_Element_Event_Jet* frogJet = new FROG_Element_Event_Jet(Calo_Jets[h].eta(),Calo_Jets[h].phi(),Calo_Jets[h].energy());
1118	>	frogCaloJet->addDaughter(frogJet);
1119	>	printf("AddJet\n");
1120	>	}
1121	>	}
1122
1123	<	MyEvent->MyMuonHitCollection.push_back(temp_RpcHit);
1123	>	// ### Calo Jets in cartesian coord ###
1124	>	FROG_Element_Base_With_DetId* frogCaloJetCand = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_RECOCAND);
1125	>	event->addDaughter(frogCaloJetCand);
1126	>	for(unsigned int i=0;i<CaloJetsProducers.size();i++){
1127	>	edm::Handle<CaloJetCollection> h_Calo_Jets;
1128	>	iEvent.getByLabel(CaloJetsProducers[i], h_Calo_Jets);
1129	>	CaloJetCollection Calo_Jets = *h_Calo_Jets.product();
1130	>
1131	>	FROG_Element_Base_With_DetId* frogCaloJetCollCand = new FROG_Element_Base_With_DetId(C_FEB_DETID, EVTID_RECOCAND + i + 1);
1132	>	frogCaloJetCand->addDaughter(frogCaloJetCollCand);
1133	>
1134	>	for(unsigned int h=0;h<Calo_Jets.size();h++){
1135	>	//                DetId theDetUnitId = RPC_Hits[h].geographicalId();
1136	>	//                const GeomDet* theDet = RpcGeom->idToDet(theDetUnitId);
1137	>
1138	>	FROG_Element_Event_Candidate* frogCandidate = new FROG_Element_Event_Candidate(Calo_Jets[h].px(),Calo_Jets[h].py(),Calo_Jets[h].pz());
1139	>	frogCaloJetCand->addDaughter(frogCandidate);
1140	>	printf("AddJetCand\n");
1141		}
1142		}
1143
1144	<	MyEvents->Events.push_back(MyEvent);
1144	>
1145	>
1146	>	NEvents++;
1147	>	if(NEvents == NEventsInVisFile){
1148	>	char OutputFileName[1024];
1149	>	sprintf(OutputFileName,"%s",OutputFile.substr(0,OutputFile.size()-4).c_str());
1150	>	if(NEventsInVisFile>=0)sprintf(OutputFileName,"%s_R%i_E%i.vis",OutputFileName,SRun,SEvent);
1151	>	sprintf(OutputFileName,"%s.vis",OutputFileName);
1152	>
1153	>	FROG_Events* events = new FROG_Events(events_prim);
1154	>	events->Save((char*) OutputFileName);
1155	>	delete events;
1156	>	delete events_prim;
1157	>
1158	>	events_prim = new FROG_Element_Base(C_PRIMARY);
1159	>	NEvents=0;
1160	>	}
1161	>
1162		}
1163
1164

Diff Legend

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