lsst::afw::math::Chebyshev1Function2< ReturnT > Class Template Reference

2-dimensional weighted sum of Chebyshev polynomials of the first kind. More...

#include <FunctionLibrary.h>

Inheritance diagram for lsst::afw::math::Chebyshev1Function2< ReturnT >:

## Public Member Functions

Chebyshev1Function2 (unsigned int order, lsst::geom::Box2D const &xyRange=lsst::geom::Box2D(lsst::geom::Point2D(-1.0, -1.0), lsst::geom::Point2D(1.0, 1.0)))
Construct a Chebyshev polynomial of specified order and range. More...

Chebyshev1Function2 (std::vector< double > params, lsst::geom::Box2D const &xyRange=lsst::geom::Box2D(lsst::geom::Point2D(-1.0, -1.0), lsst::geom::Point2D(1.0, 1.0)))
Construct a Chebyshev polynomial with specified parameters and range. More...

Chebyshev1Function2 (Chebyshev1Function2 const &)=default

Chebyshev1Function2 (Chebyshev1Function2 &&)=default

Chebyshev1Function2operator= (Chebyshev1Function2 const &)=default

Chebyshev1Function2operator= (Chebyshev1Function2 &&)=default

~Chebyshev1Function2 () noexcept override=default

std::shared_ptr< Function2< ReturnT > > clone () const override
Return a pointer to a deep copy of this function. More...

lsst::geom::Box2D getXYRange () const noexcept
Get x,y range. More...

virtual Chebyshev1Function2 truncate (int truncOrder) const
Return a truncated copy of lower (or equal) order. More...

ReturnT operator() (double x, double y) const override

std::string toString (std::string const &prefix) const override
Return a string representation of the function. More...

bool isPersistable () const noexcept override
Return true if this particular object can be persisted using afw::table::io. More...

int getOrder () const noexcept
Get the polynomial order. More...

bool isLinearCombination () const noexcept override
Is the function a linear combination of its parameters? More...

std::vector< double > getDFuncDParameters (double x, double y) const override
Return the derivative of the Function with respect to its parameters. More...

unsigned int getNParameters () const noexcept
Return the number of function parameters. More...

virtual double getParameter (unsigned int ind) const
Get one function parameter without range checking. More...

std::vector< double > const & getParameters () const noexcept
Return all function parameters. More...

void setParameter (unsigned int ind, double newValue)
Set one function parameter without range checking. More...

void setParameters (std::vector< double > const &params)
Set all function parameters. More...

void writeFits (std::string const &fileName, std::string const &mode="w") const
Write the object to a regular FITS file. More...

void writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
Write the object to a FITS image in memory. More...

void writeFits (fits::Fits &fitsfile) const
Write the object to an already-open FITS object. More...

## Static Public Member Functions

static int nParametersFromOrder (int order)
Compute number of parameters from polynomial order. More...

static int orderFromNParameters (int nParameters)
Compute polynomial order from the number of parameters. More...

static std::shared_ptr< Function2< ReturnT > > readFits (fits::Fits &fitsfile)

static std::shared_ptr< Function2< ReturnT > > readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
Read an object from a regular FITS file. More...

static std::shared_ptr< Function2< ReturnT > > readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
Read an object from a FITS file in memory. More...

static std::shared_ptr< Function< ReturnT > > readFits (fits::Fits &fitsfile)

static std::shared_ptr< Function< ReturnT > > readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
Read an object from a regular FITS file. More...

static std::shared_ptr< Function< ReturnT > > readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
Read an object from a FITS file in memory. More...

static std::shared_ptr< Function2< ReturnT > > dynamicCast (std::shared_ptr< Persistable > const &ptr)
Dynamically cast a shared_ptr. More...

static std::shared_ptr< Function< ReturnT > > dynamicCast (std::shared_ptr< Persistable > const &ptr)
Dynamically cast a shared_ptr. More...

## Protected Types

