hipercam¶

hipercam - a reduction package for the high-speed camera HiPERCAM

hipercam is a package for the reduction of data from the 5-band multi-window high-speed CCD camera HiPERCAM. It can access the raw data, display it, slice it into individual files containing the 5 CCDs, etc. It provides a combination of an API to access HiPERCAM data and high-level scripts to enact certain commonly-required operations in reduction. Most users will be most interested in the latter, and if that is the case for you, your first port of entry is probably to look at the ‘scripts’ sub-package, e.g. pydoc hipercam.scripts.

If you are interested in the API, then read on. The code is compartmentalised into several sub-modules and sub-packages, e.g. CCD and MCCD appear in hipercam.ccd, but they are also imported to the top level, so that e.g. pydoc hipercam.CCD and pydoc hipercam.ccd.CCD report back the same thing. This is true for most of the sub-modules, so looking through the top-level docs covers a large part of the API. However, it is rather long and if you want to specialise to a restricted part of the documentation, then a command like ‘pydoc hipercam.ccd’ can prove useful to find a more focussed view of related software. There are some exceptions though where you will need to drill deeper, namely the sub-packages like ‘ucam’ and ‘hcam’, and the plotting modules mpl and pgp.

Perhaps the most important class of all is MCCD which is the first place to go if you have a HiPERCAM ‘.hcm’ file you want to do something with beyond the current routines (although NB ‘.hcm’ files are just FITS files in thin disguise of a changed extension and you may be able to do your own stuff with standard tools for FITS files). Example code:

>> import hipercam as hcam
>> mccd = hcam.MCCD.read('myfile.hcm')
>> print(mccd)
>> print(mccd['1'])
>> print(mccd['1']['E1'])
>> print(mccd['1']['E1'][123,45])
>> mccd['1']['E1'][123,45] = 0
>> mccd.write('mynewfile.hcm')

which reads an hcm file in, then prints it, the CCD it contains labelled ‘1’ (a CCD object), then the window data from this CCD labelled ‘E1’ (a Window object) and finally the pixel value at iy=123, ix=45 (C-like starting from 0). This shows the dictionary-like interface used for MCCD and CCD objects alike (they are both sub-classes of a container class Group). It then sets this pixel to zero and writes out the result to a new file.

Exceptions¶

HipercamError

Class for the hipercam package errors

Classes¶

`HipercamWarning`	Class for hipercam package warnings. Use with warnings.warn
`Group`	A specialized OrderedDict that enforces string keys only and a
`Agroup`	A `Group` which defines arithmetic methods +=, +, etc which must be
`Winhead`	The header parts of a CCD window
`Window`	A CCD window, headers, position and data
`CcdWin`	All the `Winhead` objects of a single CCD.
`MccdWin`	All the `Winhead` objects for multiple CCDs.
`CCD`	Represents a single CCD as a `Group` of `Window`.
`MCCD`	Class representing a multi-CCD as a Group of CCD objects plus a FITS
`Aperture`	Represents an aperture for astronomical photometry
`CcdAper`	Class representing all the :class:Apertures for a single CCD.
`MccdAper`	Class representing all the :class:Apertures for multiple CCDs.
`Target`	Object to represent an astronomical target in terms of its appearance in a
`Field`	Object to represent a star field as a list of :class:`Target`s. This is to
`Header`	Simulates the basic functionality of astropy.io.fits.Header objects while

Functions¶

`version`()	Returns version number of installed HiPERCAM pipeline
`gregorian_to_mjd`(year, month, day)	This returns the Modified Julian Day number corresponding to the
`mjd_to_gregorian`(mjd)	This returns the year, month, and day corresponding to the supplied
`fday_to_hms`(fday)	Returns a tuple of (hours, minutes, seconds) given a fraction of a
`get_ccd_info`(fname)	Routine to return some useful basic information from an MCCD file without
`trim_ultracam`(mccd, ncol, nrow)	Trims columns and rows from an MCCD. The rows and columns are trimmed

Package Contents¶

hipercam.FIELD = '.fld'¶

hipercam.HCAM = '.hcm'¶

hipercam.LIST = '.lis'¶

hipercam.APER = '.ape'¶

hipercam.HRAW = '.fits'¶

hipercam.RED = '.red'¶

hipercam.LOG = '.log'¶

