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

robotic

scheduler

sfag

startup

telegram

telescope

weather

iag50cam

sbig6303e