AxisMapping.h

Go to the documentation of this file.

// AxisMapping.h: Map the cells of one axis to another
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_AXISMAPPING_H
#define LOFAR_PARMDB_AXISMAPPING_H
 
#include "Grid.h"
 
#include <map>
 
namespace dp3 {
namespace parmdb {
 
 
class AxisMapping {
 public:
  AxisMapping(const Axis& from, const Axis& to);
 
  typedef std::vector<int>::const_iterator const_iterator;
  const_iterator begin() const { return itsMapping.begin(); }
  const_iterator end() const { return itsMapping.end(); }
 
  size_t size() const { return itsMapping.size(); }
 
  int operator[](int i) const { return itsMapping[i]; }
 
  const double* getScaledCenters() const { return &(itsCenters[0]); }
 
  const std::vector<int>& getBorders() const { return itsBorders; }
 
 private:
  std::vector<int> itsMapping;     
  std::vector<double> itsCenters;  
  std::vector<int> itsBorders;     
};
 
//
class AxisCache {
 public:
  Grid getGrid(const std::vector<Box>& domains);
 
  Axis::ShPtr getAxis(const Axis& axis);
 
  void clear() {
    itsGridCache.clear();
    itsAxisCache.clear();
  }
 
 private:
  std::map<int64_t, std::vector<std::pair<int, int>>> itsGridCache;
  std::map<int, Axis::ShPtr> itsAxisCache;
};
 
class AxisMappingCache {
 private:
  struct AxisKey {
    AxisKey(unsigned int fromId, unsigned int toId)
        : itsFrom(fromId), itsTo(toId) {}
    unsigned int itsFrom;
    unsigned int itsTo;
 
    bool operator==(const AxisKey that) const {
      return itsFrom == that.itsFrom && itsTo == that.itsTo;
    }
    bool operator!=(const AxisKey that) const {
      return itsFrom != that.itsFrom || itsTo != that.itsTo;
    }
    bool operator<(const AxisKey that) const {
      return itsFrom < that.itsFrom ||
             (itsFrom == that.itsFrom && itsTo < that.itsTo);
    }
  };
 
 public:
  size_t size() const { return itsCache.size(); }
 
  void clear() { itsCache.clear(); }
 
  const AxisMapping& get(const Axis& from, const Axis& to) {
    std::map<AxisKey, AxisMapping>::const_iterator iter =
        itsCache.find(AxisKey(from.getId(), to.getId()));
    return (iter == itsCache.end() ? makeMapping(from, to) : iter->second);
  }
 
 private:
  const AxisMapping& makeMapping(const Axis& from, const Axis& to);
 
  std::map<AxisKey, AxisMapping> itsCache;
};
 
class GridMapping {
 public:
  static Grid::Location findLocation(AxisMappingCache& cache,
                                     const Grid::Location& location,
                                     const Grid& src, const Grid& dest);
 
  static Grid::Location findLocation(AxisMappingCache& cache,
                                     unsigned int cellId, const Grid& src,
                                     const Grid& dest);
 
  static unsigned int findCellId(AxisMappingCache& cache,
                                 const Grid::Location& location,
                                 const Grid& src, const Grid& dest);
 
  static unsigned int findcellId(AxisMappingCache& cache, unsigned int cellId,
                                 const Grid& src, const Grid& dest);
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif