ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/FastOpenGlDisplayer/src/SimEvent.cpp
(Generate patch)

Comparing UserCode/FastOpenGlDisplayer/src/SimEvent.cpp (file contents):
Revision 1.6 by roberfro, Fri Apr 4 21:20:20 2008 UTC vs.
Revision 1.9 by querten, Sun Apr 27 07:27:30 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 <                        MyRecoHit temp_RecoHit;
99 <                        CurrentChunk->read += fread(&temp_RecoHit,sizeof(MyRecoHit),1,pFile) * sizeof(MyRecoHit);
100 <                        MyRecoTrackCollection[MyRecoTrackCollection.size()-1].Hits.push_back(temp_RecoHit);
101 <                        break;  
102 <
103 <                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;  
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_ECALHIT:{   // RecHits              
106 +                        while(CurrentChunk->read<CurrentChunk->size){
107 +                                MyCaloHit* temp_EcalHit = new MyCaloHit;
108 +                                CurrentChunk->read += fread(temp_EcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);                        
109 +                                MyEcalCaloHitCollection.push_back(temp_EcalHit);
110 +                        }
111 +                        }break;
112 +
113 +                case C_RECO_HCALHIT:{   // RecHits      
114 +                        while(CurrentChunk->read<CurrentChunk->size){
115 +                                MyCaloHit* temp_HcalHit = new MyCaloHit;
116 +                                CurrentChunk->read += fread(temp_HcalHit,sizeof(MyCaloHit),1,pFile) * sizeof(MyCaloHit);                        
117 +                                MyHcalCaloHitCollection.push_back(temp_HcalHit);
118 +                        }
119 +                        }break;
120 +
121 +                case C_RECO_MUONSEG:{           // Muon Segments        
122 +                        while(CurrentChunk->read<CurrentChunk->size){
123 +                                MyMuonSegment* temp_MuonSeg = new MyMuonSegment;
124 +                                CurrentChunk->read += fread(temp_MuonSeg,sizeof(MyMuonSegment),1,pFile) * sizeof(MyMuonSegment);
125 +                                MyMuonSegmentCollection.push_back(temp_MuonSeg);
126 +                        }
127 +                        }break;
128 +
129 +                case C_RECO_MUONHIT:{           // Muon Hits
130 +                        while(CurrentChunk->read<CurrentChunk->size){
131 +                                MyMuonHit* temp_MuonHit = new MyMuonHit;
132 +                                CurrentChunk->read += fread(temp_MuonHit,sizeof(MyMuonHit),1,pFile) * sizeof(MyMuonHit);
133 +                                MyMuonHitCollection.push_back(temp_MuonHit);
134 +                        }
135 +                        }break;
136  
137  
138                  ////////////////////////UNKOWN CHUNK ////////////////////////
# Line 125 | Line 154 | void MySimEvent::SaveEvent(stChunkToSave
154   {
155          unsigned int i;
156          stChunkToSave* CurrentChunk;
157 +        void* data_buffer;
158          
159          switch(ParentChunk->type)
160          {
# Line 148 | Line 178 | void MySimEvent::SaveEvent(stChunkToSave
178                          break;
179          
180                  case C_SIM:                         // SimData
181 <                        for(i=0;i<MyPSimHitCollection.size();i++){              
181 >                        if(MyPSimHitCollection.size()>0){
182                                  CurrentChunk       = new stChunkToSave;
183                                  CurrentChunk->type = C_SIM_TRACKHIT;
184 <                                CurrentChunk->size = 6+sizeof(MyPSimHit);
185 <                                CurrentChunk->data = (char*)&MyPSimHitCollection[i];
184 >                                CurrentChunk->size = 6 + sizeof(MyPSimHit)*MyPSimHitCollection.size();
185 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
186 >                                CurrentChunk->data = data_buffer;
187 >                                for(i=0;i<MyPSimHitCollection.size();i++){              
188 >                                        memcpy( data_buffer, MyPSimHitCollection[i], sizeof(MyPSimHit) );
189 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyPSimHit));                                  
190 >                                }      
191                                  ParentChunk->daughters.push_back(CurrentChunk);
192 <                        }              
193 <                        for(i=0;i<MyPCaloHitCollection.size();i++){            
192 >                        }
193 >
194 >                        if(MyPCaloHitCollection.size()>0){
195                                  CurrentChunk       = new stChunkToSave;
196                                  CurrentChunk->type = C_SIM_CALOHIT;
197 <                                CurrentChunk->size = 6+sizeof(MyPCaloHit);
198 <                                CurrentChunk->data = (char*)&MyPCaloHitCollection[i];
197 >                                CurrentChunk->size = 6 + sizeof(MyPCaloHit)*MyPCaloHitCollection.size();
198 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
199 >                                CurrentChunk->data = data_buffer;
200 >                                for(i=0;i<MyPCaloHitCollection.size();i++){            
201 >                                        memcpy( data_buffer, &MyPCaloHitCollection[i], sizeof(MyPCaloHit) );
202 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyPCaloHit));                                  
203 >                                }      
204                                  ParentChunk->daughters.push_back(CurrentChunk);
205                          }
206 <                        for(i=0;i<MySimVertexCollection.size();i++){            
206 >
207 >                        if(MySimVertexCollection.size()>0){
208                                  CurrentChunk       = new stChunkToSave;
209                                  CurrentChunk->type = C_SIM_VERTEX;
210 <                                CurrentChunk->size = 6+sizeof(MySimVertex);
211 <                                CurrentChunk->data = (char*)&MySimVertexCollection[i];
210 >                                CurrentChunk->size = 6 + sizeof(MySimVertex)*MySimVertexCollection.size();
211 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
212 >                                CurrentChunk->data = data_buffer;
213 >                                for(i=0;i<MySimVertexCollection.size();i++){            
214 >                                        memcpy( data_buffer, &MySimVertexCollection[i], sizeof(MySimVertex) );
215 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MySimVertex));                                
216 >                                }      
217                                  ParentChunk->daughters.push_back(CurrentChunk);
218                          }
219 <                        for(i=0;i<MySimTrackCollection.size();i++){                                            
219 >
220 >                        if(MySimTrackCollection.size()>0){
221                                  CurrentChunk       = new stChunkToSave;
222                                  CurrentChunk->type = C_SIM_TRACK;
223 <                                CurrentChunk->size = 6+sizeof(MySimTrack);
224 <                                CurrentChunk->data = (char*)&MySimTrackCollection[i];
223 >                                CurrentChunk->size = 6 + sizeof(MySimTrack)*MySimTrackCollection.size();
224 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
225 >                                CurrentChunk->data = data_buffer;
226 >                                for(i=0;i<MySimTrackCollection.size();i++){            
227 >                                        memcpy( data_buffer, &MySimTrackCollection[i], sizeof(MySimTrack) );
228 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MySimTrack));                                  
229 >                                }      
230                                  ParentChunk->daughters.push_back(CurrentChunk);
231 <                        }                              
231 >                        }              
232                          break;
233  
181 –
234                  case C_RECO:                // RecoData
235                          for(i=0;i<MyRecoTrackCollection.size();i++){            
236                                  CurrentChunk         = new stChunkToSave;
237                                  CurrentChunk->type   = C_RECO_TRACK;
238                                  CurrentChunk->size   = 6;
239 <                                CurrentChunk->buffer = &MyRecoTrackCollection[i];
239 >                                CurrentChunk->buffer = MyRecoTrackCollection[i];
240                                  ParentChunk->daughters.push_back(CurrentChunk);
241                          }      
242 +
243                          
244 <                        for(i=0;i<MyEcalCaloHitCollection.size();i++){  
245 <                                CurrentChunk         = new stChunkToSave;
246 <                                CurrentChunk->type   = C_RECO_ECALHIT;
247 <                                CurrentChunk->size   = 6+sizeof(MyCaloHit);
248 <                                CurrentChunk->data   = &MyEcalCaloHitCollection[i];
244 >                        if(MyEcalCaloHitCollection.size()>0){
245 >                                CurrentChunk       = new stChunkToSave;
246 >                                CurrentChunk->type = C_RECO_ECALHIT;
247 >                                CurrentChunk->size = 6 + sizeof(MyCaloHit)*MyEcalCaloHitCollection.size();
248 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
249 >                                CurrentChunk->data = data_buffer;
250 >                                for(i=0;i<MyEcalCaloHitCollection.size();i++){          
251 >                                        memcpy( data_buffer, MyEcalCaloHitCollection[i], sizeof(MyCaloHit) );
252 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyCaloHit));                                  
253 >                                }      
254                                  ParentChunk->daughters.push_back(CurrentChunk);
255 <                        }                                              
255 >                        }
256  
257 <                        for(i=0;i<MyHcalCaloHitCollection.size();i++){  
258 <                                CurrentChunk         = new stChunkToSave;
259 <                                CurrentChunk->type   = C_RECO_HCALHIT;
260 <                                CurrentChunk->size   = 6+sizeof(MyCaloHit);
261 <                                CurrentChunk->data   = &MyHcalCaloHitCollection[i];
257 >                        if(MyHcalCaloHitCollection.size()>0){
258 >                                CurrentChunk       = new stChunkToSave;
259 >                                CurrentChunk->type = C_RECO_HCALHIT;
260 >                                CurrentChunk->size = 6 + sizeof(MyCaloHit)*MyHcalCaloHitCollection.size();
261 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
262 >                                CurrentChunk->data = data_buffer;
263 >                                for(i=0;i<MyHcalCaloHitCollection.size();i++){          
264 >                                        memcpy( data_buffer, MyHcalCaloHitCollection[i], sizeof(MyCaloHit) );
265 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyCaloHit));                                  
266 >                                }      
267                                  ParentChunk->daughters.push_back(CurrentChunk);
268 <                        }                      
268 >                        }
269 >
270 >                        if(MyMuonSegmentCollection.size()>0){
271 >                                CurrentChunk       = new stChunkToSave;
272 >                                CurrentChunk->type = C_RECO_MUONSEG;
273 >                                CurrentChunk->size = 6 + sizeof(MyMuonSegment)*MyMuonSegmentCollection.size();
274 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
275 >                                CurrentChunk->data = data_buffer;
276 >                                for(i=0;i<MyMuonSegmentCollection.size();i++){          
277 >                                        memcpy( data_buffer, MyMuonSegmentCollection[i], sizeof(MyMuonSegment) );
278 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyMuonSegment));                                      
279 >                                }      
280 >                                ParentChunk->daughters.push_back(CurrentChunk);
281 >                        }
282 >
283 >                        if(MyMuonHitCollection.size()>0){
284 >                                CurrentChunk       = new stChunkToSave;
285 >                                CurrentChunk->type = C_RECO_MUONSEG;
286 >                                CurrentChunk->size = 6 + sizeof(MyMuonHit)*MyMuonHitCollection.size();
287 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
288 >                                CurrentChunk->data = data_buffer;
289 >                                for(i=0;i<MyMuonHitCollection.size();i++){              
290 >                                        memcpy( data_buffer, MyMuonHitCollection[i], sizeof(MyMuonHit) );
291 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyMuonHit));                                  
292 >                                }      
293 >                                ParentChunk->daughters.push_back(CurrentChunk);
294 >                        }                                      
295                          break;
296  
297  
298 <                case C_RECO_TRACK:     // RecoTrack                    
299 <                        for(i=0;i<((MyRecoTrack*)ParentChunk->buffer)->Hits.size();i++){                                                
298 >                case C_RECO_TRACK:     // RecoTrack    
299 >                        if(((MyRecoTrack*)ParentChunk->buffer)->Hits.size()>0){
300                                  CurrentChunk       = new stChunkToSave;
301                                  CurrentChunk->type = C_RECO_TRACKHIT;
302 <                                CurrentChunk->size = 6+sizeof(MyRecoHit);
303 <                                CurrentChunk->data = (char*)&((MyRecoTrack*)ParentChunk->buffer)->Hits[i];
302 >                                CurrentChunk->size = 6 + sizeof(MyRecoHit)*((MyRecoTrack*)ParentChunk->buffer)->Hits.size();
303 >                                data_buffer        = new void*[CurrentChunk->size-6];                                          
304 >                                CurrentChunk->data = data_buffer;
305 >                                for(i=0;i<((MyRecoTrack*)ParentChunk->buffer)->Hits.size();i++){                
306 >                                        memcpy( data_buffer, ((MyRecoTrack*)ParentChunk->buffer)->Hits[i], sizeof(MyRecoHit) );
307 >                                        data_buffer = (void*)((unsigned int)data_buffer + sizeof(MyRecoHit));                                  
308 >                                }      
309                                  ParentChunk->daughters.push_back(CurrentChunk);
310 <                        }                                      
310 >                        }              
311                          break;
312  
313                  default:
314                          break;
315          }      
316  
317 <
317 >        
318          for(unsigned int i=0; i<ParentChunk->daughters.size();i++)
319          {
320                  if( !(ParentChunk->type == C_PRIMARY && i!=ParentChunk->daughters.size()-1))
# Line 304 | Line 398 | MySimEvents::~MySimEvents()
398  
399   }
400  
401 < void MySimEvents::Load(char* path)
401 > void MySimEvents::Load(const char* path)
402   {
403          FILE* f = fopen(path,"rb" );    
404          if(f==NULL){
# Line 392 | Line 486 | void MySimEvents::Load(char* path)
486   }
487  
488  
489 < void MySimEvents::Save(char* path)
489 > void MySimEvents::Save(const char* path)
490   {
491          stChunkToSave* Primary_chunk = new stChunkToSave;
492          
493          Primary_chunk->type  = C_PRIMARY;      
494          Primary_chunk->size =  6;
495 <
495 >        
496          for(unsigned int i=0;i<Events.size();i++){              
497                  Events[i]->SaveEvent(Primary_chunk);
498          }
# Line 406 | Line 500 | void MySimEvents::Save(char* path)
500          Primary_chunk->size =  6;
501          for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
502                  Primary_chunk->size += Primary_chunk->daughters[i]->size;
503 <        }
503 >        }      
504   /*
505          printf("%i (%i)\n",Primary_chunk->type,Primary_chunk->size);
506          for(unsigned int i=0;i<Primary_chunk->daughters.size();i++){
# Line 427 | Line 521 | void MySimEvents::Save(char* path)
521          }
522   */
523  
524 <        FILE* pFile = fopen(path,"wb" );
524 >        FILE* pFile = fopen(path,"wb" );        
525                  WriteChunk(pFile, Primary_chunk);
526 <        fclose(pFile);
526 >        fclose(pFile);  
527   }
528  
529  

Diff Legend

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