VZoneSlice.h

Go to the documentation of this file.

#ifndef _atm_VZoneSlice_h_
#define _atm_VZoneSlice_h_

#include <det/VManager.h>
#include <det/Detector.h>
#include <utl/AugerException.h>

#include <string>
#include <map>


namespace atm {

  class VZoneSlice {

  public:
    double GetMinHeight() const { return fMinHeight; }

    double GetMaxHeight() const { return fMaxHeight; }

  protected:
    VZoneSlice(const std::string& headerDBName,
               const std::string& zoneSliceId,
               const std::string& headerZoneIdString,
               const double minHeight, const double maxHeight) :
      fHeaderDBName(headerDBName),
      fZoneSliceIdString(zoneSliceId),
      fHeaderZoneIdString(headerZoneIdString),
      fMinHeight(minHeight),
      fMaxHeight(maxHeight)
    { }

    virtual ~VZoneSlice() { }

    std::string fHeaderDBName;        // name of the header table (ie. "aerosol", "molecular", "lidar")
    std::string fZoneSliceIdString;   // identifies slice in the zone
    std::string fHeaderZoneIdString;  // identifies record in aerosol_zone table
    double fMinHeight;
    double fMaxHeight;

    // Helper method to do the redundant work of preparing requests for data contained
    // an a zone slice,  sending it to the manager and reporting any errors.
    // The errorMsg argument is used to construct some hopefully meaningful error message if the
    // requested component is not found.  It should have a description in some human language
    // of what was not located.

    template<typename T>
    void
    GetSliceData(T*& requestedData,
                 const std::string& property,
                 const std::string& component,
                 const std::string& errorMsg)
      const
    {
      if (requestedData)
        return;
      requestedData = new T;

      const det::VManager::IndexMap indexMap({
        { fHeaderDBName + "_zone_id", fHeaderZoneIdString },
        { "zone_slices_id", fZoneSliceIdString }
      });

      try {
        const det::VManager& manager =
          det::Detector::GetInstance().GetAManagerRegister();

        const det::VManager::Status foundFlag =
          manager.GetData(*requestedData, property, component, indexMap);

        if (foundFlag == det::VManager::eFound)
          return;
      } catch (...) {
        delete requestedData;
        requestedData = nullptr;
        throw;
      }

      throw utl::DataNotFoundInDBException(errorMsg);
    }

    // Similar to GetSliceData, except that this method is intended for
    // data stored in attenuation_lambda and phase_func_lambda tables.
    // Fetching data from these tables requires first retrieving the
    // appropriate foreign key from the attenuation or phase_func table,
    // then using this in the query of the attenuation_lambda or
    // phase_func_lambda table.

    template<typename T>
    void
    GetLambdaSliceData(T*& requestedData,
                       const std::string& zoneTable,    // type of zone (eg. attenuation of phase_func)
                       const std::string& foreignKey,   // name of foreign key to lambda table (eg. attenuation_lambda_id, phase_func_lambda_id)
                       const std::string& lambdaTable,  // name of lambda table (eg. attenuation_lambda, phase_func_lambda)
                       const std::string& column,       // column in lambda table (eg att_lambda, f_lambda, ....)
                       const std::string& errorMsg)
      const
    {
      if (requestedData)
        return;
      requestedData = new T;

      const det::VManager::IndexMap indexMap1({
        { "aerosol_zone_id", fHeaderZoneIdString },
        { "zone_slices_id", fZoneSliceIdString }
      });

      try {
        const det::VManager& manager =
          det::Detector::GetInstance().GetAManagerRegister();

        std::string lambdaIdString;
        const det::VManager::Status found1 =
          manager.GetData(lambdaIdString, zoneTable, foreignKey, indexMap1);

        const det::VManager::IndexMap indexMap2({
          { lambdaTable + "_id", lambdaIdString }
        });

        const det::VManager::Status found2 =
          manager.GetData(*requestedData, lambdaTable, column, indexMap2);

        if (found1 == det::VManager::eFound && found2 == det::VManager::eFound)
          return;
      } catch (...) {
        delete requestedData;
        requestedData = nullptr;
        throw;
      }

      throw utl::DataNotFoundInDBException(errorMsg);
    }

  };

}


#endif