#include <map>
#include <vector>
#include <iomanip>
#include <iostream>

Functions
void	Init ()

int	TimeStructure (Int_t sensorId=0, Bool_t allSensors=kFALSE)

Variables
Int_t	gEntryNr = 0

TTree *	t

TClonesArray *	mvdUnsorted = new TClonesArray("PndSdsDigiTopix4")

TClonesArray *	mvdSorted = new TClonesArray("PndSdsDigiTopix4")

TH1D *	h1Unsorted

TH1D *	h1Sorted

TH1D *	h1UnsortedDL

TH1D *	h1UnsortedTL

TH1D *	h1SortedDL

TGraph *	grTimeStampPos

std::vector< Double_t >	dataInStreamUnsorted

Function Documentation

void Init ( )

Initialize the session

Definition at line 26 of file TimeStructure.C.

References f, h1Sorted, h1Unsorted, h1UnsortedDL, h1UnsortedTL, mvdSorted, mvdUnsorted, and t.

 {
         TFile* f = new TFile("2014-10-27-00-06-02_50_MHz.root", "READ");
         t = (TTree*)f->Get("pndsim");
 //      t->AddFriend("pndsim", "2014-10-27-00-06-02_50_MHz_Filtered_PosCorrected_Residuals.root");
 //      t->AddFriend("pndsim", "2014-10-27-00-06-02_50_MHz_Filtered_PosCorrected_Track.root");
 //      t->AddFriend("pndsim", "2014-10-27-00-06-02_50_MHz_Filtered_TimeCorrectedSorted_Event.root");
 //      t->StartViewer();
         t->SetBranchAddress("ToPix4Hits", &mvdUnsorted);
         t->SetBranchAddress("ToPix4HitsSorted", &mvdSorted);
         h1Unsorted = new TH1D("h1Unsorted", "Unsorted", 200000, -100000, 100000);
         h1Sorted = new TH1D("h1Sorted", "Sorted", 200000, -100000, 100000);
         h1UnsortedDL = new TH1D("h1UnsortedDL", "UnsortedDL", 200000, -100000, 100000);
         h1UnsortedTL = new TH1D("h1UnsortedTL", "UnsortedTL", 200000, -100000, 100000);
 //      t->SetBranchAddress("MvdTrack", &trackArray);
 
 
 //      mg->Add(gProjections, "Projected");
         t->GetEntry(0);
 }

int TimeStructure	(	Int_t	sensorId = `0`,
		Bool_t	allSensors = `kFALSE`
	)

Definition at line 48 of file TimeStructure.C.

References c1, dataInStreamUnsorted, PndSdsDigi::GetSensorID(), h1Sorted, h1Unsorted, h1UnsortedDL, h1UnsortedTL, i, Init(), mvdSorted, mvdUnsorted, out, and t.

 {
         Init();
         int runIndexUnsorted = 0;
         int runIndexSorted = 0;
 
         std::ofstream unsorted ("unsorted3.txt", std::ofstream::out);
         std::ofstream sorted ("sorted3.txt", std::ofstream::out);
         double oldTimeUnsorted = 0;
         double oldTimeUnsortedDL = 0;
         double oldTimeUnsortedTL = 0;
         double oldTimeSorted = 0;
 
 //      for (int i = 0; i < t->GetEntries(); i++){
         double timeDiff = 0;
         double timeDiffDL = 0;
         double timeDiffTL = 0;
 
 //      for (int i = 0; i < t->GetEntries(); i++){
         for (int i = 333800; i < 344680; i++){
                 t->GetEntry(i);
                 for (int j = 0; j < mvdUnsorted->GetEntries(); j++){
                         PndSdsDigiTopix4* unsortedHit = (PndSdsDigiTopix4*)mvdUnsorted->At(j);
                         if (unsortedHit->GetSensorID() == sensorId || allSensors){
                                 timeDiff = unsortedHit->GetTimeStamp() - oldTimeUnsorted;
                                 timeDiffDL = unsortedHit->GetTimeStamp() - oldTimeUnsortedDL;
                                 timeDiffTL = unsortedHit->GetTimeStamp() - oldTimeUnsortedTL;
 
                                 unsorted << runIndexUnsorted++ << " , " << unsortedHit->GetSensorID() << " , " << std::setprecision(15) << unsortedHit->GetTimeStamp() << " , " << timeDiff << std::endl;
                                 h1Unsorted->Fill(timeDiff);
                                 h1UnsortedDL->Fill(timeDiffDL);
                                 h1UnsortedTL->Fill(timeDiffTL);
                                 oldTimeUnsortedTL = oldTimeUnsortedDL;
                                 oldTimeUnsortedDL = oldTimeUnsorted;
                                 oldTimeUnsorted = unsortedHit->GetTimeStamp();
                                 dataInStreamUnsorted.push_back(unsortedHit->GetTimeStamp());
                         }
                 }
                 for (int k = 0; k < mvdSorted->GetEntries(); k++){
                         PndSdsDigiTopix4* sortedHit = (PndSdsDigiTopix4*)mvdSorted->At(k);
                         if (sortedHit->GetSensorID() == sensorId || allSensors){
                                 double timeDiffD = sortedHit->GetTimeStamp() - oldTimeSorted;
                                 sorted << runIndexSorted++ << " , " << std::setprecision(15) << sortedHit->GetTimeStamp() << " , " << timeDiffD << std::endl;
                                 h1Sorted->Fill(timeDiffD);
                                 oldTimeSorted = sortedHit->GetTimeStamp();
                         }
                 }
                 if (i % 1000 == 0){
                         std::cout << i << std::endl;
                 }
         }
         unsorted.close();
         sorted.close();
 
         TCanvas* c1 = new TCanvas();
         c1->Divide(4,1);
         c1->cd(1);
         h1Unsorted->Draw();
         c1->cd(2);
         h1UnsortedDL->Draw();
         c1->cd(3);
         h1UnsortedTL->Draw();
         c1->cd(4);
         h1Sorted->Draw();
   return 0;
 }