Configuration of the IAG 50cm

This is the configuration for the 50cm telescope at the Institute for Astrophysics and Geophysics in Göttingen. See here for more details.

The modules are distributed over two different computers, iag50srv and iag50cam. Autoslew is used as the telescope software and is running on a third computer, together with an ASCOM Alpaca Remote server for remote access.

All the configs are shown here without the comm part and the environment details.

../_images/structure_iag50cm.svg

iag50srv

acquisition

Module for performing a fine-acquisition on target

 1class: pyobs.modules.pointing.Acquisition
 2
 3# modules
 4telescope: telescope
 5camera: sbig6303e
 6filters: sbig6303e
 7
 8# image settings
 9filter_name: Clear
10binning: 2
11exposure_time: 2
12
13# log file
14log_file: /pyobs/acquisition.csv
15
16# tolerances
17max_offset: 7200
18tolerance: 10
19
20pipeline:
21  - class: pyobs.images.processors.detection.SepSourceDetection
22  - class: pyobs.images.processors.astrometry.AstrometryDotNet
23    url: ...
24    radius: 5
25  - class: pyobs.images.processors.offsets.AstrometryOffsets
26
27apply:
28  class: pyobs.utils.offsets.ApplyRaDecOffsets
29  max_offset: 7200
30
31vfs:
32  class: pyobs.vfs.VirtualFileSystem
33  roots:
34    cache:
35      class: pyobs.vfs.HttpFile
36      download: http://localhost:37075/

  • The Acquisition class is used for the acquisition module (line 1).

  • It requires the name of the other modules to use, which are telescope for the telescope, sbig6303e for the camera and the same for module for the filter wheel, since it is integrated into the camera (lines 4-6).

  • The camera settings for the acquisition images (lines 9-11).

  • A log file where all the offsets from the acquisitions are stored, can be useful for checking the pointing model (line 14).

  • Tolerances for the acquisiton: it succeeds if the telescope is closer than 10” to the target and fails if the offsets get larger than 7200”.

  • The pipeline defines steps performed on the images in order to get the offsets for the next step (lines 20-25):

    1. SepSourceDetection detects sources in the image.

    2. AstrometryDotNet performs the astrometric calibration using a local astrometry.net server.

    3. AstrometryOffsets uses the astronomy to calculate offsets for the next telescope move.

  • The offsets are applied via ApplyRaDecOffsets. It fails if the total offset gets larger than 7200” (lines 27-29).

  • Finally, a VFS is defined with a root cache that points to the filecache HTTP cache server (lines 31-36) and is used for downloading the images from the camera.

autofocus

Module for performing an auto-focus series to determine the best focus

 1class: pyobs.modules.focus.AutoFocusSeries
 2
 3# modules
 4camera: sbig6303e
 5focuser: focuser
 6filters: sbig6303e
 7
 8# use absolute focus values instead of offsets
 9offset: False
10
11# camera settings
12filter_name: Clear
13binning: 2
14
15# use projected stars
16series:
17  class: pyobs.utils.focusseries.ProjectionFocusSeries
18
19vfs:
20  class: pyobs.vfs.VirtualFileSystem
21  roots:
22    cache:
23      class: pyobs.vfs.HttpFile
24      download: http://localhost:37075/

  • The AutoFocusSeries class is used for the auto focus module (line 1).

  • It requires the name of the other modules to use, which are focuser for the focus unit, sbig6303e for the camera and the same for module for the filter wheel, since it is integrated into the camera (lines 4-6).

  • The offset parameter defines, whether absolute focus values are used or offsets from a fixed value (line 9).

  • Image settings (lines 12-13).

  • The actual focus series is done using the helper class ProjectionFocusSeries (lines 16-17).

  • Finally, a VFS is defined with a root cache that points to the filecache HTTP cache server (lines 31-36) and is used for downloading the images from the camera.

dome

Module operating the dome

 1class: pyobs_alpaca.AlpacaDome
 2
 3# Alpaca server
 4server: xxx.xxx.xxx.xxx
 5port: 11111
 6
 7# ASCOM device definition
 8device_type: dome
 9device: 0
10
11# Follow telescope on sky
12follow: telescope
13
14# Do not open on bad weather
15weather: weather

  • The AlpacaDome class is used for the dome module (line 1).

  • IP and port for the connection are set (lines 4-5).

  • The ASCOM device type and number are given (lines 8-9).

  • AlpacaDome inherits from FollowMixin, so it can automatically follow other devices, in this case the telescope.

filecache

