PeakDetectHorizontal.h

Go to the documentation of this file.

#ifndef PEAKDETECTTHRESHOLD_H_
#define PEAKDETECTTHRESHOLD_H_

#include "component/Behavior.h"
#include "data/Location.h"

class Location;
class UniversalDataReader;

class PeakDetectHorizontal : public Behavior
{
public:

    PeakDetectHorizontal( const Str& prefix, const Module* module );

    virtual ~PeakDetectHorizontal();

    void initialize( void );

    bool readParams();

    bool calcSatisfied();

    void run();

    bool isSatisfied();

    bool runIfUnsatisfied();

    void uninitialize( void );

    static Behavior* CreateBehavior( const Str& prefix, const Module* module );

protected:

    // Slate input setting variables

    SettingReader *detectFromSettingReader_;

    SettingReader *depthFromSettingReader_;

    SettingReader *latitudeFromSettingReader_;

    SettingReader *longitudeFromSettingReader_;

    SettingReader *advectValuesSettingReader_;

    SettingReader *detectTroughSettingReader_;

    SettingReader *beginThresholdSettingReader_;

    SettingReader *offPeakFractionSettingReader_;

    SettingReader *filterWidthSettingReader_;

    SettingReader *centerPeakSettingReader_;

    // Actual values from settings

    const Unit* detectFromBaseUnit_;

    int advectValuesSetting_;

    int detectTroughSetting_;

    float beginThresholdSetting_;

    float offPeakFractionSetting_;

    int filterWidthSetting_;

    int centerPeakSetting_;

    // Slate input measurements

    DataReader* detectInputReader_;

    DataReader* depthInputReader_;

    DataReader* latitudeInputReader_;

    DataReader* longitudeInputReader_;

    DataReader* distanceWrtSeaWaterReader_;

    DataReader* latitudeReader_;

    DataReader* longitudeReader_;

    DataReader* eastwardSeaWaterVelocityReader_;

    DataReader* northwardSeaWaterVelocityReader_;

    // Argument output variables
    DataWriter* peakDetectWriter_;
    DataWriter* peakDepthWriter_;
    DataWriter* peakLatitudeWriter_;
    DataWriter* peakLongitudeWriter_;
    DataWriter* peakDistanceWriter_;

    float detect_;
    float depth_;
    float distance_;
    float latitude_;
    float longitude_;
    float eastwardVelocity_;
    float northwardVelocity_;

    float peakDetect_;

    bool inPeak_;
    int peakIndex_;

    class PointValue
    {
    public:
        PointValue( double init )
            : time_( init ),
              latitude_( init ),
              longitude_( init ),
              distance_( init ),
              depth_( init ),
              value_( init )
        {}
        void set( double time, double latitude, double longitude, float distance, float depth, float value )
        {
            time_ = time, latitude_ = latitude, longitude_ = longitude, distance_ = distance, depth_ = depth, value_ = value;
        }
        double getTime()
        {
            return time_;
        }
        double getLatitude()
        {
            return latitude_;
        }
        double getLongitude()
        {
            return longitude_;
        }
        float getDepth()
        {
            return depth_;
        }
        float getDistance()
        {
            return distance_;
        }
        float getValue()
        {
            return value_;
        }
        void advect( const float bearing, const float distance )
        {
            Location::AtBearing( bearing, distance, latitude_, longitude_ );
        }
        bool differsFrom( const float depth, const float value )
        {
            return depth_ != depth || value_ != value;
        }
        PointValue& operator += ( const PointValue& pv )
        {
            time_ += pv.time_, latitude_ += pv.latitude_, longitude_ += pv.longitude_, distance_ += pv.distance_, depth_ += pv.depth_, value_ += pv.value_;
            return *this;
        }
        PointValue& operator /= ( const int div )
        {
            time_ /= div, latitude_ /= div, longitude_ /= div, distance_ /= div, depth_ /= div, value_ /= div;
            return *this;
        }
    protected:
        double time_;
        double latitude_;
        double longitude_;
        float distance_;
        float depth_;
        float value_;
    };

    FlexArray<PointValue*> history_;

    int historySize_;

    void reportPeak();

private:

    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    PeakDetectHorizontal( const PeakDetectHorizontal& old ); // disallow copy constructor

    void initVars();
};

#endif /*PEAKDETECTTHRESHOLD_H_*/