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
#	User	Rev	Content
1	querten	1.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	querten	1.2	// MyrecoTrack.Hits = new MyRecoHit[MyrecoTrack.N];
231	querten	1.1
232	querten	1.2	for(unsigned int h=0;h<recoTrack.recHitsSize();h++){
233	querten	1.1	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	querten	1.2
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	querten	1.1	}
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