Module used for distributing images among the other modules

1class: pyobs.modules.utils.HttpFileCache
2
3port: 37075
4max_file_size: 200

  • HttpFileCache provides a HTTP server that can be used for distributing files (line 1).

  • It needs a port to run on (line 3).

  • The maximum file size is set to 200MB (line 4).

flatfield

Modules used for automatic flat-fielding

 1class: pyobs.modules.flatfield.FlatField
 2
 3# modules
 4telescope: telescope
 5camera: sbig6303e
 6filters: sbig6303e
 7
 8# log file
 9log_file: /pyobs/flatfield.csv
10
11# definition of the flat fielder
12flat_fielder:
13  class: pyobs.utils.skyflats.FlatFielder
14  pointing:
15    class: pyobs.utils.skyflats.pointing.SkyFlatsStaticPointing
16  combine_binnings: False
17  functions:
18    1x1:
19      Clear: exp(-1.22421*(h+4.06676))
20      Red: exp(-1.13196*(h+2.88736))
21      Green: exp(-1.07774*(h+2.58413))
22      Blue: exp(-1.02646*(h+2.60224))
23    2x2:
24      Clear: exp(-0.99118*(h+4.66784))
25      Red: exp(-1.44869*(h+3.63067))
26      Green: exp(-1.23137*(h+3.37692))
27      Blue: exp(-1.13074*(h+3.47531))
28
29vfs:
30  class: pyobs.vfs.VirtualFileSystem
31  roots:
32    cache:
33      class: pyobs.vfs.HttpFile
34      download: http://localhost:37075/
35      upload: http://localhost:37075/
36    pyobs:
37      class: pyobs.vfs.LocalFile
38      root: /opt/pyobs/storage

  • The FlatField class is used for the flat-field module (line 1).

  • It requires the name of the other modules to use, which are telescope for the telescope, sbig6303e for the camera and the same for module for the filter wheel, since it is integrated into the camera (lines 4-6).

  • A log file is created containing the exposure times, which can help refine the functions for the exposure times (line 9).

  • The flat-fielding itself is done using the FlatFielder class (lines 12-13).

  • The pointing keyword defines where to point in the sky, for which SkyFlatsStaticPointing is used (lines 14-15).

  • The combine_binning flag is set to False, so that the functions (see below) need to include binnings (line 16).

  • The functions for calculating the exposure time as a function of h (solar elevation in degrees) are defined, depending on the given filter and binning (lines 17-27).

  • Finally, a VFS is defined with a root cache that points to the filecache HTTP cache server (lines 31-36).

focuser

Module operating the focus unit to focus the telescope

1class: pyobs_alpaca.AlpacaFocuser
2
3# Alpaca server
4server: xxx.xxx.xxx.xxx
5port: 11111
6
7# ASCOM device definition
8device_type: focuser
9device: 0

  • The AlpacaFocuser class is used for the focuser module (line 1).

  • IP and port for the connection are set (lines 4-5).

  • The ASCOM device type and number are given (lines 8-9).

imagewatcher

Module for copying new images into the archive

 1class: pyobs.modules.image.ImageWatcher
 2
 3# path to watch
 4watchpath: /temp/
 5
 6# paths to copy to
 7destinations:
 8  - /archive/{FNAME}
 9
