Belle II Software development
Public Member Functions | Private Attributes | List of all members
TrgEclDigitizer Class Reference
Packages » trg

FAM module
More...

#include <TrgEclDigitizer.h>

Inheritance diagram for TrgEclDigitizer:

Public Member Functions

 TrgEclDigitizer ()
 Constructor.
 
virtual ~TrgEclDigitizer ()
 Destructor.
 
void setup (int)
 setup fam module

 
void getTCHit (int)
 get TC Hits from Xtal hits
 
void digitization01 (std::vector< std::vector< double > > &, std::vector< std::vector< double > > &)
 fit method, digi with 125ns interval
 
void digitization02 (std::vector< std::vector< double > > &, std::vector< std::vector< double > > &)
 original no fit method, digi with 12ns interval
 
void save (int)
 save fitting result into tables
 
void setWaveform (int wave)
 Set flag of waveform table.
 
void setFADC (int fadc)
 Set flag of waveform table.
 
double FADC (int, double)
 FADC

 
double SimplifiedFADC (int, double)
 FADC.
 
double interFADC (double)
 Faster FADC using interpolation.
 
double ShapeF (double, double, double, double, double, double, double)
 return shape using FADC function

 
double ShapeF (double, double)
 Return shape using Simplified FADC.
 
double u_max (double, double)
 Find max value between 2 vals;.
 

Private Attributes

double TimeRange
 time range(default : -4000 ~ 4000 ns )
 
double TCEnergy [576][80]
 TC Energy converted from Xtarl Energy [GeV].
 
double TCTiming [576][80]
 TC Timing converted from Xtarl Timing [GeV].
 
double TCEnergy_tot [576]
 TC Energy converted from Xtarl Energy [GeV].
 
double TCTiming_tot [576]
 TC Timing converted from Xtarl Timing [GeV].
 
double TCRawEnergy [576][60]
 Input TC energy[GeV].
 
double TCRawTiming [576][60]
 Input TC timing[ns]

 
double TCRawBkgTag [576][60]
 Input Beambackground tag

 
TrgEclMapping * _TCMap
 Object of TC Mapping.
 
TrgEclDataBase * _DataBase
 Object of DataBase.
 
std::vector< std::vector< double > > MatrixParallel
 Noise Matrix of Parallel and Serial Noise.
 
std::vector< std::vector< double > > MatrixSerial
 Noise Low triangle Matrix of Serial noise

 
double TCBkgContribution [576][80]
 Beambackground contribution.
 
double TCSigContribution [576][80]
 Signal contribution.
 
int TCBeambkgTag [576][80]
 Beambackground tag.
 
int _waveform
 Flag of waveform table.
 
double WaveForm [576][64]
 TC Energy converted from Xtarl Energy [GeV].
 
int _FADC
 Flag of choosing the method of waveform generation function 0: use simplifiedFADC, 1: use interFADC(interpolation)
 
int _BeambkgTag
 Flag of saving beam background tag or not.
 

Detailed Description

FAM module

Definition at line 24 of file TrgEclDigitizer.h.

Constructor & Destructor Documentation

◆ TrgEclDigitizer()

TrgEclDigitizer ( )

Constructor.

Definition at line 32 of file TrgEclDigitizer.cc.

32 :
33 TimeRange(0), _waveform(0), _FADC(1), _BeambkgTag(0)
34{
35 MatrixParallel.clear();
36 MatrixSerial.clear();
37
38 _TCMap = new TrgEclMapping();
39 _DataBase = new TrgEclDataBase();
40
41 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
42 TCEnergy_tot[iTCIdm] = 0;
43 TCTiming_tot[iTCIdm] = 0;
44 for (int iTime = 0; iTime < 80; iTime++) {
45 TCEnergy[iTCIdm][iTime] = 0;
46 TCTiming[iTCIdm][iTime] = 0;
47 TCBkgContribution[iTCIdm][iTime] = 0;
48 TCSigContribution[iTCIdm][iTime] = 0;
49 TCBeambkgTag[iTCIdm][iTime] = 0;
50 }
51
52 for (int iii = 0; iii < 60 ; iii++) {
53 TCRawEnergy[iTCIdm][iii] = 0;
54 TCRawTiming[iTCIdm][iii] = 0;
55 TCRawBkgTag[iTCIdm][iii] = 0;
56 }
57 for (int iii = 0; iii < 64 ; iii++) {
58 WaveForm[iTCIdm][iii] = 0;
59 }
60 }
61}
Belle2::TrgEclDataBase
class TrgEclDataBase;
Definition: TrgEclDataBase.h:20
Belle2::TrgEclDigitizer::_FADC
int _FADC
Flag of choosing the method of waveform generation function 0: use simplifiedFADC,...
Definition: TrgEclDigitizer.h:110
Belle2::TrgEclDigitizer::TCTiming_tot
double TCTiming_tot[576]
TC Timing converted from Xtarl Timing [GeV].
Definition: TrgEclDigitizer.h:75
Belle2::TrgEclDigitizer::TCBkgContribution
double TCBkgContribution[576][80]
Beambackground contribution.
Definition: TrgEclDigitizer.h:100
Belle2::TrgEclDigitizer::WaveForm
double WaveForm[576][64]
TC Energy converted from Xtarl Energy [GeV].
Definition: TrgEclDigitizer.h:108
Belle2::TrgEclDigitizer::TCRawTiming
double TCRawTiming[576][60]
Input TC timing[ns]
Definition: TrgEclDigitizer.h:85
Belle2::TrgEclDigitizer::TCEnergy
double TCEnergy[576][80]
TC Energy converted from Xtarl Energy [GeV].
Definition: TrgEclDigitizer.h:69
Belle2::TrgEclDigitizer::TCSigContribution
double TCSigContribution[576][80]
Signal contribution.
Definition: TrgEclDigitizer.h:102
Belle2::TrgEclDigitizer::MatrixParallel
std::vector< std::vector< double > > MatrixParallel
Noise Matrix of Parallel and Serial Noise.
Definition: TrgEclDigitizer.h:96
Belle2::TrgEclDigitizer::_DataBase
TrgEclDataBase * _DataBase
Object of DataBase.
Definition: TrgEclDigitizer.h:92
Belle2::TrgEclDigitizer::TCTiming
double TCTiming[576][80]
TC Timing converted from Xtarl Timing [GeV].
Definition: TrgEclDigitizer.h:71
Belle2::TrgEclDigitizer::TCRawBkgTag
double TCRawBkgTag[576][60]
Input Beambackground tag
Definition: TrgEclDigitizer.h:87
Belle2::TrgEclDigitizer::MatrixSerial
std::vector< std::vector< double > > MatrixSerial
Noise Low triangle Matrix of Serial noise
Definition: TrgEclDigitizer.h:98
Belle2::TrgEclDigitizer::TCRawEnergy
double TCRawEnergy[576][60]
Input TC energy[GeV].
Definition: TrgEclDigitizer.h:83
Belle2::TrgEclDigitizer::TimeRange
double TimeRange
time range(default : -4000 ~ 4000 ns )
Definition: TrgEclDigitizer.h:67
Belle2::TrgEclDigitizer::_BeambkgTag
int _BeambkgTag
Flag of saving beam background tag or not.
Definition: TrgEclDigitizer.h:112
Belle2::TrgEclDigitizer::_waveform
int _waveform
Flag of waveform table.
Definition: TrgEclDigitizer.h:106
Belle2::TrgEclDigitizer::TCBeambkgTag
int TCBeambkgTag[576][80]
Beambackground tag.
Definition: TrgEclDigitizer.h:104
Belle2::TrgEclDigitizer::_TCMap
TrgEclMapping * _TCMap
Object of TC Mapping.
Definition: TrgEclDigitizer.h:90
Belle2::TrgEclDigitizer::TCEnergy_tot
double TCEnergy_tot[576]
TC Energy converted from Xtarl Energy [GeV].
Definition: TrgEclDigitizer.h:73
Belle2::TrgEclMapping
A class of TC Mapping.
Definition: TrgEclMapping.h:26

◆ ~TrgEclDigitizer()

