diff --git a/core/data/psd/CbmPsdDigi.cxx b/core/data/psd/CbmPsdDigi.cxx
index a4624648fcf10dbbed78894d743941d404607722..eee0c67ab984b118b0ed7e8046e99bf09e386bd8 100644
--- a/core/data/psd/CbmPsdDigi.cxx
+++ b/core/data/psd/CbmPsdDigi.cxx
@@ -46,6 +46,7 @@ CbmPsdDigi::CbmPsdDigi(const CbmPsdDigi& other)
 
   , fdEdepWfm(other.fdEdepWfm)
   , fdAmpl(other.fdAmpl)
+  , fuMinimum(other.fuMinimum)
   , fuTimeMax(other.fuTimeMax)
 
   , fdFitAmpl(other.fdFitAmpl)
@@ -68,6 +69,7 @@ CbmPsdDigi::CbmPsdDigi(CbmPsdDigi&& other)
 
   , fdEdepWfm(other.fdEdepWfm)
   , fdAmpl(other.fdAmpl)
+  , fuMinimum(other.fuMinimum)
   , fuTimeMax(other.fuTimeMax)
 
   , fdFitAmpl(other.fdFitAmpl)
@@ -96,6 +98,7 @@ CbmPsdDigi& CbmPsdDigi::operator=(const CbmPsdDigi& other)
 
     fdEdepWfm = other.fdEdepWfm;
     fdAmpl    = other.fdAmpl;
+    fuMinimum = other.fuMinimum;
     fuTimeMax = other.fuTimeMax;
 
     fdFitAmpl    = other.fdFitAmpl;
@@ -121,6 +124,7 @@ CbmPsdDigi& CbmPsdDigi::operator=(CbmPsdDigi&& other)
 
     fdEdepWfm = other.fdEdepWfm;
     fdAmpl    = other.fdAmpl;
+    fuMinimum = other.fuMinimum;
     fuTimeMax = other.fuTimeMax;
 
     fdFitAmpl    = other.fdFitAmpl;
@@ -187,6 +191,7 @@ void CbmPsdDigi::Streamer(TBuffer& R__b)
 
       R__b >> fdEdepWfm;
       R__b >> fdAmpl;
+      R__b >> fuMinimum;
       R__b >> fuTimeMax;
 
       R__b >> fdFitAmpl;
@@ -238,6 +243,7 @@ void CbmPsdDigi::Streamer(TBuffer& R__b)
 
       R__b << fdEdepWfm;
       R__b << fdAmpl;
+      R__b << fuMinimum;
       R__b << fuTimeMax;
 
       R__b << fdFitAmpl;
diff --git a/core/data/psd/CbmPsdDigi.h b/core/data/psd/CbmPsdDigi.h
index 07dc9d1dd17d6ad5ca52218fe65521b71baaf7e0..dc5b45cc957a6d63e27be4c99cd0d7b4bc97f0cc 100644
--- a/core/data/psd/CbmPsdDigi.h
+++ b/core/data/psd/CbmPsdDigi.h
@@ -148,6 +148,7 @@ public:
 
   Double_t fdEdepWfm = 0.;  /// Energy deposition from waveform [MeV]
   Double_t fdAmpl    = 0.;  /// Amplitude from waveform [mV]
+  UInt_t fuMinimum   = 0;   /// Minimum of waveform [adc samples]
   UInt_t fuTimeMax   = 0;   /// Time of maximum in waveform [adc samples]
 
   Double_t fdFitAmpl    = 0.;    /// Amplitude from fit of waveform [mV]
@@ -180,6 +181,7 @@ private:
 
     ar& fdEdepWfm;
     ar& fdAmpl;
+    ar& fuMinimum;
     ar& fuTimeMax;
 
     ar& fdFitAmpl;
diff --git a/core/data/raw/PsdGbtReader-v1.00.cxx b/core/data/raw/PsdGbtReader-v1.00.cxx
index ec872249ed0ce924fcd8b42c93925c0d9375a90a..6e83d7c804c644db8d34e735733c319aa6dedcdb 100644
--- a/core/data/raw/PsdGbtReader-v1.00.cxx
+++ b/core/data/raw/PsdGbtReader-v1.00.cxx
@@ -37,8 +37,7 @@ namespace PsdDataV100
   void PsdGbtReader::ReadPackHeader()
   {
     PackHdr.clear();
-    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl
-                << std::setfill('0') << std::setw(16) << buffer[word_index + 1] << std::endl;
+    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl;
 
     buffer_shift        = 0;
     PackHdr.uHitsNumber = (buffer[word_index] >> buffer_shift) & (((static_cast<uint16_t>(1)) << PackHdr.HNs) - 1);
@@ -48,8 +47,13 @@ namespace PsdDataV100
     PackHdr.uMagicWord = (buffer[word_index] >> buffer_shift) & (((static_cast<uint16_t>(1)) << PackHdr.MWs) - 1);
     word_index++;
 
-    buffer_shift = 0;
+    if(PackHdr.uMagicWord != 0xb) { 
+      if (print) PackHdr.printout();
+      return;
+    }
 
+    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl;
+    buffer_shift     = 0;
     PackHdr.uAdcTime = (buffer[word_index] >> buffer_shift) & (((static_cast<uint64_t>(1)) << PackHdr.TMs) - 1);
     buffer_shift += PackHdr.TMs;
     PackHdr.uTotalWords = (buffer[word_index] >> buffer_shift) & (((static_cast<uint32_t>(1)) << PackHdr.TWs) - 1);
@@ -83,8 +87,7 @@ namespace PsdDataV100
 
   void PsdGbtReader::ReadHitData()
   {
-    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl
-                << std::setfill('0') << std::setw(16) << buffer[word_index + 1] << std::endl;
+    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl;
 
     uint16_t wfm_point = 0;
     wfm_point          = ((buffer[word_index] >> 8) & 0xffff);
@@ -93,6 +96,7 @@ namespace PsdDataV100
     HitData.uWfm.push_back(wfm_point);
     word_index++;
 
+    save_buffer << std::hex << std::setfill('0') << std::setw(16) << buffer[word_index] << std::endl;
     wfm_point = ((buffer[word_index] >> 16) & 0xffff);
     HitData.uWfm.push_back(wfm_point);
     wfm_point = (buffer[word_index] & 0xffff);
@@ -133,7 +137,7 @@ namespace PsdDataV100
       if (PackHdr.uMagicWord != 0xb) {
         word_is_Pack_header = false;
         if (print) printf("End of microslice\n");
-        word_index -= 2;
+        word_index -= 1;
         break;  //return 1;
       }
       else {
diff --git a/core/detectors/psd/PronyFitter.cxx b/core/detectors/psd/PronyFitter.cxx
index ee0396eb3e9009675ac9bfdfe631814bc66ebaac..0bdd594bbc46b9bf3c4b01ec476937558afffc8f 100644
--- a/core/detectors/psd/PronyFitter.cxx
+++ b/core/detectors/psd/PronyFitter.cxx
@@ -506,7 +506,7 @@ parameters
     fuFitZeroLevel                         = (uint16_t) std::real(fh[0]);
     for (int sample_curr = 0; sample_curr < fSampleTotal; sample_curr++) {
       fit_ampl_in_sample = {0., 0.};
-      if ((sample_curr >= fSignalBegin) && (sample_curr <= fGateEnd)) {
+      if ((sample_curr >= fSignalBegin)) {//&& (sample_curr <= fGateEnd)) {
         for (int i = 0; i < fExpNumber + 1; i++) {
           fit_ampl_in_sample += fh[i] * z_power[i];
           z_power[i] *= fz[i];
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
index 8ae631874d6ad7e83819c34e8e1dbde083d24a06..31f0cf3254b34c46426ba30da5a02292fdc2d7b5 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
@@ -422,66 +422,74 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t uM
                 if (fbMonitorWfmMode) fvhHitWfmChan[uHitChannel]->Reset();
                 if (fbMonitorFitMode) fvhHitFitWfmChan[uHitChannel]->Reset();
 
-                dHitChargeWfm = std::accumulate(uWfm.begin(), uWfm.end(), 0);
-                dHitChargeWfm -= uZeroLevel * uWfm.size();
-                auto const max_iter = std::max_element(uWfm.begin(), uWfm.end());
-                assert(max_iter != uWfm.end());
-                if (max_iter == uWfm.end()) break;
-                //uint8_t hit_time_max = std::distance(uWfm.begin(), max_iter);
-                dHitAmlpitude = *max_iter - uZeroLevel;
-                dHitAmlpitude /= kfAdc_to_mV;
-                dHitChargeWfm /= kfAdc_to_mV;
-                fvhHitAmplChan[uHitChannel]->Fill(dHitAmlpitude);
-                fvhHitChargeByWfmChan[uHitChannel]->Fill(dHitChargeWfm);
-
-                if (fbMonitorWfmMode) {
-                  fvhHitLPChanEvo[uHitChannel]->Fill(fdMsTime - fdStartTime, uWfm.back());
-                  for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
-                    fvhHitWfmChan[uHitChannel]->Fill(wfm_iter, uWfm.at(wfm_iter));
-                  fvhHitWfmChan[uHitChannel]->SetTitle(
-                    Form("Waveform channel %03u charge %0u zero level %0u; Time [adc "
-                         "counts]; Amplitude [adc counts]",
-                         uHitChannel, uSignalCharge, uZeroLevel));
-                  for (uint8_t i = 0; i < kuNbWfmRanges; ++i) {
-                    if (uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i + 1)) {
-                      UInt_t uFlatIndexOfChange = i * kuNbChanPsd + uHitChannel;
-
-                      UInt_t uWfmExampleIter = kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange);
-                      UInt_t uFlatIndexHisto =
-                        uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd + i * kuNbChanPsd + uHitChannel;
-                      fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Reset();
-
-                      for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
-                        fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Fill(wfm_iter, uWfm.at(wfm_iter));
-                      fv3hHitWfmFlattenedChan[uFlatIndexHisto]->SetTitle(
-                        Form("Waveform channel %03u charge %0u zero level %0u; Time "
-                             "[adc counts]; Amplitude [adc counts]",
-                             uHitChannel, uSignalCharge, uZeroLevel));
-
-                      kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange)++;
-                      if (kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) == kuNbWfmExamples)
-                        kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) = 0;
-
-                    }  // if( uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i+1) )
-                  }    // for (uint8_t i=0; i<kuNbWfmRanges; ++i)
-                }      //if (fbMonitorWfmMode)
-
-                if (fbMonitorFitMode) {
+                if (!uWfm.empty()){
+                  dHitChargeWfm = std::accumulate(uWfm.begin(), uWfm.end(), 0);
+                  dHitChargeWfm -= uZeroLevel * uWfm.size();
+                  auto const max_iter = std::max_element(uWfm.begin(), uWfm.end());
+                  assert(max_iter != uWfm.end());
+                  if (max_iter == uWfm.end()) break;
+                  //uint8_t hit_time_max = std::distance(uWfm.begin(), max_iter);
+                  dHitAmlpitude = *max_iter - uZeroLevel;
+                  dHitAmlpitude /= kfAdc_to_mV;
+                  dHitChargeWfm /= kfAdc_to_mV;
+                  fvhHitAmplChan[uHitChannel]->Fill(dHitAmlpitude);
+                  fvhHitChargeByWfmChan[uHitChannel]->Fill(dHitChargeWfm);
+
+                  if (fbMonitorWfmMode) {
+                    fvhHitLPChanEvo[uHitChannel]->Fill(fdMsTime - fdStartTime, uWfm.back());
+                    for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
+                      fvhHitWfmChan[uHitChannel]->Fill(wfm_iter, uWfm.at(wfm_iter));
+                    fvhHitWfmChan[uHitChannel]->SetTitle(
+                      Form("Waveform channel %03u charge %0u zero level %0u; Time [adc "
+                           "counts]; Amplitude [adc counts]",
+                           uHitChannel, uSignalCharge, uZeroLevel));
+                    for (uint8_t i = 0; i < kuNbWfmRanges; ++i) {
+                      if (uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i + 1)) {
+                        UInt_t uFlatIndexOfChange = i * kuNbChanPsd + uHitChannel;
+
+                        UInt_t uWfmExampleIter = kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange);
+                        UInt_t uFlatIndexHisto =
+                          uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd + i * kuNbChanPsd + uHitChannel;
+                        fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Reset();
+
+                        for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
+                          fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Fill(wfm_iter, uWfm.at(wfm_iter));
+                        fv3hHitWfmFlattenedChan[uFlatIndexHisto]->SetTitle(
+                          Form("Waveform channel %03u charge %0u zero level %0u; Time "
+                               "[adc counts]; Amplitude [adc counts]",
+                               uHitChannel, uSignalCharge, uZeroLevel));
+
+                        kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange)++;
+                        if (kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) == kuNbWfmExamples)
+                          kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) = 0;
+
+                      }  // if( uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i+1) )
+                    }    // for (uint8_t i=0; i<kuNbWfmRanges; ++i)
+                  }      //if (fbMonitorWfmMode)
+                }    //if (!uWfm.empty())
+
+
+                if (fbMonitorFitMode && !uWfm.empty()) {
                   int gate_beg = 0;
-                  int gate_end = uWfm.size() - 1;
+                  int gate_end = 10;//uWfm.size() - 1;
                   PsdSignalFitting::PronyFitter Pfitter(2, 2, gate_beg, gate_end);
 
                   Pfitter.SetDebugMode(0);
                   Pfitter.SetWaveform(uWfm, uZeroLevel);
-                  int SignalBeg           = 2;
-                  Int_t best_signal_begin = Pfitter.ChooseBestSignalBeginHarmonics(SignalBeg - 1, SignalBeg + 1);
+                  int SignalBeg           = 4;
+					std::complex<float> first_fit_harmonic  = {0.72,  0.0};
+					std::complex<float> second_fit_harmonic = {0.38, -0.0};
+					Pfitter.SetExternalHarmonics(first_fit_harmonic, second_fit_harmonic);
+					Int_t best_signal_begin = Pfitter.ChooseBestSignalBegin(SignalBeg-1, SignalBeg+1);
+					Pfitter.SetSignalBegin(best_signal_begin);
+					Pfitter.CalculateFitAmplitudes();
 
                   Pfitter.SetSignalBegin(best_signal_begin);
                   Pfitter.CalculateFitHarmonics();
                   Pfitter.CalculateFitAmplitudes();
 
-                  Float_t fit_integral = Pfitter.GetIntegral(gate_beg, gate_end) / kfAdc_to_mV;
-                  Float_t fit_R2       = Pfitter.GetRSquare(gate_beg, gate_end);
+                  Float_t fit_integral = Pfitter.GetIntegral(gate_beg, uWfm.size() - 1) / kfAdc_to_mV;
+                  Float_t fit_R2       = Pfitter.GetRSquare(gate_beg, uWfm.size() - 1);
 
                   std::complex<float>* harmonics = Pfitter.GetHarmonics();
                   std::vector<uint16_t> uFitWfm  = Pfitter.GetFitWfm();
@@ -496,10 +504,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t uM
                   if (fit_R2 > 0.02) continue;
                   fvhFitHarmonic1Chan[uHitChannel]->Fill(std::real(harmonics[1]), std::imag(harmonics[1]));
                   fvhFitHarmonic2Chan[uHitChannel]->Fill(std::real(harmonics[2]), std::imag(harmonics[2]));
-                }  //if (fbMonitorFitMode)
-              }    //if (fbMonitorChanMode)
-
-
+                }  //if (fbMonitorFitMode && !uWfm.empty())
+              }//if (fbMonitorChanMode)
             }  // for(int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber; hit_iter++)
           }
           else if (ReadResult == 1) {
diff --git a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerAlgoPsd.cxx b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerAlgoPsd.cxx
index db12509864ef0e80a80d57b8a2e4a0d94ba22495..e613652c418b9d381b68f42cd854fafb6db22824 100644
--- a/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerAlgoPsd.cxx
+++ b/fles/mcbm2018/unpacker/CbmMcbm2018UnpackerAlgoPsd.cxx
@@ -219,16 +219,6 @@ Bool_t CbmMcbm2018UnpackerAlgoPsd::ProcessTs(const fles::Timeslice& ts)
     }    // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
   }      // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
 
