FastOpenGlDisplayer/src/OpenGLDisplayer.cc

// -*- C++ -*-
//
// Package:    OpenGLDisplayer
// Class:      OpenGLDisplayer
// 
/**\class OpenGLDisplayer OpenGLDisplayer.cc Visualisation/OpenGLDisplayer/src/OpenGLDisplayer.cc

 Description: <one line class summary>

 Implementation:
     <Notes on implementation>
*/
//
// Original Author:  Loic QUERTENMONT
//         Created:  Fri Oct 26 07:22:12 CEST 2007
// $Id: OpenGLDisplayer.cc,v 1.2 2008/03/15 17:02:20 querten Exp $
//
//


// system include files
#include <memory>

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/Framework/interface/ESHandle.h"

#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
#include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
#include "Geometry/CommonTopologies/interface/PixelTopology.h"
#include "Geometry/CommonTopologies/interface/StripTopology.h"
#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetType.h"
#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetType.h"
#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"
#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
#include "DataFormats/GeometrySurface/interface/BoundSurface.h"
#include "DataFormats/DetId/interface/DetId.h"

#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"
#include "SimDataFormats/TrackingHit/interface/PSimHit.h"
#include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h"
#include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "SimDataFormats/Vertex/interface/SimVertex.h"

#include "DataFormats/Provenance/interface/BranchDescription.h"
#include "DataFormats/Provenance/interface/Provenance.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/HepMCCandidate/interface/GenParticleCandidate.h"
#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
#include "DataFormats/TrackReco/interface/Track.h"

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h"
#include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"

#include "Visualisation/OpenGLDisplayer/interface/SimEvent.h"
#include "Visualisation/OpenGLDisplayer/interface/Geometry.h"

using namespace edm;
using namespace std;

//
// class decleration
//

class OpenGLDisplayer : public edm::EDAnalyzer {
   public:
      explicit OpenGLDisplayer(const edm::ParameterSet&);
      ~OpenGLDisplayer();


   private:
      virtual void beginJob(const edm::EventSetup& iSetup);
      virtual void analyze (const edm::Event&, const edm::EventSetup&);
      virtual void endJob  ();


      MySimEvents* MyEvents;
      Geometry*    Geom;


      std::vector<std::string> SimHitSubdetectors;

      std::string              OutputFile;


      // ----------member data ---------------------------
};

//
// constructors and destructor
//
OpenGLDisplayer::OpenGLDisplayer(const edm::ParameterSet& iConfig)
{
    SimHitSubdetectors  = iConfig.getParameter<std::vector<std::string> >("SimHitSubdetectors");

    OutputFile          = iConfig.getParameter<std::string >("OutputFile");
}


OpenGLDisplayer::~OpenGLDisplayer()
{
}

// ------------ method called once each job just before starting event loop  ------------
void
OpenGLDisplayer::beginJob(const edm::EventSetup& iSetup)
{

   MyEvents = new MySimEvents();
   Geom     = new Geometry();

   edm::ESHandle<TrackerGeometry> tkGeom;
   iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
   vector<GeomDet*> Det = tkGeom->dets();

   for(unsigned int i=0;i<Det.size();i++){
      DetId  Detid  = Det[i]->geographicalId();
//      int    SubDet = Detid.subdetId();
  
      GeomDet* DetUnit = Det[i]; 
      if(!DetUnit)continue;
      const BoundPlane plane = DetUnit->surface();
      const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
      const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));  

      float width;
      float length;
      float thickness;
      float TrapezoidalParam;

      if(trapezoidalBounds)
      {
         std::vector<float> const & parameters = (*trapezoidalBounds).parameters();      
         width            = parameters[0]*2;
         length           = parameters[3]*2;   
         thickness        =  (*trapezoidalBounds).thickness();
         TrapezoidalParam = parameters[1]/parameters[0];
      }else if(rectangularBounds){
         width            = DetUnit->surface().bounds().width();
         length           = DetUnit->surface().bounds().length();
         thickness        = DetUnit->surface().bounds().thickness();
         TrapezoidalParam = 1;
      }

      Surface::GlobalPoint WidthVector  = plane.toGlobal( LocalPoint(width/2, 0, 0) );
      Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
      Surface::GlobalPoint ThickVector  = plane.toGlobal( LocalPoint(0, 0, thickness/2) );

      GlobalVector Pos =  GlobalVector(DetUnit->position().basicVector());

      Geom->Add_TrackerDet(Detid.rawId(), TrapezoidalParam,
           Pos.x(),                  Pos.y(),                  Pos.z(),
           WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
           LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
           ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
      

   }
   Geom->Save("Tracker.geom");     

 
}

