Calculate energy, time and chi2 for one channel using fitted pulse shape.
Method uses HFITV.
268 {
269
270 amplitude = 0.0;
272 pedestal = 0.0;
274
275 const HWIdentifier adcId =
digit->adc_HWID();
279
282
284
285
287 int noise_channel = (
ros < 3) ? channel :
channel + 48;
288
289 if (igain == 0) {
291 case 3:
293 if (rms > 0.0) break;
294
295 case 2:
297 if (rms > 0.0) break;
298
299 case 1:
301 if (rms > 0.0) break;
302
303 default:
305 }
306 } else if (igain == 1) {
308 case 3:
310 if (rms > 0.0) break;
311
312 case 2:
314 if (rms > 0.0) break;
315
316 case 1:
318 if (rms > 0.0) break;
319
320 default:
322 }
323 } else {
324
326 return;
327 }
328
330 << " ROS=" << ros
331 << " Channel=" << channel
332 << " gain=" << igain
333 << " RMS=" << rms
335
336
337 int ifit1 = 0;
339
342
344 << " ifit1=" << ifit1
345 << " ifit2=" << ifit1 + nfit - 1
346 << " nfit=" << nfit
351 << " demoCh=" << ((demo)?"true":"false") );
352
353 std::vector<float> samples =
digit->samples();
354 samples.erase(samples.begin(),samples.begin()+
m_firstSample);
356 double maxsamp = 0.0;
358
361
362 bool no_signal = true;
363 pedestal = samples[0];
364 const double delta = 1.e-6;
365
366 for (int isamp = 0; isamp < nfit; ++isamp) {
367 int j = isamp + ifit1;
369 yvec0[isamp] = samples[
j];
370 if (no_signal) no_signal = (fabs(samples[j] - pedestal) < delta);
371
372
375 } else {
378 ATH_MSG_VERBOSE(
"Saturated ADC value yvec0[" << isamp <<
"]=" << yvec0[isamp]
380
381 } else {
383 ATH_MSG_VERBOSE(
"Zero ADC value yvec0[" << isamp <<
"]=" << yvec0[isamp]
384 << " RMS=" << eyvec[isamp] );
385 }
386 }
387
388 if (yvec0[isamp] > maxsamp) {
389
390
391 maxsamp = yvec0[isamp];
393 }
394 if (yvec0[isamp] < minsamp) {
395 minsamp = yvec0[isamp];
397 }
399 << ", xvec=" << xvec[isamp]
400 << ", yvec0=" << yvec0[isamp]
401 << ", eyvec=" << eyvec[isamp] );
402 }
403
404 if (no_signal) {
406 return;
407 }
408
409
410 double pedg = (yvec0[0] + yvec0[nfit - 1]) / 2.0;
411
412
413 int delta_peak = 0;
414
416
418
419 if (!fixedTime) {
421
422 pedg = yvec0[0];
426 } else {
427 fixedTime = true;
429 }
430 } else {
437 } else {
438 fixedTime = true;
440 }
441 }
442 }
443
444 double expectedTime = 0.;
447 delta_peak = std::round(expectedTime /
DTIME);
449 }
450
453 << " ipeakMax=" << ipeakMax
454 << " ipeakMin=" << ipeakMin
455 << " fixedTime=" << ((fixedTime) ? "true" : "false") );
456
457 const std::vector<double>* tpulse = &
m_dummy;
458 const std::vector<double>* ypulse = &
m_dummy;
459 const std::vector<double>* tdpulse = &
m_dummy;
460 const std::vector<double>* dpulse = &
m_dummy;
461 const std::vector<double>* tleak = &
m_dummy;
462 const std::vector<double>* yleak = &
m_dummy;
463 const std::vector<double>* tdleak = &
m_dummy;
464 const std::vector<double>* dleak = &
m_dummy;
465
466
469 if (demo) {
472 }
473
475 if (igain == 0) {
485 } else {
494 }
495 } else {
505 } else {
514 }
515 }
516 } else {
517 if (dolas) {
518 if (igain == 0) {
523 } else {
528 }
529 } else {
530 if (igain == 0) {
535 } else {
540 }
541 }
542 }
543
544 if (demo) {
545 docis = false;
547 }
548
549
550 double gval, gpval,
sy, syg, sygp, sg, sgp, sgg, sgpgp, sggp, serr, err2;
551 double dgg0, dgg, dggp, dgpgp, dyg, dygp,
dg, dc,
xd;
552 double sllp, sylp, slplp, dleakage, leakage;
553 double fixtau = 0.0, fixped = 0.0, fixampl = 0.0, fixchi2 =
MAX_CHI2;
554 double leaktau = 0.0, leakped = 0.0, leakampl = 0.0, leakchi2 =
MAX_CHI2;
555 double cistau = 0.0, cisped = 0.0, cisampl = 0.0, cisatau = 0.0, cischi2 =
MAX_CHI2;
557
558
559 int niter = 0;
560 do {
561 ++niter;
563
564 if (tempChi2 < oldchi2) oldchi2 = tempChi2;
565
566
567
569
571
573
574
577
578 sllp = 0.0;
579 sylp = 0.0;
580 slplp = 0.0;
581 for (int isamp = 0; isamp < nfit; ++isamp) {
582 ATH_MSG_VERBOSE (
"Lo gain leakage xvec[" << isamp <<
"]=" << xvec[isamp] );
583
584 leakage =
pulse(xvec[isamp], tleak, yleak);
585 dleakage =
derivative(xvec[isamp], tdleak, dleak);
586
587
588 yvec[isamp] = yvec0[isamp] - pedg;
589
591 << " yvec0[" << isamp << "]=" << yvec0[isamp]
592 << " pedg=" << pedg);
593
594 sllp += leakage * dleakage;
595 sylp +=
yvec[isamp] * dleakage;
596 slplp += dleakage * dleakage;
597 }
598
599 if (fabs(slplp) >
EPS_DG && !fixedTime) {
600 leaktau = (sllp - sylp) / slplp;
601
605 } else {
606 leaktau = 0.0;
607 }
608
610 << " sylp=" << sylp
611 << " slplp=" << slplp
612 << " leaktau=" << leaktau);
613
614
615
618 sg = 0.0;
619 syg = 0.0;
620 sgg = 0.0;
621 serr = 0.0;
622 for (int isamp = 0; isamp < nfit; ++isamp) {
623 leakage =
pulse(xvec[isamp], tleak, yleak);
625 yvec[isamp] = yvec0[isamp] - leakage;
626
628 << " yvec0[" << isamp << "]=" << yvec0[isamp]
629 << " leakage=" << leakage );
630
631 err2 = eyvec[isamp] * eyvec[isamp];
633 sg += gval / err2;
634 syg +=
yvec[isamp] * gval / err2;
635 sgg += gval * gval / err2;
636 serr += 1.0 / err2;
637 }
638
639 dgg0 = sg * sg - serr * sgg;
640 if (fabs(dgg0) >
EPS_DG) {
641 leakampl = (
sy * sg - serr * syg) / dgg0;
642 leakped = (syg * sg -
sy * sgg) / dgg0;
643 } else {
644 leakampl = 0.0;
646 }
647
648
650
651 leakchi2 = 0.0;
655
656 for (int isamp = 0; isamp < nfit; ++isamp) {
658 leakage =
pulse(xvec[isamp], tleak, yleak);
659 xd = yvec0[isamp] - (gval + leakage);
660 leakchi2 = leakchi2 + (
xd *
xd) / (eyvec[isamp] * eyvec[isamp]);
661
663 << " yvec0[" << isamp << "]=" << yvec0[isamp]
664 << " gval=" << gval
665 << ", leakage=" << leakage
666 << ", xd=" << xd );
667 }
668
669 leakchi2 = leakchi2/(nfit-3.0);
670
672 << " leakped=" << leakped
673 << " leakampl=" << leakampl
674 << " leakchi2=" << leakchi2 );
675
676
677 if (!fixedTime) {
681
682 for (int isamp = 0; isamp < nfit; ++isamp) {
683 leakage =
pulse(xvec[isamp], tleak, yleak);
684
685
686 yvec[isamp] = yvec0[isamp] - leakage;
687
689 << " yvec0[" << isamp << "]=" << yvec0[isamp]
690 << " leakage=" << leakage
691 << " yvec[" << isamp << "]=" << yvec[isamp] );
692 }
693
698 sg = 0.0;
699 sgp = 0.0;
700 syg = 0.0;
701 sygp = 0.0;
702 sgg = 0.0;
703 sggp = 0.0;
704 sgpgp = 0.0;
705 serr = 0.0;
706
707 for (int isamp = 0; isamp < nfit; ++isamp) {
709 gpval =
derivative(xvec[isamp], tdpulse, dpulse);
710 err2 = eyvec[isamp] * eyvec[isamp];
712 sg += gval / err2;
713 sgp += gpval / err2;
714 syg +=
yvec[isamp] * gval / err2;
715 sygp +=
yvec[isamp] * gpval / err2;
716 sgg += gval * gval / err2;
717 sggp += gval * gpval / err2;
718 sgpgp += gpval * gpval / err2;
719 serr += 1.0 / err2;
720 }
721
722 dgg = sgg - sg * sg / serr;
723 dggp = sggp - sg * sgp / serr;
724 dgpgp = sgpgp - sgp * sgp / serr;
725 dyg = syg -
sy * sg / serr;
726 dygp = sygp -
sy * sgp / serr;
727 dg = dgg * dgpgp - dggp * dggp;
728
730 cisampl = (dyg * dgpgp - dygp * dggp) / dg;
731 cisatau = (dyg * dggp - dygp * dgg) / dg;
733 - (dyg * dgpgp * sg - dygp * dggp * sg + dyg * dggp * sgp - dygp * dgg * sgp) /
dg)
734 / serr;
735
736 if (fabs(cisampl) >
EPS_DG) {
737 cistau = cisatau / cisampl;
741 } else {
742 cistau = 0.0;
743 }
744 } else {
745 cisampl = 0.0;
746 cisatau = 0.0;
747 cistau = 0.0;
749 }
750
751 if (
msgLvl(MSG::VERBOSE)) {
752 msg(MSG::VERBOSE) <<
" sy=" <<
sy
753 << " sg=" << sg
754 << " sgp=" << sgp
755 << " syg=" << syg
756 << " sygp=" << sygp
757 << " sgg=" << sgg
758 << " sggp=" << sggp
759 <<
" sgpgp=" << sgpgp <<
endmsg;
760
761 msg(MSG::VERBOSE) <<
" dgg=" << dgg
762 << " dggp=" << dggp
763 << " sgpgp=" << sgpgp
764 << " dyg=" << dyg
765 << " dygp=" << dygp
767
768 msg(MSG::VERBOSE) <<
" cistau=" << cistau
769 << " cisped=" << cisped
770 <<
" cisampl=" << cisampl <<
endmsg;
771 }
772
773
774 cischi2 = 0.0;
778
779 for (int isamp = 0; isamp < nfit; ++isamp) {
781 leakage =
pulse(xvec[isamp], tleak, yleak);
782
783 yvec[isamp] = yvec0[isamp] - leakage;
785 cischi2 = cischi2 + (
xd *
xd) / (eyvec[isamp] * eyvec[isamp]);
786
788 << " yvec[" << isamp << "]=" << yvec[isamp]
789 << " leakage=" << leakage
790 << " gval=" << gval
791 << " xd=" << xd );
792 }
793
794 cischi2 = cischi2 / (nfit - 3.0);
795
797 }
798
799
800 if ((cischi2 < leakchi2) && !fixedTime) {
803 ampl = cisampl;
804 tempChi2 = cischi2;
805 } else {
808 ampl = leakampl;
809 tempChi2 = leakchi2;
810 }
811
812 } else {
813
814
815 if (niter == 1) {
816
817
820
822 sg = 0.0;
823 sgg = 0.0;
824 syg = 0.0;
825 serr = 0.0;
826
827 for (int isamp = 0; isamp < nfit; ++isamp) {
828 if (!dolas) {
829
830 int jsamp = (
int) xvec[isamp] - delta_peak;
831 if (jsamp < 0)
832 jsamp = 0;
833 else if (jsamp >= nfit) jsamp = nfit - 1;
834
835 if (igain == 0) {
837 } else {
839 }
840 } else {
842 }
843 err2 = eyvec[isamp] * eyvec[isamp];
844 sy += yvec0[isamp] / err2;
845 sg += gval / err2;
846 syg += yvec0[isamp] * gval / err2;
847 sgg += gval * gval / err2;
848 serr += 1.0 / err2;
849 }
850
851 fixtau = 0.0;
852 dgg0 = sg * sg - serr * sgg;
853 if (fabs(dgg0) >
EPS_DG) {
854 fixampl = (
sy * sg - serr * syg) / dgg0;
855 fixped = (syg * sg -
sy * sgg) / dgg0;
857 << " fixped = " << fixped );
858 } else {
859 fixampl = 0.0;
862 << ", fixampl = " << fixampl
863 << " fixped = " << fixped );
864 }
865
869 fixchi2 = 0.0;
870 for (int isamp = 0; isamp < nfit; ++isamp) {
871 dc = yvec0[isamp] -
scaledPulse(xvec[isamp], tpulse, ypulse);
872 fixchi2 = fixchi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
874 << " yvec0[" << isamp << "]= " << yvec0[isamp]
875 << " eyvec[" << isamp << "]= " << eyvec[isamp]
876 << " fixchi2= " << fixchi2 );
877 }
878 fixchi2 = fixchi2 / (nfit - 2.0);
880 << " nfit=" << nfit );
881
883
884
888 }
889
890 if (fixedTime) {
894 ampl = fixampl;
895 tempChi2 = oldchi2 = -fabs(fixchi2);
896 } else {
897
899 sg = 0.0;
900 sgp = 0.0;
901 syg = 0.0;
902 sygp = 0.0;
903 sgg = 0.0;
904 sggp = 0.0;
905 sgpgp = 0.0;
906 serr = 0.0;
907
908 for (int isamp = 0; isamp < nfit; ++isamp) {
909 if ((niter == 1) && (!dolas)) {
910
911
912 int jsamp = (
int) xvec[isamp] - delta_peak;
913 if (jsamp < 0)
914 jsamp = 0;
915 else if (jsamp >= nfit) jsamp = nfit - 1;
916
917 if (igain == 0) {
920 } else {
923 }
924 } else {
925
927 gpval =
derivative(xvec[isamp], tdpulse, dpulse);
928 }
929
930 err2 = eyvec[isamp] * eyvec[isamp];
931 sy += yvec0[isamp] / err2;
932 sg += gval / err2;
933 sgp += gpval / err2;
934 syg += yvec0[isamp] * gval / err2;
935 sygp += yvec0[isamp] * gpval / err2;
936 sgg += gval * gval / err2;
937 sggp += gval * gpval / err2;
938 sgpgp += gpval * gpval / err2;
939 serr += 1.0 / err2;
940
942 << " gval=" << gval
943 << " sg=" << sg
944 << " gpval=" << gpval
945 << " sgp=" << sgp );
946 }
947
948 dgg = sgg - sg * sg / serr;
949 dggp = sggp - sg * sgp / serr;
950 dgpgp = sgpgp - sgp * sgp / serr;
951 dyg = syg -
sy * sg / serr;
952 dygp = sygp -
sy * sgp / serr;
953 dg = dgg * dgpgp - dggp * dggp;
954
955
957
958 ampl = (dyg * dgpgp - dygp * dggp) / dg;
959
960 atau = (dyg * dggp - dygp * dgg) / dg;
961
962 ped = (
sy - ((dyg * dgpgp - dygp * dggp) * sg + (dyg * dggp - dygp * dgg) * sgp) /
dg)
963 / serr;
964
965 if (fabs(ampl) >
EPS_DG) {
966
971 } else {
973 }
974 } else {
975 ampl = 0.0;
976 atau = 0.0;
979 }
980
981 if (
msgLvl(MSG::VERBOSE)) {
983 msg(MSG::VERBOSE) <<
" sy=" <<
sy
984 << " sg=" << sg
985 <<
" sgp=" << sgp <<
endmsg;
986
987 msg(MSG::VERBOSE) <<
" syg=" << syg
988 << " sygp=" << sygp
989 <<
" sgg=" << sgg <<
endmsg;
990
991 msg(MSG::VERBOSE) <<
" sggp=" << sggp
992 <<
" sgpgp=" << sgpgp <<
endmsg;
993
994 msg(MSG::VERBOSE) <<
" ampl = (dyg*dgpgp - dygp*dggp)= " << ampl <<
endmsg;
995
996 msg(MSG::VERBOSE) <<
" dyg=" << dyg
997 << " dgpgp=" << dgpgp
998 <<
" dyg*dgpgp=" << (dyg * dgpgp) <<
endmsg;
999
1000 msg(MSG::VERBOSE) <<
" dygp=" << dygp
1001 << " dggp=" << dggp
1002 <<
" dygp*dggp=" << (dygp * dggp) <<
endmsg;
1003
1004 msg(MSG::VERBOSE) <<
" dyg=" << dyg
1005 << " dggp=" << dggp
1006 <<
" dyg*dggp=" << (dyg * dggp) <<
endmsg;
1007
1008 msg(MSG::VERBOSE) <<
" dygp=" << dygp
1009 << " dgg=" << dgg
1010 <<
" dygp*dgg=" << (dygp * dgg) <<
endmsg;
1011
1012 msg(MSG::VERBOSE) <<
" dg=" <<
dg
1013 << " atau=" << atau
1015 }
1016
1020
1021 tempChi2 = 0;
1022
1023 for (int isamp = 0; isamp < nfit; ++isamp) {
1024 dc = yvec0[isamp] -
scaledPulse(xvec[isamp], tpulse, ypulse);
1025 tempChi2 = tempChi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
1027 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1028 << " eyvec[" << isamp << "]=" << eyvec[isamp]
1029 << " dc=" << dc
1030 << " chi2=" << tempChi2 );
1031 }
1032
1033 tempChi2 = tempChi2 / (nfit - 3.0);
1035 << " nfit=" << nfit );
1036 }
1037 }
1038
1039 if (
msgLvl(MSG::VERBOSE))
1040 msg(MSG::VERBOSE) <<
" t0fit: " <<
m_t0Fit << ((
tau < 0.0) ?
" - " :
" + ") << fabs(tau);
1041
1042
1045 if (
msgLvl(MSG::VERBOSE))
1052 } else {
1053
1054
1057
1058
1065 }
1066 }
1067
1068
1069 if (tempChi2 <
chi2) {
1072 amplitude = ampl;
1074 }
1075
1079 else
1081
1083 }
1084
1087 << " phase=" << tau
1088 << " ped=" << ped
1089 << " ampl=" << ampl
1090 << " chi2=" << tempChi2 );
1091
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1110
1112 << " Time=" << time
1113 << " Ped=" << pedestal
1114 << " Amplitude=" << amplitude
1115 <<
" Chi2=" <<
chi2 );
1116
1118 int nfit_real;
1119
1120
1121
1123
1125
1127
1128
1130 if (!fixedTime) {
1132
1133 sllp = 0.0;
1134 sylp = 0.0;
1135 slplp = 0.0;
1137
1138 ATH_MSG_VERBOSE (
"Lo gain leakage xvec[" << isamp <<
"]=" << xvec[isamp] );
1139
1140 leakage =
pulse(xvec[isamp], tleak, yleak);
1141 dleakage =
derivative(xvec[isamp], tdleak, dleak);
1142
1143
1144 yvec[isamp] = yvec0[isamp] - pedg;
1145
1147 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1148 << " pedg=" << pedg );
1149
1150 sllp += leakage * dleakage;
1151 sylp +=
yvec[isamp] * dleakage;
1152 slplp += dleakage * dleakage;
1153 }
1154
1155 if (fabs(slplp) >
EPS_DG && !fixedTime) {
1156 leaktau = (sllp - sylp) / slplp;
1157
1161 } else {
1162 leaktau = 0.0;
1163 }
1164
1166 << " sylp=" << sylp
1167 << " slplp=" << slplp
1168 << " leaktau=" << leaktau );
1169
1170
1171
1174 sg = 0.0;
1175 syg = 0.0;
1176 sgg = 0.0;
1177 serr = 0.0;
1178
1179 for (int isamp = 0;
1181
1182 leakage =
pulse(xvec[isamp], tleak, yleak);
1184 yvec[isamp] = yvec0[isamp] - leakage;
1185
1187 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1188 << " leakage=" << leakage );
1189
1190 err2 = eyvec[isamp] * eyvec[isamp];
1191 sy +=
yvec[isamp] / err2;
1192 sg += gval / err2;
1193 syg +=
yvec[isamp] * gval / err2;
1194 sgg += gval * gval / err2;
1195 serr += 1.0 / err2;
1196 }
1197
1198 dgg0 = sg * sg - serr * sgg;
1199 if (fabs(dgg0) >
EPS_DG) {
1200 leakampl = (
sy * sg - serr * syg) / dgg0;
1201 leakped = (syg * sg -
sy * sgg) / dgg0;
1202 } else {
1203 leakampl = 0.0;
1205 ATH_MSG_ERROR(
"TileRawChannelBuilderFitFilter::pulseFit: serr is zero.");
1206 return;
1207 }
1208 leakped =
sy / serr;
1209 }
1210
1211
1213
1214 leakchi2 = 0.0;
1215 nfit_real = 0;
1219
1220 for (int isamp = 0;
1222
1223 ++nfit_real;
1225 leakage =
pulse(xvec[isamp], tleak, yleak);
1226 xd = yvec0[isamp] - (gval + leakage);
1227 leakchi2 = leakchi2 + (
xd *
xd) / (eyvec[isamp] * eyvec[isamp]);
1228
1230 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1231 << " gval=" << gval
1232 << ", leakage=" << leakage
1233 << ", xd=" << xd );
1234 }
1235
1236 leakchi2 = leakchi2 / (nfit_real - 3.0);
1237
1239 << " leakped=" << leakped
1240 << " leakampl=" << leakampl
1241 << " leakchi2=" << leakchi2 );
1242
1243
1247
1248 for (int isamp = 0;
1250
1251 leakage =
pulse(xvec[isamp], tleak, yleak);
1252
1253
1254 yvec[isamp] = yvec0[isamp] - leakage;
1255
1257 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1258 << " leakage=" << leakage
1259 << " yvec[" << isamp << "]=" << yvec[isamp] );
1260 }
1261
1266 sg = 0.0;
1267 sgp = 0.0;
1268 syg = 0.0;
1269 sygp = 0.0;
1270 sgg = 0.0;
1271 sggp = 0.0;
1272 sgpgp = 0.0;
1273 serr = 0.0;
1274
1275 for (int isamp = 0;
1277
1279 gpval =
derivative(xvec[isamp], tdpulse, dpulse);
1280 err2 = eyvec[isamp] * eyvec[isamp];
1281 sy +=
yvec[isamp] / err2;
1282 sg += gval / err2;
1283 sgp += gpval / err2;
1284 syg +=
yvec[isamp] * gval / err2;
1285 sygp +=
yvec[isamp] * gpval / err2;
1286 sgg += gval * gval / err2;
1287 sggp += gval * gpval / err2;
1288 sgpgp += gpval * gpval / err2;
1289 serr += 1.0 / err2;
1290 }
1291
1292 if (serr == 0) serr = 1;
1293 dgg = sgg - sg * sg / serr;
1294 dggp = sggp - sg * sgp / serr;
1295 dgpgp = sgpgp - sgp * sgp / serr;
1296 dyg = syg -
sy * sg / serr;
1297 dygp = sygp -
sy * sgp / serr;
1298 dg = dgg * dgpgp - dggp * dggp;
1299
1301 cisampl = (dyg * dgpgp - dygp * dggp) / dg;
1302 cisatau = (dyg * dggp - dygp * dgg) / dg;
1304 - (dyg * dgpgp * sg - dygp * dggp * sg + dyg * dggp * sgp - dygp * dgg * sgp) /
dg)
1305 / serr;
1306
1307 if (fabs(cisampl) >
EPS_DG) {
1308 cistau = cisatau / cisampl;
1312 } else {
1313 cistau = 0.0;
1314 }
1315 } else {
1316 cisampl = 0.0;
1317 cisatau = 0.0;
1318 cistau = 0.0;
1320 }
1321
1322 if (
msgLvl(MSG::VERBOSE)) {
1323 msg(MSG::VERBOSE) <<
" sy=" <<
sy
1324 << " sg=" << sg
1325 << " sgp=" << sgp
1326 << " syg=" << syg
1327 << " sygp=" << sygp
1328 << " sgg=" << sgg
1329 << " sggp=" << sggp
1330 <<
" sgpgp=" << sgpgp <<
endmsg;
1331
1332 msg(MSG::VERBOSE) <<
" dgg=" << dgg
1333 << " dggp=" << dggp
1334 << " sgpgp=" << sgpgp
1335 << " dyg=" << dyg
1336 << " dygp=" << dygp
1338
1339 msg(MSG::VERBOSE) <<
" cistau=" << cistau
1340 << " cisped=" << cisped
1341 <<
" cisampl=" << cisampl <<
endmsg;
1342 }
1343
1344
1345 cischi2 = 0.0;
1346 nfit_real = 0;
1350
1351 for (int isamp = 0;
1353
1354 ++nfit_real;
1356 leakage =
pulse(xvec[isamp], tleak, yleak);
1357
1358 yvec[isamp] = yvec0[isamp] - leakage;
1360 cischi2 = cischi2 + (
xd *
xd) / (eyvec[isamp] * eyvec[isamp]);
1361
1363 << " yvec[" << isamp << "]=" << yvec[isamp]
1364 << " leakage=" << leakage
1365 << " gval=" << gval
1366 << " xd=" << xd );
1367 }
1368
1369 cischi2=cischi2/(nfit_real-3.0);
1370
1372
1373
1374 if ((cischi2 < leakchi2) && !fixedTime) {
1377 ampl = cisampl;
1378 tempChi2 = cischi2;
1379 } else {
1382 ampl = leakampl;
1383 tempChi2 = leakchi2;
1384 }
1385
1386 }
1387 } else {
1388 if (!fixedTime) {
1389
1390
1394
1396 sg = 0.0;
1397 sgp = 0.0;
1398 syg = 0.0;
1399 sygp = 0.0;
1400 sgg = 0.0;
1401 sggp = 0.0;
1402 sgpgp = 0.0;
1403 serr = 0.0;
1404
1405 for (int isamp = 0;
1407
1409 gpval =
derivative(xvec[isamp], tdpulse, dpulse);
1410
1411 err2 = eyvec[isamp] * eyvec[isamp];
1412 sy += yvec0[isamp] / err2;
1413 sg += gval / err2;
1414 sgp += gpval / err2;
1415 syg += yvec0[isamp] * gval / err2;
1416 sygp += yvec0[isamp] * gpval / err2;
1417 sgg += gval * gval / err2;
1418 sggp += gval * gpval / err2;
1419 sgpgp += gpval * gpval / err2;
1420 serr += 1.0 / err2;
1421
1423 << " gval=" << gval
1424 << " sg=" << sg
1425 << " gpval=" << gpval
1426 << " sgp=" << sgp );
1427 }
1428
1429 dgg = sgg - sg * sg / serr;
1430 dggp = sggp - sg * sgp / serr;
1431 dgpgp = sgpgp - sgp * sgp / serr;
1432 dyg = syg -
sy * sg / serr;
1433 dygp = sygp -
sy * sgp / serr;
1434 dg = dgg * dgpgp - dggp * dggp;
1435
1436
1438
1439 ampl = (dyg * dgpgp - dygp * dggp) / dg;
1440
1441 atau = (dyg * dggp - dygp * dgg) / dg;
1442
1443 ped = (
sy - ((dyg * dgpgp - dygp * dggp) * sg + (dyg * dggp - dygp * dgg) * sgp) /
dg)
1444 / serr;
1445
1446 if (fabs(ampl) >
EPS_DG) {
1447
1452 } else {
1454 }
1455 } else {
1456 ampl = 0.0;
1457 atau = 0.0;
1460 }
1461
1462 if (
msgLvl(MSG::VERBOSE)) {
1464 msg(MSG::VERBOSE) <<
" sy=" <<
sy
1465 << " sg=" << sg
1466 <<
" sgp=" << sgp <<
endmsg;
1467
1468 msg(MSG::VERBOSE) <<
" syg=" << syg
1469 << " sygp=" << sygp
1470 <<
" sgg=" << sgg <<
endmsg;
1471
1472 msg(MSG::VERBOSE) <<
" sggp=" << sggp
1473 <<
" sgpgp=" << sgpgp <<
endmsg;
1474
1475 msg(MSG::VERBOSE) <<
" ampl = (dyg*dgpgp - dygp*dggp)= " << ampl <<
endmsg;
1476 msg(MSG::VERBOSE) <<
" dyg=" << dyg
1477 << " dgpgp=" << dgpgp
1478 <<
" dyg*dgpgp=" << (dyg * dgpgp) <<
endmsg;
1479
1480 msg(MSG::VERBOSE) <<
" dygp=" << dygp
1481 << " dggp=" << dggp
1482 <<
" dygp*dggp=" << (dygp * dggp) <<
endmsg;
1483
1484 msg(MSG::VERBOSE) <<
" dyg=" << dyg
1485 << " dggp=" << dggp
1486 <<
" dyg*dggp=" << (dyg * dggp) <<
endmsg;
1487
1488 msg(MSG::VERBOSE) <<
" dygp=" << dygp
1489 << " dgg=" << dgg
1490 <<
" dygp*dgg=" << (dygp * dgg) <<
endmsg;
1491
1492 msg(MSG::VERBOSE) <<
" dg=" <<
dg
1493 << " atau=" << atau
1495 }
1496
1500
1501 tempChi2 = 0;
1502 nfit_real = 0;
1503
1504 for (int isamp = 0;
1506
1507 ++nfit_real;
1508 dc = yvec0[isamp] -
scaledPulse(xvec[isamp], tpulse, ypulse);
1509 tempChi2 = tempChi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
1511 << " yvec0[" << isamp << "]=" << yvec0[isamp]
1512 << " eyvec[" << isamp << "]=" << eyvec[isamp]
1513 << " dc=" << dc
1514 << " chi2=" << tempChi2 );
1515 }
1516
1517 tempChi2 = tempChi2 / (nfit_real - 3.0);
1519 << " nfit_real=" << nfit_real );
1520 }
1521 }
1522
1523 if (
msgLvl(MSG::VERBOSE))
1524 msg(MSG::VERBOSE) <<
" t0fit: " <<
m_t0Fit << ((
tau < 0.0) ?
" - " :
" + ") << fabs(tau);
1525
1526
1528 if (
msgLvl(MSG::VERBOSE) )
1530
1531
1538 }
1539
1543 amplitude = ampl;
1545 }
1546
1547 }
1548
1550 << " Ped=" << pedestal
1551 << " Amplitude=" << amplitude
1552 <<
" Chi2=" <<
chi2 );
1553}
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
std::vector< double > m_dummy
Gaudi::Property< double > m_maxTimeFromPeak
Gaudi::Property< double > m_noiseThresholdRMS
Gaudi::Property< int > m_maxIterate
Gaudi::Property< double > m_saturatedSampleError
Gaudi::Property< double > m_zeroSampleError
double derivative(double x, const std::vector< double > *xvec, const std::vector< double > *yvec) const
Gaudi::Property< bool > m_disableNegativeAmp
Gaudi::Property< int > m_firstSample
double chi2(TH1 *h0, TH1 *h1)
time(flags, cells_name, *args, **kw)