~TrgEclDigitizer ( )
virtual

Destructor.

Definition at line 65 of file TrgEclDigitizer.cc.

66{
67 delete _TCMap;
68 delete _DataBase;
69}

Member Function Documentation

◆ digitization01()

void digitization01 ( std::vector< std::vector< double > > &  TCDigiE,
std::vector< std::vector< double > > &  TCDigiT 
)

fit method, digi with 125ns interval

Definition at line 317 of file TrgEclDigitizer.cc.

319{
320 TCDigiE.clear();
321 TCDigiE.resize(576, vector<double>(64, 0));
322 TCDigiT.clear();
323 TCDigiT.resize(576, vector<double>(64, 0));
324
325 //
326 double cut_energy_tot = 0.03; // [GeV]
327 int nbin_pedestal = 4; // = nbin_pedestal*fam_sampling_interval [ns] in total
328 double fam_sampling_interval = 125; // [ns]
329 int NSampling = 64; // # of sampling array
330
331
332 std::vector< std::vector<float> > noise_pileup(576, std::vector<float>(64, 0.0)); // [GeV]
333 std::vector< std::vector<float> > noise_parallel(576, std::vector<float>(64, 0.0)); // [GeV]
334 std::vector< std::vector<float> > noise_serial(576, std::vector<float>(64, 0.0)); // [GeV]
335 std::vector<float> X_pr(64, 0.0);
336 std::vector<float> X_sr(64, 0.0);
337
338
339 // (Make sampling time random between FAM sampling intervals)
340 double random_sampling_correction = 0; // [ns]
341 random_sampling_correction = gRandom->Rndm() * fam_sampling_interval;
342 //==================
343 // (01)Signal digitization
344 //==================
345 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
346 for (int iTimeBin = 0; iTimeBin < 80; iTimeBin++) {
347
348 if (TCEnergy[iTCIdm][iTimeBin] < 0.0001) {continue;} // 0.1MeV cut on TC bin_energy
349 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
350 // inputTiming is in [us] <-- Be careful, here is NOT [ns]
351 double inputTiming
352 = (-TCTiming[iTCIdm][iTimeBin] - TimeRange + (-nbin_pedestal + iSampling) * fam_sampling_interval) * 0.001;
353 inputTiming += random_sampling_correction * 0.001;
354 if (inputTiming < 0 || inputTiming > 2.0) {continue;} // Shaping in t0 ~t0+ 2.0 us
355 if (_FADC == 1) {
356
357 TCDigiE[iTCIdm][iSampling] += interFADC(inputTiming) * TCEnergy[iTCIdm][iTimeBin];
358 } else {
359 TCDigiE[iTCIdm][iSampling] += SimplifiedFADC(0, inputTiming) * TCEnergy[iTCIdm][iTimeBin];
360 }
361 }
362
363 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
364 TCDigiT[iTCIdm][iSampling] = (-nbin_pedestal + iSampling - TimeRange / fam_sampling_interval) * fam_sampling_interval;
365 TCDigiT[iTCIdm][iSampling] += random_sampling_correction;
366 }
367 }
368 }
369 //
370 //
371 //
372 if (0) {
373 FILE* f_out_dat = fopen("ztsim.no_noise.dat", "w");
374 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
375 if (TCEnergy_tot[iTCIdm] < cut_energy_tot) { continue; } // TC energy_tot cut
376 fprintf(f_out_dat, "%5i %8.5f %8.5f %8.1f ",
377 iTCIdm + 1, TCEnergy_tot[iTCIdm], TCEnergy[iTCIdm][0], TCDigiT[iTCIdm][0]);
378 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
379 fprintf(f_out_dat, "%7.4f ", TCDigiE[iTCIdm][iSampling]);
380 }
381 fprintf(f_out_dat, "\n");
382 }
383 fclose(f_out_dat);
384 }
385 //==================
386 // (01)noise embedding
387 //==================
388 double tmin_noise = -4; // orignal
389 double tgen = 10.3; // orignal
390 int bkg_level = 1030;
391 double ttt0 = 0; // [us]
392 /* cppcheck-suppress variableScope */
393 double ttt1 = 0; // [us]
394 /* cppcheck-suppress variableScope */
395 double ttt2 = 0; // [us]
396 //
397 double frac_pileup = 0.035; // pileup noise fraction?
398 double frac_parallel = 0.023; // parralel noise fraction?
399 double frac_serial = 0.055; // serial noise fraction?
400 double times_pileup = 1; // noise scale based on Belle noise.
401 double times_parallel = 3.15; // noise scale
402 double times_serial = 3.15; // noise scale
403
404 double corr_pileup = times_pileup * frac_pileup * sqrt(fam_sampling_interval * 0.001);
405 double corr_parallel = times_parallel * frac_parallel * sqrt(fam_sampling_interval * 0.001);
406 double corr_serial = times_serial * frac_serial * sqrt(fam_sampling_interval * 0.001);
407
408
409 if (0) {
410 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
411 if (TCEnergy_tot[iTCIdm] < cut_energy_tot) { continue; } // TC energy_tot cut
412 for (int jjj = 0; jjj < bkg_level; jjj++) {
413 ttt0 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
414 ttt1 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
415 ttt2 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
416 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
417 // (pile-up noise)
418 if (ttt0 > 0) { TCDigiE[iTCIdm][iSampling] += SimplifiedFADC(0, ttt0) * corr_pileup * 0.001; }
419 // (parallel noise)
420 if (ttt1 > 0) { TCDigiE[iTCIdm][iSampling] += SimplifiedFADC(1, ttt1) * corr_parallel; }
421 // (serial noise)
422 if (ttt2 > 0) { TCDigiE[iTCIdm][iSampling] += SimplifiedFADC(2, ttt2) * corr_serial; }
423 ttt0 += fam_sampling_interval * 0.001;
424 ttt1 += fam_sampling_interval * 0.001;
425 ttt2 += fam_sampling_interval * 0.001;
426 }
427 }
428 }
429 }
430 if (1) { //use L Matrix
431 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
432
433 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
434 X_pr[iSampling] = gRandom ->Gaus(0, 1);
435 X_sr[iSampling] = gRandom ->Gaus(0, 1);
436 }
437
438 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
439 for (int jSampling = 0; jSampling < NSampling; jSampling++) {
440 noise_parallel[iTCIdm][iSampling] += 10 * corr_parallel * MatrixParallel[iSampling][jSampling] * X_pr[jSampling];
441 noise_serial[iTCIdm][iSampling] += 10 * corr_serial * MatrixSerial[iSampling][jSampling] * X_sr[jSampling];
442 }
443 }
444
445 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
446
447 TCDigiE[iTCIdm][iSampling] += noise_pileup[iTCIdm][iSampling] + noise_parallel[iTCIdm][iSampling] +
448 noise_serial[iTCIdm][iSampling];
449 }
450 }
451 if (0) {
452 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) { //Only Pile-up noise use old method.
453 if (TCEnergy_tot[iTCIdm] < cut_energy_tot) { continue; } // TC energy_tot cut
454 for (int jjj = 0; jjj < bkg_level; jjj++) {
455 ttt0 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
456 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
457 // (pile-up noise)
458 if (ttt0 > 0) { TCDigiE[iTCIdm][iSampling] += SimplifiedFADC(0, ttt0) * corr_pileup * 0.001; }
459 ttt0 += fam_sampling_interval * 0.001;
460 }
461 }
462 }
463 }
464 }
465
466 if (_waveform == 1) {
467
468 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
469 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
470 WaveForm[iTCIdm][iSampling] = TCDigiE[iTCIdm][iSampling];
471 }
472
473 }
474 }
475
476}
Belle2::TrgEclDigitizer::interFADC
double interFADC(double)
Faster FADC using interpolation.
Definition: TrgEclDigitizer.cc:609
Belle2::TrgEclDigitizer::SimplifiedFADC
double SimplifiedFADC(int, double)
FADC.
Definition: TrgEclDigitizer.cc:837
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28

◆ digitization02()

void digitization02 ( std::vector< std::vector< double > > &  TCDigiE,
std::vector< std::vector< double > > &  TCDigiT 
)

