// -------------------------------------------------------------- // History: // // Created by Letizia Peruzzo (letizia.peruzzo@cern.ch) 2016-06-02 // Added cout's for CREAM signal plotting - protopop@cern.ch - Nov 2026 // // Inherit from MUV12 Reconstruction // -------------------------------------------------------------- /// \class SAVReconstruction /// \Brief /// \EndBrief /// \Detailed /// The reconstruction makes use of the base class NA62VReconstruction and of the classes in NA62MC/SAC/Persistency (TRecoSAVEvent, TRecoSAVCandidate, TRecoSAVHit). ///\n /// The SAV reconstruction basic parameters are set in NA62Reconstruction/config/SAV.conf /// \n /// \========= /// \n /// SAV.conf /// \n /// \========= /// \n /// Description of parameters can be found in SAV.conf, here the parameters you may want to change to perform your own reconstruction: /// \n\n /// \===================================================================================================================================== /// \n /// SAV Reconstruction /// \EndDetailed /// \author Created by Letizia Peruzzo (letizia.peruzzo@cern.ch) #include "SAVReconstruction.hh" #include "CalL0Emulator.hh" #include "FADCEvent.hh" #include "NA62ConditionsService.hh" #include "NA62VDetectorDecoder.hh" #include "NA62VRawDecoder.hh" #include "Riostream.h" #include "SAVDigitizer.hh" #include "TH1.h" #include "TObjString.h" #include "TRecoSAVEvent.hh" #include "TRecoSAVHit.hh" #include "TRegexp.h" #include "TSAVDigi.hh" #include "TSlimRecoSAVEvent.hh" #include "TSpecialTriggerEvent.hh" #include #include #include void mystaticSAVChiSquareSinglePeakFCN(Int_t &npars, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag) { // Array par contains one more value than npars (dummy parameter containing pointer) SAVReconstruction *sav_reco = reinterpret_cast((uintptr_t)(par[npars])); sav_reco->ChiSquareSinglePeakFCN(npars, gin, f, par, iflag); } void mystaticSAVChiSquareDoublePeakFCN(Int_t &npars, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag) { // Array par contains one more value than npars (dummy parameter containing pointer) SAVReconstruction *sav_reco = reinterpret_cast((uintptr_t)(par[npars])); sav_reco->ChiSquareDoublePeakFCN(npars, gin, f, par, iflag); } SAVReconstruction::SAVReconstruction(TString ConfigFileName, TString /*rawDecType*/): NA62VReconstruction("SAV", ConfigFileName, &SAVConfig::GetInstanceMod()), fFitter1(nullptr), fFitter2(nullptr), fLastNsamp(128), fFirstSlot(31), fLastSlot(0) { //Initializing the fitter fFitter1 = new TMinuit(5); arg1 = 1.; ierflg1 = 0; fFitter1->SetPrintLevel(-1); fFitter1->mnexcm("SET ERR", &arg1, 1, ierflg1); fFitter1->SetFCN(mystaticSAVChiSquareSinglePeakFCN); fFitter2 = new TMinuit(8); arg2 = 1.; ierflg2 = 0; fFitter2->SetPrintLevel(-1); fFitter2->mnexcm("SET ERR", &arg2, 1, ierflg2); fFitter2->SetFCN(mystaticSAVChiSquareDoublePeakFCN); fL0Emulator = new CalL0Emulator(3, 2, 32, 0); } SAVReconstruction::~SAVReconstruction() { if(fFitter1) { delete fFitter1; fFitter1 = nullptr; } if(fFitter2) { delete fFitter2; fFitter2 = nullptr; } delete fL0Emulator; fL0Emulator = nullptr; } void SAVReconstruction::Init() { //common part for all the subdetectors NA62VReconstruction::Init(); } Bool_t SAVReconstruction::Trigger(TDetectorVEvent * /* tEvent */, Event * /*tGenEvent*/) { return true; } void SAVReconstruction::StartOfBurst(Int_t runID, Int_t burstID) { NA62VReconstruction::StartOfBurst(runID, burstID); // common part for all the subdetectors fL0Emulator->SetRunID(runID); } void SAVReconstruction::EndOfBurst(Int_t runID, Int_t burstID) { NA62VReconstruction::EndOfBurst(runID, burstID); // common part for all the subdetectors } TRecoVEvent *SAVReconstruction::ProcessEvent(EventHeader &eventHeader, TDetectorVEvent *tEvent, Event *tGenEvent) { //Special Triggers if(tEvent->IsA() == TSpecialTriggerEvent::Class()) { //read it return nullptr; } //common part for all the subdetectors TRecoSAVEvent *fRecoEvent = new TRecoSAVEvent(); NA62VReconstruction::ProcessEventBase(fRecoEvent, tEvent, tGenEvent); fL0Emulator->SetStationT0(SAVConfig::GetInstance().GetReconstructionConfig()->GetStationT0(0)); Int_t NDigis = tEvent->GetNHits(); if(NDigis < 1) { fL0Emulator->Process(static_cast(tEvent), &eventHeader); return fRecoEvent; //No digi found } TClonesArray &Digis = *static_cast(tEvent)->GetHits(); //Preparing to store hits std::vector PeakPosition; TRecoSAVHit *ThisHit; // -------------------------------------------------------------------------------------------- // // Loop over digis and produce hits ------------------------------------------------------------------------ // // -------------------------------------------------------------------------------------------- // for(Int_t iHit = 0; iHit < NDigis; iHit++) { TSAVDigi *Digi = static_cast(Digis[iHit]); Double_t *Amplitude = Digi->GetADCSamples(); Int_t Nsamples = Digi->GetNSamples(); Int_t DetectorID = Digi->GetChannelID() / 10; // 0=SAC 1=IRC Int_t Channel = Digi->GetChannelID() % 10 - 1; //Int_t Slot = fFirstSlot + fDetectorDecoder->GetDecoder()->GetChannelRO(Digi->GetChannelID()) / 32; Int_t Slot = fFirstSlot + SAVConfig::GetInstance().GetRawDecoderConfig()->GetChannelRO(Digi->GetChannelID()) / 32; //Int_t CREAMChannel = fDetectorDecoder->GetDecoder()->GetChannelRO(Digi->GetChannelID())%32; if(Slot > fLastSlot) fLastSlot = Slot; if(Slot < fFirstSlot) fFirstSlot = Slot; fLastNsamp = Nsamples; // DP debug info string std::ostringstream pulse_info; UInt_t evnum = eventHeader.GetEventNumber(); pulse_info << evnum << " " << DetectorID << " " << Channel << " " << Slot << " "; pulse_info << "Samples " << Nsamples << " "; // Hit Position TVector3 HitPos(0, 0, 0); HitPos[0] = Digi->GetChannelPosition().X(); HitPos[1] = Digi->GetChannelPosition().Y(); UInt_t flag = Digi->GetFlags(); Bool_t Saturation = ((flag & (1 << NA62::kCREAMSaturationBit)) != 0); //event with points saturating the ADC scale Bool_t Underflow = ((flag & (1 << NA62::kCREAMUnderflowBit)) != 0); //event with points under the ADC scale Saturation = Saturation && SAVConfig::GetInstance().GetSaveSaturated(); Underflow = Underflow && SAVConfig::GetInstance().GetSaveUnderflow(); //------------------------------------------- // Hits. //------------------------------------------- //------------------------------------------- //Determining baseline value for this event //------------------------------------------- Int_t Npoint = 0; //Number of points for baseline calculation Double_t mean = 0; //Baseline variable Double_t minimum = Amplitude[0], maximum = Amplitude[0]; //maximum oscillation of the baseline Double_t min = minimum, max = maximum; //global maximum and minimum Double_t int_base = 0, int_sig = 0; Int_t skip = 0; for(Int_t i = 0; i < Nsamples; i++) { fSAVFitDataX[i] = i; fSAVFitDataErrorX[i] = 1. / ClockPeriod; fSAVFitDataY[i] = Amplitude[i]; fSAVFitDataErrorY[i] = 3.; if(Amplitude[i] > max) max = Amplitude[i]; if(Amplitude[i] < min) min = Amplitude[i]; // DP debug info pulse_info << Amplitude[i] << " "; if(i < 5) int_base += (Amplitude[i]) / 5.; if(i >= (Nsamples / 2. - 2) && i <= Nsamples / 2. + 2) int_sig += (Amplitude[i]) / 5.; if(i < 1 || i > Nsamples - 2) continue; if(skip > 0) { skip--; continue; } Double_t der2 = -1.; if(i < Nsamples - 1) der2 = TMath::Abs((Amplitude[i + 1] - Amplitude[i - 1]) / 2.); if(der2 > 5) { skip = 2; continue; } mean += Amplitude[i]; if(Amplitude[i] < minimum) minimum = Amplitude[i]; if(Amplitude[i] > maximum) maximum = Amplitude[i]; Npoint++; } //-------------------------------------------- //Peaks finding //-------------------------------------------- if(Npoint >= 5) mean /= Npoint; else mean = min + 10; //absolute minimum taken as reference if there are not enough points for the baseline extimation // DP debug info pulse_info << mean << " " << min << " " << max << " "; if(max - min < 10.) continue; //If any peak is present it is too small if((mean - min) > 50. && min > 100.) mean = min + 50; //too high distance between minimum and extimated baseline const Double_t DerLim = 15.; //Limit on the derivative const Double_t DerLim2 = 20.; //Tighter limit on the derivative const Double_t AmpLim = 20.; //Limit on the Amplitude PeakPosition.clear(); Double_t Der2Pt = 0; for(Int_t iPt = 1; iPt < Nsamples; iPt++) { Der2Pt = (Amplitude[iPt] - Amplitude[iPt - 1]); if(Der2Pt < DerLim) continue; if((Amplitude[iPt] - mean) < AmpLim && Der2Pt < DerLim2) continue; while(iPt + 1 < Nsamples && Amplitude[iPt] < Amplitude[iPt + 1]) iPt++; if(iPt > Nsamples - 2) continue; PeakPosition.push_back(iPt); } // DP debug info section ========= UInt_t peaksFound = PeakPosition.size(); Bool_t train = false; pulse_info << peaksFound << " "; if(peaksFound > 0){ for(UInt_t iPeak = 0; iPeak < peaksFound; iPeak++){ pulse_info << PeakPosition[iPeak] << " "; } } // DP debug: looking for undershoot // if (peaksFound < 1 || (peaksFound > 1 || PeakPosition[0] > 3) ) // continue; // DP debug info ================== if(peaksFound != 1 && !train){ std::cout << pulse_info.str() << std::endl; } // else we will append fit results if(PeakPosition.size() < 1) continue; //No peak found // DP debug info ================== if(peaksFound == 1 && train){ // decide if pulse is good for training if (PeakPosition[0] > 3 && PeakPosition[0] < 7 && fabs(Amplitude[0] - Amplitude[9]) < 20 ){ std::cout << pulse_info.str() << std::endl; } } // ================================ //---------------------- //Fitting the peaks //---------------------- for(UInt_t iPeak = 0; iPeak < PeakPosition.size(); iPeak++) { //Single peak baseline determination Double_t base = 0.; Int_t ibase = PeakPosition[iPeak]; if(PeakPosition[iPeak] > Nsamples / 2.) { while(ibase - 1 >= 0 && Amplitude[ibase] > Amplitude[ibase - 1]) { ibase--; } } else { while(ibase + 1 < Nsamples - 1 && Amplitude[ibase] > Amplitude[ibase + 1]) { ibase++; } } base = Amplitude[ibase]; //Comparison with the event baseline if((base - mean) > 100) base = mean; else if((base - mean) > 80) base = (2. * mean + base) / 3.; else if((base - mean) > 60) base = (base + mean) / 2.; else if((base - mean) > 40) base = (2. * base + mean) / 3.; //---------------------------------- //Two peaks at less than 8 bins //---------------------------------- if(PeakPosition.size() > 1 && iPeak < (PeakPosition.size() - 1) && (PeakPosition[iPeak + 1] - PeakPosition[iPeak]) < 8) { //Setting Fit data addresses for Minuit //Assign correct window for the fit (fit starts 7 points before peak) fSAVFitDataXptr = &fSAVFitDataX[(PeakPosition[iPeak] - 7 >= 0 ? PeakPosition[iPeak] - 7 : 0)]; fSAVFitDataYptr = &fSAVFitDataY[(PeakPosition[iPeak] - 7 >= 0 ? PeakPosition[iPeak] - 7 : 0)]; fSAVFitDataErrorXptr = &fSAVFitDataErrorX[(PeakPosition[iPeak] - 7 >= 0 ? PeakPosition[iPeak] - 7 : 0)]; fSAVFitDataErrorYptr = &fSAVFitDataErrorY[(PeakPosition[iPeak] - 7 >= 0 ? PeakPosition[iPeak] - 7 : 0)]; fNSAVFitPoints = 1 + ((PeakPosition[iPeak + 1] + 3 < Nsamples ? PeakPosition[iPeak + 1] + 3 : Nsamples - 1) - (PeakPosition[iPeak] - 7 >= 0 ? PeakPosition[iPeak] - 7 : 0)); //Determining the starting values for the fit of the first peak Double_t peak_time_1 = PeakPosition[iPeak] * Amplitude[PeakPosition[iPeak]]; Double_t peak_amp_1 = Amplitude[PeakPosition[iPeak]]; for(Int_t i = 1; i < 5; i++) { if(PeakPosition[iPeak] - i < 0 || PeakPosition[iPeak] + i > Nsamples - 1) break; Bool_t der = (Amplitude[PeakPosition[iPeak] - i] - Amplitude[PeakPosition[iPeak] - i + 1]) < 0; der &= (Amplitude[PeakPosition[iPeak] + i] - Amplitude[PeakPosition[iPeak] + i - 1]) < 0; if(!der) break; peak_time_1 += (i + PeakPosition[iPeak]) * (Amplitude[PeakPosition[iPeak] + i]); peak_amp_1 += Amplitude[PeakPosition[iPeak] + i]; peak_time_1 += (PeakPosition[iPeak] - i) * (Amplitude[PeakPosition[iPeak] - i]); peak_amp_1 += Amplitude[PeakPosition[iPeak] - i]; } peak_time_1 /= peak_amp_1; Double_t peak_sigma_1 = 0.; peak_amp_1 = 0.; Int_t Nsigma_1 = 0; for(Int_t i = 0; i < 5; i++) { if(PeakPosition[iPeak] - i >= 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak] - i] - Amplitude[PeakPosition[iPeak] - i + 1]) < 0 || i == 0); if(der && Amplitude[PeakPosition[iPeak] - i] < Amplitude[PeakPosition[iPeak]]) { Nsigma_1++; peak_sigma_1 += (peak_time_1 - PeakPosition[iPeak] + i) * (peak_time_1 - PeakPosition[iPeak] + i) * (Amplitude[PeakPosition[iPeak] - i] - mean); peak_amp_1 += (Amplitude[PeakPosition[iPeak] - i] - mean); } } if(PeakPosition[iPeak] + i < Nsamples && i > 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak] + i] - Amplitude[PeakPosition[iPeak] + i - 1]) < 0); if(der && Amplitude[PeakPosition[iPeak] + i] < Amplitude[PeakPosition[iPeak]]) { Nsigma_1++; peak_sigma_1 += (peak_time_1 - PeakPosition[iPeak] - i) * (peak_time_1 - PeakPosition[iPeak] - i) * (Amplitude[PeakPosition[iPeak] + i] - mean); peak_amp_1 += (Amplitude[PeakPosition[iPeak] + i] - mean); } } } if(peak_sigma_1 / peak_amp_1 >= 0) peak_sigma_1 = TMath::Sqrt(peak_sigma_1 / peak_amp_1); if(peak_sigma_1 < 1. || peak_sigma_1 > 5. || peak_sigma_1 / peak_amp_1 < 0) { Nsigma_1 = 1; peak_sigma_1 = 1.2; } //Determining the starting values for the second peak fitting Double_t peak_time_2 = PeakPosition[iPeak + 1] * Amplitude[PeakPosition[iPeak + 1]]; Double_t peak_amp_2 = Amplitude[PeakPosition[iPeak + 1]]; for(Int_t i = 1; i < 5; i++) { if(PeakPosition[iPeak + 1] - i < 0 || PeakPosition[iPeak + 1] + i > Nsamples - 1) break; Bool_t der = (Amplitude[PeakPosition[iPeak + 1] - i] - Amplitude[PeakPosition[iPeak + 1] - i + 1]) < 0; der &= (Amplitude[PeakPosition[iPeak + 1] + i] - Amplitude[PeakPosition[iPeak + 1] + i - 1]) < 0; if(!der) break; peak_time_2 += (i + PeakPosition[iPeak + 1]) * (Amplitude[PeakPosition[iPeak + 1] + i]); peak_amp_2 += Amplitude[PeakPosition[iPeak + 1] + i]; peak_time_2 += (PeakPosition[iPeak + 1] - i) * (Amplitude[PeakPosition[iPeak + 1] - i]); peak_amp_2 += Amplitude[PeakPosition[iPeak + 1] - i]; } peak_time_2 /= peak_amp_2; Double_t peak_sigma_2 = 0.; peak_amp_2 = 0.; Int_t Nsigma_2 = 0; for(Int_t i = 0; i < 5; i++) { if(PeakPosition[iPeak + 1] - i >= 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak + 1] - i] - Amplitude[PeakPosition[iPeak + 1] - i + 1]) < 0 || i == 0); if(der && Amplitude[PeakPosition[iPeak + 1] - i] < Amplitude[PeakPosition[iPeak + 1]]) { Nsigma_2++; peak_sigma_2 += (peak_time_2 - PeakPosition[iPeak + 1] + i) * (peak_time_2 - PeakPosition[iPeak + 1] + i) * (Amplitude[PeakPosition[iPeak + 1] - i] - mean); peak_amp_2 += (Amplitude[PeakPosition[iPeak + 1] - i] - mean); } } if(PeakPosition[iPeak + 1] + i < Nsamples && i > 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak + 1] + i] - Amplitude[PeakPosition[iPeak + 1] + i - 1]) < 0); if(der && Amplitude[PeakPosition[iPeak + 1] + i] < Amplitude[PeakPosition[iPeak + 1]]) { Nsigma_2++; peak_sigma_2 += (peak_time_2 - PeakPosition[iPeak + 1] - i) * (peak_time_2 - PeakPosition[iPeak + 1] - i) * (Amplitude[PeakPosition[iPeak + 1] + i] - mean); peak_amp_2 += (Amplitude[PeakPosition[iPeak + 1] + i] - mean); } } } if(peak_sigma_2 / peak_amp_2 >= 0) peak_sigma_2 = TMath::Sqrt(peak_sigma_2 / peak_amp_2); if(peak_sigma_2 < 1. || peak_sigma_2 > 5. || peak_sigma_2 / peak_amp_2 < 0) { Nsigma_2 = 1; peak_sigma_2 = 1.2; } //Setting up the fitter Double_t vstart[7] = { base, Amplitude[PeakPosition[iPeak]] - base, peak_time_1, peak_sigma_1, Amplitude[PeakPosition[iPeak + 1]] - mean, peak_time_2, peak_sigma_2}; Double_t step[7] = {0.1, 0.1, 0.001, 0.05, 0.1, 0.001, 0.05}; fFitter2->mnparm(0, "Baseline", vstart[0], step[0], 0, 0, ierflg2); fFitter2->mnparm(1, "Amplitude_1", vstart[1], step[1], 0, 0, ierflg2); fFitter2->mnparm(2, "Time_1", vstart[2], step[2], 0, 0, ierflg2); fFitter2->mnparm(3, "Sigma_1", vstart[3], step[3], 0, 0, ierflg2); fFitter2->mnparm(4, "Amplitude_2", vstart[4], step[4], 0, 0, ierflg2); fFitter2->mnparm(5, "Time_2", vstart[5], step[5], 0, 0, ierflg2); fFitter2->mnparm(6, "Sigma_2", vstart[6], step[6], 0, 0, ierflg2); fFitter2->mnparm(7, "dummy", (uintptr_t)this, 0, 0., 0., ierflg2); fFitter2->FixParameter(7); //Setting the limits of the fitting parameters Double_t Limits[3]; Limits[0] = 1; Limits[1] = mean - 30; Limits[2] = mean + 30; fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); if(PeakPosition[iPeak] > 0) { Limits[0] = 2; Limits[1] = (Amplitude[PeakPosition[iPeak]] - base - 60 > 5 ? Amplitude[PeakPosition[iPeak]] - base - 60 : 5); Limits[2] = (Amplitude[PeakPosition[iPeak]] - base + 60 > 60 ? Amplitude[PeakPosition[iPeak]] - base + 60 : 60); fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); Limits[0] = 3; Limits[1] = PeakPosition[iPeak] - peak_sigma_1 / TMath::Sqrt(Nsigma_1); Limits[2] = PeakPosition[iPeak] + peak_sigma_1 / TMath::Sqrt(Nsigma_1); fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); } Limits[0] = 4; Limits[1] = 1.; Limits[2] = 3.; fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); Limits[0] = 5; Limits[1] = 5.; Limits[2] = (Amplitude[PeakPosition[iPeak + 1]] - base + 60 > 60 ? Amplitude[PeakPosition[iPeak + 1]] - base + 60 : 60); fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); Limits[0] = 6; Limits[1] = PeakPosition[iPeak + 1] - peak_sigma_2 / TMath::Sqrt(Nsigma_2); Limits[2] = PeakPosition[iPeak + 1] + peak_sigma_2 / TMath::Sqrt(Nsigma_2); fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); Limits[0] = 7; Limits[1] = 1.; Limits[2] = 3.; fFitter2->mnexcm("SET LIM", Limits, 3, ierflg2); //Fitting Double_t Args[2] = {1000., 1.}; Double_t FitPars[8], FitParErrors[8]; fFitter2->mnexcm("MIGRAD", Args, 2, ierflg2); //Exporting the fitting results for(Int_t ipar = 0; ipar < 7; ipar++) fFitter2->GetParameter(ipar, FitPars[ipar], FitParErrors[ipar]); //Resetting the fitter fFitter2->mnexcm("CLE", Args, 0, ierflg2); Double_t baseline = FitPars[0]; //Determining peak 1 position and amplitude Double_t time1 = (FitPars[2] - Digi->GetTriggerSample()) * ClockPeriod; Double_t peak1 = FitPars[1]; Double_t energy1 = peak1; if(peak1 > 0. && peak1 < 3.e+4) { // Time correction time1 -= SAVConfig::GetInstance().GetT0Correction(Digi, fTriggerDriftT0); time1 -= SAVConfig::GetInstance().GetChannelT0(Digi->GetChannelID()); // SAC channel equalization. if(DetectorID == 0) { peak1 *= SAVConfig::GetInstance().GetSACChannelEq(Channel); // SAC energy. energy1 = peak1 / SAVConfig::GetInstance().GetSAVCalibration(0).second; } // IRC energy. if(DetectorID == 1) energy1 = peak1 / SAVConfig::GetInstance().GetSAVCalibration(Channel + 1).second; GetMyMonitor()->GetHChannelsOccupancy()->Fill(Digi->GetChannelID()); GetMyMonitor()->GetHAmplitudeVSChannel()->Fill(Digi->GetChannelID(), peak1); GetMyMonitor()->GetHBaselinesVSChannel()->Fill(Digi->GetChannelID(), baseline); GetMyMonitor()->GetHEnergyVSChannel()->Fill(Digi->GetChannelID(), energy1); if(TMath::Abs(time1 - eventHeader.GetFineTime() * ClockPeriod / 256.) < 20.) GetMyMonitor()->GetHEnergyVSChannel_L0intime()->Fill(Digi->GetChannelID(), energy1); GetMyMonitor()->GetHHitTime()->Fill(FitPars[2], Slot); GetMyMonitor()->GetHHitTime_L0Time()->Fill(time1 - eventHeader.GetFineTime() * ClockPeriod / 256.); GetMyMonitor()->GetHHitTimeVSBurst()->Fill(fRecoEvent->GetBurstID(), time1); GetMyMonitor()->GetHHitTimeVSChannel()->Fill(Digi->GetChannelID(), time1); // add hit information. ThisHit = static_cast(fRecoEvent->AddHit(Digi)); ThisHit->DecodeChannelID(Digi->GetChannelID()); ThisHit->SetTime(time1); ThisHit->SetAmplitude(peak1); ThisHit->SetBaseline(baseline); ThisHit->SetEnergy(energy1 * 1000.); ThisHit->SetPosition(HitPos); } //Determining peak 2 position and amplitude Double_t time2 = (FitPars[5] - Digi->GetTriggerSample()) * ClockPeriod; Double_t peak2 = FitPars[4]; Double_t energy2 = peak2; if(peak2 > 0. && peak2 < 3.e+4) { // Time correction time2 -= SAVConfig::GetInstance().GetT0Correction(Digi, fTriggerDriftT0); time2 -= SAVConfig::GetInstance().GetChannelT0(Digi->GetChannelID()); // SAC channel equalization. if(DetectorID == 0) { peak2 *= SAVConfig::GetInstance().GetSACChannelEq(Channel); // SAC energy. energy2 = peak2 / SAVConfig::GetInstance().GetSAVCalibration(0).second; } // IRC energy. if(DetectorID == 1) energy2 = peak2 / SAVConfig::GetInstance().GetSAVCalibration(Channel + 1).second; GetMyMonitor()->GetHChannelsOccupancy()->Fill(Digi->GetChannelID()); GetMyMonitor()->GetHAmplitudeVSChannel()->Fill(Digi->GetChannelID(), peak2); GetMyMonitor()->GetHEnergyVSChannel()->Fill(Digi->GetChannelID(), energy2); if(TMath::Abs(time2 - eventHeader.GetFineTime() * ClockPeriod / 256.) < 20.) GetMyMonitor()->GetHEnergyVSChannel_L0intime()->Fill(Digi->GetChannelID(), energy2); GetMyMonitor()->GetHHitTime()->Fill(FitPars[2], Slot); GetMyMonitor()->GetHHitTime_L0Time()->Fill(time2 - eventHeader.GetFineTime() * ClockPeriod / 256.); GetMyMonitor()->GetHHitTimeVSBurst()->Fill(fRecoEvent->GetBurstID(), time2); GetMyMonitor()->GetHHitTimeVSChannel()->Fill(Digi->GetChannelID(), time2); // add hit information. ThisHit = static_cast(fRecoEvent->AddHit(Digi)); ThisHit->DecodeChannelID(Digi->GetChannelID()); ThisHit->SetTime(time2); ThisHit->SetAmplitude(peak2); ThisHit->SetBaseline(baseline); ThisHit->SetEnergy(energy2 * 1000.); ThisHit->SetPosition(HitPos); } iPeak++; continue; } //--------------------------------- //Isolated one peak //--------------------------------- else { //Setting Fit data addresses for minuit //Assign correct window to the fit (fit starts 5 points before peak) fSAVFitDataXptr = &fSAVFitDataX[(PeakPosition[iPeak] - 5 >= 0 ? PeakPosition[iPeak] - 5 : 0)]; fSAVFitDataYptr = &fSAVFitDataY[(PeakPosition[iPeak] - 5 >= 0 ? PeakPosition[iPeak] - 5 : 0)]; fSAVFitDataErrorXptr = &fSAVFitDataErrorX[(PeakPosition[iPeak] - 5 >= 0 ? PeakPosition[iPeak] - 5 : 0)]; fSAVFitDataErrorYptr = &fSAVFitDataErrorY[(PeakPosition[iPeak] - 5 >= 0 ? PeakPosition[iPeak] - 5 : 0)]; fNSAVFitPoints = 1 + ((PeakPosition[iPeak] + 3 < Nsamples ? PeakPosition[iPeak] + 3 : Nsamples - 1) - (PeakPosition[iPeak] - 5 >= 0 ? PeakPosition[iPeak] - 5 : 0)); //Determining starting values for the fit Double_t peak_time = PeakPosition[iPeak] * Amplitude[PeakPosition[iPeak]]; Double_t peak_amp = Amplitude[PeakPosition[iPeak]]; for(Int_t i = 1; i < 7; i++) { if(PeakPosition[iPeak] - i < 0 || PeakPosition[iPeak] + i > Nsamples - 1) break; Bool_t der = (Amplitude[PeakPosition[iPeak] - i] - Amplitude[PeakPosition[iPeak] - i + 1]) < 0; der &= (Amplitude[PeakPosition[iPeak] + i] - Amplitude[PeakPosition[iPeak] + i - 1]) < 0; if(!der) break; peak_time += (i + PeakPosition[iPeak]) * (Amplitude[PeakPosition[iPeak] + i]); peak_amp += Amplitude[PeakPosition[iPeak] + i]; peak_time += (PeakPosition[iPeak] - i) * (Amplitude[PeakPosition[iPeak] - i]); peak_amp += Amplitude[PeakPosition[iPeak] - i]; } peak_time /= peak_amp; Double_t peak_sigma = 0.; peak_amp = 0.; Int_t Nsigma = 0; for(Int_t i = 0; i < 5; i++) { if(PeakPosition[iPeak] - i >= 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak] - i] - Amplitude[PeakPosition[iPeak] - i + 1]) < 0); if(der && Amplitude[PeakPosition[iPeak] - i] < Amplitude[PeakPosition[iPeak]]) { peak_sigma += (peak_time - PeakPosition[iPeak] + i) * (peak_time - PeakPosition[iPeak] + i) * (Amplitude[PeakPosition[iPeak] - i] - mean); peak_amp += (Amplitude[PeakPosition[iPeak] - i] - mean); Nsigma++; } } if(PeakPosition[iPeak] + i < Nsamples && i > 0) { Bool_t der = ((Amplitude[PeakPosition[iPeak] + i] - Amplitude[PeakPosition[iPeak] + i - 1]) < 0); if(der && Amplitude[PeakPosition[iPeak] + i] < Amplitude[PeakPosition[iPeak]]) { peak_sigma += (peak_time - PeakPosition[iPeak] - i) * (peak_time - PeakPosition[iPeak] - i) * (Amplitude[PeakPosition[iPeak] + i] - mean); peak_amp += (Amplitude[PeakPosition[iPeak] + i] - mean); Nsigma++; } } } if(peak_sigma / peak_amp >= 0) peak_sigma = TMath::Sqrt(peak_sigma / peak_amp); if(peak_sigma < 1. || peak_sigma > 5. || peak_sigma / peak_amp < 0) peak_sigma = 1.2; //Setting up the fitter Double_t vstart[4] = {base, Amplitude[PeakPosition[iPeak]] - mean, peak_time, peak_sigma}; Double_t step[4] = {0.1, 0.1, 0.001, 0.05}; fFitter1->mnparm(0, "Baseline", vstart[0], step[0], 0, 0, ierflg1); fFitter1->mnparm(1, "Amplitude", vstart[1], step[1], 0, 0, ierflg1); fFitter1->mnparm(2, "Time", vstart[2], step[2], 0, 0, ierflg1); fFitter1->mnparm(3, "Sigma", vstart[3], step[3], 0, 0, ierflg1); fFitter1->mnparm(4, "dummy", (uintptr_t)this, 0, 0., 0., ierflg1); fFitter1->FixParameter(4); //Setting the limits for the fitting parameters Double_t Limits[3]; Limits[0] = 1; Limits[1] = mean - 30; Limits[2] = mean + 30; fFitter1->mnexcm("SET LIM", Limits, 3, ierflg1); if(PeakPosition[iPeak] > 0) { Limits[0] = 2; Limits[1] = ((Amplitude[PeakPosition[iPeak]] - base - 60) > 10 ? (Amplitude[PeakPosition[iPeak]] - base - 60) : 10); Limits[2] = ((Amplitude[PeakPosition[iPeak]] - base + 60) > 10 ? (Amplitude[PeakPosition[iPeak]] - base + 60) : 100); fFitter1->mnexcm("SET LIM", Limits, 3, ierflg1); } Limits[0] = 4; Limits[1] = 1.; Limits[2] = 5.; fFitter1->mnexcm("SET LIM", Limits, 3, ierflg1); if(PeakPosition[iPeak] > 0) { Limits[0] = 3; Limits[1] = PeakPosition[iPeak] - peak_sigma / TMath::Sqrt(Nsigma); Limits[2] = PeakPosition[iPeak] + peak_sigma / TMath::Sqrt(Nsigma); fFitter1->mnexcm("SET LIM", Limits, 3, ierflg1); } //Fitting Double_t Args[2] = {500., 1.}; fFitter1->mnexcm("MIGRAD", Args, 2, ierflg1); Double_t FitPars[8], FitParErrors[8]; for(Int_t ipar = 0; ipar < 4; ipar++) fFitter1->GetParameter(ipar, FitPars[ipar], FitParErrors[ipar]); fFitter1->mnexcm("CLE", Args, 0, ierflg1); //Determining peak position and amplitude Double_t baseline = FitPars[0]; Double_t time = (FitPars[2] - Digi->GetTriggerSample()) * ClockPeriod; Double_t peak = FitPars[1]; Double_t energy = peak; Double_t sigma = FitPars[3] * ClockPeriod; // DP - append fit results for comparison (single peak case) ======= pulse_info << FitPars[0] << " " << peak << " " << time << " " << sigma; // DP - print pulse_info to stdout after appending fit results if(!train){ // not needed for training std::cout << pulse_info.str() << std::endl; } // ================================================================== //Storing the info if(peak > 0. && peak < 3.e+4) { // T0 corrections. time -= SAVConfig::GetInstance().GetT0Correction(Digi, fTriggerDriftT0); time -= SAVConfig::GetInstance().GetChannelT0(Digi->GetChannelID()); // SAC channel equalization. if(DetectorID == 0) { peak *= SAVConfig::GetInstance().GetSACChannelEq(Channel); energy = peak / SAVConfig::GetInstance().GetSAVCalibration(0).second; } // IRC energy. if(DetectorID == 1) energy = (peak) / SAVConfig::GetInstance().GetSAVCalibration(Channel + 1).second; GetMyMonitor()->GetHChannelsOccupancy()->Fill(Digi->GetChannelID()); GetMyMonitor()->GetHAmplitudeVSChannel()->Fill(Digi->GetChannelID(), peak); GetMyMonitor()->GetHBaselinesVSChannel()->Fill(Digi->GetChannelID(), baseline); GetMyMonitor()->GetHEnergyVSChannel()->Fill(Digi->GetChannelID(), energy); if(TMath::Abs(time - eventHeader.GetFineTime() * ClockPeriod / 256.) < 20.) GetMyMonitor()->GetHEnergyVSChannel_L0intime()->Fill(Digi->GetChannelID(), energy); GetMyMonitor()->GetHHitTime()->Fill(FitPars[1], Slot); GetMyMonitor()->GetHHitTime_L0Time()->Fill(time - eventHeader.GetFineTime() * ClockPeriod / 256.); GetMyMonitor()->GetHHitTimeVSBurst()->Fill(fRecoEvent->GetBurstID(), time); GetMyMonitor()->GetHHitTimeVSChannel()->Fill(Digi->GetChannelID(), time); ThisHit = static_cast(fRecoEvent->AddHit(Digi)); ThisHit->DecodeChannelID(Digi->GetChannelID()); ThisHit->SetTime(time); ThisHit->SetAmplitude(peak); ThisHit->SetBaseline(baseline); ThisHit->SetEnergy(energy * 1000.); ThisHit->SetPosition(HitPos); } } } } // -------------------------------------------------------------------------------------------- // // Produce candidates ------------------------------------------------------------------------ // // -------------------------------------------------------------------------------------------- // TClonesArray *HitsArray = fRecoEvent->GetHits(); Int_t Nhits = fRecoEvent->GetNHits(); GetMyMonitor()->GetHNHitsVSBurst()->Fill(fRecoEvent->GetBurstID(), Nhits); std::vector DetectorHits[2]; std::vector Used[2]; Int_t NUsedHits[2] = {0, 0}; Int_t NHits[2] = {0, 0}; Int_t SeedIndex[2] = {-1, -1}; Double_t SeedAmplitude[2] = {0, 0}; // Search the seed. for(Int_t i = 0; i < HitsArray->GetEntries(); i++) { TRecoSAVHit *hit = static_cast(HitsArray->At(i)); Int_t DetectorID = hit->GetDetector(); //Double_t ChannelID = hit->GetChannel() % 10; DetectorHits[DetectorID].push_back(hit); // hit in the detector. Used[DetectorID].push_back(false); // hit not yet used. NHits[DetectorID]++; // number of hits per detector. Double_t A = hit->GetAmplitude(); if(SeedAmplitude[DetectorID] > A) continue; SeedAmplitude[DetectorID] = A; SeedIndex[DetectorID] = NHits[DetectorID] - 1; } // Grouping hits in clusters. for(Int_t jDetector = 0; jDetector < 2; jDetector++) { if(NHits[jDetector] < 1) continue; while((NHits[jDetector] - NUsedHits[jDetector]) > 0) { if(SeedAmplitude[jDetector] < 50.) break; TRecoSAVCandidate *candidate = static_cast(fRecoEvent->AddCandidate()); // start from seed candidate->AddHit(HitsArray->IndexOf(DetectorHits[jDetector][SeedIndex[jDetector]])); Used[jDetector][SeedIndex[jDetector]] = true; NUsedHits[jDetector]++; Int_t NHitsCand = 1; Double_t SeedTime = DetectorHits[jDetector][SeedIndex[jDetector]]->GetTime(); Double_t Time = DetectorHits[jDetector][SeedIndex[jDetector]]->GetTime(); Double_t Energy = DetectorHits[jDetector][SeedIndex[jDetector]]->GetEnergy(); Double_t X = DetectorHits[jDetector][SeedIndex[jDetector]]->GetPosition().X() * Energy; Double_t Y = DetectorHits[jDetector][SeedIndex[jDetector]]->GetPosition().Y() * Energy; for(Int_t jHit = 0; jHit < NHits[jDetector]; jHit++) { if(Used[jDetector][jHit]) continue; Double_t hitTime = DetectorHits[jDetector][jHit]->GetTime(); GetMyMonitor()->GetHHitTimeDist(jDetector)->Fill(hitTime - SeedTime); if(TMath::Abs(hitTime - SeedTime) > 5.) continue; GetMyMonitor()->GetHCandidateHitTime(jDetector)->Fill(hitTime - Time / NHitsCand); candidate->AddHit(HitsArray->IndexOf(DetectorHits[jDetector][jHit])); Used[jDetector][jHit] = true; NUsedHits[jDetector]++; NHitsCand++; Time += hitTime; Energy += DetectorHits[jDetector][jHit]->GetEnergy(); X += (DetectorHits[jDetector][jHit]->GetPosition().X() * DetectorHits[jDetector][jHit]->GetEnergy()); Y += (DetectorHits[jDetector][jHit]->GetPosition().Y() * DetectorHits[jDetector][jHit]->GetEnergy()); } Time /= NHitsCand; X /= Energy; Y /= Energy; candidate->SetTime(Time); candidate->SetEnergy(Energy); candidate->SetPosition(X, Y); GetMyMonitor()->GetHCandidateMap(jDetector)->Fill(candidate->GetX(), candidate->GetY()); GetMyMonitor()->GetHNHits(jDetector)->Fill(NUsedHits[jDetector]); GetMyMonitor()->GetHCandidateEnergy(jDetector)->Fill(Energy / 1000.); SeedAmplitude[jDetector] = 0; SeedIndex[jDetector] = -1; for(Int_t j = 0; j < NHits[jDetector]; j++) { if(Used[jDetector][j]) continue; if(DetectorHits[jDetector][j]->GetAmplitude() < SeedAmplitude[jDetector]) continue; SeedAmplitude[jDetector] = DetectorHits[jDetector][j]->GetAmplitude(); SeedIndex[jDetector] = j; } } } fL0Emulator->Process(static_cast(tEvent), &eventHeader); return fRecoEvent; } void SAVReconstruction::EndProcessing() { NA62VReconstruction::EndProcessing(); // call base class for raw hist output } void SAVReconstruction::FillTimes(EventHeader & /*eventHeader*/, TRecoVEvent *fRecoEvent, Double_t ReferenceTime) { //-- add here the user code to fill histos for T0 evaluation --// if(fHRecoHitTimeWrtReferenceVsROChannel) { TClonesArray *Hits = fRecoEvent->GetHits(); for(Int_t i = 0; i < fRecoEvent->GetNHits(); i++) { TRecoSAVHit *Hit = static_cast(Hits->At(i)); Int_t channel = Hit->GetChannelID(); //Int_t ROChannel = fDetectorDecoder->GetDecoder()->GetChannelRO(Hit->GetChannelID()); Int_t ROChannel = SAVConfig::GetInstance().GetRawDecoderConfig()->GetChannelRO(Hit->GetChannelID()); if(fHRecoHitTimeWrtReferenceVsROChannel) fHRecoHitTimeWrtReferenceVsROChannel->Get()->Fill(ROChannel, Hit->GetTime() - ReferenceTime); if(fHRecoHitTimeWrtReferenceVsROChannelNoT0) fHRecoHitTimeWrtReferenceVsROChannelNoT0->Get()->Fill(ROChannel, Hit->GetTime() - ReferenceTime + SAVConfig::GetInstance().GetChannelT0(channel)); } } } Double_t SAVReconstruction::SinglePeakFunction(Double_t x, Double_t *pars) { Double_t value = pars[0]; value += pars[1] * TMath::Gaus(x, pars[2], pars[3]); return value; } void SAVReconstruction::ChiSquareSinglePeakFCN(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/) { Double_t chisquare = 0.; for(Int_t i = 0; i < fNSAVFitPoints; i++) { Double_t delta = (SinglePeakFunction(fSAVFitDataXptr[i], par) - fSAVFitDataYptr[i]); Double_t err2_x = SinglePeakFunction(fSAVFitDataErrorXptr[i] + fSAVFitDataXptr[i], par); err2_x -= SinglePeakFunction(fSAVFitDataXptr[i] - fSAVFitDataErrorXptr[i], par); err2_x *= err2_x / 4.; Double_t err2_y = fSAVFitDataErrorYptr[i] * fSAVFitDataErrorYptr[i]; Double_t err2 = err2_x + err2_y; chisquare += delta * delta / err2; } f = chisquare; } Double_t SAVReconstruction::DoublePeakFunction(Double_t x, Double_t *pars) { Double_t value = pars[0]; value += pars[1] * TMath::Gaus(x, pars[2], pars[3]); value += pars[4] * TMath::Gaus(x, pars[5], pars[6]); return value; } void SAVReconstruction::ChiSquareDoublePeakFCN(Int_t & /*npar*/, Double_t * /*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/) { Double_t chisquare = 0.; for(Int_t i = 0; i < fNSAVFitPoints; i++) { Double_t delta = (DoublePeakFunction(fSAVFitDataXptr[i], par) - fSAVFitDataYptr[i]); Double_t err2_x = DoublePeakFunction(fSAVFitDataErrorXptr[i] + fSAVFitDataXptr[i], par); err2_x -= DoublePeakFunction(fSAVFitDataXptr[i] - fSAVFitDataErrorXptr[i], par); err2_x *= err2_x / 4.; Double_t err2_y = fSAVFitDataErrorYptr[i] * fSAVFitDataErrorYptr[i]; Double_t err2 = err2_x + err2_y; chisquare += delta * delta / err2; } f = chisquare; } TRecoVEvent *SAVReconstruction::GetSampleRecoEvent() const { return new TRecoSAVEvent; } TSlimRecoVEvent *SAVReconstruction::GetSampleSlimRecoEvent() const { return new TSlimRecoSAVEvent(); }