sipm-characterisation 0.1.0
SiPM characterisation for ePIC — IV/DCR/gain, laser, readout, irradiation
Loading...
Searching...
No Matches
fine_analysis.h
Go to the documentation of this file.
1#ifndef ALCOR_UTILITYFINEANALYSIS_H
2#define ALCOR_UTILITYFINEANALYSIS_H
12#include "analysis_utils.h"
13using namespace analysis_utils;
16typedef std::tuple<double, double, double> kFineTuneParamsType;
17std::map<global_identifier_t,kFineTuneParamsType> kFineTuneParameters; // Is detector unit oriented
18std::map<TString,TH2F*> kFineTuneRawHistograms; // Is Run oriented
22bool kIgnoreFix = false;
23const int kMaximumOffsetCalibIteration = 4;
24const float kEspilonOffsets = 0.001; // 3.125 ps
25const float kEspilonOffMean = 0.001; // 3.125 ps
26const TString output_preprocess_fine_analysis_directory = output_preprocess_directory + TString("/FineAnalysis/");
27const TString output_preprocess_fine_analysis_file_raw = output_preprocess_fine_analysis_directory + TString("/%s/FineTuneRaw.root");
28const TString output_preprocess_fine_analysis_file_rslt = output_preprocess_fine_analysis_directory + TString("/%s/FineTuneResults.root");
29const TString output_preprocess_fine_analysis_file_offset_raw = output_preprocess_fine_analysis_directory + TString("/%s/FineTuneOffsetRaw.root");
30const TString output_preprocess_fine_analysis_file_offset_rslt = output_preprocess_fine_analysis_directory + TString("/%s/FineTuneOffsetResults.root");
31const TString output_preprocess_fine_analysis_file_check = output_preprocess_fine_analysis_directory + TString("/%s/FineTuneResultsCheck.root");
32const TString output_preprocess_fine_analysis_graphics_dir = output_preprocess_fine_analysis_directory + TString("/%s/FitCheck/");
33TF1* fine_analysis_fit_function = new TF1("fine_analysis_fit_function", "[0]*(1./(exp((x-[1])/[2])+1))*(1./(exp(([3]-x)/[4])+1))", 20., 150.);
38template< typename TH2_Type = TH2F >
39TH2_Type* build_fine_tune_raw_histogram ( std::vector<TString> kInputFileNames, TString kRunTag, TString kOutputFileName, bool kRecalculate );
40template< typename TH2_Type = TH2F >
41TH2_Type* build_fine_tune_raw_histogram ( TString kRunTag, TString kOutputFileName, bool kRecalculate );
42template< typename TH2_Type = TH2F >
43TH2_Type* run_fine_tune_analysis ( TString kRunTag, TString kOutputFileName, TString kOutputGraphics, bool kRecalculate );
45kFineTuneParamsType
46 get_fine_calibration ( global_identifier_t kFilters );
47double get_fine_calibration_min ( global_identifier_t kFilters ) { return get<0>(get_fine_calibration(kFilters)); }
48double get_fine_calibration_max ( global_identifier_t kFilters ) { return get<1>(get_fine_calibration(kFilters)); }
49double get_fine_calibration_offset ( global_identifier_t kFilters ) { return get<2>(get_fine_calibration(kFilters)); }
50template< typename TH2_Type = TH2F >
51TH2_Type* get_fine_tune_parameters ( TString kRunTag );
52template< typename TH2_Type = TH2F >
53TH2_Type* get_fine_tune_raw_histogram ( TString kRunTag );
54TH1D* get_fine_tune_raw_histogram ( global_identifier_t kFilters ) { return get_fine_tune_raw_histogram( get<0>(kFilters) )->ProjectionY( Form("hFine_%i", get<1>(kFilters) ), get<1>(kFilters) + 1, get<1>(kFilters) + 1); }
55void set_fine_calibration ( global_identifier_t kFilters, double kCalibrationMin, double kCalibrationMax, double kCalibrationOffset ) { kFineTuneParameters[kFilters] = { kCalibrationMin, kCalibrationMax, kCalibrationOffset }; }
56void set_fine_calibration_min ( global_identifier_t kFilters, double kCalibrationMin ) { get<0>(kFineTuneParameters[kFilters]) = kCalibrationMin; }
57void set_fine_calibration_max ( global_identifier_t kFilters, double kCalibrationMax ) { get<1>(kFineTuneParameters[kFilters]) = kCalibrationMax; }
58void set_fine_calibration_offset ( global_identifier_t kFilters, double kCalibrationOffset ) { get<2>(kFineTuneParameters[kFilters]) = kCalibrationOffset; }
59void set_fine_calibration ( global_identifier_t kFilters );
60void set_fine_analysis_fit_function ( TH1D* histo, int riseThreshold =1, int dropThreshold =1, int max_step = -3, int min_step = 3);
61template< typename TH2_Type = TH2F >
62void set_fine_tune_raw_histogram ( TString kRunTag, TH2_Type* kFineTuneRawHistogram ) { kFineTuneRawHistograms[kRunTag] = kFineTuneRawHistogram; }
63void set_fine_tune_raw_histogram ( TString kRunTag ) { kFineTuneRawHistograms[kRunTag] = build_fine_tune_raw_histogram( kRunTag, "", false ); };
64template< typename TH2_Type = TH2F >
65void set_fine_tune_raw_histogram ( global_identifier_t kFilters, TH2_Type* kFineTuneRawHistogram ) { set_fine_tune_raw_histogram( get<0>(kFilters), kFineTuneRawHistogram ); }
66void set_fine_tune_raw_histogram ( global_identifier_t kFilters ) { set_fine_tune_raw_histogram( get<0>(kFilters) ); }
68double calculate_calibrated_phase ( int kFineParameter, double kCalibrationMin, double kCalibrationMax, double kCalibrationOffset );
69double calculate_calibrated_phase ( int kFineParameter, global_identifier_t kFilters ) { return calculate_calibrated_phase(kFineParameter, get_fine_calibration_min(kFilters), get_fine_calibration_max(kFilters), get_fine_calibration_offset(kFilters)); }
70double calculate_calibrated_phase ( int kFineParameter, TString kRunTag, int kGlobalIndex ) { return calculate_calibrated_phase(kFineParameter,{kRunTag,kGlobalIndex}); };
71template< typename TH1_Type = TH1F >
72int get_fit_bump ( TH1_Type* histo, double critical_value, int bin_step );
77template< typename TH2_Type = TH2F >
78TH2_Type*
79build_fine_tune_raw_histogram
80 ( std::vector<TString> kInputFileNames, TString kRunTag, TString kOutputFileName, bool kRecalculate ) {
82 TFile* kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_raw,kRunTag.Data()));
84 cout << "[INFO] Looking if fine tune histogram for tuning is cached" << endl;
85 if ( kFileOut->IsOpen() && !kRecalculate ) { cout << "[INFO] Found! Using cached" << endl; return (TH2F*)(kFileOut->Get("hFine_All")); }
86 else { cout << "[INFO] Not found! Re-generating" << endl; delete kFileOut; }
88 TH2_Type* hFine_All = new TH2_Type("hFine_All", ";index;fine", kGlobalIndexRange, 0, kGlobalIndexRange, kFineRange, 0, kFineRange);
90 for ( auto kCurrentFileName : kInputFileNames ) {
91 std::cout << "[INFO] Opening file: " << kCurrentFileName.Data() << std::endl;
93 auto kCurrentFile = TFile::Open(kCurrentFileName);
94 if ( !kCurrentFile || !kCurrentFile->IsOpen() ) {
95 std::cout << "[WARNING] Opening file: " << kCurrentFileName.Data() << " failed!" << std::endl;
96 continue;
97 }
99 data_t kCurrentData;
100 TTree* kCurrentTree = (TTree *)kCurrentFile->Get("alcor");
101 if ( !kCurrentTree ) {
102 std::cout << "[WARNING] No \"alcor\" tree in file: " << kCurrentFileName.Data() << ". Loading failed!" << std::endl;
103 continue;
104 }
106 auto nEvents = kCurrentTree->GetEntries();
107 load_tree( kCurrentTree, kCurrentData );
108 for (int iEv = 0; iEv < nEvents; ++iEv) {
109 kCurrentTree->GetEntry(iEv);
110 int iCurrentIndex = get_global_index( kCurrentData.fifo, kCurrentData.pixel, kCurrentData.column, kCurrentData.tdc );
111 hFine_All->Fill( iCurrentIndex, kCurrentData.fine);
112 }
113 kCurrentFile->Close();
114 }
116 if ( kOutputFileName.Length() != 0 ) {
117 // system(Form("mkdir -p %s", kOutputFileName.Data())); //! TODO: Create folder (?)
118 kFileOut = new TFile( kOutputFileName, "RECREATE" );
119 hFine_All->Write();
120 kFileOut->Close();
121 } else {
122 system(Form("mkdir -p %s/%s",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
123 kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_raw,kRunTag.Data()), "RECREATE" );
124 hFine_All->Write();
125 kFileOut->Close();
126 }
127 return hFine_All;
128}
130template< typename TH2_Type = TH2F >
131TH2_Type*
132build_fine_tune_raw_histogram
133 ( TString kRunTag, TString kOutputFileName, bool kRecalculate ) {
134 std::vector<TString> kInputFileNames;
135 for ( Int_t iFile = 0; iFile < 24; iFile++ ) { kInputFileNames.push_back(Form(intput_rawdata_decoded_file,kRunTag.Data(),iFile)); }
136 return build_fine_tune_raw_histogram<TH2_Type>( kInputFileNames, kRunTag, kOutputFileName, kRecalculate );
137}
139template< typename TH2_Type = TH2F >
140TH2_Type*
141run_fine_tune_analysis
142 ( TString kRunTag, TString kOutputFileName, TString kOutputGraphics, bool kRecalculate ) {
144 TFile* kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_rslt,kRunTag.Data()) );
146 cout << "[INFO] Looking if fine tune histogram for tuning is cached" << endl;
147 if ( kFileOut->IsOpen() && !kRecalculate ) { cout << "[INFO] Found! Using cached" << endl; return (TH2F*)(kFileOut->Get("kFine_All_Tune_Params")); }
148 else { cout << "[INFO] Not found! Re-generating" << endl; delete kFileOut; }
150 gROOT->SetBatch(true);
152 auto hFine_All = get_fine_tune_raw_histogram( kRunTag );
154 TH2_Type* kFine_All_Tune_Params = new TH2_Type( "kFine_All_Tune_Params", "kFine_All_Tune_Params", kGlobalIndexRange, -0.5, kGlobalIndexRange-0.5, 6, 0., 6.);
155 TH1F* kMaximumDistribution = new TH1F( "kMaximumDistribution", "kMaximumDistribution", 200, 0, 200 );
156 TH1F* kMinimumDistribution = new TH1F( "kMinimumDistribution", "kMinimumDistribution", 200, 0, 200 );
157 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(1,"Normalisation");
158 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(2,"Maximum");
159 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(3,"Sigma Max");
160 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(4,"Minimum");
161 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(5,"Sigma Min");
162 kFine_All_Tune_Params->GetYaxis()->SetBinLabel(6,"Offset");
164 for ( Int_t iIndex = 0; iIndex < kGlobalIndexRange; iIndex++ ) {
165 global_identifier_t kCurrentFilter;
166 get<0>(kCurrentFilter) = kRunTag;
167 get<1>(kCurrentFilter) = iIndex;
168 auto kCurrentInfos = get_full_info(iIndex);
169 auto kCurrentFineHisto = get_fine_tune_raw_histogram( kCurrentFilter );
170 if ( kCurrentFineHisto->GetEntries() <= 100 ) {
171 cout << "[WARNING] Skipping empty histogram " << iIndex << " chip:" << get<0>(kCurrentInfos) << " pixel:" << get<1>(kCurrentInfos) << " column:" << get<2>(kCurrentInfos) << " TDC:" << get<3>(kCurrentInfos) << endl;
172 continue;
173 }
174 set_fine_analysis_fit_function( kCurrentFineHisto );
175 kCurrentFineHisto->Fit( fine_analysis_fit_function, "SQ", "" );
176 kFine_All_Tune_Params->SetBinContent( iIndex+1, 1, fine_analysis_fit_function->GetParameter(0) );
177 kFine_All_Tune_Params->SetBinContent( iIndex+1, 2, fine_analysis_fit_function->GetParameter(1) );
178 kFine_All_Tune_Params->SetBinContent( iIndex+1, 3, fine_analysis_fit_function->GetParameter(2) );
179 kFine_All_Tune_Params->SetBinContent( iIndex+1, 4, fine_analysis_fit_function->GetParameter(3) );
180 kFine_All_Tune_Params->SetBinContent( iIndex+1, 5, fine_analysis_fit_function->GetParameter(4) );
181 kMaximumDistribution->Fill(fine_analysis_fit_function->GetParameter(1));
182 kMinimumDistribution->Fill(fine_analysis_fit_function->GetParameter(3));
183 if ( !(kOutputGraphics.Length() == 0) ) {
184 system(Form("mkdir -p %s",kOutputGraphics.Data()));
185 TLatex* kLatex = new TLatex();
186 auto kMinimum = fine_analysis_fit_function->GetParameter(3);
187 auto kMaximum = fine_analysis_fit_function->GetParameter(1);
188 TCanvas* c1 = new TCanvas("", "", 1000, 300);
189 c1->Divide(3,1);
190 c1->cd(1);
191 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMinimum -10, kMinimum +20);
192 kCurrentFineHisto->DrawCopy();
193 kLatex->DrawLatexNDC(0.6, 0.5, Form("Min: %.2f", kMinimum));
194 c1->cd(2);
195 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMinimum -10, kMaximum +10);
196 kCurrentFineHisto->DrawCopy();
197 kLatex->DrawLatexNDC(0.4, 0.5, Form("Max: %.2f", kMaximum));
198 kLatex->DrawLatexNDC(0.4, 0.45, Form("Min: %.2f", kMinimum));
199 c1->cd(3);
200 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMaximum -20, kMaximum +10);
201 kCurrentFineHisto->DrawCopy();
202 kLatex->DrawLatexNDC(0.3, 0.5, Form("Max: %.2f", kMaximum));
203 c1->SaveAs(Form("%s/%s.pdf",kOutputGraphics.Data(),kCurrentFineHisto->GetName()));
204 } else {
205 system(Form("mkdir -p %s", Form( output_preprocess_fine_analysis_graphics_dir.Data(),kRunTag.Data())));
206 TLatex* kLatex = new TLatex();
207 auto kMinimum = fine_analysis_fit_function->GetParameter(3);
208 auto kMaximum = fine_analysis_fit_function->GetParameter(1);
209 TCanvas* c1 = new TCanvas("", "", 1000, 300);
210 c1->Divide(3,1);
211 c1->cd(1);
212 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMinimum -10, kMinimum +20);
213 kCurrentFineHisto->DrawCopy();
214 kLatex->DrawLatexNDC(0.6, 0.5, Form("Min: %.2f", kMinimum));
215 c1->cd(2);
216 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMinimum -10, kMaximum +10);
217 kCurrentFineHisto->DrawCopy();
218 kLatex->DrawLatexNDC(0.4, 0.5, Form("Max: %.2f", kMaximum));
219 kLatex->DrawLatexNDC(0.4, 0.45, Form("Min: %.2f", kMinimum));
220 c1->cd(3);
221 kCurrentFineHisto->GetXaxis()->SetRangeUser(kMaximum -20, kMaximum +10);
222 kCurrentFineHisto->DrawCopy();
223 kLatex->DrawLatexNDC(0.3, 0.5, Form("Max: %.2f", kMaximum));
224 c1->SaveAs(Form("%s/%s.pdf", Form( output_preprocess_fine_analysis_graphics_dir.Data(),kRunTag.Data()),kCurrentFineHisto->GetName()));
225 }
226 }
228 if ( kOutputFileName.Length() != 0 ) {
229 // system(Form("mkdir -p %s", kOutputFileName.Data())); //! TODO: Create folder (?)
230 kFileOut = new TFile( kOutputFileName, "RECREATE" );
231 kMaximumDistribution->Write();
232 kMinimumDistribution->Write();
233 hFine_All->Write();
234 kFine_All_Tune_Params->Write();
235 kFileOut->Close();
236 } else {
237 system(Form("mkdir -p %s/%s",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
238 kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_rslt,kRunTag.Data()), "RECREATE" );
239 kMaximumDistribution->Write();
240 kMinimumDistribution->Write();
241 hFine_All->Write();
242 kFine_All_Tune_Params->Write();
243 kFileOut->Close();
244 }
246 gROOT->SetBatch(false);
247 return kFine_All_Tune_Params;
248}
250void
251raw_delta_fine_tune_offset
252( TString kRunTag, int kGlobalIndex, TH2F& hFine_Offset_All ) {
254 framed_data_t framed_data;
255 auto kInfos = get_full_info(kGlobalIndex);
256 int kExaminedChip = get<0>(kInfos);
257 int kExaminedChannel = get_dochannel(get<1>(kInfos), get<2>(kInfos));
258 int kExaminedTDC = get<3>(kInfos);
259 while ( populate_framed_data( framed_data, Form(intput_rawdata_decoded_file_dir,kRunTag.Data()), timing_filenames, frame_size ) ) {
260 for ( auto &spill_data : framed_data ) {
261 auto spill = spill_data.first;
262 auto &frames = spill_data.second;
263 for (auto &frame_data : frames) {
264 auto frame = frame_data.first;
265 auto &chips = frame_data.second;
266 double average_time[6] = {0.};
267 for (auto &chip_data : chips) {
268 auto kNormalisation = 0;
269 auto chip = chip_data.first;
271 if ( chip < 4 ) continue;
272 auto &channels = chip_data.second;
273 for (auto &channel_data : channels) {
274 auto channel = channel_data.first;
275 auto &hits = channel_data.second;
277 auto &hit = hits[0];
278 int iCurrentIndex = get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc );
279 if ( iCurrentIndex == kGlobalIndex ) continue;
280 double phase = calculate_calibrated_phase( hit.fine, kRunTag, get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc ) );
281 if ( phase <= -9.9 ) continue;
282 double time = hit.coarse * coarse_to_ns + hit.rollover * rollover_to_ns - phase * coarse_to_ns; // [ns]
283 average_time[chip] += time;
284 kNormalisation++;
285 }
286 if (channels.size() > 0) average_time[chip] /= kNormalisation;
287 }
288 if ( chips[4].size() != 32 || chips[5].size() != 32 ) continue;
289 auto delta = average_time[4] - average_time[5];
290 if ( fabs(delta) > 5. ) continue;
291 auto reference = 0.5 * ( average_time[4] + average_time[5] ); // [ns]
293 if ( chips.find(kExaminedChip) == chips.end() ) continue;
294 auto &channels = chips[kExaminedChip];
295 if ( channels.find(kExaminedChannel) == channels.end() ) continue;
296 auto &hits = channels[kExaminedChannel];
297 auto &hit = hits[0];
298 if ( hit.tdc != kExaminedTDC ) continue;
300 int iCurrentIndex = get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc );
301 if ( iCurrentIndex != kGlobalIndex ) continue;
302 double phase = calculate_calibrated_phase( hit.fine, kRunTag, get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc ) );
303 if ( phase <= -9.9 ) continue;
304 double time = hit.coarse * coarse_to_ns + hit.rollover * rollover_to_ns - phase * coarse_to_ns; // [ns]
305 delta = time - reference;
306 hFine_Offset_All.Fill(iCurrentIndex,delta);
307 }
308 }
309 }
310}
312template< typename TH2_Type = TH2F,
313 typename TH3_Type = TH3F >
314TH2_Type*
315run_fine_tune_offset_analysis
316 ( TString kRunTag, TString kOutputFileName, TString kOutputGraphics, bool kRecalculate ) {
318 TFile* kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_offset_rslt,kRunTag.Data()) );
320 cout << "[INFO] Looking if fine tune offset histogram for tuning is cached" << endl;
321 if ( kFileOut->IsOpen() && !kRecalculate ) { cout << "[INFO] Found! Using cached" << endl; return (TH2F*)(kFileOut->Get("kFine_All_Tune_Params")); }
322 else { cout << "[INFO] Not found! Re-generating" << endl; delete kFileOut; }
324 TH2F* kFine_All_Tune_Params = (TH2F*)run_fine_tune_analysis( kRunTag, kOutputFileName, kOutputGraphics, false )->Clone();
326 gROOT->SetBatch(true);
328 TH2_Type* hFine_Offset_All = new TH2_Type("hFine_Offset_All", ";index;#Delta t", kGlobalIndexRange, 0, kGlobalIndexRange, 1000, -50, 50 );
329 TH3_Type* hFine_Check_Tune_Phas = new TH3_Type("hFine_Check_Tune", ";index;#Delta t", kGlobalIndexRange, 0, kGlobalIndexRange, 1000, -50, 50, 400, -2, +2 );
330 TH3_Type* hFine_Check_Tune_Fine = new TH3_Type("hFine_Check_Raw_", ";index;#Delta t", kGlobalIndexRange, 0, kGlobalIndexRange, 1000, -50, 50, kFineRange, 0, kFineRange );
331 TH3_Type* hFine_Check_TRaw_Phas = new TH3_Type("hFine_Check_Tune", ";index;#Delta t", kGlobalIndexRange, 0, kGlobalIndexRange, 1000, -50, 50, 400, -2, +2 );
332 TH3_Type* hFine_Check_TRaw_Fine = new TH3_Type("hFine_Check_Raw_", ";index;#Delta t", kGlobalIndexRange, 0, kGlobalIndexRange, 1000, -50, 50, kFineRange, 0, kFineRange );
334 system(Form("mkdir -p %s/%s",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
335 kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_offset_rslt,kRunTag.Data()), "RECREATE" );
336 kFine_All_Tune_Params->Write();
337 hFine_Offset_All->Write();
338 kFileOut->Close();
340 for ( int iTer = 0; iTer < kMaximumOffsetCalibIteration; iTer++ ) {
341 break;
342 auto hFine_Offset_All_Memory = (TH2F*)hFine_Offset_All->Clone();
343 hFine_Offset_All->Reset();
344 for ( Int_t iIndex = kGlobalIndexTiming_Start; iIndex < kGlobalIndexTiming_End; iIndex++ ) {
346 raw_delta_fine_tune_offset( kRunTag, iIndex, *hFine_Offset_All);
347 auto hCurrentSlice = hFine_Offset_All->ProjectionY(Form("kOffsetTune_%i",iIndex),iIndex+1,iIndex+1);
349 auto kNewOffset = hCurrentSlice->GetMean() / coarse_to_ns;
350 auto kOldOffset = kFine_All_Tune_Params->GetBinContent(iIndex+1,6);
352 if ( ( fabs( kNewOffset - kOldOffset) < kEspilonOffsets ) && ( kNewOffset < kEspilonOffMean ) ) {}
353 set_fine_calibration_offset({kRunTag,iIndex}, kOldOffset + kNewOffset);
354 kFine_All_Tune_Params->SetBinContent(iIndex+1,6,kOldOffset + kNewOffset);
356 system(Form("mkdir -p %s/%s/OffsetCheck/",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
357 TCanvas* cPlotFit = new TCanvas();
358 gPad->SetLogy();
359 hCurrentSlice->GetXaxis()->SetRangeUser(-10,10);
360 hCurrentSlice->Draw();
361 cPlotFit->SaveAs(Form("%s/%s/OffsetCheck/OffsetCheck_%i_%i.pdf",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data(),iIndex,iTer));
362 delete cPlotFit;
363 }
364 set_fine_tune_raw_histogram(kRunTag,kFine_All_Tune_Params);
365 }
366 check_fine_tune_effect( kRunTag, hFine_Check_Tune_Phas, hFine_Check_Tune_Fine, hFine_Check_TRaw_Phas, hFine_Check_TRaw_Fine );
368 if ( kOutputFileName.Length() != 0 ) {
369 // system(Form("mkdir -p %s", kOutputFileName.Data())); //! TODO: Create folder (?)
370 kFileOut = new TFile( kOutputFileName, "RECREATE" );
371 kFine_All_Tune_Params->Write();
372 hFine_Offset_All->Write();
373 hFine_Check_Tune_Phas->Write();
374 hFine_Check_Tune_Fine->Write();
375 hFine_Check_TRaw_Phas->Write();
376 hFine_Check_TRaw_Fine->Write();
377 kFileOut->Close();
378 } else {
379 system(Form("mkdir -p %s/%s",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
380 kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_offset_rslt,kRunTag.Data()), "RECREATE" );
381 kFine_All_Tune_Params->Write();
382 hFine_Offset_All->Write();
383 hFine_Check_Tune_Phas->Write();
384 hFine_Check_Tune_Fine->Write();
385 hFine_Check_TRaw_Phas->Write();
386 hFine_Check_TRaw_Fine->Write();
387 kFileOut->Close();
388 }
390 gROOT->SetBatch(false);
391 return hFine_Offset_All;
392}
396kFineTuneParamsType
403template< typename TH2_Type = TH2F >
404TH2_Type*
405get_fine_tune_parameters
406 ( TString kRunTag ) {
408 run_fine_tune_analysis ( kRunTag, "", "", false );
409 run_fine_tune_offset_analysis ( kRunTag, "", "", false );
411 TFile* kFileOut = new TFile( Form (output_preprocess_fine_analysis_file_offset_rslt,kRunTag.Data()) );
412 return (TH2F*)(kFileOut->Get("kFine_All_Tune_Params"));
413}
415template< typename TH2_Type = TH2F >
416TH2_Type*
423void
433void
434set_fine_analysis_fit_function
435 ( TH1D* histo, int riseThreshold =1, int dropThreshold =1, int max_step = -3, int min_step = 3) {
436 double guess = histo->GetBinContent(70);
437 dropThreshold = 0.25*guess;
438 riseThreshold = 0.25*guess;
439 double max = get_fit_bump(histo, dropThreshold, max_step);
440 double min = get_fit_bump(histo, riseThreshold, min_step);
441 double height = histo->GetBinContent((int)(0.5*(max+min)));
442 double minguess = histo->GetBinCenter(min);
443 double maxguess = histo->GetBinCenter(max);
444 // Set Parameter 0
445 fine_analysis_fit_function->SetParLimits(0, height*0.7, height*1.3);
446 fine_analysis_fit_function->SetParameter(0, height );
447 // Set Parameter 1
448 fine_analysis_fit_function->SetParLimits(1, maxguess*0.7, maxguess*1.3);
449 fine_analysis_fit_function->SetParameter(1, maxguess);
450 // Set Parameter 2
451 fine_analysis_fit_function->SetParLimits(2, 0, 1.);
452 fine_analysis_fit_function->SetParameter(2, 0.4);
453 // Set Parameter 3
454 fine_analysis_fit_function->SetParLimits(3, minguess*0.7, minguess*1.3);
455 fine_analysis_fit_function->SetParameter(3, minguess);
456 // Set Parameter 4
457 fine_analysis_fit_function->SetParLimits(4, 0, 1.);
458 fine_analysis_fit_function->SetParameter(4, 0.4);
459}
463double
484template< typename TH1_Type = TH1F >
485int
486get_fit_bump
487( TH1_Type* histo, double critical_value, int bin_step ) {
488 if ( bin_step > 0 ) {
489 for ( int j=1; j<=histo->GetNbinsX()-bin_step; j+=bin_step ) {
490 double y1 = histo->GetBinContent(j);
491 double y2 = histo->GetBinContent(j+bin_step);
492 if ( fabs(y1-y2) > critical_value ){
493 return (int)(j+bin_step*0.5);
494 }
495 }
496 } else if ( bin_step < 0 ) {
497 for ( int j=histo->GetNbinsX(); j>(-bin_step); j+=bin_step ) {
498 double y1 = histo->GetBinContent(j);
499 double y2 = histo->GetBinContent(j+bin_step);
500 if ( fabs(y1-y2) > critical_value ){
501 return (int)(j+bin_step*0.5);
502 }
503 }
504 }
505 return -1;
506}
510template< typename TH3_Type = TH3F >
511void
512check_fine_tune_effect
513( TString kRunTag, TH3_Type& hFine_Check_Tune_Phas, TH3_Type& hFine_Check_Tune_Fine, TH3_Type& hFine_Check_TRaw_Phas, TH3_Type& hFine_Check_TRaw_Fine ) {
515 gROOT->SetBatch();
516 framed_data_t framed_data;
517 while ( populate_framed_data( framed_data, Form(intput_rawdata_decoded_file_dir,kRunTag.Data()), timing_filenames, frame_size ) ) {
518 for ( auto &spill_data : framed_data ) {
519 auto spill = spill_data.first;
520 auto &frames = spill_data.second;
521 for (auto &frame_data : frames) {
522 kIgnoreFix = false;
523 auto frame = frame_data.first;
524 auto &chips = frame_data.second;
525 double average_time[6] = {0.};
526 for (auto &chip_data : chips) {
527 auto kNormalisation = 0;
528 auto chip = chip_data.first;
529 if ( chip < 4 ) continue;
530 auto &channels = chip_data.second;
531 for (auto &channel_data : channels) {
532 auto channel = channel_data.first;
533 auto &hits = channel_data.second;
535 auto &hit = hits[0];
536 double phase = calculate_calibrated_phase( hit.fine, kRunTag, get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc ) );
537 if ( phase <= -9.9 ) continue;
538 double time = hit.coarse * coarse_to_ns + hit.rollover * rollover_to_ns - phase * coarse_to_ns; // [ns]
539 average_time[chip] += time;
540 kNormalisation++;
541 }
542 if (channels.size() > 0) average_time[chip] /= kNormalisation;
543 }
544 if ( chips[4].size() != 32 || chips[5].size() != 32 ) continue;
545 auto delta = average_time[4] - average_time[5];
546 if ( fabs(delta) > 5. ) continue;
547 auto reference = 0.5 * ( average_time[4] + average_time[5] ); // [ns]
549 kIgnoreFix = true;
550 for (auto &chip_data : chips) {
551 auto kNormalisation = 0;
552 auto chip = chip_data.first;
553 auto &channels = chip_data.second;
554 for (auto &channel_data : channels) {
555 auto channel = channel_data.first;
556 auto &hits = channel_data.second;
558 auto &hit = hits[0];
559 auto global_index = get_global_index( hit.fifo, hit.pixel, hit.column, hit.tdc );
560 double phase = calculate_calibrated_phase( hit.fine, kRunTag, global_index );
561 double calib_time = hit.coarse * coarse_to_ns + hit.rollover * rollover_to_ns - phase * coarse_to_ns; // [ns]
562 double uncal_time = hit.coarse * coarse_to_ns + hit.rollover * rollover_to_ns; // [ns]
563 hFine_Check_Tune_Phas->Fill( global_index, calib_time-reference, phase );
564 hFine_Check_Tune_Fine->Fill( global_index, calib_time-reference, hit.fine );
565 hFine_Check_TRaw_Phas->Fill( global_index, uncal_time-reference, phase );
566 hFine_Check_TRaw_Fine->Fill( global_index, uncal_time-reference, hit.fine );
567 }
568 }
569 }
570 }
571 }
572 system(Form("mkdir -p %s/%s/TDC_FineTune_Check/",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data()));
573 for ( Int_t iIndex = 512; iIndex < kGlobalIndexRange; iIndex++ ) {
574 TCanvas* cPlotFit = new TCanvas();
575 cPlotFit->Divide(2,2);
576 cPlotFit->cd(1);
577 gStyle->SetOptStat(0);
578 hFine_Check_Tune_Fine->GetXaxis()->SetRange(iIndex+1,iIndex+1);
579 auto hTune_Fine = hFine_Check_Tune_Fine->Project3DProfile("yz");
580 hTune_Fine->SetTitle("t_{i}-t_{ref} both tuned vs fine par.");
581 hTune_Fine->GetYaxis()->SetTitle("t_{i}-t_{ref} (ns)");
582 hTune_Fine->GetXaxis()->SetTitle("fine par. a.u.");
583 hTune_Fine->Draw("COLZ");
584 cPlotFit->cd(2);
585 gStyle->SetOptStat(0);
586 hFine_Check_Tune_Phas->GetXaxis()->SetRange(iIndex+1,iIndex+1);
587 auto hTune_Phas = hFine_Check_Tune_Phas->Project3DProfile("yz");
588 hTune_Phas->SetTitle("t_{i}-t_{ref} both tuned vs calib. phase");
589 hTune_Phas->GetYaxis()->SetTitle("t_{i}-t_{ref} (ns)");
590 hTune_Phas->GetXaxis()->SetTitle("phase a.u.");
591 hTune_Phas->Draw("COLZ");
592 cPlotFit->cd(3);
593 gStyle->SetOptStat(0);
594 hFine_Check_TRaw_Fine->GetXaxis()->SetRange(iIndex+1,iIndex+1);
595 auto hTRaw_Fine = hFine_Check_TRaw_Fine->Project3DProfile("yz");
596 hTRaw_Fine->SetTitle("t_{i}-t_{ref} only ref tuned vs fine par.");
597 hTRaw_Fine->GetYaxis()->SetTitle("t_{i}-t_{ref} (ns)");
598 hTRaw_Fine->GetXaxis()->SetTitle("fine par. a.u.");
599 hTRaw_Fine->Draw("COLZ");
600 cPlotFit->cd(4);
601 gStyle->SetOptStat(0);
602 hFine_Check_TRaw_Phas->GetXaxis()->SetRange(iIndex+1,iIndex+1);
603 auto hTRaw_Phas = hFine_Check_TRaw_Phas->Project3DProfile("yz");
604 hTRaw_Phas->SetTitle("t_{i}-t_{ref} only ref tuned vs calib. phase");
605 hTRaw_Phas->GetYaxis()->SetTitle("t_{i}-t_{ref} (ns)");
606 hTRaw_Phas->GetXaxis()->SetTitle("phase a.u.");
607 hTRaw_Phas->Draw("COLZ");
609 cPlotFit->SaveAs(Form("%s/%s/TDC_FineTune_Check/TDC%i.pdf",output_preprocess_fine_analysis_directory.Data(),kRunTag.Data(),iIndex));
610 delete cPlotFit;
611 }
612 hFine_Check_Tune_Fine->GetXaxis()->SetRange(-1,-1);
613 hFine_Check_Tune_Phas->GetXaxis()->SetRange(-1,-1);
614 hFine_Check_TRaw_Fine->GetXaxis()->SetRange(-1,-1);
615 hFine_Check_TRaw_Phas->GetXaxis()->SetRange(-1,-1);
616 gROOT->SetBatch(false);
617}
619#endif
analysis_utils.h
set_fine_calibration
void set_fine_calibration(global_identifier_t kFilters, double kCalibrationMin, double kCalibrationMax, double kCalibrationOffset)
Definition fine_analysis.h:55
build_fine_tune_raw_histogram
TH2_Type * build_fine_tune_raw_histogram(std::vector< TString > kInputFileNames, TString kRunTag, TString kOutputFileName, bool kRecalculate)
Functions -------------------------------------------------------------------------------------------...
Definition fine_analysis.h:80
output_preprocess_fine_analysis_file_rslt
const TString output_preprocess_fine_analysis_file_rslt
Definition fine_analysis.h:28
run_fine_tune_analysis
TH2_Type * run_fine_tune_analysis(TString kRunTag, TString kOutputFileName, TString kOutputGraphics, bool kRecalculate)
Definition fine_analysis.h:142
output_preprocess_fine_analysis_file_offset_rslt
const TString output_preprocess_fine_analysis_file_offset_rslt
Definition fine_analysis.h:30
kFineTuneParameters
std::map< global_identifier_t, kFineTuneParamsType > kFineTuneParameters
Definition fine_analysis.h:17
get_fine_calibration_offset
double get_fine_calibration_offset(global_identifier_t kFilters)
Definition fine_analysis.h:49
kFineTuneRawHistograms
std::map< TString, TH2F * > kFineTuneRawHistograms
Definition fine_analysis.h:18
check_fine_tune_effect
void check_fine_tune_effect(TString kRunTag, TH3_Type &hFine_Check_Tune_Phas, TH3_Type &hFine_Check_Tune_Fine, TH3_Type &hFine_Check_TRaw_Phas, TH3_Type &hFine_Check_TRaw_Fine)
NEW THINGS TO INTEGRATE ------—.
Definition fine_analysis.h:513
run_fine_tune_offset_analysis
TH2_Type * run_fine_tune_offset_analysis(TString kRunTag, TString kOutputFileName, TString kOutputGraphics, bool kRecalculate)
Definition fine_analysis.h:316
output_preprocess_fine_analysis_directory
const TString output_preprocess_fine_analysis_directory
Definition fine_analysis.h:26
raw_delta_fine_tune_offset
void raw_delta_fine_tune_offset(TString kRunTag, int kGlobalIndex, TH2F &hFine_Offset_All)
Definition fine_analysis.h:252
kEspilonOffMean
const float kEspilonOffMean
Definition fine_analysis.h:25
get_fit_bump
int get_fit_bump(TH1_Type *histo, double critical_value, int bin_step)
@Chiara Fraticelli
Definition fine_analysis.h:487
fine_analysis_fit_function
TF1 * fine_analysis_fit_function
Definition fine_analysis.h:33
get_fine_calibration_max
double get_fine_calibration_max(global_identifier_t kFilters)
Definition fine_analysis.h:48
output_preprocess_fine_analysis_file_offset_raw
const TString output_preprocess_fine_analysis_file_offset_raw
Definition fine_analysis.h:29
output_preprocess_fine_analysis_file_check
const TString output_preprocess_fine_analysis_file_check
Definition fine_analysis.h:31
get_fine_tune_parameters
TH2_Type * get_fine_tune_parameters(TString kRunTag)
Get stored fine tune parameters from calibration file.
Definition fine_analysis.h:406
calculate_calibrated_phase
double calculate_calibrated_phase(int kFineParameter, double kCalibrationMin, double kCalibrationMax, double kCalibrationOffset)
— — Calibration function
Definition fine_analysis.h:465
set_fine_calibration_offset
void set_fine_calibration_offset(global_identifier_t kFilters, double kCalibrationOffset)
Definition fine_analysis.h:58
set_fine_analysis_fit_function
void set_fine_analysis_fit_function(TH1D *histo, int riseThreshold=1, int dropThreshold=1, int max_step=-3, int min_step=3)
@Chiara Fraticelli
Definition fine_analysis.h:435
kFineTuneParamsType
std::tuple< double, double, double > kFineTuneParamsType
Data Structures -------------------------------------------------------------------------------------...
Definition fine_analysis.h:16
kEspilonOffsets
const float kEspilonOffsets
Definition fine_analysis.h:24
set_fine_tune_raw_histogram
void set_fine_tune_raw_histogram(TString kRunTag, TH2_Type *kFineTuneRawHistogram)
Definition fine_analysis.h:62
kIgnoreFix
bool kIgnoreFix
Variables -------------------------------------------------------------------------------------------...
Definition fine_analysis.h:22
output_preprocess_fine_analysis_graphics_dir
const TString output_preprocess_fine_analysis_graphics_dir
Definition fine_analysis.h:32
kMaximumOffsetCalibIteration
const int kMaximumOffsetCalibIteration
Definition fine_analysis.h:23
get_fine_tune_raw_histogram
TH2_Type * get_fine_tune_raw_histogram(TString kRunTag)
Get the raw histograms for calibration.
Definition fine_analysis.h:418
set_fine_calibration_max
void set_fine_calibration_max(global_identifier_t kFilters, double kCalibrationMax)
Definition fine_analysis.h:57
get_fine_calibration
kFineTuneParamsType get_fine_calibration(global_identifier_t kFilters)
— — Getter & Setters
Definition fine_analysis.h:398
set_fine_calibration_min
void set_fine_calibration_min(global_identifier_t kFilters, double kCalibrationMin)
Definition fine_analysis.h:56
get_fine_calibration_min
double get_fine_calibration_min(global_identifier_t kFilters)
Definition fine_analysis.h:47
output_preprocess_fine_analysis_file_raw
const TString output_preprocess_fine_analysis_file_raw
Definition fine_analysis.h:27
analysis_utils
Definition analysis_utils.h:20
analysis_utils::timing_filenames
std::vector< std::string > timing_filenames
Definition analysis_utils.h:83
analysis_utils::frame_size
const int frame_size
Variables -------------------------------------------------------------------------------------------...
Definition analysis_utils.h:53
analysis_utils::get_dochannel
int get_dochannel(int pixel, int column)
— Implementation — — Getter & Setters
Definition analysis_utils.h:121
analysis_utils::output_preprocess_directory
const TString output_preprocess_directory
Definition analysis_utils.h:63
analysis_utils::load_tree
void load_tree(TTree *kInputTree, data_t &kReadData)
Definition analysis_utils.h:178
analysis_utils::populate_framed_data
bool populate_framed_data(framed_data_t &framed_data, std::string dirname, std::vector< std::string > filenames=all_filenames, int frame_size=1024)
Definition analysis_utils.h:192
analysis_utils::get_full_info
std::tuple< Int_t, Int_t, Int_t, Int_t > get_full_info(Int_t iIndex)
Definition analysis_utils.h:158
analysis_utils::kGlobalIndexTiming_End
const Int_t kGlobalIndexTiming_End
Definition analysis_utils.h:56
analysis_utils::intput_rawdata_decoded_file_dir
const TString intput_rawdata_decoded_file_dir
Definition analysis_utils.h:61
analysis_utils::kGlobalIndexRange
const Int_t kGlobalIndexRange
Definition analysis_utils.h:54
analysis_utils::kFineRange
const Int_t kFineRange
— Finetune analysis
Definition analysis_utils.h:59
analysis_utils::rollover_to_ns
const double rollover_to_ns
Definition analysis_utils.h:73
analysis_utils::get_global_index
int get_global_index(int fifo, int pixel, int column, int tdc, bool kUseFIFO=true)
Definition analysis_utils.h:138
analysis_utils::intput_rawdata_decoded_file
const TString intput_rawdata_decoded_file
Definition analysis_utils.h:62
analysis_utils::coarse_to_ns
const double coarse_to_ns
Definition analysis_utils.h:68
analysis_utils::global_identifier_t
std::tuple< TString, int > global_identifier_t
Definition analysis_utils.h:49
analysis_utils::framed_data_t
std::map< int, spill_data_t > framed_data_t
Definition analysis_utils.h:48
analysis_utils::kGlobalIndexTiming_Start
const Int_t kGlobalIndexTiming_Start
Definition analysis_utils.h:55
analysis_utils::data_t
Data Structures — ALCOR output structure.
Definition analysis_utils.h:23
analysis_utils::data_t::fifo
int fifo
Definition analysis_utils.h:24
analysis_utils::data_t::pixel
int pixel
Definition analysis_utils.h:28
analysis_utils::data_t::column
int column
Definition analysis_utils.h:27
analysis_utils::data_t::tdc
int tdc
Definition analysis_utils.h:29
analysis_utils::data_t::fine
int fine
Definition analysis_utils.h:32