using OutputArchiveHandle = io::OutputArchiveHandle

## Protected Member Functions

std::string getPersistenceName () const override
Return the unique name used to persist this object and look up its factory. More...

void write (afw::table::io::OutputArchiveHandle &handle) const override
Write the object to one or more catalogs. More...

Chebyshev1Function2 ()

std::string getPythonModule () const override
Return the fully-qualified Python module that should be imported to guarantee that its factory is registered. More...

## Protected Attributes

int _order
order of polynomial More...

std::vector< double > _params

bool _isCacheValid

## Detailed Description

### template<typename ReturnT> class lsst::afw::math::Chebyshev1Function2< ReturnT >

2-dimensional weighted sum of Chebyshev polynomials of the first kind.

f(x,y) = c0 T0(x') T0(y') # order 0

• c1 T1(x') T0(y') + c2 T0(x') T1(y') # order 1
• c3 T2(x') T0(y') + c4 T1(x') T1(y') + c5 T0(x') T2(y') # order 2
• ...

= c0 # order 0

• c1 T1(x') + c2 T1(y') # order 1
• c3 T2(x') + c4 T1(x') T1(y') + c5 T2(y') # order 2
• ...

where:

• Tn(x) is the nth Chebyshev function of the first kind: T0(x) = 1 T1(x) = x Tn+1(x) = 2xTn(x) + Tn-1(x)
• x' is x offset and scaled to range [-1, 1] as x ranges over [minX, maxX]
• y' is y offset and scaled to range [-1, 1] as y ranges over [minY, maxY]

Return value is incorrect if function arguments are not in the range [minX, maxX], [minY, maxY].

Definition at line 719 of file FunctionLibrary.h.

## ◆ OutputArchiveHandle

 using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle
protectedinherited

Definition at line 108 of file Persistable.h.

## ◆ Chebyshev1Function2() [1/5]

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::Chebyshev1Function2 ( unsigned int order, lsst::geom::Box2D const & xyRange = lsst::geom::Box2D(                                         lsst::geom::Point2D(-1.0, -1.0),                                         lsst::geom::Point2D(1.0, 1.0)) )
inlineexplicit

Construct a Chebyshev polynomial of specified order and range.

The parameters are initialized to zero.

Parameters
 order order of polynomial (0 for constant) xyRange allowed x,y range

Definition at line 726 of file FunctionLibrary.h.

730  : BasePolynomialFunction2<ReturnT>(order),
731  _oldYPrime(0),
732  _yCheby(this->_order + 1),
733  _xCoeffs(this->_order + 1) {
734  _initialize(xyRange);
735  }
table::Key< int > order

## ◆ Chebyshev1Function2() [2/5]

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::Chebyshev1Function2 ( std::vector< double > params, lsst::geom::Box2D const & xyRange = lsst::geom::Box2D(                                         lsst::geom::Point2D(-1.0, -1.0),                                         lsst::geom::Point2D(1.0, 1.0)) )
inlineexplicit

Construct a Chebyshev polynomial with specified parameters and range.

The order of the polynomial is set to the length of the params vector.

Exceptions
 lsst::pex::exceptions::InvalidParameterError if params is empty
Parameters
 params polynomial coefficients length must be one of 1, 3, 6, 10, 15... xyRange allowed x,y range

Definition at line 744 of file FunctionLibrary.h.

749  : BasePolynomialFunction2<ReturnT>(params),
750  _oldYPrime(0),
751  _yCheby(this->_order + 1),
752  _xCoeffs(this->_order + 1) {
753  _initialize(xyRange);
754  }

## ◆ Chebyshev1Function2() [3/5]

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::Chebyshev1Function2 ( Chebyshev1Function2< ReturnT > const & )
default

## ◆ Chebyshev1Function2() [4/5]

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::Chebyshev1Function2 ( Chebyshev1Function2< ReturnT > && )
default

## ◆ ~Chebyshev1Function2()

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::~Chebyshev1Function2 ( )
overridedefaultnoexcept

