metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/mars/Param.h

@@ -0,0 +1,84 @@
+/*
+ * (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.
+ */
+
+// File Param.h
+// Baudouin Raoult - ECMWF Dec 97
+
+#ifndef metkit_Param_H
+#define metkit_Param_H
+
+#include <string>
+
+#include "eckit/persist/Bless.h"
+
+namespace eckit {
+class DumpLoad;
+}
+
+namespace metkit {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class Param {
+public:
+
+    Param() : table_(-1), value_(-1) {}
+
+    Param(const std::string&);
+
+    Param(long table, long value) : table_(table), value_(value) {}
+
+#include "metkit/mars/Param.b"
+
+    ~Param() {}
+
+    operator std::string() const;
+
+    bool operator==(const Param& other) const { return value_ == other.value_ && table_ == other.table_; }
+
+    bool operator!=(const Param& other) const { return value_ != other.value_ || table_ != other.table_; }
+
+    bool operator<(const Param& other) const {
+        return (value_ == other.value_) ? (table_ < other.table_) : (value_ < other.value_);
+    }
+
+    bool operator>(const Param& other) const {
+        return (value_ == other.value_) ? (table_ > other.table_) : (value_ > other.value_);
+    }
+
+    long table() const { return table_; }
+    long value() const { return value_; }
+    long grib1value() const { return value_ % 1000; }
+
+    long paramId() const;
+
+    void dump(eckit::DumpLoad&) const;
+    void load(eckit::DumpLoad&);
+
+protected:
+
+    void print(std::ostream& s) const;
+
+private:
+
+    long table_;
+    long value_;
+
+    friend std::ostream& operator<<(std::ostream& s, const Param& p) {
+        p.print(s);
+        return s;
+    }
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/ParamID.h

@@ -0,0 +1,306 @@
+/*
+ * (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.
+ */
+
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+/// @author Simon Smart
+
+/// @date Febuary 2019
+
+#ifndef metkit_ParamID_H
+#define metkit_ParamID_H
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "eckit/config/Resource.h"
+#include "eckit/filesystem/PathName.h"
+#include "eckit/log/Log.h"
+#include "eckit/runtime/Metrics.h"
+#include "eckit/types/Types.h"
+
+#include "metkit/config/LibMetkit.h"
+#include "metkit/mars/Param.h"
+
+namespace metkit {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class ParamID {
+
+public:  // types
+
+    struct WindFamily {
+        Param u_;
+        Param v_;
+        Param vo_;
+        Param d_;
+
+        WindFamily(const std::string& u, const std::string& v, const std::string& vo, const std::string& d) :
+            u_(u), v_(v), vo_(vo), d_(d) {}
+    };
+
+public:  // methods
+
+    template <typename REQUEST_T, typename AXIS_T>
+    static void normalise(const REQUEST_T& r, std::vector<Param>& req, const AXIS_T& axis, bool& windConversion,
+                          bool fullTableDropping = ParamID::fullTableDropping());
+
+    static const std::vector<WindFamily>& getWindFamilies();
+    static const std::vector<size_t>& getDropTables();
+    static bool fullTableDropping();
+    static const std::set<std::string>& getMlParamsSingleLevel();
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+inline long replaceTable(size_t table, long paramid) {
+    return (table * 1000 + paramid % 1000);
+}
+
+template <typename REQUEST_T, typename AXIS_T>
+void ParamID::normalise(const REQUEST_T& request, std::vector<Param>& req, const AXIS_T& axis, bool& windConversion,
+                        bool fullTableDropping) {
+
+    static const bool useGRIBParamID = eckit::Resource<bool>("useGRIBParamID", false);
+
+    const std::vector<WindFamily>& windFamilies(getWindFamilies());
+
+
+    if (useGRIBParamID) {
+
+
+        std::set<Param> inAxis;
+        for (typename AXIS_T::const_iterator j = axis.begin(); j != axis.end(); ++j) {
+            inAxis.insert((*j));
+        }
+
+        std::vector<Param> newreq;
+        newreq.reserve(req.size());
+
+        for (std::vector<Param>::const_iterator k = req.begin(); k != req.end(); ++k) {
+            const Param& p = (*k);
+
+            Param alt;
+
+            if (p.table()) {
+                alt = Param(0, (p.table() == 128 ? 0 : p.table()) * 1000 + p.value());  // No '.' version
+            }
+            else {
+                size_t t = p.value() / 1000;
+                size_t v = p.value() % 1000;
+                alt      = Param(t == 0 ? 128 : t, v);  // '.' version
+            }
+
+            if (inAxis.find(p) != inAxis.end()) {
+                newreq.push_back(p);
+            }
+            else if (inAxis.find(alt) != inAxis.end()) {
+                newreq.push_back(alt);
+            }
+            else {
+                newreq.push_back(p);
+            }
+
+            LOG_DEBUG_LIB(LibMetkit) << "useGRIBParamID p=" << p << ", alt=" << alt << ", choice=" << newreq.back()
+                                     << std::endl;
+        }
+
+
+        req = newreq;
+
+        for (eckit::Ordinal w = 0; w < windFamilies.size(); w++) {
+
+            const Param windU(windFamilies[w].u_);
+            const Param windV(windFamilies[w].v_);
+            const Param windVO(windFamilies[w].vo_);
+            const Param windD(windFamilies[w].d_);
+
+            bool wantU  = false;
+            bool wantV  = false;
+            bool wantVO = false;
+            bool wantD  = false;
+
+            // Check if wind is requested
+            for (eckit::Ordinal i = 0; i < req.size(); i++) {
+                if (req[i] == windU)
+                    wantU = true;
+                if (req[i] == windV)
+                    wantV = true;
+                if (req[i] == windVO)
+                    wantVO = true;
+                if (req[i] == windD)
+                    wantD = true;
+            }
+
+            // Check if we have got it, axis should be sorted
+            bool gotU = false;
+            bool gotV = false;
+
+            if (wantU)
+                gotU = std::binary_search(axis.begin(), axis.end(), windU);
+
+            if (wantV)
+                gotV = std::binary_search(axis.begin(), axis.end(), windV);
+
+
+            if ((wantU && !gotU) || (wantV && !gotV)) {
+                // Push VO and D if needed
+                if (!wantVO)
+                    req.push_back(windVO);
+                if (!wantD)
+                    req.push_back(windD);
+
+                LOG_DEBUG_LIB(LibMetkit) << "U/V conversion requested U=" << windU << ", V=" << windV
+                                         << ", VO=" << windVO << ", D=" << windD << std::endl;
+                windConversion = true;
+            }
+        }
+    }
+    else {
+
+        std::vector<std::pair<Param, Param> > tableDropped;
+
+        std::set<Param> inAxis;
+        std::map<long, Param> inAxisParamID;
+        std::set<Param> wind;
+
+        for (typename AXIS_T::const_iterator j = axis.begin(); j != axis.end(); ++j) {
+            inAxis.emplace(*j);
+            inAxisParamID[j->paramId()] = *j;
+        }
+
+        std::vector<Param> newreq;
+        newreq.reserve(req.size());
+
+        for (auto r : req) {
+            if (inAxis.find(r) != inAxis.end()) {  // Perfect match - look no further
+                newreq.push_back(r);
+            }
+            else {  // r is normalised to ParamID
+                long paramid = r.paramId();
+                auto ap      = inAxisParamID.find(paramid);
+                if (ap != inAxisParamID.end()) {  // ParamID representation matching - look no further
+                    newreq.push_back(ap->second);
+                }
+                else {  // Special case for U/V - exact match
+                    bool ok = false;
+                    for (eckit::Ordinal w = 0; w < windFamilies.size(); w++) {
+                        if ((paramid == windFamilies[w].u_.paramId() || paramid == windFamilies[w].u_.grib1value() ||
+                             paramid == windFamilies[w].v_.paramId() || paramid == windFamilies[w].v_.grib1value()) &&
+                            inAxis.find(windFamilies[w].vo_) != inAxis.end() &&
+                            inAxis.find(windFamilies[w].d_) != inAxis.end()) {
+
+                            if (paramid == windFamilies[w].u_.paramId() || paramid == windFamilies[w].u_.grib1value())
+                                newreq.push_back(windFamilies[w].u_);
+                            else
+                                newreq.push_back(windFamilies[w].v_);
+
+                            wind.emplace(windFamilies[w].vo_);
+                            wind.emplace(windFamilies[w].d_);
+                            windConversion = true;
+
+                            ok = true;
+                            break;
+                        }
+                    }
+                    if (!ok && r.table() == 0 &&
+                        paramid < 1000) {  // Partial match (only it table has not been specified by user)
+                        const std::vector<size_t>& dropTables = ParamID::getDropTables();
+                        for (auto t : dropTables) {
+                            auto ap = inAxisParamID.find(replaceTable(t, paramid));
+                            if (ap != inAxisParamID.end()) {  // ParamID representation matching - look no further
+                                newreq.push_back(ap->second);
+                                ok = true;
+                                break;
+                            }
+                        }
+
+                        if (!ok) {  // Special case for U/V - partial match
+                            for (eckit::Ordinal w = 0; !ok && w < windFamilies.size(); w++) {
+                                if (paramid == windFamilies[w].u_.paramId() ||
+                                    paramid == windFamilies[w].v_.paramId()) {
+                                    for (auto t : dropTables) {
+                                        auto vo = inAxisParamID.find(replaceTable(t, windFamilies[w].vo_.paramId()));
+                                        auto d  = inAxisParamID.find(replaceTable(t, windFamilies[w].d_.paramId()));
+
+                                        if (vo != inAxisParamID.end() && d != inAxisParamID.end()) {
+                                            bool grib1 = vo->second.table() > 0;
+                                            if (paramid == windFamilies[w].u_.paramId())
+                                                newreq.push_back(grib1 ? Param(t, paramid)
+                                                                       : Param(0, replaceTable(t, paramid)));
+                                            else
+                                                newreq.push_back(grib1 ? Param(t, paramid)
+                                                                       : Param(0, replaceTable(t, paramid)));
+
+                                            wind.emplace(vo->second);
+                                            wind.emplace(d->second);
+                                            windConversion = true;
+
+                                            ok = true;
+                                            break;
+                                        }
+                                    }
+                                    if (ok)
+                                        break;
+                                }
+                            }
+                        }
+                        if (fullTableDropping &&
+                            !ok) {  // Backward compatibility - Partial match (drop completely table information)
+                            for (auto ap : inAxisParamID) {
+                                if (ap.first % 1000 == paramid % 1000) {
+                                    newreq.push_back(ap.second);
+                                    ok = true;
+                                    tableDropped.push_back(std::make_pair(r, ap.second));
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        req = newreq;
+
+        for (auto w : wind) {
+            bool exist = false;
+            for (eckit::Ordinal i = 0; i < req.size(); i++)
+                if (req[i] == w) {
+                    exist = true;
+                    break;
+                }
+            if (!exist) {
+                req.push_back(w);
+            }
+        }
+        if (tableDropped.size() > 0) {
+            eckit::MetricsPrefix prefix("paramid_normalisation");
+            {
+                std::ostringstream oss;
+                oss << request;
+                eckit::Metrics::set("user_request", oss.str());
+            }
+            {
+                std::ostringstream oss;
+                oss << tableDropped;
+                eckit::Metrics::set("params", oss.str());
+            }
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/Parameter.h

@@ -0,0 +1,87 @@
+/*
+ * (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.
+ */
+
+/// @author Manuel Fuentes
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+
+/// @date Sep 96
+
+#ifndef metkit_Parameter_H
+#define metkit_Parameter_H
+
+#include "eckit/types/Date.h"
+#include "eckit/types/Double.h"
+#include "eckit/types/Time.h"
+#include "eckit/utils/Translator.h"
+#include "eckit/value/Value.h"
+
+namespace eckit {
+class JSON;
+class MD5;
+}  // namespace eckit
+
+namespace metkit {
+namespace mars {
+
+class Type;
+class MarsRequest;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+
+class Parameter {
+public:  // methods
+
+    Parameter();
+    ~Parameter();
+
+    Parameter(const std::vector<std::string>& values, Type* = 0);
+    Parameter(const Parameter&);
+
+    Parameter& operator=(const Parameter&);
+    bool operator<(const Parameter&) const;
+
+    const std::vector<std::string>& values() const { return values_; }
+    void values(const std::vector<std::string>& values);
+
+    bool filter(const std::vector<std::string>& filter);
+    bool filter(const std::string& keyword, const std::vector<std::string>& filter);
+    bool matches(const std::vector<std::string>& matches) const;
+
+    void merge(const Parameter& p);
+
+    Type& type() const { return *type_; }
+    const std::string& name() const;
+
+    size_t count() const;
+
+private:  // methods
+
+    void print(std::ostream&) const;
+
+    friend std::ostream& operator<<(std::ostream& s, const Parameter& p) {
+        p.print(s);
+        return s;
+    }
+
+private:  // members
+
+    Type* type_;
+    std::vector<std::string> values_;
+};
+
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/Quantile.h

@@ -0,0 +1,73 @@
+/*
+ * (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.
+ */
+
+/// @file   Quantile.h
+/// @author Emanuele Danovaro
+/// @date   February 2022
+
+#pragma once
+
+#include <string>
+
+namespace metkit {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class Quantile {
+public:
+
+    Quantile(const std::string& value);
+    Quantile(long num, long den);
+
+    long num() const { return num_; }
+    long den() const { return den_; }
+
+    operator std::string();
+
+    Quantile& operator+=(const long& rhs);
+    Quantile& operator-=(const long& rhs);
+
+protected:
+
+    void print(std::ostream& s) const;
+
+private:
+
+    void check() const;
+
+    friend std::ostream& operator<<(std::ostream& s, const Quantile& q) {
+        q.print(s);
+        return s;
+    }
+
+private:
+
+    long num_;
+    long den_;
+};
+
+bool operator==(const Quantile& lhs, const Quantile& rhs);
+inline bool operator!=(const Quantile& lhs, const Quantile& rhs) {
+    return !(rhs == lhs);
+}
+bool operator<(const Quantile& lhs, const Quantile& rhs);
+inline bool operator>(const Quantile& lhs, const Quantile& rhs) {
+    return rhs < lhs;
+}
+inline bool operator<=(const Quantile& lhs, const Quantile& rhs) {
+    return !(lhs > rhs);
+}
+inline bool operator>=(const Quantile& lhs, const Quantile& rhs) {
+    return !(lhs < rhs);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit

metkitlib/include/metkit/mars/RequestEnvironment.h

@@ -0,0 +1,58 @@
+/*
+ * (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.
+ */
+
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+#pragma once
+
+#include <map>
+#include <mutex>
+#include <optional>
+#include <string>
+
+#include "metkit/mars/MarsRequest.h"
+
+namespace metkit::mars {
+
+/// Encapsulates the environment to be sent to the mars-server.
+/// This uses a mars request with 'environ' as the verb and each environment
+/// variable is treated as keyword with its respective value.
+class RequestEnvironment {
+public:
+
+    RequestEnvironment(const RequestEnvironment& other);
+
+    /// Create the actual "mars-request"
+    /// @return the request
+    const MarsRequest& request() const { return *env_; }
+
+    /// @brief Initialize the RequestEnvironment with a map of KEYWORD:VALUE(s).
+    /// @param env, map of KEYWORD:VALUE (or KEYWORD:VALUE1/VALUE2/.../VALUEn) to add to the environment.
+    static void initialize(const std::map<std::string, std::string>& env);
+
+    /// @brief Update the RequestEnvironment with a map of KEYWORD:VALUE(s).
+    /// @param env, map of KEYWORD:VALUE (or KEYWORD:VALUE1/VALUE2/.../VALUEn) to add to the environment.
+    void update(const std::map<std::string, std::string>& env);
+
+    /// Access instance of RequestEnvironment
+    /// @return RequestEnvironment
+    static const RequestEnvironment& instance();
+
+private:
+
+    RequestEnvironment() = default;
+
+    static RequestEnvironment& inst();
+
+    std::optional<MarsRequest> env_ = std::nullopt;
+    std::recursive_mutex init_;
+};
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/StepRange.b

@@ -0,0 +1,43 @@
+
+StepRange(eckit::Bless& b):
+	from_(b(&from_)),
+	to_(b(&to_))
+{
+}
+
+StepRange(eckit::Evolve b):
+	from_(b("StepRange","from_")),
+	to_(b("StepRange","to_"))
+{
+}
+
+static const char* specName()      { return "StepRange"; }
+static void isa(TypeInfo* t)  { eckit::Isa::add(t,specName()); }
+static eckit::Isa* isa()             { return eckit::Isa::get(specName());  }
+
+static void schema(eckit::Schema& s)
+{
+	s.start(specName(),sizeof(StepRange));
+	s.member("from_",member_size(StepRange,from_),member_offset(StepRange,from_),"double");
+	s.member("to_",member_size(StepRange,to_),member_offset(StepRange,to_),"double");
+	s.end(specName());
+}
+
+
+void describe(std::ostream& s,int depth = 0) const {
+	eckit::_startClass(s,depth,specName());
+	eckit::_describe(s,depth+1,"from_",from_);
+	eckit::_describe(s,depth+1,"to_",to_);
+	eckit::_endClass(s,depth,specName());
+}
+
+
+
+void _export(eckit::Exporter& h) const {
+	eckit::_startClass(h,"StepRange");
+	eckit::_export(h,"from_",from_);
+	eckit::_export(h,"to_",to_);
+	eckit::_endClass(h,"StepRange");
+}
+
+