1151 lines
51 KiB
Python
1151 lines
51 KiB
Python
from django.shortcuts import render
|
|
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseForbidden
|
|
from django.db.models import DecimalField, Value
|
|
from django.db.models import F
|
|
from django.db.models import Q
|
|
from django.utils.encoding import smart_str
|
|
from django.urls import reverse
|
|
from django.urls import resolve
|
|
from django.contrib.auth.models import Group
|
|
from django.shortcuts import get_object_or_404
|
|
|
|
from heasarc.models import HeasarcXrayMaster
|
|
from heasarc.models import HeasarcXMMSSC
|
|
from heasarc.models import HeasarcBase
|
|
from heasarc.models import HeasarcSwiftBAT105m
|
|
from heasarc.models import HeasarcIntegral9
|
|
from heasarc.models import HeasarcIntRefCat
|
|
from heasarc.models import HeasarcRASS2RXS
|
|
from heasarc.models import HeasarcMAXIGSCHGL
|
|
from heasarc.models import HeasarcXTEASSCAT
|
|
from heasarc.models import Heasarc4XMMDR9
|
|
from heasarc.models import HeasarcXMMSL2
|
|
from heasarc.models import Heasarc3MAXI
|
|
|
|
from srgcat.models import ArtCat, ArtSource
|
|
from srglib.utils import srg_auth, srg_group_auth, srg_group_auth_stats, status_code
|
|
from srgcat.models import SkyMaps, SrgDataDump, SkyMapSource, SelectAllskyMissed
|
|
from srgcat.models import Selection, UserSessionParameters
|
|
from srgcat.models import TrackStats
|
|
|
|
from monthplan.models import Survey
|
|
from monthplan.models import SurveyHealpixPlate, NSIDE_PLATES, ORDER, MAPS_DIR, Survey, SurveyPath
|
|
|
|
from astropy import units as u
|
|
from astropy.coordinates import SkyCoord
|
|
from astropy.coordinates import ICRS, Galactic, FK5
|
|
from astropy_healpix import HEALPix
|
|
|
|
from .utils import make_source_name
|
|
from .forms import SourceNameForm, LookupTargetForm, SkyMapForm
|
|
from .forms import SelectionForm, UserSessionParametersForm
|
|
|
|
import csv
|
|
from math import isfinite
|
|
|
|
# Create your views here.
|
|
|
|
def HttpResponseCSV(srcs, dump=None, key='', subclass=None):
|
|
response = HttpResponse(content_type='text/csv')
|
|
response['Content-Disposition'] = 'attachment; filename='+"{}_{}.csv".format(key,dump)
|
|
writer = csv.writer(response, csv.excel)
|
|
#response.write(u'\ufeff'.encode('utf8'))
|
|
|
|
response.write(u'# '.encode('utf8'))
|
|
""" CNTS,CNTS_ERR,CNTS_BG,EXPTIME,FLUX,FLUX_ERR,SIG,NFALSE """
|
|
writer.writerow([
|
|
smart_str(u"NAME"),
|
|
smart_str(u"FIELD"),
|
|
smart_str(u"RA"),
|
|
smart_str(u"Dec"),
|
|
smart_str(u"CNTS"),
|
|
smart_str(u"CNTS_ERR"),
|
|
smart_str(u"CNTS_BG"),
|
|
smart_str(u"EXPTIME"),
|
|
smart_str(u"FLUX"),
|
|
smart_str(u"FLUX_ERR"),
|
|
smart_str(u"SIG"),
|
|
smart_str(u"Simbad(offset, type, redshift, name, ra, dec)"),
|
|
smart_str(u"4XMM(offset, name, ra, dec, ep_5_flux)"),
|
|
smart_str(subclass.__name__) if subclass else None,
|
|
])
|
|
|
|
for src in srcs:
|
|
if(subclass):
|
|
subcatalog = src.heasarc.instance_of(subclass).first()
|
|
|
|
crd = SkyCoord(src.ra, src.dec, frame="fk5", unit="deg")
|
|
|
|
xmm = src.heasarc.instance_of(Heasarc4XMMDR9)
|
|
xmm_name=[]
|
|
xmm_separation=[]
|
|
xmm_ra=[]
|
|
xmm_dec=[]
|
|
xmm_ep_5_flux=[]
|
|
xmm_ep_5_flux_err=[]
|
|
|
|
for xmmsrc in xmm:
|
|
xmm_name.append(xmmsrc.name)
|
|
xmm_ra.append(xmmsrc.ra)
|
|
xmm_dec.append(xmmsrc.dec)
|
|
xmm_ep_5_flux.append(xmmsrc.EP_5_FLUX)
|
|
xmm_ep_5_flux_err.append(xmmsrc.EP_5_FLUX_ERR)
|
|
xmm_separation.append(crd.separation(SkyCoord(xmmsrc.ra, xmmsrc.dec, frame="fk5", unit="deg")).arcsecond)
|
|
|
|
xmm_szip = sorted(zip(xmm_separation, xmm_name, xmm_ra, xmm_dec, xmm_ep_5_flux, xmm_ep_5_flux_err))
|
|
|
|
simbad = src.simbad.all()
|
|
simbad_name=[]
|
|
simbad_type=[]
|
|
simbad_redshift=[]
|
|
simbad_separation=[]
|
|
simbad_ra=[]
|
|
simbad_dec=[]
|
|
for simsrc in simbad:
|
|
simbad_ra.append(simsrc.ra)
|
|
simbad_dec.append(simsrc.dec)
|
|
simbad_name.append(simsrc.main_id)
|
|
simbad_type.append(simsrc.obj_class)
|
|
if isfinite(simsrc.z):
|
|
simbad_redshift.append(simsrc.z)
|
|
else:
|
|
simbad_redshift.append(0.0)
|
|
simbad_separation.append(crd.separation(SkyCoord(simsrc.ra, simsrc.dec, frame="fk5", unit="deg")).arcsecond)
|
|
simbad_szip = sorted(zip(simbad_separation, simbad_type, simbad_redshift, simbad_name, simbad_ra, simbad_dec))
|
|
|
|
writer.writerow([
|
|
smart_str(src.name_orig),
|
|
smart_str(src.skymap),
|
|
smart_str(src.ra),
|
|
smart_str(src.dec),
|
|
smart_str(src.cnts),
|
|
smart_str(src.cnts_err),
|
|
smart_str(src.cnts_bg),
|
|
smart_str(src.exptime),
|
|
smart_str(src.flux),
|
|
smart_str(src.flux_err),
|
|
smart_str(src.sig),
|
|
smart_str([simbad_name for simbad_name in simbad_szip]),
|
|
smart_str([xmm_name for xmm_name in xmm_szip]),
|
|
smart_str(subcatalog.name) if subclass else None,
|
|
])
|
|
return response
|
|
|
|
def get_skymap_sources(dump, owner):
|
|
try:
|
|
session = UserSessionParameters.objects.get(owner=owner)
|
|
if not session.sign_threshold is None:
|
|
skymap_sources = dump.skymapsource_set.all().filter(sig__gt=session.sign_threshold).order_by('ra')
|
|
else:
|
|
skymap_sources = dump.skymapsource_set.all().order_by('ra')
|
|
except UserSessionParameters.DoesNotExist:
|
|
skymap_sources = dump.skymapsource_set.all().order_by('ra')
|
|
pass
|
|
|
|
return skymap_sources
|
|
|
|
def show_stats(request):
|
|
status=srg_auth(request.user)
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
groups=Group.objects.all()
|
|
data = TrackStats.objects.all().order_by('-created')[:100]
|
|
return render(request,'srgcat/stats.html', {'data': data,'groups':groups,})
|
|
|
|
def show_stats_by_group(request, group_id):
|
|
status=srg_auth(request.user)
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
group = Group.objects.get(pk=group_id)
|
|
except:
|
|
return HttpResponse("This group was not found")
|
|
groups=Group.objects.all()
|
|
data = TrackStats.objects.all().filter(group=group).order_by('-created')
|
|
return render(request,'srgcat/stats.html', {'data': data,'groups':groups,})
|
|
|
|
def show_aladin_healpix(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#dump = SrgDataDump.objects.latest('date')
|
|
|
|
skymap_sources = get_skymap_sources(dump, request.user)
|
|
ntotal=skymap_sources.count()
|
|
#skymap_sources = SkyMapSource.objects.all().order_by('created')
|
|
try:
|
|
survey = Survey.objects.get(Q(start__lt=dump.date) & Q(stop__gt=dump.date))
|
|
surveypaths = survey.surveypath_set.all()
|
|
except:
|
|
survey=None
|
|
surveypaths=None
|
|
pass
|
|
return render(request,'srgcat/healpix.html', {'artcats': artcats,
|
|
'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,
|
|
'srcs':skymap_sources,
|
|
'dump':dump,
|
|
'survey':survey,
|
|
'surveypaths':surveypaths,})
|
|
|
|
def index(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
print("srgcat index")
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#dump = SrgDataDump.objects.latest('date')
|
|
|
|
skymap_sources = get_skymap_sources(dump, request.user)
|
|
ntotal=skymap_sources.count()
|
|
#skymap_sources = SkyMapSource.objects.all().order_by('created')
|
|
try:
|
|
survey = Survey.objects.get(Q(start__lt=dump.date) & Q(stop__gt=dump.date))
|
|
surveypaths = survey.surveypath_set.all()
|
|
except:
|
|
survey=None
|
|
surveypaths=None
|
|
pass
|
|
print("srgcat index render")
|
|
return render(request,'srgcat/index.html', {'artcats': artcats,
|
|
'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,
|
|
'srcs':skymap_sources,
|
|
'dump':dump,
|
|
'survey':survey,
|
|
'surveypaths':surveypaths,})
|
|
def show_erosita_matched_catalogs(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
|
|
return render(request,'srgcat/erosita_matched_catalogs.html', {'artcats': artcats,'selections':selections,})
|
|
|
|
def show_erosita_matched_catalog(request, catalog_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
try:
|
|
catalog=ArtCat.objects.get(pk=catalog_id)
|
|
except:
|
|
return HttpResponse("This catalog was not found")
|
|
artcats = ArtCat.objects.all()
|
|
skymap_sources=catalog.skymapsource_set.all().order_by("-ra")
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
|
|
return render(request,'srgcat/erosita_matched_catalogs.html', {'artcats': artcats,
|
|
'catalog':catalog,
|
|
'selections':selections,
|
|
'skymap_sources':skymap_sources,})
|
|
def show_erosita_matched(request, catalog_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
try:
|
|
catalog=ArtCat.objects.get(pk=catalog_id)
|
|
except:
|
|
return HttpResponse("This catalog was not found")
|
|
artcats = ArtCat.objects.all()
|
|
skymap_sources=catalog.skymapsource_set.filter(erositamatch__isnull=False).order_by("-ra")
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
|
|
return render(request,'srgcat/erosita_matched_catalogs.html', {'artcats': artcats,
|
|
'catalog':catalog,
|
|
'selections':selections,
|
|
'skymap_sources':skymap_sources,})
|
|
def show_erosita_nomatch(request, catalog_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
try:
|
|
catalog=ArtCat.objects.get(pk=catalog_id)
|
|
except:
|
|
return HttpResponse("This catalog was not found")
|
|
artcats = ArtCat.objects.all()
|
|
skymap_sources=catalog.skymapsource_set.filter(erositamatch__isnull=True).order_by("-ra")
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
artcats = ArtCat.objects.all()
|
|
|
|
return render(request,'srgcat/erosita_matched_catalogs.html', {'artcats': artcats,
|
|
'catalog':catalog,
|
|
'selections':selections,
|
|
'skymap_sources':skymap_sources,})
|
|
|
|
def show_selection(request, selection_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
try:
|
|
selection = Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This Selection was not found")
|
|
skymap_sources = selection.skymap_sources.all()
|
|
ntotal=skymap_sources.count()
|
|
|
|
return render(request,'srgcat/index.html', {'selection':selection,
|
|
'ntotal':ntotal,
|
|
'skymap_sources':skymap_sources,
|
|
'selections':selections,})
|
|
|
|
def add_skymapsource_to_selection(request, selection_id, skymapsource_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
try:
|
|
selection = Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This Selection was not found")
|
|
|
|
try:
|
|
src=SkyMapSource.objects.get(pk=skymapsource_id)
|
|
except:
|
|
return HttpResponse("This SkyMapSource was not found")
|
|
|
|
if not selection.skymap_sources.filter(pk=src.pk).exists():
|
|
selection.skymap_sources.add(src)
|
|
selection.save()
|
|
|
|
skymap_sources = selection.skymap_sources.all()
|
|
ntotal=skymap_sources.count()
|
|
|
|
return render(request,'srgcat/index.html', {'selection':selection,
|
|
'ntotal':ntotal,
|
|
'skymap_sources':skymap_sources,
|
|
'selections':selections,})
|
|
|
|
def delete_skymapsource_in_selection(request, selection_id, skymapsource_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
try:
|
|
selection = Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This Selection was not found")
|
|
|
|
try:
|
|
src=SkyMapSource.objects.get(pk=skymapsource_id)
|
|
except:
|
|
return HttpResponse("This SkyMapSource was not found")
|
|
|
|
if selection.skymap_sources.filter(pk=src.pk).exists():
|
|
selection.skymap_sources.remove(src)
|
|
selection.save()
|
|
|
|
skymap_sources = selection.skymap_sources.all()
|
|
ntotal=skymap_sources.count()
|
|
|
|
return render(request,'srgcat/index.html', {'selection':selection,
|
|
'ntotal':ntotal,
|
|
'skymap_sources':skymap_sources,
|
|
'selections':selections,})
|
|
|
|
def show_gaia(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
artcats = ArtCat.objects.all()
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.exclude(gaia=None)
|
|
skymap_sources = get_skymap_sources(dump, request.user).exclude(gaia=None)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
#skymap_sources = SkyMapSource.objects.exclude(gaia=None).order_by('created')
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'artcats': artcats,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,
|
|
'srcs':skymap_sources,
|
|
'dump':dump,})
|
|
|
|
def show_heasarc(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.exclude(heasarc=None)
|
|
skymap_sources = get_skymap_sources(dump, request.user).exclude(heasarc=None)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
""" skymap_sources = SkyMapSource.objects.exclude(heasarc=None).order_by('created') """
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,'srcs':skymap_sources,'dump':dump,})
|
|
|
|
def show_xss(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxteasscat__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcxteasscat__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,'srcs':skymap_sources,'dump':dump,})
|
|
def get_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.all()
|
|
|
|
return HttpResponseCSV(skymap_sources, dump, key='iki')
|
|
|
|
def get_xss_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxteasscat__isnull=False)
|
|
|
|
return HttpResponseCSV(skymap_sources, dump, key='xss',subclass=HeasarcXTEASSCAT)
|
|
|
|
def show_maxi_gsc(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcmaxigschgl__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcmaxigschgl__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,'srcs':skymap_sources,'dump':dump,})
|
|
def get_maxi_gsc_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcmaxigschgl__isnull=False)
|
|
|
|
return HttpResponseCSV(skymap_sources, dump, key='maxi_gsc',subclass=HeasarcMAXIGSCHGL)
|
|
|
|
def show_intrefcat(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcintrefcat__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcintrefcat__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def show_integral2020(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcintrefcat__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcintegral2020__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def get_intrefcat_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcintrefcat__isnull=False)
|
|
|
|
return HttpResponseCSV(skymap_sources, dump, key='intrefcat', subclass=HeasarcIntRefCat)
|
|
|
|
def show_swiftbat105m(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcswiftbat105m__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcswiftbat105m__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def get_swiftbat105m_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcswiftbat105m__isnull=False)
|
|
|
|
return HttpResponseCSV(skymap_sources, dump, key='swiftbat105m', subclass=HeasarcSwiftBAT105m)
|
|
|
|
def show_rass2rxs(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcrass2rxs__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcrass2rxs__isnull=False)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def show_3maxi(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
cnt = dump.skymapsource_set.count()
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxmmsl2__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarc3maxi__isnull=False).distinct()
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def get_3maxi_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxmmsl2__isnull=False).distinct()
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarc3maxi__isnull=False).distinct()
|
|
#print("get_xmmsl2_csv: {}".format(skymap_sources.count()))
|
|
return HttpResponseCSV(skymap_sources, dump, key='xmmsl2',subclass=Heasarc3MAXI)
|
|
|
|
def show_xmmsl2(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
cnt = dump.skymapsource_set.count()
|
|
#print("show_xmmsl2: {} total".format(cnt))
|
|
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxmmsl2__isnull=False)
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcxmmsl2__isnull=False).distinct()
|
|
ntotal=skymap_sources.count()
|
|
#print("show_xmmsl2: {}".format(ntotal))
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'ntotal':ntotal,'dump':dump,})
|
|
def get_xmmsl2_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcxmmsl2__isnull=False).distinct()
|
|
skymap_sources = get_skymap_sources(dump, request.user).filter(heasarc__heasarcxmmsl2__isnull=False).distinct()
|
|
#print("get_xmmsl2_csv: {}".format(skymap_sources.count()))
|
|
return HttpResponseCSV(skymap_sources, dump, key='xmmsl2',subclass=None)
|
|
|
|
def get_rass2rxs_csv(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(heasarc__heasarcrass2rxs__isnull=False)
|
|
return HttpResponseCSV(skymap_sources, dump, key='rass2rxs',subclass=HeasarcRASS2RXS)
|
|
|
|
def show_exclude_allsky(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
|
|
sign_threshold=0.0
|
|
try:
|
|
session = UserSessionParameters.objects.get(owner=request.user)
|
|
if not session.sign_threshold is None:
|
|
sign_threshold = session.sign_threshold
|
|
except UserSessionParameters.DoesNotExist:
|
|
pass
|
|
|
|
select_missed = SelectAllskyMissed.objects.filter(dump=dump)
|
|
ntotal=0
|
|
skymap_sources = []
|
|
for s in select_missed:
|
|
if s.source.sig >= sign_threshold:
|
|
skymap_sources.append(s.source)
|
|
ntotal=ntotal+1
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'skymap_sources':skymap_sources,
|
|
'srcs':skymap_sources,'dump':dump,'ntotal':ntotal})
|
|
|
|
def get_exclude_allsky(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
select_missed = SelectAllskyMissed.objects.filter(dump=dump)
|
|
skymap_sources = []
|
|
for s in select_missed:
|
|
skymap_sources.append(s.source)
|
|
return HttpResponseCSV(skymap_sources, dump, key='exclude_allsky_surveys_')
|
|
|
|
def show_simbad(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
artcats = ArtCat.objects.all()
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
#skymap_sources = dump.skymapsource_set.exclude(simbad=None)
|
|
skymap_sources = get_skymap_sources(dump, request.user).exclude(simbad=None)
|
|
ntotal=skymap_sources.count()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
#skymap_sources = SkyMapSource.objects.exclude(simbad=None).order_by('created')
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'artcats': artcats,
|
|
'skymap_sources':skymap_sources,'ntotal':ntotal,'srcs':skymap_sources,'dump':dump,})
|
|
|
|
def show_latest(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
artcats = ArtCat.objects.all()
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymaps = dump.skymap.all()
|
|
skymap_sources = dump.skymapsource_set.filter(new=True)
|
|
ntotal=skymap_sources.count()
|
|
survey = Survey.objects.get(Q(start__lt=dump.date) & Q(stop__gt=dump.date))
|
|
surveypaths = survey.surveypath_set.all()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request,'srgcat/index.html', {'selections':selections,
|
|
'artcats': artcats,
|
|
'skymap_sources':skymap_sources,
|
|
'ntotal':ntotal,
|
|
'srcs':skymap_sources,
|
|
'dump':dump,
|
|
'survey':survey,
|
|
'surveypaths':surveypaths,})
|
|
|
|
|
|
def show_srg_data_dumps(request):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
ddumps = SrgDataDump.objects.all().order_by("-date")
|
|
ntotal = ddumps.count()
|
|
return render(request,'srgcat/ddumps.html', {'ddumps': ddumps,'ntotal':ntotal,})
|
|
|
|
def show_data_dump(request, dump_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
dump=SrgDataDump.objects.get(pk=dump_id)
|
|
except:
|
|
return HttpResponse("This data dump was not found")
|
|
|
|
try:
|
|
survey = Survey.objects.get(Q(start__lt=dump.date) & Q(stop__gt=dump.date))
|
|
surveypaths = survey.surveypath_set.all().order_by('obt')
|
|
except:
|
|
survey=None
|
|
surveypaths=None
|
|
pass
|
|
skymap_sources = dump.skymapsource_set.all()
|
|
return render(request,'srgcat/ddumps.html', {'dump':dump,'skymap_sources':skymap_sources,'surveypaths':surveypaths,})
|
|
|
|
def update_catalog_data_dump(request, dump_id):
|
|
status=srg_group_auth_stats(request, "srg-iki-admin")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
dump = get_object_or_404(SrgDataDump, pk=dump_id)
|
|
dump.catalog_loaded = False
|
|
dump.save()
|
|
|
|
ddumps = SrgDataDump.objects.all().order_by("-date")
|
|
ntotal = ddumps.count()
|
|
return render(request,'srgcat/ddumps.html', {'ddumps':ddumps,})
|
|
|
|
def show_skymap(request, skymap_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
skymap=SkyMaps.objects.get(pk=skymap_id)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
|
|
related_dumps = skymap.srgdatadump_set.all().order_by('-date')
|
|
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(Q(skymap=skymap) & Q(bad=False))
|
|
|
|
skymaps = []
|
|
for plate in skymap.survey_healpix_plate.all():
|
|
skymaps.append(plate.healpix)
|
|
swiftbat = HeasarcBase.objects.instance_of(HeasarcSwiftBAT105m).filter(healpix_plate__in=skymaps)
|
|
intrefcat = HeasarcBase.objects.instance_of(HeasarcIntRefCat).filter(healpix_plate__in=skymaps)
|
|
rosat = HeasarcBase.objects.instance_of(HeasarcRASS2RXS).filter(healpix_plate__in=skymaps)
|
|
return render(request,'srgcat/skymap.html', {'intrefcat':intrefcat,'skymaps':skymaps,
|
|
'rosat':rosat,'swiftbat':swiftbat,
|
|
'skymap':skymap,'skymap_sources':skymap_sources,
|
|
'related_dumps':related_dumps,})
|
|
|
|
def show_skymap_radec(request, skymap_id, ra, dec):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
try:
|
|
skymap=SkyMaps.objects.get(pk=skymap_id)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
related_dumps = skymap.srgdatadump_set.all().order_by('-date')
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(Q(skymap=skymap) & Q(bad=False))
|
|
|
|
skymaps = []
|
|
for plate in skymap.survey_healpix_plate.all():
|
|
skymaps.append(plate.healpix)
|
|
swiftbat = HeasarcBase.objects.instance_of(HeasarcSwiftBAT105m).filter(healpix_plate__in=skymaps)
|
|
intrefcat = HeasarcBase.objects.instance_of(HeasarcIntRefCat).filter(healpix_plate__in=skymaps)
|
|
rosat = HeasarcBase.objects.instance_of(HeasarcRASS2RXS).filter(healpix_plate__in=skymaps)
|
|
return render(request,'srgcat/skymap.html', {'intrefcat':intrefcat,'skymaps':skymaps,
|
|
'rosat':rosat,'swiftbat':swiftbat,
|
|
'skymap':skymap,'skymap_sources':skymap_sources,
|
|
'related_dumps':related_dumps,'target_ra':ra,'target_dec':dec})
|
|
def show_field_radec(request, field, ra, dec):
|
|
""" the same as show_field_radec, but query field number rather than skymap.id """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
try:
|
|
skymap=SkyMaps.objects.get(SMAPNR=field)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
related_dumps = skymap.srgdatadump_set.all().order_by('-date')
|
|
dump = SrgDataDump.objects.filter(catalog_loaded=True).latest('date')
|
|
skymap_sources = dump.skymapsource_set.filter(Q(skymap=skymap) & Q(bad=False))
|
|
|
|
skymaps = []
|
|
for plate in skymap.survey_healpix_plate.all():
|
|
skymaps.append(plate.healpix)
|
|
swiftbat = HeasarcBase.objects.instance_of(HeasarcSwiftBAT105m).filter(healpix_plate__in=skymaps)
|
|
intrefcat = HeasarcBase.objects.instance_of(HeasarcIntRefCat).filter(healpix_plate__in=skymaps)
|
|
rosat = HeasarcBase.objects.instance_of(HeasarcRASS2RXS).filter(healpix_plate__in=skymaps)
|
|
return render(request,'srgcat/skymap.html', {'intrefcat':intrefcat,'skymaps':skymaps,
|
|
'rosat':rosat,'swiftbat':swiftbat,
|
|
'skymap':skymap,'skymap_sources':skymap_sources,
|
|
'related_dumps':related_dumps,'target_ra':ra,'target_dec':dec})
|
|
|
|
def show_skymap_by_name(request, skymap_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
skymap=SkyMaps.objects.get(SMAPNR=skymap_id)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
|
|
related_dumps = skymap.srgdatadump_set.all().order_by('-date')
|
|
|
|
return render(request,'srgcat/skymap.html', {'skymap':skymap,'related_dumps':related_dumps,})
|
|
|
|
|
|
def show_dump_skymap(request, dump_id, skymap_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
dump=SrgDataDump.objects.get(pk=dump_id)
|
|
except:
|
|
return HttpResponse("This data dump was not found")
|
|
|
|
try:
|
|
skymap=SkyMaps.objects.get(pk=skymap_id)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
|
|
related_dumps = skymap.srgdatadump_set.all().order_by('-date')
|
|
try:
|
|
survey = Survey.objects.get(Q(start__lt=dump.date) & Q(stop__gt=dump.date))
|
|
except:
|
|
survey = None
|
|
|
|
skymaps = []
|
|
for plate in skymap.survey_healpix_plate.all():
|
|
skymaps.append(plate.healpix)
|
|
|
|
rosat = HeasarcBase.objects.instance_of(HeasarcRASS2RXS).filter(healpix_plate__in=skymaps)
|
|
intrefcat = HeasarcBase.objects.instance_of(HeasarcIntRefCat).filter(healpix_plate__in=skymaps)
|
|
swiftbat = HeasarcBase.objects.instance_of(HeasarcSwiftBAT105m).filter(healpix_plate__in=skymaps)
|
|
|
|
return render(request,'srgcat/skymap.html', {'intrefcat':intrefcat,
|
|
'rosat':rosat,'swiftbat':swiftbat,
|
|
'survey':survey,
|
|
'dump':dump,
|
|
'skymap':skymap,
|
|
'related_dumps':related_dumps,})
|
|
|
|
def download_selection(request, selection_id):
|
|
""" Delete new Selection """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
selection=Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This selection was not found")
|
|
|
|
if not (selection.public or selection.owner == request.user):
|
|
return HttpResponse("You are trying to download not your (and private) Selection")
|
|
|
|
return HttpResponseCSV(selection.skymap_sources.all(), key="{}".format(selection.slug))
|
|
|
|
|
|
def delete_selection(request, selection_id):
|
|
""" Delete new Selection """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
selection=Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This selection was not found")
|
|
|
|
if(selection.owner != request.user):
|
|
return HttpResponse("You are trying to delete not your Selection")
|
|
|
|
selection.delete()
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/edit_all_selections.html', {'selections': selections,})
|
|
|
|
def edit_all_selections(request):
|
|
""" Edit all Selection """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/edit_all_selections.html', {'selections': selections,})
|
|
|
|
def edit_selection(request, selection_id):
|
|
""" Create new Selection """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
selection=Selection.objects.get(pk=selection_id)
|
|
except:
|
|
return HttpResponse("This selection was not found")
|
|
|
|
if(selection.owner != request.user):
|
|
return HttpResponse("You are trying to edit not your Selection")
|
|
|
|
if request.method == 'POST':
|
|
form = SelectionForm(request.POST)
|
|
if form.is_valid():
|
|
name=form.cleaned_data['name']
|
|
slug=form.cleaned_data['slug']
|
|
public=form.cleaned_data['public']
|
|
if (selection.slug != slug):
|
|
""" if user changed slug, check it """
|
|
if(Selection.objects.filter(owner=request.user).filter(slug=slug).exists()):
|
|
return render(request,
|
|
'srgcat/selection.html', {'form': form,
|
|
'message':"Short name \"{}\" for user {} is already exists".format(slug,request.user),})
|
|
selection.slug=slug
|
|
selection.name=name
|
|
selection.public=public
|
|
selection.save()
|
|
#return HttpResponseRedirect(reverse('art-xc survey index'))
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/edit_all_selections.html', {'selections': selections,})
|
|
else:
|
|
form = SelectionForm(instance=selection)
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/selection.html', {'form': form,'selections':selections,})
|
|
|
|
def user_session_parameters(request):
|
|
""" Edit user session parameters """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
if request.method == 'POST':
|
|
form = UserSessionParametersForm(request.POST)
|
|
if form.is_valid():
|
|
sign_threshold=form.cleaned_data['sign_threshold']
|
|
target_ra=form.cleaned_data['target_ra']
|
|
target_dec=form.cleaned_data['target_dec']
|
|
|
|
try:
|
|
session = UserSessionParameters.objects.get(owner=request.user)
|
|
except UserSessionParameters.DoesNotExist:
|
|
session=form.save(commit=False)
|
|
session.owner=request.user
|
|
session.save()
|
|
|
|
session.sign_threshold = sign_threshold
|
|
session.target_ra = target_ra
|
|
session.target_dec = target_dec
|
|
session.save()
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/session.html', {'selections': selections,'form':form,'session':session,})
|
|
else:
|
|
#form = UserSessionParametersForm()
|
|
pass
|
|
|
|
try:
|
|
session = UserSessionParameters.objects.get(owner=request.user)
|
|
except UserSessionParameters.DoesNotExist:
|
|
session = UserSessionParameters()
|
|
session.owner=request.user
|
|
session.save()
|
|
|
|
form = UserSessionParametersForm(instance=session)
|
|
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/session.html', {'form': form,'selections':selections,'session':session,})
|
|
|
|
def create_new_selection(request):
|
|
""" Create new Selection """
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
if request.method == 'POST':
|
|
form = SelectionForm(request.POST)
|
|
if form.is_valid():
|
|
name=form.cleaned_data['name']
|
|
slug=form.cleaned_data['slug']
|
|
public=form.cleaned_data['public']
|
|
if(Selection.objects.filter(owner=request.user).filter(slug=slug).exists()):
|
|
return render(request,
|
|
'srgcat/selection.html', {'form': form,
|
|
'message':"Short name \"{}\" for user {} is already exists".format(slug,request.user),})
|
|
selection=form.save(commit=False)
|
|
selection.owner=request.user
|
|
selection.save()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/selection.html', {'selections': selections,})
|
|
else:
|
|
form = SelectionForm()
|
|
selections = Selection.objects.filter(owner=request.user)
|
|
return render(request, 'srgcat/selection.html', {'form': form,'selections':selections,})
|
|
|
|
|
|
def get_name(request):
|
|
""" Get source name """
|
|
if request.method == 'POST':
|
|
form = SourceNameForm(request.POST)
|
|
if form.is_valid():
|
|
ra=float(form.cleaned_data['ra'])
|
|
dec=float(form.cleaned_data['dec'])
|
|
name=make_source_name('SRG',ra,dec)
|
|
return render(request, 'srgcat/source_name.html', {'form': form, 'name':name,})
|
|
else:
|
|
form = SourceNameForm()
|
|
|
|
return render(request, 'srgcat/source_name.html', {'form': form})
|
|
|
|
def show_skymap_form(request):
|
|
""" Get target in survey """
|
|
# if this is a POST request we need to process the form data
|
|
if request.method == 'POST':
|
|
# create a form instance and populate it with data from the request:
|
|
form = SkyMapForm(request.POST)
|
|
# check whether it's valid:
|
|
if form.is_valid():
|
|
# process the data in form.cleaned_data as required
|
|
# ...
|
|
# redirect to a new URL:
|
|
#return HttpResponseRedirect('/srgcat/srga')
|
|
skymap_id=int(form.cleaned_data['skymap'])
|
|
try:
|
|
skymap=SkyMaps.objects.get(SMAPNR=skymap_id)
|
|
except:
|
|
return HttpResponse("This sky map was not found")
|
|
return render(request, 'srgcat/skymap.html', {'form': form,'skymap':skymap,})
|
|
|
|
# if a GET (or any other method) we'll create a blank form
|
|
else:
|
|
form = SkyMapForm()
|
|
|
|
return render(request, 'srgcat/skymap.html', {'form': form})
|
|
|
|
|
|
def get_target_survey_post(request):
|
|
""" Get target in survey """
|
|
# if this is a POST request we need to process the form data
|
|
if request.method == 'POST':
|
|
# create a form instance and populate it with data from the request:
|
|
form = LookupTargetForm(request.POST)
|
|
# check whether it's valid:
|
|
if form.is_valid():
|
|
# process the data in form.cleaned_data as required
|
|
# ...
|
|
# redirect to a new URL:
|
|
#return HttpResponseRedirect('/srgcat/srga')
|
|
ra=float(form.cleaned_data['ra'])
|
|
dec=float(form.cleaned_data['dec'])
|
|
load_surveypath=form.cleaned_data['load_surveypath']
|
|
#name=make_source_name('SRG',ra,dec)
|
|
hp = HEALPix(nside=NSIDE_PLATES, order=ORDER, frame=FK5())
|
|
crd = SkyCoord(ra, dec, frame="fk5", unit="deg")
|
|
heal = hp.skycoord_to_healpix(crd)
|
|
plate=SurveyHealpixPlate.objects.get(healpix=heal)
|
|
surveys = plate.survey.all()
|
|
skymaps = plate.skymaps_set.all().annotate(separation=Value(0.0, output_field=DecimalField()))
|
|
c = SkyCoord(ra, dec, frame="fk5", unit="deg")
|
|
for smap in skymaps:
|
|
c0 = SkyCoord(smap.RA_CEN, smap.DE_CEN, frame="fk5", unit="deg")
|
|
smap.separation=c.separation(c0).arcmin
|
|
return render(request, 'srgcat/target_survey.html', {'form': form, 'ra_cen':ra, 'dec_cen':dec,
|
|
'load_surveypath':load_surveypath,
|
|
'plate':plate,'surveys':surveys,'skymaps':skymaps,})
|
|
|
|
# if a GET (or any other method) we'll create a blank form
|
|
else:
|
|
form = LookupTargetForm()
|
|
|
|
return render(request, 'srgcat/target_survey.html', {'form': form})
|
|
|
|
def get_target_survey_get(request):
|
|
""" Get target in survey """
|
|
# if this is a GET request we need to process the form data
|
|
if request.method == 'GET':
|
|
# create a form instance and populate it with data from the request:
|
|
form = LookupTargetForm(request.GET)
|
|
# check whether it's valid:
|
|
if form.is_valid():
|
|
# process the data in form.cleaned_data as required
|
|
# ...
|
|
# redirect to a new URL:
|
|
#return HttpResponseRedirect('/srgcat/srga')
|
|
ra=float(form.cleaned_data['ra'])
|
|
dec=float(form.cleaned_data['dec'])
|
|
load_surveypath=form.cleaned_data['load_surveypath']
|
|
name=make_source_name('SRG',ra,dec)
|
|
hp = HEALPix(nside=NSIDE_PLATES, order=ORDER, frame=FK5())
|
|
crd = SkyCoord(ra, dec, frame="fk5", unit="deg")
|
|
heal = hp.skycoord_to_healpix(crd)
|
|
plate=SurveyHealpixPlate.objects.get(healpix=heal)
|
|
surveys = plate.survey.all()
|
|
return render(request, 'srgcat/target_survey.html', {'form': form,
|
|
'ra_cen':ra,
|
|
'dec_cen':dec,
|
|
'load_surveypath':load_surveypath,
|
|
'name':name,
|
|
'plate':plate,
|
|
'surveys':surveys})
|
|
|
|
# if a GET (or any other method) we'll create a blank form
|
|
else:
|
|
form = LookupTargetForm()
|
|
|
|
return render(request, 'srgcat/target_survey.html', {'form': form})
|
|
|
|
|
|
def show_cat(request, cat_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
cat=ArtCat.objects.get(pk=cat_id)
|
|
except:
|
|
return HttpResponse("This catalog was not found")
|
|
artcats = ArtCat.objects.all()
|
|
srcs=cat.artsource_set.all().order_by("-sign")
|
|
return render(request,'srgcat/index.html', {'artcats': artcats,'cat':cat,'srcs':srcs,})
|
|
|
|
def show_artsource(request, artsource_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
src=ArtSource.objects.get(pk=artsource_id)
|
|
except:
|
|
return HttpResponse("This ArtSource was not found")
|
|
artcats = ArtCat.objects.all()
|
|
cat = src.catalog
|
|
heasarcs = src.heasarc.all().annotate(separation=Value(0.0, output_field=DecimalField()))
|
|
c = SkyCoord(src.ra, src.dec, frame="fk5", unit="deg")
|
|
for heasarc in heasarcs:
|
|
c0 = SkyCoord(heasarc.ra, heasarc.dec, frame="fk5", unit="deg")
|
|
sep=c.separation(c0)
|
|
heasarc.separation=sep.arcsecond
|
|
return render(request,'srgcat/index.html', {'artcats': artcats,'cat':cat,'src':src,'heasarcs':heasarcs,})
|
|
|
|
|
|
def show_skymapsource(request, skymapsource_id):
|
|
status=srg_group_auth_stats(request, "srg-artxc-survey")
|
|
if status != 0:
|
|
return HttpResponse(status_code[status])
|
|
|
|
try:
|
|
src=SkyMapSource.objects.get(pk=skymapsource_id)
|
|
except:
|
|
return HttpResponse("This SkyMapSource was not found")
|
|
|
|
heasarcs = src.heasarc.all().annotate(separation=Value(0.0, output_field=DecimalField()))
|
|
c = SkyCoord(src.ra, src.dec, frame="fk5", unit="deg")
|
|
for heasarc in heasarcs:
|
|
heasarc.separation=c.separation(SkyCoord(heasarc.ra, heasarc.dec, frame="fk5", unit="deg")).arcsecond
|
|
|
|
"""
|
|
gaia = src.gaia.all().annotate(separation=Value(0.0, output_field=DecimalField()))
|
|
for gaiasrc in gaia:
|
|
gaiasrc.separation=c.separation(SkyCoord(gaiasrc.ra, gaiasrc.dec, frame="fk5", unit="deg")).arcsecond
|
|
"""
|
|
|
|
simbad = src.simbad.all().annotate(separation=Value(0.0, output_field=DecimalField()))
|
|
for simsrc in simbad:
|
|
simsrc.separation=c.separation(SkyCoord(simsrc.ra, simsrc.dec, frame="fk5", unit="deg")).arcsecond
|
|
|
|
return render(request,'srgcat/index.html', {'src':src,'cat':src.skymap,
|
|
'heasarcs':heasarcs,
|
|
'simbad':simbad,})
|
|
|