## ◆ Chebyshev1Function2() [5/5]

template<typename ReturnT >
 lsst::afw::math::Chebyshev1Function2< ReturnT >::Chebyshev1Function2 ( )
inlineexplicitprotected

Definition at line 899 of file FunctionLibrary.h.

900  : BasePolynomialFunction2<ReturnT>(),
901  _oldYPrime(0),
902  _yCheby(0),
903  _xCoeffs(0),
904  _minX(0.0),
905  _minY(0.0),
906  _maxX(0.0),
907  _maxY(0.0),
908  _scaleX(1.0),
909  _scaleY(1.0),
910  _offsetX(0.0),
911  _offsetY(0.0) {}

## ◆ clone()

template<typename ReturnT >
 std::shared_ptr > lsst::afw::math::Chebyshev1Function2< ReturnT >::clone ( ) const
inlineoverridevirtual

Return a pointer to a deep copy of this function.

This function exists instead of a copy constructor so one can obtain a copy of an actual function instead of a useless copy of the base class.

Every non-virtual function must override this method.

Returns
a pointer to a deep copy of the function

Implements lsst::afw::math::Function2< ReturnT >.

Definition at line 762 of file FunctionLibrary.h.

762  {
764  new Chebyshev1Function2(this->_params, this->getXYRange()));
765  }
lsst::geom::Box2D getXYRange() const noexcept
Get x,y range.
std::vector< double > _params
Definition: Function.h:185

## ◆ dynamicCast() [1/2]

 template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< Function2< ReturnT > >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )
staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions
 lsst::pex::exceptions::LogicError if the cast fails

param[in] ptr The pointer to be cast.

Returns
The cast pointer.
Exceptions
 lsst::pex::exceptions::TypeError If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

18  {
19  auto result = std::dynamic_pointer_cast<T>(ptr);
20  if (!result) {
21  throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
22  }
23  return result;
24 }
py::object result
Definition: _schema.cc:429
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
uint64_t * ptr
Definition: RangeSet.cc:88

## ◆ dynamicCast() [2/2]

 template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< Function< ReturnT > >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )
staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions
 lsst::pex::exceptions::LogicError if the cast fails

param[in] ptr The pointer to be cast.

Returns
The cast pointer.
Exceptions
 lsst::pex::exceptions::TypeError If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

18  {
19  auto result = std::dynamic_pointer_cast<T>(ptr);
20  if (!result) {
21  throw LSST_EXCEPT(pex::exceptions::TypeError, "Dynamic pointer cast failed");
22  }
23  return result;
24 }

## ◆ getDFuncDParameters()

template<typename ReturnT >
 std::vector lsst::afw::math::BasePolynomialFunction2< ReturnT >::getDFuncDParameters ( double x, double y ) const
inlineoverridevirtualinherited

Return the derivative of the Function with respect to its parameters.

Because this is a polynomial, c0 F0(x,y) + c1 F1(x,y) + c2 F2(x,y) + ... we can set ci = 0 for all i except the parameter of interest and evaluate. This isn't necessarily the most efficient algorithm, but it's general, and you can override it if it isn't suitable for your particular subclass.

Reimplemented from lsst::afw::math::Function2< ReturnT >.

Reimplemented in lsst::afw::math::PolynomialFunction2< ReturnT >.

Definition at line 411 of file Function.h.

411  {
412  unsigned int const numParams = this->getNParameters(); // Number of parameters
413  std::vector<double> deriv(numParams); // Derivatives, to return
414
416  this->clone(); // Dummy function to evaluate for derivatives
417  for (unsigned int i = 0; i < numParams; ++i) {
418  dummy->setParameter(i, 0.0);
419  }
420
421  for (unsigned int i = 0; i < numParams; ++i) {
422  dummy->setParameter(i, 1.0);
423  deriv[i] = (*dummy)(x, y);
424  dummy->setParameter(i, 0.0);
425  }
426
427  return deriv;
428  }
double x
int y
Definition: SpanSet.cc:48
virtual std::shared_ptr< Function2< ReturnT > > clone() const =0
Return a pointer to a deep copy of this function.
unsigned int getNParameters() const noexcept
Return the number of function parameters.
Definition: Function.h:112

