Hypo.h

Go to the documentation of this file.

/*****************************************
 * This file is documented for Doxygen.
 * If you modify this file please update
 * the comments so that Doxygen will still
 * be able to work.
 ****************************************/
#ifndef HYPO_H
#define HYPO_H

#include <json.h>
#include <geo.h>
#include <memory>
#include <string>
#include <vector>
#include <mutex>
#include <atomic>
#include "TTT.h"

namespace glasscore {

// forward declarations
class CPick;
class CCorrelation;
class CTrigger;
class CSiteList;
class CHypoList;

typedef struct _HypoAuditingPerformanceStruct {
    double dtOrigin;
    double dtCreated;
    double dtNucleated;
    double dtNucleationPickInsertion;
    double dtLastBigMove;
    int nMaxPhasesBeforeMove;
    int nMaxPhasesSinceMove;
    double dMaxStackBeforeMove;
    double dMaxStackSinceMove;
    double dtFirstEventMessage;
    double dtFirstHypoMessage;
    double dLatPrev;
    double dLonPrev;
    double dDepthPrev;
} HypoAuditingPerformanceStruct;

class CHypo {
 public:
    CHypo();

    CHypo(std::shared_ptr<json::Object> detection, double thresh, int cut,
            std::shared_ptr<traveltime::CTravelTime> firstTrav,
            std::shared_ptr<traveltime::CTravelTime> secondTrav,
            std::shared_ptr<traveltime::CTTT> ttt, double resolution = 100,
            double aziTaper = 360.0, double maxDepth = 800.0,
            CSiteList *pSiteList = NULL);

    CHypo(double lat, double lon, double z, double time, std::string pid,
            std::string web, double bayes, double thresh, int cut,
            std::shared_ptr<traveltime::CTravelTime> firstTrav,
            std::shared_ptr<traveltime::CTravelTime> secondTrav,
            std::shared_ptr<traveltime::CTTT> ttt, double resolution = 100,
            double aziTaper = 360.0, double maxDepth = 800.0);

    explicit CHypo(std::shared_ptr<CTrigger> trigger,
                    std::shared_ptr<traveltime::CTTT> ttt);

    explicit CHypo(std::shared_ptr<CCorrelation> corr,
                    std::shared_ptr<traveltime::CTravelTime> firstTrav,
                    std::shared_ptr<traveltime::CTravelTime> secondTrav,
                    std::shared_ptr<traveltime::CTTT> ttt);

    ~CHypo();

    void clear();

    bool initialize(double lat, double lon, double z, double time,
                    std::string pid, std::string web, double bayes,
                    double thresh, int cut,
                    std::shared_ptr<traveltime::CTravelTime> firstTrav,
                    std::shared_ptr<traveltime::CTravelTime> secondTrav,
                    std::shared_ptr<traveltime::CTTT> ttt, double resolution =
                            100,
                    double aziTaper = 360.0, double maxDepth = 800.0);

    bool addPickReference(std::shared_ptr<CPick> pck);

    void removePickReference(std::shared_ptr<CPick> pck);

    bool hasPickReference(std::shared_ptr<CPick> pck);

    void clearPickReferences();

    void addCorrelationReference(std::shared_ptr<CCorrelation> corr);

    void removeCorrelationReference(std::shared_ptr<CCorrelation> corr);

    bool hasCorrelationReference(std::shared_ptr<CCorrelation> corr);

    void clearCorrelationReferences();

    std::shared_ptr<json::Object> generateHypoMessage();

    std::shared_ptr<json::Object> generateEventMessage();

    std::shared_ptr<json::Object> generateCancelMessage();

    std::shared_ptr<json::Object> generateExpireMessage();

    bool canAssociate(std::shared_ptr<CPick> pick, double sigma,
                        double sdassoc, bool p_only = false,
                        bool debug = false);

    double getTravelTimeForPhase(std::shared_ptr<CPick> pick,
                                  std::string phaseName);

    double calculateDistanceToPick(std::shared_ptr<CPick> pick);

    double calculateResidual(std::shared_ptr<CPick> pick,
                        bool * useForLocations = NULL,
                        std::string * phaseName = NULL,
                        bool p_only = false);

    bool canAssociate(std::shared_ptr<CCorrelation> corr, double tWindow,
                        double xWindow);