original no fit method, digi with 12ns interval

Definition at line 478 of file TrgEclDigitizer.cc.

479{
480 //===============
481 // (03)Signal digitization (w/ 12ns interval for method-0)
482 //===============
483 TCDigiE.clear();
484 TCDigiE.resize(576, vector<double>(666, 0));
485 TCDigiT.clear();
486 TCDigiT.resize(576, vector<double>(666, 0));
487 double cut_energy_tot = 0.03; // [GeV]
488 int nbin_pedestal = 100;
489 float fam_sampling_interval = 12; // [ns]
490
491 std::vector< std::vector<float> > TCDigiEnergy(576, std::vector<float>(666, 0.0)); // [GeV]
492 std::vector< std::vector<float> > TCDigiTiming(576, std::vector<float>(666, 0.0)); // [ns]
493 int NSampling = 666;
494
495 // Make sampling time random between FAM sampling intervals
496 float random_sampling_correction = 0; // [ns]
497 random_sampling_correction = gRandom->Rndm() * fam_sampling_interval;
498 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
499 if (TCEnergy_tot[iTCIdm] < cut_energy_tot) {continue;} // TC energy_tot cut
500 for (int iTimeBin = 0; iTimeBin < 80; iTimeBin++) {
501 if (TCEnergy[iTCIdm][iTimeBin] < 0.0001) { continue; } // 0.1 MeV cut on TC bin_energy
502 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
503 // inputTiming is in [us] <-- Be careful, here is NOT [ns]
504 float inputTiming
505 = (-TCTiming[iTCIdm][iTimeBin] - TimeRange + (-nbin_pedestal + iSampling) * fam_sampling_interval) * 0.001;
506
507 inputTiming += random_sampling_correction * 0.001;
508 if (inputTiming < 0 || inputTiming > 2.0) {continue;} // Shaping in t0 ~t0+ 2.0 us
509
510 TCDigiEnergy[iTCIdm][iSampling] += FADC(0, inputTiming) * TCEnergy[iTCIdm][iTimeBin];
511 }
512 }
513 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
514 TCDigiTiming[iTCIdm][iSampling] = (-nbin_pedestal + iSampling - TimeRange / fam_sampling_interval) * fam_sampling_interval;
515 TCDigiTiming[iTCIdm][iSampling] += random_sampling_correction;
516 }
517 }
518 //==================
519 // (03)noise embedding
520 //==================
521
522 double tmin_noise = -4; // orignal
523 double tgen = 10.3; //
524 int bkg_level = 1030;
525 double ttt0 = 0; // [us]
526 double ttt1 = 0; // [us]
527 double ttt2 = 0; // [us]
528 //double frac_pileup = 0.035; // pileup noise fraction?
529 //double frac_parallel = 0.023; // parralel noise fraction?
530 //double frac_serial = 0.055; // serial noise fraction?
531 //double times_pileup = 1; // noise scale based on Belle noise.
532 //double times_parallel = 1; // noise scale
533 //double times_serial = 1; // noise scale
534 //double corr_pileup = times_pileup * frac_pileup * sqrt(fam_sampling_interval * 0.001);
535 //double corr_parallel = times_parallel * frac_parallel * sqrt(fam_sampling_interval * 0.001);
536 //double corr_serial = times_serial * frac_serial * sqrt(fam_sampling_interval * 0.001);
537 double corr_pileup = 0.011068;
538 double corr_parallel = 0.00727324;
539 double corr_serial = 0.0173925;
540
541
542 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
543 if (TCEnergy_tot[iTCIdm] < cut_energy_tot) { continue; } // 1 MeV TC energy cut
544 for (int jjj = 0; jjj < bkg_level; jjj++) {
545 ttt0 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
546 ttt1 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
547 ttt2 = -(tmin_noise + tgen * gRandom->Rndm()); // [us]
548 for (int iSampling = 0; iSampling < NSampling; iSampling++) {
549 // (pile-up noise)
550 if (ttt0 > 0) { TCDigiEnergy[iTCIdm][iSampling] += FADC(0, ttt0) * corr_pileup * 0.001; }
551 // (parallel noise)
552 if (ttt1 > 0) { TCDigiEnergy[iTCIdm][iSampling] += FADC(1, ttt1) * corr_parallel; }
553 // (serial noise)
554 if (ttt2 > 0) { TCDigiEnergy[iTCIdm][iSampling] += FADC(2, ttt2) * corr_serial; }
555 ttt0 += fam_sampling_interval * 0.001;
556 ttt1 += fam_sampling_interval * 0.001;
557 ttt2 += fam_sampling_interval * 0.001;
558 }
559 }
560 }
561
562}
Belle2::TrgEclDigitizer::FADC
double FADC(int, double)
FADC
Definition: TrgEclDigitizer.cc:646

◆ FADC()

double FADC ( int  flag_gen,
double  timing 
)

FADC

Definition at line 646 of file TrgEclDigitizer.cc.

648{
649
650 //--------------------------------------
651 //
652 // o "timing" unit is [us]
653 // o flag_gen = 0(=signal), 1(=parallel), 2(=serial)
654 // o return value(PDF) is [GeV]
655 //
656 //--------------------------------------
657 double tsh, dd;
658 static double tc, tc2, tsc, tris, b1, b2;
659 static double amp, dft, as;
660 static double td, t1, t2;
661
662 static int ifir = 0;
663
664 if (ifir == 0) {
665
666 td = 0.10; // diff time ( 0.10)
667 t1 = 0.10; // integ1 real ( 0.10)
668 b1 = 30.90; // integ1 imag ( 30.90)
669 t2 = 0.01; // integ2 real ( 0.01)
670 b2 = 30.01; // integ2 imag ( 30.01)
671 double ts = 1.00; // scint decay ( 1.00)
672 dft = 0.600; // diff delay ( 0.600)
673 as = 0.548; // diff frac ( 0.548)
674 //
675 amp = 1.0;
676 tris = 0.01;
677 tsc = ts;
678 //
679 int im = 0;
680 int ij = 0;
681 int fm = 0;
682 tc = 0;
683 double tt = u_max(u_max(td, t1), u_max(t2, ts)) * 2;
684 int flag_once = 0;
685 while (flag_once == 0) {
686 double tm = 0;
687 for (int j = 1; j <= 1000; j++) {
688 tc2 = tc - dft;
689 double fff =
690 (ShapeF(tc, t1, b1, t2, b2, td, tsc) -
691 ShapeF(tc, t1, b1, t2, b2, td, tris) * 0.01) -
692 (ShapeF(tc2, t1, b1, t2, b2, td, tsc) -
693 ShapeF(tc2, t1, b1, t2, b2, td, tris) * 0.01) * as;
694 if (fff > fm) {
695 fm = fff;
696 tm = tc;
697 im = j;
698 }
699 double dt = tt / 1000;
700 tc = tc + dt;
701 }
702 if (im >= 1000) {
703 tt = 2 * tt;
704 flag_once = 0;
705 continue;
706 }
707 if (ij == 0) {
708 ij = 1;
709 tc = 0.99 * tm;
710 flag_once = 0;
711 continue;
712 }
713 flag_once = 1;
714 }
715 amp = 1.0 / fm;
716 ifir = 1;
717 }
718 //
719 //
720 double pdf = 0;
721 if (flag_gen == 0) {
722 //-----<signal>
723 tc2 = timing - dft;
724 pdf = amp * (
725 (ShapeF(timing, t1, b1, t2, b2, td, tsc) -
726 ShapeF(timing, t1, b1, t2, b2, td, tris) * 0.01) -
727 (ShapeF(tc2, t1, b1, t2, b2, td, tsc) -
728 ShapeF(tc2, t1, b1, t2, b2, td, tris) * 0.01) * as);
729 } else if (flag_gen == 1) {
730 //-----<parallel>
731 tc2 = timing - dft;
732 tsh = 0.001;
733 pdf = amp * (
734 ShapeF(timing, t1, b1, t2, b2, td, tsh) -
735 ShapeF(tc2, t1, b1, t2, b2, td, tsh) * as);
736 pdf = pdf * 0.001; // GeV
737 } else {
738 //-----<serial>
739 tc2 = timing - dft;
740 tsh = 0.001;
741 pdf = amp * (
742 ShapeF(timing, t1, b1, t2, b2, td, tsh) -
743 ShapeF(tc2, t1, b1, t2, b2, td, tsh) * as);
744 //
745 tc = timing - 0.01;
746 if (tc < 0) { tc = 0; }
747 dd = timing - tc;
748 tc2 = tc - dft;
749 pdf = (amp * (
750 ShapeF(tc, t1, b1, t2, b2, td, tsh) -
751 ShapeF(tc2, t1, b1, t2, b2, td, tsh) * as) - pdf) / dd;
752 pdf = pdf * 0.001; // GeV
753 }
754
755 return pdf;
756}
Belle2::TrgEclDigitizer::u_max
double u_max(double, double)
Find max value between 2 vals;.
Definition: TrgEclDigitizer.cc:1027
Belle2::TrgEclDigitizer::ShapeF
double ShapeF(double, double, double, double, double, double, double)
return shape using FADC function
Definition: TrgEclDigitizer.cc:761

◆ getTCHit()

void getTCHit ( int  SourceOfTC)

get TC Hits from Xtal hits

Definition at line 92 of file TrgEclDigitizer.cc.

93{
94
95 std::vector< std::vector<float> > E_cell(8736, std::vector<float>(80, 0.0));
96 std::vector< std::vector<float> > T_ave(8736, std::vector<float>(80, 0.0));
97 std::vector< std::vector<float> > Tof_ave(8736, std::vector<float>(80, 0.0));
98 std::vector< std::vector<float> > beambkg_tag(8736, std::vector<float>(80, 0.0));
99
100 int nBinTime = 80;
101 TimeRange = 4000; // -4us ~ 4us
102 //-------------------------------------------------------------------
103 // read Xtal data
104 //---------------------------------------------------------------------
105 if (SourceOfTC == 1) { // read ECLHit table
106
107 StoreArray<ECLHit> eclHitArray("ECLHits");
108
109 int nHits_hit = eclHitArray.getEntries();
110 //
111 for (int iHits = 0; iHits < nHits_hit; iHits++) {
112 // Get a hit
113 ECLHit* aECLHit = eclHitArray[iHits];
114 int beambkg = aECLHit->getBackgroundTag();
115
116 // Hit geom. info
117 int hitCellId = aECLHit->getCellId() - 1;
118 float hitE = aECLHit->getEnergyDep() / Unit::GeV;
119 float aveT = aECLHit->getTimeAve(); // ns :time from IP to PD
120 if (aveT < - TimeRange || aveT > TimeRange) {continue;} //Choose - TimeRange ~ TimeTange
121 int TimeIndex = (int)((aveT + TimeRange) / 100); //Binning : -4000 = 1st bin ~ 4000 80th bin.
122
123 int iTCIdm = _TCMap->getTCIdFromXtalId(hitCellId + 1) - 1;
124 TCEnergy[iTCIdm][TimeIndex] += hitE;
125 TCTiming[iTCIdm][TimeIndex] += hitE * aveT;
126 if (beambkg > 0) {TCBkgContribution[iTCIdm][TimeIndex] += hitE ;}
127 else if (beambkg == 0) {TCSigContribution[iTCIdm][TimeIndex] += hitE;}
128
129 }
130 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
131 for (int iTime = 0; iTime < nBinTime; iTime++) {
132
133 if (TCEnergy[iTCIdm][iTime] < 1e-9) {continue;}// 0.01MeV cut
134 /* cppcheck-suppress variableScope */
135 double maxbkgE = 0;
136 /* cppcheck-suppress variableScope */
137 int maxbkgtag = 0;
138 TCTiming[iTCIdm][iTime] /= TCEnergy[iTCIdm][iTime];
139 if (_BeambkgTag == 1) {
140 if (TCBkgContribution[iTCIdm][iTime] < TCSigContribution[iTCIdm][iTime]) {
141 TCBeambkgTag[iTCIdm][iTime] = 0; //signal Tag : 0
142 } else {
143 for (int iXtalIdm = 0; iXtalIdm < 8736; iXtalIdm++) {
144 int iTCId = _TCMap->getTCIdFromXtalId(iXtalIdm + 1) - 1;
145 if (iTCIdm != iTCId) {continue;}
146 if (maxbkgE < E_cell[iXtalIdm][iTime]) {
147 maxbkgE = E_cell[iXtalIdm][iTime];
148 maxbkgtag = beambkg_tag[iXtalIdm][iTime];
149 }
150 }
151 TCBeambkgTag[iTCIdm][iTime] = maxbkgtag;
152 }
153 }
154 }
155 }
156 }
157
158
159 if (SourceOfTC == 2) { // read ECLSimHit
160 ECL::ECLGeometryPar* eclp = ECL::ECLGeometryPar::Instance();
161 //=====================
162 // Loop over all hits of steps
163 //=====================
164 StoreArray<ECLSimHit> eclArray("ECLSimHits");
165 int nHits = eclArray.getEntries();
166 //
167 for (int iHits = 0; iHits < nHits; iHits++) {
168 // Get a hit
169 ECLSimHit* aECLSimHit = eclArray[iHits];
170
171 int hitCellId = aECLSimHit->getCellId() - 1;
172 float hitE = aECLSimHit->getEnergyDep() / Unit::GeV;
173 float hitTOF = aECLSimHit->getFlightTime() / Unit::ns;
174
175 G4ThreeVector t = aECLSimHit->getPosIn(); // [cm], Hit position in Xtal (based on from IP)
176 ROOT::Math::XYZVector HitInPos(t.x(), t.y(), t.z()); // = aECLSimHit->getPosIn(); // [cm], Hit position in Xtal (based on from IP)
177 ROOT::Math::XYZVector PosCell = eclp->GetCrystalPos(hitCellId);// [cm], Xtal position (based on from IP)
178 ROOT::Math::XYZVector VecCell = eclp->GetCrystalVec(hitCellId);
179 float local_pos_r = 15.0 - (HitInPos - PosCell).Dot(VecCell);
180 if (hitTOF < - TimeRange || hitTOF > TimeRange) {continue;}
181 int TimeIndex = (int)((hitTOF + TimeRange) / 100);
182 E_cell[hitCellId][TimeIndex] = E_cell[hitCellId][TimeIndex] + hitE;
183 T_ave[hitCellId][TimeIndex] = T_ave[hitCellId][TimeIndex] + hitE * local_pos_r;
184 Tof_ave[hitCellId][TimeIndex] = Tof_ave[hitCellId][TimeIndex] + hitE * hitTOF;
185 }
186 //
187 //
188 //
189 //===============
190 // Xtal energy and timing (0-8us, 0.2us interval, 40 bins)
191 //===============
192 for (int iECLCell = 0; iECLCell < 8736; iECLCell++) {
193 for (int TimeIndex = 0; TimeIndex < nBinTime; TimeIndex++) {
194
195 if (E_cell[iECLCell][TimeIndex] < 1e-9) {continue;} // 0.01MeV cut
196
197 T_ave[iECLCell][TimeIndex] = T_ave[iECLCell][TimeIndex] / E_cell[iECLCell][TimeIndex];
198 T_ave[iECLCell][TimeIndex] =
199 6.05 +
200 0.0749 * T_ave[iECLCell][TimeIndex] -
201 0.00112 * T_ave[iECLCell][TimeIndex] * T_ave[iECLCell][TimeIndex];
202 Tof_ave[iECLCell][TimeIndex] = Tof_ave[iECLCell][TimeIndex] / E_cell[iECLCell][TimeIndex];
203
204 } // 40bins, Time interval = 200ns
205 }
206 //
207 //
208 //
209 for (int iXtalIdm = 0; iXtalIdm < 8736; iXtalIdm++) {
210 int iTCIdm = _TCMap->getTCIdFromXtalId(iXtalIdm + 1) - 1;
211 for (int iTime = 0; iTime < nBinTime; iTime++) {
212
213 if (E_cell[iXtalIdm][iTime] < 1e-9) {continue;} // 0.01MeV cut
214 TCEnergy[iTCIdm][iTime] += E_cell[iXtalIdm][iTime];
215 TCTiming[iTCIdm][iTime] += E_cell[iXtalIdm][iTime] * (T_ave[iXtalIdm][iTime]);
216 if (beambkg_tag[iXtalIdm][iTime] > 0) {TCBkgContribution[iTCIdm][iTime] += E_cell[iXtalIdm][iTime];}
217 if (beambkg_tag[iXtalIdm][iTime] == 0) {TCSigContribution[iTCIdm][iTime] += E_cell[iXtalIdm][iTime];}
218
219 }
220 }
221 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
222 for (int iTime = 0; iTime < nBinTime; iTime++) {
223 /* cppcheck-suppress variableScope */
224 double maxbkgE = 0;
225 /* cppcheck-suppress variableScope */
226 int maxbkgtag = 0;
227
228 if (TCEnergy[iTCIdm][iTime] < 1e-9) {continue;} // 0.01MeV cut
229 TCTiming[iTCIdm][iTime] /= TCEnergy[iTCIdm][iTime];
230 if (_BeambkgTag == 1) {
231 if (TCBkgContribution[iTCIdm][iTime] < TCSigContribution[iTCIdm][iTime]) {
232 TCBeambkgTag[iTCIdm][iTime] = 0; //signal Tag : 0
233 } else {
234 for (int iXtalIdm = 0; iXtalIdm < 8736; iXtalIdm++) {
235 int iTCId = _TCMap->getTCIdFromXtalId(iXtalIdm + 1) - 1;
236 if (iTCIdm != iTCId) {continue;}
237 if (maxbkgE < E_cell[iXtalIdm][iTime]) {
238 maxbkgE = E_cell[iXtalIdm][iTime];
239 maxbkgtag = beambkg_tag[iXtalIdm][iTime];
240 }
241 }
242 TCBeambkgTag[iTCIdm][iTime] = maxbkgtag;
243 }
244 }
245 }
246
247 }
248
249 }
250 //--------------------------------------------------------
251 //
252 //--------------------------------------------------------
253 if (SourceOfTC == 3) {
254
255 StoreArray<ECLHit> eclHitArray("ECLHits");
256
257 int nHits_hit = eclHitArray.getEntries();
258 // signal hit
259 for (int iHits = 0; iHits < nHits_hit; iHits++) {
260 // Get a hit
261 ECLHit* aECLHit = eclHitArray[iHits];
262 // Hit geom. info
263 int hitCellId = aECLHit->getCellId() - 1;
264 float hitE = aECLHit->getEnergyDep() / Unit::GeV;
265 float aveT = aECLHit->getTimeAve(); // ns :time from IP to PD
266 // Choose - TimeRange ~ TimeTange
267 if (aveT < - TimeRange || aveT > TimeRange) {continue;}
268 // Binning : -4000 = 1st bin ~ 4000 80th bin.
269 int TimeIndex = (int)((aveT + TimeRange) / 100);
270
271 int iTCIdm = _TCMap->getTCIdFromXtalId(hitCellId + 1) - 1;
272 TCEnergy[iTCIdm][TimeIndex] += hitE;
273 TCTiming[iTCIdm][TimeIndex] += hitE * aveT;
274 }
275 // background hit
276 StoreArray<TRGECLBGTCHit> m_trgeclBGTCHits("TRGECLBGTCHits_beamBG");
277 for (const TRGECLBGTCHit& ttt : m_trgeclBGTCHits) {
278 // TC timing
279 double tcbg_t = ttt.getTimeAve();
280 // Timing cut
281 if (abs(tcbg_t) > TimeRange) continue;
282 //Binning : -4000 = 1st bin ~ 4000 80th bin.
283 int TimeIndex = (int)((tcbg_t + TimeRange) / 100);
284 // TC energy
285 double tcbg_e = ttt.getEnergyDep();
286 // TC ID index
287 int iTCIdm = ttt.getTCId() - 1;
288 // TC energy and timing
289 double tc_e = TCEnergy[iTCIdm][TimeIndex];
290 double tc_t = TCTiming[iTCIdm][TimeIndex];
291 TCEnergy[iTCIdm][TimeIndex] += tcbg_e;
292 TCTiming[iTCIdm][TimeIndex] += (tcbg_e * tcbg_t + tc_e * tc_t);
293 }
294 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
295 for (int iTime = 0; iTime < nBinTime; iTime++) {
296 TCTiming[iTCIdm][iTime] /= TCEnergy[iTCIdm][iTime];
297 }
298 }
299 }
300 //--------------------------
301 // TC energy and timing in t=0-1us as true values.
302 //--------------------------
303 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
304 for (int iTime = 40; iTime < 50; iTime++) {
305 TCEnergy_tot[iTCIdm] += TCEnergy[iTCIdm][iTime];
306 TCTiming_tot[iTCIdm] += TCTiming[iTCIdm][iTime] * TCEnergy[iTCIdm][iTime];
307 }
308 TCTiming_tot[iTCIdm] /= TCEnergy_tot[iTCIdm];
309 }
310
311 return;
312}
Belle2::ECLHit
Class to store simulated hits which equate to average of ECLSImHit on crystals input for digitization...
Definition: ECLHit.h:25
Belle2::ECLHit::getTimeAve
double getTimeAve() const
Get average time.
Definition: ECLHit.h:75
Belle2::ECLHit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLHit.h:65
Belle2::ECLHit::getEnergyDep
double getEnergyDep() const
Get deposit energy.
Definition: ECLHit.h:70
Belle2::ECLSimHit
ClassECLSimHit - Geant4 simulated hit for the ECL.
Definition: ECLSimHit.h:29
Belle2::ECLSimHit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLSimHit.h:86
Belle2::ECLSimHit::getFlightTime
double getFlightTime() const
Get Flight time from IP.
Definition: ECLSimHit.h:101
Belle2::ECLSimHit::getEnergyDep
double getEnergyDep() const
Get Deposit energy.
Definition: ECLSimHit.h:106
Belle2::ECLSimHit::getPosIn
G4ThreeVector getPosIn() const
Get Position.
Definition: ECLSimHit.h:121
Belle2::ECL::ECLGeometryPar
The Class for ECL Geometry Parameters.
Definition: ECLGeometryPar.h:44
Belle2::ECL::ECLGeometryPar::Instance
static ECLGeometryPar * Instance()
Static method to get a reference to the ECLGeometryPar instance.
Definition: ECLGeometryPar.cc:168
Belle2::ECL::ECLGeometryPar::GetCrystalPos
ROOT::Math::XYZVector GetCrystalPos(int cid)
The Position of crystal.
Definition: ECLGeometryPar.h:101
Belle2::ECL::ECLGeometryPar::GetCrystalVec
ROOT::Math::XYZVector GetCrystalVec(int cid)
The direction of crystal.
Definition: ECLGeometryPar.h:109
Belle2::SimHitBase::getBackgroundTag
virtual unsigned short getBackgroundTag() const
Get background tag.
Definition: SimHitBase.h:46
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::TRGECLBGTCHit
Example Detector.
Definition: TRGECLBGTCHit.h:24
Belle2::TrgEclMapping::getTCIdFromXtalId
int getTCIdFromXtalId(int)
get [TC ID] from [Xtal ID]
Definition: TrgEclMapping.cc:30
Belle2::Unit::ns
static const double ns
Standard of [time].
Definition: Unit.h:48
Belle2::Unit::GeV
static const double GeV
Standard of [energy, momentum, mass].
Definition: Unit.h:51