hipercam.DFCT = '.dft'¶

hipercam.SEP = '.sep'¶

hipercam.TBTS = '.tbts'¶

exception hipercam.HipercamError¶

Bases: Exception

Class for the hipercam package errors

class hipercam.HipercamWarning¶

Bases: astropy.utils.exceptions.AstropyUserWarning

Class for hipercam package warnings. Use with warnings.warn

hipercam.DMINS = 1440.0¶

hipercam.CNAMS¶

hipercam.CIS = ((1, 1, 1), (0, 0, 0), (0.898, 0, 0), (0.082, 0.69, 0.102), (0.012, 0.263, 0.875), (1, 0.008,...¶

hipercam.version()¶: Returns version number of installed HiPERCAM pipeline

hipercam.gregorian_to_mjd(year, month, day)¶

This returns the Modified Julian Day number corresponding to the start of the Gregorian date supplied. Algorithm taken from Duffet-Smith. Tested against astropy.time.Time. Designed to be simple and fast.

Parameters:

yearint: Year (valid range: 1582 onwards)
monthint: Month of year, 1 to 12 inclusive.
dayint: day of month (1 to 31; will not check month by month)

Returns:

mjdint: Modified Julian Day number

hipercam.mjd_to_gregorian(mjd)¶

This returns the year, month, and day corresponding to the supplied MJD. From Duffet-Smith. Checked against ‘gregorian_to_mjd’.

Parameters:

mjdint: Modified Julian Day number

Returns:

Returns a tuple of (year,month,day)

hipercam.fday_to_hms(fday)¶

Returns a tuple of (hours, minutes, seconds) given a fraction of a day. The hours and minutes are integers, the seconds are floating point.

fday should lie in the interval [0,1)

hipercam.ALL_OK¶

hipercam.NO_FWHM¶

hipercam.NO_SKY¶

hipercam.SKY_AT_EDGE¶

hipercam.TARGET_AT_EDGE¶

hipercam.TARGET_NONLINEAR¶

hipercam.TARGET_SATURATED¶

hipercam.REDUCE_FILE_VERSION = '20230222'¶

hipercam.NO_EXTRACTION¶

hipercam.NO_DATA¶

hipercam.CLOUDS¶

hipercam.JUNK¶

hipercam.ANY_FLAG¶

hipercam.BAD_FLAT¶

hipercam.BAD_COLUMN¶

hipercam.BAD_TIME¶

hipercam.FLAGS¶

hipercam.OUTLIER¶

hipercam.FLAG_MESSAGES¶

hipercam.FRNG = '.frng'¶

class hipercam.Group(ftype, *args, **kwargs)¶

Bases: collections.OrderedDict

A specialized OrderedDict that enforces string keys only and a single class for the values. The objects stored as values should support a copy method to return a deepcopy for use in the Group copy operation.

Group is designed to amalgamate several of the classes used for objects associated with CCDs such as Window (see CCD), and Aperture (see CcdAper)

ftype¶

__setitem__(key, item)¶: Adds an item item keyed by key checking that its type matches

copy(memo=None)¶: Copy operation. The stored objects must have a copy(self, memo) method.

check()¶

Checks validity of a Group if its objects have a method ‘clash’ defined to check that they are compatible. This should have signature ‘clash(self, other)’, but does not have to be defined for all objects storable in Groups. See Winhead for an example of an object for which this makes sense.

If the Group fails this check, a ValueError is raised.

get_num(num)¶: Returns the num element of the Group (starting from 0)

__copy__()¶: Copy operation for copy.copy

__deepcopy__(memo)¶: Copy operation for copy.deepcopy

__repr__()¶: Return repr(self).

class hipercam.Agroup(ftype, *args, **kwargs)¶

Bases: Group

A Group which defines arithmetic methods +=, +, etc which must be supported by whatever objects the Group contains. This allows the same approach to be taken when operating on CCD and MCCD objects which are based on this class. The objects stored in the Agroup must define a method copy which returns a deep copy; this is required by several operators.

copy(memo=None)¶: Copy operation.

__iadd__(other)¶

Adds other to the Agroup as ‘self += other’. If other is another Agroup with the same object type (ftype) as self, then the operation will be applied to each pair of objects with matching keys. Otherwise other will be regarded as a constant object to add to each object in the Agroup.