FdPulseFinder.cc

Go to the documentation of this file.

#include <fwk/CentralConfig.h>

#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/Trace.h>
#include <utl/TraceAlgorithm.h>
#include <utl/PhysicalConstants.h>
#include <utl/Vector.h>
#include <utl/Point.h>
#include <utl/Math.h>

#include <evt/Event.h>
#include <evt/ShowerRecData.h>
#include <evt/ShowerFRecData.h>

#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/Telescope.h>
#include <fevt/EyeRecData.h>
#include <fevt/EyeHeader.h>
#include <fevt/Pixel.h>
#include <fevt/PixelRecData.h>
#include <fevt/PixelTriggerData.h>
#include <fevt/SLTData.h>

#include <det/Detector.h>

#include <fdet/FDetector.h>
#include <fdet/Telescope.h>
#include <fdet/Camera.h>
#include <fdet/Pixel.h>
#include <fdet/Eye.h>

#include "FdPulseFinder.h"

#include "TTree.h"

#include <sstream>

using namespace std;
using namespace fwk;
using namespace utl;
using namespace evt;
using namespace fevt;
using namespace det;
using namespace fdet;
using namespace FdPulseFinderOG;


VModule::ResultFlag
FdPulseFinder::Init()
{
  CentralConfig& cc = *CentralConfig::GetInstance();
  Branch topB = cc.GetTopBranch("FdPulseFinder");

  if (!topB) {
    ERROR("Could not find branch FdPulseFinder ");
    return eFailure;
  }

  topB.GetChild("verbosity").GetData(fVerbosity);
  topB.GetChild("useAllPixels").GetData(fuseAllPixels);
  topB.GetChild("minSnRatio").GetData(fMinSnRatio);
  topB.GetChild("offset").GetData(fOffsetTime);
  topB.GetChild("minWindowLength").GetData(fMinWindowLengthTime);
  topB.GetChild("maxWindowLength").GetData(fMaxWindowLengthTime);

  // SetMaxTreeSize to avoid problems with large files
  TTree::SetMaxTreeSize(1000*Long64_t(2000000000));

  // info output
  ostringstream info;
  info << "\n"
          " Version: " << GetVersionInfo(VModule::eRevisionNumber) << "\n"
          " Parameters:\n"
          "         min SN ratio: " << fMinSnRatio << "\n"
          "               offset: " << fOffsetTime / ns << "ns\n"
          "    min window length: " << fMinWindowLengthTime / ns << "ns\n"
          "    max window length: " << fMaxWindowLengthTime / ns << "ns\n";
  if (fuseAllPixels)
    info << "       use all pixels: " << fuseAllPixels << '\n';

  INFO(info);

  return eSuccess;
}