## ◆ getNParameters()

template<typename ReturnT >
 unsigned int lsst::afw::math::Function< ReturnT >::getNParameters ( ) const
inlinenoexceptinherited

Return the number of function parameters.

Returns
the number of function parameters

Definition at line 112 of file Function.h.

112 { return _params.size(); }
T size(T... args)

## ◆ getOrder()

template<typename ReturnT >
 int lsst::afw::math::BasePolynomialFunction2< ReturnT >::getOrder ( ) const
inlinenoexceptinherited

Get the polynomial order.

Definition at line 360 of file Function.h.

360 { return _order; }

## ◆ getParameter()

template<typename ReturnT >
 virtual double lsst::afw::math::Function< ReturnT >::getParameter ( unsigned int ind ) const
inlinevirtualinherited

Get one function parameter without range checking.

Returns
the specified function parameter
Parameters
 ind index of parameter

Definition at line 119 of file Function.h.

120  {
121  return _params[ind];
122  }

## ◆ getParameters()

template<typename ReturnT >
 std::vector const& lsst::afw::math::Function< ReturnT >::getParameters ( ) const
inlinenoexceptinherited

Return all function parameters.

Returns
the function parameters as a vector

Definition at line 129 of file Function.h.

129 { return _params; }

## ◆ getPersistenceName()

template<typename ReturnT >
 std::string lsst::afw::math::Chebyshev1Function2< ReturnT >::getPersistenceName
overrideprotectedvirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 212 of file FunctionLibrary.cc.

212  {
213  return "Chebyshev1Function2" + Suffix<ReturnT>::get();
214 }

## ◆ getPythonModule()

template<typename ReturnT >
 std::string lsst::afw::math::Function< ReturnT >::getPythonModule ( ) const
inlineoverrideprotectedvirtualinherited

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 188 of file Function.h.

188 { return "lsst.afw.math"; }

## ◆ getXYRange()

template<typename ReturnT >
 lsst::geom::Box2D lsst::afw::math::Chebyshev1Function2< ReturnT >::getXYRange ( ) const
inlinenoexcept

Get x,y range.

Definition at line 770 of file FunctionLibrary.h.

770  {
771  return lsst::geom::Box2D(lsst::geom::Point2D(_minX, _minY), lsst::geom::Point2D(_maxX, _maxY));
772  };
A floating-point coordinate rectangle geometry.
Definition: Box.h:413

## ◆ isLinearCombination()

template<typename ReturnT >
 bool lsst::afw::math::BasePolynomialFunction2< ReturnT >::isLinearCombination ( ) const
inlineoverridevirtualnoexceptinherited

Is the function a linear combination of its parameters?

Returns
true if the function can be expressed as: sum over i of parameter_i * function_i(args)
Warning
: subclasses must override if true.

Reimplemented from lsst::afw::math::Function< ReturnT >.

Definition at line 362 of file Function.h.

362 { return true; }

## ◆ isPersistable()

template<typename ReturnT >
 bool lsst::afw::math::Chebyshev1Function2< ReturnT >::isPersistable ( ) const
inlineoverridevirtualnoexcept

Return true if this particular object can be persisted using afw::table::io.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 863 of file FunctionLibrary.h.

863 { return true; }

## ◆ nParametersFromOrder()

template<typename ReturnT >
 static int lsst::afw::math::BasePolynomialFunction2< ReturnT >::nParametersFromOrder ( int order )
inlinestaticinherited

Compute number of parameters from polynomial order.

Exceptions
 lsst::pex::exceptions::InvalidParameterError if order < 0

