Feature/query cxx types ne aircraft altitude

src/bufr/BufrParser/Exports/Export.cpp

@@ -16,6 +16,7 @@
 #include "Splits/CategorySplit.h"
 #include "Variables/QueryVariable.h"
 #include "Variables/DatetimeVariable.h"
+#include "Variables/AircraftAltitudeVariable.h"
 #include "Variables/TimeoffsetVariable.h"
 #include "Variables/Transforms/Transform.h"
 #include "Variables/Transforms/TransformBuilder.h"
@@ -37,6 +38,7 @@ namespace
             const char* Timeoffset = "timeoffset";
             const char* Query = "query";
             const char* GroupByField = "group_by";  // Deprecated
+            const char* AircraftAltitude = "aircraftAltitude";
             const char* Type = "type";
         }  // namespace Variable
 
@@ -133,6 +135,11 @@ namespace Ingester
                 auto dtconf = subConf.getSubConfiguration(ConfKeys::Variable::Datetime);
                 variable = std::make_shared<DatetimeVariable>(key, groupByField, dtconf);
             }
+            else if (subConf.has(ConfKeys::Variable::AircraftAltitude))
+            {
+                auto dtconf = subConf.getSubConfiguration(ConfKeys::Variable::AircraftAltitude);
+                variable = std::make_shared<AircraftAltitudeVariable>(key, groupByField, dtconf);
+            }
             else if (subConf.has(ConfKeys::Variable::Timeoffset))
             {
                 auto dtconf = subConf.getSubConfiguration(ConfKeys::Variable::Timeoffset);

src/bufr/BufrParser/Exports/Variables/AircraftAltitudeVariable.cpp

@@ -0,0 +1,208 @@
+/*
+ * (C) Copyright 2022 NOAA/NWS/NCEP/EMC
+ *
+ * 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.
+ */
+
+#include <string>
+
+#include <ostream>
+#include <time.h>
+#include <vector>
+
+#include "eckit/exception/Exceptions.h"
+
+#include "DataObject.h"
+#include "AircraftAltitudeVariable.h"
+
+
+namespace
+{
+    namespace ConfKeys
+    {
+        const char* Pressure = "pressure";
+        const char* AircraftIndicatedAltitude = "aircraftIndicatedAltitude";
+        const char* PressureAltitudeRelativeToMeanSeaLevel =
+            "pressureAltitudeRelativeToMeanSeaLevel";
+        const char* FlightLevel = "flightLevel";
+        const char* Height = "height";
+        const char* HeightOrAltitude = "heightOrAltitude";
+        const char* FlightLevelST = "flightLevelST";
+    }  // namespace ConfKeys
+
+    const std::vector<std::string> FieldNames = {ConfKeys::Pressure,
+                                                 ConfKeys::AircraftIndicatedAltitude,
+                                                 ConfKeys::PressureAltitudeRelativeToMeanSeaLevel,
+                                                 ConfKeys::FlightLevel,
+                                                 ConfKeys::Height,
+                                                 ConfKeys::HeightOrAltitude,
+                                                 ConfKeys::FlightLevelST};
+}  // namespace
+
+
+namespace Ingester
+{
+    AircraftAltitudeVariable::AircraftAltitudeVariable(const std::string& exportName,
+                                                       const std::string& groupByField,
+                                                       const eckit::LocalConfiguration &conf) :
+      Variable(exportName),
+      groupByField_(groupByField),
+      conf_(conf)
+    {
+        initQueryMap();
+    }
+
+    std::shared_ptr<DataObjectBase> AircraftAltitudeVariable::exportData(const BufrDataMap& map)
+    {
+        checkKeys(map);
+
+        std::unordered_map<std::string, std::shared_ptr<DataObjectBase>> includedFieldMap;
+        std::vector<std::string> includedFields;
+
+        std::shared_ptr<DataObjectBase> referenceObj = nullptr;
+        for (const auto& fieldName : FieldNames)
+        {
+            if (conf_.has(fieldName))
+            {
+                includedFieldMap.insert({fieldName, map.at(getExportKey(fieldName))});
+                includedFields.push_back(fieldName);
+            }
+        }
+
+        referenceObj = (*includedFieldMap.begin()).second;
+
+        // Validation: make sure the dimensions are consistent
+        auto path = referenceObj->getPath();
+        for (const auto& fieldName : FieldNames)
+        {
+            if (includedFieldMap.find(fieldName) != includedFieldMap.end() &&
+                includedFieldMap[fieldName]->getPath() != path)
+            {
+                std::ostringstream errStr;
+                errStr << "Inconsistent dimensions found in source data.";
+                throw eckit::BadParameter(errStr.str());
+            }
+        }
+
+        std::vector<float> aircraftAlts;
+        aircraftAlts.resize(referenceObj->size(), DataObject<float>::missingValue());
+
+        for (size_t idx = 0; idx < referenceObj->size(); idx++)
+        {
+            std::cout << "idx = " << idx << std::endl;
+            for (auto nameIt = includedFields.rbegin(); nameIt != includedFields.rend(); ++nameIt)
+            {
+                const auto& fieldName = *nameIt;
+                const auto& fieldValues = includedFieldMap.at(fieldName);
+                if (fieldName == ConfKeys::Pressure)
+                {
+                    if (!fieldValues->isMissing(idx))
+                    {
+                        auto value = fieldValues->getAsFloat(idx);
+                        if (value < 22630.0f)
+                        {
+                            aircraftAlts[idx]  =
+                                11000.0f - (std::log1p(value / 22630.0f) / 0.0001576106f);
+                            std::cout << "section 1" << std::endl;
+                        }
+                        else
+                        {
+                            aircraftAlts[idx]  =
+                                (1.0f - powf((value / 101325.0f),
+                                             (1.0f / 5.256f))) * (288.15f / 0.0065f);
+                            std::cout << "section 2" << std::endl;
+                        }
+                    }
+                    else if (includedFieldMap.find(ConfKeys::AircraftIndicatedAltitude)
+                             != includedFieldMap.end())
+                    {
+                        if (!includedFieldMap[ConfKeys::AircraftIndicatedAltitude]->isMissing(idx))
+                        {
+                            aircraftAlts[idx] =
+                             includedFieldMap[ConfKeys::AircraftIndicatedAltitude]->getAsFloat(idx);
+                            std::cout << "section 3" << std::endl;
+                        }
+                    }
+                }
+                else if (fieldName == ConfKeys::AircraftIndicatedAltitude)
+                {
+                    // This variable is only used in conjunction with pressure.
+                    continue;
+                    std::cout << "section 4" << std::endl;
+                }
+                else if (!fieldValues->isMissing(idx))
+                {
+                    std::cout << " fieldValues = " << fieldValues << std::endl;
+                    aircraftAlts[idx] = fieldValues->getAsFloat(idx);
+                    std::cout << "section 5" << std::endl;
+                }
+            }
+        std::cout << "AA = " << aircraftAlts[idx] << std::endl;
+        }
+
+        return std::make_shared<DataObject<float>>(aircraftAlts,
+                                                    getExportName(),
+                                                    groupByField_,
+                                                    referenceObj->getDims(),
+                                                    referenceObj->getPath(),
+                                                    referenceObj->getDimPaths());
+    }
+
+    void AircraftAltitudeVariable::checkKeys(const BufrDataMap& map)
+    {
+        std::vector<std::string> requiredKeys;
+        for (const auto& fieldName : FieldNames)
+        {
+            if (conf_.has(fieldName))
+            {
+                requiredKeys.push_back(getExportKey(fieldName));
+            }
+        }
+
+        std::stringstream errStr;
+        errStr << "Query ";
+
+        bool isKeyMissing = false;
+        for (const auto& key : requiredKeys)
+        {
+            if (map.find(key) == map.end())
+            {
+                isKeyMissing = true;
+                errStr << key;
+                break;
+            }
+        }
+
+        errStr << " could not be found during export of AircraftAltitude object.";
+
+        if (isKeyMissing)
+        {
+            throw eckit::BadParameter(errStr.str());
+        }
+    }
+
+    QueryList AircraftAltitudeVariable::makeQueryList() const
+    {
+        auto queries = QueryList();
+
+        for (const auto& fieldName : FieldNames)
+        {
+            if (conf_.has(fieldName))
+            {
+                QueryInfo info;
+                info.name = getExportKey(fieldName);
+                info.query = conf_.getString(fieldName);
+                info.groupByField = groupByField_;
+                queries.push_back(info);
+            }
+        }
+
+        return queries;
+    }
+
+    std::string AircraftAltitudeVariable::getExportKey(const std::string& name) const
+    {
+        return getExportName() + "_" + name;
+    }
+}  // namespace Ingester

src/bufr/BufrParser/Exports/Variables/AircraftAltitudeVariable.h

@@ -0,0 +1,52 @@
+/*
+ * (C) Copyright 2022 NOAA/NWS/NCEP/EMC
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "eckit/config/LocalConfiguration.h"
+
+#include "Variable.h"
+
+
+namespace Ingester
+{
+    /// \brief Exports parsed data as aircraftAltitudes using specified Mnemonics
+    class AircraftAltitudeVariable final : public Variable
+    {
+     public:
+        AircraftAltitudeVariable() = delete;
+        AircraftAltitudeVariable(const std::string& exportName,
+                                 const std::string& groupByField,
+                                 const eckit::LocalConfiguration& conf);
+
+        ~AircraftAltitudeVariable() final = default;
+
+        /// \brief Get the configured mnemonics and turn them into AircraftAltitude
+        /// \param map BufrDataMap that contains the parsed data for each mnemonic
+        std::shared_ptr<DataObjectBase> exportData(const BufrDataMap& map) final;
+
+        /// \brief Get a list of queries for this variable
+        QueryList makeQueryList() const final;
+
+     private:
+        /// \brief For field
+        std::string groupByField_;
+
+        /// \brief The configuration
+        const eckit::LocalConfiguration conf_;
+
+        /// \brief makes sure the bufr data map has all the required keys.
+        void checkKeys(const BufrDataMap& map);
+
+        /// \brief get the export key string
+        std::string getExportKey(const std::string& name) const;
+    };
+}  // namespace Ingester

src/bufr/CMakeLists.txt

@@ -27,6 +27,8 @@ list(APPEND _ingester_srcs
   BufrParser/Exports/Variables/Variable.h
   BufrParser/Exports/Variables/DatetimeVariable.h
   BufrParser/Exports/Variables/DatetimeVariable.cpp
+  BufrParser/Exports/Variables/AircraftAltitudeVariable.h
+  BufrParser/Exports/Variables/AircraftAltitudeVariable.cpp
   BufrParser/Exports/Variables/TimeoffsetVariable.h
   BufrParser/Exports/Variables/TimeoffsetVariable.cpp
   BufrParser/Exports/Variables/QueryVariable.h

src/bufr/DataObject.h

@@ -110,6 +110,10 @@ namespace Ingester
         /// \return Float data.
         virtual float getAsFloat(const Location& loc) const = 0;
 
+        /// \brief Is the element at the location the missing value.
+        /// \return bool data.
+        virtual bool isMissing(const Location& loc) const = 0;
+
         /// \brief Get the data at the index as an int.
         /// \return Int data.
         virtual int getAsInt(size_t idx) const = 0;
@@ -338,6 +342,14 @@ namespace Ingester
         /// \return String data.
         std::string getAsString(const Location& loc) const final { return _getAsString(loc); }
 
+        /// \brief Is the element at the location the missing value.
+        /// \param loc The coordinate for the data point (ex: if data 2d then loc {2,4} gets data
+        ///            at that coordinate).
+        /// \return bool data.
+        bool isMissing(const Location& loc) const final
+        {
+            return get(loc) == missingValue();
+        }
 
         /// \brief Get the data at the index into the internal 1d array as a int. This function
         ///        gives you direct access to the internal data and doesn't account for dimensional

test/CMakeLists.txt

@@ -185,6 +185,9 @@ if( iodaconv_bufr_ENABLED )
     testinput/gdas.t12z.adpsfc.prepbufr
     testinput/gdas.t06z.adpsfc.tm00.bufr_d
     testinput/gdas.t12z.adpsfc.tm00.bufr_d
+    testinput/gdas.t12z.aircar.tm00.bufr_d
+    testinput/gdas.t12z.aircft.tm00.bufr_d
+    testinput/gdas.t12z.acft_profiles.prepbufr
     testinput/bufr_ncep_snow_adpsfc.yaml
     testinput/bufr_read_2_dim_blocks.yaml
     testinput/bufr_ncep_1bamua.yaml
@@ -193,6 +196,10 @@ if( iodaconv_bufr_ENABLED )
     testinput/bufr_ncep_esamua.yaml
     testinput/bufr_ncep_esmhs.yaml
     testinput/bufr_ncep_satwind_avhrr.yaml
+    testinput/bufr_ncep_aircar.yaml
+    testinput/bufr_ncep_aircft_AMDAR103.yaml
+    testinput/bufr_ncep_aircft_noAMDAR103.yaml
+    testinput/bufr_ncep_prepbufr_aircft.yaml
     testinput/bufr_read_wmo_radiosonde.yaml
     testinput/bufr_satwnd_old_format.yaml
     testinput/bufr_satwnd_new_format.yaml
@@ -245,6 +252,10 @@ if( iodaconv_bufr_ENABLED )
     testoutput/gdas.t12z.adpsfc.prepbufr.nc
     testoutput/gdas.t12z.adpsfc.tm00.nc
     testoutput/gdas.t06z.adpsfc_snow.tm00.nc
+    testoutput/gdas.t12z.aircar.tm00.nc
+    testoutput/gdas.t12z.aircft_AMDAR103.tm00.nc
+    testoutput/gdas.t12z.aircft_noAMDAR103.tm00.nc
+    testoutput/gdas.t12z.acft_profiles.prepbufr.nc
     testoutput/gdas.t00z.sevcsr.tm00.nc
     testoutput/bufr_read_2_dim_blocks.nc
     testoutput/bufr_read_wmo_radiosonde.nc
@@ -1204,6 +1215,42 @@ if(iodaconv_bufr_ENABLED)
                             gdas.t06z.adpsfc_snow.tm00.nc ${IODA_CONV_COMP_TOL_ZERO}
                     DEPENDS bufr2ioda.x )
 
+  ecbuild_add_test( TARGET  test_iodaconv_bufr_ncep_aircar2ioda
+                    TYPE    SCRIPT
+                    COMMAND bash
+                    ARGS    ${CMAKE_BINARY_DIR}/bin/iodaconv_comp.sh
+                            netcdf
+                            "${CMAKE_BINARY_DIR}/bin/bufr2ioda.x testinput/bufr_ncep_aircar.yaml"
+                            gdas.t12z.aircar.tm00.nc ${IODA_CONV_COMP_TOL_ZERO}
+                    DEPENDS bufr2ioda.x )
+
+  ecbuild_add_test( TARGET  test_iodaconv_bufr_ncep_aircft_noamdar2ioda
+                    TYPE    SCRIPT
+                    COMMAND bash
+                    ARGS    ${CMAKE_BINARY_DIR}/bin/iodaconv_comp.sh
+                            netcdf
+                            "${CMAKE_BINARY_DIR}/bin/bufr2ioda.x testinput/bufr_ncep_aircft_noAMDAR103.yaml"
+                            gdas.t12z.aircft_noAMDAR103.tm00.nc ${IODA_CONV_COMP_TOL_ZERO}
+                    DEPENDS bufr2ioda.x )
+
+  ecbuild_add_test( TARGET  test_iodaconv_bufr_ncep_aircft_amdar2ioda
+                    TYPE    SCRIPT
+                    COMMAND bash
+                    ARGS    ${CMAKE_BINARY_DIR}/bin/iodaconv_comp.sh
+                            netcdf
+                            "${CMAKE_BINARY_DIR}/bin/bufr2ioda.x testinput/bufr_ncep_aircft_AMDAR103.yaml"
+                            gdas.t12z.aircft_AMDAR103.tm00.nc ${IODA_CONV_COMP_TOL_ZERO}
+                    DEPENDS bufr2ioda.x )
+
+  ecbuild_add_test( TARGET  test_iodaconv_prepbufr_ncep_aircftprofiles2ioda
+                    TYPE    SCRIPT
+                    COMMAND bash
+                    ARGS    ${CMAKE_BINARY_DIR}/bin/iodaconv_comp.sh
+                            netcdf
+                            "${CMAKE_BINARY_DIR}/bin/bufr2ioda.x testinput/bufr_ncep_prepbufr_aircft.yaml"
+                            gdas.t12z.acft_profiles.prepbufr.nc ${IODA_CONV_COMP_TOL_ZERO}
+                    DEPENDS bufr2ioda.x )
+
 
   ecbuild_add_test( TARGET  test_iodaconv_bufr_read_2_dim_blocks
                     TYPE    SCRIPT