lsst.obs.decam._instrument.DarkEnergyCamera Class Reference

Inheritance diagram for lsst.obs.decam._instrument.DarkEnergyCamera:

Public Member Functions
def	__init__ (self, **kwargs)
def	getName (cls)
def	getCamera (self)
def	register (self, registry, update=False)
def	getRawFormatter (self, dataId)
TranslatorFactory	makeDataIdTranslatorFactory (self)

Public Attributes
	configPaths

Static Public Attributes
	filterDefinitions = DECAM_FILTER_DEFINITIONS
string	policyName = "decam"
string	obsDataPackage = "obs_decam_data"

Detailed Description

Definition at line 39 of file _instrument.py.

Constructor & Destructor Documentation

__init__()

def lsst.obs.decam._instrument.DarkEnergyCamera.__init__	(		self,
		**	kwargs
	)

Definition at line 44 of file _instrument.py.

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        packageDir = getPackageDir("obs_decam")
        self.configPaths = [os.path.join(packageDir, "config")]
 

Member Function Documentation

getCamera()

def lsst.obs.decam._instrument.DarkEnergyCamera.getCamera

(

self

)

Definition at line 53 of file _instrument.py.

    def getCamera(self):
        path = os.path.join(getPackageDir("obs_decam"), self.policyName, "camGeom")
        return self._getCameraFromPath(path)
 

getName()

def lsst.obs.decam._instrument.DarkEnergyCamera.getName

(

cls

)

Definition at line 50 of file _instrument.py.

    def getName(cls):
        return "DECam"
 

getRawFormatter()

def lsst.obs.decam._instrument.DarkEnergyCamera.getRawFormatter	(		self,
			dataId
	)

Definition at line 108 of file _instrument.py.

    def getRawFormatter(self, dataId):
        # local import to prevent circular dependency
        from .rawFormatter import DarkEnergyCameraRawFormatter
        return DarkEnergyCameraRawFormatter
 

makeDataIdTranslatorFactory()

TranslatorFactory lsst.obs.decam._instrument.DarkEnergyCamera.makeDataIdTranslatorFactory

(

self

)

Definition at line 113 of file _instrument.py.

    def makeDataIdTranslatorFactory(self) -> TranslatorFactory:
        # Docstring inherited from lsst.obs.base.Instrument.
        factory = TranslatorFactory()
        factory.addGenericInstrumentRules(self.getName(), calibFilterType="band",
                                          detectorKey="ccdnum")
        # DECam calibRegistry entries are bands or aliases, but we need
        # physical_filter in the gen3 registry.
        factory.addRule(_DecamBandToPhysicalFilterKeyHandler(self.filterDefinitions),
                        instrument=self.getName(),
                        gen2keys=("filter",),
                        consume=("filter",),
                        datasetTypeName="cpFlat")
        return factory
 
 

register()

def lsst.obs.decam._instrument.DarkEnergyCamera.register	(		self,
			registry,
			update = False
	)

Definition at line 70 of file _instrument.py.

    def register(self, registry, update=False):
        camera = self.getCamera()
        # Combined with detector_max=100 (below), obsMax=2**25 causes the
        # number of bits in packed IDs to match the Gen2 ones.
        obsMax = 2**25
        with registry.transaction():
            # Note that detector_max here is really only used for packing
            # detector and visit/exposure IDs together into a single integer,
            # so it's rounded up to the nearest power of ten to make that
            # encoding decodable by humans (and consistent with its previous
            # Gen2 definition).  There are other checks (database constraints)
            # that ensure any ingested raws have "real" detector values, and
            # those are based on the detector records added in the loop below.
            registry.syncDimensionData(
                "instrument",
                {
                    "name": self.getName(), "detector_max": 100, "visit_max": obsMax, "exposure_max": obsMax,
                    "class_name": get_full_type_name(self),
                },
                update=update
            )
 
            for detector in camera:
                registry.syncDimensionData(
                    "detector",
                    {
                        "instrument": self.getName(),
                        "id": detector.getId(),
                        "full_name": detector.getName(),
                        "name_in_raft": detector.getName()[1:],
                        "raft": detector.getName()[0],
                        "purpose": str(detector.getType()).split(".")[-1],
                    },
                    update=update
                )
 
            self._registerFilters(registry, update=update)
 

Member Data Documentation

configPaths

lsst.obs.decam._instrument.DarkEnergyCamera.configPaths

Definition at line 47 of file _instrument.py.

filterDefinitions

lsst.obs.decam._instrument.DarkEnergyCamera.filterDefinitions = DECAM_FILTER_DEFINITIONS

static

Definition at line 40 of file _instrument.py.

obsDataPackage

string lsst.obs.decam._instrument.DarkEnergyCamera.obsDataPackage = "obs_decam_data"

static

Definition at line 42 of file _instrument.py.

policyName

string lsst.obs.decam._instrument.DarkEnergyCamera.policyName = "decam"

static

Definition at line 41 of file _instrument.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/obs_decam/22.0.1-16-g9282f48+790f5f2caa/python/lsst/obs/decam/_instrument.py