// ------------ method called once each job just after ending the event loop  ------------
void
OpenGLDisplayer::endJob() {
  
   MyEvents->Save((char*) OutputFile.c_str());
   MyEvents->Load((char*) OutputFile.c_str());
}


//
// member functions
//

// ------------ method called to for each event  ------------
void
OpenGLDisplayer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{

        edm::Handle<std::vector< SimTrack > > h_SimTracks;
        iEvent.getByLabel("g4SimHits", h_SimTracks);
        std::vector< SimTrack > SimTrackColl = *h_SimTracks.product();

        edm::Handle<std::vector< SimVertex > > h_Vertex;
        iEvent.getByLabel("g4SimHits", h_Vertex);
        std::vector< SimVertex > VertexColl = *h_Vertex.product();


        // access the tracker
        edm::ESHandle<TrackerGeometry> theTrackerGeometry;
        iSetup.get<TrackerDigiGeometryRecord>().get(theTrackerGeometry);
        const TrackerGeometry& theTracker(*theTrackerGeometry);
 
        // the DetUnits
        TrackingGeometry::DetContainer theDetUnits = theTracker.dets();


        // Save the data

        MySimEvent* MyEvent = new MySimEvent;
   
        for ( unsigned int a = 0; a < SimTrackColl.size(); ++a ) {
                MySimTrack  MysimTrack;
                SimTrack    simTrack    =SimTrackColl[a];

                MysimTrack.track_id     =simTrack.trackId();
                MysimTrack.Type         =simTrack.type();
                MysimTrack.parent_vertex=simTrack.vertIndex();
                MysimTrack.Px           =simTrack.momentum().x();
                MysimTrack.Py           =simTrack.momentum().y();
                MysimTrack.Pz           =simTrack.momentum().z();
                MysimTrack.E            =simTrack.momentum().e();
                MysimTrack.charge       =simTrack.charge(); 

                MyEvent->MySimTrackCollection.push_back(MysimTrack);
        }


        for (unsigned int b = 0; b < VertexColl.size(); ++b ) {
                MySimVertex     MyVertex;
                SimVertex       Vertex  =  VertexColl[b];

                MyVertex.parentTrack_id =Vertex.parentIndex ();
                MyVertex.x              =Vertex.position().x();
                MyVertex.y              =Vertex.position().y();
                MyVertex.z              =Vertex.position().z();

                MyEvent->MySimVertexCollection.push_back(MyVertex);
        }

        for(unsigned int i=0; i<SimHitSubdetectors.size(); i++)
        {
           edm::Handle<std::vector< PSimHit > > h_Hits;
           iEvent.getByLabel("g4SimHits",SimHitSubdetectors[i].c_str(), h_Hits);
           std::vector< PSimHit > Hits = *h_Hits.product();

           for(unsigned int h=0; h<Hits.size(); h++)
           {
               DetId theDetUnitId(Hits[h].detUnitId());
               const GeomDet * theDet = theTracker.idToDet(theDetUnitId);

                MyPSimHit Hit;
                Hit.x           = theDet->surface().toGlobal(Hits[h].localPosition()).x();
                Hit.y           = theDet->surface().toGlobal(Hits[h].localPosition()).y();
                Hit.z           = theDet->surface().toGlobal(Hits[h].localPosition()).z();
                Hit.ProcessType = Hits[h].processType();
                Hit.dEdX        = Hits[h].energyLoss();

                MyEvent->MyPSimHitCollection.push_back(Hit);

           }
        }

        edm::Handle<std::vector< reco::Track > > h_Tracks;
        iEvent.getByLabel("ctfWithMaterialTracks", h_Tracks);
        std::vector< reco::Track > TrackColl = *h_Tracks.product();

        for ( unsigned int t = 0; t < TrackColl.size(); ++t ) {
                MyRecoTrack  MyrecoTrack;
                reco::Track  recoTrack  =TrackColl[t];

//                MyrecoTrack.Hits = new MyRecoHit[MyrecoTrack.N];

                for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
                      TrackingRecHitRef h_it     = recoTrack.recHit(h);
                      if(!h_it->isValid() )continue;
                      DetId detId                = h_it->geographicalId();
                      const GeomDet * theDet     = theTracker.idToDet(detId);
                      LocalPoint localPos        = h_it->localPosition();

                      MyRecoHit hit;          
                      hit.x      = theDet->surface().toGlobal(localPos).x();
                      hit.y      = theDet->surface().toGlobal(localPos).y();
                      hit.z      = theDet->surface().toGlobal(localPos).z();
                      hit.DetId  = detId.rawId();
                      hit.Charge = -1;
                      MyrecoTrack.Hits.push_back(hit);


//                    printf("%8.2f %8.2f %8.2f\n",theDet->surface().toGlobal(localPos).x(),theDet->surface().toGlobal(localPos).y(),theDet->surface().toGlobal(localPos).z());
                }
                MyEvent->MyRecoTrackCollection.push_back(MyrecoTrack);
        }

        MyEvents->Events.push_back(MyEvent);   

}


//define this as a plug-in
DEFINE_FWK_MODULE(OpenGLDisplayer);


Revision:	1.8
Committed:	Fri Mar 21 08:41:36 2008 UTC (17 years, 1 month ago) by querten
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+2 -3 lines
Log Message:	Fix TrackerGeometry in Endcap
#	Content
1	// -- C++ --
2	//
3	// Package: OpenGLDisplayer
4	// Class: OpenGLDisplayer
5	//
6	/**\class OpenGLDisplayer OpenGLDisplayer.cc Visualisation/OpenGLDisplayer/src/OpenGLDisplayer.cc
7
8	Description: <one line class summary>
9
10	Implementation:
11	<Notes on implementation>
12	*/
13	//
14	// Original Author: Loic QUERTENMONT
15	// Created: Fri Oct 26 07:22:12 CEST 2007
16	// $Id: OpenGLDisplayer.cc,v 1.2 2008/03/15 17:02:20 querten Exp $
17	//
18	//
19
20
21	// system include files
22	#include <memory>
23
24	// user include files
25	#include "FWCore/Framework/interface/Frameworkfwd.h"
26	#include "FWCore/Framework/interface/EDAnalyzer.h"
27
28	#include "FWCore/Framework/interface/Event.h"
29	#include "FWCore/Framework/interface/MakerMacros.h"
30
31	#include "FWCore/ParameterSet/interface/ParameterSet.h"
32	#include "FWCore/ServiceRegistry/interface/Service.h"
33	#include "FWCore/Framework/interface/ESHandle.h"
34
35	#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
36	#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
37	#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
38	#include "Geometry/TrackerNumberingBuilder/interface/GeometricDet.h"
39	#include "Geometry/CommonTopologies/interface/PixelTopology.h"
40	#include "Geometry/CommonTopologies/interface/StripTopology.h"
41	#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetType.h"
42	#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetType.h"
43	#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h"
44	#include "Geometry/TrackerGeometryBuilder/interface/StripGeomDetUnit.h"
45	#include "DataFormats/GeometrySurface/interface/BoundSurface.h"
46	#include "DataFormats/DetId/interface/DetId.h"
47
48	#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"
49	#include "SimDataFormats/TrackingHit/interface/PSimHit.h"
50	#include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h"
51	#include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
52	#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
53	#include "SimDataFormats/Track/interface/SimTrack.h"
54	#include "SimDataFormats/Vertex/interface/SimVertex.h"
55
56	#include "DataFormats/Provenance/interface/BranchDescription.h"
57	#include "DataFormats/Provenance/interface/Provenance.h"
58	#include "DataFormats/Candidate/interface/Candidate.h"
59	#include "DataFormats/HepMCCandidate/interface/GenParticleCandidate.h"
60	#include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
61	#include "DataFormats/TrackReco/interface/Track.h"
62
63	#include "DataFormats/Math/interface/Point3D.h"
64	#include "DataFormats/GeometrySurface/interface/TrapezoidalPlaneBounds.h"
65	#include "DataFormats/GeometrySurface/interface/RectangularPlaneBounds.h"
66
67	#include "Visualisation/OpenGLDisplayer/interface/SimEvent.h"
68	#include "Visualisation/OpenGLDisplayer/interface/Geometry.h"
69
70	using namespace edm;
71	using namespace std;
72
73	//
74	// class decleration
75	//
76
77	class OpenGLDisplayer : public edm::EDAnalyzer {
78	public:
79	explicit OpenGLDisplayer(const edm::ParameterSet&);
80	~OpenGLDisplayer();
81
82
83	private:
84	virtual void beginJob(const edm::EventSetup& iSetup);
85	virtual void analyze (const edm::Event&, const edm::EventSetup&);
86	virtual void endJob ();
87
88
89	MySimEvents* MyEvents;
90	Geometry* Geom;
91
92
93	std::vector<std::string> SimHitSubdetectors;
94
95	std::string OutputFile;
96
97
98	// ----------member data ---------------------------
99	};
100
101	//
102	// constructors and destructor
103	//
104	OpenGLDisplayer::OpenGLDisplayer(const edm::ParameterSet& iConfig)
105	{
106	SimHitSubdetectors = iConfig.getParameter<std::vector<std::string> >("SimHitSubdetectors");
107
108	OutputFile = iConfig.getParameter<std::string >("OutputFile");
109	}
110
111
112	OpenGLDisplayer::~OpenGLDisplayer()
113	{
114	}
115
116	// ------------ method called once each job just before starting event loop ------------
117	void
118	OpenGLDisplayer::beginJob(const edm::EventSetup& iSetup)
119	{
120
121	MyEvents = new MySimEvents();
122	Geom = new Geometry();
123
124	edm::ESHandle<TrackerGeometry> tkGeom;
125	iSetup.get<TrackerDigiGeometryRecord>().get( tkGeom );
126	vector<GeomDet*> Det = tkGeom->dets();
127
128	for(unsigned int i=0;i<Det.size();i++){
129	DetId Detid = Det[i]->geographicalId();
130	// int SubDet = Detid.subdetId();
131
132	GeomDet* DetUnit = Det[i];
133	if(!DetUnit)continue;
134	const BoundPlane plane = DetUnit->surface();
135	const TrapezoidalPlaneBounds* trapezoidalBounds( dynamic_cast<const TrapezoidalPlaneBounds*>(&(plane.bounds())));
136	const RectangularPlaneBounds* rectangularBounds( dynamic_cast<const RectangularPlaneBounds*>(&(plane.bounds())));
137
138	float width;
139	float length;
140	float thickness;
141	float TrapezoidalParam;
142
143	if(trapezoidalBounds)
144	{
145	std::vector<float> const & parameters = (*trapezoidalBounds).parameters();
146	width = parameters[0]*2;
147	length = parameters[3]*2;
148	thickness = (*trapezoidalBounds).thickness();
149	TrapezoidalParam = parameters[1]/parameters[0];
150	}else if(rectangularBounds){
151	width = DetUnit->surface().bounds().width();
152	length = DetUnit->surface().bounds().length();
153	thickness = DetUnit->surface().bounds().thickness();
154	TrapezoidalParam = 1;
155	}
156
157	Surface::GlobalPoint WidthVector = plane.toGlobal( LocalPoint(width/2, 0, 0) );
158	Surface::GlobalPoint LengthVector = plane.toGlobal( LocalPoint(0, length/2, 0) );
159	Surface::GlobalPoint ThickVector = plane.toGlobal( LocalPoint(0, 0, thickness/2) );
160
161	GlobalVector Pos = GlobalVector(DetUnit->position().basicVector());
162
163	Geom->Add_TrackerDet(Detid.rawId(), TrapezoidalParam,
164	Pos.x(), Pos.y(), Pos.z(),
165	WidthVector.x() -Pos.x(), WidthVector.y() -Pos.y(), WidthVector.z() -Pos.z(),
166	LengthVector.x()-Pos.x(), LengthVector.y()-Pos.y(), LengthVector.z()-Pos.z(),
167	ThickVector.x() -Pos.x(), ThickVector.y() -Pos.y(), ThickVector.z() -Pos.z());
168
169
170	}
171	Geom->Save("Tracker.geom");
172
173
174	}
175
176	// ------------ method called once each job just after ending the event loop ------------
177	void
178	OpenGLDisplayer::endJob() {
179
180	MyEvents->Save((char*) OutputFile.c_str());
181	MyEvents->Load((char*) OutputFile.c_str());
182	}
183
184
185
186	//
187	// member functions
188	//
189
190	// ------------ method called to for each event ------------
191	void
192	OpenGLDisplayer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
193	{
194
195	edm::Handle<std::vector< SimTrack > > h_SimTracks;
196	iEvent.getByLabel("g4SimHits", h_SimTracks);
197	std::vector< SimTrack > SimTrackColl = *h_SimTracks.product();
198
199	edm::Handle<std::vector< SimVertex > > h_Vertex;
200	iEvent.getByLabel("g4SimHits", h_Vertex);
201	std::vector< SimVertex > VertexColl = *h_Vertex.product();
202
203
204
205	// access the tracker
206	edm::ESHandle<TrackerGeometry> theTrackerGeometry;
207	iSetup.get<TrackerDigiGeometryRecord>().get(theTrackerGeometry);
208	const TrackerGeometry& theTracker(*theTrackerGeometry);
209
210	// the DetUnits
211	TrackingGeometry::DetContainer theDetUnits = theTracker.dets();
212
213
214
215
216	// Save the data
217
218	MySimEvent* MyEvent = new MySimEvent;
219
220	for ( unsigned int a = 0; a < SimTrackColl.size(); ++a ) {
221	MySimTrack MysimTrack;
222	SimTrack simTrack =SimTrackColl[a];
223
224	MysimTrack.track_id =simTrack.trackId();
225	MysimTrack.Type =simTrack.type();
226	MysimTrack.parent_vertex=simTrack.vertIndex();
227	MysimTrack.Px =simTrack.momentum().x();
228	MysimTrack.Py =simTrack.momentum().y();
229	MysimTrack.Pz =simTrack.momentum().z();
230	MysimTrack.E =simTrack.momentum().e();
231	MysimTrack.charge =simTrack.charge();
232
233	MyEvent->MySimTrackCollection.push_back(MysimTrack);
234	}
235
236
237	for (unsigned int b = 0; b < VertexColl.size(); ++b ) {
238	MySimVertex MyVertex;
239	SimVertex Vertex = VertexColl[b];
240
241	MyVertex.parentTrack_id =Vertex.parentIndex ();
242	MyVertex.x =Vertex.position().x();
243	MyVertex.y =Vertex.position().y();
244	MyVertex.z =Vertex.position().z();
245
246	MyEvent->MySimVertexCollection.push_back(MyVertex);
247	}
248
249	for(unsigned int i=0; i<SimHitSubdetectors.size(); i++)
250	{
251	edm::Handle<std::vector< PSimHit > > h_Hits;
252	iEvent.getByLabel("g4SimHits",SimHitSubdetectors[i].c_str(), h_Hits);
253	std::vector< PSimHit > Hits = *h_Hits.product();
254
255	for(unsigned int h=0; h<Hits.size(); h++)
256	{
257	DetId theDetUnitId(Hits[h].detUnitId());
258	const GeomDet * theDet = theTracker.idToDet(theDetUnitId);
259
260	MyPSimHit Hit;
261	Hit.x = theDet->surface().toGlobal(Hits[h].localPosition()).x();
262	Hit.y = theDet->surface().toGlobal(Hits[h].localPosition()).y();
263	Hit.z = theDet->surface().toGlobal(Hits[h].localPosition()).z();
264	Hit.ProcessType = Hits[h].processType();
265	Hit.dEdX = Hits[h].energyLoss();
266
267	MyEvent->MyPSimHitCollection.push_back(Hit);
268
269	}
270	}
271
272	edm::Handle<std::vector< reco::Track > > h_Tracks;
273	iEvent.getByLabel("ctfWithMaterialTracks", h_Tracks);
274	std::vector< reco::Track > TrackColl = *h_Tracks.product();
275
276	for ( unsigned int t = 0; t < TrackColl.size(); ++t ) {
277	MyRecoTrack MyrecoTrack;
278	reco::Track recoTrack =TrackColl[t];
279
280	// MyrecoTrack.Hits = new MyRecoHit[MyrecoTrack.N];
281
282	for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
283	TrackingRecHitRef h_it = recoTrack.recHit(h);
284	if(!h_it->isValid() )continue;
285	DetId detId = h_it->geographicalId();
286	const GeomDet * theDet = theTracker.idToDet(detId);
287	LocalPoint localPos = h_it->localPosition();
288
289	MyRecoHit hit;
290	hit.x = theDet->surface().toGlobal(localPos).x();
291	hit.y = theDet->surface().toGlobal(localPos).y();
292	hit.z = theDet->surface().toGlobal(localPos).z();
293	hit.DetId = detId.rawId();
294	hit.Charge = -1;
295	MyrecoTrack.Hits.push_back(hit);
296
297
298	// printf("%8.2f %8.2f %8.2f\n",theDet->surface().toGlobal(localPos).x(),theDet->surface().toGlobal(localPos).y(),theDet->surface().toGlobal(localPos).z());
299	}
300	MyEvent->MyRecoTrackCollection.push_back(MyrecoTrack);
301	}
302
303	MyEvents->Events.push_back(MyEvent);
304
305	}
306
307
308	//define this as a plug-in
309	DEFINE_FWK_MODULE(OpenGLDisplayer);
310
311