Feature/eckit stats

CMakeLists.txt

@@ -207,6 +207,13 @@ ecbuild_add_option( FEATURE GEO_PROJECTION_PROJ_DEFAULT
 
 set( eckit_GEO_CACHE_PATH "/tmp/cache" )
 
+
+### eckit::stats
+
+ecbuild_add_option( FEATURE ECKIT_STATS
+                    DEFAULT OFF
+                    DESCRIPTION "eckit::stats statistics library" )
+
 ### LAPACK
 
 if( eckit_HAVE_MKL )

src/eckit/CMakeLists.txt

@@ -979,3 +979,7 @@ endif()
 if( eckit_HAVE_ECKIT_GEO )
     add_subdirectory( geo )
 endif()
+
+if( eckit_HAVE_ECKIT_STATS )
+    add_subdirectory( stats )
+endif()

src/eckit/stats/CMakeLists.txt

@@ -0,0 +1,58 @@
+list( APPEND eckit_stats_srcs
+    Comparator.cc
+    Comparator.h
+    Distribution.cc
+    Distribution.h
+    Field.cc
+    Field.h
+    FieldStatistics.cc
+    FieldStatistics.h
+    Method.cc
+    Method.h
+    Statistics.cc
+    Statistics.h
+    comparator/ComparatorT.cc
+    comparator/ComparatorT.h
+    comparator/MissingValues.cc
+    comparator/MissingValues.h
+    comparator/Spectral.cc
+    comparator/Spectral.h
+    detail/AngleT.cc
+    detail/AngleT.h
+    detail/CentralMomentsT.cc
+    detail/CentralMomentsT.h
+    detail/Counter.cc
+    detail/Counter.h
+    detail/CounterBinary.cc
+    detail/CounterBinary.h
+    detail/ModeT.cc
+    detail/ModeT.h
+    detail/PNormsT.h
+    detail/ScalarT.h
+    distribution/DistributionT.cc
+    distribution/DistributionT.h
+    field/CentralMomentStats.cc
+    field/CentralMomentStats.h
+    field/CounterStats.cc
+    field/CounterStats.h
+    field/ModeStats.cc
+    field/ModeStats.h
+    method/MethodT.cc
+    method/MethodT.h
+    statistics/SimplePackingEntropy.cc
+    statistics/SimplePackingEntropy.h
+    statistics/Spectral.cc
+    statistics/Spectral.h
+    statistics/StatisticsT.cc
+    statistics/StatisticsT.h
+    util/mutex.h
+)
+
+ecbuild_add_library(
+    TARGET             eckit_stats
+    TYPE               SHARED
+    INSTALL_HEADERS    LISTED
+    HEADER_DESTINATION ${INSTALL_INCLUDE_DIR}/eckit/stats
+    SOURCES            ${eckit_stats_srcs}
+    PUBLIC_LIBS        eckit )
+

src/eckit/stats/Comparator.cc

@@ -0,0 +1,92 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+
+#include "eckit/stats/Comparator.h"
+
+#include <map>
+#include <ostream>
+
+#include "eckit/exception/Exceptions.h"
+#include "eckit/log/Log.h"
+#include "eckit/stats/util/Mutex.h"
+
+
+namespace eckit::stats {
+
+
+static util::recursive_mutex* local_mutex           = nullptr;
+static std::map<std::string, ComparatorFactory*>* m = nullptr;
+static util::once_flag once;
+static void init() {
+    local_mutex = new util::recursive_mutex();
+    m           = new std::map<std::string, ComparatorFactory*>();
+}
+
+
+Comparator::Comparator(const Parametrisation& param1, const Parametrisation& param2) :
+    parametrisation1_(param1), parametrisation2_(param2) {}
+
+
+Comparator::~Comparator() = default;
+
+
+ComparatorFactory::ComparatorFactory(const std::string& name) : name_(name) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    if (m->find(name) != m->end()) {
+        throw SeriousBug("ComparatorFactory: duplicate '" + name + "'");
+    }
+
+    ASSERT(m->find(name) == m->end());
+    (*m)[name] = this;
+}
+
+
+ComparatorFactory::~ComparatorFactory() {
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    m->erase(name_);
+}
+
+
+void ComparatorFactory::list(std::ostream& out) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    const char* sep = "";
+    for (auto& j : *m) {
+        out << sep << j.first;
+        sep = ", ";
+    }
+    out << std::endl;
+}
+
+
+Comparator* ComparatorFactory::build(const std::string& name, const Parametrisation& param1,
+                                     const Parametrisation& param2) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    Log::debug() << "ComparatorFactory: looking for '" << name << "'" << std::endl;
+
+    auto j = m->find(name);
+    if (j == m->end()) {
+        list(Log::error() << "ComparatorFactory: unknown '" << name << "', choices are: ");
+        throw SeriousBug("ComparatorFactory: unknown '" + name + "'");
+    }
+
+    return j->second->make(param1, param2);
+}
+
+
+}  // namespace eckit::stats