    /* \brief Calculate pick affinity
     *
     * Calculate the association affinity between the given
     * supporting pick and the current hypocenter based on a number of factors
     * including the identified phase, distance to picked station,
     * observation error, and other hypocentral properties
     *
     * \param pck - A std::shared_ptr to the pick to consider.
     * \return Returns a double value containing the pick affinity
     */
    double calculateAffinity(std::shared_ptr<CPick> pck);

    /* \brief Calculate correlation affinity
     *
     * Calculate the association affinity between the given
     * supporting correlation and the current hypocenter based on a number of
     * factors including distance to correlation station,
     * time to correlation, and other properties
     *
     * \param corr - A std::shared_ptr to the correlation to consider.
     * \return Returns a double value containing the correlation affinity
     */
    double calculateAffinity(std::shared_ptr<CCorrelation> corr);

    /* \brief Remove data that no longer fit association criteria
     *
     * Calculate the association affinity between it's associated
     * supporting data and the current hypocenter based on a number of factors
     * including the identified phase, distance to picked station,
     * observation error, and other hypocentral properties
     *
     * \param parentThread - A pointer to a parent Hypolist thread to
     * reprt status to.
     * \return Returns true if any data removed
     */
    bool pruneData(CHypoList* parentThread = NULL);

    bool cancelCheck();

    bool reportCheck();

    void calculateStatistics();

    double anneal(int nIter = 5000, double dStart = 100.0, double dStop = 1.0,
                    double tStart = 5., double tStop = .5);

    double localize();

    void annealingLocateBayes(int nIter, double dStart, double dStop,
                                double tStart, double tStop, bool nucleate =
                                        false);

    void annealingLocateResidual(int nIter, double dStart, double dStop,
                                    double tStart, double tStop, bool nucleate =
                                            false);

    double calculateGap(double lat, double lon, double z);

    double calculateCurrentBayes();

    double calculateBayes(double xlat, double xlon, double xZ, double oT,
                            bool nucleate);

    double calculateAbsResidualSum(double xlat, double xlon, double xZ,
                                    double oT, bool nucleate);

    double calculateWeightedResidual(std::string sPhase, double tObs,
                                        double tCal);

    void graphicsOutput();

    bool resolveData(std::shared_ptr<CHypo> hypo, bool allowStealing = true,
            CHypoList* parentThread = NULL);

    void trap();

    double getAzimuthTaper() const;

    double getMaxDepth() const;

    double getLatitude() const;

    void setLatitude(double lat);

    double getLongitude() const;

    void setLongitude(double lon);

    double getDepth() const;

    void setDepth(double z);

    glass3::util::Geo getGeo() const;

    double getTOrigin() const;

    void setTOrigin(double newTOrg);

    double getBayesValue() const;

    bool getCorrelationAdded() const;

    void setCorrelationAdded(bool corrAdded);

    bool getEventGenerated() const;

    bool getHypoGenerated() const;

    bool getFixed() const;

    void setFixed(bool fixed);

    double getInitialBayesValue() const;

    double getAssociationDistanceCutoff() const;

    double getDistanceCutoffFactor() const;

    int getNucleationDataThreshold() const;

    void setNucleationDataThreshold(int cut);

    double getNucleationStackThreshold() const;

    void setNucleationStackThreshold(double thresh);

    double getGap() const;

    int getTeleseismicPhaseCount() const;

    double getMedianDistance() const;

    double getMinDistance() const;

    std::mutex & getProcessingMutex();

    double getWebResolution() const;

    double getDistanceSD() const;

    int getProcessCount() const;

    int setProcessCount(int newCycle);

    int getTotalProcessCount() const;

    int incrementTotalProcessCount();

    const std::string& getID() const;

    const std::string& getWebName() const;

    int getPickDataSize() const;

    std::vector<std::shared_ptr<CPick>> getPickData() const;

    int getCorrelationDataSize() const;

    double getTCreate() const;

    std::shared_ptr<traveltime::CTravelTime> getNucleationTravelTime1() const;

    std::shared_ptr<traveltime::CTravelTime> getNucleationTravelTime2() const;

    std::shared_ptr<traveltime::CTTT> getTravelTimeTables() const;

    int getReportCount() const;

    bool isLockedForProcessing();

    int64_t getTSort() const;

    void setTSort(double newTSort);

    void setTCreate(double newTCreate);

    void setNucleationAuditingInfo(double tNucleation,
                                    double tNucleationKeyPickInsertion);
    const HypoAuditingPerformanceStruct * getHypoAuditingPerformanceInfo();

