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$
//
//


// 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 "Visualisation/OpenGLDisplayer/interface/SimEvent.h"
//#include "Visualisation/OpenGLDisplayer/interface/SimEvent.cpp"


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&) ;
      virtual void analyze(const edm::Event&, const edm::EventSetup&);
      virtual void endJob() ;


      MySimEvents* MyEvents;


      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&)
{


   MyEvents = new MySimEvents();
 
}

// ------------ 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.2
Committed:	Sat Mar 15 17:02:20 2008 UTC (17 years, 1 month ago) by querten
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+13 -25 lines
Log Message:	Upgrade in the .Vis Format
#	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$
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
65
66	#include "Visualisation/OpenGLDisplayer/interface/SimEvent.h"
67	//#include "Visualisation/OpenGLDisplayer/interface/SimEvent.cpp"
68
69
70
71	using namespace edm;
72	using namespace std;
73
74	//
75	// class decleration
76	//
77
78	class OpenGLDisplayer : public edm::EDAnalyzer {
79	public:
80	explicit OpenGLDisplayer(const edm::ParameterSet&);
81	~OpenGLDisplayer();
82
83
84	private:
85	virtual void beginJob(const edm::EventSetup&) ;
86	virtual void analyze(const edm::Event&, const edm::EventSetup&);
87	virtual void endJob() ;
88
89
90	MySimEvents* MyEvents;
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&)
119	{
120
121
122	MyEvents = new MySimEvents();
123
124	}
125
126	// ------------ method called once each job just after ending the event loop ------------
127	void
128	OpenGLDisplayer::endJob() {
129
130	MyEvents->Save((char*) OutputFile.c_str());
131	MyEvents->Load((char*) OutputFile.c_str());
132	}
133
134
135
136	//
137	// member functions
138	//
139
140	// ------------ method called to for each event ------------
141	void
142	OpenGLDisplayer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
143	{
144
145	edm::Handle<std::vector< SimTrack > > h_SimTracks;
146	iEvent.getByLabel("g4SimHits", h_SimTracks);
147	std::vector< SimTrack > SimTrackColl = *h_SimTracks.product();
148
149	edm::Handle<std::vector< SimVertex > > h_Vertex;
150	iEvent.getByLabel("g4SimHits", h_Vertex);
151	std::vector< SimVertex > VertexColl = *h_Vertex.product();
152
153
154
155	// access the tracker
156	edm::ESHandle<TrackerGeometry> theTrackerGeometry;
157	iSetup.get<TrackerDigiGeometryRecord>().get(theTrackerGeometry);
158	const TrackerGeometry& theTracker(*theTrackerGeometry);
159
160	// the DetUnits
161	TrackingGeometry::DetContainer theDetUnits = theTracker.dets();
162
163
164
165
166	// Save the data
167
168	MySimEvent* MyEvent = new MySimEvent;
169
170	for ( unsigned int a = 0; a < SimTrackColl.size(); ++a ) {
171	MySimTrack MysimTrack;
172	SimTrack simTrack =SimTrackColl[a];
173
174	MysimTrack.track_id =simTrack.trackId();
175	MysimTrack.Type =simTrack.type();
176	MysimTrack.parent_vertex=simTrack.vertIndex();
177	MysimTrack.Px =simTrack.momentum().x();
178	MysimTrack.Py =simTrack.momentum().y();
179	MysimTrack.Pz =simTrack.momentum().z();
180	MysimTrack.E =simTrack.momentum().e();
181	MysimTrack.charge =simTrack.charge();
182
183	MyEvent->MySimTrackCollection.push_back(MysimTrack);
184	}
185
186
187	for (unsigned int b = 0; b < VertexColl.size(); ++b ) {
188	MySimVertex MyVertex;
189	SimVertex Vertex = VertexColl[b];
190
191	MyVertex.parentTrack_id =Vertex.parentIndex ();
192	MyVertex.x =Vertex.position().x();
193	MyVertex.y =Vertex.position().y();
194	MyVertex.z =Vertex.position().z();
195
196	MyEvent->MySimVertexCollection.push_back(MyVertex);
197	}
198
199	for(unsigned int i=0; i<SimHitSubdetectors.size(); i++)
200	{
201	edm::Handle<std::vector< PSimHit > > h_Hits;
202	iEvent.getByLabel("g4SimHits",SimHitSubdetectors[i].c_str(), h_Hits);
203	std::vector< PSimHit > Hits = *h_Hits.product();
204
205	for(unsigned int h=0; h<Hits.size(); h++)
206	{
207	DetId theDetUnitId(Hits[h].detUnitId());
208	const GeomDet * theDet = theTracker.idToDet(theDetUnitId);
209
210	MyPSimHit Hit;
211	Hit.x = theDet->surface().toGlobal(Hits[h].localPosition()).x();
212	Hit.y = theDet->surface().toGlobal(Hits[h].localPosition()).y();
213	Hit.z = theDet->surface().toGlobal(Hits[h].localPosition()).z();
214	Hit.ProcessType = Hits[h].processType();
215	Hit.dEdX = Hits[h].energyLoss();
216
217	MyEvent->MyPSimHitCollection.push_back(Hit);
218
219	}
220	}
221
222	edm::Handle<std::vector< reco::Track > > h_Tracks;
223	iEvent.getByLabel("ctfWithMaterialTracks", h_Tracks);
224	std::vector< reco::Track > TrackColl = *h_Tracks.product();
225
226	for ( unsigned int t = 0; t < TrackColl.size(); ++t ) {
227	MyRecoTrack MyrecoTrack;
228	reco::Track recoTrack =TrackColl[t];
229
230	// MyrecoTrack.Hits = new MyRecoHit[MyrecoTrack.N];
231
232	for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
233	TrackingRecHitRef h_it = recoTrack.recHit(h);
234	if(!h_it->isValid() )continue;
235	DetId detId = h_it->geographicalId();
236	const GeomDet * theDet = theTracker.idToDet(detId);
237	LocalPoint localPos = h_it->localPosition();
238
239	MyRecoHit hit;
240	hit.x = theDet->surface().toGlobal(localPos).x();
241	hit.y = theDet->surface().toGlobal(localPos).y();
242	hit.z = theDet->surface().toGlobal(localPos).z();
243	hit.DetId = detId.rawId();
244	hit.Charge = -1;
245	MyrecoTrack.Hits.push_back(hit);
246
247
248	// printf("%8.2f %8.2f %8.2f\n",theDet->surface().toGlobal(localPos).x(),theDet->surface().toGlobal(localPos).y(),theDet->surface().toGlobal(localPos).z());
249	}
250	MyEvent->MyRecoTrackCollection.push_back(MyrecoTrack);
251	}
252
253	MyEvents->Events.push_back(MyEvent);
254
255	}
256
257
258	//define this as a plug-in
259	DEFINE_FWK_MODULE(OpenGLDisplayer);
260
261