◆ interFADC()

double interFADC ( double  timing)

Faster FADC using interpolation.

Definition at line 609 of file TrgEclDigitizer.cc.

610{
611
612 std::vector<double> SignalAmp;
613 std::vector<double> SignalTime;
614
615 SignalAmp.clear();
616 SignalTime.clear();
617
618 timing = timing * 1000;
619 int startbin = (int)(timing) / 12;
620 int endbin = startbin + 1;
621
622 SignalAmp = { 0, 3.47505e-06, 0.000133173, 0.000939532, 0.00337321, 0.00845977, 0.0170396, 0.0296601, 0.0465713, 0.0677693, 0.0930545, 0.122086, 0.154429, 0.189595, 0.227068, 0.266331, 0.306882, 0.348243, 0.389971, 0.431664, 0.472959, 0.513539, 0.553127, 0.59149, 0.628431, 0.663791, 0.697445, 0.729297, 0.759281, 0.787354, 0.813494, 0.837698, 0.859982, 0.880372, 0.898908, 0.915639, 0.930622, 0.943919, 0.955598, 0.965731, 0.97439, 0.98165, 0.987587, 0.992275, 0.995788, 0.9982, 0.999581, 1, 0.999525, 0.998219, 0.996143, 0.993356, 0.989846, 0.985364, 0.979439, 0.971558, 0.961304, 0.948421, 0.932809, 0.914509, 0.893664, 0.870494, 0.845267, 0.818279, 0.789837, 0.76025, 0.729815, 0.698815, 0.667511, 0.636141, 0.604919, 0.574035, 0.543654, 0.513915, 0.484939, 0.456822, 0.429643, 0.403462, 0.378324, 0.354259, 0.331286, 0.309412, 0.288633, 0.26894, 0.250316, 0.232736, 0.216174, 0.200597, 0.185972, 0.172262, 0.159428, 0.147431, 0.136232, 0.12579, 0.116067, 0.107022, 0.0986191, 0.0908193, 0.0835871, 0.0768874, 0.0706867, 0.0649528, 0.0596551, 0.0547641, 0.0502523, 0.0460932, 0.042262, 0.0387353, 0.0354909, 0.0325082, 0.0297677, 0.0272511, 0.0249416, 0.0228232, 0.020881, 0.0191014, 0.0174714, 0.0159792, 0.0146138, 0.0133649, 0.012223, 0.0111793, 0.0102258, 0.00935504, 0.00856, 0.00783438, 0.00717232, 0.00656842, 0.00601773, 0.00551567, 0.00505807, 0.00464106, 0.00426114, 0.00391506, 0.00359985, 0.0033128, 0.00305143, 0.00281346, 0.00259681, 0.00239957, 0.00222002, 0.00205655, 0.00190773, 0.00177223, 0.00164885, 0.00153648, 0.00143413, 0.00134087, 0.00125589, 0.00117842, 0.00110777, 0.00104332, 0.000984488, 0.000930766, 0.000881678, 0.000836798, 0.000795734, 0.000758134, 0.000723677, 0.00069207, 0.000663051, 0.000636377, 0.000611832, 0.000589219, 0.000568358, 0.000549086, 0.000531258, 0.000514738, 0.000499407, 0.000485156, 0.000471884, 0.000459502, 0.00044793, 0.000437092, 0.000426923, 0.000417363, 0.000408356, 0.000399853, 0.000391811, 0.000384187, 0.000376946, 0.000370055, 0.000363483, 0.000357203, 0.000351192, 0.000345426, 0.000339886, 0.000334554, 0.000329413, 0.000324448, 0.000319645, 0.000314993, 0.000310481, 0.000306098, 0.000301836, 0.000297686, 0.00029364, 0.000289693, 0.000285837, 0.000282068, 0.00027838, 0.000274768, 0.000271229, 0.000267759, 0.000264354, 0.000261011, 0.000257727, 0.000254499, 0.000251326, 0.000248204, 0.000245132, 0.000242108, 0.000239131, 0.000236198, 0.000233308, 0.00023046, 0.000227653, 0.000224885, 0.000222155, 0.000219463, 0.000216807, 0.000214187, 0.000211602, 0.00020905, 0.000206532, 0.000204046, 0.000201593, 0.00019917, 0.000196779, 0.000194417, 0.000192085, 0.000189782, 0.000187508, 0.000185262, 0.000183044, 0.000180853, 0.000178689, 0.000176552, 0.000174441, 0.000172355, 0.000170295, 0.00016826, 0.000166249, 0.000164263, 0.000162301, };
623
624 SignalTime = { 0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276, 288, 300, 312, 324, 336, 348, 360, 372, 384, 396, 408, 420, 432, 444, 456, 468, 480, 492, 504, 516, 528, 540, 552, 564, 576, 588, 600, 612, 624, 636, 648, 660, 672, 684, 696, 708, 720, 732, 744, 756, 768, 780, 792, 804, 816, 828, 840, 852, 864, 876, 888, 900, 912, 924, 936, 948, 960, 972, 984, 996, 1008, 1020, 1032, 1044, 1056, 1068, 1080, 1092, 1104, 1116, 1128, 1140, 1152, 1164, 1176, 1188, 1200, 1212, 1224, 1236, 1248, 1260, 1272, 1284, 1296, 1308, 1320, 1332, 1344, 1356, 1368, 1380, 1392, 1404, 1416, 1428, 1440, 1452, 1464, 1476, 1488, 1500, 1512, 1524, 1536, 1548, 1560, 1572, 1584, 1596, 1608, 1620, 1632, 1644, 1656, 1668, 1680, 1692, 1704, 1716, 1728, 1740, 1752, 1764, 1776, 1788, 1800, 1812, 1824, 1836, 1848, 1860, 1872, 1884, 1896, 1908, 1920, 1932, 1944, 1956, 1968, 1980, 1992, 2004, 2016, 2028, 2040, 2052, 2064, 2076, 2088, 2100, 2112, 2124, 2136, 2148, 2160, 2172, 2184, 2196, 2208, 2220, 2232, 2244, 2256, 2268, 2280, 2292, 2304, 2316, 2328, 2340, 2352, 2364, 2376, 2388, 2400, 2412, 2424, 2436, 2448, 2460, 2472, 2484, 2496, 2508, 2520, 2532, 2544, 2556, 2568, 2580, 2592, 2604, 2616, 2628, 2640, 2652, 2664, 2676, 2688, 2700, 2712, 2724, 2736, 2748, 2760, 2772, 2784, 2796, 2808, 2820, 2832, 2844, 2856, 2868, 2880, 2892, 2904, 2916, 2928, };
625
626
627 double E_out = 0;
628 if (timing < 0 || timing > 2928) {return E_out;}
629
630 if (timing > SignalTime[startbin] && timing < SignalTime[endbin]) {
631 E_out = (((SignalAmp[endbin] - SignalAmp[startbin])) / (SignalTime[endbin] - SignalTime[startbin])) *
632 (timing - SignalTime[startbin]) + SignalAmp[startbin];
633 return E_out;
634 } else {
635 E_out = 0;
636 }
637
638
639 return E_out;
640
641}

