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

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