LSST Applications g04a91732dc+146a938ab0,g07dc498a13+80b84b0d75,g0fba68d861+4c4f3dcb5c,g1409bbee79+80b84b0d75,g1a7e361dbc+80b84b0d75,g1fd858c14a+f6e422e056,g20f46db602+333b6c0f32,g35bb328faa+fcb1d3bbc8,g42c1b31a95+a1301e4c20,g4d2262a081+f1facf12e5,g4d39ba7253+9b833be27e,g4e0f332c67+5d362be553,g53246c7159+fcb1d3bbc8,g60b5630c4e+9b833be27e,g78460c75b0+2f9a1b4bcd,g786e29fd12+cf7ec2a62a,g7b71ed6315+fcb1d3bbc8,g8852436030+790117df0f,g89139ef638+80b84b0d75,g8d6b6b353c+9b833be27e,g9125e01d80+fcb1d3bbc8,g989de1cb63+80b84b0d75,g9f33ca652e+9c6b68d7f3,ga9baa6287d+9b833be27e,gaaedd4e678+80b84b0d75,gabe3b4be73+1e0a283bba,gb1101e3267+9f3571abad,gb58c049af0+f03b321e39,gb90eeb9370+691e4ab549,gc741bbaa4f+2bcd3860df,gcf25f946ba+790117df0f,gd315a588df+5b65d88fe4,gd6cbbdb0b4+c8606af20c,gd9a9a58781+fcb1d3bbc8,gde0f65d7ad+ee6a3faa19,ge278dab8ac+932305ba37,ge82c20c137+76d20ab76d,gee8db133a9+2a6ae0040b,w.2025.10
LSST Data Management Base Package
|
Classes | |
class | GenericPlugin |
class | WrappedForcedPlugin |
class | WrappedSingleFramePlugin |
Functions | |
wrapAlgorithmControl (Base, Control, module=None, hasMeasureN=False) | |
wrapAlgorithm (Base, AlgClass, factory, executionOrder, name=None, Control=None, ConfigClass=None, TransformClass=None, doRegister=True, shouldApCorr=False, apCorrList=(), hasLogName=False, **kwds) | |
wrapSingleFrameAlgorithm (AlgClass, executionOrder, name=None, needsMetadata=False, hasMeasureN=False, hasLogName=False, deprecated=None, **kwds) | |
wrapForcedAlgorithm (AlgClass, executionOrder, name=None, needsMetadata=False, hasMeasureN=False, needsSchemaOnly=False, hasLogName=False, deprecated=None, **kwds) | |
wrapSimpleAlgorithm (AlgClass, executionOrder, name=None, needsMetadata=False, hasMeasureN=False, hasLogName=False, deprecated=None, **kwds) | |
wrapTransform (transformClass, hasLogName=False) | |
lsst.meas.base.wrappers.wrapAlgorithm | ( | Base, | |
AlgClass, | |||
factory, | |||
executionOrder, | |||
name = None, | |||
Control = None, | |||
ConfigClass = None, | |||
TransformClass = None, | |||
doRegister = True, | |||
shouldApCorr = False, | |||
apCorrList = (), | |||
hasLogName = False, | |||
** | kwds ) |
Wrap a C++ algorithm class to create a measurement plugin. Parameters ---------- Base : `SingleFramePlugin` or `ForcedPlugin` Base class for the returned Plugin. AlgClass : API compatible with `SingleFrameAlgorithm` or `ForcedAlgorithm` C++ algorithm class to convert. May either derive directly from `SingleFrameAlgorithm` or `ForcedAlgorithm`, or be an unrelated class which has the same ``measure`` and ``measureN`` signatures. factory : callable A callable that is used to construct an instance of ``AlgClass``. It must take four arguments, either ``(config, name, schema, metadata)`` or ``(config, name, schemaMapper, metadata)``, depending on whether the algorithm is single-frame or forced. executionOrder : `float` The order this plugin should be run, relative to others (see `BasePlugin.getExecutionOrder`). name : `str`, optional String to use when registering the algorithm. Ignored if ``doRegistry=False``, set to ``generateAlgorithmName(AlgClass)`` if `None`. Control : Pybind11-wrapped version of a C++ class, optional Pybind11-wrapped C++ Control class for the algorithm; ``AlgClass.Control`` is used if `None`. Ignored if ``ConfigClass`` is not `None`. ConfigClass : subclass of `BaseMeasurementPluginConfig` Python config class that wraps the C++ algorithm's pybind11-wrapped Control class. If `None`, `wrapAlgorithmControl` is called to generate a Config class using the ``Control`` argument. TransformClass : subclass of `MeasurementTransform`, optional Transformation which may be used to post-process the results of measurement. If `None`, the default defined by `BasePlugin` is used. doRegister : `bool`, optional If `True` (the default), register the plugin with ``Base``'s registry, allowing it to be used by measurement tasks. shouldApCorr : `bool`, optional Does this algorithm measure an instFlux that can be aperture corrected? This is shorthand for ``apCorrList=[name]`` and is ignored if ``apCorrList`` is specified. apCorrList : iterable of `str`, optional Field name prefixes for instFlux fields to be aperture corrected. If an algorithm measures a single instFlux that should be aperture corrected, then it is simpler to set ``shouldApCorr=True``. However, if an algorithm produces multiple such fields, then specify ``apCorrList`` instead. For example, ``modelfit_CModel`` produces three such fields: ``apCorrList= ("modelfit_CModel_exp", "modelfit_CModel_exp", "modelfit_CModel_def")`` If ``apCorrList`` is not empty then ``shouldApCorr`` is ignored. If non-empty and ``doRegister`` is `True` then the names are added to the set retrieved by ``getApCorrNameSet``. hasLogName : `bool`, optional `True` if the C++ algorithm supports ``logName`` as a constructor argument. **kwds Additional keyword arguments passed to generateAlgorithmControl, which may include: - ``hasMeasureN``: Whether the plugin supports fitting multiple objects at once ;if so, a config option to enable/disable this will be added (`bool`). - ``executionOrder``: If not `None`, an override for the default execution order for this plugin (the default is ``2.0``, which is usually appropriate for fluxes; `bool`). Returns ------- PluginClass : subclass of ``Base`` The new plugin class.
Definition at line 124 of file wrappers.py.
lsst.meas.base.wrappers.wrapAlgorithmControl | ( | Base, | |
Control, | |||
module = None, | |||
hasMeasureN = False ) |
Wrap a C++ algorithm's control class into a Python config class. Parameters ---------- Base : `SingleFramePluginConfig` or `ForcedPluginConfig` Base class for the returned config. Control : pybind11-wrapped version of a C++ class. Control class to be wrapped. module : module, `str`, `int`, or `None`; optional Either a module object, a string specifying the name of the module, or an integer specifying how far back in the stack to look for the module to use: ``0`` is `lsst.pex.config.wrap`, ``1`` is `lsst.meas.base.wrappers`, ``2`` is the immediate caller, etc. This will be used to set ``__module__`` for the new config class, and the class will also be added to the module. The default is none in which case module will be looked up from Control. hasMeasureN : `bool`, optional Whether the plugin supports fitting multiple objects at once (if so, a config option to enable/disable this will be added). Returns ------- ConfigClass : `lsst.pex.config.Config` A new subclass of lsst.pex.config.Config. Notes ----- This function is generally only called by `wrapAlgorithm`; it is unlikely users will have to call it directly.
Definition at line 73 of file wrappers.py.
lsst.meas.base.wrappers.wrapForcedAlgorithm | ( | AlgClass, | |
executionOrder, | |||
name = None, | |||
needsMetadata = False, | |||
hasMeasureN = False, | |||
needsSchemaOnly = False, | |||
hasLogName = False, | |||
deprecated = None, | |||
** | kwds ) |
Expose a C++ ``ForcedAlgorithm`` class as a measurement plugin. Parameters ---------- AlgClass : API compatible with `ForcedAlgorithm` C++ algorithm class to convert. May either derive directly from `ForcedAlgorithm` or be an unrelated class which has the same ``measure``, ``measureN`` and ``fail`` signatures. executionOrder : `float` The order this plugin should be run, relative to others (see `BasePlugin.getExecutionOrder`). name : `str`, optional Name to use when registering the algorithm. Ignored if ``doRegistry=False``; set to ``generateAlgorithmName(AlgClass)`` if `None`. needsMetadata : `bool`, optional Sets whether the ``AlgClass``'s constructor should be passed a `~lsst.daf.base.PropertySet` metadata argument. hasMeasureN : `bool`, optional Does the algorithm support simultaneous measurement of multiple sources? If `True`, a `bool` ``doMeasureN`` field will be added to the generated config class, and its value will be passed as the last argument when calling the ``AlgClass`` constructor. hasLogName : `bool`, optional `True` if the C++ algorithm supports ``logName`` as a constructor argument. needsSchemaOnly : `bool`, optional Whether the algorithm constructor expects a Schema argument (representing the output `~lsst.afw.table.Schema`) rather than the full `~lsst.afw.table.SchemaMapper` (which provides access to both the reference schema and the output schema). deprecated : `str`, optional If specified, emit as a deprecation warning when the plugin is constructed. **kwds Additional keyword arguments are passed to the lower-level `wrapAlgorithm` and `wrapAlgorithmControl` classes. Returns ------- forcedPlugin : subclass of `ForcedPlugin` The new measurement plugin class. Notes ----- The first two arguments to the C++ constructor are expected to be ``Control const & ctrl, std::string const & name`` If ``needsSchemaOnly`` is `True`, then the third argument will be ``Schema & schema``; otherwise, it will be ``SchemaMapper & schemaMapper``. If ``needsMetadata`` is `True`, we also append ``PropertySet & metadata``. If ``hasMeasureN`` is `True`, we also append ``bool doMeasureN``. If ``hasLogName`` is `True`, we also append ``std::string logName``. If more than one of the above is `True`, the metadata ``PropertySet`` precedes the ``doMeasureN`` ``bool`` and the ``logName`` comes last of the three.
Definition at line 302 of file wrappers.py.
lsst.meas.base.wrappers.wrapSimpleAlgorithm | ( | AlgClass, | |
executionOrder, | |||
name = None, | |||
needsMetadata = False, | |||
hasMeasureN = False, | |||
hasLogName = False, | |||
deprecated = None, | |||
** | kwds ) |
Expose a C++ ``SimpleAlgorithm`` class as a measurement plugin. ``SimpleAlgorithm``\ s are made available as both `SingleFramePlugin`\ s and `ForcedPlugin`\ s. Parameters ---------- AlgClass : Subclass of C++ ``SimpleAlgorithm``, or API compatible Algorithm class to convert. The C++ class should be wrapped with Pybind11, and must provide ``measure()``, ``measureN()`` and ``fail()` signatures equivalent to ``SimpleAlgorithm``. executionOrder : `float` The order this plugin should be run, relative to others (see `~BasePlugin.getExecutionOrder`). name : `str`, optional Name to use when registering the algorithm. Ignored if ``doRegistry=False``; set to ``generateAlgorithmName(AlgClass)`` if `None`. needsMetadata : `bool`, optional Sets whether the ``AlgClass``'s constructor should be passed a `~lsst.daf.base.PropertySet` metadata argument. hasMeasureN : `bool`, optional Does the algorithm support simultaneous measurement of multiple sources? If `True`, a `bool` ``doMeasureN`` field will be added to the generated config class, and its value will be passed as the last argument when calling the ``AlgClass`` constructor. hasLogName : `bool`, optional `True` if the C++ algorithm supports ``logName`` as a constructor argument. deprecated : `str`, optional If specified, emit as a deprecation warning when the plugin is constructed. **kwds Additional keyword arguments are passed to the lower-level `wrapAlgorithm` and `wrapAlgorithmControl` classes. Returns ------- singleFramePlugin : subclass of `SingleFramePlugin` The new single frame measurement plugin class. forcedPlugin : subclass of `ForcedPlugin` The new forced measurement plugin class. Notes ----- The first three arguments to the C++ constructor are expected to be ``Control const & ctrl, std::string const & name, Schema & schema``. If ``needsMetadata`` is `True`, we also append ``PropertySet & metadata``. If ``hasMeasureN`` is `True`, we also append ``bool doMeasureN``. If ``hasLogName`` is `True`, we also append ``std::string logName``. If more than one of the above is `True`, the metadata ``PropertySet`` precedes the ``doMeasureN`` ``bool`` and the ``logName`` comes last of the three.
Definition at line 404 of file wrappers.py.
lsst.meas.base.wrappers.wrapSingleFrameAlgorithm | ( | AlgClass, | |
executionOrder, | |||
name = None, | |||
needsMetadata = False, | |||
hasMeasureN = False, | |||
hasLogName = False, | |||
deprecated = None, | |||
** | kwds ) |
Expose a C++ ``SingleFrameAlgorithm`` class as a measurement plugin. Parameters ---------- AlgClass : API compatible with `SingleFrameAlgorithm` C++ algorithm class to convert. May either derive directly from `SingleFrameAlgorithm` or be an unrelated class which has the same ``measure``, ``measureN`` and ``fail`` signatures. executionOrder : `float` The order this plugin should be run, relative to others (see `BasePlugin.getExecutionOrder`). name : `str`, optional Name to use when registering the algorithm. Ignored if ``doRegistry=False``; set to ``generateAlgorithmName(AlgClass)`` if `None`. needsMetadata : `bool`, optional Sets whether the ``AlgClass``'s constructor should be passed a `~lsst.daf.base.PropertySet` metadata argument. hasMeasureN : `bool`, optional Does the algorithm support simultaneous measurement of multiple sources? If `True`, a `bool` ``doMeasureN`` field will be added to the generated config class, and its value will be passed as the last argument when calling the ``AlgClass`` constructor. hasLogName : `bool`, optional `True` if the C++ algorithm supports ``logName`` as a constructor argument. deprecated : `str`, optional If specified, emit as a deprecation warning when the plugin is constructed. **kwds Additional keyword arguments are passed to the lower-level `wrapAlgorithm` and `wrapAlgorithmControl` classes. Returns ------- singleFramePlugin : subclass of `SingleFramePlugin` The new measurement plugin class. Notes ----- The first three arguments to the C++ constructor are expected to be ``Control const & ctrl, std::string const & name, Schema & schema``. If ``needsMetadata`` is `True`, we also append ``PropertySet & metadata``. If ``hasMeasureN`` is `True`, we also append ``bool doMeasureN``. If ``hasLogName`` is `True`, we also append ``std::string logName``. If more than one of the above is `True`, the metadata ``PropertySet`` precedes the ``doMeasureN`` ``bool`` and the ``logName`` comes last of the three.
Definition at line 220 of file wrappers.py.
lsst.meas.base.wrappers.wrapTransform | ( | transformClass, | |
hasLogName = False ) |
Modify a C++ transform to accept either a ``Config`` or a ``Control``. That is, the configuration may either be provided as a (C++) ``Control`` object or an instance of a Python class derived from `~lsst.meas.base.BasePluginConfig`. Parameters ---------- transformClass : Subclass of C++ ``BaseTransform`` A C++ transform class, wrapped with pybind11. Its constructor must take a ``Control`` object, a ``std::string``, and a `~lsst.afw.table.SchemaMapper`, in that order. hasLogName : `bool`, optional Unused.
Definition at line 473 of file wrappers.py.