◆ save()

void save ( int  m_nEvent)

save fitting result into tables

Definition at line 567 of file TrgEclDigitizer.cc.

568{
569 //---------------
570 // Root Output
571 //---------------
572 int m_hitNum = 0;
573 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
574 for (int iBinTime = 0; iBinTime < 80; iBinTime++) {
575 if (TCEnergy[iTCIdm][iBinTime] < 0.001) {continue;}
576 StoreArray<TRGECLDigi0> TCDigiArray;
577 TCDigiArray.appendNew();
578 m_hitNum = TCDigiArray.getEntries() - 1;
579
580 TCDigiArray[m_hitNum]->setEventId(m_nEvent);
581 TCDigiArray[m_hitNum]->setTCId(iTCIdm + 1);
582 TCDigiArray[m_hitNum]->setiBinTime(iBinTime);
583 TCDigiArray[m_hitNum]->setRawEnergy(TCEnergy[iTCIdm][iBinTime]);
584 TCDigiArray[m_hitNum]->setRawTiming(TCTiming[iTCIdm][iBinTime]);
585 TCDigiArray[m_hitNum]->setBeamBkgTag(TCBeambkgTag[iTCIdm][iBinTime]);
586 }
587 }
588
589 if (_waveform == 1) {
590 StoreArray<TRGECLWaveform> TCWaveformArray;
591 for (int iTCIdm = 0; iTCIdm < 576; iTCIdm++) {
592 if (iTCIdm == 80) iTCIdm = 512; // skip barrel
593 int tc_phi_id = _TCMap->getTCPhiIdFromTCId(iTCIdm + 1);
594 int tc_theta_id = _TCMap->getTCThetaIdFromTCId(iTCIdm + 1);
595 TRGECLWaveform* newWf =
596 TCWaveformArray.appendNew(iTCIdm + 1, WaveForm[iTCIdm]);
597 newWf->setThetaPhiIDs(tc_theta_id, tc_phi_id);
598 }
599
600 }
601
602
603 return;
604}
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:246
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::TRGECLWaveform
Digitize result.
Definition: TRGECLWaveform.h:26
Belle2::TRGECLWaveform::setThetaPhiIDs
void setThetaPhiIDs(int thid, int phid)
Set Theta and Phi Id of TC.
Definition: TRGECLWaveform.h:80
Belle2::TrgEclMapping::getTCThetaIdFromTCId
int getTCThetaIdFromTCId(int)
get [TC Theta ID] from [TC ID]
Definition: TrgEclMapping.cc:194
Belle2::TrgEclMapping::getTCPhiIdFromTCId
int getTCPhiIdFromTCId(int)
get [TC Phi ID] from [TC ID]
Definition: TrgEclMapping.cc:221

