ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/FastOpenGlDisplayer/src/SimEvent.cpp

Comparing UserCode/FastOpenGlDisplayer/src/SimEvent.cpp (file contents):
Revision 1.6 by roberfro, Fri Apr 4 21:20:20 2008 UTC vs.
Revision 1.12 by querten, Thu May 1 06:52:20 2008 UTC

#	Line 46 | Line 46 | void MySimEvent::LoadEvent(FILE* pFile,
46		}
47		break;
48
49	<	case C_SIM_TRACKHIT:    // PSimHit
50	<	MyPSimHit temp_SimHit;
51	<	CurrentChunk->read += fread(&temp_SimHit,sizeof(MyPSimHit),1,pFile) * sizeof(MyPSimHit);
52	<	MyPSimHitCollection.push_back(temp_SimHit);
53	<	break;
49	>	case C_SIM_TRACKHIT:{   // PSimHit
50	>	while(CurrentChunk->read<CurrentChunk->size){
51	>	MyPSimHit* temp_SimHit = new MyPSimHit;
52	>	CurrentChunk->read += fread(temp_SimHit,sizeof(MyPSimHit),1,pFile) * sizeof(MyPSimHit);
53	>	MyPSimHitCollection.push_back(temp_SimHit);
54	>	}
55	>	}break;
56
57	<	case C_SIM_CALOHIT:             // PCaloHit
58	<	MyPCaloHit temp_PSimCaloHit;
59	<	CurrentChunk->read += fread(&temp_PSimCaloHit,sizeof(MyPCaloHit),1,pFile) * sizeof(MyPCaloHit);
60	<	MyPCaloHitCollection.push_back(temp_PSimCaloHit);
61	<	break;
57	>	case C_SIM_CALOHIT:{            // PCaloHit
58	>	while(CurrentChunk->read<CurrentChunk->size){
59	>	MyPCaloHit* temp_PSimCaloHit = new MyPCaloHit;
60	>	CurrentChunk->read += fread(temp_PSimCaloHit,sizeof(MyPCaloHit),1,pFile) * sizeof(MyPCaloHit);
61	>	MyPCaloHitCollection.push_back(temp_PSimCaloHit);
62	>	}
63	>	}break;
64
65	<	case C_SIM_VERTEX:              // SimVertex
66	<	MySimVertex temp_SimVertex;
67	<	CurrentChunk->read += fread(&temp_SimVertex,sizeof(MySimVertex),1,pFile) * sizeof(MySimVertex);
68	<	MySimVertexCollection.push_back(temp_SimVertex);
69	<	break;
65	>	case C_SIM_VERTEX:{             // SimVertex
66	>	while(CurrentChunk->read<CurrentChunk->size){
67	>	MySimVertex* temp_SimVertex = new MySimVertex;
68	>	CurrentChunk->read += fread(temp_SimVertex,sizeof(MySimVertex),1,pFile) * sizeof(MySimVertex);
69	>	MySimVertexCollection.push_back(temp_SimVertex);
70	>	}
71	>	}break;
72
73	<	case C_SIM_TRACK:               // SimTrack
74	<	MySimTrack temp_SimTrack;
75	<	CurrentChunk->read += fread(&temp_SimTrack,sizeof(MySimTrack),1,pFile) * sizeof(MySimTrack);
76	<	MySimTrackCollection.push_back(temp_SimTrack);
77	<	break;
73	>	case C_SIM_TRACK:{              // SimTrack
74	>	while(CurrentChunk->read<CurrentChunk->size){
75	>	MySimTrack* temp_SimTrack = new MySimTrack;
76	>	CurrentChunk->read += fread(temp_SimTrack,sizeof(MySimTrack),1,pFile) * sizeof(MySimTrack);
77	>	MySimTrackCollection.push_back(temp_SimTrack);
78	>	}
79	>	}break;
80
81
82
#	Line 79 | Line 87 | void MySimEvent::LoadEvent(FILE* pFile,
87		}
88		break;
89
90	<	case C_RECO_TRACK:              // RecoTrack
91	<	MyRecoTrackCollection.push_back(*(new MyRecoTrack));
90	>	case C_RECO_TRACK:{             // RecoTrack
91	>	MyRecoTrackCollection.push_back(new MyRecoTrack);
92		while(CurrentChunk->read<CurrentChunk->size){
93		LoadEvent(pFile,CurrentChunk);
94		}
95	<	break;
95	>	}break;
96	>
97	>	case C_RECO_TRACKHIT:{  // RecHits
98	>	while(CurrentChunk->read<CurrentChunk->size){
99	>	MyRecoHit* temp_RecoHit = new MyRecoHit;
100	>	CurrentChunk->read += fread(temp_RecoHit,sizeof(MyRecoHit),1,pFile) * sizeof(MyRecoHit);
101	>	MyRecoTrackCollection[MyRecoTrackCollection.size()-1]->Hits.push_back(temp_RecoHit);
102	>	}
103	>	}break;
104	>
105	>	case C_RECO_TRACKINFO:{ // TrackInfo
106	>	MyRecoTrackInfo* temp_Info = new MyRecoTrackInfo;
107	>	CurrentChunk->read += fread(temp_Info,sizeof(MyRecoTrackInfo),1,pFile) * sizeof(MyRecoTrackInfo);
108	>	MyRecoTrackCollection[MyRecoTrackCollection.size()-1]->Info = temp_Info;
109	>	}break;
110
111	<	case C_RECO_TRACKHIT:   // RecHits
112	<	MyRecoHit temp_RecoHit;
113	<	CurrentChunk->read += fread(&temp_RecoHit,sizeof(MyRecoHit),1,pFile) * sizeof(MyRecoHit);
114	<	MyRecoTrackCollection[MyRecoTrackCollection.size()-1].Hits.push_back(temp_RecoHit);
115	<	break;
116	<
117	<	case C_RECO_ECALHIT:    // RecHits
96	<	MyCaloHit temp_EcalHit;
97	<	CurrentChunk->read += fread(&temp_EcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);
98	<	MyEcalCaloHitCollection.push_back(temp_EcalHit);
99	<	break;
100	<
101	<	case C_RECO_HCALHIT:    // RecHits
102	<	MyCaloHit temp_HcalHit;
103	<	CurrentChunk->read += fread(&temp_HcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);
104	<	MyHcalCaloHitCollection.push_back(temp_HcalHit);
105	<	break;
111	>	case C_RECO_ECALHIT:{   // ECAL Hits
112	>	while(CurrentChunk->read<CurrentChunk->size){
113	>	MyCaloHit* temp_EcalHit = new MyCaloHit;
114	>	CurrentChunk->read += fread(temp_EcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);
115	>	MyEcalCaloHitCollection.push_back(temp_EcalHit);
116	>	}
117	>	}break;
118
119	+	case C_RECO_HCALHIT:{   // HCAL Hits
120	+	while(CurrentChunk->read<CurrentChunk->size){
121	+	MyCaloHit* temp_HcalHit = new MyCaloHit;
122	+	CurrentChunk->read += fread(temp_HcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);
123	+	MyHcalCaloHitCollection.push_back(temp_HcalHit);
124	+	}
125	+	}break;
126	+
127	+	case C_RECO_MUONSEG:{           // Muon Segments
128	+	while(CurrentChunk->read<CurrentChunk->size){
129	+	MyMuonSegment* temp_MuonSeg = new MyMuonSegment;
130	+	CurrentChunk->read += fread(temp_MuonSeg,sizeof(MyMuonSegment),1,pFile) * sizeof(MyMuonSegment);
131	+	MyMuonSegmentCollection.push_back(temp_MuonSeg);
132	+	}
133	+	}break;
134	+
135	+
136	+	case C_RECO_MUONHIT:{           // Muon Hits
137	+	while(CurrentChunk->read<CurrentChunk->size){
138	+	MyMuonHit* temp_MuonHit = new MyMuonHit;
139	+	CurrentChunk->read += fread(temp_MuonHit,sizeof(MyMuonHit),1,pFile) * sizeof(MyMuonHit);
140	+	MyMuonHitCollection.push_back(temp_MuonHit);
141	+	}
142	+	}break;
143
144
145		////////////////////////UNKOWN CHUNK ////////////////////////
#	Line 125 | Line 161 | void MySimEvent::SaveEvent(stChunkToSave
161		{
162		unsigned int i;
163		stChunkToSave* CurrentChunk;
164	+	void* data_buffer;
165
166		switch(ParentChunk->type)
167		{
#	Line 148 | Line 185 | void MySimEvent::SaveEvent(stChunkToSave
185		break;
186
187		case C_SIM:                         // SimData
188	<	for(i=0;i<MyPSimHitCollection.size();i++){
188	>	if(MyPSimHitCollection.size()>0){
189		CurrentChunk       = new stChunkToSave;
190		CurrentChunk->type = C_SIM_TRACKHIT;
191	<	CurrentChunk->size = 6+sizeof(MyPSimHit);
192	<	CurrentChunk->data = (char*)&MyPSimHitCollection[i];
191	>	CurrentChunk->size = 6 + sizeof(MyPSimHit)*MyPSimHitCollection.size();
192	>	data_buffer        = new void*[CurrentChunk->size-6];
193	>	CurrentChunk->data = data_buffer;
194	>	for(i=0;i<MyPSimHitCollection.size();i++){
195	>	memcpy( data_buffer, MyPSimHitCollection[i], sizeof(MyPSimHit) );
196	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyPSimHit));
197	>	}
198		ParentChunk->daughters.push_back(CurrentChunk);
199	<	}
200	<	for(i=0;i<MyPCaloHitCollection.size();i++){
199	>	}
200	>
201	>	if(MyPCaloHitCollection.size()>0){
202		CurrentChunk       = new stChunkToSave;
203		CurrentChunk->type = C_SIM_CALOHIT;
204	<	CurrentChunk->size = 6+sizeof(MyPCaloHit);
205	<	CurrentChunk->data = (char*)&MyPCaloHitCollection[i];
204	>	CurrentChunk->size = 6 + sizeof(MyPCaloHit)*MyPCaloHitCollection.size();
205	>	data_buffer        = new void*[CurrentChunk->size-6];
206	>	CurrentChunk->data = data_buffer;
207	>	for(i=0;i<MyPCaloHitCollection.size();i++){
208	>	memcpy( data_buffer, MyPCaloHitCollection[i], sizeof(MyPCaloHit) );
209	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyPCaloHit));
210	>	}
211		ParentChunk->daughters.push_back(CurrentChunk);
212		}
213	<	for(i=0;i<MySimVertexCollection.size();i++){
213	>
214	>	if(MySimVertexCollection.size()>0){
215		CurrentChunk       = new stChunkToSave;
216		CurrentChunk->type = C_SIM_VERTEX;
217	<	CurrentChunk->size = 6+sizeof(MySimVertex);
218	<	CurrentChunk->data = (char*)&MySimVertexCollection[i];
217	>	CurrentChunk->size = 6 + sizeof(MySimVertex)*MySimVertexCollection.size();
218	>	data_buffer        = new void*[CurrentChunk->size-6];
219	>	CurrentChunk->data = data_buffer;
220	>	for(i=0;i<MySimVertexCollection.size();i++){
221	>	memcpy( data_buffer, MySimVertexCollection[i], sizeof(MySimVertex) );
222	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MySimVertex));
223	>	}
224		ParentChunk->daughters.push_back(CurrentChunk);
225		}
226	<	for(i=0;i<MySimTrackCollection.size();i++){
226	>
227	>	if(MySimTrackCollection.size()>0){
228		CurrentChunk       = new stChunkToSave;
229		CurrentChunk->type = C_SIM_TRACK;
230	<	CurrentChunk->size = 6+sizeof(MySimTrack);
231	<	CurrentChunk->data = (char*)&MySimTrackCollection[i];
230	>	CurrentChunk->size = 6 + sizeof(MySimTrack)*MySimTrackCollection.size();
231	>	data_buffer        = new void*[CurrentChunk->size-6];
232	>	CurrentChunk->data = data_buffer;
233	>	for(i=0;i<MySimTrackCollection.size();i++){
234	>	memcpy( data_buffer, MySimTrackCollection[i], sizeof(MySimTrack) );
235	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MySimTrack));
236	>	}
237		ParentChunk->daughters.push_back(CurrentChunk);
238	<	}
238	>	}
239		break;
240
181	–
241		case C_RECO:                // RecoData
242		for(i=0;i<MyRecoTrackCollection.size();i++){
243		CurrentChunk         = new stChunkToSave;
244		CurrentChunk->type   = C_RECO_TRACK;
245		CurrentChunk->size   = 6;
246	<	CurrentChunk->buffer = &MyRecoTrackCollection[i];
246	>	CurrentChunk->buffer = MyRecoTrackCollection[i];
247		ParentChunk->daughters.push_back(CurrentChunk);
248		}
249	+
250
251	<	for(i=0;i<MyEcalCaloHitCollection.size();i++){
252	<	CurrentChunk         = new stChunkToSave;
253	<	CurrentChunk->type   = C_RECO_ECALHIT;
254	<	CurrentChunk->size   = 6+sizeof(MyCaloHit);
255	<	CurrentChunk->data   = &MyEcalCaloHitCollection[i];
251	>	if(MyEcalCaloHitCollection.size()>0){
252	>	CurrentChunk       = new stChunkToSave;
253	>	CurrentChunk->type = C_RECO_ECALHIT;
254	>	CurrentChunk->size = 6 + sizeof(MyCaloHit)*MyEcalCaloHitCollection.size();
255	>	data_buffer        = new void*[CurrentChunk->size-6];
256	>	CurrentChunk->data = data_buffer;
257	>	for(i=0;i<MyEcalCaloHitCollection.size();i++){
258	>	memcpy( data_buffer, MyEcalCaloHitCollection[i], sizeof(MyCaloHit) );
259	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyCaloHit));
260	>	}
261		ParentChunk->daughters.push_back(CurrentChunk);
262	<	}
262	>	}
263
264	<	for(i=0;i<MyHcalCaloHitCollection.size();i++){
265	<	CurrentChunk         = new stChunkToSave;
266	<	CurrentChunk->type   = C_RECO_HCALHIT;
267	<	CurrentChunk->size   = 6+sizeof(MyCaloHit);
268	<	CurrentChunk->data   = &MyHcalCaloHitCollection[i];
264	>	if(MyHcalCaloHitCollection.size()>0){
265	>	CurrentChunk       = new stChunkToSave;
266	>	CurrentChunk->type = C_RECO_HCALHIT;
267	>	CurrentChunk->size = 6 + sizeof(MyCaloHit)*MyHcalCaloHitCollection.size();
268	>	data_buffer        = new void*[CurrentChunk->size-6];
269	>	CurrentChunk->data = data_buffer;
270	>	for(i=0;i<MyHcalCaloHitCollection.size();i++){
271	>	memcpy( data_buffer, MyHcalCaloHitCollection[i], sizeof(MyCaloHit) );
272	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyCaloHit));
273	>	}
274		ParentChunk->daughters.push_back(CurrentChunk);
275	<	}
275	>	}
276	>
277	>	if(MyMuonSegmentCollection.size()>0){
278	>	CurrentChunk       = new stChunkToSave;
279	>	CurrentChunk->type = C_RECO_MUONSEG;
280	>	CurrentChunk->size = 6 + sizeof(MyMuonSegment)*MyMuonSegmentCollection.size();
281	>	data_buffer        = new void*[CurrentChunk->size-6];
282	>	CurrentChunk->data = data_buffer;
283	>	for(i=0;i<MyMuonSegmentCollection.size();i++){
284	>	memcpy( data_buffer, MyMuonSegmentCollection[i], sizeof(MyMuonSegment) );
285	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyMuonSegment));
286	>	}
287	>	ParentChunk->daughters.push_back(CurrentChunk);
288	>	}
289	>
290	>	if(MyMuonHitCollection.size()>0){
291	>	CurrentChunk       = new stChunkToSave;
292	>	CurrentChunk->type = C_RECO_MUONHIT;
293	>	CurrentChunk->size = 6 + sizeof(MyMuonHit)*MyMuonHitCollection.size();
294	>	data_buffer        = new void*[CurrentChunk->size-6];
295	>	CurrentChunk->data = data_buffer;
296	>	for(i=0;i<MyMuonHitCollection.size();i++){
297	>	memcpy( data_buffer, MyMuonHitCollection[i], sizeof(MyMuonHit) );
298	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyMuonHit));
299	>	}
300	>	ParentChunk->daughters.push_back(CurrentChunk);
301	>	}
302		break;
303
304
305	<	case C_RECO_TRACK:     // RecoTrack
306	<	for(i=0;i<((MyRecoTrack*)ParentChunk->buffer)->Hits.size();i++){
305	>	case C_RECO_TRACK:     // RecoTrack
306	>	if(((MyRecoTrack*)ParentChunk->buffer)->Hits.size()>0){
307		CurrentChunk       = new stChunkToSave;
308		CurrentChunk->type = C_RECO_TRACKHIT;
309	<	CurrentChunk->size = 6+sizeof(MyRecoHit);
310	<	CurrentChunk->data = (char*)&((MyRecoTrack*)ParentChunk->buffer)->Hits[i];
309	>	CurrentChunk->size = 6 + sizeof(MyRecoHit)*((MyRecoTrack*)ParentChunk->buffer)->Hits.size();
310	>	data_buffer        = new void*[CurrentChunk->size-6];
311	>	CurrentChunk->data = data_buffer;
312	>	for(i=0;i<((MyRecoTrack*)ParentChunk->buffer)->Hits.size();i++){
313	>	memcpy( data_buffer, ((MyRecoTrack*)ParentChunk->buffer)->Hits[i], sizeof(MyRecoHit) );
314	>	data_buffer = (void*)((unsigned long)data_buffer + sizeof(MyRecoHit));
315	>	}
316		ParentChunk->daughters.push_back(CurrentChunk);
317	<	}
317	>
318	>	if(((MyRecoTrack*)ParentChunk->buffer)->Info!=NULL){
319	>	printf("X\n");
320	>	CurrentChunk       = new stChunkToSave;
321	>	CurrentChunk->type = C_RECO_TRACKINFO;
322	>	CurrentChunk->size = 6 + sizeof(MyRecoTrackInfo);
323	>	data_buffer        = new void*[CurrentChunk->size-6];
324	>	CurrentChunk->data = data_buffer;
325	>	memcpy( data_buffer, ((MyRecoTrack*)ParentChunk->buffer)->Info, sizeof(MyRecoTrackInfo) );
326	>	ParentChunk->daughters.push_back(CurrentChunk);
327	>	}
328	>	}
329		break;
330
331		default:
332		break;
333		}
334
335	<
335	>
336		for(unsigned int i=0; i<ParentChunk->daughters.size();i++)
337		{
338		if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
#	Line 304 | Line 416 | MySimEvents::~MySimEvents()
416
417		}
418
419	<	void MySimEvents::Load(char* path)
419	>	void MySimEvents::Load(const char* path)
420		{
421		FILE* f = fopen(path,"rb" );
422		if(f==NULL){
#	Line 392 | Line 504 | void MySimEvents::Load(char* path)
504		}
505
506
507	<	void MySimEvents::Save(char* path)
507	>	void MySimEvents::Save(const char* path)
508		{
509		stChunkToSave* Primary_chunk = new stChunkToSave;
510
511		Primary_chunk->type  = C_PRIMARY;
512		Primary_chunk->size =  6;
513	<
513	>
514		for(unsigned int i=0;i<Events.size();i++){
515		Events[i]->SaveEvent(Primary_chunk);
516		}
#	Line 406 | Line 518 | void MySimEvents::Save(char* path)
518		Primary_chunk->size =  6;
519		for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
520		Primary_chunk->size += Primary_chunk->daughters[i]->size;
521	<	}
521	>	}
522		/*
523		printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
524		for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
#	Line 427 | Line 539 | void MySimEvents::Save(char* path)
539		}
540		*/
541
542	<	FILE* pFile = fopen(path,"wb" );
542	>	FILE* pFile = fopen(path,"wb" );
543		WriteChunk(pFile, Primary_chunk);
544	<	fclose(pFile);
544	>	fclose(pFile);
545		}
546
547

Diff Legend

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