Giter Club home page Giter Club logo

planobs's Introduction

planobs

Toolset for planning and triggering observations with ZTF. GCN parsing is currently only implemented for IceCube alerts.

It checks if the object is observable with a maximum airmass on a given date, plots the airmass vs. time, computes two optimal (minimal airmass at night) observations of 300s in g- and r and generate the ZTF field plots for all fields having a reference. There is also the option to create a longer (multiday) observation plan.

CI Coverage Status PyPI version DOI

Requirements

ztfquery for checking if fields have a reference.

planobs requires Python 3.10.

Installation

Using Pip: pip install planobs.

Otherwise, you can clone the repository: git clone https://github.com/simeonreusch/planobs, followed by poetry install This also gives you access to the Slackbot.

Note for ARM-based macs: The install of fiona might fail if you do not have gdal installed. In that case, consider using a conda and running conda install -c conda-forge gdal before running poetry install.

General usage

from planobs.plan import PlanObservation

name = "testalert" # Name of the alert object
date = "2020-05-05" #This is optional, defaults to today
ra = 133.7
dec = 13.37

plan = PlanObservation(name=name, date=date, ra=ra, dec=dec)
plan.plot_target() # Plots the observing conditions
plan.request_ztf_fields() # Checks in which ZTF fields this 
# object is observable and generates plots for them.

The observation plot and the ZTF field plots will be located in the current directory/[name]

Note: Checking if fields have references requires ztfquery, which needs IPAC credentials.

Usage for IceCube alerts

from planobs.plan import PlanObservation

name = "IC201007A" # Name of the alert object
date = "2020-10-08" #This is optional, defaults to today

# No RA and Dec values are given, because we set alertsource to icecube, which leads to automatic GCN parsing.

plan = PlanObservation(name=name, date=date, alertsource="icecube")
plan.plot_target() # Plots the observing conditions.
plan.request_ztf_fields() # Checks which ZTF fields cover the target (and have references).
print(plan.recommended_field) # This give you the field with the most overlap.

Triggering ZTF

planobs can be used to schedule ToO observations with ZTF. This is done through API calls to the Kowalski system, managed by the Kowalski Python API penquins.

To use this functionality, you must first configure the connection details. You need both an API token, and to know the address of the Kowalski host address. You can then set these as environment variables:

export KOWALSKI_HOST=something
export KOWALSKI_API_TOKEN=somethingelse

You can then import the Queue class for querying, submitting and deleting ToO triggers:

Querying

from planobs.api import Queue

q = Queue(user="yourname")

existing_too_requests = get_too_queues(names_only=True)
print(existing_too_requests)

Submitting

from planobs.api import Queue, get_too_queues
from planobs.models import TooTarget

trigger_name = "ToO_IC220513A_test"

# Instantiate the API connection
q = Queue(user="yourname")

# Add a trigger to the internal submission queue. Filter ID is 1 for r-, 2 for g- and 3 for i-band. Exposure time is given in seconds.
q.add_trigger_to_queue(
    trigger_name=trigger_name,
    validity_window_start_mjd=59719.309333333334,
    targets=[
        TooTarget(
            field_id=427,
            filter_id=1,
            exposure_time=300,
        )
    ],
)

q.submit_queue()

# Now we verify that our trigger has been successfully submitted
existing_too_requests = get_too_queues(names_only=True)
print(existing_too_requests)
assert trigger_name in existing_too_requests

Deleting

from planobs.api import Queue

q = Queue(user="yourname")

trigger_name = "ToO_IC220513A_test"

res = q.delete_trigger(trigger_name=trigger_name)

Citing the code

If you use this code, please cite it! A DOI is provided by Zenodo, which can reference both the code repository and specific releases:

DOI

Contributors

planobs's People

Contributors

dependabot[bot] avatar github-actions[bot] avatar jannisne avatar jvansanten avatar robertdstein avatar simeonreusch avatar

Watchers

 avatar

planobs's Issues

Move away from poetry?

Is your feature request related to a problem? Please describe.
I'm always frustrated when I'm trying to use planobs as a dependency, because the poetry dependency requirements are very strict. It makes it hard to ensure compatibility with other projects.

In general, the poetry model is great for a final-level analysis code which should be exactly reproducible, but bad for generic utility packages which are imported by a lot of other packages. It seems like planobs is in the second category, with three downstream packages so far.

Describe the solution you'd like
I would think the package could be more widely/easily used if either the poetry requirements were substantially loosened, or the entire dependency system was moved to setuptools with minimal constraints on e.g python version <3.12, or pandas ==1.4.x

Describe alternatives you've considered
This might be out of scope, because the package does it's core function fine as is. So things could be left as they are.

Too short observation window raises uncaught exception

Describe the bug
If the airmass requirement is fulfilled, but the resulting observation time is too short for the required observation length and separation between bands, an error occurs.

To Reproduce
Run

from planobs.plan import PlanObservation
PlanObservation(name="IC231211A", alertsource="icecube")

and see traceback:

File ~/Software/planobs/planobs/plan.py:322, in PlanObservation.__init__(self, name, ra, dec, arrivaltime, date, max_airmass, observationlength, bands, multiday, alertsource, obswindow, site, switch_filters, verbose, **kwargs)
    317     self.g_band_recommended_time_start = utils.round_time(
    318         g_band_obsblock[0]
    319     )
    320     self.g_band_recommended_time_end = utils.round_time(g_band_obsblock[-1])
    321     self.r_band_recommended_time_start = utils.round_time(
--> 322         r_band_obsblock[0]
    323     )
    324     self.r_band_recommended_time_end = utils.round_time(r_band_obsblock[-1])
    326 else:

IndexError: list index out of range

Expected behavior
planobs checks for this case and saves something like not observable due to short observation window.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.