src/eckit/stats/Comparator.h

@@ -0,0 +1,97 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+
+#pragma once
+
+#include <iosfwd>
+#include <string>
+
+
+namespace eckit {
+class Parametrisation;
+namespace stats {
+class Field;
+}
+}  // namespace eckit
+
+
+namespace eckit::stats {
+
+
+class Comparator {
+public:
+    // -- Constructors
+
+    Comparator(const Parametrisation&, const Parametrisation&);
+    Comparator(const Comparator&) = delete;
+
+    // -- Destructor
+
+    virtual ~Comparator();
+
+    // -- Operators
+
+    void operator=(const Comparator&) = delete;
+
+    // -- Methods
+
+    virtual std::string execute(const Field&, const Field&) = 0;
+
+protected:
+    // -- Members
+
+    const Parametrisation& parametrisation1_;
+    const Parametrisation& parametrisation2_;
+
+    // -- Methods
+
+    virtual void print(std::ostream&) const = 0;
+
+private:
+    // -- Friends
+
+    friend std::ostream& operator<<(std::ostream& out, const Comparator& r) {
+        r.print(out);
+        return out;
+    }
+};
+
+
+class ComparatorFactory {
+    std::string name_;
+    virtual Comparator* make(const Parametrisation&, const Parametrisation&) = 0;
+
+    ComparatorFactory(const ComparatorFactory&)            = delete;
+    ComparatorFactory& operator=(const ComparatorFactory&) = delete;
+
+protected:
+    ComparatorFactory(const std::string&);
+    virtual ~ComparatorFactory();
+
+public:
+    static void list(std::ostream&);
+    static Comparator* build(const std::string&, const Parametrisation&, const Parametrisation&);
+};
+
+
+template <class T>
+class ComparatorBuilder : public ComparatorFactory {
+    Comparator* make(const Parametrisation& param1, const Parametrisation& param2) override {
+        return new T(param1, param2);
+    }
+
+public:
+    ComparatorBuilder(const std::string& name) : ComparatorFactory(name) {}
+};
+
+
+}  // namespace eckit::stats

src/eckit/stats/Distribution.cc

@@ -0,0 +1,97 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+
+#include "eckit/stats/Distribution.h"
+
+#include <map>
+#include <sstream>
+
+#include "eckit/config/YAMLConfiguration.h"
+#include "eckit/exception/Exceptions.h"
+#include "eckit/log/Log.h"
+#include "eckit/stats/util/Mutex.h"
+
+
+namespace eckit::stats {
+
+
+static util::once_flag once;
+static util::recursive_mutex* local_mutex             = nullptr;
+static std::map<std::string, DistributionFactory*>* m = nullptr;
+static void init() {
+    local_mutex = new util::recursive_mutex();
+    m           = new std::map<std::string, DistributionFactory*>();
+}
+
+
+Distribution::Distribution() = default;
+
+
+Distribution::~Distribution() = default;
+
+
+DistributionFactory::DistributionFactory(const std::string& name) : name_(name) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    if (m->find(name) != m->end()) {
+        std::ostringstream oss;
+        oss << "DistributionFactory: duplicate '" << name << "'";
+        throw SeriousBug(oss.str());
+    }
+
+    (*m)[name] = this;
+}
+
+
+DistributionFactory::~DistributionFactory() {
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    m->erase(name_);
+}
+
+
+Distribution* DistributionFactory::build(const std::string& name) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    // parse <name>[{<yaml-arguments>}] (arguments are optional)
+    auto braces = name.find('{');
+    ASSERT(braces == std::string::npos || name.back() == '}');
+
+    auto key  = name.substr(0, braces);
+    auto yaml = name.substr(braces);
+
+    Log::debug() << "DistributionFactory: looking for '" << key << "'" << std::endl;
+
+    if (auto j = m->find(key); j != m->end()) {
+        return j->second->make(YAMLConfiguration{yaml});
+    }
+
+    list(Log::error() << "DistributionFactory: unknown '" << key << "', choices are: ");
+    Log::warning() << std::endl;
+}
+
+
+void DistributionFactory::list(std::ostream& out) {
+    util::call_once(once, init);
+    util::lock_guard<util::recursive_mutex> lock(*local_mutex);
+
+    const char* sep = "";
+    for (const auto& j : *m) {
+        out << sep << j.first;
+        sep = ", ";
+    }
+}
+
+
+}  // namespace eckit::stats