Definition at line 369 of file Function.h.

369  {
370  if (order < 0) {
372  os << "order=" << order << " invalid: must be >= 0";
374  }
375  return (order + 1) * (order + 2) / 2;
376  }
std::ostream * os
Definition: Schema.cc:557
Reports invalid arguments.
Definition: Runtime.h:66

## ◆ operator()()

template<typename ReturnT >
 ReturnT lsst::afw::math::Chebyshev1Function2< ReturnT >::operator() ( double x, double y ) const
inlineoverridevirtual

Implements lsst::afw::math::Function2< ReturnT >.

Definition at line 791 of file FunctionLibrary.h.

791  {
792  /* Solve as follows:
793  - f(x,y) = Cy0 T0(y') + Cy1 T1(y') + Cy2 T2(y') + Cy3 T3(y') + ...
794  where:
795  Cy0 = P0 T0(x') + P1 T1(x') + P3 T2(x') + P6 T3(x') + ...
796  Cy1 = P2 T0(x') + P4 T1(x') + P7 T2(x') + ...
797  Cy2 = P5 T0(x') + P8 T1(x') + ...
798  Cy3 = P9 T0(x') + ...
799  ...
800
801  First compute Tn(x') for each n
802  Then use that to compute Cy0, Cy1, ...Cyn
803  Then solve the y Chebyshev polynomial using the Clenshaw algorithm
804  */
805  double const xPrime = (x + _offsetX) * _scaleX;
806  double const yPrime = (y + _offsetY) * _scaleY;
807
808  const int nParams = static_cast<int>(this->_params.size());
809  const int order = this->_order;
810
811  if (order == 0) {
812  return this->_params[0]; // No caching required
813  }
814
815  if ((yPrime != _oldYPrime) || !this->_isCacheValid) {
816  // update cached _yCheby and _xCoeffs
817  _yCheby[0] = 1.0;
818  _yCheby[1] = yPrime;
819  for (int chebyInd = 2; chebyInd <= order; chebyInd++) {
820  _yCheby[chebyInd] = (2 * yPrime * _yCheby[chebyInd - 1]) - _yCheby[chebyInd - 2];
821  }
822
823  for (int coeffInd = 0; coeffInd <= order; coeffInd++) {
824  _xCoeffs[coeffInd] = 0;
825  }
826  for (int coeffInd = 0, endCoeffInd = 0, paramInd = 0; paramInd < nParams; paramInd++) {
827  _xCoeffs[coeffInd] += this->_params[paramInd] * _yCheby[endCoeffInd];
828  --coeffInd;
829  ++endCoeffInd;
830  if (coeffInd < 0) {
831  coeffInd = endCoeffInd;
832  endCoeffInd = 0;
833  }
834  }
835
836  _oldYPrime = yPrime;
837  this->_isCacheValid = true;
838  }
839
840  // Clenshaw function for solving the Chebyshev polynomial
841  // Non-recursive version from Kresimir Cosic
842  if (order == 1) {
843  return _xCoeffs[0] + (_xCoeffs[1] * xPrime);
844  }
845  double cshPrev = _xCoeffs[order];
846  double csh = (2 * xPrime * _xCoeffs[order]) + _xCoeffs[order - 1];
847  for (int i = order - 2; i > 0; --i) {
848  double cshNext = (2 * xPrime * csh) + _xCoeffs[i] - cshPrev;
849  cshPrev = csh;
850  csh = cshNext;
851  }
852  return (xPrime * csh) + _xCoeffs[0] - cshPrev;
853  }

## ◆ operator=() [1/2]

template<typename ReturnT >
 Chebyshev1Function2& lsst::afw::math::Chebyshev1Function2< ReturnT >::operator= ( Chebyshev1Function2< ReturnT > && )
default

## ◆ operator=() [2/2]

template<typename ReturnT >
 Chebyshev1Function2& lsst::afw::math::Chebyshev1Function2< ReturnT >::operator= ( Chebyshev1Function2< ReturnT > const & )
default

## ◆ orderFromNParameters()

template<typename ReturnT >
 static int lsst::afw::math::BasePolynomialFunction2< ReturnT >::orderFromNParameters ( int nParameters )
inlinestaticinherited

Compute polynomial order from the number of parameters.

Only certain values of nParameters are acceptable, including: nParameters order 1 0 3 1 6 2 10 3 15 4 ...

Exceptions
 lsst::pex::exceptions::InvalidParameterError if nParameters is invalid

Definition at line 392 of file Function.h.

392  {
393  int order = static_cast<int>(
394  0.5 + ((-3.0 + (std::sqrt(1.0 + (8.0 * static_cast<double>(nParameters))))) / 2.0));
397  os << "nParameters=" << nParameters << " invalid: order is not an integer";
399  }
400  return order;
401  }
static int nParametersFromOrder(int order)
Compute number of parameters from polynomial order.
Definition: Function.h:369
T sqrt(T... args)

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function2< ReturnT > >::readFits ( fits::Fits & fitsfile )
inlinestaticinherited

Parameters
 [in] fitsfile FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

183  {
185  }
static std::shared_ptr< Function2< ReturnT > > dynamicCast(std::shared_ptr< Persistable > const &ptr)
Dynamically cast a shared_ptr.
Definition: Persistable.cc:18

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function< ReturnT > >::readFits ( fits::Fits & fitsfile )
inlinestaticinherited

Parameters
 [in] fitsfile FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

183  {
185  }

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function< ReturnT > >::readFits ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )
inlinestaticinherited

Read an object from a FITS file in memory.

Parameters
 [in] manager Manager for the memory to read from. [in] hdu HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

205  {
207  }

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function2< ReturnT > >::readFits ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )
inlinestaticinherited

Read an object from a FITS file in memory.

Parameters
 [in] manager Manager for the memory to read from. [in] hdu HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

205  {
207  }

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function2< ReturnT > >::readFits ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )
inlinestaticinherited

Read an object from a regular FITS file.

Parameters
 [in] fileName Name of the file to read. [in] hdu HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

194  {
196  }

 static std::shared_ptr > lsst::afw::table::io::PersistableFacade< Function< ReturnT > >::readFits ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )
inlinestaticinherited

Read an object from a regular FITS file.

Parameters
 [in] fileName Name of the file to read. [in] hdu HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

194  {
196  }

## ◆ setParameter()

template<typename ReturnT >
 void lsst::afw::math::Function< ReturnT >::setParameter ( unsigned int ind, double newValue )
inlineinherited

Set one function parameter without range checking.

Parameters
 ind index of parameter newValue new value for parameter

Definition at line 143 of file Function.h.

145  {
146  _isCacheValid = false;
147  _params[ind] = newValue;
148  }

## ◆ setParameters()

template<typename ReturnT >
 void lsst::afw::math::Function< ReturnT >::setParameters ( std::vector< double > const & params )
inlineinherited

Set all function parameters.

Exceptions
 lsst::pex::exceptions::InvalidParameterError if the wrong number of parameters is supplied.
Parameters
 params vector of function parameters

Definition at line 156 of file Function.h.

157  {
158  if (_params.size() != params.size()) {
159  throw LSST_EXCEPT(
161  (boost::format("params has %d entries instead of %d") % params.size() % _params.size())
162  .str());
163  }
164  _isCacheValid = false;
165  _params = params;
166  }
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174

## ◆ toString()

template<typename ReturnT >
 std::string lsst::afw::math::Chebyshev1Function2< ReturnT >::toString ( std::string const & ) const
inlineoverridevirtual

Return a string representation of the function.

Returns
a string representation of the function

Reimplemented from lsst::afw::math::Function2< ReturnT >.

Definition at line 855 of file FunctionLibrary.h.

855  {
857  os << "Chebyshev1Function2 [";
858  os << this->_order << ", " << this->getXYRange() << "]";
859  os << Function2<ReturnT>::toString(prefix);
860  return os.str();
861  }
std::string prefix
Definition: SchemaMapper.cc:72

## ◆ truncate()

template<typename ReturnT >
 virtual Chebyshev1Function2 lsst::afw::math::Chebyshev1Function2< ReturnT >::truncate ( int truncOrder ) const
inlinevirtual

Return a truncated copy of lower (or equal) order.

Exceptions
 lsst::pex::exceptions::InvalidParameter if truncated order > original order
Parameters
 truncOrder order of truncated polynomial

Definition at line 779 of file FunctionLibrary.h.

780  {
781  if (truncOrder > this->_order) {
783  os << "truncated order=" << truncOrder << " must be <= original order=" << this->_order;
785  }
786  int truncNParams = this->nParametersFromOrder(truncOrder);
787  std::vector<double> truncParams(this->_params.begin(), this->_params.begin() + truncNParams);
788  return Chebyshev1Function2(truncParams, this->getXYRange());
789  }
T begin(T... args)

## ◆ write()

template<typename ReturnT >
 void lsst::afw::math::Chebyshev1Function2< ReturnT >::write ( afw::table::io::OutputArchiveHandle & handle ) const
overrideprotectedvirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 247 of file FunctionLibrary.cc.

247  {
248  Chebyshev1Function2PersistenceHelper const keys(this->getNParameters());
249  table::BaseCatalog catalog = handle.makeCatalog(keys.schema);
251  keys.coefficients.assignVector(*record, this->getParameters());
253  record->set(keys.min, bbox.getMin());
254  record->set(keys.max, bbox.getMax());
255  handle.saveCatalog(catalog);
256 }
AmpInfoBoxKey bbox
Definition: Amplifier.cc:117
std::vector< double > const & getParameters() const noexcept
Return all function parameters.
Definition: Function.h:129
CatalogT< BaseRecord > BaseCatalog
Definition: fwd.h:72

## ◆ writeFits() [1/3]

 void lsst::afw::table::io::Persistable::writeFits ( fits::Fits & fitsfile ) const
inherited

Write the object to an already-open FITS object.

Parameters
 [in] fitsfile Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

18  {
19  OutputArchive archive;
20  archive.put(this);
21  archive.writeFits(fitsfile);
22 }

## ◆ writeFits() [2/3]

 void lsst::afw::table::io::Persistable::writeFits ( fits::MemFileManager & manager, std::string const & mode = "w" ) const
inherited

Write the object to a FITS image in memory.

Parameters
 [in] manager Name of the file to write to. [in] mode If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

29  {
30  fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
31  writeFits(fitsfile);
32 }
void writeFits(std::string const &fileName, std::string const &mode="w") const
Write the object to a regular FITS file.
Definition: Persistable.cc:24

## ◆ writeFits() [3/3]

 void lsst::afw::table::io::Persistable::writeFits ( std::string const & fileName, std::string const & mode = "w" ) const
inherited

Write the object to a regular FITS file.

Parameters
 [in] fileName Name of the file to write to. [in] mode If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

24  {
25  fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
26  writeFits(fitsfile);
27 }

## ◆ _isCacheValid

template<typename ReturnT >
 bool lsst::afw::math::Function< ReturnT >::_isCacheValid
mutableprotectedinherited

Definition at line 186 of file Function.h.

## ◆ _order

template<typename ReturnT >
 int lsst::afw::math::BasePolynomialFunction2< ReturnT >::_order
protectedinherited

order of polynomial

Definition at line 431 of file Function.h.

## ◆ _params

template<typename ReturnT >
 std::vector lsst::afw::math::Function< ReturnT >::_params
protectedinherited

Definition at line 185 of file Function.h.

The documentation for this class was generated from the following files:
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/include/lsst/afw/math/FunctionLibrary.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/src/math/FunctionLibrary.cc