Configuration of the IAG VVT

This is the configuration for the Vacuum Vertical Telescope (VVT) at the Institute for Astrophysics and Geophysics in Göttingen. See here for more details.

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

_static/structure_iagvt.svg

acquisition

Module for performing a fine-acquisition on the sun

 1class: pyobs.modules.pointing.Acquisition
 2
 3# modules
 4telescope: solartelescope
 5camera: suncamera
 6
 7# loging
 8log_file: /pyobs/acquisition.csv
 9
10# camera setting
11exposure_time: 0.02
12
13# tolerances
14max_offset: 7200
15tolerance: 10
16attempts: 10
17
18pipeline:
19  - class: pyobs_iagvt.diskoffset.DiskOffset
20  - class: pyobs_iagvt.sunexptime.SunExpTimeEstimator
21
22apply:
23  class: pyobs_iagvt.applyoffsets.ApplySiderostatOffsets
24
25vfs:
26  class: pyobs.vfs.VirtualFileSystem
27  roots:
28    cache:
29      class: pyobs.vfs.HttpFile
30      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 solartelescope for the telescope and suncamera for the camera (lines 4-5).

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

  • The (initial) exposure time for the camera (line 11).

  • Tolerances for the acquisiton: it succeeds if the telescope is closer than 10” to the position on the sund get larger than 7200”. 10 moves are allowed (lines 14-16).

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

    1. DiskOffset is a custom class that takes the WCS from the suncamera and calculates offsets to go to the requested position.

    2. SunExpTimeEstimator is a custom class that tries to estimate a best exposure time for the next image.

  • The offsets are applied via ApplySiderostatOffsets, a custom class for offsetting the solartelescope (lines 22-23).

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

fibercamera

Module for operating the camera looking at the mirror with the two fiber holes

 1class: pyobs_iagvt.fibercamera.FiberCamera
 2device: The Imaging Source Europe GmbH-DMK ...
 3
 4# hole positions
 5centre: [ 1265.0, 1050.0 ]
 6fiberholes: [[1265.0, 1050.0], [1215.0, 1085.0]]
 7
 8# rotation E of N, and flip
 9rotation: -97.07
10flip: True
11
12# plate scale
13plate_scale: 0.0005746363 # deg/px
14
15# filenames
16filenames: /fibercamera/pyobs-{DAY-OBS|date:}-{FRAMENUM|string:04d}.fits
17video_path: /fibercamera/video.mjpg
18
19# SIP calibration
20calibration_image: ...
21
22# camera settings
23buffers: 5
24settings:
25  Gain: 0
26  BlackLevel: 0
27  FPS: 2
  • FiberCamera is a class derived from pyobs_aravis.araviscamera.AravisCamera with some extensions.

  • Both fiber holes are defines and one is also defined as the center (lines 5-6).

  • The rotation of the camera is given as well as that the image should be flipped (lines 9-10).

  • The plate scale is given (line 13).

  • URLs for FITS files and the video stream are defined (lines 16-17).

  • A SIP calibration is given to be added to the WCS of the FITS file (line 20).

  • Some camera settings are defined (lines 23-27).

filecache

Module used for distributing images among the other modules

1class: pyobs.modules.utils.HttpFileCache
2hostname: iagvtsrv
3port: 37075
  • HttpFileCache provides a HTTP server that can be used for distributing files (line 1).

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

filewatcher

Module for copying new images into the archive

 1class: pyobs_iagvt.filewatcher.FileWatcher
 2
 3# watch settings
 4watchpath: /ftscontrol/Local_Storage/
 5pattern: "*.fits"
 6poll: True
 7poll_interval: 30
 8
 9# copy instructions
10wait_time: 10
11destinations:
12- /archive/{DAY-OBS}/{FNAME}
13
14vfs:
15  class: pyobs.vfs.VirtualFileSystem
16  roots:
17    ftscontrol:
18      class: pyobs.vfs.LocalFile
19      root: /path/to/data/
20    archive:
21      class: pyobs.vfs.LocalFile
22      root: /path/to/archive/
  • FileWatcher is just an extension of pyobs.modules.image.imagewatcher.ImageWatcher, which copies a few extra files (line 1).

  • The path and files to watch are defined as well as that it should be polled every 10 seconds (lines 4-7).

  • A single destination for the files is defined, where they should be copied 10 seconds after first discovery (lines 10-12).

  • A VFS is used both for the watched directory and the destination path.

fts

Module for operating the Fourier Transform Spectrograph (FTS)