VModule::ResultFlag
FdPulseFinder::Run(evt::Event& event)
{
  if (fVerbosity > 0)
    INFO(" searching for pulses ");

  if (!event.HasFEvent())
    return eSuccess;

  bool flagPrintout = false;

  FEvent& fevent = event.GetFEvent();
  for (FEvent::EyeIterator eyeiter = fevent.EyesBegin(ComponentSelector::eHasData);
       eyeiter != fevent.EyesEnd(ComponentSelector::eHasData); ++eyeiter) {

    bool firstRun = true;
    if (eyeiter->HasRecData()) {

      EyeRecData& eyeRec = eyeiter->GetRecData();

      if (eyeRec.GetNPulsedPixels()) {

        if (!flagPrintout) {
          flagPrintout = true;
          INFO("Running 2nd time, using reconstructed geometry to find more pulses.");
        }

        firstRun = false;

        // RESET pulsed pixels list
        if (fVerbosity > 1)
          INFO("cleaning up pulsed pixel list ");
        for (EyeRecData::PixelIterator iPixel = eyeRec.PulsedPixelsBegin();
             iPixel != eyeRec.PulsedPixelsEnd(); ) {
          iPixel = eyeRec.RemovePulsedPixel(iPixel);
        }

        // RESET sdp pixels list
        if (fVerbosity > 1)
          INFO("cleaning up sdp pixel list ");
        for (EyeRecData::PixelIterator iPixel = eyeRec.SDPPixelsBegin();
             iPixel != eyeRec.SDPPixelsEnd(); ) {
          iPixel = eyeRec.RemoveSDPPixel(iPixel);
        }

        // RESET time fit pixels list
        if (fVerbosity > 1)
          INFO("cleaning up time fit pixel list ");
        for (EyeRecData::PixelIterator iPixel = eyeRec.TimeFitPixelsBegin();
             iPixel != eyeRec.TimeFitPixelsEnd(); ) {
          iPixel = eyeRec.RemoveTimeFitPixel(iPixel);
        }
      }
    } else
      eyeiter->MakeRecData();

    for (fevt::Eye::TelescopeIterator teliter = eyeiter->TelescopesBegin(ComponentSelector::eHasData);
         teliter != eyeiter->TelescopesEnd(ComponentSelector::eHasData); ++teliter) {

      fCountPix = 0;
      fCountFlt = 0;
      fCountPulsed = 0;
      fCountNoRecData = 0;
      fCountNoTrigData = 0;
      fCountBoundsErr = 0;

      for (fevt::Telescope::PixelIterator pixiter = teliter->PixelsBegin(ComponentSelector::eHasData);
           pixiter!= teliter->PixelsEnd(ComponentSelector::eHasData); ++pixiter) {

        bool pulseSearched = false;
        bool pulseFound = false;

        if (!firstRun) {

          EyeRecData& eyeRec = eyeiter->GetRecData();

          // Check if module runs after geometry reconstruction
          // If so, use the geometry to find more pulses in non-triggered pixels !
          if (eyeRec.HasFRecShower()) {
            pulseFound = FindAdditionalPulse(*pixiter, *eyeiter, eyeRec.GetFRecShower());
            pulseSearched = true;
          } else {
            if (event.HasRecShower() && event.GetRecShower().HasFRecShower()) {
              pulseFound = FindAdditionalPulse(*pixiter, *eyeiter, event.GetRecShower().GetFRecShower());
              pulseSearched = true;
            }
          }
        }

        // Convert the pulse window widths from time to no. of bins
        const fdet::FDetector& detFD = det::Detector::GetInstance().GetFDetector();
        const fdet::Camera& detCamera = detFD.GetTelescope(*teliter).GetCamera();
        const double lengthFADCBin = detCamera.GetFADCBinSize();
        fOffset = static_cast<unsigned int>(fOffsetTime / lengthFADCBin);
        fMinWindowLength = static_cast<int>(fMinWindowLengthTime / lengthFADCBin);
        fMaxWindowLength = static_cast<int>(fMaxWindowLengthTime / lengthFADCBin);

        if (!pulseSearched)
          pulseFound = FindPulse(*pixiter);

        if (pulseFound) {

          EyeRecData& eyerecdata = eyeiter->GetRecData();
          eyerecdata.AddPulsedPixel(*pixiter);

        }

      }

      ostringstream info;
      info << "nPix=" << fCountPix
           << " nFLT=" << fCountFlt
           << " nNoRec=" << fCountNoRecData
           << " nNoTrg=" << fCountNoTrigData
           << " nErr=" << fCountBoundsErr
           << " nPulse=" << fCountPulsed;
      INFO(info);

    }  // for teliter

  }  // for eyeiter

  return eSuccess;
}


VModule::ResultFlag
FdPulseFinder::Finish()
{
  return eSuccess;
}


bool
FdPulseFinder::FindPulse(fevt::Pixel& pixel)
{
  const fdet::FDetector& detFD = det::Detector::GetInstance().GetFDetector();
  const fdet::Pixel& detPixel = detFD.GetPixel(pixel);

  const int pixelId = pixel.GetId();
  const int eyeId = detPixel.GetEyeId();
  const int telId = detPixel.GetTelescopeId();
  const int channelId = detPixel.GetChannelId();

  ++fCountPix;

  if (!pixel.HasRecData()) {
    if (fVerbosity > 2) {
      ostringstream info;
      info << " Pixel: " << pixelId << " tel: " << telId << " eye: " << eyeId << " has no rec-data ";
      INFO(info);
    }
    ++fCountNoRecData;
    return false;
  }

  fevt::PixelRecData& pixelrec = pixel.GetRecData();

  if (!pixel.HasTriggerData()) {
    if (fVerbosity > 2) {
      ostringstream info;
      info << " Pixel: " << pixelId << " tel: " << telId << " eye: " << eyeId << " has no trigger-data ";
      INFO(info);
    }
    ++fCountNoTrigData;
    return false;
  }

  const fevt::PixelTriggerData& pixelTrig = pixel.GetTriggerData();
  const utl::TraceB& fltTrace = pixelTrig.GetFLTTrace();

  const fdet::Telescope& detTel = detFD.GetEye(eyeId).GetTelescope(telId);
  const fdet::Camera& detCamera = detTel.GetCamera();

  const TraceD& trace = pixelrec.GetPhotonTrace();
  const int firstFLTbin = pixelrec.GetFirstTriggeredTimeBin(); // use as 'has FLT' flag

  if (fVerbosity > 0)
    cout << "\nPixel=" << pixelId << " Tel=" << telId << " channel=" <<channelId
         << " fltBin=" << firstFLTbin << endl;

  // pulse search region
  unsigned int start = 0;
  unsigned int stop = 0;

  if (firstFLTbin >= 0) {

    ++fCountFlt;

    const double fltBinSize = fltTrace.GetBinning(); //detCamera.GetTraceSLTBinSize();
    const unsigned int fltTraceLength = fltTrace.GetSize(); //detCamera.GetTraceSLTBinSize();

    // sanity checks
    if (fltTraceLength != trace.GetSize()) {
      ostringstream err;
      err << " FADC and FLT trace have different sizes! nFADC=" << trace.GetSize()
          << " and nFLT=" << fltTraceLength << ". CONNOT HANDLE!";
      ERROR(err.str());
      return false;
    }

    if (fltBinSize != trace.GetBinning()) {
      ostringstream err;
      err << " FADC and FLT binning differs! bFADC=" << trace.GetBinning()/ns
          << " and bFLT=" << fltBinSize/ns << ". CONNOT HANDLE!";
      ERROR(err.str());
      return false;
    }

    // storage for all FLT trigger section (pulses)
    vector<unsigned int> length;          // length of SLT triggered section
    vector<unsigned int> firstSectionBin; // SLT trace binning
    vector<unsigned int> lastSectionBin;  // SLT trace binning

    if (fVerbosity > 0) {
      cout << "FLT-trace:  ";
      for (unsigned int bin = 0; bin < fltTraceLength; ++bin)
        if (fltTrace[bin])
          cout << "1";
        else
          cout << "0";
      cout << endl;
    }

    // loop FLT/FADC - pixel trace

    unsigned int currLength = 0;
    bool gotTrigger = false;
    for (unsigned int bin = 0; bin < fltTraceLength; ++bin) {

      if (fltTrace[bin]) {  // bin was FLT

        ++currLength;
        if (!gotTrigger) {
          firstSectionBin.push_back(bin);
          gotTrigger = true;
        }

      } else if (gotTrigger) {  // triggered section has ended -> check length

        length.push_back(currLength);
        lastSectionBin.push_back(bin - 1);

        // reset
        currLength = 0;
        gotTrigger = false;
      }
    }  // end loop FLT/FADC trace

    // necessary if last section reaches end of trace
    if (gotTrigger) {
      length.push_back(currLength);
      lastSectionBin.push_back(fltTraceLength - 1);
    }

    // loop found FLT sections, and select the prime candidate for pulse search

    double maxSectionCharge = 0;
    unsigned int noMaxChargeSection = 0;
    for (unsigned int section = 0; section < length.size(); ++section) {

      unsigned int sectionStart = firstSectionBin[section];
      unsigned int sectionStop = lastSectionBin[section];

      unsigned int fltBoxcar = detCamera.GetFLTBoxcarSumLength();

      if (sectionStart < fltBoxcar)
        sectionStart = 0;
      else
        sectionStart = sectionStart - fltBoxcar;

      if (sectionStop + fltBoxcar >= fltTraceLength)
        sectionStop = fltTraceLength-1;
      else
        sectionStop = sectionStop + fltBoxcar;

      const double sectionCharge = TraceAlgorithm::Sum(trace, sectionStart, sectionStop);
      //firstSectionBin[section], lastSectionBin[section] );

      if (fVerbosity > 0) {
        cout << "Section " << section
             << ":  " << firstSectionBin[section]
             << " - " << lastSectionBin[section]
             << " ->  " << sectionStart
             << " - " << sectionStop
             << ", charge: " << sectionCharge << endl;
      }

      firstSectionBin[section] = sectionStart;
      lastSectionBin[section] = sectionStop;

      if (sectionCharge > maxSectionCharge) {
        maxSectionCharge = sectionCharge;
        noMaxChargeSection = section;
      }

    }  // loop over triggered sections

    // starting to search for highest signal in 'biggest' FLT triggered section

    double maxSignal = 0;
    unsigned int maxSignalBin = 0;
    if (firstSectionBin.size() > noMaxChargeSection) {

      for (unsigned int i = firstSectionBin[noMaxChargeSection];
           i < lastSectionBin[noMaxChargeSection]; ++i) {

        if (trace[i] > maxSignal) {
          maxSignal = trace[i];
          maxSignalBin = i;
        }

      }

    } else {

      // IF WE CAME HERE WITHOUT FINDING ANY PULSE, SOMETHING MUST BE WRONG WITH THE EVENT
      // -> no detailed FLT information: using the first FLT bin for pulse search

      maxSignalBin = firstFLTbin;
    }

    // setting the final search boundaries

    if (maxSignalBin < fOffset)
      start = trace.GetStart();
    else
      start = maxSignalBin-fOffset;

    if (maxSignalBin + fOffset > trace.GetStop())
      stop = trace.GetStop();
    else
      stop = maxSignalBin+fOffset;

    if (fVerbosity > 0) {
      cout << "Selected section " << noMaxChargeSection
           << " and found biggest signal in bin " << maxSignalBin
           << endl;
    }

  } else {  // firstFLTbin < 0  ---> No FLT trigger

    if (!fuseAllPixels) {
      // Don't look at non-triggered pixels !
      if (fVerbosity > 0)
        cout << "no FLT -> skipping" << endl;
      return false;
    }

    // -> Use full trace range ........

    start = trace.GetStart();
    stop = trace.GetStop();
  }

  return FindBestSignalOverNoise(pixel, start, stop);
}


// changed start and stop and windowstart, windowstop to type int instead of
// unsigned int to avoid problems with this comparison:
// windowStart< (stop -  fMaxWindowLength)
// when (stop - fMaxWindowLength) is negative

bool
FdPulseFinder::FindBestSignalOverNoise(fevt::Pixel& pixel,
                                       const int start, const int stop)
  const
{
  fevt::PixelRecData& pixelrec = pixel.GetRecData();
  const TraceD& trace = pixelrec.GetPhotonTrace();

  const fdet::FDetector& detFD = det::Detector::GetInstance().GetFDetector();
  const unsigned int eyeId = pixel.GetEyeId();
  const unsigned int telId = pixel.GetTelescopeId();
  const fdet::Pixel& detPixel = detFD.GetPixel(pixel);
  const fdet::Telescope& detTel = detFD.GetEye(eyeId).GetTelescope(telId);
  const fdet::Camera& detCamera = detTel.GetCamera();
  const double Vg = detCamera.GetGainVariance();
  const double referenceLambda = detFD.GetReferenceLambda();
  const double photon2pe = detPixel.GetDiaPhoton2PEFactor(referenceLambda);

  // calculate correlation from cutoffFrequency, see A.Menshikov et al,
  // IEEE Vol. 50 (2003), 1208 Eq.(5) and (6)

  // original numbers from P.Wahrlich:
  //  r_01 = 0.2;     standard telescopes
  //  r_01 = 0.43;    HEAT

  // calculated numbers (as of FModelConfig.xml March 2012):
  //  r_01 = 0.30;   standard telescopes
  //  r_01 = 0.46;   HEAT

  const double F = detCamera.GetCutoffFrequency();
  const double deltaT = detCamera.GetFADCBinSize();
  const double r_01 = exp(-4 * kPi * pow(deltaT * F, 2));

  const int pixelId = pixel.GetId();
  const int channelId = detPixel.GetChannelId();

  // ####### Start to search for pulse #############

  //if (start < trace.GetStart()) start = trace.GetStart();
  //if (stop > trace.GetStop()) stop = trace.GetStop();

  if( fVerbosity > 0) {
    if (fuseAllPixels) {
      cout << "\nPixel " << pixelId << " channel=" << channelId
           << "  == > searching pulse between:  "  << start << " - " << stop << endl;
    } else
      cout << "  == > searching pulse between:  " << start << " - " << stop << endl;
  }

  unsigned int pulseStart = 0;
  unsigned int pulseStop = 0;

  double maxSnRatio = 0;

  double rmsnoise = pixelrec.GetRMS();

  for (int windowStart = start; windowStart < stop - fMinWindowLength; ++windowStart) {

    for (int windowStop = windowStart + fMinWindowLength;
         windowStop < windowStart + fMaxWindowLength && windowStop <= stop;
         ++windowStop) {

      const double value = TraceAlgorithm::Sum(trace, windowStart, windowStop);

      //double snratio = value / ((windowStop - windowStart) * rmsnoise);
      const double w = abs(double(windowStop - windowStart));
      const double snratio = value / (sqrt(w) * rmsnoise);

      if (snratio > maxSnRatio) {

        maxSnRatio = snratio;
        pulseStart = windowStart;
        pulseStop = windowStop;

      }

    }

  }

  if (pulseStart <= trace.GetStart()) {
    ++fCountBoundsErr;
    return false;  // check bounds
  }
  if (pulseStop >=  trace.GetStop())  {
    ++fCountBoundsErr;
    return false;
  }

  // pwahrlich 13/08/10, modified 3 Nov 2010:
  // Added a constraint that while extending the pulse
  // window, the total signal/noise can not drop below 5-sigma.

  // The pulse window is extended in 1-bin increments in the direction with
  // the highest 1-bin signal

  // The complicated logic is to check other pulse window boundary when
  // the chosen boundary fails to following criteria:

  // Extend trace until:
  // 1-bin signal drops below 1-sigma
  // AND
  // 3-bin signal drops below sqrt(3)-sigma

  while (true) {

    if (pulseStart == trace.GetStart() || pulseStop == trace.GetStop() ||
        pulseStart-1 == trace.GetStart() || pulseStop + 1 == trace.GetStop()) {
      ++fCountBoundsErr;
      return false;
    }

    const double sigStart = trace[pulseStart-1] + trace[pulseStart] + trace[pulseStart+1];
    const double sigStop = trace[pulseStop+1] + trace[pulseStop] + trace[pulseStop-1];
    const double noiseQuadSum = sqrt(pulseStop - pulseStart + 1) * rmsnoise;

    const bool extendStart = trace[pulseStart-1] >= trace[pulseStop+1];
    const bool startThr = sigStart > rmsnoise*sqrt(3) || trace[pulseStart-1] > rmsnoise;
    const bool stopThr = sigStop > rmsnoise*sqrt(3) || trace[pulseStop+1] > rmsnoise;
    const bool startSnRatio = TraceAlgorithm::Sum(trace, pulseStart - 1, pulseStop) / noiseQuadSum > fMinSnRatio;
    const bool stopSnRatio = TraceAlgorithm::Sum(trace, pulseStart, pulseStop + 1) / noiseQuadSum > fMinSnRatio;

    if ((extendStart || (!extendStart && (!stopThr || !stopSnRatio))) &&
        startThr && startSnRatio)
      --pulseStart;
    else if ((!extendStart || (extendStart && (!startThr || !startSnRatio))) &&
             stopThr && stopSnRatio)
      ++pulseStop;
    else
      break;
  }

  const double charge = TraceAlgorithm::Sum(trace, pulseStart, pulseStop);

  // redefine sn ratio
  const double new_snRatio =
    charge / sqrt(double(pulseStop - pulseStart)) / rmsnoise;

  if (new_snRatio > fMinSnRatio) {

    pixelrec.SetPulseFound();
    pixelrec.SetPulseStart(pulseStart);
    pixelrec.SetPulseStop(pulseStop);

    pixelrec.SetTotalCharge(charge);

    const double centroid = TraceAlgorithm::Centroid(trace, pulseStart, pulseStop);
    // centroid "time" is at center of bins

    // p. wahrlich 12/04/10: see GAP2009-133 for details
    // of the centroid error calculation

    const double rmspe2 = Sqr(rmsnoise*photon2pe);

    double centroid_err2 = 0;
    double peCovariance = r_01;

    for (unsigned int i = pulseStart; i <= pulseStop; ++i) {

      // if the trace is negative, set the trace to zero for error calculation.
      // this means that the bin is assumed to contain only noise (no signal).

      const double trace0 = (trace[i] < rmsnoise) ? 0 : trace[i];
      const double trace1 = (trace[i+1] < rmsnoise) ? 0 : trace[i+1];

      // photoelectron variance
      const double peVariance = rmspe2 + trace0 * photon2pe * (1 + Vg);

      // mean photoelectron time variance
      const double timeVariance = trace0 ? 1 / (12 * trace0 * photon2pe) : 0;

      // photoelectron covariance
      if (i != pulseStop)
        peCovariance = r_01 * sqrt((rmspe2 + trace0 * photon2pe*(1 + Vg)) * (rmspe2 + trace1 * photon2pe*(1 + Vg)));

      const double binTime = i + 0.5;

      centroid_err2 +=
        (Sqr(binTime - centroid) * peVariance + 2*(binTime - centroid)*(binTime + 1 - centroid) * peCovariance + Sqr(trace0*photon2pe)*timeVariance) / Sqr(charge*photon2pe);

    }

    //----------End centroid error determination

    const double centroid_err = sqrt(centroid_err2);

    pixelrec.SetCentroid(centroid, centroid_err);

    if (fVerbosity > 0) {
      cout << "Found Pulse at " << centroid << " with charge " << charge
           << " between " << pulseStart << " - " << pulseStop << endl;
    }

    ++fCountPulsed;
    return true;

  }  // if new_snRatio

  return false;
}


bool
FdPulseFinder::FindAdditionalPulse(fevt::Pixel& pixel,
                                   const fevt::Eye& eyeEvt,
                                   const evt::ShowerFRecData& /*frec*/)
  const
{
  if (!pixel.HasRecData())
    return false;

  fevt::PixelRecData& pixelrec = pixel.GetRecData();
  const int pixelId = pixel.GetId();
  const int telId = pixel.GetTelescopeId();

  if (fVerbosity > 0)
    cout << "\n FindAdditionalPulse for Pixel=" << pixelId << " Tel=" << telId << '\n';

  const fdet::FDetector& detFD = det::Detector::GetInstance().GetFDetector();

  const fevt::Telescope& telEvent = eyeEvt.GetTelescope(pixel.GetTelescopeId());
  const fevt::EyeRecData& eyeRec = eyeEvt.GetRecData();
  //const fevt::EyeHeader& eyeHeader = eyeEvt.GetHeader();

  const fdet::Telescope& detTel = detFD.GetTelescope(telEvent);
  const fdet::Camera& detCamera = detTel.GetCamera();
  double fadcBinning = detCamera.GetFADCBinSize();
  unsigned int fadcSize = detCamera.GetFADCTraceLength();

  const fdet::Eye& detEye = detFD.GetEye(eyeEvt);
  const CoordinateSystemPtr& eyeCS = detEye.GetEyeCoordinateSystem();
  const Vector vertical(0,0,1, eyeCS);

  const fdet::Pixel& detPixel = detFD.GetPixel(pixel);
  const utl::Vector& pixelDir = detPixel.GetDirection();

  //const Vector& axis = frec.GetAxis();
  //const utl::Point& core = frec.GetCorePosition();

  const Vector sdp = eyeRec.GetSDP();
  const Vector horizontal_in_sdp = Cross(sdp, vertical);

  const double T0 = eyeRec.GetTZero();
  const double Chi_0 = eyeRec.GetChiZero();
  const double Rp = eyeRec.GetRp();

  //TimeStamp eyeTrig = eyeHeader.GetTimeStamp();
  const double telTimeOffset = telEvent.GetTimeOffset();

  const Vector chi_i_vector = pixelDir - (sdp * pixelDir) *  sdp;

  const double Chi_i = Angle(horizontal_in_sdp, chi_i_vector);
  const double alpha = Chi_0 - Chi_i - 90*deg;

  // all times relative to eye trigger time
  const double t = T0 + Rp/utl::kSpeedOfLight * (tan(alpha) + 1/cos(alpha)) - telTimeOffset;

  const unsigned int bin = ceil(t / fadcBinning);// - fadcSize;

  if (fVerbosity > 0)
    cout << " pixel chi_i=" << Chi_i/deg << " alpha=" << alpha/deg
         << " t=" << t << " bin=" << bin
         << " telOffset=" << telTimeOffset
         << " Rp=" << Rp
         << " T0=" << T0
         << " chi0=" << Chi_0/deg
         << " recChi_i=" << pixelrec.GetChi_i()/deg
         << endl;

  if (t < 0 || bin >= fadcSize) {
    if (fVerbosity >= 1)
      INFO("Shower out of FD-DAQ time-window (for this pixel)!");
    return false;
  }

  // setting the search boundaries

  unsigned int offset = fOffset/2;
  const unsigned int start = (bin < offset) ? 0 : bin - offset;
  unsigned int stop = (bin + offset >= fadcSize) ? fadcSize - 1 : bin + offset;

  if (pixelrec.PulseIsFound()) {

    const double pulseTime = pixelrec.GetCentroid();

    ostringstream info;
    info << " -> Found FLT pixel with pulse at time=" << pulseTime;
    INFO(info);

    // check for already existing pulse in time-window
    if (pulseTime > start && pulseTime < stop) {
      if (fVerbosity > 0)
        INFO("Pixel had already valid pulse. Keeping.");
      return true;
    }

    INFO("Pulse possibly wrong. Refine search...");
  }

  if (fVerbosity > 1) {
    ostringstream info;
    info << " -> Search additional pulse in pixel=" << pixelId << " within [" << start << " - " << stop << "]";
    INFO(info);
  }

  if (FindBestSignalOverNoise(pixel, start, stop)) {
    ostringstream info;
    info << "New pulse found in pixel=" << pixelId;
    INFO(info);
    return true;
  }

  if (fVerbosity > 1)
    INFO ("No pulse found");

  return false;
}