diff --git a/docs/observing/add_facility_form_admin.png b/docs/observing/add_facility_form_admin.png new file mode 100644 index 000000000..8208b571a Binary files /dev/null and b/docs/observing/add_facility_form_admin.png differ diff --git a/docs/observing/index.rst b/docs/observing/index.rst index efb84ebee..38544f555 100644 --- a/docs/observing/index.rst +++ b/docs/observing/index.rst @@ -31,3 +31,5 @@ allow your TOM to submit observation requests to observatories. :doc:`Facility Modules <../api/tom_observations/facilities>` - Take a look at the supported facilities. :doc:`Observation Views <../api/tom_observations/views>` - Familiarize yourself with the available Observation Views. + +:doc:`Selecting Targets ` - Display a selection of targets for a specific observing facility. diff --git a/docs/observing/selecting_targets_for_facility.rst b/docs/observing/selecting_targets_for_facility.rst new file mode 100644 index 000000000..251493520 --- /dev/null +++ b/docs/observing/selecting_targets_for_facility.rst @@ -0,0 +1,220 @@ +Selecting Targets for an Observing Facility +=========================================== + +During observing runs, particularly at manually- or remotely-operated telescope +facilities, it can often be very useful to display a selection of targets to be +observed on a particular night. This needs to take into account target visibility from +the telescope site, as well as any prioritization of targets that the team have made. + +TOMs provide support for this through the Target Selection option under the Target menu +in the main navigation bar. + +.. image:: target_selection_menu_option.png + :alt: Menu option for Target Selection view + +Observers can select the telescope facility that they are observing from using the form +provided, indicating the date of the observing run. The selected targets will be draw +from a predefined Target Grouping, which users can chose from the pulldown menu. + +The TOM will evaluate the visibility of the selected sidereal targets for the telescope on the +night in question, and the resulting table will include all objects with a minimum +airmass less than 2.0. + +.. image:: target_selection_table_default.png + :alt: Default table output for target selection + +Customizing the Selected Targets Table +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +By default, this table will include the essential parameters necessary to point a +telescope at the target, but it can be easily extended to add further information. + +The columns of the table can be configured by editing the TOM's ``settings.py`` file. +Additional parameters can be defined for each target by adding dictionary definitions +to the ``EXTRA_FIELDS`` list, as shown in the example below: + +.. code-block:: python + + # settings.py + EXTRA_FIELDS = [ + {'name': 'Mag_now', 'type': 'number'}, + {'name': 'Priority1', 'type': 'number'}, + {'name': 'Priority2', 'type': 'string'} + ] + SELECTION_EXTRA_FIELDS = [ + 'Mag_now', + 'Priority1', + 'Priority2', + ] + +In this example, we have added ``EXTRA_FIELDS`` named ``Mag_now``, ``Priority1`` +and ``Priority2``, which the user can set either by editing each Target's parameters +directly, or programmatically. Having done so, we can add those ``EXTRA_FIELDS`` to +the target selection table by adding the parameter names to the list of ``SELECTION_EXTRA_FIELDS``. +This produces the table displayed below. + +.. image:: target_selection_table_extra_fields.png + :alt: Target Selection table with additional columns added + +.. code:: python + + # casleo.py + + # DEFAULT: + try: + EXAMPLE_MANUAL_SETTINGS = settings.FACILITIES['EXAMPLE_MANUAL'] + except KeyError: + EXAMPLE_MANUAL_SETTINGS = { + } + + EXAMPLE_SITES = { + 'Example Manual Facility': { + 'sitecode': 'Example', + 'latitude': 0.0, + 'longitude': 0.0, + 'elevation': 0.0 + }, + } + EXAMPLE_TERMINAL_OBSERVING_STATES = ['Completed'] + + # UPDATED TO: + try: + CASLEO_SETTINGS = settings.FACILITIES['CASLEO'] + except KeyError: + CASLEO_SETTINGS = { + } + + CASLEO_SITES = { + 'El Leoncito': { + 'sitecode': 'CASLEO', + 'latitude': -31.7986, + 'longitude': -69.2956, + 'elevation': 2483.0 + }, + } + TERMINAL_OBSERVING_STATES = ['Completed'] + +Then we give the facility class a distinctive name: + +.. code:: python + + # casleo.py + + # DEFAULT: + class ExampleManualFacility(BaseManualObservationFacility): + """ + """ + + name = 'Example' + observation_types = [('OBSERVATION', 'Manual Observation')] + + # UPDATED TO: + class CASLEOFacility(BaseManualObservationFacility): + """ + """ + + name = 'El Leoncito' + observation_types = [('OBSERVATION', 'Manual Observation')] + +We also need to update the reference to the list of possible end states of observing requests. +This list can be expanded for telescopes that are programmatically accessible, but it can be left +with the default list for manual facilities. + +.. code:: python + + # casleo.py + + # DEFAULT: + def get_terminal_observing_states(self): + """ + Returns the states for which an observation is not expected + to change. + """ + return EXAMPLE_TERMINAL_OBSERVING_STATES + + + # UPDATED TO: + def get_terminal_observing_states(self): + """ + Returns the states for which an observation is not expected + to change. + """ + return TERMINAL_OBSERVING_STATES + + +Lastly, we need to make sure that the method to fetch the information on observing sites refers to the +list of dictionaries that we specified above. + +.. code:: python + + # casleo.py + + # DEFAULT: + def get_observing_sites(self): + """ + Return a list of dictionaries that contain the information + necessary to be used in the planning (visibility) tool. The + list should contain dictionaries each that contain sitecode, + latitude, longitude and elevation. + """ + return EXAMPLE_SITES + + + # UPDATED TO: + def get_observing_sites(self): + """ + Return a list of dictionaries that contain the information + necessary to be used in the planning (visibility) tool. The + list should contain dictionaries each that contain sitecode, + latitude, longitude and elevation. + """ + return CASLEO_SITES + + +The new facility is now ready. To make sure that the TOM includes it, +we simply need to add it to our TOM's list of facilities in the ``settings.py`` file: + + +.. code-block:: python + + # settings.py + TOM_FACILITY_CLASSES = [ + 'tom_observations.facilities.lco.LCOFacility', + 'tom_observations.facilities.gemini.GEMFacility', + 'tom_observations.facilities.soar.SOARFacility', + 'facilities.casleo.CASLEOFacility', + ] + + +Returning to the target selection form, the new observatory now appears as +an option in the Observatory pulldown menu. + + +.. image:: target_selection_table_new_facility.png + :alt: Target selection table with new telescope facility added + + +Adding Facilities to the Observing Facilities Table +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +If you would like to record a telescope facility for the purposes of observation planning, but don't want to +add code for a new facility module, you can add it to the TOM's table of observing facilities. + +Currently, this can be done by the TOM's administrator, by navigating to the TOM's built-in admin interface. +This page can be reached by adding ``/admin/`` to the end of the TOM's root URL in your browser's navigation bar, e.g.: + +.. code-block:: html +> https://demo.lco.global/admin/ + +Scrolling down the list of database tables, you will find ``Facilitys`` under the tables from the ``tom_observations`` app. +Clicking on this link will take you to a list of telescopes recorded in the TOM's database. Note that this list +is distinct (and does not include) telescopes already known to the TOM through installed facility modules. + +You can record new telescopes to this table using the admin interface's ``Add Facility`` button; this will present you +with the following form: + +.. image:: add_facility_form_admin.png + :alt: Form to add a new telescope facility + +Fill in the form and click ``save``. Now if you return to your TOM's usual interface, and navigate to the ``Target Selection`` +page, the facility you added will appear in the list of facilities for which visibilities can be calculated. \ No newline at end of file diff --git a/docs/observing/target_selection_menu_option.png b/docs/observing/target_selection_menu_option.png new file mode 100644 index 000000000..ac35cd1a2 Binary files /dev/null and b/docs/observing/target_selection_menu_option.png differ diff --git a/docs/observing/target_selection_table_default.png b/docs/observing/target_selection_table_default.png new file mode 100644 index 000000000..3a2016f61 Binary files /dev/null and b/docs/observing/target_selection_table_default.png differ diff --git a/docs/observing/target_selection_table_extra_fields.png b/docs/observing/target_selection_table_extra_fields.png new file mode 100644 index 000000000..f9214f9fb Binary files /dev/null and b/docs/observing/target_selection_table_extra_fields.png differ diff --git a/docs/observing/target_selection_table_new_facility.png b/docs/observing/target_selection_table_new_facility.png new file mode 100644 index 000000000..74f20fd60 Binary files /dev/null and b/docs/observing/target_selection_table_new_facility.png differ diff --git a/tom_common/templates/tom_common/navbar_content.html b/tom_common/templates/tom_common/navbar_content.html index 1b1d7dfbe..c8a7a8e0b 100644 --- a/tom_common/templates/tom_common/navbar_content.html +++ b/tom_common/templates/tom_common/navbar_content.html @@ -12,6 +12,7 @@
Targets Target Grouping + Target Selection
  • diff --git a/tom_observations/templatetags/observation_extras.py b/tom_observations/templatetags/observation_extras.py index f129bdf7e..4179ca041 100644 --- a/tom_observations/templatetags/observation_extras.py +++ b/tom_observations/templatetags/observation_extras.py @@ -108,7 +108,14 @@ def observation_plan(target, facility=None, length=2, interval=60, airmass_limit start_time = datetime.now() end_time = start_time + timedelta(days=length) - visibility_data = get_sidereal_visibility(target, start_time, end_time, interval, airmass_limit, facility) + visibility_data = get_sidereal_visibility( + target, + start_time, + end_time, + interval, + airmass_limit, + facility_name=facility + ) i = 0 plot_data = [] for site, data in visibility_data.items(): diff --git a/tom_observations/utils.py b/tom_observations/utils.py index df3dafc30..bcd2be0d2 100644 --- a/tom_observations/utils.py +++ b/tom_observations/utils.py @@ -6,11 +6,19 @@ import logging from tom_observations import facility +from tom_observations.models import Facility as GeneralFacility logger = logging.getLogger(__name__) -def get_sidereal_visibility(target, start_time, end_time, interval, airmass_limit, observation_facility=None): +def get_sidereal_visibility( + target, + start_time, + end_time, + interval, + airmass_limit, + facility_name=None +): """ Uses astroplan to calculate the airmass for a sidereal target for each given interval between the start and end times. @@ -34,9 +42,10 @@ def get_sidereal_visibility(target, start_time, end_time, interval, airmass_limi :param airmass_limit: maximum acceptable airmass for the resulting calculations :type airmass_limit: int - :param observation_facility: observing facility for which to calculate the airmass. None indicates all available - facilities. - :type observation_facility: BaseObservationFacility + :param facility_name: name string of a declared observing facility class OR general facility, + for which to calculate the airmass. + None indicates all available facilities. + :type facility_name: string :returns: A dictionary containing the airmass data for each site. The dict keys consist of the site name prepended with the observing facility. The values are the airmass data, structured as an array containing two arrays. The @@ -57,35 +66,66 @@ def get_sidereal_visibility(target, start_time, end_time, interval, airmass_limi if airmass_limit is None: airmass_limit = 10 - if observation_facility is None: - facilities = facility.get_service_classes() - else: - facilities = [observation_facility] + # Build list of observers, including all sites for a given facility + observers = {} + + # First check whether a general facility was selected. This allows us to calculate for a single facility + # if that's what the user asked for + observation_facility = None + general_facility = None + if facility_name is not None: + qs = GeneralFacility.objects.filter(full_name=facility_name, location='ground') + + # If the observatory refers to a general facility, build a list of observers from that DB entry. + # The zero-length class_facilities list indicates that these are not required + if qs.count() > 0: + general_facility = qs[0] + observation_facility = None + class_facilities = [] + observers[f'{general_facility.short_name}'] = Observer(longitude=general_facility.longitude * units.deg, + latitude=general_facility.latitude * units.deg, + elevation=general_facility.elevation * units.m) + else: + general_facility = None + observation_facility = facility.get_service_class(facility_name) + + # If the user did not select a general facility, but selected a facility module, + # this function should calculate for that facility alone. + # If the user selected neither a general facility nor a facility module, calculate for the default + # list of facility modules + if observation_facility is None and general_facility is None: + class_facilities = [clazz for name, clazz in facility.get_service_classes().items()] + elif observation_facility and general_facility is None: + class_facilities = [observation_facility] + + # Add observers to the list for the facility modules, including all sites for a given facility + for observing_facility_class in class_facilities: + sites = observing_facility_class().get_observing_sites() + for site, site_details in sites.items(): + observers[f'({observing_facility_class.name}) {site}'] = Observer( + longitude=site_details.get('longitude') * units.deg, + latitude=site_details.get('latitude') * units.deg, + elevation=site_details.get('elevation') * units.m + ) body = FixedTarget(name=target.name, coord=SkyCoord(target.ra, target.dec, unit='deg')) visibility = {} sun, time_range = get_astroplan_sun_and_time(start_time, end_time, interval) - for observing_facility in facilities: - observing_facility_class = facility.get_service_class(observing_facility) - sites = observing_facility_class().get_observing_sites() - for site, site_details in sites.items(): - observer = Observer(longitude=site_details.get('longitude')*units.deg, - latitude=site_details.get('latitude')*units.deg, - elevation=site_details.get('elevation')*units.m) + for observer_name, observer in observers.items(): + sun_alt = observer.altaz(time_range, sun).alt + obj_airmass = observer.altaz(time_range, body).secz - sun_alt = observer.altaz(time_range, sun).alt - obj_airmass = observer.altaz(time_range, body).secz + bad_indices = np.argwhere( + (obj_airmass >= airmass_limit) | + (obj_airmass <= 1) | + (sun_alt > -18*units.deg) # between astronomical twilights, i.e. sun is up + ) - bad_indices = np.argwhere( - (obj_airmass >= airmass_limit) | - (obj_airmass <= 1) | - (sun_alt > -18*units.deg) # between astronomical twilights, i.e. sun is up - ) + obj_airmass = [None if i in bad_indices else float(airmass) for i, airmass in enumerate(obj_airmass)] - obj_airmass = [None if i in bad_indices else float(airmass) for i, airmass in enumerate(obj_airmass)] + visibility[observer_name] = (time_range.datetime, obj_airmass) - visibility[f'({observing_facility}) {site}'] = (time_range.datetime, obj_airmass) return visibility @@ -132,3 +172,15 @@ def get_astroplan_sun_and_time(start_time, end_time, interval): sun = get_sun(time_range) return sun, time_range + + +def get_facilities(): + """ + Function to return a complete list of all available observing facilities, including + both facility classes and general facilities. + """ + + facilities = [(x, x) for x in facility.get_service_classes()] + facilities += [(x.full_name, x.full_name) for x in GeneralFacility.objects.all()] + + return facilities diff --git a/tom_setup/templates/tom_setup/settings.tmpl b/tom_setup/templates/tom_setup/settings.tmpl index c6947cdda..bbeea1004 100644 --- a/tom_setup/templates/tom_setup/settings.tmpl +++ b/tom_setup/templates/tom_setup/settings.tmpl @@ -310,6 +310,7 @@ HARVESTERS = { # {'name': 'discovery_date', 'type': 'datetime'} # ] EXTRA_FIELDS = [] +SELECTION_EXTRA_FIELDS = [] # Authentication strategy can either be LOCKED (required login for all views) # or READ_ONLY (read only access to views) diff --git a/tom_targets/forms.py b/tom_targets/forms.py index 90056308b..5881a9b67 100644 --- a/tom_targets/forms.py +++ b/tom_targets/forms.py @@ -1,13 +1,16 @@ +import datetime + from crispy_forms.layout import Layout, Div from django import forms +from django.conf import settings from astropy.coordinates import Angle from astropy import units as u from crispy_forms.helper import FormHelper from django.forms import ValidationError, inlineformset_factory -from django.conf import settings from django.contrib.auth.models import Group from guardian.shortcuts import assign_perm, get_groups_with_perms, remove_perm +from tom_observations.utils import get_facilities from tom_dataproducts.sharing import get_sharing_destination_options from .models import Target, TargetExtra, TargetName, TargetList, PersistentShare from tom_targets.base_models import (SIDEREAL_FIELDS, NON_SIDEREAL_FIELDS, REQUIRED_SIDEREAL_FIELDS, @@ -282,3 +285,23 @@ def __init__(self, *args, **kwargs): if self.target_id: self.fields['target'].initial = self.target_id self.fields['target'].disabled = True + + +class TargetSelectionForm(forms.Form): + """ + Form for selecting the targets from a pre-existing TargetList + """ + target_list = forms.ModelChoiceField( + TargetList.objects.all(), + required=True) + observatory = forms.ChoiceField(required=True, choices=[]) + date = forms.DateField( + required=True, + initial=datetime.date.today, + widget=forms.TextInput(attrs={'type': 'date'}), + help_text='YYYY-MM-DD' + ) + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.fields['observatory'].choices = get_facilities() diff --git a/tom_targets/templates/tom_targets/target_facility_selection.html b/tom_targets/templates/tom_targets/target_facility_selection.html new file mode 100644 index 000000000..0f5f703ca --- /dev/null +++ b/tom_targets/templates/tom_targets/target_facility_selection.html @@ -0,0 +1,64 @@ +{% extends 'tom_common/base.html' %} +{% load bootstrap4 targets_extras dataproduct_extras static %} +{% block title %}Target Selection{% endblock %} +{% block additional_css %} + +{% endblock %} +{% block content %} +

    Select Targets for an Observing Facility

    +
    +
    + {% csrf_token %} +
    +
    + {% bootstrap_field form.observatory %} +
    +
    + {% bootstrap_field form.date %} +
    +
    + {% bootstrap_field form.target_list %} +
    +
    + +
    +
    +
    +
    +
    + {% if targets_page.has_other_pages %} + {% bootstrap_pagination targets_page %} + {% endif%} + + + {%if use_table %} + + {% for col in table_columns %} + + {% endfor %} + + {% if target_visibilities|length > 0 %} + {% for entry in target_visibilities %} + + + {% for item in entry %} + {% if forloop.counter0 > 1 %} + + {% endif %} + {% endfor %} + + {% endfor %} + {% else %} + + + + {% endif %} + {% endif %} +
    {{col}}
    + {{ entry.1 }} + {{item}}
    No visible targets found
    + {% if targets_page.has_other_pages %} + {% bootstrap_pagination targets_page %} + {% endif%} +
    +{% endblock %} diff --git a/tom_targets/urls.py b/tom_targets/urls.py index d16d3e603..e364a0a30 100644 --- a/tom_targets/urls.py +++ b/tom_targets/urls.py @@ -6,6 +6,7 @@ TargetAddRemoveGroupingView, TargetMergeView, TargetPersistentShareManageFormView, PersistentShareManageFormView, TargetPersistentShareManageTable, PersistentShareManageTable) from .views import TargetGroupingShareView, TargetHermesPreloadView, TargetGroupingHermesPreloadView +from .views import TargetFacilitySelectionView from .views import TargetSeedView from .viewsets import PersistentShareViewSet @@ -53,5 +54,6 @@ PersistentShareViewSet.as_view({'get': 'retrieve', 'delete': 'destroy', 'patch': 'update'}), name='persistent-share-detail'), path('/persistentshare/', PersistentShareViewSet.as_view({'get': 'list'}), - name='target-persistent-share') + name='target-persistent-share'), + path('targetselection/', TargetFacilitySelectionView.as_view(), name='target-selection'), ] diff --git a/tom_targets/views.py b/tom_targets/views.py index 793bd1a36..c6dc374fa 100644 --- a/tom_targets/views.py +++ b/tom_targets/views.py @@ -1,8 +1,11 @@ import logging -from datetime import datetime +from datetime import datetime, timedelta from io import StringIO from urllib.parse import urlencode +import numpy as np +from astropy.coordinates import SkyCoord +from astropy import units as u from django.conf import settings from django.contrib import messages @@ -10,6 +13,7 @@ from django.contrib.auth.models import Group from django.core.exceptions import PermissionDenied from django.core.management import call_command +from django.core.paginator import Paginator from django.db import transaction from django.db.models import Q from django_filters.views import FilterView @@ -23,7 +27,6 @@ from django.utils.safestring import mark_safe from django.views.generic.edit import CreateView, UpdateView, DeleteView, FormView from django.views.generic.detail import DetailView, SingleObjectMixin -from django.views.generic.list import ListView from django.views.generic import RedirectView, TemplateView, View from rest_framework.views import APIView from rest_framework.renderers import TemplateHTMLRenderer @@ -40,7 +43,7 @@ from tom_targets.filters import TargetFilter from tom_targets.forms import SiderealTargetCreateForm, NonSiderealTargetCreateForm, TargetExtraFormset from tom_targets.forms import TargetNamesFormset, TargetShareForm, TargetListShareForm, TargetMergeForm, \ - UnknownTypeTargetCreateForm + UnknownTypeTargetCreateForm, TargetSelectionForm from tom_targets.sharing import share_target_with_tom from tom_targets.merge import target_merge from tom_dataproducts.sharing import (share_data_with_hermes, share_data_with_tom, sharing_feedback_handler, @@ -56,10 +59,10 @@ from tom_targets.permissions import targets_for_user from tom_targets.templatetags.targets_extras import target_merge_fields, persistent_share_table from tom_targets.utils import import_targets, export_targets +from tom_observations.utils import get_sidereal_visibility from tom_targets.seed import seed_messier_targets from tom_dataproducts.alertstreams.hermes import BuildHermesMessage, preload_to_hermes - logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) @@ -750,7 +753,7 @@ def post(self, request, *args, **kwargs): return redirect(reverse('tom_targets:list') + '?' + query_string) -class TargetGroupingView(PermissionListMixin, ListView): +class TargetGroupingView(PermissionListMixin, FormView): """ View that handles the display of ``TargetList`` objects, also known as target groups. Requires authorization. """ @@ -907,6 +910,159 @@ def post(self, request, *args, **kwargs): return HttpResponseBadRequest("Must have hermes section with HERMES_API_KEY set in DATA_SHARING settings") +class TargetFacilitySelectionView(Raise403PermissionRequiredMixin, FormView): + """ + View to select targets suitable to observe from a specific facility/location, taking into account target visibility + from that site, as well as other user-defined constraints. + """ + template_name = 'tom_targets/target_facility_selection.html' + strict = False + model = Target + paginate_by = 5 + permission_required = 'tom_targets.view_target' + form_class = TargetSelectionForm + observable_targets = [] + + def get_context_data(self, *args, **kwargs): + """ + Adds the ``TargetListShareForm`` to the context and prepopulates the hidden fields. + :returns: context object + :rtype: dict + """ + + context = super().get_context_data(*args, **kwargs) + # Surely this needs to verify that the user has permission? + context['form'] = TargetSelectionForm() + + # The displayed table can be extended to include selected extra_fields for each target, + # if configured in the TOM's settings.py. So we set the list of table columns accordingly. + context['table_columns'] = [ + 'Target', 'RA', 'Dec', 'Site', 'Min airmass' + ] + getattr(settings, 'SELECTION_EXTRA_FIELDS', []) + + return context + + def post(self, request, *args, **kwargs): + + # Populate the form with data from the request + form = self.form_class(request.POST) + + if form.is_valid(): + targetlist = form.cleaned_data['target_list'] + date = form.cleaned_data['date'] + observatory = form.cleaned_data['observatory'] + + # Retrieve the full list of targets for this targetlist. + # This is paginated so that the visibility calculations + # are performed on a limited number of targets rather than + # all of them at once, which can be time consuming. + targets = targetlist.targets.all().order_by('name') + paginator = Paginator(targets, self.paginate_by) + targets_page = paginator.get_page(1) + + # This list is stored in the session so that future GETs + # can retrieve different pages. The Target query set and date have to be + # in a format that can serialize to JSON + request.session['targets'] = [t.pk for t in targets] + request.session['date'] = date.strftime('%Y-%m-%d') + request.session['observatory'] = observatory + + # Now calculate the visibilities of the restricted list of objects + target_visibilities = self.get_observable_targets( + targets_page, + date, + observatory + ) + + context = self.get_context_data(*args, **kwargs) + + context['target_visibilities'] = target_visibilities + context['targets_page'] = targets_page + context['use_table'] = True + + return render(request, self.template_name, context) + + def get(self, request, *args, **kwargs): + + context = self.get_context_data(*args, **kwargs) + + page = request.GET.get('page') + + if page and 'targets' in request.session.keys(): + targets = Target.objects.filter(pk__in=request.session['targets']) + date = datetime.strptime(request.session['date'], "%Y-%m-%d") + paginator = Paginator(targets, self.paginate_by) + targets_page = paginator.get_page(page) + target_visibilities = self.get_observable_targets( + targets_page, + date, + request.session['observatory'] + ) + context['target_visibilities'] = target_visibilities + context['targets_page'] = targets_page + context['use_table'] = True + else: + context['target_visibilities'] = None + context['targets_page'] = None + context['use_table'] = False + + return render(request, self.template_name, context) + + def get_observable_targets(self, targets_page, date, observatory): + """ + Handles POST requests to select targets suitable for observation from this facility + + :param targets_page: int Index of the page of targets to compute visbilities for + :param date: datetime object for the day to calculate for + :param observatory: str Full name of the observatory to compute for. This can refer to either + a facility module or general facilty entry + :return: HTTPRequest + """ + + # Configuration: + # Maximum airmass limit to consider a target visible + # Number of intervals with which to calculate visibility throughout a single night + airmass_max = 2.0 + visibiliy_intervals = 10 + + # Calculate the visibility of all selected targets on the date given + # Since some observatories include multiple sites, the visibility_data returned is always + # a dictionary indexed by site code. Our purpose here is to verify whether each target is ever + # visible at lower airmass than the limit from any site - if so the target is considered to be visible + observable_targets = [] + + for target in targets_page: + start_time = datetime.combine(date, datetime.min.time()) + end_time = start_time + timedelta(days=1) + visibility_data = get_sidereal_visibility( + target, start_time, end_time, + visibiliy_intervals, airmass_max, + facility_name=observatory + ) + for site, vis_data in visibility_data.items(): + airmass_data = np.array([x for x in vis_data[1] if x]) + if len(airmass_data) > 0: + s = SkyCoord(target.ra, target.dec, frame='icrs', unit=(u.deg, u.deg)) + target_data = [ + target.id, + target.name, + s.ra.to_string(u.hour), + s.dec.to_string(u.deg, alwayssign=True), + site, + round(airmass_data.min(), 1) + ] + + # Extract any requested extra parameters for this object, if available + for param in getattr(settings, 'SELECTION_EXTRA_FIELDS', []): + if param in target.extra_fields.keys(): + target_data.append(target.extra_fields[param]) + else: + target_data.append(None) + observable_targets.append(target_data) + + return observable_targets + + class PersistentShareManageFormView(APIView): renderer_classes = [TemplateHTMLRenderer] template_name = 'tom_targets/target_manage_persistent_shares.html'