1class: pyobs_iagvt.fts.FTS
2...
  • FTS is a class deriving from pyobs.modules.camera.basespectrograph.BaseSpectrograph to implement the functionality of the spectrograph (line 1).

  • The rest of the config is omitted here.

gregorycamera

Module for operating a camera that looks at the gregory hole fiber

 1class: pyobs_iagvt.gregorycamera.GregoryCamera
 2
 3# aravis
 4device: The Imaging Source Europe GmbH-DFK 23GP031-50410119
 5
 6# paths
 7filenames: /gregorycamera/pyobs-{DAY-OBS|date:}-{FRAMENUM|string:04d}.fits
 8video_path: /gregorycamera/video.mjpg
 9http_port: 37078
10
11# camera
12buffers: 5
13settings:
14  Gain: 0
15  BlackLevel: 0
16  FPS: 2
  • GregoryCamera is a class derived from pyobs_aravis.araviscamera.AravisCamera with some extensions (line 1).

  • The Aravis device name is given (line 4).

  • Paths to FITS files and video stream are given as well as the used port (lines 7-9).

  • Some camera settings are defined (lines 12-16).

guiding

Module for guiding on a given position on the sun

 1class: pyobs.modules.pointing.AutoGuiding
 2
 3# modules
 4telescope: solartelescope
 5camera: suncamera
 6
 7# tolerances
 8exposure_time: 0.01
 9min_interval: 5
10
11pipeline:
12  - class: pyobs_iagvt.diskoffset.DiskOffset
13  - class: pyobs_iagvt.sunexptime.SunExpTimeEstimator
14
15apply:
16  class: pyobs_iagvt.applyoffsets.ApplySiderostatOffsets
17  min_offset: 2
18  max_offset: 30
19  log_file: /pyobs/guiding.csv
20
21vfs:
22  class: pyobs.vfs.VirtualFileSystem
23  roots:
24    cache:
25      class: pyobs.vfs.HttpFile
26      download: http://localhost:37075/
27    fibercamera:
28      class: pyobs.vfs.HttpFile
29      download: http://localhost:37077/
  • The class AutoGuiding performs auto-guiding on images of the suncamera (line 1).

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

  • The initial exposure time of images to use for auto-guiding is defined as well as a min interval in seconds between offsets (lines 8-9).

  • The pipeline is defined to calculate offsets, in this case based on (lines 11-13):

    1. DiskOffset is a custom class that takes the WCS from the suncamera and calculates offsets to go to the requested position.

    2. SunExpTimeEstimator is a custom class that tries to estimate a best exposure time for the next image.

  • The offsets are applied via ApplySiderostatOffsets, a custom class for offsetting the solartelescope (lines 15-19).

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

robotic

Module for running full roboric operations

 1class: pyobs_iagvt.solarmastermind.SolarMastermind
 2
 3schedule:
 4  class: pyobs_iagvt.taskschedule.VTTaskSchedule
 5  ...
 6
 7runner:
 8  class: pyobs.robotic.TaskRunner
 9  scripts:
10    EXPOSE:
11      class: pyobs_iagvt.defaultscript.VTDefaultScript
12      telescope: solartelescope
13      fts: fts
14      acquisition: acquisition
15      autoguider: guiding
  • SolarMastermind is a custom class that combined the task runner and the scheduler in one class (line 1).

  • The schedule is calculated using the custom class VTTaskSchedule (line 3-5).

  • A task runner is defined which runs a custom script (lines 7-15).

solartelescope

Module for operating the siderostat

1class: pyobs_iagvt.solartelescope.SolarTelescope
  • SolarTelescope is a custom telescope class, inheriting from pyobs.modules.telescope.basetelescope.BaseTelescope, but it also implements pyobs.interfaces.IPointingHGS.IPointingHGS to be able to move to Heliographic Stonyhurst coordinates.

suncamera

A module for a virtual camera that adds a correct WCS to images from fibercamera

 1class: pyobs_iagvt.suncamera.SunCamera
 2flatfield: /opt/pyobs/storage/flatfield.npy
 3
 4vfs:
 5  class: pyobs.vfs.VirtualFileSystem
 6  roots:
 7    cache:
 8      class: pyobs.vfs.HttpFile
 9      upload: http://localhost:37075/
10    fibercamera:
11      class: pyobs.vfs.HttpFile
12      download: http://localhost:37077/
  • SunCamera is not much more than a proxy, forwarding all calls to fibercamera. But it also uses a disk detection to add a correct WCS to the images (line 1).

  • A flat-field to use for the calibration is given (line 2).

  • A VFS is used to grab images from fibercamera and publish new images with the WCS (lines 4-12).

weather

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).