    // constants
    static constexpr double k_dResidualSigmaLengthSeconds = 1.0;

    static constexpr double k_dGapTaperDownBegin = 270.0;

    static constexpr double k_dGapTaperDownEnd = 360.0;

    static constexpr double k_dTimeToDistanceCorrectionFactor = 10.0;

    static constexpr double k_dVerticalToHorizontalDistanceCorrectionFactor = 2.0;  // NOLINT

    static constexpr double k_dBayesFactorMaximumRange = 0.2;

    static constexpr double k_dBayesFactorExponent = 2.0;

    static constexpr double k_dBayesFactorStepSizeReduction = 500.0;

    /* \brief Indicates what portion of the Web Resolution is required to
     * indicate an epicentral location change was significant(big, large, etc..)
     * Used for auditing purposes.
     */
    static constexpr double k_dLocationChangeWebResolutionRatio = 0.5;

    static constexpr double k_dMinimumDepthChangeKMThreshold = 7.5;

    static constexpr double k_dMinimumDepthChangeRatioThreshold = 0.25;

    static constexpr double k_dInitialAnnealStepReducationFactor = .5;

    static constexpr double k_dFinalAnnealStepReducationFactor = 100.0;

    static constexpr double k_dLocationMinDistanceStepSize = 1.0;

    static constexpr double k_dLocationMinTimeStepSize = 0.1;

    static constexpr double k_dLocationSearchRadiusToTime = 30.0;

    static constexpr double k_dLocationTaperConstant = 0.0001;

    static constexpr double k_dLocationMaxTaperThreshold = 30.0;

    static const int k_iLocationNPicksToSkipSmall = 5;

    static const int k_iLocationNPicksToSkipMedium = 10;

    static const int k_iLocationNPicksToSkipLarge = 25;

    static const int k_iLocationNPickThresholdSmall = 25;

    static const int k_iLocationNPickThresholdMedium = 50;

    static const int k_iLocationNPickThresholdLarge = 150;

    static const int k_iLocationNumIterationsSmall = 500;

    static const int k_iLocationNumIterationsMedium = 1250;

    static const int k_iLocationNumIterationsLarge = 10000;

    static constexpr double k_dSearchRadiusResolutionFactor = 1.0;

    static constexpr double k_dSearchRadiusTaperFactor = 0.75;

    static constexpr double k_dSearchRadiusFactor = 0.5;

 private:
    std::string m_sWebName;

    std::atomic<int> m_iNucleationDataThreshold;

    std::atomic<double> m_dNucleationStackThreshold;

    std::atomic<double> m_dAzimuthTaper;

    std::atomic<double> m_dMaxDepth;

    std::atomic<int> m_iProcessCount;

    std::atomic<double> m_tOrigin;

    std::atomic<double> m_dLatitude;

    std::atomic<double> m_dLongitude;

    std::atomic<double> m_dDepth;

    std::atomic<bool> m_bEventGenerated;

    std::atomic<bool> m_bHypoGenerated;

    std::atomic<double> m_dBayesValue;

    std::atomic<double> m_dInitialBayesValue;

    std::atomic<double> m_dMinDistance;

    std::atomic<double> m_dMedianDistance;

    std::atomic<double> m_dGap;

        std::atomic<int> m_iTeleseismicPhaseCount;

    std::atomic<double> m_dDistanceSD;

    std::atomic<double> m_dWebResolution;

    std::atomic<double> m_dAssociationDistanceCutoff;

    std::string m_sID;

    std::atomic<bool> m_bFixed;

    std::atomic<double> m_bCorrelationAdded;

    std::atomic<int> m_iTotalProcessCount;

    std::atomic<int> m_iReportCount;

    std::atomic<double> m_tCreate;

    std::atomic<int64_t> m_tSort;

    std::vector<std::shared_ptr<CPick>> m_vPickData;

    std::vector<std::shared_ptr<CCorrelation>> m_vCorrelationData;

    std::shared_ptr<traveltime::CTravelTime> m_pNucleationTravelTime1;

    std::shared_ptr<traveltime::CTravelTime> m_pNucleationTravelTime2;

    std::shared_ptr<traveltime::CTTT> m_pTravelTimeTables;

    mutable std::recursive_mutex m_HypoMutex;

    std::mutex m_ProcessingMutex;

    HypoAuditingPerformanceStruct m_hapsAudit;
};
}  // namespace glasscore
#endif  // HYPO_H