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

Diff Legend

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