◆ setFADC()

void setFADC ( int  fadc)
inline

Set flag of waveform table.

Definition at line 48 of file TrgEclDigitizer.h.

48{_FADC = fadc;}

◆ setup()

void setup ( int  SourceOfTC)

setup fam module

Definition at line 75 of file TrgEclDigitizer.cc.

76{
77
78 // prepare Matrix for Noise generation
79 _DataBase-> readNoiseLMatrix(MatrixParallel, MatrixSerial);
80
81 // Set TC data
82 // SourceOfTC => 1=ECLHit, 2=ECLSimHit, 3=ECLHit+TRGECLBGTCHit
83 // ("1:=ECLHit" is used for signal w/o bkg, and real time background monitor)
84 getTCHit(SourceOfTC);
85
86 return;
87}
Belle2::TrgEclDigitizer::getTCHit
void getTCHit(int)
get TC Hits from Xtal hits
Definition: TrgEclDigitizer.cc:92

◆ setWaveform()

void setWaveform ( int  wave)
inline

Set flag of waveform table.

Definition at line 46 of file TrgEclDigitizer.h.

46{_waveform = wave;}

◆ ShapeF() [1/2]

double ShapeF ( double  t00,
double  ts1 
)

Return shape using Simplified FADC.

Definition at line 957 of file TrgEclDigitizer.cc.

958{
959 static const double realNaN = std::numeric_limits<double>::quiet_NaN();
960
961 double dzna;
962 // double das1,das0,dac0;
963 double dcs0s = realNaN, dsn0s = realNaN, dcs0d, dsn0d;
964 double dcs1s = realNaN, dsn1s = realNaN, dcs1d, dsn1d;
965 double a1, a2, b1, b2, c1, c2 = realNaN;
966 double sv123 = 0.0;
967
968 if (t00 <= 0.0) return 0;
969
970
971
972 a1 = 10 ;
973 a2 = 0.0323625 ;
974 b1 = 100;
975 b2 = 0.0333222;
976 c1 = 10;
977
978 if (ts1 == 1) {
979 c2 = 1;
980 dsn0s = -29.9897;
981 dcs0s = -0.08627;
982
983 dsn1s = -2.64784;
984 dcs1s = -0.00285194;
985 }
986 if (ts1 == 0.01) {
987 c2 = 100;
988 dsn0s = 2.999 ;
989 dcs0s = -0.00323517;
990
991 dsn1s = 5.82524;
992 dcs1s = -7866.7;
993 }
994 if (ts1 == 0.001) {
995 c2 = 1000;
996 dsn0s = 0.272636;
997 dcs0s = -0.000204983;
998
999 dsn1s = 0.291262;
1000 dcs1s = 0.000204894;
1001 }
1002
1003 dsn0d = -5.998;
1004 dcs0d = -8340.22;
1005
1006 dsn1d = -2.91262;
1007 dcs1d = -0.00323517;
1008 //
1009 //
1010 //
1011 dzna = 6.561e+07;
1012
1013 sv123 = (
1014 (dcs0s + dcs1s) * exp(-c2 * t00) * (-1) +
1015 (dcs0d + dcs1d) * exp(-c1 * t00) +
1016 ((dsn0s - dsn0d) * sin(a2 * t00) + (dcs0s - dcs0d) * cos(a2 * t00)) * exp(-a1 * t00) +
1017 ((dsn1s - dsn1d) * sin(b2 * t00) + (dcs1s - dcs1d) * cos(b2 * t00)) * exp(-b1 * t00)
1018 )
1019 / dzna / (1 / c2 - 1 / c1);
1020
1021 return sv123;
1022}
Belle2::realNaN
static const double realNaN
constant for double NaN
Definition: ECLBhabhaTCollectorModule.h:39

◆ ShapeF() [2/2]

double ShapeF ( double  t00,
double  t01,
double  tb1,
double  t02,
double  tb2,
double  td1,
double  ts1 
)

return shape using FADC function

Definition at line 761 of file TrgEclDigitizer.cc.

768{
769 double dr;
770 double dzna;
771 double das1, das0, dac0;
772 double dcs0s, dsn0s, dcs0d, dsn0d;
773 double dcs1s, dsn1s, dcs1d, dsn1d;
774
775 double sv123 = 0.0;
776 if (t00 < 0) return 0;
777
778 dr = (ts1 - td1) / td1;
779 if (fabs(dr) <= 1.0e-5) {
780 if (ts1 > td1) { ts1 = td1 * 1.00001; }
781 else { ts1 = td1 * 0.99999; }
782 }
783 //
784 dr = (pow((t01 - t02), 2) + pow((tb1 - tb2), 2)) / (pow((t01), 2) + pow((tb1), 2));
785 if (dr <= 1.e-10) {
786 if (t01 < t02) { t01 = t02 / 1.00001; }
787 else { t01 = t02 / 0.99999; }
788 }
789 if (t00 <= 0.0) return 0;
790 //
791 //
792 //
793 double a1 = 1 / t01;
794 double a2 = 1 / tb1;
795 double b1 = 1 / t02;
796 double b2 = 1 / tb2;
797 double c1 = 1 / td1;
798 double c2 = 1 / ts1;
799
800 das0 = b2 * (pow((b1 - a1), 2) + (b2 + a2) * (b2 - a2));
801 dac0 = -2 * (b1 - a1) * a2 * b2;
802 das1 = a2 * (pow((b1 - a1), 2) - (b2 + a2) * (b2 - a2));
803
804 dsn0s = ((c2 - a1) * das0 - (-a2) * dac0) / (pow(a2, 2) + pow((c2 - a1), 2));
805 dcs0s = ((-a2) * das0 + (c2 - a1) * dac0) / (pow(a2, 2) + pow((c2 - a1), 2));
806
807 dsn1s = ((c2 - b1) * das1 - (-b2) * (-dac0)) / (pow(b2, 2) + pow((c2 - b1), 2));
808 dcs1s = ((-b2) * das1 + (c2 - b1) * (-dac0)) / (pow(b2, 2) + pow((c2 - b1), 2));
809
810 dsn0d = ((c1 - a1) * das0 - (-a2) * dac0) / (pow(a2, 2) + pow((c1 - a1), 2));
811 dcs0d = ((-a2) * das0 + (c1 - a1) * dac0) / (pow(a2, 2) + pow((c1 - a1), 2));
812
813 dsn1d = ((c1 - b1) * das1 - (-b2) * (-dac0)) / (pow(b2, 2) + pow((c1 - b1), 2));
814 dcs1d = ((-b2) * das1 + (c1 - b1) * (-dac0)) / (pow(b2, 2) + pow((c1 - b1), 2));
815 //
816 //
817 //
818 dzna = (pow((b1 - a1), 2) + pow((b2 - a2), 2)) * (pow((b1 - a1), 2) + pow((a2 + b2), 2));
819
820 sv123 = (
821 (dcs0s + dcs1s) * exp(-c2 * t00) * (-1) +
822 (dcs0d + dcs1d) * exp(-c1 * t00) +
823 ((dsn0s - dsn0d) * sin(a2 * t00) + (dcs0s - dcs0d) * cos(a2 * t00)) * exp(-a1 * t00) +
824 ((dsn1s - dsn1d) * sin(b2 * t00) + (dcs1s - dcs1d) * cos(b2 * t00)) * exp(-b1 * t00)
825 )
826 / dzna / (1 / c2 - 1 / c1);
827
828 return sv123;
829}

