BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
BesAsciiIO.cc
Go to the documentation of this file.
1//---------------------------------------------------------------------------//
2//// BOOST --- BESIII Object_Oriented Simulation Tool //
3////---------------------------------------------------------------------------//
4////Description:
5////Author: Dengzy
6////Created: Mar, 2004
7////Modified:
8////Comment:
9//
10#include "BesEventAction.hh"
11#include "EmcSim/BesEmcDigi.hh"
12#include "EmcSim/BesEmcHit.hh"
13#include "G4HCofThisEvent.hh"
14#include "G4PrimaryParticle.hh"
15#include "G4PrimaryVertex.hh"
16#include "G4RunManager.hh"
17#include "G4SDManager.hh"
18#include "MdcSim/BesMdcDigi.hh"
19#include "MdcSim/BesMdcHit.hh"
20#include "MucSim/BesMucDigi.hh"
21#include "MucSim/BesMucHit.hh"
22#include "TofSim/BesTofDigi.hh"
23#include "TofSim/BesTofHit.hh"
24#include "TruSim/BesSensitiveManager.hh"
25#include "TruSim/BesTruthTrack.hh"
26#include "TruSim/BesTruthVertex.hh"
27
28#include "AsciiDmp/dmplib.hh"
29#include "BesAsciiIO.hh"
30#include "G4DigiManager.hh"
31#include <iostream>
32using namespace std;
33
34#include "GaudiKernel/Bootstrap.h"
35#include "GaudiKernel/IDataProviderSvc.h"
36#include "GaudiKernel/ISvcLocator.h"
37#include "GaudiKernel/MsgStream.h"
38#include "GaudiKernel/RegistryEntry.h"
39#include "GaudiKernel/SmartDataPtr.h"
40#include "McTruth/DecayMode.h"
41
42BesAsciiIO::BesAsciiIO( G4int mdcTruFlag, G4int mdcDigiFlag, G4int tofTruFlag,
43 G4int tofDigiFlag, G4int emcTruFlag, G4int emcDigiFlag,
44 G4int mucTruFlag, G4int mucDigiFlag, G4String name )
45 : m_mdcTruFlag( mdcTruFlag )
46 , m_mdcDigiFlag( mdcDigiFlag )
47 , m_tofTruFlag( tofTruFlag )
48 , m_tofDigiFlag( tofDigiFlag )
49 , m_emcTruFlag( emcTruFlag )
50 , m_emcDigiFlag( emcDigiFlag )
51 , m_mucTruFlag( mucTruFlag )
52 , m_mucDigiFlag( mucDigiFlag )
53 , m_asciiFile( name ) {
54 m_DigiMan = G4DigiManager::GetDMpointer();
55}
56
57BesAsciiIO::~BesAsciiIO() {}
58
59void BesAsciiIO::SaveAsciiEvents( G4int runId, const G4Event* evt ) {
60 EVENT asciiEvt;
61
62 asciiEvt.set_initialized();
63 asciiEvt.header.set_initialized();
64 asciiEvt.header.eventNo = evt->GetEventID();
65 asciiEvt.header.runNo = runId;
66 asciiEvt.decayMode.set_initialized();
67 SaveDecayMode( asciiEvt );
68
69 asciiEvt.trackTruth.set_initialized();
70 asciiEvt.vertexTruth.set_initialized();
71 SaveTrackTruth( asciiEvt );
72 SaveVertexTruth( asciiEvt );
73
74 if ( m_mdcTruFlag )
75 {
76 asciiEvt.mdcTruth.set_initialized();
77 SaveMdcTruth( asciiEvt );
78 }
79
80 if ( m_mdcDigiFlag )
81 {
82 asciiEvt.mdcDigi.set_initialized();
83 SaveMdcDigits( asciiEvt );
84 }
85
86 if ( m_tofTruFlag )
87 {
88 asciiEvt.tofTruth.set_initialized();
89 SaveTofTruth( asciiEvt );
90 }
91
92 if ( m_tofDigiFlag )
93 {
94 asciiEvt.tofDigi.set_initialized();
95 SaveTofDigits( asciiEvt );
96 }
97
98 if ( m_emcTruFlag )
99 {
100 asciiEvt.emcTruth.set_initialized();
101 SaveEmcTruth( asciiEvt );
102 }
103
104 if ( m_emcDigiFlag )
105 {
106 asciiEvt.emcDigi.set_initialized();
107 SaveEmcDigits( asciiEvt );
108 }
109
110 if ( m_mucTruFlag )
111 {
112 asciiEvt.mucTruth.set_initialized();
113 SaveMucTruth( asciiEvt );
114 }
115
116 if ( m_mucDigiFlag )
117 {
118 asciiEvt.mucDigi.set_initialized();
119 SaveMucDigits( asciiEvt );
120 }
121
122 ofstream os;
123 if ( evt->GetEventID() == 0 )
124 {
125 os.open( m_asciiFile );
126 FRMTVERSION version;
127 version.set_initialized();
128 version.major = 1;
129 version.minor = 0;
130 os << version;
131 }
132 else os.open( m_asciiFile, ios::out | ios::app );
133
134 try
135 { os << asciiEvt; } catch ( AsciiWrongTag& ex )
136 {
137 std::cerr << "wrong tag, got " << ex.got() << " expected: " << ex.expected() << std::endl;
138 } catch ( AsciiDumpException& )
139 { std::cerr << "AsciiDumpException was caught!" << std::endl; }
140 os.close();
141}
142
143void BesAsciiIO::SaveDecayMode( EVENT& asciiEvt ) {
144 asciiEvt.decayMode.size = 10;
145 // interface to event data service
146 ISvcLocator* svcLocator = Gaudi::svcLocator();
147 IDataProviderSvc* evtSvc;
148 StatusCode sc = svcLocator->service( "EventDataSvc", evtSvc );
149 if ( sc.isFailure() ) G4cout << "Could not accesss EventDataSvc!" << G4endl;
150
151 SmartDataPtr<DecayMode> decayMode( evtSvc, "/Event/MC/DecayMode" );
152 if ( !decayMode )
153 {
154 for ( int i = 0; i < 10; i++ ) asciiEvt.decayMode.data[i] = 0;
155 }
156 else
157 {
158 int dm[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
159 decayMode->getData( dm, 10 );
160 for ( int i = 0; i < 10; i++ ) asciiEvt.decayMode.data[i] = dm[i];
161 }
162}
163
164void BesAsciiIO::SaveTrackTruth( EVENT& asciiEvt ) {
165
166 BesSensitiveManager* sensitiveManager = BesSensitiveManager::GetSensitiveManager();
167
168 vector<BesTruthTrack*>* trackList = sensitiveManager->GetTrackList();
169
170 // arrange TruthTrack in trackList in order of trackIndex
171 G4int nTrack = trackList->size();
172 BesTruthTrack* track;
173 for ( int i = 0; i < nTrack - 1; i++ )
174 for ( int j = i + 1; j < nTrack; j++ )
175 if ( ( *trackList )[i]->GetIndex() > ( *trackList )[j]->GetIndex() )
176 {
177 track = ( *trackList )[i];
178 ( *trackList )[i] = ( *trackList )[j];
179 ( *trackList )[j] = track;
180 }
181
182 for ( int i = 0; i < nTrack; i++ )
183 {
184 TrackTruthType trackTruth;
185 track = ( *( sensitiveManager->GetTrackList() ) )[i];
186 trackTruth.trackIndex = track->GetIndex();
187 if ( track->GetIndex() < 0 ) G4cout << "trackIndex<0!" << G4endl;
188 trackTruth.PDGCode = track->GetPDGCode();
189 trackTruth.PDGCharge = track->GetPDGCharge();
190 trackTruth.v0Index = track->GetVertex()->GetIndex();
191 if ( track->GetTerminalVertex() )
192 trackTruth.v1Index = track->GetTerminalVertex()->GetIndex();
193 else trackTruth.v1Index = -99;
194 trackTruth.px = track->GetP4().x() / 1000.;
195 trackTruth.py = track->GetP4().y() / 1000.;
196 trackTruth.pz = track->GetP4().z() / 1000.;
197 trackTruth.E = track->GetP4().t() / 1000.;
198
199 G4int size = track->GetDaughterIndexes().size();
200 if ( size > 0 )
201 {
202 trackTruth.minDaughterIndex = ( track->GetDaughterIndexes() )[0];
203 trackTruth.maxDaughterIndex = ( track->GetDaughterIndexes() )[size - 1];
204 }
205 else
206 {
207 trackTruth.minDaughterIndex = -99;
208 trackTruth.maxDaughterIndex = -99;
209 }
210
211 asciiEvt.trackTruth.truthCol.push_back( trackTruth );
212 }
213
214 asciiEvt.trackTruth.nTruth = asciiEvt.trackTruth.truthCol.size();
215}
216
217void BesAsciiIO::SaveVertexTruth( EVENT& asciiEvt ) {
218 BesSensitiveManager* sensitiveManager = BesSensitiveManager::GetSensitiveManager();
219
220 vector<BesTruthVertex*>* vertexList = sensitiveManager->GetVertexList();
221
222 G4int nVertex = vertexList->size();
223 BesTruthVertex* vertex;
224 for ( int i = 0; i < nVertex; i++ )
225 {
226 VertexTruthType vertexTruth;
227 vertex = ( *vertexList )[i];
228 vertexTruth.vertexIndex = vertex->GetIndex();
229 if ( vertex->GetParentTrack() )
230 vertexTruth.parentTrackIndex = vertex->GetParentTrack()->GetIndex();
231 else vertexTruth.parentTrackIndex = -99;
232
233 vertexTruth.posX = vertex->GetPosition().x() / 10.;
234 vertexTruth.posY = vertex->GetPosition().y() / 10.;
235 vertexTruth.posZ = vertex->GetPosition().z() / 10.;
236 vertexTruth.time = vertex->GetTime();
237 asciiEvt.vertexTruth.truthCol.push_back( vertexTruth );
238 }
239 asciiEvt.vertexTruth.nTruth = asciiEvt.vertexTruth.truthCol.size();
240}
241
242void BesAsciiIO::SaveMdcTruth( EVENT& asciiEvt ) {
243 G4int HCID = -1;
244 HCID = m_DigiMan->GetHitsCollectionID( "BesMdcTruthCollection" );
245 if ( HCID > 0 )
246 {
247 BesMdcHitsCollection* HC = 0;
248 HC = (BesMdcHitsCollection*)( m_DigiMan->GetHitsCollection( HCID ) );
249 G4int n_hit = HC->entries();
250 if ( n_hit > 0 )
251 {
252 // arrange hits in hits collection in order of trackIndex
253 BesMdcHit* hit;
254 vector<BesMdcHit*>* vecHC = HC->GetVector();
255 for ( int i = 0; i < n_hit - 1; i++ )
256 for ( int j = i + 1; j < n_hit; j++ )
257 if ( ( *vecHC )[i]->GetTrackID() > ( *vecHC )[j]->GetTrackID() )
258 {
259 hit = ( *vecHC )[i];
260 ( *vecHC )[i] = ( *vecHC )[j];
261 ( *vecHC )[j] = hit;
262 }
263
264 for ( G4int i = 0; i < n_hit; i++ )
265 {
266 hit = ( *HC )[i];
267 MdcTruthType mdcTruth;
268 mdcTruth.trackIndex = hit->GetTrackID();
269 mdcTruth.layerNo = hit->GetLayerNo();
270 mdcTruth.cellNo = hit->GetCellNo();
271 mdcTruth.edep = hit->GetEdep();
272 mdcTruth.driftD = hit->GetDriftD();
273 mdcTruth.posX = hit->GetPos().x();
274 mdcTruth.posY = hit->GetPos().y();
275 mdcTruth.posZ = hit->GetPos().z();
276 mdcTruth.posFlag = hit->GetPosFlag();
277
278 asciiEvt.mdcTruth.truthCol.push_back( mdcTruth );
279 }
280 }
281 }
282 asciiEvt.mdcTruth.nTruth = asciiEvt.mdcTruth.truthCol.size();
283}
284
285void BesAsciiIO::SaveTofTruth( EVENT& asciiEvt ) {
286 G4int HCID = -1;
287 HCID = m_DigiMan->GetHitsCollectionID( "BesTofHitsList" );
288 if ( HCID > 0 )
289 {
290 BesTofHitsCollection* HC = 0;
291 HC = (BesTofHitsCollection*)( m_DigiMan->GetHitsCollection( HCID ) );
292 G4int n_hit = HC->entries();
293 if ( n_hit > 0 )
294 {
295 // arrange hits in hits collection in order of trackIndex
296 BesTofHit* hit;
297 vector<BesTofHit*>* vecHC = HC->GetVector();
298 for ( int i = 0; i < n_hit - 1; i++ )
299 for ( int j = i + 1; j < n_hit; j++ )
300 if ( ( *vecHC )[i]->GetTrackIndex() > ( *vecHC )[j]->GetTrackIndex() )
301 {
302 hit = ( *vecHC )[i];
303 ( *vecHC )[i] = ( *vecHC )[j];
304 ( *vecHC )[j] = hit;
305 }
306
307 for ( G4int i = 0; i < n_hit; i++ )
308 {
309 hit = ( *HC )[i];
310 TofTruthType tofTruth;
311 tofTruth.trackIndex = hit->GetTrackIndex();
312 tofTruth.partId = hit->GetPartId();
313 tofTruth.scinNb = hit->GetScinNb();
314 tofTruth.posX = hit->GetPos().x();
315 tofTruth.posY = hit->GetPos().y();
316 tofTruth.posZ = hit->GetPos().z();
317 tofTruth.px = hit->GetMomentum().x();
318 tofTruth.py = hit->GetMomentum().y();
319 tofTruth.pz = hit->GetMomentum().z();
320 tofTruth.trackL = hit->GetTrackL();
321 tofTruth.time = hit->GetTime();
322
323 asciiEvt.tofTruth.truthCol.push_back( tofTruth );
324 }
325 }
326 }
327 asciiEvt.tofTruth.nTruth = asciiEvt.tofTruth.truthCol.size();
328}
329
330void BesAsciiIO::SaveEmcTruth( EVENT& asciiEvt ) {
331 G4int HCID = -1;
332 HCID = m_DigiMan->GetHitsCollectionID( "BesEmcHitsList" );
333 if ( HCID > 0 )
334 {
335 BesEmcHitsCollection* HC = 0;
336 HC = (BesEmcHitsCollection*)( m_DigiMan->GetHitsCollection( HCID ) );
337 G4int n_hit = HC->entries();
338 if ( n_hit > 0 )
339 {
340 // arrange hits in hits collection in order of trackIndex
341 BesEmcHit* hit;
342 vector<BesEmcHit*>* vecHC = HC->GetVector();
343 for ( int i = 0; i < n_hit - 1; i++ )
344 for ( int j = i + 1; j < n_hit; j++ )
345 if ( ( *vecHC )[i]->GetTrackIndex() > ( *vecHC )[j]->GetTrackIndex() )
346 {
347 hit = ( *vecHC )[i];
348 ( *vecHC )[i] = ( *vecHC )[j];
349 ( *vecHC )[j] = hit;
350 }
351
352 for ( G4int i = 0; i < n_hit; i++ )
353 {
354 hit = ( *HC )[i];
355 EmcTruthType emcTruth;
356 emcTruth.trackIndex = hit->GetTrackIndex();
357 emcTruth.partId = hit->GetPartId();
358 emcTruth.numTheta = hit->GetNumThetaCrystal();
359 emcTruth.numPhi = hit->GetNumPhiCrystal();
360 emcTruth.posX = hit->GetPosCrystal().x();
361 emcTruth.posY = hit->GetPosCrystal().y();
362 emcTruth.posZ = hit->GetPosCrystal().z();
363 emcTruth.px = hit->GetMomentum().x();
364 emcTruth.py = hit->GetMomentum().y();
365 emcTruth.pz = hit->GetMomentum().z();
366 emcTruth.totalEdep = hit->GetEdepCrystal();
367
368 asciiEvt.emcTruth.truthCol.push_back( emcTruth );
369 }
370 }
371 }
372 asciiEvt.emcTruth.nTruth = asciiEvt.emcTruth.truthCol.size();
373}
374
375void BesAsciiIO::SaveMucTruth( EVENT& asciiEvt ) {
376 G4int HCID = -1;
377 HCID = m_DigiMan->GetHitsCollectionID( "BesMucHitsList" );
378 if ( HCID > 0 )
379 {
380 BesMucHitsCollection* HC = 0;
381 HC = (BesMucHitsCollection*)( m_DigiMan->GetHitsCollection( HCID ) );
382 G4int n_hit = HC->entries();
383 if ( n_hit > 0 )
384 {
385 // arrange hits in hits collection in order of trackIndex
386 BesMucHit* hit;
387 vector<BesMucHit*>* vecHC = HC->GetVector();
388 for ( int i = 0; i < n_hit - 1; i++ )
389 for ( int j = i + 1; j < n_hit; j++ )
390 if ( ( *vecHC )[i]->GetTrackIndex() > ( *vecHC )[j]->GetTrackIndex() )
391 {
392 hit = ( *vecHC )[i];
393 ( *vecHC )[i] = ( *vecHC )[j];
394 ( *vecHC )[j] = hit;
395 }
396
397 for ( G4int i = 0; i < n_hit; i++ )
398 {
399 hit = ( *HC )[i];
400 MucTruthType mucTruth;
401 mucTruth.trackIndex = hit->GetTrackIndex();
402 mucTruth.partId = hit->GetPart();
403 mucTruth.segId = hit->GetSeg();
404 mucTruth.gapId = hit->GetGap();
405 mucTruth.stripId = hit->GetStrip();
406 mucTruth.posX = hit->GetPos().x();
407 mucTruth.posY = hit->GetPos().y();
408 mucTruth.posZ = hit->GetPos().z();
409 mucTruth.px = hit->GetMomentum().x();
410 mucTruth.py = hit->GetMomentum().y();
411 mucTruth.pz = hit->GetMomentum().z();
412 asciiEvt.mucTruth.truthCol.push_back( mucTruth );
413 }
414 }
415 }
416 asciiEvt.mucTruth.nTruth = asciiEvt.mucTruth.truthCol.size();
417}
418
419void BesAsciiIO::SaveMdcDigits( EVENT& asciiEvt ) {
420 G4int mdcDigiCollID = -1;
421 mdcDigiCollID = m_DigiMan->GetDigiCollectionID( "BesMdcDigisCollection" );
422 if ( mdcDigiCollID >= 0 )
423 {
424 BesMdcDigisCollection* mdcDC =
425 (BesMdcDigisCollection*)m_DigiMan->GetDigiCollection( mdcDigiCollID );
426 G4int nDigi = mdcDC->entries();
427 if ( nDigi > 0 )
428 {
429 BesMdcDigi* mdcDigi;
430 for ( int i = 0; i < nDigi; i++ )
431 {
432 MdcDigiType mdcData;
433 mdcDigi = ( *mdcDC )[i];
434 mdcData.trackIndex = mdcDigi->GetTrackID();
435 mdcData.layerNo = mdcDigi->GetLayerNo();
436 mdcData.cellNo = mdcDigi->GetCellNo();
437 mdcData.energyDeposit = mdcDigi->GetEdep();
438 mdcData.driftTime = mdcDigi->GetDriftT();
439 asciiEvt.mdcDigi.digiCol.push_back( mdcData );
440 }
441 }
442 }
443 asciiEvt.mdcDigi.nDigi = asciiEvt.mdcDigi.digiCol.size();
444}
445
446void BesAsciiIO::SaveTofDigits( EVENT& asciiEvt ) {
447
448 G4int tofDigiCollID = -1;
449 tofDigiCollID = m_DigiMan->GetDigiCollectionID( "BesTofDigitsCollection" );
450
451 if ( tofDigiCollID >= 0 )
452 {
453 BesTofDigitsCollection* tofDC =
454 (BesTofDigitsCollection*)m_DigiMan->GetDigiCollection( tofDigiCollID );
455 G4int nDigi = tofDC->entries();
456 if ( nDigi > 0 )
457 {
458 // arrange digis in digitsCollection in order of trackIndex
459 BesTofDigi* digi;
460 vector<BesTofDigi*>* vecDC = tofDC->GetVector();
461 for ( int i = 0; i < nDigi - 1; i++ )
462 for ( int j = i + 1; j < nDigi; j++ )
463 if ( ( *vecDC )[i]->GetTrackIndex() > ( *vecDC )[j]->GetTrackIndex() )
464 {
465 digi = ( *vecDC )[i];
466 ( *vecDC )[i] = ( *vecDC )[j];
467 ( *vecDC )[j] = digi;
468 }
469
470 for ( int i = 0; i < nDigi; i++ )
471 {
472 TofDigiType tofData;
473 digi = ( *tofDC )[i];
474 tofData.trackIndex = digi->GetTrackIndex();
475 tofData.partId = digi->GetPartId();
476 tofData.scinNb = digi->GetScinNb();
477 tofData.forwADC = digi->GetForwADC();
478 tofData.forwTDC = digi->GetForwTDC();
479 tofData.backADC = digi->GetBackADC();
480 tofData.backTDC = digi->GetBackTDC();
481
482 asciiEvt.tofDigi.digiCol.push_back( tofData );
483 }
484 }
485 }
486 asciiEvt.tofDigi.nDigi = asciiEvt.tofDigi.digiCol.size();
487}
488
489void BesAsciiIO::SaveEmcDigits( EVENT& asciiEvt ) {
490 G4int emcDigiCollID = -1;
491 emcDigiCollID = m_DigiMan->GetDigiCollectionID( "BesEmcDigitsCollection" );
492 if ( emcDigiCollID >= 0 )
493 {
494 BesEmcDigitsCollection* emcDC =
495 (BesEmcDigitsCollection*)m_DigiMan->GetDigiCollection( emcDigiCollID );
496 G4int nDigi = emcDC->entries();
497 if ( nDigi > 0 )
498 {
499 // arrange digis in digitsCollection in order of trackIndex
500 BesEmcDigi* digi;
501 vector<BesEmcDigi*>* vecDC = emcDC->GetVector();
502 for ( int i = 0; i < nDigi - 1; i++ )
503 for ( int j = i + 1; j < nDigi; j++ )
504 if ( ( *vecDC )[i]->GetTrackIndex() > ( *vecDC )[j]->GetTrackIndex() )
505 {
506 digi = ( *vecDC )[i];
507 ( *vecDC )[i] = ( *vecDC )[j];
508 ( *vecDC )[j] = digi;
509 }
510 for ( int i = 0; i < nDigi; i++ )
511 {
512 EmcDigiType emcData;
513 digi = ( *emcDC )[i];
514 emcData.trackIndex = digi->GetTrackIndex();
515 emcData.partId = digi->GetPartId();
516 emcData.numTheta = digi->GetThetaNb();
517 emcData.numPhi = digi->GetPhiNb();
518 emcData.energyDeposit = digi->GetEnergy();
519 emcData.hitTime = (G4double)digi->GetTime();
520 asciiEvt.emcDigi.digiCol.push_back( emcData );
521 }
522 }
523 }
524 asciiEvt.emcDigi.nDigi = asciiEvt.emcDigi.digiCol.size();
525}
526
527void BesAsciiIO::SaveMucDigits( EVENT& asciiEvt ) {
528 G4int mucDigiCollID = -1;
529 mucDigiCollID = m_DigiMan->GetDigiCollectionID( "BesMucDigisCollection" );
530 if ( mucDigiCollID >= 0 )
531 {
532 BesMucDigisCollection* mucDC =
533 (BesMucDigisCollection*)m_DigiMan->GetDigiCollection( mucDigiCollID );
534 G4int nDigi = mucDC->entries();
535 if ( nDigi > 0 )
536 {
537 BesMucDigi* mucDigi;
538 for ( int i = 0; i < nDigi; i++ )
539 {
540 MucDigiType mucData;
541 mucDigi = ( *mucDC )[i];
542 mucData.trackIndex = mucDigi->GetTrackIndex();
543 mucData.partNo = mucDigi->GetPartId();
544 mucData.segNo = mucDigi->GetSegId();
545 mucData.gapNo = mucDigi->GetGapId();
546 mucData.stripNo = mucDigi->GetStripId();
547
548 asciiEvt.mucDigi.digiCol.push_back( mucData );
549 }
550 }
551 }
552 asciiEvt.mucDigi.nDigi = asciiEvt.mucDigi.digiCol.size();
553}
554
555// Below used when output hits not digis
556void BesAsciiIO::SaveHitAsciiEvents( G4int runId, const G4Event* evt ) {
557 HitEVENT asciiEvt;
558
559 asciiEvt.set_initialized();
560 asciiEvt.header.set_initialized();
561 asciiEvt.header.eventNo = evt->GetEventID();
562 asciiEvt.header.runNo = runId;
563 asciiEvt.decayMode.set_initialized();
564 SaveDecayMode( asciiEvt );
565
566 asciiEvt.trackTruth.set_initialized();
567 asciiEvt.vertexTruth.set_initialized();
568 SaveTrackTruth( asciiEvt );
569 SaveVertexTruth( asciiEvt );
570
571 if ( m_mdcTruFlag )
572 {
573 asciiEvt.mdcTruth.set_initialized();
574 SaveMdcTruth( asciiEvt );
575 }
576
577 if ( m_mdcDigiFlag )
578 {
579 asciiEvt.mdcHit.set_initialized();
580 SaveMdcHits( asciiEvt );
581 }
582 /*
583 if(m_tofTruFlag)
584 {
585 asciiEvt.tofTruth.set_initialized();
586 SaveTofTruth(asciiEvt);
587 }
588
589 if(m_tofDigiFlag)
590 {
591 asciiEvt.tofHit.set_initialized();
592 SaveTofHits(asciiEvt);
593 }
594
595 if(m_emcTruFlag)
596 {
597 asciiEvt.emcTruth.set_initialized();
598 SaveEmcTruth(asciiEvt);
599 }
600
601 if(m_emcDigiFlag)
602 {
603 asciiEvt.emcHit.set_initialized();
604 SaveEmcHits(asciiEvt);
605 }
606
607 if(m_mucTruFlag)
608 {
609 asciiEvt.mucTruth.set_initialized();
610 SaveMucTruth(asciiEvt);
611 }
612
613 if(m_mucDigiFlag)
614 {
615 asciiEvt.mucHit.set_initialized();
616 SaveMucHits(asciiEvt);
617 }
618 */
619 ofstream os;
620 if ( evt->GetEventID() == 0 )
621 {
622 os.open( m_asciiFile );
623 FRMTVERSION version;
624 version.set_initialized();
625 version.major = 1;
626 version.minor = 0;
627 os << version;
628 }
629 else os.open( m_asciiFile, ios::out | ios::app );
630
631 try
632 { os << asciiEvt; } catch ( AsciiWrongTag& ex )
633 {
634 std::cerr << "wrong tag, got " << ex.got() << " expected: " << ex.expected() << std::endl;
635 } catch ( AsciiDumpException& )
636 { std::cerr << "AsciiDumpException was caught!" << std::endl; }
637
638 os.close();
639}
640
641void BesAsciiIO::SaveDecayMode( HitEVENT& asciiEvt ) {
642 asciiEvt.decayMode.size = 10;
643 // interface to event data service
644 ISvcLocator* svcLocator = Gaudi::svcLocator();
645 IDataProviderSvc* evtSvc;
646 StatusCode sc = svcLocator->service( "EventDataSvc", evtSvc );
647 if ( sc.isFailure() ) G4cout << "Could not accesss EventDataSvc!" << G4endl;
648
649 SmartDataPtr<DecayMode> decayMode( evtSvc, "/Event/MC/DecayMode" );
650 if ( !decayMode )
651 {
652 for ( int i = 0; i < 10; i++ ) asciiEvt.decayMode.data[i] = 0;
653 }
654 else
655 {
656 int dm[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
657 decayMode->getData( dm, 10 );
658 for ( int i = 0; i < 10; i++ ) asciiEvt.decayMode.data[i] = dm[i];
659 }
660}
661
662void BesAsciiIO::SaveTrackTruth( HitEVENT& asciiEvt ) {
663
664 BesSensitiveManager* sensitiveManager = BesSensitiveManager::GetSensitiveManager();
665
666 vector<BesTruthTrack*>* trackList = sensitiveManager->GetTrackList();
667
668 // arrange TruthTrack in trackList in order of trackIndex
669 G4int nTrack = trackList->size();
670 BesTruthTrack* track;
671 for ( int i = 0; i < nTrack - 1; i++ )
672 for ( int j = i + 1; j < nTrack; j++ )
673 if ( ( *trackList )[i]->GetIndex() > ( *trackList )[j]->GetIndex() )
674 {
675 track = ( *trackList )[i];
676 ( *trackList )[i] = ( *trackList )[j];
677 ( *trackList )[j] = track;
678 }
679
680 for ( int i = 0; i < nTrack; i++ )
681 {
682 TrackTruthType trackTruth;
683 track = ( *( sensitiveManager->GetTrackList() ) )[i];
684 trackTruth.trackIndex = track->GetIndex();
685 trackTruth.PDGCode = track->GetPDGCode();
686 trackTruth.PDGCharge = track->GetPDGCharge();
687 trackTruth.v0Index = track->GetVertex()->GetIndex();
688 if ( track->GetTerminalVertex() )
689 trackTruth.v1Index = track->GetTerminalVertex()->GetIndex();
690 else trackTruth.v1Index = -99;
691 trackTruth.px = track->GetP4().x();
692 trackTruth.py = track->GetP4().y();
693 trackTruth.pz = track->GetP4().z();
694 trackTruth.E = track->GetP4().t();
695
696 G4int size = track->GetDaughterIndexes().size();
697 if ( size > 0 )
698 {
699 trackTruth.minDaughterIndex = ( track->GetDaughterIndexes() )[0];
700 trackTruth.maxDaughterIndex = ( track->GetDaughterIndexes() )[size - 1];
701 }
702 else
703 {
704 trackTruth.minDaughterIndex = -99;
705 trackTruth.maxDaughterIndex = -99;
706 }
707
708 asciiEvt.trackTruth.truthCol.push_back( trackTruth );
709 }
710
711 asciiEvt.trackTruth.nTruth = asciiEvt.trackTruth.truthCol.size();
712}
713
714void BesAsciiIO::SaveVertexTruth( HitEVENT& asciiEvt ) {
715 BesSensitiveManager* sensitiveManager = BesSensitiveManager::GetSensitiveManager();
716
717 vector<BesTruthVertex*>* vertexList = sensitiveManager->GetVertexList();
718
719 G4int nVertex = vertexList->size();
720 BesTruthVertex* vertex;
721 for ( int i = 0; i < nVertex; i++ )
722 {
723 VertexTruthType vertexTruth;
724 vertex = ( *vertexList )[i];
725 vertexTruth.vertexIndex = vertex->GetIndex();
726 if ( vertex->GetParentTrack() )
727 vertexTruth.parentTrackIndex = vertex->GetParentTrack()->GetIndex();
728 else vertexTruth.parentTrackIndex = -99;
729
730 vertexTruth.posX = vertex->GetPosition().x();
731 vertexTruth.posY = vertex->GetPosition().y();
732 vertexTruth.posZ = vertex->GetPosition().z();
733 vertexTruth.time = vertex->GetTime();
734 asciiEvt.vertexTruth.truthCol.push_back( vertexTruth );
735 }
736 asciiEvt.vertexTruth.nTruth = asciiEvt.vertexTruth.truthCol.size();
737}
738
739void BesAsciiIO::SaveMdcTruth( HitEVENT& asciiEvt ) {
740 G4int HCID = -1;
741 HCID = m_DigiMan->GetHitsCollectionID( "BesMdcTruthCollection" );
742 if ( HCID > 0 )
743 {
744 BesMdcHitsCollection* HC = 0;
745 HC = (BesMdcHitsCollection*)( m_DigiMan->GetHitsCollection( HCID ) );
746 G4int n_hit = HC->entries();
747 if ( n_hit > 0 )
748 {
749 // arrange hits in hits collection in order of trackIndex
750 BesMdcHit* hit;
751 vector<BesMdcHit*>* vecHC = HC->GetVector();
752 for ( int i = 0; i < n_hit - 1; i++ )
753 for ( int j = i + 1; j < n_hit; j++ )
754 if ( ( *vecHC )[i]->GetTrackID() > ( *vecHC )[j]->GetTrackID() )
755 {
756 hit = ( *vecHC )[i];
757 ( *vecHC )[i] = ( *vecHC )[j];
758 ( *vecHC )[j] = hit;
759 }
760
761 for ( G4int i = 0; i < n_hit; i++ )
762 {
763 hit = ( *HC )[i];
764 MdcTruthType mdcTruth;
765 mdcTruth.trackIndex = hit->GetTrackID();
766 mdcTruth.layerNo = hit->GetLayerNo();
767 mdcTruth.cellNo = hit->GetCellNo();
768 mdcTruth.edep = hit->GetEdep();
769 mdcTruth.driftD = hit->GetDriftD();
770 mdcTruth.posX = hit->GetPos().x();
771 mdcTruth.posY = hit->GetPos().y();
772 mdcTruth.posZ = hit->GetPos().z();
773 mdcTruth.posFlag = hit->GetPosFlag();
774
775 asciiEvt.mdcTruth.truthCol.push_back( mdcTruth );
776 }
777 }
778 }
779 asciiEvt.mdcTruth.nTruth = asciiEvt.mdcTruth.truthCol.size();
780}
781
782void BesAsciiIO::SaveMdcHits( HitEVENT& asciiEvt ) {
783 G4int mdcHitCollID = -1;
784 mdcHitCollID = m_DigiMan->GetHitsCollectionID( "BesMdcHitsCollection" );
785 if ( mdcHitCollID >= 0 )
786 {
787 BesMdcHitsCollection* mdcDC =
788 (BesMdcHitsCollection*)m_DigiMan->GetHitsCollection( mdcHitCollID );
789 G4int nHit = mdcDC->entries();
790 if ( nHit > 0 )
791 {
792 BesMdcHit* mdcHit;
793 for ( int i = 0; i < nHit; i++ )
794 {
795 MdcHitType mdcData;
796 mdcHit = ( *mdcDC )[i];
797 mdcData.trackIndex = mdcHit->GetTrackID();
798 mdcData.layerNo = mdcHit->GetLayerNo();
799 mdcData.cellNo = mdcHit->GetCellNo();
800 mdcData.posX = mdcHit->GetPos().x();
801 mdcData.posY = mdcHit->GetPos().y();
802 mdcData.posZ = mdcHit->GetPos().z();
803 mdcData.energyDeposit = mdcHit->GetEdep();
804 mdcData.driftDistance = mdcHit->GetDriftD();
805 mdcData.globalT = mdcHit->GetGlobalT();
806 mdcData.theta = mdcHit->GetTheta();
807 mdcData.enterAngle = mdcHit->GetEnterAngle();
808 mdcData.posFlag = mdcHit->GetPosFlag();
809
810 asciiEvt.mdcHit.hitCol.push_back( mdcData );
811 }
812 }
813 }
814 asciiEvt.mdcHit.nHit = asciiEvt.mdcHit.hitCol.size();
815}
BesEmcDigitsCollection
G4TDigiCollection< BesEmcDigi > BesEmcDigitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/EmcSim/BesEmcDigi.hh:68
BesEmcHitsCollection
G4THitsCollection< BesEmcHit > BesEmcHitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/EmcSim/BesEmcHit.hh:86
BesMdcDigisCollection
G4TDigiCollection< BesMdcDigi > BesMdcDigisCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcSim/BesMdcDigi.hh:55
BesMdcHitsCollection
G4THitsCollection< BesMdcHit > BesMdcHitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcSim/BesMdcHit.hh:76
BesMucDigisCollection
G4TDigiCollection< BesMucDigi > BesMucDigisCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MucSim/BesMucDigi.hh:55
BesMucHitsCollection
G4THitsCollection< BesMucHit > BesMucHitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MucSim/BesMucHit.hh:100
BesTofDigitsCollection
G4TDigiCollection< BesTofDigi > BesTofDigitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TofSim/BesTofDigi.hh:78
BesTofHitsCollection
G4THitsCollection< BesTofHit > BesTofHitsCollection
Definition InstallArea/x86_64-el9-gcc13-dbg/include/TofSim/BesTofHit.hh:113
BesAsciiIO::SaveMdcHits
void SaveMdcHits(HitEVENT &)
Definition BesAsciiIO.cc:782
BesAsciiIO::SaveMucDigits
void SaveMucDigits(EVENT &)
Definition BesAsciiIO.cc:527
BesAsciiIO::SaveTrackTruth
void SaveTrackTruth(EVENT &)
Definition BesAsciiIO.cc:164
BesAsciiIO::SaveDecayMode
void SaveDecayMode(EVENT &)
Definition BesAsciiIO.cc:143
BesAsciiIO::BesAsciiIO
BesAsciiIO(G4int, G4int, G4int, G4int, G4int, G4int, G4int, G4int, G4String)
Definition BesAsciiIO.cc:42
BesAsciiIO::SaveMdcDigits
void SaveMdcDigits(EVENT &)
Definition BesAsciiIO.cc:419
BesAsciiIO::SaveMucTruth
void SaveMucTruth(EVENT &)
Definition BesAsciiIO.cc:375
BesAsciiIO::SaveEmcDigits
void SaveEmcDigits(EVENT &)
Definition BesAsciiIO.cc:489
BesAsciiIO::SaveEmcTruth
void SaveEmcTruth(EVENT &)
Definition BesAsciiIO.cc:330
BesAsciiIO::SaveTofTruth
void SaveTofTruth(EVENT &)
Definition BesAsciiIO.cc:285
BesAsciiIO::SaveHitAsciiEvents
void SaveHitAsciiEvents(G4int, const G4Event *)
Definition BesAsciiIO.cc:556
BesAsciiIO::SaveMdcTruth
void SaveMdcTruth(EVENT &)
Definition BesAsciiIO.cc:242
BesAsciiIO::SaveTofDigits
void SaveTofDigits(EVENT &)
Definition BesAsciiIO.cc:446
BesAsciiIO::SaveVertexTruth
void SaveVertexTruth(EVENT &)
Definition BesAsciiIO.cc:217
BesAsciiIO::SaveAsciiEvents
void SaveAsciiEvents(G4int, const G4Event *)
Definition BesAsciiIO.cc:59
EMCDIGI::digiCol
std::vector< EmcDigiType > digiCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:346
EMCTRUTH::truthCol
std::vector< EmcTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:184
MDCDIGI::digiCol
std::vector< MdcDigiType > digiCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:240
MDCHIT::hitCol
std::vector< MdcHitType > hitCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:272
MDCTRUTH::truthCol
std::vector< MdcTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:122
MUCDIGI::digiCol
std::vector< MucDigiType > digiCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:391
MUCTRUTH::truthCol
std::vector< MucTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:215
TOFDIGI::digiCol
std::vector< TofDigiType > digiCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:300
TOFTRUTH::truthCol
std::vector< TofTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:153
TRACKTRUTH::truthCol
std::vector< TrackTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:69
VERTEXTRUTH::truthCol
std::vector< VertexTruthType > truthCol
Definition Event/AsciiDmp/include/AsciiDmp/AsciiData.hh:93