source: fact/tools/marsmacros/mc2csv/MonteCarlo.C@ 14726

Last change on this file since 14726 was 14726, checked in by Jens Buss, 12 years ago
deleted variable mpSamples hence it is unused
  • Property svn:executable set to *
File size: 26.6 KB
Line 
1#include "MonteCarlo.h"
2
3MonteCarlo::MonteCarlo()
4{
5 InitVariables();
6
7 return;
8}
9
10MonteCarlo::MonteCarlo(
11 TString filename
12 )
13{
14 InitVariables();
15
16 mFileName = filename;
17
18 OpenRootFile();
19 if ( !mRootFileOpend ) return;
20
21 LoadEventTree( "Events");
22 LoadHeaderTree( "RunHeaders");
23
24 ReadRunHeader();
25
26 return;
27}
28
29MonteCarlo::MonteCarlo(
30 TString filename,
31 TString evtsTreeName
32 )
33{
34 InitVariables();
35
36 mFileName = filename;
37
38 OpenRootFile();
39 if ( !mRootFileOpend ) return;
40
41 LoadEventTree( evtsTreeName);
42 LoadHeaderTree( "RunHeaders");
43
44 ReadRunHeader();
45
46 return;
47}
48
49MonteCarlo::MonteCarlo(
50 TString filename,
51 TString evtsTreeName,
52 TString headerTreeName
53 )
54{
55 InitVariables();
56
57 mFileName = filename;
58
59 OpenRootFile();
60 if ( !mRootFileOpend ) return;
61
62 LoadEventTree( evtsTreeName);
63 LoadHeaderTree( headerTreeName);
64
65 ReadRunHeader();
66
67 return;
68}
69
70MonteCarlo::~MonteCarlo(void)
71{
72 delete[] mpPixel;
73
74 CloseRootFile();
75
76 delete mpRootFile;
77
78 return;
79}
80
81void
82MonteCarlo::InitVariables()
83{
84 mFileName = "";
85 mSeparator = " ";
86
87 // source file
88 mpRootFile = NULL;
89 mRootFileOpend = false;
90
91 // Trees
92 mpEventTree = NULL;
93 mpHeaderTree = NULL;
94
95
96 //header data types
97 mpIntendedPulsePos = NULL;
98 mpMcRunHeader = NULL;
99 mpGeomCam = NULL;
100 mpRawRunHeader = NULL;
101 mpCorsikaRunHeader = NULL;
102
103 //Evt data types
104 mpElectronicNoise = NULL;
105 mpRawEventData = NULL;
106 mpIncidentAngle = NULL;
107 mpMcEventMetaData = NULL;
108 mpRawEventHeader = NULL;
109 mpCorsikaEvtHeader = NULL;
110 //
111
112 // containers
113 mpPixel = NULL;
114// mpSamples = NULL;
115 mEventNumber = 0;
116 mNumberOfEvents = 2;
117
118 mVerbosityLvl = 3;
119
120 return;
121}
122
123void
124MonteCarlo::SetVerbosityLevel(int verbLvl)
125{
126 mVerbosityLvl = verbLvl;
127
128 return;
129}
130
131int
132MonteCarlo::GetVerbosityLevel()
133{
134 return mVerbosityLvl;
135}
136
137void
138MonteCarlo::OpenRootFile()
139{
140 if (mVerbosityLvl > 0) cout << "...opening root file: " << mFileName << endl;
141
142 mpRootFile = new TFile(mFileName, "READ");
143
144 if (!mpRootFile->IsOpen())
145 {
146 cout << "ERROR - Could not find file " << mFileName << endl;
147 mRootFileOpend =false;
148 return ;
149 }
150 mRootFileOpend = true;
151
152 return;
153}
154
155void
156MonteCarlo::CloseRootFile()
157{
158 if (mVerbosityLvl > 0) cout << "...closing root file: " << mFileName << endl;
159 mpRootFile->Close("R");
160 mpRootFile=NULL;
161
162 return;
163}
164
165void
166MonteCarlo::OpenCsvFile(TString fileName)
167{
168 mCsvFileName = fileName;
169
170 if (mVerbosityLvl > 0) cout << "...opening csv file: " << mCsvFileName << endl;
171
172 mCsv.open( mCsvFileName );
173
174 return;
175}
176
177void
178MonteCarlo::CloseCsvFile()
179{
180 if (mVerbosityLvl > 0) cout << "...closing csv file: " << mCsvFileName << endl;
181
182 mCsv.close();
183
184 return;
185}
186
187void
188MonteCarlo::LoadHeaderTree(TString treeName)
189{
190 if (mVerbosityLvl > 0) cout << "...loading run header tree" << endl;
191
192 mpHeaderTree = (TTree*)mpRootFile->Get(treeName);
193
194 if (mpHeaderTree->IsZombie())
195 {
196 cout << "...could not load tree" << endl;
197 return;
198 }
199
200 // =======================================================================
201 //Set Adresses to Branches in RunHeader-Tree
202
203 // -----------------------------------------------------------------------
204
205 // MGeomCam
206 if ( mpHeaderTree->GetBranchStatus("MGeomCam.") )
207 {
208 if (mVerbosityLvl > 1) cout << " ...MGeomCam" << endl;
209 mpHeaderTree->SetBranchAddress("MGeomCam.", &mpGeomCam);
210 }
211 else cout << "...could not load branch: MGeomCam" << endl;
212
213 // -----------------------------------------------------------------------
214
215 // IntendedPulsePos
216 if ( mpHeaderTree->GetBranchStatus("IntendedPulsePos.") )
217 {
218 if (mVerbosityLvl > 1) cout << " ...IntendedPulsePos" << endl;
219 mpHeaderTree->SetBranchAddress("IntendedPulsePos.", &mpIntendedPulsePos);
220 }
221 else cout << "...could not load branch: IntendedPulsePos" << endl;
222
223 // -----------------------------------------------------------------------
224
225 // MMcRunHeader
226 if ( mpHeaderTree->GetBranchStatus("MMcRunHeader.") )
227 {
228 if (mVerbosityLvl > 1) cout << " ...MMcRunHeader" << endl;
229 mpHeaderTree->SetBranchAddress("MMcRunHeader.", &mpMcRunHeader);
230 }
231 else cout << "...could not load branch: MMcRunHeader" << endl;
232
233 // -----------------------------------------------------------------------
234
235 // ElectronicNoise
236 if ( mpHeaderTree->GetBranchStatus("ElectronicNoise.") )
237 {
238 if (mVerbosityLvl > 1) cout << " ...ElectronicNoise" << endl;
239 mpHeaderTree->SetBranchAddress("ElectronicNoise.", &mpElectronicNoise);
240 }
241 else cout << "...could not load branch: ElectronicNoise" << endl;
242
243 // -----------------------------------------------------------------------
244
245 // MRawRunHeader
246 if ( mpHeaderTree->GetBranchStatus("MRawRunHeader.") )
247 {
248 if (mVerbosityLvl > 1) cout << " ...MRawRunHeader" << endl;
249 mpHeaderTree->SetBranchAddress("MRawRunHeader.", &mpRawRunHeader);
250 }
251 else cout << "...could not load branch: MRawRunHeader" << endl;
252
253 // -----------------------------------------------------------------------
254
255 // MCorsikaRunHeader
256 if ( mpHeaderTree->GetBranchStatus("MCorsikaRunHeader.") )
257 {
258 if (mVerbosityLvl > 1) cout << " ...MCorsikaRunHeader" << endl;
259 mpHeaderTree->SetBranchAddress("MCorsikaRunHeader.",&mpCorsikaRunHeader);
260 }
261 else cout << "...could not load branch: MCorsikaRunHeader" << endl;
262
263 // =======================================================================
264
265 return;
266}
267
268void
269MonteCarlo::ReadRunHeader()
270{
271 if (mVerbosityLvl > 0)
272 cout << "...reading run header " << mpHeaderTree << endl;
273
274 //Read Values from RunHeader-Tree
275
276 mpHeaderTree->GetEntry(); //This causes problems
277
278 // -----------------------------------------------------------------------
279
280 //Get values from "MGeomCam" Branch
281 //Getter functions from "MGeomCamFACT.h"
282 if ( mpGeomCam != NULL)
283 {
284 mCamDist = mpGeomCam->GetCameraDist();
285 mNumberOfPixels = mpGeomCam->GetNumPixels();
286 mNumberOfSectors = mpGeomCam->GetNumSectors();
287 mNumberOfAreas = mpGeomCam->GetNumAreas();
288 }
289 else if (mVerbosityLvl > 2)
290 cout << "...could not read data from: MGeomCam" << endl;
291
292 // -----------------------------------------------------------------------
293
294 //Get values from "IntendedPulsePos" Branch
295 if ( mpIntendedPulsePos != NULL)
296 {
297 mIntendedPulsePos = mpIntendedPulsePos->GetVal();
298 }
299 else if (mVerbosityLvl > 2)
300 cout << "...could not read data from: IntendedPulsePos" << endl;
301
302 // -----------------------------------------------------------------------
303
304 //Get values from "MMcRunHeader" Branch from event Tree
305 if ( mpMcRunHeader != NULL)
306 {
307 mNumSimulatedShowers = mpMcRunHeader->GetNumSimulatedShowers();
308 }
309 else if (mVerbosityLvl > 2)
310 cout << "...could not read data from: MMcRunHeader" << endl;
311
312 // -----------------------------------------------------------------------
313
314 //Get number of Events from event Tree
315 if ( mpEventTree != NULL)
316 {
317 mNumberOfEntries = mpEventTree->GetEntries();
318 }
319 else if (mVerbosityLvl > 2)
320 cout << "...could not read number of Events from event Tree" << endl;
321
322 if (mVerbosityLvl > 0)
323 cout << "Event Tree has " << mNumberOfEntries << " entries" << endl;
324
325 // -----------------------------------------------------------------------
326
327 //Get values from "MRawRunHeader" Branch
328 if ( mpRawRunHeader != NULL)
329 {
330 mNumberOfEvents = mpRawRunHeader->GetNumEvents(); // couses problems
331 mNumberOfEventsRead = mpRawRunHeader->GetNumEventsRead();
332 mSamplingFrequency = mpRawRunHeader->GetFreqSampling();
333 mSourceName = mpRawRunHeader->GetSourceName();
334 mFileNumber = mpRawRunHeader->GetFileNumber();
335 mNumberOfSamples = mpRawRunHeader->GetNumSamplesHiGain();
336 mNumberOfBytes = mpRawRunHeader->GetNumBytesPerSample();
337 mRunNumber = mpRawRunHeader->GetRunNumber();
338 mRunType = mpRawRunHeader->GetRunType();
339 }
340 else if (mVerbosityLvl > 2)
341 cout << "...could not read data from: MRawRunHeader" << endl;
342
343 // -----------------------------------------------------------------------
344
345 //Get values from "MCorsikaRunHeader" Branch
346 if ( mpCorsikaRunHeader != NULL)
347 {
348 mSlopeSpectrum = mpCorsikaRunHeader->GetSlopeSpectrum();
349 mEnergyMin = mpCorsikaRunHeader->GetEnergyMin();
350 mEnergyMax = mpCorsikaRunHeader->GetEnergyMax();
351 mZdMin = mpCorsikaRunHeader->GetZdMin();
352 mZdMax = mpCorsikaRunHeader->GetZdMax();
353 mAzMin = mpCorsikaRunHeader->GetAzMin();
354 mAzMax = mpCorsikaRunHeader->GetAzMax();
355 }
356 else if (mVerbosityLvl > 2)
357 cout << "...could not read data from: MCorsikaRunHeader" << endl;
358
359 // -----------------------------------------------------------------------
360
361 // delete Pixel Array before you set refferences for a new one
362 if (mpPixel != NULL)
363 {
364 delete[] mpPixel;
365 }
366 mpPixel = new pixel_t[mNumberOfPixels];
367
368 // -----------------------------------------------------------------------
369
370 //Get Pedestal from "ElectronicNoise" Branch
371 if ( mpElectronicNoise != NULL)
372 {
373 if (mVerbosityLvl > 1) cout << " ...reading pedestal offsets" << endl;
374
375 // Read Pedestal Offset
376 for ( int i = 0; i < mNumberOfPixels; i++ )
377 {
378 if ( &(mpElectronicNoise[0][i]) != NULL)
379 mpPixel[i].pedestal = mpElectronicNoise[0][i].GetPedestal();
380 else if (mVerbosityLvl > 2)
381 cout << " ...cannot read pedestal offset" << endl;
382 }
383 }
384 else if (mVerbosityLvl > 2)
385 cout << "...could not read data from: ElectronicNoise" << endl;
386
387 return;
388}
389
390void
391MonteCarlo::LoadEventTree(TString treeName)
392{
393 if (mVerbosityLvl > 0) cout << "...loading event tree" << endl;
394
395 mpEventTree = (TTree*)mpRootFile->Get(treeName);
396
397 if (mpEventTree->IsZombie())
398 {
399 cout << "...could not load tree" << endl;
400 return;
401 }
402
403 // =======================================================================
404 //Set Adresses to Branches in Events-Tree
405
406 if (mVerbosityLvl > 1) cout << "...SetBranchAddresses:" << endl;
407
408 // -----------------------------------------------------------------------
409
410 // MRawEvtData
411 if ( mpEventTree->GetBranchStatus("MRawEvtData.") != -1 )
412 {
413 if (mVerbosityLvl > 1) cout << " ...MRawEvtData" << endl;
414 mpEventTree->SetBranchAddress("MRawEvtData.", &mpRawEventData);
415 }
416 else cout << "...could not load branch: MRawEvtData" << endl;
417
418 // -----------------------------------------------------------------------
419
420 // IncidentAngle
421 if ( mpEventTree->GetBranchStatus("IncidentAngle.") )
422 {
423 //FIX ME: THIS VALUE IS NOT EXISTANT IN EVERY MC FILE
424
425 if (mVerbosityLvl > 1) cout << " ...IncidentAngle" << endl;
426 mpEventTree->SetBranchAddress("IncidentAngle.", &mpIncidentAngle);
427 }
428 else cout << "...could not load branch: IncidentAngle" << endl;
429
430 // -----------------------------------------------------------------------
431
432 // MMcEvt
433 if ( mpEventTree->GetBranchStatus("MMcEvt.") )
434 {
435 if (mVerbosityLvl > 1) cout << " ...McEvt" << endl;
436 mpEventTree->SetBranchAddress("MMcEvt.", &mpMcEventMetaData);
437 }
438 else cout << "...could not load branch: McEvt" << endl;
439
440 // -----------------------------------------------------------------------
441
442 // MRawEvtHeader
443 if ( mpEventTree->GetBranchStatus("MRawEvtHeader.") )
444 {
445 if (mVerbosityLvl > 1) cout << " ...MRawEventHeader" << endl;
446 mpEventTree->SetBranchAddress("MRawEvtHeader.", &mpRawEventHeader);
447 }
448 else cout << "...could not load branch: MRawEvtHeader" << endl;
449
450 // -----------------------------------------------------------------------
451
452 // MCorsikaEvtHeader
453 if ( mpEventTree->GetBranchStatus("MCorsikaEvtHeader.") )
454 {
455 if (mVerbosityLvl > 1) cout << " ...MCorsikaEvtHeader" << endl;
456 mpEventTree->SetBranchAddress("MCorsikaEvtHeader.", &mpCorsikaEvtHeader);
457 }
458 else cout << "...could not load branch: MCorsikaEvtHeader" << endl;
459
460 // =======================================================================
461
462 return;
463}
464
465void
466MonteCarlo::ReadEventMetaData()
467{
468 if (mVerbosityLvl > 1)
469 cout << "...reading event header" << endl;
470
471 //Get values from "MGeomCamFACT" Branch
472 if ( mpIncidentAngle != NULL)
473 {
474 mIncidentAngle = mpIncidentAngle->GetVal();
475 }
476 else if (mVerbosityLvl > 2)
477 cout << "...could not read data from: MGeomCamFACT" << endl;
478
479 // -----------------------------------------------------------------------
480
481 //Get values from "MMcEvt" Branch
482 if ( mpMcEventMetaData != NULL)
483 {
484 //The following Getter Functions can be found in MMcEvt.h
485 mCorsikaEventNumber = mpMcEventMetaData->GetEvtNumber();
486 mPhotElFromShower = mpMcEventMetaData->GetPhotElfromShower();
487 mPhotElinCamera = mpMcEventMetaData->GetPhotElinCamera();
488 //The following Getter Functions can be found in MMcEvtBasic.h
489 mPartId = mpMcEventMetaData->GetPartId();
490 mPartName = mpMcEventMetaData->GetParticleName(mPartId);
491 mPartSymbol = mpMcEventMetaData->GetParticleSymbol(mPartId);
492 mEnergy = mpMcEventMetaData->GetEnergy();
493 mImpact = mpMcEventMetaData->GetImpact();
494 mTelescopePhi = mpMcEventMetaData->GetTelescopePhi();
495 mTelescopeTheta = mpMcEventMetaData->GetTelescopeTheta();
496 mPhi = mpMcEventMetaData->GetParticlePhi();
497 mTheta = mpMcEventMetaData->GetParticleTheta();
498 }
499 else if (mVerbosityLvl > 2)
500 cout << "...could not read data from: MMcEvt" << endl;
501
502 // -----------------------------------------------------------------------
503
504 //Get values from "MRawEventHeader" Branch
505 if ( mpRawEventHeader != NULL)
506 {
507 mEventNumber = mpRawEventHeader->GetDAQEvtNumber();
508 mNumTriggerLvl1 = mpRawEventHeader->GetNumTrigLvl1();
509 mNumTriggerLvl2 = mpRawEventHeader->GetNumTrigLvl2();
510 }
511 else if (mVerbosityLvl > 2)
512 cout << "...could not read data from: MRawEventHeader" << endl;
513
514 // -----------------------------------------------------------------------
515
516 //Get values from "MCorsikaEvtHeader" Branch
517 if ( mpCorsikaEvtHeader != NULL)
518 {
519 mFirstInteractionHeight = mpCorsikaEvtHeader->GetFirstInteractionHeight();
520 mEvtReuse = mpCorsikaEvtHeader->GetNumReuse();
521 mMomentumX = mpCorsikaEvtHeader->GetMomentum().X();
522 mMomentumY = mpCorsikaEvtHeader->GetMomentum().Y();
523 mMomentumZ = mpCorsikaEvtHeader->GetMomentum().Z();
524 mZd = mpCorsikaEvtHeader->GetZd();
525 mAz = mpCorsikaEvtHeader->GetAz();
526 mX = mpCorsikaEvtHeader->GetX();
527 mY = mpCorsikaEvtHeader->GetY();
528 }
529 else if (mVerbosityLvl > 2)
530 cout << "...could not read data from: MCorsikaEvtHeader" << endl;
531
532 // -----------------------------------------------------------------------
533
534 // mWeightedNumPhotons = mpCorsikaEvtHeader->Get;
535 // no getter function, no idea how to extract information
536
537 return;
538}
539
540void
541MonteCarlo::ReadEventRawData()
542{
543 if (mVerbosityLvl > 1) cout << "...reading event raw data" << endl;
544
545 // -----------------------------------------------------------------------
546
547 // delete Pixel Array before you set refferences for a new one
548 if (mpPixel != NULL)
549 {
550 delete[] mpPixel;
551 }
552 mpPixel = new pixel_t[mNumberOfPixels];
553
554 // -----------------------------------------------------------------------
555
556 if ( mpRawEventData == NULL)
557 {
558 cout << "ERROR: cannot read event data" << endl;
559 return;
560 }
561
562 mpRawEventData->InitRead(mpRawRunHeader);
563
564 int pix_first_sample;
565// int pix_last_sample;
566
567 // -----------------------------------------------------------------------
568
569 unsigned short* all_raw_data = NULL;
570
571 if ( mpRawEventData != NULL)
572 {
573 all_raw_data = (unsigned short*) mpRawEventData->GetSamples();
574 }
575 else cout << "...cannot read event raw data" << endl;
576
577 // -----------------------------------------------------------------------
578
579 if (mVerbosityLvl > 1)
580 cout << "...pixel progress: ";
581
582 for ( int i = 0; i < mNumberOfPixels; i++ )
583 {
584 if (mVerbosityLvl > 1){
585 if ( !(i%(mNumberOfPixels/10) ))
586 cout << i/(mNumberOfPixels*1.0)*100 << "%.." ;
587 if ( i == mNumberOfPixels-1)
588 cout << "100% " ;
589 }
590
591 // Read Pedestal Offset
592 if ( mpElectronicNoise != NULL)
593 {
594 mpPixel[i].pedestal = mpElectronicNoise[0][i].GetPedestal();
595 }
596 else cout << "...cannot read pedestal offset" << endl;
597
598 // Read Pixel SoftId
599 if ( mpRawEventData != NULL)
600 {
601 mpPixel[i].SoftId = mpRawEventData->GetPixelIds()[i];
602 }
603 else cout << "...cannot read pixel id" << endl;
604
605 pix_first_sample = i*mNumberOfSamples;
606
607 // point beginning of pixel's rawdata array to address
608 // of pixel's first sample's adress
609 mpPixel[i].rawData = &(all_raw_data[pix_first_sample]);
610 }
611
612 if (mVerbosityLvl > 1)
613 cout << endl;
614
615 return;
616}
617
618void
619MonteCarlo::ReadEvent(int Event)
620{
621 if (mVerbosityLvl > 0) cout << endl
622 << "====================" << endl
623 << "...reading Event: " << Event << endl
624 << "====================" << endl;
625
626
627 //load certain event from tree
628 mpEventTree->GetEntry(Event);
629
630 ReadEventMetaData();
631 ReadEventRawData();
632
633 return;
634}
635
636void
637MonteCarlo::WriteMc2Csv(TString filename)
638{
639 if ( !mRootFileOpend ){
640 cout << "ERROR - no rootfile loaded, no data loaded, cannot write csv"
641 << endl;
642 return;
643 }
644
645 cout << "...writing mc to csv: " << filename << endl;
646 cout << "...processing " << mNumberOfEntries << "Events" << endl;
647
648 mCsvFileName = filename;
649 OpenCsvFile(mCsvFileName);
650
651 WriteFileInfo2Csv();
652 WriteRunHeaderInfo2Csv();
653 WriteRunHeader2Csv();
654
655 WritePedestalInfo2Csv();
656 WritePedestal2Csv();
657
658 WriteEventHeaderInfo2Csv();
659 WriteEventDataInfo2Csv();
660
661// for (int evt = 0; evt < mNumberOfEvents; evt++)
662 for (int evt = 0; evt < mNumberOfEntries; evt++)
663 {
664 ReadEvent(evt);
665 WriteEventHeader2Csv();
666 WriteEventData2Csv();
667 }
668
669 cout << endl << "...conversion done " << endl;
670
671 CloseCsvFile();
672 return;
673}
674
675void
676MonteCarlo::WriteFileInfo2Csv()
677{
678 if (mVerbosityLvl > 0) cout << "...writing file header to csv" << endl;
679
680 mCsv << "### ==========================================================="
681 << endl;
682 mCsv << "### = FACT Monte Carlo ="
683 << endl;
684 mCsv << "### ==========================================================="
685 << endl;
686 mCsv << "### = FileInfo: "
687 << endl;
688 mCsv << "### = "
689 << endl;
690 mCsv << "### = Source Name: " << mSourceName << endl;
691 mCsv << "### = Number of Entries: " << mNumberOfEntries << endl;
692 mCsv << "### = Run Number: " << mRunNumber << endl;
693 mCsv << "### = Run Type : " << mRunType << endl;
694 mCsv << "### = File Number: " << mFileNumber << endl;
695 mCsv << "### ==========================================================="
696 << endl ;
697 mCsv << "###"
698 << endl ;
699
700 return;
701}
702
703void
704MonteCarlo::WriteRunHeaderInfo2Csv()
705{
706 if (mVerbosityLvl > 0) cout << "...writing run header names to csv" << endl;
707
708 mCsv << "### [RunHeader]" << endl;
709
710 mCsv << "# mNumberOfEntries" << mSeparator;
711 mCsv << "mIntendedPulsePos" << mSeparator;
712// Csv << "mPedestalOffset" << mSeparator;
713 mCsv << "mNumSimulatedShowers" << mSeparator;
714 mCsv << "mNumberOfPixels" << mSeparator;
715 mCsv << "mNumberOfSamples" << mSeparator;
716// mCsv << "mSampleSize" << mSeparator;
717 mCsv << "mCamDist" << mSeparator;
718 mCsv << "mSourceName" << mSeparator;
719 mCsv << "mSlopeSpectrum" << mSeparator;
720 mCsv << "mEnergyMin" << mSeparator;
721 mCsv << "mEnergyMax" << mSeparator;
722 mCsv << "mZdMin" << mSeparator;
723 mCsv << "mZdMax" << mSeparator;
724 mCsv << "mAzMin" << mSeparator;
725 mCsv << "mAzMax" << mSeparator;
726 mCsv << "mFileNumber" << mSeparator;
727 mCsv << "mRunnumber" << mSeparator;
728 mCsv << "mRunType" << endl;
729
730 return;
731}
732
733void
734MonteCarlo::WriteRunHeader2Csv()
735{
736 if (mVerbosityLvl > 0) cout << "...writing run header to csv" << endl;
737
738 mCsv << mNumberOfEntries << mSeparator;
739 mCsv << mIntendedPulsePos << mSeparator;
740// mCsv << mPedestalOffset << mSeparator;
741 mCsv << mNumSimulatedShowers << mSeparator;
742 mCsv << mNumberOfPixels << mSeparator;
743 mCsv << mNumberOfSamples << mSeparator;
744// mCsv << mSampleSize << mSeparator;
745 mCsv << mCamDist << mSeparator;
746 mCsv << mSourceName << mSeparator;
747 mCsv << mSlopeSpectrum << mSeparator;
748 mCsv << mEnergyMin << mSeparator;
749 mCsv << mEnergyMax << mSeparator;
750 mCsv << mZdMin << mSeparator;
751 mCsv << mZdMax << mSeparator;
752 mCsv << mAzMin << mSeparator;
753 mCsv << mAzMax << mSeparator;
754 mCsv << mFileNumber << mSeparator;
755 mCsv << mRunNumber << mSeparator;
756 mCsv << mRunType << endl;
757
758 return;
759}
760
761void
762MonteCarlo::WriteEventHeaderInfo2Csv()
763{
764 if (mVerbosityLvl > 0) cout << "...writing event header names to csv" << endl;
765
766 mCsv << "### [EventHeader]" << endl;
767
768 mCsv << "# mEventNumber" << mSeparator;
769 mCsv << "mNumberOfBytes" << mSeparator;
770 mCsv << "mIncidentAngle" << mSeparator;
771 mCsv << "mPartId" << mSeparator;
772 mCsv << "mEnergy" << mSeparator;
773 mCsv << "mImpact" << mSeparator;
774 mCsv << "mTelescopePhi" << mSeparator;
775 mCsv << "mTelescopeTheta" << mSeparator;
776 mCsv << "mPhi" << mSeparator;
777 mCsv << "mTheta" << mSeparator;
778 mCsv << "mCorsikaEventNumber" << mSeparator;
779 mCsv << "mPhotElFromShower" << mSeparator;
780 mCsv << "mEvtReuse" << mSeparator;
781 mCsv << "mNumTriggerLvl1" << mSeparator;
782 mCsv << "mFirstInteractionHeight" << mSeparator;
783 mCsv << "mMomentumX" << mSeparator;
784 mCsv << "mMomentumY" << mSeparator;
785 mCsv << "mMomentumZ" << mSeparator;
786 mCsv << "mZd" << mSeparator;
787 mCsv << "mAz" << mSeparator;
788 mCsv << "mX" << mSeparator;
789 mCsv << "mY" << mSeparator;
790// mCsv << "mWeightedNumPhotons" ;
791 mCsv << endl;
792
793 return;
794}
795
796void
797MonteCarlo::WriteEventHeader2Csv()
798{
799 if (mVerbosityLvl > 0) cout << "...writing event header to csv" << endl;
800
801 mCsv << mEventNumber << mSeparator;
802 mCsv << mNumberOfBytes << mSeparator;
803 mCsv << mIncidentAngle << mSeparator;
804 mCsv << mPartId << mSeparator;
805 mCsv << mEnergy << mSeparator;
806 mCsv << mImpact << mSeparator;
807 mCsv << mTelescopePhi << mSeparator;
808 mCsv << mTelescopeTheta << mSeparator;
809 mCsv << mPhi << mSeparator;
810 mCsv << mTheta << mSeparator;
811 mCsv << mCorsikaEventNumber << mSeparator;
812 mCsv << mPhotElFromShower << mSeparator;
813 mCsv << mEvtReuse << mSeparator;
814 mCsv << mNumTriggerLvl1 << mSeparator;
815 mCsv << mFirstInteractionHeight << mSeparator;
816 mCsv << mMomentumX << mSeparator;
817 mCsv << mMomentumY << mSeparator;
818 mCsv << mMomentumZ << mSeparator;
819 mCsv << mZd << mSeparator;
820 mCsv << mAz << mSeparator;
821 mCsv << mX << mSeparator;
822 mCsv << mY << mSeparator;
823// mCsv << mWeightedNumPhotons ;
824 mCsv << endl;
825
826 return;
827}
828
829void
830MonteCarlo::WriteEventDataInfo2Csv()
831{
832 if (mVerbosityLvl > 0) cout << "...writing event categories to csv" << endl;
833
834 mCsv << "### [RawData]" << endl;
835 mCsv << "# mEventNumber" << mSeparator;
836 mCsv << "pixelID" << mSeparator;
837// mCsv << "pixelPedestal" << mSeparator;
838 for (int i = 0; i < mNumberOfSamples; i++)
839 {
840 mCsv << "Raw_" << i << mSeparator;
841 }
842 mCsv << endl;
843
844 return;
845}
846
847void
848MonteCarlo::WriteEventData2Csv()
849{
850 if (mVerbosityLvl > 0) cout << "...writing event data to csv" << endl;
851
852 // Loop over pixels and write pixeldata to csv
853 for (int i = 0; i < mNumberOfPixels; i++)
854 {
855 WritePixelData2Csv(i);
856 }
857
858 return;
859}
860
861void
862MonteCarlo::WritePixelData2Csv(int pixelID)
863{
864 if (mVerbosityLvl > 3) cout << "...writing pixel data to csv" << endl;
865 mCsv << mEventNumber << mSeparator;
866 mCsv << mpPixel[pixelID].SoftId << mSeparator;
867// mCsv << mpPixel[pixelID].pedestal << mSeparator;
868
869 for (int i = 0; i < mNumberOfSamples; i++)
870 {
871 mCsv << mpPixel[pixelID].rawData[i] << mSeparator;
872 }
873 mCsv << endl;
874
875 return;
876}
877
878void
879MonteCarlo::WritePedestalInfo2Csv()
880{
881 mCsv << "### [Pedestal]" << endl;
882// mCsv << "# SoftID" ;
883// mCsv << mSeparator ;
884// mCsv << "Pedestal" << endl;
885}
886
887void
888MonteCarlo::WritePedestal2Csv()
889{
890 if (mVerbosityLvl > 3) cout << "...writing pedestal info to csv" << endl;
891
892 for (int pixelID = 0; pixelID < mNumberOfPixels; pixelID++)
893 {
894// mCsv << mpPixel[pixelID].SoftId;
895 mCsv << mpPixel[pixelID].pedestal;
896 if (pixelID < mNumberOfPixels -1)
897 mCsv << mSeparator;
898 }
899 mCsv << endl;
900
901 return;
902}
903
904
905//--------------------------------------------------------------------------------
906//
907//
908//
909// FADC samples (hi gain) of all pixels
910// This is an array of Byte_t variables. The value of a FADC sample has a
911// size of n=fNumBytesPerSample bytes. Therefore, a FADC sample value will
912// occupy n consecutive elements of this array (little endian ordering, i.e,
913// less significant bits (and bytes) go first.
914// If m = GetNumHiGainSamples(), the n bytes corresponding to the value of the
915// i-th FADC sample of the j-th pixel are stored in the n consecutive
916// positions of this array, starting from fHiGainFadcSamples[j*n*m+i*n]
917
918
919
920
Note: See TracBrowser for help on using the repository browser.