◆ SimplifiedFADC()

double SimplifiedFADC ( int  flag_gen,
double  timing 
)

FADC.

Faster FADC

Definition at line 837 of file TrgEclDigitizer.cc.

839{
840
841 //--------------------------------------
842 //
843 // o "timing" unit is [us]
844 // o flag_gen = 0(=signal), 1(=parallel), 2(=serial)
845 // o return value(PDF) is [GeV]
846 // o Generate signal shape using a simplified function.
847 //
848 //
849 //--------------------------------------
850 double tsh, dd;
851 static double tc, tc2, tsc, tris;
852 static double amp, dft, as;
853
854
855 // int im, ij;
856
857 static int ifir = 0;
858
859 if (ifir == 0) {
860
861 const double td = 0.10; // diff time ( 0.10)
862 const double t1 = 0.10; // integ1 real ( 0.10)
863 // b1 = 30.90; // integ1 imag ( 30.90)
864 const double t2 = 0.01; // integ2 real ( 0.01)
865 // b2 = 30.01; // integ2 imag ( 30.01)
866 double ts = 1.00; // scint decay ( 1.00)
867 dft = 0.600; // diff delay ( 0.600)
868 as = 0.548; // diff frac ( 0.548)
869 //
870 amp = 1.0;
871 tris = 0.01;
872 // ts0 = 0.0;
873 tsc = ts;
874 double fm = 0;
875 //
876 int im = 0;
877 int ij = 0;
878 tc = 0;
879 double tt = u_max(u_max(td, t1), u_max(t2, ts)) * 2;
880 int flag_once = 0;
881 while (flag_once == 0) {
882 double dt = tt / 1000;
883
884 double tm = 0;
885 for (int j = 1; j <= 1000; j++) {
886 tc2 = tc - dft;
887 double fff =
888 (ShapeF(tc, tsc) -
889 ShapeF(tc, tris) * 0.01) -
890 (ShapeF(tc2, tsc) -
891 ShapeF(tc2, tris) * 0.01) * as;
892 if (fff > fm) {
893 fm = fff;
894 tm = tc;
895 im = j;
896 }
897 tc = tc + dt;
898 }
899 if (im >= 1000) {
900 tt = 2 * tt;
901 flag_once = 0;
902 continue;
903 }
904 if (ij == 0) {
905 ij = 1;
906 tc = 0.99 * tm;
907 dt = tm * 0.02 / 1000;
908 flag_once = 0;
909 continue;
910 }
911 flag_once = 1;
912 }
913 amp = 1.0 / fm;
914 ifir = 1;
915 }
916 //
917 //
918 double pdf = 0;
919 if (flag_gen == 0) {
920 //-----<signal>
921 tc2 = timing - dft;
922 pdf = amp * (
923 (ShapeF(timing, tsc) -
924 ShapeF(timing, tris) * 0.01) -
925 (ShapeF(tc2, tsc) -
926 ShapeF(tc2, tris) * 0.01) * as);
927 } else if (flag_gen == 1) {
928 //-----<parallel>
929 tc2 = timing - dft;
930 tsh = 0.001;
931 pdf = amp * (
932 ShapeF(timing, tsh) -
933 ShapeF(tc2, tsh) * as);
934 pdf = pdf * 0.001; // GeV
935 } else {
936 //-----<serial>
937 tc2 = timing - dft;
938 tsh = 0.001;
939 pdf = amp * (
940 ShapeF(timing, tsh) -
941 ShapeF(tc2, tsh) * as);
942 //
943 tc = timing - 0.01;
944 if (tc < 0) { tc = 0; }
945 dd = timing - tc;
946 tc2 = tc - dft;
947 pdf = (amp * (
948 ShapeF(tc, tsh) -
949 ShapeF(tc2, tsh) * as) - pdf) / dd;
950 pdf = pdf * 0.001; // GeV
951 }
952
953 return pdf;
954}

◆ u_max()

double u_max ( double  aaa,
double  bbb 
)

Find max value between 2 vals;.

Definition at line 1027 of file TrgEclDigitizer.cc.

1028{
1029 if (aaa > bbb) { return aaa; }
1030 else { return bbb; }
1031}

Member Data Documentation

◆ _BeambkgTag

int _BeambkgTag
private

Flag of saving beam background tag or not.

Definition at line 112 of file TrgEclDigitizer.h.

◆ _DataBase

TrgEclDataBase* _DataBase
private

Object of DataBase.

Definition at line 92 of file TrgEclDigitizer.h.

◆ _FADC

int _FADC
private

Flag of choosing the method of waveform generation function 0: use simplifiedFADC, 1: use interFADC(interpolation)

Definition at line 110 of file TrgEclDigitizer.h.

◆ _TCMap

TrgEclMapping* _TCMap
private

Object of TC Mapping.

Definition at line 90 of file TrgEclDigitizer.h.

◆ _waveform

int _waveform
private

Flag of waveform table.

Definition at line 106 of file TrgEclDigitizer.h.

◆ MatrixParallel

std::vector<std::vector<double> > MatrixParallel
private

Noise Matrix of Parallel and Serial Noise.

Noise Low triangle Matrix of Parallel noise

Definition at line 96 of file TrgEclDigitizer.h.

◆ MatrixSerial

std::vector<std::vector<double> > MatrixSerial
private

Noise Low triangle Matrix of Serial noise

Definition at line 98 of file TrgEclDigitizer.h.

◆ TCBeambkgTag

int TCBeambkgTag[576][80]
private

Beambackground tag.

Definition at line 104 of file TrgEclDigitizer.h.

◆ TCBkgContribution

double TCBkgContribution[576][80]
private

Beambackground contribution.

Definition at line 100 of file TrgEclDigitizer.h.

◆ TCEnergy

double TCEnergy[576][80]
private

TC Energy converted from Xtarl Energy [GeV].

Definition at line 69 of file TrgEclDigitizer.h.

◆ TCEnergy_tot

double TCEnergy_tot[576]
private

TC Energy converted from Xtarl Energy [GeV].

Definition at line 73 of file TrgEclDigitizer.h.

◆ TCRawBkgTag

double TCRawBkgTag[576][60]
private

Input Beambackground tag

Definition at line 87 of file TrgEclDigitizer.h.

◆ TCRawEnergy

double TCRawEnergy[576][60]
private

Input TC energy[GeV].

Definition at line 83 of file TrgEclDigitizer.h.

◆ TCRawTiming

double TCRawTiming[576][60]
private

Input TC timing[ns]

Definition at line 85 of file TrgEclDigitizer.h.

◆ TCSigContribution

double TCSigContribution[576][80]
private

Signal contribution.

Definition at line 102 of file TrgEclDigitizer.h.

◆ TCTiming

double TCTiming[576][80]
private

TC Timing converted from Xtarl Timing [GeV].

Definition at line 71 of file TrgEclDigitizer.h.

◆ TCTiming_tot

double TCTiming_tot[576]
private

TC Timing converted from Xtarl Timing [GeV].

Definition at line 75 of file TrgEclDigitizer.h.

◆ TimeRange

double TimeRange
private

time range(default : -4000 ~ 4000 ns )

Definition at line 67 of file TrgEclDigitizer.h.

◆ WaveForm

double WaveForm[576][64]
private

TC Energy converted from Xtarl Energy [GeV].

Definition at line 108 of file TrgEclDigitizer.h.

The documentation for this class was generated from the following files: