SdTopDownSignalSelector.h

Go to the documentation of this file.

#ifndef _SdTopDownSignalSelectorUGR_h_
#define _SdTopDownSignalSelectorUGR_h_

#include <fwk/VModule.h>

#include <sevt/SEvent.h>
#include <sevt/Station.h>

#include <utl/Point.h>
#include <utl/TimeStamp.h>


namespace evt {
  class Event;
}


// you should assign your module to a namespace

namespace SdTopDownSignalSelectorUGR {

  class GeoSegment {
  public:
    GeoSegment(const int start, const int stop, const double binsTh,
               const double charge, const double aop, const double signal,
               utl::TimeStamp startTime,
               sevt::Station* const stEvt, const sdet::Station* const stDet,
               bool candidate) :
      fStart(start),
      fStop(stop),
      fBinsOverThresh(binsTh),
      fCharge(charge),
      fAoP(aop),
      fSignal(signal),
      fStartTime(startTime),
      fStEvt(stEvt),
      fStDet(stDet),
      fCandidate(candidate),
      fTimeResidual(0)
    { }

    int fStart;
    int fStop;
    int fBinsOverThresh;
    double fCharge; // Integrated signal in VEM Charge
    double fAoP;
    double fSignal; // Integrated signal in VEM Peak
    utl::TimeStamp fStartTime;
    sevt::Station* fStEvt;
    const sdet::Station* fStDet;
    bool fCandidate;
    double fTimeResidual;
  };


  typedef std::vector<GeoSegment> GeoSegmentCollection;


  class ByIncreasingSignal {
  public:
    bool operator()(const GeoSegment& i, const GeoSegment& j) const;
  };


  class ByDecreasingSignal {
  public:
    bool operator()(const GeoSegment& i, const GeoSegment& j) const;
  };


  class ByDecreasingSignalQ {
  public:
    bool operator()(const GeoSegment& i, const GeoSegment& j) const;
  };


  class ByDecreasingAoP {
  public:
    bool operator()(const GeoSegment& i, const GeoSegment& j) const;
  };


  class ByDecreasingAoPQ {
  public:
    bool operator()(const GeoSegment& i, const GeoSegment& j) const;
  };


  class SdTopDownSignalSelectorUGR : public fwk::VModule {

  public:
    // If you define a constructor, you MUST provide an implementation
    // for it, otherwise the REGISTER_MODULE macro will not register
    // your module. (Here, implementation is in SdTopDownSignalSelectorUGR.cc)
    SdTopDownSignalSelectorUGR();
    virtual ~SdTopDownSignalSelectorUGR() { }

    fwk::VModule::ResultFlag Init();
    fwk::VModule::ResultFlag Run(evt::Event& event);
    fwk::VModule::ResultFlag Finish();

  private:
    static utl::TimeStamp fBaryTime;
    static utl::Point fBarycenter;
    std::vector<double> fResiduals;

    sevt::SEvent* fSEvent;
    int fVerbose;
    // Costants for Signal identification
    double fSignalThreshold;
    int fMinSlots;
    double fMinSignal;
    double fMinStSignal;
    int fMinNumberStSignalCut;
    double fLowFactor;
    int fMingap;
    unsigned int fRejectionProcedure;

    // Constants for TopDown Selection
    double fPreSignalThreshold;
    int fPreMinSlots;
    int fPreMingap;
    double fPreMinSignal;

    bool fRejectNonT4Events;
    double kBaryPower;
    double kTolRes;
    double kTolResM;
    double kIsoDist1;
    double kIsoDist2;
    double kCurv0;
    double kAreaMin;
    double kAreaMax;
    double kAna3RatMin;
    double kDistMax;
    double kIsoTime1;
    double kIsoTime2;
    GeoSegmentCollection fAllSegments;

    enum TimeCorrectionType {
      eNone = 0,
      eAltitude = 1,
      eCurved = 2,
      eAltitudeCurved = 3
    };

    // method to initialize.
    void RemoveEA();
    void RemoveDoublets();
    void RemoveIsolatedStations();
    void UpdateStations();
    bool Select();
    bool TryRemovingStations(int);
    bool EstimateCore();
    bool IsGoodTimeConfig(const TimeCorrectionType correctionType);
    bool IsGoodSpaceConfig();
    double CorrectTimeAltitude(const int);
    double CorrectTimeAltitudeCurv(const int);
    bool IsAligned();
    double fU,fV,fT0;
    double fXCore, fYCore, fZCore, fTCore;
    std::vector<unsigned int> fIndexes;
    int fNMinStations, fNMaxStations, fNMaxRemovedStations;
    bool fIsLastTimingIteration;

    bool PatternRecovering();
    void RemoveRandomStations();
    bool Recover3Stations();

    double EstimatedZenith(const std::string& s);
    double EstimatedAzimuth(const std::string& s);

    std::pair<double, double> fRiseTimeFractions;
    std::pair<double, double> fFallTimeFractions;

    std::vector<GeoSegment> FoundSegments(sevt::Station& st);
    std::vector<GeoSegment> FoundBasicSegments(sevt::Station& st);
    bool SelectMainSegment(GeoSegmentCollection& segments);
    void UpdateSegmentValues(const int seg);
    bool UpdateStationValues(sevt::Station& st, const int start, const int stop);
    utl::TraceD GetVEMChargeTrace(const sevt::Station& st) const;

    // From the Sd Calibrator copy-paste
    void ComputeShapeRiseFallPeak(sevt::PMTRecData& pmtRecData,
                                  const double binSize,
                                  const unsigned int startBin,
                                  const unsigned int startIntegration,
                                  const unsigned int endIntegration,
                                  const double traceIntegral) const;

    // The REGISTER_MODULE macro makes the framework aware of your module.
    // You need to put this macro at the very end of your module class definition.
    // Give your module a name (first argument) and specify its
    // class name (second argument).  In the ModuleSequenceExample.xml file,
    // you can see this module being refered to by the name we give it here.

    REGISTER_MODULE("SdTopDownSignalSelectorUGR", SdTopDownSignalSelectorUGR);

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -k"
// End: