VZone.h

Go to the documentation of this file.

#ifndef _atm_VZone_h_
#define _atm_VZone_h_

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

#include <string>
#include <vector>


namespace atm {

  class VZone {

  public:
    const std::string& GetName() const { return fName; }

    double GetNorthing() const { return fNorthing; }

    double GetEasting() const { return fEasting; }

  protected:
    VZone(const std::string& zoneId, const std::string& name,
          const double northing, const double easting) :
      fZoneIdString(zoneId),
      fName(name),
      fNorthing(northing),
      fEasting(easting)
    { }

    virtual ~VZone() { }

    std::string fZoneIdString;
    std::string fName;
    double fNorthing;
    double fEasting;

    // Cache the slices in this zone (fills data on zone slice boundaries and

    template<typename Slice>
    void
    CacheSlices(std::vector<const Slice*>*& slices, // vector of zone slices to be filled in by this method
                const std::string& database,        // eg. aerosol, molecular, lidar
                const std::string& property,        // eg. attenuation, phase_func, molecular, VAOD from lidar
                const std::string& zone,            // id for the wanted aerosol, molecular, lidar zone slices
                const det::VManager& manager)       // specify which manager (or manager register) to use
      const
    {
      if (slices)
        return;
      slices = new std::vector<const Slice*>;

      std::vector<std::string> propertyIdVec;
      const std::string propertyId = property + "_id";
      const det::VManager::IndexMap zoneSelect({ { database + "_zone_id", zone } });
      const auto stat = manager.GetData(propertyIdVec, property, propertyId, zoneSelect);

      if (stat == det::VManager::eNotFound) {
        std::ostringstream err;
        err << "Did not find requested data, "
               "header table: " << database << ", "
               "slice table name: " << property << ", "
               "zoneId: " << zone;
        ERROR(err);
        throw utl::NonExistentComponentException(err.str());
      }

      for (const auto& pId : propertyIdVec) {
        std::string zoneSlicesId;
        const det::VManager::IndexMap idSelect({ { propertyId, pId } });
        manager.GetData(zoneSlicesId, property, "zone_slices_id", idSelect);

        const det::VManager::IndexMap zoneSlicesSelect({ { "zone_slices_id", zoneSlicesId } });

        double minHeight = 0;
        manager.GetData(minHeight, "zone_slices", "min_height", zoneSlicesSelect);

        double maxHeight = 0;
        manager.GetData(maxHeight, "zone_slices", "max_height", zoneSlicesSelect);

        slices->push_back(new Slice(database, zoneSlicesId, zone, minHeight, maxHeight));
      }
    }

  };

}


#endif