10vfs:
11  class: pyobs.vfs.VirtualFileSystem
12  roots:
13    temp:
14      class: pyobs.vfs.LocalFile
15      root: /path/to/new/data
16    archive:
17      class: pyobs.vfs.ArchiveFile
18      url: ...
19      token: ...

  • The ImageWatcher class is used for uploading images to the archive (line 1).

  • The module actively watches a path in the VFS, in which ImageWriter writes new images` (line 4).

  • Destination paths in the VFS are provided. Files are only deleted from the watchpath, if they have successfully been copied to all destinations (lines 7-8).

  • The VFS defines the paths for the watchpath and all destinations (lines 10-19).

imagewriter

Module that watches for NewImageEvent and writes images to disk

 1class: pyobs.modules.image.ImageWriter
 2sources: [sbig6303e]
 3
 4vfs:
 5  class: pyobs.vfs.VirtualFileSystem
 6  roots:
 7    archive:
 8      class: pyobs.vfs.LocalFile
 9      root: /path/to/new/data
10    cache:
11      class: pyobs.vfs.HttpFile
12      download: http://localhost:37075/

  • The ImageWriter class is used for writing images to disk (line 1).

  • Only images from the given sources are handled (line 2).

  • The VFS defines a path for /cache/, which are the images coming from the camera, and /archive/, to which it stores the images.

pointing

Module that takes images on various position on the sky for creating a pointing model

 1class: pyobs_iag50.Pointing
 2
 3# module to use
 4acquisition: acquisition
 5
 6# log file
 7log_file: /pyobs/pointing.poi
 8
 9# grid config
10alt_range: [20., 85.]
11az_range: [5., 355.]
12dec_range: [-85., 85.]
13
14vfs:
15  class: pyobs.vfs.VirtualFileSystem
16  roots:
17    pyobs:
18      class: pyobs.vfs.LocalFile
19      root: /opt/pyobs/storage

  • The custom class pyobs_iag50.Pointing (inherits from PointingSeries) is used for the pointing module (line 1).

  • It requires the name of an acquisition module (line 4).

  • A log file is written, which can directly be used by Autoslew to create a new pointing model (line 7).

  • The grid is defined in ranges, default values are used for the number of points to create, see PointingSeries for details (lines 10-12).

  • A VFS is used to store the log file (lines 14-19).

robotic

Module for full robotic mode

 1class: pyobs.modules.robotic.Mastermind
 2
 3schedule:
 4  class: pyobs.robotic.lco.LcoTaskSchedule
 5  url: ...
 6  token: ...
 7  site: ...
 8
 9runner:
10  class: pyobs.robotic.TaskRunner
11  scripts:
12    BIAS:
13      class: pyobs.robotic.lco.scripts.LcoDefaultScript
14      camera: sbig6303e
15    DARK:
16      class: pyobs.robotic.lco.scripts.LcoDefaultScript
17      camera: sbig6303e
18    EXPOSE:
19      class: pyobs.robotic.lco.scripts.LcoDefaultScript
20      telescope: telescope
21      filters: sbig6303e
22      camera: sbig6303e
23      roof: dome
24      acquisition: acquisition
25      autoguider: autoguider
26    REPEAT_EXPOSE:
27      class: pyobs.robotic.lco.scripts.LcoDefaultScript
28      telescope: telescope
29      filters: sbig6303e
30      camera: sbig6303e
31      roof: dome
32      acquisition: acquisition
33      autoguider: autoguider
34    AUTO_FOCUS:
35      class: pyobs.robotic.lco.scripts.LcoAutoFocusScript
36      telescope: telescope
37      filters: sbig6303e
38      camera: sbig6303e
39      roof: dome
40      autofocus: autofocus
41    SCRIPT:
42      class: pyobs.robotic.lco.scripts.LcoScript
43      scripts:
44        skyflats:
45          class: pyobs.robotic.scripts.SkyFlats
46          roof: dome
47          telescope: telescope
48          flatfield: flatfield
49          combine_binnings: False
50          readout:
51            1x1: 19.6918
52            2x2: 8.4241
53            3x3: 5.4810
54          functions:
55            1x1:
56              Clear: exp(-1.22421*(h+4.06676))
57              Red: exp(-1.13196*(h+2.88736))
58              Green: exp(-1.07774*(h+2.58413))
59              Blue: exp(-1.02646*(h+2.60224))
60            2x2:
61              Clear: exp(-0.99118*(h+4.66784))
62              Red: exp(-1.44869*(h+3.63067))
63              Green: exp(-1.23137*(h+3.37692))
64              Blue: exp(-1.13074*(h+3.47531))
65          priorities:
66            class: pyobs.utils.skyflats.priorities.ArchiveSkyflatPriorities
67            archive:
68              class: pyobs.utils.archive.PyobsArchive
69              url: ...
70              token: ...
71            site: ...
72            instrument: kb03
73            filter_names: [ 'Clear', 'Red', 'Green', 'Blue' ]
74            binnings: [ 1, 2 ]

  • The class Mastermind provides the functionality for the full robotic mode (line 1).

  • It requires a schedule to fetch its tasks from. Since we use the LCO observation portal, an object of type LcoTaskSchedule is used for this. The parameters given are for the connection to the portal (lines 3-7).

  • The actual task runner is TaskRunner, which is based on scripts that handle different kinds of request. For every type a class is given to handle it (mostly LcoDefaultScript) together with all the modules that this class needs to do its job (lines 9-74).

scheduler

Module for calculating the schedule

 1class: pyobs.modules.robotic.Scheduler
 2
 3# which twilight to use
 4twilight: nautical
 5
 6# estimated time of scheduler run
 7safety_time: 600
 8
 9tasks:
10  class: pyobs.robotic.lco.LcoTaskArchive
11  url: ...
12  token: ...
13  instrument_type: ...
14
15schedule:
16  class: pyobs.robotic.lco.LcoTaskSchedule
17  url: ...
18  token: ...
19  site: ...
20  enclosure: ...
21  telescope: ...
22  instrument: ...
23  instrument_type: ...

  • The class Scheduler calculates the schedule to be used by the robotic module (line 1).

  • The used definition of twilight is used to determine, in which time frame to actually schedule tasks, can be nautical with sun elevation of -12 degrees or astronomical at -18 degrees (line 4).

  • The safety_time is the estimated maximum number of seconds that the scheduler will run. That means that the scheduler will always only schedule tasks starting at now+safety_time (line 7).

  • A task archive is needed to fetch schedulable tasks from, in this case handled by LcoTaskArchive (lines 9-13).

  • Finally, the scheduler needs to write the calculated schedule somewhere, which in this case is an object of type LcoTaskSchedule (lines 15-23).

sfag

Module that provides the science frame auto-guiding (sfag)

 1class: pyobs.modules.pointing.ScienceFrameAutoGuiding
 2
 3# modules
 4telescope: telescope
 5camera: sbig6303e
 6
 7# config
 8max_exposure_time: 180
 9min_interval: 20
10max_interval: 200
11max_offset: 600
12
13# log file
14log_file: /pyobs/autoguiding.csv
15
16pipeline:
17  - class: pyobs.images.processors.offsets.ProjectedOffsets
18
19apply:
20  class: pyobs.utils.offsets.ApplyRaDecOffsets
21  min_offset: 1
22
23vfs:
24  class: pyobs.vfs.VirtualFileSystem
25  roots:
26    cache:
27      class: pyobs.vfs.HttpFile
28      download: http://localhost:37075/
29    pyobs:
30      class: pyobs.vfs.LocalFile
31      root: /opt/pyobs/storage

  • The class ScienceFrameAutoGuiding performs auto-guiding on images of the science camera (line 1).

  • It requires the names of the telescope (telescope) and the camera (sbig6303e) modules (lines 4-5).

  • The maximum exposure time of images to use for auto-guiding is defined as well as a min/max interval in seconds between offsets and a maximum offset to go (lines 8-11).

  • A log file is written with all auto-guiding offsets (line 14).

  • The pipeline is defined to calculate offsets, in this case based on ProjectedOffsets (lines 16-17).

  • The determined offsets are applied using ApplyRaDecOffsets, with a minimum offset defined (lines 19-21).

  • A VFS is used to catch the images from the camera and for storing the log (lines 23-31).

startup

Module that opens dome and initializes telescope on good weather

1class: pyobs.modules.utils.Trigger
2
3triggers:
4  - event: pyobs.events.GoodWeatherEvent
5    module: dome
6    method: init
7  - event: pyobs.events.RoofOpenedEvent
8    module: telescope
9    method: init

  • The class Trigger provides a simple trigger on events (line 1).

  • Two triggers are defined:

telegram

A module for communicating with pyobs via the Telegram app

1class: pyobs.modules.utils.Telegram
2token: ...
3password: ...

  • The Telegram class is used for the Telegram connection and requires a token and a password (lines 1-3).

telescope

Module operating the telescope

 1class: pyobs_alpaca.AlpacaTelescope
 2
 3# Alpaca server
 4server: xxx.xxx.xxx.xxx
 5port: 11111
 6
 7# ASCOM device definition
 8device_type: telescope
 9device: 0
10
11# other modules
12wait_for_dome: dome
13weather: weather
14
15# additional FITS headers
16fits_headers:
17  'TEL-FOCL': [3369.0, 'Focal length of telescope [mm]']
18  'OBSERVAT': ['Goettingen', 'Location of telescope']
19  'ORIGIN': ['IAG', 'Organization responsible for the data']
20  'TEL-AEFF': [502.0, 'Telescope effective aperture [mm]']
21  'TEL-APER': [514.8, 'Telescope circular aperture [mm]']
22  'TELESCOP': ['IAG50', 'Name of telescope']
23
24# namespace for fits
25fits_namespaces:
26  sbig6303e:
27  asi071mc: ['OBSERVAT', 'ORIGIN', 'SITEID', 'TEL-ALT', 'TEL-AZ', 'TEL-RA', 'TEL-DEC', 'RA', 'DEC', 'ALTOFF',
28             'AZOFF', 'CRVAL1', 'CRVAL2', 'AIRMASS', 'TEL-ZD', 'MOONDIST', 'MOONALT', 'MOONFRAC', 'SUNDIST', 'SUNALT']

  • The AlpacaTelescope class is used for the telescope module (line 1).

  • IP and port for the connection are set (lines 4-5).

  • The ASCOM device type and number are given (lines 8-9).

  • The module waits for the dome module after movements and consults the Weather module about the current weather (lines 12-13).

  • Additional static FITS headers are provided (lines 16-22).

  • FITS namespaces for other modules providing FITS headers are given:

    • The sbig6303e module gets all FITS headers (line 26).

    • The asi071mc module only gets the listed FITS headers (lines 27-28).

weather

Module that provides current weather information

1class: pyobs.modules.weather.Weather
2url: ...

  • In this case, the Weather class is used, which connects to a running instance of pyobs-weather (lines 1-2).

iag50cam

sbig6303e

Module for operating a SBIG6303e camera

 1class: pyobs_sbig.Sbig6303eCamera
 2
 3# temperature setpoint
 4setpoint: -10
 5
 6# file naming
 7filenames: /cache/iag50cm-kb03-{DAY-OBS|date:}-{FRAMENUM|string:04d}-{IMAGETYP|type}00.fits
 8
 9# additional fits headers
10fits_headers:
11  INSTRUME: ['kb03', 'Name of instrument']
12  'DET-PIXL': [0.009, 'Size of detector pixels (square) [mm]']
13  'DET-NAME': ['KAF-6303E', 'Name of detector']
14  'DET-RON': [13.5, 'Detector readout noise [e-]']
15  'DET-SATU': [100000, 'Detector saturation limit [e-]']
16  'DET-DARK': [0.3, 'Detector dark current [e-/s]']
17  'TELID': ['0m5', 'ID for telescope']
18  'SITEID': ['iag50cm', 'ID of site.']
19
20# opto-mechanical centre
21centre: [1536.0, 1024.0]
22
23# rotation (east of north)
24rotation: -1.76
25flip: True
26
27# filter wheel
28filter_wheel: AUTO
29filter_names: [Red, Green, Blue, Clear, Halpha]
30
31vfs:
32  class: pyobs.vfs.VirtualFileSystem
33  roots:
34    cache:
35      class: pyobs.vfs.HttpFile
36      upload: http://iag50srv:37075/

  • The Sbig6303eCamera class is used for connecting to the camera (line 1).

  • The temperature is set to -10 degrees C (line 4).

  • The filenames for the images are create from a template that is filled from the FITS header (line 7).

  • Additional static FITS headers are provided (lines 10-18).

  • The opti-mechanic centre of the camera is provided (line 21).

  • The rotation is given and whether the image must be flipped (lines 24-25).

  • The names of the filters in the filter wheel are defined (lines 28-29).

  • A VFS is used to store the images.

asi071mc

Module for operating a ZWO ASI071MC Pro camera

 1class: pyobs_asi.AsiCoolCamera
 2camera: ZWO ASI071MC Pro
 3
 4# file naming
 5filenames: /cache/iag50cm-sz01-{DAY-OBS|date:}-{FRAMENUM|string:04d}-{IMAGETYP|type}00.fits
 6
 7# additional fits headers
 8fits_headers:
 9  INSTRUME: ['sz01', 'Name of instrument']
10  'DET-PIXL': [0.00478, 'Size of detector pixels (square) [mm]']
11  'DET-NAME': ['SONY IMX071', 'Name of detector']
12  'DET-RON': [2.3, 'Detector readout noise [e-]']
13  'DET-SATU': [46000, 'Detector saturation limit [e-]']
14  'TELID': ['0m1', 'ID for telescope']
15  'SITEID': ['goe', 'ID of site.']
16  'TEL-FOCL': [770.0, 'Focal length of telescope [mm]']
17  'OBSERVAT': ['Goettingen', 'Location of telescope']
18  'ORIGIN': ['IAG', 'Organization responsible for the data']
19  'TEL-AEFF': [110.0, 'Telescope effective aperture [mm]']
20  'TEL-APER': [110.8, 'Telescope circular aperture [mm]']
21  'TELESCOP': ['IAG50GUIDER', 'Name of telescope']
22
23# opto-mechanical centre
24centre: [2472.0, 1642.0]
25
26# rotation (east of north)
27rotation: 3.06
28flip: True
29
30vfs:
31  class: pyobs.vfs.VirtualFileSystem
32  roots:
33    cache:
34      class: pyobs.vfs.HttpFile
35      upload: http://iag50srv:37075/