Parm.h

Go to the documentation of this file.

// Parm.h: Class giving access to a parameter
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
 
#ifndef LOFAR_PARMDB_PARM_H
#define LOFAR_PARMDB_PARM_H
 
#include "Grid.h"
#include "ParmSet.h"
 
#include <casacore/casa/Arrays/Array.h>
 
namespace dp3 {
namespace parmdb {
 
class ParmCache;
class ParmValue;
class ParmValueSet;
class AxisMappingCache;
 
 
 
//
 
class Parm {
 public:
  Parm(ParmCache&, ParmId parmid);
 
  Parm(ParmCache&, const std::string& name);
 
  void setSolveGrid(const Grid& solveGrid);
 
  unsigned int getCoeffSize(bool useMask = true);
 
  std::vector<double> getCoeff(const Grid::Location&, bool useMask = true);
 
  std::vector<double> getErrors(const Grid::Location&, bool useMask = true);
 
  void setCoeff(const Grid::Location&, const double* values,
                unsigned int nvalues, const double* errors = nullptr,
                bool useMask = true);
 
  void revertCoeff();
 
  const std::vector<double>& getPerturbations() const {
    return itsPerturbations;
  }
 
  double getPerturbation(unsigned int index) {
    return itsPerturbations.at(index);
  }
 
  void getResult(casacore::Array<double>& result, const Grid& predictGrid,
                 bool emptyResult = false);
 
  void getResult(std::vector<casacore::Array<double>>& result,
                 const Grid& predictGrid, bool perturb);
 
  static std::vector<double> copyValues(const casacore::Array<double>& values,
                                        const casacore::Array<bool>& mask,
                                        bool useMask);
 
  static void getResultCoeff(casacore::Array<double>* resultVec,
                             const Grid& predictGrid, const ParmValueSet& pvset,
                             const std::vector<double>& perturbations,
                             AxisMappingCache& axisMappingCache);
 
  static void getResultScalar(casacore::Array<double>& result,
                              const Grid& predictGrid, const ParmValue& pval,
                              AxisMappingCache& axisMappingCache);
 
  static void getResultScalar(casacore::Array<double>& result,
                              casacore::Array<double>* errors,
                              const Grid& predictGrid,
                              const ParmValueSet& pvset,
                              AxisMappingCache& axisMappingCache);
 
  static void fillArrayPV(double* resData, int nrx, int stx, int sty, int endx,
                          int endy, const double* data, const ParmValue& pval,
                          const Grid& predictGrid);
 
  void calcPerturbations();
 
 private:
  ParmCache* itsCache;
  ParmId itsParmId;
  Grid itsSolveGrid;
  std::vector<double> itsPerturbations;
};
 
 
}  // namespace parmdb
}  // namespace dp3
 
#endif