How to create a new LSST obs package¶
These instructions describe how to create a package that allows the LSST Science Pipelines to read raw data from a telescope and instrument using the gen3 middleware and ingest it into an LSST repository.
“Ingestion” is the process of reading raw files, interpreting their metadata, and formatting the data in a way the Data Butler
can read.
This guide describes how to create an interface between the Data Butler
and your raw files, so that users do not have to know any details about a particular instrument.
These instructions are necessary, but not sufficient: camera geometry, config overrides for tasks, and defects and other curated calibration are other necessary components not described here.
You will have successfully made an obs package when an ingestion test passes.
This demonstrates that the butler can read data ingested from your instrument.
The instructions here assume that you are writing for the ExampleCam
camera, with the new package called obs_example
.
Here we put the code in a lsst.obs
module hierarchy but this is not required by the Data Butler and you can use any hierarchy that suits your needs.
MetadataTranslator¶
The astro_metadata_translator
package abstracts away reading metadata from raw images of a given telescope+instrument.
For example, the time of the observation, temperature, and filter for a given observation might each be stored in each raw file’s FITS header as "OBSTIME"
, "TEMP_W"
, "FILTOBS"
.
The translator knows how to get all of this relevant metadata out of the raw files, so that they can be loaded into the Data Butler
.
Creating a MetadataTranslator
derived from MetadataTranslator
or FitsTranslator
is the first step in building an obs_package.
Your new metadata translator can live in a separate package as you are developing it, but you should eventually make a pull request to astro_metadata_translator
itself, so that other people can readily use it.
You will call your new translator ExampleTranslator
from here on.
See the metadata translator package for details.
Filters¶
Every instrument has a particular set of photometric filters, each with their own effective wavelength (e.g., 477 microns
), transmission function, internal name (e.g., HSC-G
), and filter band (e.g., g
).
You define these filters using a FilterDefinitionCollection
containing multiple FilterDefinitions
.
Create a file, python/lsst/obs/example/exampleFilters.py
, formatted like the following:
from lsst.obs.base import FilterDefinition, FilterDefinitionCollection
EXAMPLE_FILTER_DEFINITIONS = FilterDefinitionCollection(
FilterDefinition(physical_filter="example g filter",
band="g",
lambdaEff=432),
FilterDefinition(physical_filter="example z filter",
band="z",
lambdaEff=1234),
)
See the FilterDefinition
docs for the various components that go into defining a filter.
Note that the physical_filter
name should match the exact filter name used in that observatory’s metadata.
Formatter¶
A Formatter
defines how the Data Butler reads raw data from the original files and converts it to the LSST conventions.
At present, most astronomical data is distributed as FITS files, so you will very likely be creating a subclass of FitsRawFormatterBase
, but this is not required.
Create a file, python/lsst/obs/example/rawFormatter.py
, containing an ExampleRawFormatter
derived from the FitsRawFormatterBase
base class.
At minimum, you must define a translatorClass
pointing to the ExampleTranslator
you made in MetadataTranslator and a filterDefinitions
pointing to the filter list you created in Filters.
This formatter can also contain specializations for your specific camera, for example to rotate the SkyWcs
for detectors in the camera that have a different orientation.
__all__ = ["ExampleCameraRawFormatter"]
from astro_metadata_translator import ExampleTranslator
from lsst.obs.base import FitsRawFormatterBase
from .exampleFilters import EXAMPLE_FILTER_DEFINITIONS
class ExampleCameraRawFormatter(FitsRawFormatterBase):
translatorClass = ExampleTranslator
filterDefinitions = EXAMPLE_FILTER_DEFINITIONS
def getDetector(self, id):
return ExampleCamera().getCamera()[id]
Instrument¶
An Instrument
defines the instrument-specific logic for the Data Butler.
First create a new file tests/test_instrument.py
with a test case derived from InstrumentTests
and TestCase
, defining self.data
and self.instrument
in setUp
.
The set
of physical_filters
you provide here will be checked to ensure that your FilterDefinitionCollection
is loaded correctly.
"""Tests of the ExampleCam instrument class.
"""
import unittest
import lsst.utils.tests
import lsst.obs.example
from lsst.obs.base.instrument_tests import InstrumentTests, InstrumentTestData
class TestExampleCam(InstrumentTests, lsst.utils.tests.TestCase):
def setUp(self):
physical_filters = {"example g filter",
"example z filter"}
self.data = InstrumentTestData(name="Example",
nDetectors=4,
firstDetectorName="1_1",
physical_filters=physical_filters)
self.instrument = lsst.obs.example.ExampleCam()
if __name__ == '__main__':
lsst.utils.tests.init()
unittest.main()
Run this test via
pytest -sv tests/test_instrument.py
the tests should fail, as there is no Example Instrument
yet.
Next, add a file in python/lsst/obs/example/_instrument.py
containing a subclass of Instrument
, named `ExampleCam
, which at minimum overrides these abstract methods: Instrument.getName
, Instrument.getCamera
, Instrument.register
, Instrument.filterDefinitions
, Instrument.getRawFormatter
and define self.configPaths
in __init__
.
The underscore is used in the name to indicate that the class will be exported by default and referred to as lsst.obs.example.ExampleCam
.
Run your test again: the tests should now pass. If they do not, you can use the test output to determine what parts of the Instrument need to be fixed.
Ingest tests¶
In order to test how your new gen3 obs package works with the Data Butler
, you need to write a test that ingests raw data.
IngestTestBase
provides a base class for those tests, requiring only that you specify the input data that will be tested, and the dataIds to use to check that the data was correctly ingested.
This is how our system tests that your Formatter
works correctly and that the ingest process can extract the required metadata from the files.
"""Unit tests for Gen3 ExampleCam raw data ingest.
"""
import unittest
import os
import lsst.utils.tests
from lsst.obs.base.ingest_tests import IngestTestBase
from lsst.obs.example.hsc import ExampleCam
testDataPackage = "testdata_example"
try:
testDataDirectory = lsst.utils.getPackageDir(testDataPackage)
except lsst.pex.exceptions.NotFoundError:
testDataDirectory = None
@unittest.skipIf(testDataDirectory is None, "testdata_example must be set up")
class ExampleIngestTestCase(IngestTestBase, lsst.utils.tests.TestCase):
def setUp(self):
self.ingestdir = os.path.dirname(__file__)
self.instrument = Examplecam()
self.file = os.path.join(testDataDirectory, "example", "raw", "somefile.fits.gz")
self.dataId = dict(instrument="Example", exposure=12345, detector=123)
super().setUp()
def setup_module(module):
lsst.utils.tests.init()
if __name__ == "__main__":
lsst.utils.tests.init()
unittest.main()
The ingest tests do not check pixel values, so it is acceptable to run the ingest on stripped data files where the pixel values have been set to a single value and the data compressed with fpack
.
This can result in a very small file that can be included directly in your obs package.