-
-  for (auto& elem : fDigiVect) {
-
-    if (elem.GetSectionID() < 10 && elem.fuZL < 100) {
-      printf("NOWW %s %u %f %f\n", elem.ToString().c_str(), elem.fuZL, elem.fdAmpl,
-             elem.ffFitEdep); /*PsdReader.PrintSaveBuff();*/
-    }
-  }
-
-
   /// Sort the buffers of hits due to the time offsets applied
   std::sort(fDigiVect.begin(), fDigiVect.end(),
             [](const CbmPsdDigi& a, const CbmPsdDigi& b) -> bool { return a.GetTime() < b.GetTime(); });
@@ -337,12 +327,12 @@ Bool_t CbmMcbm2018UnpackerAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t u
         while (PsdReader.GetTotalGbtWordsRead() < uNbMessages) {
           int ReadResult = PsdReader.ReadMs();
           if (fair::Logger::Logging(fair::Severity::debug)) {
-            printf("\n");
+            printf("\nMicroslice idx: %llu\n", fulCurrentMsIdx);
             PsdReader.PrintOut(); /*PsdReader.PrintSaveBuff();*/
           }
           if (ReadResult == 0) {
 
-            double prev_hit_time = (double) fulCurrentMsIdx + PsdReader.VectPackHdr.at(0).uAdcTime * 12.5;  //in ns
+            double prev_hit_time = (double) fulCurrentMsIdx*25. + PsdReader.VectPackHdr.at(0).uAdcTime * 12.5;  //in ns
             //hit loop
             for (uint64_t hit_iter = 0; hit_iter < PsdReader.VectHitHdr.size(); hit_iter++) {
               if (PsdReader.VectPackHdr.size() != PsdReader.VectHitHdr.size()) {
@@ -356,24 +346,9 @@ Bool_t CbmMcbm2018UnpackerAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t u
               //uint8_t uLinkIndex     = PsdReader.VectPackHdr.at(hit_iter).uLinkIndex;
               uint32_t uSignalCharge = PsdReader.VectHitHdr.at(hit_iter).uSignalCharge;
               uint16_t uZeroLevel    = PsdReader.VectHitHdr.at(hit_iter).uZeroLevel;
-              double dHitTime = (double) fulCurrentMsIdx + PsdReader.VectPackHdr.at(hit_iter).uAdcTime * 12.5;  //in ns
-              //double dHitTime = PsdReader.MsHdr.ulMicroSlice*1000. + PsdReader.VectPackHdr.at(hit_iter).uAdcTime*12.5; //in ns
+              double dHitTime = (double) fulCurrentMsIdx*25. + PsdReader.VectPackHdr.at(hit_iter).uAdcTime * 12.5;  //in ns
               std::vector<uint16_t> uWfm = PsdReader.VectHitData.at(hit_iter).uWfm;
-
-              int32_t iHitAmlpitude = 0;
-              int32_t iHitChargeWfm = 0;
-              uint8_t uHitTimeMax   = 0;
-              if (!uWfm.empty()) {
-                iHitChargeWfm = std::accumulate(uWfm.begin(), uWfm.end(), 0);
-                iHitChargeWfm -= uZeroLevel * uWfm.size();
-
-                auto const max_iter = std::max_element(uWfm.begin(), uWfm.end());
-                assert(max_iter != uWfm.end());
-                if (max_iter == uWfm.end()) break;
-
-                uHitTimeMax   = std::distance(uWfm.begin(), max_iter);
-                iHitAmlpitude = *max_iter - uZeroLevel;
-              }
+              double dEdep = (double) uSignalCharge / fUnpackPar->GetMipCalibration(uHitChannel);  // ->now in MeV
 
               if (uHitChannel >= fviPsdChUId.size()) {
                 LOG(error) << "hit channel number out of range! channel index: " << uHitChannel
@@ -385,10 +360,6 @@ Bool_t CbmMcbm2018UnpackerAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t u
               UInt_t uRpdChId = uChId;                  //Should be map(uChId) TODO
               UInt_t uChanUId = fviPsdChUId[uRpdChId];  //unique ID
 
-              double dEdep    = (double) uSignalCharge / fUnpackPar->GetMipCalibration(uHitChannel);  // ->now in MeV
-              double dEdepWfm = (double) iHitChargeWfm / fUnpackPar->GetMipCalibration(uHitChannel);  // ->now in MeV
-              double dAmpl    = (double) iHitAmlpitude / 16.5;                                        // -> now in mV
-
               CbmPsdDigi digi;
               digi.fuAddress = uChanUId;
               digi.fdTime    = dHitTime;
@@ -396,20 +367,67 @@ Bool_t CbmMcbm2018UnpackerAlgoPsd::ProcessMs(const fles::Timeslice& ts, size_t u
               digi.fuZL      = uZeroLevel;
               digi.fdAccum   = (double) PsdReader.VectHitHdr.at(hit_iter).uFeeAccum;
               digi.fdAdcTime = (double) PsdReader.VectPackHdr.at(hit_iter).uAdcTime;
-              digi.fdEdepWfm = dEdepWfm;
-              digi.fdAmpl    = dAmpl;
-              digi.fuTimeMax = uHitTimeMax;
-              digi.fdFitEdep = uWfm.back();
 
-              fDigiVect.emplace_back(digi);
+              if(!uWfm.empty()){
+
+                int32_t iHitAmlpitude = 0;
+                int32_t iHitChargeWfm = 0;
+                uint8_t uHitTimeMax   = 0;
+                uint32_t uHitMinimum   = 0;
+                if (!uWfm.empty()) {
+                  iHitChargeWfm = std::accumulate(uWfm.begin(), uWfm.end(), 0);
+                  iHitChargeWfm -= uZeroLevel * uWfm.size();
 
+		        auto const max_iter = std::max_element(uWfm.begin(), uWfm.end());
+		        assert(max_iter != uWfm.end());
+		        if (max_iter == uWfm.end()) break;
+		        uHitTimeMax   = std::distance(uWfm.begin(), max_iter);
+		        iHitAmlpitude = *max_iter - uZeroLevel;
+
+		        auto const min_iter = std::min_element(uWfm.begin(), uWfm.end());
+		        uHitMinimum = *min_iter;
+                }
+
+                digi.fdEdepWfm = (double) iHitChargeWfm / fUnpackPar->GetMipCalibration(uHitChannel);  // ->now in MeV
+                digi.fdAmpl    = (double) iHitAmlpitude / 16.5;                                        // -> now in mV
+                digi.fuTimeMax = uHitTimeMax;
+                digi.fuMinimum = uHitMinimum; // FIXME
+
+
+
+					int gate_beg = 0;
+					int gate_end = (int)uWfm.size()-1;
+					PsdSignalFitting::PronyFitter Pfitter(2, 2, gate_beg, gate_end);
+					Pfitter.SetDebugMode(0);
+					//std::vector<int> iWfm(uWfm.begin(), uWfm.end());
+					Pfitter.SetWaveform(uWfm, uZeroLevel);
+					int SignalBeg           = 4;
+					//0.6, 0.2 // 0.72 0.38
+					std::complex<float> first_fit_harmonic  = {0.72,  0.0};
+					std::complex<float> second_fit_harmonic = {0.38, -0.0};
+					Pfitter.SetExternalHarmonics(first_fit_harmonic, second_fit_harmonic);
+					Int_t best_signal_begin = Pfitter.ChooseBestSignalBegin(SignalBeg-1, SignalBeg+1);
+					Pfitter.SetSignalBegin(best_signal_begin);
+					Pfitter.CalculateFitAmplitudes();
+
+					digi.fdFitEdep = Pfitter.GetIntegral(gate_beg, gate_end) / fUnpackPar->GetMipCalibration(uHitChannel);  // ->now in MeV
+					digi.fdFitAmpl = (Pfitter.GetMaxAmplitude() - Pfitter.GetZeroLevel()) / 16.5;                           // ->now in mV
+					digi.fdFitR2 = Pfitter.GetRSquare(gate_beg, gate_end);
+					digi.fdFitZL = Pfitter.GetZeroLevel();
+					digi.fdFitTimeMax= Pfitter.GetSignalMaxTime();
+
+
+		}
+
+
+              fDigiVect.emplace_back(digi);
 
               //DEBUG
               if (dHitTime < prev_hit_time) printf("negative time!\n");
               //DEBUG END
               prev_hit_time = dHitTime;
-              //DEBUG
 
+              //DEBUG
             }  // for(int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber; hit_iter++)
           }
           else if (ReadResult == 1) {