ParmValue.h

Go to the documentation of this file.

// ParmValue.h: A class containing the values of a parameter
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_PARMVALUE_H
#define LOFAR_PARMDB_PARMVALUE_H
 
#include "Grid.h"
#include "Axis.h"
 
#include <casacore/casa/Arrays/Array.h>
 
#include <memory>
#include <string>
#include <vector>
 
namespace dp3 {
namespace parmdb {
 
 
 
//
 
class ParmValue {
 public:
  typedef std::shared_ptr<ParmValue> ShPtr;
 
  enum FunkletType {
    Scalar = 0,
    Polc = 1,
    PolcLog = 2
  };
 
  explicit ParmValue(double value = 0.);
 
  ParmValue(const ParmValue&);
 
  ~ParmValue();
 
  ParmValue& operator=(const ParmValue&);
 
  void setScalar(double value);
 
  void setCoeff(const casacore::Array<double>&);
 
  void setScalars(const Grid&, const casacore::Array<double>&);
 
  void setErrors(const casacore::Array<double>&);
 
  unsigned int nx() const {
    return static_cast<unsigned int>(itsValues.shape()[0]);
  }
  unsigned int ny() const {
    return static_cast<unsigned int>(itsValues.shape()[1]);
  }
 
  const casacore::Array<double>& getValues() const { return itsValues; }
  casacore::Array<double>& getValues() { return itsValues; }
 
  const Grid& getGrid() const { return itsGrid; }
 
  bool hasErrors() const { return itsErrors != nullptr; }
 
  const casacore::Array<double>& getErrors() const { return *itsErrors; }
  casacore::Array<double>& getErrors() { return *itsErrors; }
 
  int getRowId() const { return itsRowId; }
  void setRowId(int rowId) { itsRowId = rowId; }
  void clearRowId() { itsRowId = -1; }
 
  static casacore::Matrix<double> scale2(const casacore::Matrix<double>& coeff,
                                         double offx, double offy,
                                         double scalex, double scaley);
 
  bool rescale(double sx, double ex, double sy, double ey,
               const Box& oldDomain);
 
 private:
  void copyOther(const ParmValue& that);
 
  static void fillPascal(casacore::Matrix<double>& pascal, int order);
 
  // Data members.
  Grid itsGrid;                       
  casacore::Array<double> itsValues;  
  casacore::Array<double>* itsErrors;
  int itsRowId;  
};
 
 
class ParmValueSet {
 public:
  explicit ParmValueSet(const ParmValue& defaultValue = ParmValue(),
                        ParmValue::FunkletType = ParmValue::Scalar,
                        double perturbation = 1e-6, bool pertRel = true,
                        const Box& scaleDomain = Box());
 
  ParmValueSet(const Grid& domainGrid,
               const std::vector<ParmValue::ShPtr>& values,
               const ParmValue& defaultValue = ParmValue(),
               ParmValue::FunkletType type = ParmValue::Scalar,
               double perturbation = 1e-6, bool pertRel = true);
 
  ParmValueSet(const ParmValueSet&);
 
  ParmValueSet& operator=(const ParmValueSet&);
 
  void setSolveGrid(const Grid& solveGrid);
 
  ParmValue::FunkletType getType() const { return itsType; }
 
  const casacore::Array<bool>& getSolvableMask() const {
    return itsSolvableMask;
  }
  void setSolvableMask(const casacore::Array<bool>& mask) {
    itsSolvableMask.assign(mask);
  }
 
  double getPerturbation() const { return itsPerturbation; }
 
  bool getPertRel() const { return itsPertRel; }
 
  const Grid& getGrid() const { return itsDomainGrid; }
 
  unsigned int size() const { return itsValues.size(); }
 
  bool empty() const { return itsValues.size() == 0; }
 
  const ParmValue& getDefParmValue() const { return itsDefaultValue; }
 
  const Box& getScaleDomain() const { return itsScaleDomain; }
  void setScaleDomain(const Box& domain) { itsScaleDomain = domain; }
 
  const ParmValue& getFirstParmValue() const;
 
  const ParmValue& getParmValue(int i) const { return *(itsValues[i]); }
  ParmValue& getParmValue(int i) { return *(itsValues[i]); }
 
  bool isDirty() const { return itsDirty; }
  void setDirty(bool dirty = true) { itsDirty = dirty; }
 
 private:
  void createValues(const Grid& solveGrid);
  void checkGrid(const Grid& solveGrid);
  void addValues(const Grid& solveGrid);
  void addCoeffValues(const Grid& solveGrid);
  ParmValue::ShPtr copyParmCoeff(const ParmValue::ShPtr& pval);
 
  ParmValue::FunkletType itsType;
  double itsPerturbation;
  bool itsPertRel;
  casacore::Array<bool> itsSolvableMask;
  Grid itsDomainGrid;
  std::vector<ParmValue::ShPtr> itsValues;
  ParmValue itsDefaultValue;
  Box itsScaleDomain;
  bool itsDirty;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif