DATABASES/madrigal Commit - r2:98d277d09dd7

Add modules for interactive plots and upload data

jespinoza -

r2:98d277d09dd7

parent child

Context file:

r2:98d277d09dd7

Expand all files

source/madpy/djangoMad/apps/login/__init__.py created 755 0 0

NO CONTENT: new file 100755

source/madpy/djangoMad/apps/login/migrations/__init__.py created 755 0 0

NO CONTENT: new file 100755

source/madpy/djangoMad/apps/login/templates/login/login.html created 755 +17 0

@@ -0,0 +1,17
	1	{% extends "base.html" %}
	2
	3	{% block title %}Login{% endblock %}
	4
	5	{% block content %}
	6	<center>
	7	<h4>Please login</h4>
	8
	9	<div style="margin-top: 30px;">
	10	<form method="POST">
	11	{{ form.as_p }}
	12	{% csrf_token %}
	13	<button type="submit">Login</button>
	14	</form>
	15	</div>
	16	</center>
	17	{% endblock %}

source/madpy/djangoMad/apps/login/urls.py created 755 +9 0

@@ -0,0 +1,9
	1	from django.conf.urls import url
	2	from . import views
	3
	4	urlpatterns = [
	5	url(r'^login/$', views.login_view, name='login'),
	6	url(r'^logout/$', views.logout_view, name='logout'),
	7	]
	8
	9	app_name = 'login' No newline at end of file

source/madpy/djangoMad/apps/login/views.py created 755 +38 0

@@ -0,0 +1,38
	1	from django.contrib.auth import authenticate
	2	from django.contrib.auth import login, logout
	3	from django.contrib.auth.forms import AuthenticationForm
	4	from django.shortcuts import render, redirect
	5
	6	''' Login to updata app for ROJ staff'''
	7
	8	def login_view(request):
	9
	10	form = AuthenticationForm()
	11	if request.method == "POST":
	12	form = AuthenticationForm(data=request.POST)
	13
	14	if form.is_valid():
	15
	16	username = form.cleaned_data['username']
	17	password = form.cleaned_data['password']
	18
	19	user = authenticate(username=username, password=password)
	20
	21	if user is not None:
	22
	23	if user.is_active:
	24	login(request, user)
	25
	26	return redirect('/updata')
	27	else:
	28	return render(request, "login/login.html" )
	29	else:
	30	context = {'error_login': "error"}
	31	return render(request, "login/login.html", context )
	32
	33	return render(request, "login/login.html", {'form': form})
	34
	35	def logout_view(request):
	36
	37	logout(request)
	38	return redirect('/') No newline at end of file

source/madpy/djangoMad/apps/updata/__init__.py created 755 0 0

	1	NO CONTENT: new file 100755			NO CONTENT: new file 100755

NO CONTENT: new file 100755

source/madpy/djangoMad/apps/updata/forms.py created 755 +108 0

@@ -0,0 +1,108
	1	from django import forms
	2	import django.utils.html
	3	import django.utils.safestring
	4	import django.template.defaulttags
	5
	6	# third party imports
	7	import numpy
	8
	9	# Madrigal imports
	10	import madrigal.metadata
	11	import madrigal.ui.web
	12
	13	# madrigal imports
	14	import madrigal._derive
	15	import madrigal.metadata
	16	import madrigal.ui.web
	17	import madrigal.cedar
	18	import madrigal.isprint
	19	import madweb.forms
	20
	21	import datetime, time
	22
	23	def getSelection(keyword, args, kwargs):
	24	"""getSelection returns '0' if keyword not a key in either args[0] or kwargs,
	25	otherwise the value
	26
	27	args, kwargs - arguments as passed into SingleExpDefaultForm __init__
	28	"""
	29	if len(args) == 0 and len(list(kwargs.keys())) == 0:
	30	return('0') # default case when no data passed in
	31	elif len(args) > 0:
	32	# args[0] is data dict argument to bind data
	33	if keyword in args[0]:
	34	return(args[0][keyword])
	35	else:
	36	return('0')
	37	elif keyword in kwargs:
	38	return(kwargs[keyword])
	39	elif 'data' in kwargs:
	40	if keyword in kwargs['data']:
	41	return(kwargs['data'][keyword])
	42	else:
	43	return('0')
	44	else:
	45	return('0')
	46
	47	def getExperimentList(args, kwargs, madWeb, header='Select experiment: '):
	48
	49	instrumentsId= int(getSelection('instruments', args, kwargs))
	50
	51	kinstList = [int(instrumentsId)]
	52	startDate = datetime.datetime(1950,1,1)
	53	startDT = datetime.datetime(startDate.year, startDate.month, startDate.day, 0, 0, 0)
	54	now = datetime.datetime.now()
	55	endDate = datetime.datetime(now.year, 12, 31, 23, 59, 59)
	56	endDT = datetime.datetime(endDate.year, endDate.month, endDate.day, 23, 59, 59)
	57	experiments = madWeb.getExperimentList(kinstList,startDT, endDT, True)
	58	expListin = [('0', header),]
	59	for exp in experiments:
	60	expListin.append((exp[0], exp[2]))
	61
	62	# Using set
	63	seen = set()
	64
	65	# using list comprehension
	66	expList = [(a, b) for a, b in expListin
	67	if not (b in seen or seen.add(b))]
	68
	69	return(expList)
	70
	71	class UpdataForm(forms.Form):
	72	def __init__(self, args, *kwargs):
	73	super(UpdataForm, self).__init__(args, *kwargs)
	74	madDB = madrigal.metadata.MadrigalDB()
	75	madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
	76	instruments = madInstData.getInstruments(0, True)
	77	instList = [('0', "Select Instrument"), ]
	78	for kinst, instDesc, siteID in instruments:
	79	instList.append((str(kinst), instDesc))
	80
	81	instrumentSelection = getSelection('instruments', args, kwargs)
	82	self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateExp(this)'}),
	83	choices=instList,
	84	initial=instrumentSelection,
	85	label='Instrument:')
	86
	87	madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
	88	experimentSelection = getSelection('experiments', args, kwargs)
	89	self.fields['experiments'] = django.forms.ChoiceField(choices=getExperimentList(args, kwargs, madWebObj),
	90	initial=experimentSelection,
	91	required=False, label='Experiment:')
	92
	93	description = forms.CharField(widget=forms.Textarea(attrs={'cols': 40,'rows': 3, 'style': 'resize:none'}), label='Description')
	94	type = forms.ChoiceField(choices=[('0', 'Public'),('1', 'Private')], initial=0,widget=forms.RadioSelect(attrs={'class': 'custom-radio'}))
	95	file = forms.FileField(label='Select Files', widget=forms.ClearableFileInput(attrs={'multiple': True}))
	96
	97	class ExpForm(forms.Form):
	98	"""SingleExpInstForm is a Form class for the instrument select field in the Single Experiment interface.
	99	Use this because its faster to create than the full SingleExpDefaultForm
	100	"""
	101	def __init__(self, args, *kwargs):
	102	super(ExpForm, self).__init__(args, *kwargs)
	103	madDB = madrigal.metadata.MadrigalDB()
	104	madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
	105	experimentSelection = getSelection('experiments', args, kwargs)
	106	self.fields['experiments'] = django.forms.ChoiceField(choices=getExperimentList(args, kwargs, madWebObj),
	107	initial=experimentSelection,
	108	required=False, label='Experiment')

source/madpy/djangoMad/apps/updata/migrations/__init__.py created 755 0 0

	1	NO CONTENT: new file 100755			NO CONTENT: new file 100755

NO CONTENT: new file 100755

source/madpy/djangoMad/apps/updata/templates/updata/experiments.html created 755 +9 0

@@ -0,0 +1,9
	1	<div class="row">
	2	{{ form.experiments.label }}
	3	</div>
	4	<!-- Instrument select is its own row in selections column -->
	5	<div class="row">
	6	<div class="col-md-12">
	7	{{ form.experiments }}
	8	</div> <!-- end span -->
	9	</div> <!-- end row --> No newline at end of file

source/madpy/djangoMad/apps/updata/templates/updata/index.html created 755 +102 0

@@ -0,0 +1,102
	1	{% extends "base.html" %}
	2	{% block title %}Upload Data{% endblock %}
	3
	4	{% block extra_head %}
	5	<script type="text/javascript">
	6	function populateExp(select) {
	7
	8	var kinst = select.options[select.selectedIndex].value;
	9	var url = "{% url 'updata:get_experiments' %}" + '?instruments=' + kinst;
	10	// first delete all forms that are now out of date
	11	divIndex = $(".single_form").index($("#experiments"))
	12	$(".single_form").slice(divIndex).empty()
	13	// second populate the categories html
	14	$(".single_form").slice(divIndex, divIndex + 1).load(url);
	15	}
	16
	17	</script>
	18
	19	<style>
	20	.custom-radio {
	21	list-style: none;
	22	margin: 0;
	23	padding: 0;
	24	}
	25	</style>
	26	{% endblock %}
	27
	28	{% block content %}
	29
	30	<center><h4>Upload Data</h4></center>
	31	<form method="post" enctype="multipart/form-data">
	32
	33	{% csrf_token %}
	34
	35	{% block description %}
	36	<!-- subdivide selection column for instruments to be possibly filled in by ajax - single_form 0 -->
	37	<div class="col-md-12 single_form" id="description">
	38	<div class="row">
	39	{{ form.description.label }}
	40	</div>
	41	<!-- Instrument select is its own row in selections column -->
	42	<div class="row">
	43	<div class="col-md-12">
	44	{{ form.description }}
	45	</div> <!-- end span -->
	46	</div> <!-- end row -->
	47	</div> <!-- end subdivide -->
	48
	49	{% endblock %}
	50
	51	{% block file %}
	52	<div class="col-md-12 single_form" style="margin-top: 15px;" id="description">
	53	<div class="row">
	54	{{ form.file.label }}
	55	</div>
	56	<!-- Instrument select is its own row in selections column -->
	57	<div class="row">
	58	<div class="col-md-12">
	59	{{ form.file }}
	60	</div> <!-- end span -->
	61	</div> <!-- end row -->
	62	</div> <!-- end subdivide -->
	63
	64	{% endblock %}
	65
	66	{% block type %}
	67	<div class="col-md-12 single_form" style="margin-top: 15px;" id="description">
	68	<!-- Instrument select is its own row in selections column -->
	69	<div class="row">
	70	<div class="col-md-12">
	71	{{ form.type }}
	72	</div> <!-- end span -->
	73	</div> <!-- end row -->
	74	</div> <!-- end subdivide -->
	75
	76	{% endblock %}
	77
	78	{% block instruments %}
	79	<!-- subdivide selection column for instruments to be possibly filled in by ajax - single_form 0 -->
	80	<div class="col-md-12 single_form" style="margin-top: 15px;" id="instruments">
	81
	82	{% if form.instruments %}
	83	{% include "madweb/instruments.html" %}
	84	{% endif %}
	85
	86	</div> <!-- end subdivide -->
	87	{% endblock %}
	88
	89	{% block experiments %}
	90	<!-- subdivide selection column for experiments to be possibly filled in by ajax - single_form 0 -->
	91	<div class="col-md-12 single_form" style="margin-top: 15px;" id="experiments">
	92
	93	{% if form.experiments %}
	94	{% include "updata/experiments.html" %}
	95	{% endif %}
	96
	97	</div> <!-- end subdivide -->
	98	{% endblock %}
	99	<button style="margin-top: 15px;" type="submit">Load</button>
	100
	101	</form>
	102	{% endblock %} No newline at end of file

source/madpy/djangoMad/apps/updata/urls.py created 755 +9 0

@@ -0,0 +1,9
	1	from django.conf.urls import url
	2	from . import views
	3
	4	urlpatterns = [
	5	url(r'^$',views.index, name='updata_index'),
	6	url(r'^getExperiments/?$', views.get_experiments, name='get_experiments'),
	7	]
	8
	9	app_name = 'updata' No newline at end of file

source/madpy/djangoMad/apps/updata/views.py created 755 +83 0

@@ -0,0 +1,83
	1
	2	from django.contrib.auth.decorators import login_required
	3	from django.shortcuts import render
	4	from .forms import UpdataForm, ExpForm
	5	from django.core.files.storage import FileSystemStorage
	6	from django.contrib import messages
	7
	8	import os
	9
	10	# madrigal imports
	11	import madrigal.metadata
	12	import madrigal.ui.web
	13	import madrigal.admin
	14
	15	@login_required
	16	def index(request):
	17	'''
	18	Uploading experiments data view. Allows user to upload experiment files
	19
	20	'''
	21	dbAdminObj = madrigal.admin.MadrigalDBAdmin()
	22	madDB = madrigal.metadata.MadrigalDB()
	23	madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
	24	siteName, siteList = madWebObj.getSiteInfo()
	25
	26	if request.method == 'POST':
	27	form = UpdataForm(request.POST, request.FILES)
	28	files = request.FILES.getlist('file')
	29
	30	if form.is_valid():
	31	try:
	32	description = form.cleaned_data['description']
	33	instCode = int(form.cleaned_data['instruments'])
	34	expId = form.cleaned_data['experiments']
	35	perm = int(form.cleaned_data['type'])
	36
	37	#saving file
	38	for f in files:
	39	fs = FileSystemStorage(location='/tmp')
	40	fs.save(f.name, f)
	41	madExp = madrigal.metadata.MadrigalExperiment()
	42	filepath = os.path.join('/tmp', f.name)
	43	expTitle = madExp.getExpNameByExpId(expId)
	44
	45	dbAdminObj.createMadrigalExperiment(filepath,expTitle, perm, description, instCode)
	46
	47
	48	madInstParams = madrigal.metadata.MadrigalInstrumentParameters()
	49	madInstKindats = madrigal.metadata.MadrigalInstrumentKindats()
	50
	51	print('* Updating local metadata *')
	52	dbAdminObj.__updateLocalMetadata__()
	53	print('* Rebuilding instParmTab.txt *')
	54	madInstParams.rebuildInstParmTable()
	55	print('* Rebuilding instKindatTab.txt *')
	56	madInstKindats.rebuildInstKindatTable()
	57	messages.success(
	58	request, 'Experimento(s) creado(s) exitosamente')
	59	form = UpdataForm()
	60
	61	except Exception as e:
	62	messages.error(
	63	request, str(e))
	64	else:
	65	form = UpdataForm()
	66
	67	return render(request, 'updata/index.html', {
	68	'form': form,
	69	'site_name': siteName,
	70	'site_list': siteList,
	71	})
	72
	73
	74	def get_experiments(request):
	75	"""get_experiments is a Ajax call that returns the experiments select html to support the
	76	updata UI. Called when a user modifies the intruments select field.
	77
	78	Inputs:
	79	request
	80	"""
	81	form = ExpForm(request.GET)
	82
	83	return render(request, 'updata/experiments.html', {'form': form})

source/madpy/djangoMad/madweb/static/loader.gif created 755 binary 0 0

NO CONTENT: new file 100755, binary diff hidden

source/madpy/djangoMad/madweb/templates/madweb/parameter_selection.html created 755 +50 0

@@ -0,0 +1,50
	1	<div class="row" style="margin-bottom: 20px">
	2	Select parameter: <br>
	3	{{ form.param_list1d.label }}
	4	{{ form.param_list1d }}
	5	{% if form.param_list2d %}
	6	{{ form.param_list2d.label }}
	7	{{ form.param_list2d }}
	8	{% endif %}
	9
	10	</div>
	11
	12	<script>
	13	$('#id_param_list2d').bind('change', function (e) {
	14	var expID = '{{ expID }}';
	15	var param = $(this).val();
	16	var url = '{% url 'plot' %}' + '?expID=' + expID + '&param2d=' + param;
	17	console.log(url)
	18	// first delete all forms that are now out of date
	19	divIndex = $(".single_form").index($( "#file_plot" ))
	20	$(".single_form").slice(divIndex).empty()
	21	// second populate the file_plot html if '0' not selected
	22	if (param != '0') {
	23	$(".single_form").slice(divIndex,divIndex+1).html("<img src=\"static/loader.gif\" class=\"load_center\"/>").load(url);
	24	}
	25	})
	26	$('#id_param_list1d').bind('change', function (e) {
	27	var expID = '{{ expID }}';
	28	var param = $(this).val();
	29	var url = '{% url 'plot' %}' + '?expID=' + expID + '&param1d=' + param;
	30	console.log(url)
	31	// first delete all forms that are now out of date
	32	divIndex = $(".single_form").index($( "#file_plot" ))
	33	$(".single_form").slice(divIndex).empty()
	34	// second populate the file_plot html if '0' not selected
	35	if (param != '0') {
	36	$(".single_form").slice(divIndex,divIndex+1).html("<img src=\"static/loader.gif\" class =\"load_center\"/>").load(url);
	37	}
	38	})
	39	</script>
	40	<style>
	41	.load_center {
	42	display: block;
	43	margin-left: auto;
	44	margin-right: auto;
	45	margin-top: 100px;
	46	margin-bottom: 100px;
	47	width: 4%;
	48	align-items: center;
	49	}
	50	</style> No newline at end of file

source/madpy/djangoMad/djangoMad/settings.py +16 -10

             """
             Django settings for djangoMad project.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.7/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.7/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
             BASE_DIR = os.path.dirname(os.path.dirname(__file__))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.7/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
-            SECRET_KEY = '!wa!749ow0!%7t7tr6fr^fvkqyd7yc#mmvpfedr+f2pb!4r)wd'
+            SECRET_KEY = '^c1l3d35+q28^66d2pc1qlu(k$wmw^*gg3rfitz^s)t=9eu1ui'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['localhost:8000', '127.0.0.1', 'localhost']
             ADMINS = (('Bill Rideout', 'brideout@haystack.mit.edu'),)
             EMAIL_HOST = 'hyperion.haystack.mit.edu'
             SEND_BROKEN_LINK_EMAILS = True
             MANAGERS = (('Bill Rideout', 'brideout@haystack.mit.edu'),)
             # Application definition
             INSTALLED_APPS = (
-                #'django.contrib.admin',
+                'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'madweb',
                 'django_bootstrap_calendar',
-                'bootstrap3'
+                'bootstrap3',
+                'apps.login',
+                'apps.updata',
             )
-            MIDDLEWARE_CLASSES = (
+            MIDDLEWARE = [
-                'django.contrib.auth.middleware.AuthenticationMiddleware',
+                'django.middleware.security.SecurityMiddleware',
-                'django.contrib.messages.middleware.MessageMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
-                'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
+                'django.contrib.auth.middleware.AuthenticationMiddleware',
+                'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
+            ]
             ROOT_URLCONF = 'djangoMad.urls'
             WSGI_APPLICATION = 'djangoMad.wsgi.application'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [
                         os.path.join(BASE_DIR, "templates"),
                     ],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.contrib.auth.context_processors.auth',
                             'django.template.context_processors.debug',
                             'django.template.context_processors.i18n',
                             'django.template.context_processors.media',
                             'django.template.context_processors.static',
                             'django.template.context_processors.tz',
                             'django.contrib.messages.context_processors.messages',
+                            'django.template.context_processors.request',
                         ],
                     },
                 },
             ]
             # Database
             # https://docs.djangoproject.com/en/1.7/ref/settings/#databases
             DATABASES = {
+                'default': {
+                    'ENGINE': 'django.db.backends.sqlite3',
+                    'NAME': 'madrigal.sqlite',
                 }
+            }
             # Internationalization
             # https://docs.djangoproject.com/en/1.7/topics/i18n/
             LANGUAGE_CODE = 'en-us'
             TIME_ZONE = 'UTC'
             USE_I18N = True
             USE_L10N = True
             USE_TZ = True
             # Absolute filesystem path to the directory that will hold user-uploaded files.
             # Example: "/home/media/media.lawrence.com/media/"
             MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             # URL that handles the media served from MEDIA_ROOT. Make sure to use a
             # trailing slash.
             # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
             MEDIA_URL = '/media/'
             # Absolute path to the directory static files should be collected to.
             # Don't put anything in this directory yourself; store your static files
             # in apps' "static/" subdirectories and in STATICFILES_DIRS.
             # Example: "/home/media/media.lawrence.com/static/"
             # STATIC_ROOT = os.path.join(BASE_DIR, 'static')
             # URL prefix for static files.
             # Example: "http://media.lawrence.com/static/"
             STATIC_URL = '/static/'
             BOOTSTRAP3 = {
                 # Include jQuery with Bootstrap JavaScript (affects django-bootstrap3 template tags)
                 'jquery_url': '/static/jquery.min.js',
                 'include_jquery': True,
             }

source/madpy/djangoMad/djangoMad/urls.py +3 0

             from django.conf.urls import include, url
             from django.contrib import admin
             import madweb.views
             urlpatterns = [
                 url(r'^', include('madweb.urls')),
                 url(r'^$', madweb.views.index),
+                url(r'^updata/', include('apps.updata.urls', namespace="updata")),
+                url(r'^accounts/', include('apps.login.urls', namespace="login")),
+                url(r'^admin/', admin.site.urls),
             ]

source/madpy/djangoMad/djangoMad/wsgi.py +1 -1

             """
             WSGI config for djangoMad project.
             It exposes the WSGI callable as a module-level variable named ``application``.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.7/howto/deployment/wsgi/
             """
             import os, os.path
             import madrigal.metadata
             madDB = madrigal.metadata.MadrigalDB()
             os.environ['PYTHON_EGG_CACHE'] = os.path.join(madDB.getMadroot(), 'eggs')
-            os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoMad.settings_production")
+            os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djangoMad.settings")
             from django.core.wsgi import get_wsgi_application
             application = get_wsgi_application()

source/madpy/djangoMad/madweb/forms.py +134 0

             """Forms for madweb application
             $Id: forms.py 7288 2020-12-10 16:49:16Z brideout $
             """
             # standard python imports
             import os.path
             import datetime
             import itertools
             # django imports
             import django.forms
             import django.utils.html
             import django.utils.safestring
             import django.template.defaulttags
             # third party imports
             import numpy
+            import h5py
             # Madrigal imports
             import madrigal.metadata
             import madrigal.ui.web
             # temp only
             import logging
             @django.template.defaulttags.register.filter
             def get_item(dictionary, key):
                 return(dictionary.get(key))
             @django.template.defaulttags.register.filter
             def modulo(num, val):
                 return(num % val == 0)
             class HorizontalRadioSelect(django.forms.RadioSelect):
                 template_name = 'madweb/horizontal_select.html'
             def getSelection(keyword, args, kwargs):
                 """getSelection returns '0' if keyword not a key in either args[0] or kwargs,
                 otherwise the value
                 args, kwargs - arguments as passed into SingleExpDefaultForm __init__
                 """
                 if len(args) == 0 and len(list(kwargs.keys())) == 0:
                     return('0') # default case when no data passed in
                 elif len(args) > 0:
                     # args[0] is data dict argument to bind data
                     if keyword in args[0]:
                         return(args[0][keyword])
                     else:
                         return('0')
                 elif keyword in kwargs:
                     return(kwargs[keyword])
                 elif 'data' in kwargs:
                     if keyword in kwargs['data']:
                         return(kwargs['data'][keyword])
                     else:
                         return('0')
                 else:
                     return('0')
             def getIsGlobal(args, kwargs):
                 """getIsGlobal is a helper function returns True if 'isGlobal' not found in either args[0] or kwargs,
                 otherwise the bool of the value
                 args, kwargs - arguments as passed into SingleExpDefaultForm __init__
                 """
                 if len(args) == 0 and len(list(kwargs.keys())) == 0:
                     return(True) # default case when no data passed in
                 elif len(args) > 0:
                     # args[0] is data dict argument to bind data
                     if 'isGlobal' in args[0]:
                         if args[0]['isGlobal'] == '0':
                             return(False)
                         else:
                             return(bool(args[0]['isGlobal']))
                     else:
                         return(False)
                 elif 'data' in kwargs:
                     if 'isGlobal' in kwargs['data']:
                         if kwargs['data']['isGlobal'] == '0':
                             return(False)
                         else:
                             return(bool(kwargs['data']['isGlobal']))
                     else:
                         return(False)
                 elif 'isGlobal' in kwargs:
                     if kwargs['isGlobal'] == '0':
                             return(False)
                     else:
                         return(bool(kwargs['isGlobal']))
                 else:
                     return(False)
             def getCategoryList(args, kwargs, madInstData, forList=False):
                 """getCategoryList is a helper function that returns the categories choices in
                 SingleExpDefaultForm.categories at runtime
                 Inputs:
                     args, kwargs - arguments as passed into SingleExpDefaultForm __init__.  Used only to
                         determine isGlobal
                     madInstData - madrigal.metadata.MadrigalInstrumentData object
                     forList - if False (the default) category list if for single interface, If True, for List interface
                 """
                 if not forList:
                     local = not getIsGlobal(args, kwargs)
                 else:
                     local = False
                 categories = madInstData.getCategories(local)
                 if forList:
                     catList = [('0', 'All instrument categories'),]
                 else:
                     catList = [('0', 'Choose instrument type: '),]
                 for catID, catDesc in categories:
                     catList.append((str(catID), catDesc))
                 return(catList)
             def getInstrumentList(args, kwargs, madInstData, header='Select an instrument: ', local=None, includeYears=False):
                 """getInstrumentList is a helper function that returns the instrument choices in
                 SingleExpDefaultForm.categories at runtime
                 Inputs:
                     args, kwargs - arguments as passed into SingleExpDefaultForm __init__.  Used to
                         determine categoryId and local
                     madInstData - madrigal.metadata.MadrigalInstrumentData object
                     header - text of first item in selection
                     local - if None (the default), set local flag via args and kwargs.  If boolean,
                         set local flag to arg.
                     includeYear - if True, include data years in description.  If False (the default), do not.
                 """
                 if local is None:
                     local = not getIsGlobal(args, kwargs)
                 else:
                     local = bool(local)
                 if header == 'Select an instrument: ':
                     categoryId = int(getSelection('categories', args, kwargs))
                 else:
                     categoryId = 0
                 instruments = madInstData.getInstruments(categoryId, local)
                 instList = [('0', header),]
                 for kinst, instDesc, siteID in instruments:
                     if includeYears:
                         instYears = madInstData.getInstrumentYears(kinst)
                         instList.append((str(kinst), '%s [%i-%i]' % (instDesc, instYears[0], instYears[-1])))
                     else:
                         instList.append((str(kinst), instDesc))
                 return(instList)
             def getYearList(args, kwargs, madInstData):
                 """getYearList is a helper function that returns the year choices in
                 SingleExpDefaultForm.categories at runtime
                 Inputs:
                     args, kwargs - arguments as passed into SingleExpDefaultForm __init__.  Used to
                         determine categoryId and local and kinst
                     madInstData - madrigal.metadata.MadrigalInstrumentData object
                 """
                 local = not getIsGlobal(args, kwargs)
                 kinst = int(getSelection('instruments', args, kwargs))
                 years = madInstData.getInstrumentYears(kinst)
                 yearsList = [('0', 'Select a year: '),]
                 for thisYear in reversed(years):
                     yearsList.append((str(thisYear), str(thisYear)))
                 return(yearsList)
             def getMonthList(args, kwargs, madWebObj):
                 """getMonthList is a helper function that returns the month choices in
                 SingleExpDefaultForm.categories at runtime.  Value is (month number,
                 month name)
                 Inputs:
                     args, kwargs - arguments as passed into SingleExpDefaultForm __init__.  Used to
                         determine and kinst and year
                     madWebObj - madrigal.ui.web.MadrigalWeb object
                 """
                 kinst = int(getSelection('instruments', args, kwargs))
                 year = int(getSelection('years', args, kwargs))
                 monthList = [('0', 'Select a month: '),]
                 addedMonthList = madWebObj.getMonths(kinst, year)
                 if len(addedMonthList) == 0:
                     addedMonthList = madWebObj.getMonths(kinst, year, optimize=False)
                 monthList += addedMonthList
                 return([(str(monthNumber), monthName) for monthNumber, monthName in monthList])
             def getDayList():
                 """always returns 1 ... 31
                 """
                 dayList = [(i, str(i)) for i in range(1,32)]
                 return(dayList)
             def getExpList(args, kwargs, madWebObj):
                 """getExpList is a helper function that returns the experiment choices in
                 SingleExpDefaultForm.categories at runtime.  Value is (expId,
                 expDesc, expDir, pi_name, pi_email)
                 Inputs:
                     args, kwargs - arguments as passed into SingleExpDefaultForm __init__.  Used to
                         determine and kinst, year, month, day
                     madWebObj - madrigal.ui.web.MadrigalWeb object
                 """
                 kinst = int(getSelection('instruments', args, kwargs))
                 year = int(getSelection('years', args, kwargs))
                 month = int(getSelection('months', args, kwargs))
                 day = int(getSelection('days', args, kwargs))
                 expList = madWebObj.getExpsOnDate(kinst, year, month, day)
                 if len(expList) == 0:
                     expList = madWebObj.getExpsOnDate(kinst, year, month, day, optimize=False)
                 return(expList)
             def handle_registration(kwargs, user_email, expUrl, kinst, madDB):
                 """handle_registration causes the user to register or unregister interest in getting emails
                 when a particular experiment or instrument is updated
                 Inputs:
                     kwargs - dictionary as passed into form
                     user_email - users email address
                     expUrl - experiment url (part after /madtoc/)
                     kinst - instrument code
                     madDB - madrigal.metadata.MadrigalDB object
                 """
                 # first find out if this exp or inst is already registered
                 madUserObj = madrigal.ui.userData.MadrigalUserData(madDB)
                 expsRegistered = madUserObj.getRegisteredExperiments(user_email)
                 if expUrl in expsRegistered:
                     thisExpRegistered = True
                 else:
                     thisExpRegistered = False
                 instsRegistered = madUserObj.getRegisteredInstruments(user_email)
                 if kinst in instsRegistered:
                     thisInstRegistered = True
                 else:
                     thisInstRegistered = False
                 # check registration status, update if needed, and let form know how to print this
                 # 0 - no registration, 1 - exp registered, 2 - inst registered
                 if 'registerExp' in kwargs:
                     if not thisExpRegistered:
                         madUserObj.registerExperiment(user_email, expUrl)
                     return('1')
                 elif 'registerInst' in kwargs:
                     if not thisInstRegistered:
                         madUserObj.registerInstrument(user_email, kinst)
                     return('2')
                 elif 'unregisterExp' in kwargs:
                     if thisExpRegistered:
                         madUserObj.unregisterExperiment(user_email, expUrl)
                     return('0')
                 elif 'unregisterInst' in kwargs:
                     if thisInstRegistered:
                         madUserObj.unregisterInstrument(user_email, kinst)
                     return('0')
                 elif thisExpRegistered:
                     return('1')
                 elif thisInstRegistered:
                     return('2')
                 else:
                     return('0')
             def getFormatChoices(basename, expID):
                 """getFormatChoices returns a list with 3 tuples, where each tuple
                 is 1. filename with correct extension, 2. Format
                 Inputs:
                     basename - basename of Madrigal Hdf5 file
                     expID - needed to determine if cached file available in near real time
                 """
                 madWebObj = madrigal.ui.web.MadrigalWeb()
                 formats = madWebObj.getFormatsAvailable(expID, basename)
                 fileName, fileExtension = os.path.splitext(basename)
                 retList = []
                 retList.append((basename, 'Hdf5')) # file is assumed to be in Hdf5 format
                 if 'ascii' in formats:
                     retList.append((fileName + '.txt', 'Space-delimited ascii'))
                 if 'netCDF4' in formats:
                     retList.append((fileName + '.nc', 'netCDF4'))
                 return(retList)
             class RegisterForm(django.forms.Form):
                 """RegisterForm is the form class that supports the Register page
                 """
                 def __init__(self, *args, **kwargs):
                     super(RegisterForm, self).__init__(*args, **kwargs)
                     self.fields['user_fullname'] = django.forms.CharField(label='Full name', min_length=2, max_length=256)
                     self.fields['user_email'] = django.forms.EmailField(label='Email')
                     self.fields['user_affiliation'] = django.forms.CharField(label='Affliation (type "None" if individual)', min_length=2, max_length=256)
             class SingleExpDefaultForm(django.forms.Form):
                 """SingleExpDefaultForm is a Form class for the default fields in the Single Experiment interface
                 (formally the Simple interface)
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpDefaultForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     user_email = getSelection('user_email', args, kwargs)
                     self.fields['isGlobal'] = django.forms.BooleanField(widget = django.forms.CheckboxInput(attrs={"onChange":'populateCat(this)'}),
                                                                         required=False, label='Use all Madrigal sites: ',
                                                                         initial=getIsGlobal(args, kwargs))
                     categoriesSelection = getSelection('categories', args, kwargs)
                     self.fields['categories'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateInst(this)'}),
                                                                          choices=getCategoryList(args, kwargs, madInstData),
                                                                          initial=categoriesSelection,
                                                                          label='Instrument category:')
                     # the following fields may or may not be populated.  All are also available as individual classes
                     # to allow AJAX calls to not need to create this full object
                     if categoriesSelection != '0':
                         instrumentSelection = getSelection('instruments', args, kwargs)
                         self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateYear(this)'}),
                                                                               choices=getInstrumentList(args, kwargs, madInstData),
                                                                               initial=instrumentSelection,
                                                                               required=False, label='Instrument:')
                     else:
                         return # no need to create any further fields
                     if instrumentSelection != '0':
                         yearSelection = getSelection('years', args, kwargs)
                         self.fields['years'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateMonth(this)'}),
                                                                         choices=getYearList(args, kwargs, madInstData),
                                                                         initial=yearSelection,
                                                                         required=False, label='Year:')
                     else:
                         return # no need to create any further fields
                     if yearSelection != '0':
                         madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                         monthSelection = getSelection('months', args, kwargs)
                         self.fields['months'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateCalendar(this)'}),
                                                                     choices=getMonthList(args, kwargs, madWebObj),
                                                                     initial=monthSelection, label='Month:')
                     else:
                         return # no need to create any further fields
                     if monthSelection != '0':
                         daySelection = getSelection('days', args, kwargs)
                         # this field is only used to help display the calendar
                         self.fields['days'] = django.forms.ChoiceField(required=False, choices=getDayList())
                     else:
                         return # no need to create any further fields
                     if daySelection != '0':
                         expFullList = getExpList(args, kwargs, madWebObj)
                         expIdSelection = None
                         if len(expFullList) > 1:
                             expList = [('0', 'Select one of multiple experiments')] + [(items[0], items[1]) for items in expFullList]
                             expIdSelection = getSelection('experiment_list', args, kwargs)
                             self.fields['experiment_list'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateFile(this)'}),
                                                                                       choices=expList, initial=expIdSelection,
                                                                                       required=False, label='Select experiment:')
                             if expIdSelection == '0':
                                 # no need to create any further fields
                                 return
                         if expIdSelection is None:
                             expIdSelection = expFullList[0][0]
                             expDir = expFullList[0][2]
                         else:
                             expDir = None
                             for expId, thisExpDesc, thisExpDir in expFullList:
                                 if int(expIdSelection) == int(expId):
                                     expDir = thisExpDir
                                     break
                         fileList = madWebObj.getFileFromExpDir(expDir, int(instrumentSelection))
                         fileList = [('0', 'Select file')] + fileList
                         fileSelection = getSelection('file_list', args, kwargs)
                         self.fields['file_list'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'changeFile(this)'}),
                                                                             choices=fileList, initial=fileSelection,
                                                                             required=False, label='Select file:')
                         self.fields['exp_id'] = django.forms.CharField(initial=str(expIdSelection),
                                                                        widget=django.forms.HiddenInput(attrs={'value': str(expIdSelection)}),
                                                                        required=False,
                                                                        label=str(expIdSelection))
                         pi_name, pi_email, expUrl, kinst, expDesc, kinstDesc = madWebObj.getExpInfoFromExpID(int(expIdSelection))
                         self.fields['exp_desc'] = django.forms.CharField(initial=str(expDesc),
                                                                          widget=django.forms.HiddenInput(attrs={'value': str(expDesc)}),
                                                                          required=False,
                                                                          label=str(expDesc))
                         self.fields['user_email'] = django.forms.CharField(initial=str(user_email),
                                                                            widget=django.forms.HiddenInput(attrs={'value': str(user_email)}),
                                                                            required=False,
                                                                            label=str(user_email))
                         self.fields['inst_desc'] = django.forms.CharField(initial=str(kinstDesc),
                                                                            widget=django.forms.HiddenInput(attrs={'value': str(kinstDesc)}),
                                                                            required=False,
                                                                            label=str(kinstDesc))
                         self.fields['pi_name'] = django.forms.CharField(initial=pi_name,
                                                                        widget=django.forms.HiddenInput(attrs={'value': pi_name}),
                                                                        required=False,
                                                                        label=pi_name)
                         self.fields['pi_email'] = django.forms.CharField(initial=pi_email,
                                                                         widget=django.forms.HiddenInput(attrs={'value': pi_email}),
                                                                         required=False,
                                                                         label=pi_email)
                         # handle any needed registration or unregistration
                         register = handle_registration(args[0], user_email, expUrl, kinst, madDB)
                         self.fields['register'] = django.forms.CharField(initial=register,
                                                                          widget=django.forms.HiddenInput(attrs={'value': register}),
                                                                          required=False,
                                                                          label=register)
                     else:
                         return # no need to create any further fields
                     if fileSelection != '0':
                         self.fields['file_buttons'] = django.forms.CharField(initial='',
                                                                             widget=django.forms.HiddenInput(attrs={'value': ''}),
                                                                             required=False,
                                                                             label='')
                     else:
                         return # no need to create any further fields
             class SingleExpInstForm(django.forms.Form):
                 """SingleExpInstForm is a Form class for the instrument select field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpInstForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     instrumentSelection = getSelection('instruments', args, kwargs)
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateYear(this)'}),
                                                                           choices=getInstrumentList(args, kwargs, madInstData),
                                                                           initial=instrumentSelection,
                                                                           label='Instrument:')
             class SingleExpYearForm(django.forms.Form):
                 """SingleExpYearForm is a Form class for the year select field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpYearForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     yearSelection = getSelection('years', args, kwargs)
                     self.fields['years'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateMonth(this)'}),
                                                                     choices=getYearList(args, kwargs, madInstData),
                                                                     initial=yearSelection, label='Year:')
             class SingleExpMonthForm(django.forms.Form):
                 """SingleExpMonthForm is a Form class for the month select field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpMonthForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                     monthSelection = getSelection('months', args, kwargs)
                     self.fields['months'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'populateCalendar(this)'}),
                                                                     choices=getMonthList(args, kwargs, madWebObj),
                                                                     initial=monthSelection, label='Month:')
             class SingleExpCalendarForm(django.forms.Form):
                 """SingleExpCalendarForm is a Form class for the calendar field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpCalendarForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
             class SingleExpFileForm(django.forms.Form):
                 """SingleExpFileForm is a Form class for the file select field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpFileForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                     expID = getSelection('experiment_list', args, kwargs)
                     try:
                         expID = int(expID)
                     except ValueError:
                         # convert expPath to expID
                         expID = madWebObj.getExpIDFromExpPath(expID, True)
                     user_email = getSelection('user_email', args, kwargs)
                     include_non_default = getSelection('includeNonDefault', args, kwargs)
                     if include_non_default == '0':
                         include_non_default = False
                     fileList = madWebObj.getFileFromExpID(expID, include_non_default)
                     fileList = [('0', 'Select file')] + fileList
                     fileSelection = getSelection('file_list', args, kwargs)
                     self.fields['file_list'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={"onChange":'changeFile(this)'}),
                                                                         choices=fileList, initial=fileSelection,
                                                                         required=False, label='Select file:')
                     if int(expID) != 0:
                         self.fields['exp_id'] = django.forms.CharField(initial=str(expID),
                                                                        widget=django.forms.HiddenInput(attrs={'value': str(expID)}),
                                                                        required=False,
                                                                        label=str(expID))
                         pi_name, pi_email, expUrl, kinst, expDesc, kinstDesc = madWebObj.getExpInfoFromExpID(int(expID))
                         self.fields['exp_desc'] = django.forms.CharField(initial=str(expDesc),
                                                                          widget=django.forms.HiddenInput(attrs={'value': str(expDesc)}),
                                                                          required=False,
                                                                          label=str(expDesc))
                         self.fields['user_email'] = django.forms.CharField(initial=str(user_email),
                                                                            widget=django.forms.HiddenInput(attrs={'value': str(user_email)}),
                                                                            required=False,
                                                                            label=str(user_email))
                         self.fields['inst_desc'] = django.forms.CharField(initial=str(kinstDesc),
                                                                            widget=django.forms.HiddenInput(attrs={'value': str(kinstDesc)}),
                                                                            required=False,
                                                                            label=str(kinstDesc))
                         self.fields['pi_name'] = django.forms.CharField(initial=pi_name,
                                                                        widget=django.forms.HiddenInput(attrs={'value': pi_name}),
                                                                        required=False,
                                                                        label=pi_name)
                         self.fields['pi_email'] = django.forms.CharField(initial=pi_email,
                                                                         widget=django.forms.HiddenInput(attrs={'value': pi_email}),
                                                                         required=False,
                                                                         label=pi_email)
                         self.fields['includeNonDefault'] = django.forms.BooleanField(widget = django.forms.CheckboxInput(attrs={"onChange":'reloadFiles(this)'}),
                                                                         required=False, label='Show non-default files: ',
                                                                         initial=include_non_default)
                         # handle any needed registration or unregistration
                         register = handle_registration(args[0], user_email, expUrl, kinst, madDB)
                         self.fields['register'] = django.forms.CharField(initial=register,
                                                                          widget=django.forms.HiddenInput(attrs={'value': register}),
                                                                          required=False,
                                                                          label=register)
                         if fileSelection != '0':
                             self.fields['file_buttons'] = django.forms.CharField(initial='',
                                                                                     widget=django.forms.HiddenInput(attrs={'value': ''}),
                                                                                     required=False,
                                                                                     label='')
                             self.fields['basename'] = django.forms.CharField(initial=str(fileSelection),
                                                                                widget=django.forms.HiddenInput(attrs={'value': str(fileSelection)}),
                                                                                required=False,
                                                                                label=str(fileSelection))
             class SingleExpButtonsForm(django.forms.Form):
                 """SingleExpButtonsForm is a Form class for the file buttons field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpButtonsForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                     madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                     expID = getSelection('experiment_list', args, kwargs)
                     try:
                         expID = int(expID)
                     except ValueError:
                         # convert expPath to expID
                         expID = madWebObj.getExpIDFromExpPath(expID, True)
                     fileSelection = getSelection('file_list', args, kwargs)
                     expDir = madExpObj.getExpDirByExpId(int(expID))
                     filesize = os.path.getsize(os.path.join(expDir, str(fileSelection)))
                     self.fields['file_buttons'] = django.forms.CharField(initial='',
                                                                             widget=django.forms.HiddenInput(attrs={'value': ''}),
                                                                             required=False,
                                                                             label='')
                     self.fields['exp_id'] = django.forms.CharField(initial=str(expID),
                                                                        widget=django.forms.HiddenInput(attrs={'value': str(expID)}),
                                                                        required=False,
                                                                        label=str(expID))
                     self.fields['basename'] = django.forms.CharField(initial=str(fileSelection),
                                                                        widget=django.forms.HiddenInput(attrs={'value': str(fileSelection)}),
                                                                        required=False,
                                                                        label=str(fileSelection))
                     self.fields['filesize'] = django.forms.IntegerField(initial=filesize,
                                                                        widget=django.forms.HiddenInput(attrs={'value': filesize}),
                                                                        required=False,
                                                                        label=str(filesize))
             class SingleExpPlotsForm(django.forms.Form):
                 """SingleExpPlotsForm is a Form class for the file data/show plots field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpPlotsForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                     madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                     expID = getSelection('experiment_list', args, kwargs)
                     try:
                         expID = int(expID)
                     except ValueError:
                         # convert expPath to expID
                         expID = madWebObj.getExpIDFromExpPath(expID, True)
                     plotList = madExpObj.getExpLinksByExpId(expID)
                     if len(plotList) == 0:
                         plotList = [('No plots available', '')]
                     self.fields['plot_list'] = django.forms.ChoiceField(widget = django.forms.Select(),
                                                                         choices=plotList,
                                                                         required=False)
+            '''get_params2 retrieves a list of 1d and 2d parameters of type 1 hdf5 files'''
+            def get_params1(args, kwargs, madExpObj, madWebObj):
+                expID = getSelection('experiment_list', args, kwargs)
+                expDir = madExpObj.getExpDirByExpId(expID)
+                fileList = madWebObj.getFileFromExpID(expID, False)
+                firsttuple = [a_tuple[0] for a_tuple in fileList]
+                basename = firsttuple[0]
+                fullFilename = os.path.join(expDir, basename)
+                f = h5py.File(fullFilename, "r")
+                data = f[list(f.keys())[0]]
+                array = data[list(data.keys())[0]]
+                param1d = array[list(array.keys())[0]]
+                param2d = array[list(array.keys())[1]]
+                paramch1d = list(param1d.keys())
+                paramch2d = list(param2d.keys())
+                dataparameters = param1d[list(param1d.keys())[0]]
+                paramch_mn_bin = list(dataparameters['mnemonic'])
+                paramch_bin = list(dataparameters['description'])
+                paramch_mn = list()
+                paramch = list()
+                for i in range(len(paramch_bin)):
+                    paramch_mn.append(paramch_mn_bin[i].decode("utf-8"))
+                    paramch.append(paramch_bin[i].decode("utf-8"))
+                choices1d = ['Select parameter']
+                for ch in paramch1d[1:]:
+                    aux = paramch[paramch_mn.index(ch.upper())]
+                    choices1d.append(aux)
+                dataparameters = param2d[list(param2d.keys())[0]]
+                paramch_mn_bin = list(dataparameters['mnemonic'])
+                paramch_mn = list()
+                paramch_bin = list(dataparameters['description'])
+                paramch = list()
+                for i in range(len(paramch_bin)):
+                    paramch_mn.append(paramch_mn_bin[i].decode("utf-8"))
+                    paramch.append(paramch_bin[i].decode("utf-8"))
+                choices2d = ['Select parameter']
+                for ch in paramch2d[1:]:
+                    aux = paramch[paramch_mn.index(ch.upper())]
+                    choices2d.append(aux)
+                choices = [choices1d,choices2d]
+                return choices
+            '''get params2 retrieves a list of 1d parameters of type 2 of hdf5 files'''
+            def get_params2(args, kwargs, madExpObj, madWebObj):
+                expID = getSelection('experiment_list', args, kwargs)
+                expDir = madExpObj.getExpDirByExpId(expID)
+                fileList = madWebObj.getFileFromExpID(expID, False)
+                firsttuple = [a_tuple[0] for a_tuple in fileList]
+                basename = firsttuple[0]
+                fullFilename = os.path.join(expDir, basename)
+                f = h5py.File(fullFilename, "r")
+                metadata = f[list(f.keys())[1]]
+                table = metadata[list(metadata.keys())[0]]
+                param_mn_bin = list(table['mnemonic'])
+                param_mn = list()
+                for p in param_mn_bin:
+                    param_mn.append(p.decode("utf"))
+                index = param_mn.index('UT2_UNIX')
+                params = list(table['description'])
+                choices = ['Select parameter']
+                for p in params[index+1:]:
+                    choices.append(p.decode("utf-8"))
+                return choices
+            class SingleExpPlotsSelectionForm(django.forms.Form):
+                """SingleExpPlotsSselectionForm is a Form class for the parameters selection for plotting in the Single Experiment interface.
+                Use this because its faster to create than the full SingleExpDefaultForm
+                """
+                def __init__(self, *args, **kwargs):
+                    super(SingleExpPlotsSelectionForm, self).__init__(*args, **kwargs)
+                    madDB = madrigal.metadata.MadrigalDB()
+                    madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
+                    madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
+                    expID = getSelection('experiment_list', args, kwargs)
+                    try:
+                        expID = int(expID)
+                    except ValueError:
+                        # convert expPath to expID
+                        expID = madWebObj.getExpIDFromExpPath(expID, True)
+                    expDir = madExpObj.getExpDirByExpId(expID)
+                    fileList = madWebObj.getFileFromExpID(expID, False)
+                    firsttuple = [a_tuple[0] for a_tuple in fileList]
+                    basename = firsttuple[0]
+                    fullFilename = os.path.join(expDir, basename)
+                    f = h5py.File(fullFilename, "r")
+                    data = f[list(f.keys())[0]]
+                    if 'Array Layout' in list(data.keys()):
+                        choices = get_params1(args, kwargs, madExpObj, madWebObj)
+                        params1d = choices[0]
+                        params2d = choices[1]
+                        index = list(range(len(params1d)))
+                        paramchoices1d = list(zip(index, params1d))
+                        index = list(range(len(params2d)))
+                        paramchoices2d = list(zip(index, params2d))
+                        self.fields['param_list2d'] = django.forms.ChoiceField(widget = django.forms.Select(), choices=paramchoices2d, label="2D Parameters", required=False)
+                    else:
+                        params1d = get_params2(args, kwargs, madExpObj, madWebObj)
+                        #if params1d[0] == 'ut2_unix':
+                         #   params1d[0] = 'Select parameter'
+                        index = list(range(len(params1d)))
+                        paramchoices1d = list(zip(index, params1d))
+                    self.fields['param_list1d'] = django.forms.ChoiceField(widget = django.forms.Select(), choices=paramchoices1d, label="1D Parameters", required=False)
             class SingleExpDownloadAsIsForm(django.forms.Form):
                 """SingleExpDownloadAsIsForm is a Form class for the download as is field in the Single Experiment interface.
                 Use this because its faster to create than the full SingleExpDefaultForm
                 """
                 def __init__(self, *args, **kwargs):
                     super(SingleExpDownloadAsIsForm, self).__init__(*args, **kwargs)
                     basename = getSelection('format_select', args, kwargs)
                     expID = int(getSelection('expID', args, kwargs))
                     formatChoices = getFormatChoices(basename, expID)
                     self.fields['format_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(attrs={"onChange":'changeFormat(this)'}),
                                                                             choices=formatChoices,
                                                                             required=False)
             class IsprintChoiceField(django.forms.TypedMultipleChoiceField):
                 """IsprintChoiceField is subclass of TypedMultipleChoiceField
                 """
                 def __init__(self, *args, **kwargs):
                     """__init__ allows all the arguments of TypedMultipleChoiceField, plus extra
                     keyword arguments:
                         madWebObject  madrigal.ui.web.MadrigalWeb object
                     """
                     self.isDerivedDict = kwargs.pop('isDerivedDict')
                     self.parmDescDict = kwargs.pop('parmDescDict')
                     try:
                         self.separateProlog = kwargs.pop('separateProlog')
                     except:
                         self.separateProlog = False
                     kwargs['widget'] = IsprintWidget(attrs={'isDerivedDict':self.isDerivedDict,
                                                             'parmDescDict':self.parmDescDict,
                                                             'separateProlog':self.separateProlog})
                     super(IsprintChoiceField, self).__init__(*args, **kwargs)
                     self.widget.set_parm_lists(self.isDerivedDict, self.parmDescDict, self.separateProlog)
             class IsprintWidget(django.forms.CheckboxSelectMultiple):
                 """IsprintWidget is a subclass of CheckboxSelectMultiple with additional parameters passed in
                 to modify rendering
                 """
                 def __init__(self, *args, **kwargs):
                     """__init__ allows all the arguments of CheckboxSelectMultiple, plus extra
                     keyword arguments:
                         madWebObject  madrigal.ui.web.MadrigalWeb object
                     """
                     super(IsprintWidget, self).__init__(*args, **kwargs)
                     self.renderer = django.forms.CheckboxSelectMultiple
                     self.template_name = 'madweb/parameter_multiple.html'
                 def set_parm_lists(self, isDerivedDict, parmDescDict, separateProlog=False):
                     """set_parm_lists sets class variables used by the html renderer
                     measParmList - parms in the file
                     derivedParmList - parms derivable
                     allParmList - above lists combined
                     separateProlog - if true, create separate div tags so prolog parms can be hidden or not.
                         Default is False, in which case no div tags are used
                     """
                     self.renderer.isDerivedDict = isDerivedDict
                     self.renderer.parmDescDict = parmDescDict
                     self.renderer.iterator = itertools.count()
                     self.renderer.separateProlog = separateProlog
             class IsprintForm(django.forms.Form):
                 """IsprintForm is the form for the enhanced isprint page
                 """
                 def __init__(self, *args, **kwargs):
                     madFileObj = getSelection('madFileObj', args, kwargs)
                     type = getSelection('type', args, kwargs)
                     formatChoices = [('ascii', 'Space-delimited ascii')]
                     if type == 'download':
                         formatChoices.insert(0, ('netCDF4', 'netCDF4'))
                         formatChoices.insert(0, ('Hdf5', 'Hdf5'))
                         separateProlog = True
                     else:
                         separateProlog = False
                     madDB = getSelection('madDB', args, kwargs)
                     madParmObj = getSelection('madParmObj', args, kwargs)
                     derivedParmList = getSelection('derivedParmList', args, kwargs)
                     allParmList = getSelection('allParmList', args, kwargs)
                     allParmDescList = getSelection('allParmDescList', args, kwargs)
                     self.parmList = list(zip(allParmList, allParmDescList))
                     super(IsprintForm, self).__init__(*args, **kwargs)
                     madCatObj = madrigal.metadata.MadrigalParmCategory(madDB)
                     catList = madCatObj.getCategoryList()
                     catDict = madParmObj.getCategoryDict(allParmList)
                     choices = []
                     isDerivedDict = {}
                     parmDescDict = {}
                     for catDesc, catID in catList:
                         if catID not in list(catDict.keys()):
                             continue
                         theseParms = []
                         for parm in catDict[catID][1]:
                             theseParms.append((parm, parm))
                             if parm in derivedParmList:
                                 isDerivedDict[parm] = True
                             else:
                                 isDerivedDict[parm] = False
                             parmDescDict[parm] = madParmObj.getParmDescription(parm)
                         choices.append((catDesc, theseParms))
                     choices_with_null = [('None', 'None')] + choices
                     earliestTime = madFileObj.getEarliestTime()
                     latestTime = madFileObj.getLatestTime()
                     earliestDT = datetime.datetime(*earliestTime)
                     latestDT = datetime.datetime(*latestTime)
                     earliestStr = earliestDT.strftime('%Y-%m-%d %H:%M:%S')
                     latestStr = latestDT.strftime('%Y-%m-%d %H:%M:%S')
                     self.fields['fullFilename'] = django.forms.CharField(required=False, widget=django.forms.HiddenInput())
                     self.fields['type'] = django.forms.CharField(required=False, widget=django.forms.HiddenInput())
                     # format fields
                     self.fields['formats'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(attrs={"onChange":'changeFormat(this)'}),
                                                                       choices=formatChoices, initial='ascii',
                                                                       required=False, label='Select output format:')
                     self.fields['showHeaders'] = django.forms.BooleanField(required=False, label='Show headers:',
                                                                            help_text="Select this to show a header line before each record")
                     self.fields['missing'] = django.forms.CharField(required=False,
                                                                     label='Missing value string: ',
                                                                     help_text='Modify this field to display something other than NaN for missing or assumed or known bad data.')
                     # form fields
                     self.fields['parameters'] = IsprintChoiceField(choices=choices,
                                                                    required=False,
                                                                    initial=['YEAR', 'MIN'],
                                                                    isDerivedDict=isDerivedDict,
                                                                    parmDescDict=parmDescDict,
                                                                    separateProlog=separateProlog,
                                                                    label = "")
                     # time selection
                     self.fields['start_date'] = django.forms.DateTimeField(input_formats=['%Y-%m-%dT%H:%M:%S'],
                                                                            label='Start datetime',
                                                                            help_text='Modify this field to remove all records before this start time.  Initial start datetime is the time of the first record.',
                                                                            widget=django.forms.DateTimeInput(format='%Y-%m-%dT%H:%M:%S'),
                                                                            required=False)
                     self.fields['end_date'] = django.forms.DateTimeField(input_formats=['%Y-%m-%dT%H:%M:%S'],
                                                                          label='End datetime',
                                                                          help_text='Modify this field to remove all records after this end time.  Initial end datetime is the time of the last record.',
                                                                          widget=django.forms.DateTimeInput(format='%Y-%m-%dT%H:%M:%S'),
                                                                          required=False)
                     self.fields['parm_1'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_1_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_1_upper'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_2'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_2_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_2_upper'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_3'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_3_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_3_upper'] = django.forms.CharField(required=False, initial='')
                     # add optional fields
                     if 'GDALT' in allParmList:
                         min_alt_value = getSelection('min_alt', args, kwargs)
                         max_alt_value = getSelection('max_alt', args, kwargs)
                         if min_alt_value != max_alt_value:
                             self.fields['min_alt'] = django.forms.CharField(required=False,
                                                                             label='Min altitude:',
                                                                             help_text='Modify this field to remove all data with altitudes below this level.')
                             self.fields['max_alt'] = django.forms.CharField(required=False,
                                                                             label='Max altitude:',
                                                                             help_text='Modify this field to remove all data with altitudes above this level.')
                     if 'AZM' in allParmList:
                         self.fields['min_az'] = django.forms.CharField(required=False,
                                                                        label='Min azimuth:',
                                                                        help_text='Modify this field to remove all azimuths (-180 to 180) below this value. You can also have two separate azimuth ranges by using the Azimuth 2 fields.')
                         self.fields['max_az'] = django.forms.CharField(required=False,
                                                                         label='Max azimuth:',
                                                                         help_text='Modify this field to remove all azimuths (-180 to 180) above this value. You can also have two separate azimuth ranges by using the Azimuth 2 fields.')
                         self.fields['min_az2'] = django.forms.CharField(required=False,
                                                                         label='Min azimuth 2:',
                                                                         help_text='Modify this field to have a second allowed azimuth range. This would set the lower limit of the second range.')
                         self.fields['max_az2'] = django.forms.CharField(required=False,
                                                                         label='Max azimuth 2:',
                                                                         help_text='Modify this field to have a second allowed azimuth range. This would set the upper limit of the second range.')
                     if 'ELM' in allParmList:
                         self.fields['min_el'] = django.forms.CharField(required=False,
                                                                        label='Min elevation:',
                                                                        help_text='Modify this field to remove all elevations (0 to 90) below this value. You can also have two separate elevations ranges by using the Elevations 2 fields.')
                         self.fields['max_el'] = django.forms.CharField(required=False,
                                                                         label='Max elevation:',
                                                                         help_text='Modify this field to remove all elevations (0 to 90) above this value. You can also have two separate elevations ranges by using the Elevations 2 fields.')
                         self.fields['min_el2'] = django.forms.CharField(required=False,
                                                                         label='Min elevation 2:',
                                                                         help_text='Modify this field to have a second allowed elevation range. This would set the lower limit of the second range.')
                         self.fields['max_el2'] = django.forms.CharField(required=False,
                                                                         label='Max elevation 2:',
                                                                         help_text='Modify this field to have a second allowed elevation range. This would set the upper limit of the second range.')
                     if 'PL' in allParmList:
                         min_pl_value = getSelection('min_pl', args, kwargs)
                         max_pl_value = getSelection('max_pl', args, kwargs)
                         self.fields['min_pl'] = django.forms.CharField(required=False,
                                                                        label='Min pulse len (microsec): ',
                                                                        help_text='Modify this field to remove all pulse lengths in microsecs below this value.')
                         self.fields['max_pl'] = django.forms.CharField(required=False,
                                                                         label='Max pulse len (microsec): ',
                                                                         help_text='Modify this field to remove all pulse lengths in microsecs above this value.')
                 def clean_fullFilename(self):
                     fullFilename = self.cleaned_data['fullFilename']
                     # make sure the file exists
                     if not os.access(fullFilename, os.R_OK):
                         raise django.forms.ValidationError('Invalid filename: %(value)s cannot be opened',
                                                            code='io_error',
                                                            params={'value': fullFilename})
                     return(fullFilename)
                 def clean_formats(self):
                     formats = self.cleaned_data['formats']
                     # make sure the format valid
                     if formats not in ('Hdf5', 'netCDF4', 'ascii'):
                         raise django.forms.ValidationError('Invalid format: %(value)s not legal format',
                                                            code='invalid',
                                                            params={'value': formats})
                     return(formats)
                 def clean_min_alt(self):
                     min_alt = self.cleaned_data['min_alt']
                     if len(min_alt) != 0:
                         try:
                             min_alt_value = float(min_alt)
                         except:
                             raise django.forms.ValidationError('Invalid minimum altitude: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_alt})
                         if min_alt_value < 0.0:
                             raise django.forms.ValidationError('Invalid minimum altitude: %(value)s cannot be less than 0.0 kilometers',
                                                                code='invalid',
                                                                params={'value': min_alt})
                     return(min_alt)
                 def clean_max_alt(self):
                     max_alt = self.cleaned_data['max_alt']
                     if len(max_alt) != 0:
                         try:
                             max_alt_value = float(max_alt)
                         except:
                             raise django.forms.ValidationError('Invalid maximum altitude: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_alt})
                         if max_alt_value < 0.0:
                             raise django.forms.ValidationError('Invalid maximum altitude: %(value)s cannot be less than 0.0 kilometers',
                                                                code='invalid',
                                                                params={'value': max_alt})
                     return(max_alt)
                 def clean_min_az(self):
                     min_az = self.cleaned_data['min_az']
                     if len(min_az) != 0:
                         try:
                             min_az_value = float(min_az)
                         except:
                             raise django.forms.ValidationError('Invalid minimum azimuth: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_az})
                         if min_az_value < -180.0:
                             raise django.forms.ValidationError('Invalid minimum azimuth: %(value)s cannot be less than -180 degrees',
                                                                code='invalid',
                                                                params={'value': min_az})
                         if min_az_value > 180.0:
                             raise django.forms.ValidationError('Invalid minimum azimuth: %(value)s cannot be more than 180 degrees',
                                                                code='invalid',
                                                                params={'value': min_az})
                     return(min_az)
                 def clean_max_az(self):
                     max_az = self.cleaned_data['max_az']
                     if len(max_az) != 0:
                         try:
                             max_az_value = float(max_az)
                         except:
                             raise django.forms.ValidationError('Invalid maximum azimuth: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_az})
                         if max_az_value < -180.0:
                             raise django.forms.ValidationError('Invalid maximum azimuth: %(value)s cannot be less than -180 degrees',
                                                                code='invalid',
                                                                params={'value': max_az})
                         if max_az_value > 180.0:
                             raise django.forms.ValidationError('Invalid maximum azimuth: %(value)s cannot be more than 180 degrees',
                                                                code='invalid',
                                                                params={'value': max_az})
                     return(max_az)
                 def clean_min_el(self):
                     min_el = self.cleaned_data['min_el']
                     if len(min_el) != 0:
                         try:
                             min_el_value = float(min_el)
                         except:
                             raise django.forms.ValidationError('Invalid minimum elevation: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_el})
                         if min_el_value < 0.0:
                             raise django.forms.ValidationError('Invalid minimum elevation: %(value)s cannot be less than 0 degrees',
                                                                code='invalid',
                                                                params={'value': min_el})
                         if min_el_value > 90.0:
                             raise django.forms.ValidationError('Invalid minimum elevation: %(value)s cannot be more than 90 degrees',
                                                                code='invalid',
                                                                params={'value': min_el})
                     return(min_el)
                 def clean_max_el(self):
                     max_el = self.cleaned_data['max_el']
                     if len(max_el) != 0:
                         try:
                             max_el_value = float(max_el)
                         except:
                             raise django.forms.ValidationError('Invalid maximum elevation: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_el})
                         if max_el_value < 0.0:
                             raise django.forms.ValidationError('Invalid maximum elevation: %(value)s cannot be less than 0 degrees',
                                                                code='invalid',
                                                                params={'value': max_el})
                         if max_el_value > 90.0:
                             raise django.forms.ValidationError('Invalid maximum elevation: %(value)s cannot be more than 90 degrees',
                                                                code='invalid',
                                                                params={'value': max_el})
                     return(max_el)
                 def clean_min_az2(self):
                     min_az2 = self.cleaned_data['min_az2']
                     if len(min_az2) != 0:
                         try:
                             min_az2_value = float(min_az2)
                         except:
                             raise django.forms.ValidationError('Invalid minimum azimuth 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_az2})
                         if min_az2_value < -180.0:
                             raise django.forms.ValidationError('Invalid minimum azimuth 2: %(value)s cannot be less than -180 degrees',
                                                                code='invalid',
                                                                params={'value': min_az2})
                         if min_az2_value > 180.0:
                             raise django.forms.ValidationError('Invalid minimum azimuth 2: %(value)s cannot be more than 180 degrees',
                                                                code='invalid',
                                                                params={'value': min_az2})
                     return(min_az2)
                 def clean_max_az2(self):
                     max_az2 = self.cleaned_data['max_az2']
                     if len(max_az2) != 0:
                         try:
                             max_az2_value = float(max_az2)
                         except:
                             raise django.forms.ValidationError('Invalid maximum azimuth 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_az2})
                         if max_az2_value < -180.0:
                             raise django.forms.ValidationError('Invalid maximum azimuth 2: %(value)s cannot be less than -180 degrees',
                                                                code='invalid',
                                                                params={'value': max_az2})
                         if max_az2_value > 180.0:
                             raise django.forms.ValidationError('Invalid maximum azimuth 2: %(value)s cannot be more than 180 degrees',
                                                                code='invalid',
                                                                params={'value': max_az2})
                     return(max_az2)
                 def clean_min_el2(self):
                     min_el2 = self.cleaned_data['min_el2']
                     if len(min_el2) != 0:
                         try:
                             min_el2_value = float(min_el2)
                         except:
                             raise django.forms.ValidationError('Invalid minimum elevation 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_el2})
                         if min_el2_value < 0.0:
                             raise django.forms.ValidationError('Invalid minimum elevation 2: %(value)s cannot be less than 0 degrees',
                                                                code='invalid',
                                                                params={'value': min_el2})
                         if min_el2_value > 90.0:
                             raise django.forms.ValidationError('Invalid minimum elevation 2: %(value)s cannot be more than 90 degrees',
                                                                code='invalid',
                                                                params={'value': min_el2})
                     return(min_el2)
                 def clean_max_el2(self):
                     max_el2 = self.cleaned_data['max_el2']
                     if len(max_el2) != 0:
                         try:
                             max_el2_value = float(max_el2)
                         except:
                             raise django.forms.ValidationError('Invalid maximum elevation 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_el2})
                         if max_el2_value < 0.0:
                             raise django.forms.ValidationError('Invalid maximum elevation 2: %(value)s cannot be less than 0 degrees',
                                                                code='invalid',
                                                                params={'value': max_el2})
                         if max_el2_value > 90.0:
                             raise django.forms.ValidationError('Invalid maximum elevation 2: %(value)s cannot be more than 90 degrees',
                                                                code='invalid',
                                                                params={'value': max_el2})
                     return(max_el2)
                 def clean_min_pl(self):
                     min_pl = self.cleaned_data['min_pl']
                     if len(min_pl) != 0:
                         try:
                             min_pl_value = float(min_pl)
                         except:
                             raise django.forms.ValidationError('Invalid lower limit for pulse length: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': min_pl})
                     return(min_pl)
                 def clean_max_pl(self):
                     max_pl = self.cleaned_data['max_pl']
                     if len(max_pl) != 0:
                         try:
                             max_pl_value = float(max_pl)
                         except:
                             raise django.forms.ValidationError('Invalid upper limit for pulse length: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': max_pl})
                     return(max_pl)
                 def clean_parm_1_lower(self):
                     parm_1_lower = self.cleaned_data['parm_1_lower']
                     if len(parm_1_lower) != 0:
                         try:
                             parm_1_lower_value = float(parm_1_lower)
                         except:
                             raise django.forms.ValidationError('Invalid lower limit for parm 1: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_1_lower})
                     return(parm_1_lower)
                 def clean_parm_1_upper(self):
                     parm_1_upper = self.cleaned_data['parm_1_upper']
                     if len(parm_1_upper) != 0:
                         try:
                             parm_1_upper_value = float(parm_1_upper)
                         except:
                             raise django.forms.ValidationError('Invalid upper limit for parm 1: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_1_upper})
                     return(parm_1_upper)
                 def clean_parm_2_lower(self):
                     parm_2_lower = self.cleaned_data['parm_2_lower']
                     if len(parm_2_lower) != 0:
                         try:
                             parm_2_lower_value = float(parm_2_lower)
                         except:
                             raise django.forms.ValidationError('Invalid lower limit for parm 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_2_lower})
                     return(parm_2_lower)
                 def clean_parm_2_upper(self):
                     parm_2_upper = self.cleaned_data['parm_2_upper']
                     if len(parm_2_upper) != 0:
                         try:
                             parm_2_upper_value = float(parm_2_upper)
                         except:
                             raise django.forms.ValidationError('Invalid upper limit for parm 2: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_2_upper})
                     return(parm_2_upper)
                 def clean_parm_3_lower(self):
                     parm_3_lower = self.cleaned_data['parm_3_lower']
                     if len(parm_3_lower) != 0:
                         try:
                             parm_3_lower_value = float(parm_3_lower)
                         except:
                             raise django.forms.ValidationError('Invalid lower limit for parm 3: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_3_lower})
                     return(parm_3_lower)
                 def clean_parm_3_upper(self):
                     parm_3_upper = self.cleaned_data['parm_3_upper']
                     if len(parm_3_upper) != 0:
                         try:
                             parm_3_upper_value = float(parm_3_upper)
                         except:
                             raise django.forms.ValidationError('Invalid upper limit for parm 3: %(value)s cannot be converted to a float',
                                                                code='invalid',
                                                                params={'value': parm_3_upper})
                     return(parm_3_upper)
                 def clean(self):
                     """clean in the Django method to validate things in a form that require looking at multiple fields
                     """
                     # rule 1 - start_date < end_date
                     if self.cleaned_data['start_date'] > self.cleaned_data['end_date']:
                         raise django.forms.ValidationError('Error - start datetime greater than end datetime.')
                     # rule 2 - min_alt <= max_alt
                     try:
                         min_alt = float(self.cleaned_data['min_alt'])
                         max_alt = float(self.cleaned_data['max_alt'])
                     except:
                         min_alt = 0.0
                         max_alt = 1.0
                     if min_alt > max_alt:
                         raise django.forms.ValidationError('Error - Minimum altitude greater than maximum altitude.')
                     # rule 3 - min_az <= max_az
                     try:
                         min_az = float(self.cleaned_data['min_az'])
                         max_az = float(self.cleaned_data['max_az'])
                     except:
                         min_az = 0.0
                         max_az = 1.0
                     if min_az > max_az:
                         raise django.forms.ValidationError('Error - Minimum azimuth greater than maximum azimuth.')
                     # rule 4 - min_el <= max_el
                     try:
                         min_el = float(self.cleaned_data['min_el'])
                         max_el = float(self.cleaned_data['max_el'])
                     except:
                         min_el = 0.0
                         max_el = 1.0
                     if min_el > max_el:
                         raise django.forms.ValidationError('Error - Minimum elevation greater than maximum elevation.')
                     # rule 5 - min_az2 <= max_az2
                     try:
                         min_az2 = float(self.cleaned_data['min_az2'])
                         max_az2 = float(self.cleaned_data['max_az2'])
                     except:
                         min_az2 = 0.0
                         max_az2 = 1.0
                     if min_az2 > max_az2:
                         raise django.forms.ValidationError('Error - Minimum azimuth 2 greater than maximum azimuth 2.')
                     # rule 6 - min_el2 <= max_el2
                     try:
                         min_el2 = float(self.cleaned_data['min_el2'])
                         max_el2 = float(self.cleaned_data['max_el2'])
                     except:
                         min_el2 = 0.0
                         max_el2 = 1.0
                     if min_el2 > max_el2:
                         raise django.forms.ValidationError('Error - Minimum elevation 2 greater than maximum elevation 2.')
                     # rule 7 - min_pl <= max_pl
                     try:
                         min_pl = float(self.cleaned_data['min_pl'])
                         max_pl = float(self.cleaned_data['max_pl'])
                     except:
                         min_pl = 0.0
                         max_pl = 1.0
                     if min_pl > max_pl:
                         raise django.forms.ValidationError('Error - Minimum pulse length greater than maximum pulse length.')
                     # rule 8 - parm_1_lower <= parm_1_upper
                     try:
                         parm_1_lower = float(self.cleaned_data['parm_1_lower'])
                         parm_1_upper = float(self.cleaned_data['parm_1_upper'])
                     except:
                         parm_1_lower = 0.0
                         parm_1_upper = 1.0
                     if parm_1_lower > parm_1_upper:
                         raise django.forms.ValidationError('Error - parm 1 lower limit greater than upper limit.')
                     # rule 9 - parm_2_lower <= parm_2_upper
                     try:
                         parm_2_lower = float(self.cleaned_data['parm_2_lower'])
                         parm_2_upper = float(self.cleaned_data['parm_2_upper'])
                     except:
                         parm_2_lower = 0.0
                         parm_2_upper = 1.0
                     if parm_2_lower > parm_2_upper:
                         raise django.forms.ValidationError('Error - parm 2 lower limit greater than upper limit.')
                     # rule 10 - parm_3_lower <= parm_3_upper
                     try:
                         parm_3_lower = float(self.cleaned_data['parm_3_lower'])
                         parm_3_upper = float(self.cleaned_data['parm_3_upper'])
                     except:
                         parm_3_lower = 0.0
                         parm_3_upper = 1.0
                     if parm_3_lower > parm_3_upper:
                         raise django.forms.ValidationError('Error - parm 3 lower limit greater than upper limit.')
             class ListExpForm(django.forms.Form):
                 """ListExpForm is a Form class for the default fields in the List Experiment interface
                 """
                 def __init__(self, *args, **kwargs):
                     super(ListExpForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     isGlobal = True # default load
                     now = datetime.datetime.now()
                     endDateTime = datetime.datetime(now.year, 12, 31, 23, 59, 59)
                     self.fields['isGlobal'] = django.forms.BooleanField(widget = django.forms.CheckboxInput(attrs={"onChange":'changeGlobal(this.form)'}),
                                                                         required=False, label='Use all Madrigal sites: ',
                                                                         initial=isGlobal)
                     categoriesSelection = '0'
                     self.fields['categories'] = django.forms.MultipleChoiceField(widget=django.forms.SelectMultiple(attrs={"onChange":"updateInstruments(this.form)"}),
                                                                                  choices=getCategoryList(args, kwargs, madInstData, True),
                                                                                  initial='0',
                                                                                  label='Choose instrument category(s):')
                     self.fields['instruments'] = django.forms.MultipleChoiceField(widget = django.forms.SelectMultiple(),
                                                                                   choices=getInstrumentList(args, kwargs, madInstData, 'All instruments', local=False, includeYears=True),
                                                                                   initial='0', label='Choose instrument(s)')
                     self.fields['showDefault'] = django.forms.BooleanField(widget = django.forms.CheckboxInput(),
                                                                            label='Show only default files: ',
                                                                            initial=True)
                     # time selection
                     self.fields['start_date'] = django.forms.SplitDateTimeField(input_date_formats=['%Y-%m-%d'], input_time_formats=['%H:%M:%S'],
                                                                               label='Start date',
                                                                               help_text='Modify this field to select experiments after this start time.',
                                                                               initial=datetime.datetime(1950,1,1))
                     self.fields['end_date'] = django.forms.SplitDateTimeField(input_date_formats=['%Y-%m-%d'], input_time_formats=['%H:%M:%S'],
                                                                               label='End date',
                                                                               help_text='Modify this field to select experiments before this end time.',
                                                                               initial=endDateTime)
                     # attributes to support javascript
                     local_categories = madInstData.getCategories(True)
                     global_categories = madInstData.getCategories(False)
                     local_category_ids = [cat[0] for cat in local_categories]
                     self.categories = [] # each item a tuple of (category description, category id, global only js bool)
                     self.instruments = [] # each item a tiple of (instrument desc, category id, kinst, local start year, local end year, global sy, global ey)
                     for id, desc in global_categories:
                         if id in local_category_ids:
                             localBool = 'false'
                         else:
                             localBool = 'true'
                         self.categories.append((desc, id, localBool))
                         for kinst, instDesc, siteId in madInstData.getInstruments(id):
                             if siteId == madDB.getSiteID():
                                 localInst = True
                             else:
                                 localInst = False
                             yearList = madInstData.getInstrumentYears(kinst)
                             if localInst:
                                 self.instruments.append((instDesc, id, kinst, yearList[0], yearList[-1], yearList[0], yearList[-1]))
                             else:
                                 self.instruments.append((instDesc, id, kinst, 0, 0, yearList[0], yearList[-1]))
                 def clean(self):
                     """clean in the Django method to validate things in a form that require looking at multiple fields
                     """
                     # rule 1 - start_date < end_date
                     if self.cleaned_data['start_date'] > self.cleaned_data['end_date']:
                         raise django.forms.ValidationError('Error - start datetime greater than end datetime.')
             class DownloadAsIsScriptForm(django.forms.Form):
                 """DownloadAsIsScriptForm is a Form class for the default fields in the download files as is script generator interface
                 """
                 def __init__(self, *args, **kwargs):
                     super(DownloadAsIsScriptForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                     madInstKindatObj = madrigal.metadata.MadrigalInstrumentKindats(madDB)
                     now = datetime.datetime.now()
                     endDateTime = datetime.datetime(now.year, 12, 31, 23, 59, 59)
                     kwargs['isGlobal'] = '0'
                     formatChoices = (('hdf5', 'Hdf5'), ('ascii', 'Space-delimited ascii'), ('netCDF4', 'netCDF4'))
                     languageChoices = (('python', 'python'), ('Matlab', 'Matlab'), ('IDL', 'IDL'))
                     categoriesSelection = '0'
                     self.fields['categories'] = django.forms.ChoiceField(widget=django.forms.Select(attrs={"onChange":"updateInstruments(this.form)"}),
                                                                         choices=getCategoryList(args, kwargs, madInstData),
                                                                         initial='0',
                                                                         label='Choose an instrument category if desired:')
                     self.fields['instruments'] = django.forms.ChoiceField(widget=django.forms.Select(attrs={"onChange":"updateKindats(this.form)"}),
                                                                           choices=getInstrumentList(args, kwargs, madInstData, local=True, includeYears=True),
                                                                           initial='0', label='Choose one instrument')
                     # time selection
                     self.fields['start_date'] = django.forms.DateField(input_formats=['%Y-%m-%d'],
                                                                                 label='Start date',
                                                                                 help_text='Modify this field to select experiments after this start time.',
                                                                                 initial=datetime.datetime(1950,1,1))
                     self.fields['end_date'] = django.forms.DateField(input_formats=['%Y-%m-%d'],
                                                                               label='End date',
                                                                               help_text='Modify this field to select experiments before this end time.',
                                                                               initial=endDateTime)
                     self.fields['format_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(),
                                                                             choices=formatChoices,
                                                                             initial=formatChoices[0][0],
                                                                             label='File format to download:')
                     self.fields['language_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(),
                                                                                 choices=languageChoices,
                                                                                 initial=languageChoices[0][0],
                                                                                 label='Choose scripting language:')
                     choices=(('0', 'Select an instrument first to see list'),)
                     if len(args) > 0:
                         if 'kindat_select' in args[0]:
                             choices = [(kindat, kindat) for kindat in args[0].getlist('kindat_select')]
                     self.fields['kindat_select'] = django.forms.MultipleChoiceField(choices=choices,
                                                                                     initial='0',
                                                                                     label='Choose one or more kinds of data:',
                                                                                     required=False)
                     self.fields['kindat_select'].widget.attrs['style']="max-width:100%;"
                     self.fields['expName'] = django.forms.CharField(max_length=256, required=False)
                     self.fields['fileDesc'] = django.forms.CharField(max_length=256, required=False)
                     # attributes to support javascript
                     local_categories = madInstData.getCategories(True)
                     local_category_ids = [cat[0] for cat in local_categories]
                     self.categories = [] # each item a tuple of (category description, category id, global only js bool)
                     self.instruments = [] # each item a tiple of (instrument desc, category id, kinst, local start year, local end year)
                     self.kindats = [] # each item is a tuple of (kindat, kindatDesc, kinst)
                     for id, desc in local_categories:
                         self.categories.append((desc, id))
                         for kinst, instDesc, siteId in madInstData.getInstruments(id):
                             if siteId != madDB.getSiteID():
                                 continue
                             yearList = madInstData.getInstrumentYears(kinst)
                             self.instruments.append((instDesc, id, kinst, yearList[0], yearList[-1]))
                             kindatList = madInstKindatObj.getKindatListForInstruments([kinst])
                             for kindat in kindatList:
                                 self.kindats.append((kindat, madKindatObj.getKindatDescription(kindat, kinst),
                                                      kinst))
                 def clean(self):
                     """clean is the Django method to validate things in a form that require looking at multiple fields
                     """
                     # rule 1 - start_date < end_date
                     if self.cleaned_data['start_date'] > self.cleaned_data['end_date']:
                         raise django.forms.ValidationError('Error - start datetime greater than end datetime.')
             class DownloadAdvancedScriptForm(django.forms.Form):
                 """DownloadAdvancedScriptForm is a Form class for the default fields in the download advanced script generator interface
                 """
                 def __init__(self, *args, **kwargs):
                     super(DownloadAdvancedScriptForm, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                     madInstKindatObj = madrigal.metadata.MadrigalInstrumentKindats(madDB)
                     now = datetime.datetime.now()
                     endDateTime = datetime.datetime(now.year, 12, 31, 23, 59, 59)
                     kwargs['isGlobal'] = '0'
                     formatChoices = (('hdf5', 'Hdf5'), ('ascii', 'Space-delimited ascii'), ('netCDF4', 'netCDF4'))
                     directoryChoices = (('Directory', 'Directory'), ('File', 'File'))
                     languageChoices = (('python', 'python'), ('Matlab', 'Matlab'), ('IDL', 'IDL'))
                     categoriesSelection = '0'
                     self.fields['categories'] = django.forms.ChoiceField(widget=django.forms.Select(attrs={"onChange":"updateInstruments(this.form)"}),
                                                                         choices=getCategoryList(args, kwargs, madInstData),
                                                                         initial='0',
                                                                         label='Choose an instrument category if desired:')
                     self.fields['instruments'] = django.forms.ChoiceField(widget=django.forms.Select(attrs={"onChange":"updateParmsKindats(this.form)"}),
                                                                           choices=getInstrumentList(args, kwargs, madInstData, local=True, includeYears=True),
                                                                           initial='0', label='Choose one instrument')
                     # time selection
                     self.fields['start_date'] = django.forms.DateField(input_formats=['%Y-%m-%d'],
                                                                                 label='Start date',
                                                                                 help_text='Modify this field to select experiments after this start time.',
                                                                                 initial=datetime.datetime(1950,1,1))
                     self.fields['end_date'] = django.forms.DateField(input_formats=['%Y-%m-%d'],
                                                                               label='End date',
                                                                               help_text='Modify this field to select experiments before this end time.',
                                                                               initial=endDateTime)
                     self.fields['format_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(attrs={"onChange":'changeFormat(this)'}),
                                                                             choices=formatChoices,
                                                                             initial=formatChoices[0][0],
                                                                             label='File format to download:')
                     self.fields['directory_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(),
                                                                                choices=directoryChoices,
                                                                                initial=directoryChoices[0][0],
                                                                                label='If ascii, download result to:')
                     self.fields['language_select'] = django.forms.ChoiceField(widget = HorizontalRadioSelect(),
                                                                                 choices=languageChoices,
                                                                                 initial=languageChoices[0][0],
                                                                                 label='Choose scripting language:')
                     choices=(('0', 'Select an instrument first to see list'),)
                     if len(args) > 0:
                         if 'kindat_select' in args[0]:
                             choices = [(kindat, kindat) for kindat in args[0].getlist('kindat_select')]
                     self.fields['kindat_select'] = django.forms.MultipleChoiceField(choices=choices,
                                                                                     initial='0',
                                                                                     label='Choose one or more kinds of data:',
                                                                                     required=False)
                     self.fields['kindat_select'].widget.attrs['style']="max-width:100%;"
                     self.fields['expName'] = django.forms.CharField(max_length=256, required=False)
                     self.fields['fileDesc'] = django.forms.CharField(max_length=256, required=False)
                     self.fields['seasonalStartDay'] = django.forms.IntegerField(min_value=1, max_value=31, initial=1)
                     self.fields['seasonalStartMonth'] = django.forms.IntegerField(min_value=1, max_value=12, initial=1)
                     self.fields['seasonalEndDay'] = django.forms.IntegerField(min_value=1, max_value=31, initial=31)
                     self.fields['seasonalEndMonth'] = django.forms.IntegerField(min_value=1, max_value=12, initial=12)
                     # attributes to support javascript
                     local_categories = madInstData.getCategories(True)
                     local_category_ids = [cat[0] for cat in local_categories]
                     self.categories = [] # each item a tuple of (category description, category id, global only js bool)
                     self.instruments = [] # each item a tiple of (instrument desc, category id, kinst, local start year, local end year)
                     self.kindats = [] # each item is a tuple of (kindat, kindatDesc, kinst)
                     for id, desc in local_categories:
                         self.categories.append((desc, id))
                         for kinst, instDesc, siteId in madInstData.getInstruments(id):
                             if siteId != madDB.getSiteID():
                                 continue
                             yearList = madInstData.getInstrumentYears(kinst)
                             self.instruments.append((instDesc, id, kinst, yearList[0], yearList[-1]))
                             kindatList = madInstKindatObj.getKindatListForInstruments([kinst])
                             for kindat in kindatList:
                                 self.kindats.append((kindat, madKindatObj.getKindatDescription(kindat, kinst),
                                                      kinst))
                 def clean(self):
                     """clean is the Django method to validate things in a form that require looking at multiple fields
                     """
                     # rule 1 - start_date < end_date
                     if self.cleaned_data['start_date'] > self.cleaned_data['end_date']:
                         raise django.forms.ValidationError('Error - start datetime greater than end datetime.')
                     # rule 2 - seasonal start must be before seasonal end
                     if ((self.cleaned_data['seasonalStartDay'] + 31*self.cleaned_data['seasonalStartMonth']) > \
                         (self.cleaned_data['seasonalEndDay'] + 31*self.cleaned_data['seasonalEndMonth'])):
                         raise django.forms.ValidationError('Error - seasonal start after seasonal end.')
             class AdvScriptParmsForm(django.forms.Form):
                 """AdvScriptParmsForm is the form for the parameters
                 """
                 def __init__(self, *args, **kwargs):
                     kinst = int(getSelection('instruments', args, kwargs))
                     if kinst == 0:
                         raise ValueError('kinst should never be zero')
                     madDB = madrigal.metadata.MadrigalDB()
                     madParmObj = madrigal.data.MadrigalParameters(madDB)
                     parmList = madParmObj.getParametersForInstruments([kinst])
                     self.parmList = []
                     for parm in parmList:
                         self.parmList.append((parm, madParmObj.getSimpleParmDescription(parm)))
                     madCatObj = madrigal.metadata.MadrigalParmCategory(madDB)
                     catList = madCatObj.getCategoryList()
                     catDict = madParmObj.getCategoryDict(parmList)
                     choices = []
                     isDerivedDict = {}
                     parmDescDict = {}
                     for catDesc, catID in catList:
                         if catID not in list(catDict.keys()):
                             continue
                         theseParms = []
                         for parm in catDict[catID][1]:
                             theseParms.append((parm, parm))
                             isDerivedDict[parm] = False
                             parmDescDict[parm] = madParmObj.getParmDescription(parm)
                         choices.append((catDesc, theseParms))
                     super(AdvScriptParmsForm, self).__init__(*args, **kwargs)
                     self.fields['parameters'] = IsprintChoiceField(choices=choices,
                                                                    initial=['YEAR', 'MIN'],
                                                                    required=False,
                                                                    isDerivedDict=isDerivedDict,
                                                                    parmDescDict=parmDescDict,
                                                                    separateProlog=False,
                                                                    label = "")
             class AdvScriptParmsFiltersForm(django.forms.Form):
                 """AdvScriptParmsFiltersForm is the form for the parameter filters in the scrip generator
                 """
                 def __init__(self, *args, **kwargs):
                     kinst = int(getSelection('instruments', args, kwargs))
                     if kinst == 0:
                         raise ValueError('kinst should never be zero')
                     madDB = madrigal.metadata.MadrigalDB()
                     madParmObj = madrigal.data.MadrigalParameters(madDB)
                     parmList = madParmObj.getParametersForInstruments([kinst])
                     self.parmList = []
                     for parm in parmList:
                         self.parmList.append((parm, madParmObj.getSimpleParmDescription(parm)))
                     super(AdvScriptParmsFiltersForm, self).__init__(*args, **kwargs)
                     choices = [(parm, parm) for parm in parmList]
                     choices_with_null = [('None', 'None')] + choices
                     self.fields['parm_1'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_1_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_1_upper'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_2'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_2_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_2_upper'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_3'] = django.forms.ChoiceField(required=False,
                                                                       choices=choices_with_null)
                     self.fields['parm_3_lower'] = django.forms.CharField(required=False, initial='')
                     self.fields['parm_3_upper'] = django.forms.CharField(required=False, initial='')
             class MadCalculatorForm(django.forms.Form):
                 """MadCalculatorForm is the form for the madCalculator page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     madDB = madrigal.metadata.MadrigalDB()
                     madParmObj = madrigal.data.MadrigalParameters(madDB)
                     super(MadCalculatorForm, self).__init__(*args, **kwargs)
                     fullDerivedParmList = madrigal.derivation.getDerivableParms(['gdalt', 'gdlat', 'glon'])
                     # removed unwanted time and prolog parameters
                     rejectedCats = ('Time Related Parameter', 'Prolog Parameters', 'Radar Instrument Operation Parameter',
                                     'Madrigal Hdf5 Prolog Parameters')
                     # define time parameters that do make sense to calculate
                     neededTimeParms = ('APLT', 'CONJ_SUNRISE_H', 'CONJ_SUNSET_H',
                                        'SUNRISE_H', 'SUNSET_H', 'MLT')
                     # skip parms related to inst location
                     instLocationParms = ('AZM','ELM','GALTR','GDLONR','GDLATR','RANGE', 'ASPECT',
                                          'GDALT', 'GDLAT', 'GLON', 'CXR', 'CYR', 'CZR')
                     madCatObj = madrigal.metadata.MadrigalParmCategory(madDB)
                     catList = madCatObj.getCategoryList()
                     catDict = madParmObj.getCategoryDict(fullDerivedParmList)
                     choices = []
                     isDerivedDict = {}
                     self.parmDescDict = {}
                     for catDesc, catID in catList:
                         if catDesc in rejectedCats[1:]:
                             continue
                         if catID not in list(catDict.keys()):
                             continue
                         theseParms = []
                         for parm in catDict[catID][1]:
                             if parm in instLocationParms:
                                 continue
                             if catDesc in rejectedCats and parm not in neededTimeParms:
                                 continue
                             if not parm in fullDerivedParmList:
                                 continue
                             theseParms.append((parm, parm))
                             isDerivedDict[parm] = True
                             self.parmDescDict[parm] = madParmObj.getParmDescription(parm)
                         choices.append((catDesc, theseParms))
                     # form fields
                     self.fields['min_latitude'] = django.forms.FloatField(initial=-90.0, min_value=-90.0,
                                                                           max_value=90.0)
                     self.fields['max_latitude'] = django.forms.FloatField(initial=90.0, min_value=-90.0,
                                                                           max_value=90.0)
                     self.fields['delta_latitude'] = django.forms.FloatField(initial=45, min_value=1.0E-6)
                     self.fields['min_longitude'] = django.forms.FloatField(initial=-180.0, min_value=-180.0,
                                                                           max_value=180.0)
                     self.fields['max_longitude'] = django.forms.FloatField(initial=180.0, min_value=-180.0,
                                                                           max_value=180.0)
                     self.fields['delta_longitude'] = django.forms.FloatField(initial=90, min_value=1.0E-6)
                     self.fields['min_altitude'] = django.forms.FloatField(initial=0.0, min_value=0.0)
                     self.fields['max_altitude'] = django.forms.FloatField(initial=600.0, min_value=0.0)
                     self.fields['delta_altitude'] = django.forms.FloatField(initial=200, min_value=1.0E-6)
                     # time selection
                     now = datetime.datetime.utcnow()
                     self.fields['datetime'] = django.forms.SplitDateTimeField(input_date_formats=['%Y-%m-%d'], input_time_formats=['%H:%M:%S'],
                                                                               label='Select UT datetime',
                                                                               help_text='Select the UT time at which to run this calcuation',
                                                                               initial=datetime.datetime(now.year,1,1))
                     self.fields['parameters'] = IsprintChoiceField(choices=choices,
                                                                    required=False,
                                                                    isDerivedDict=isDerivedDict,
                                                                    parmDescDict=self.parmDescDict,
                                                                    separateProlog=False,
                                                                    label = "")
                 def clean(self):
                     """clean is the Django method to validate things in a form that require looking at multiple fields
                     """
                     max_len = 1.0E5
                     try:
                         a1 = numpy.arange(self.cleaned_data['min_latitude'], self.cleaned_data['max_latitude'], self.cleaned_data['delta_latitude'])
                         if len(a1) > max_len:
                             raise django.forms.ValidationError('Too many latitudes: %i.' % (len(a1)))
                     except ZeroDivisionError:
                         raise django.forms.ValidationError('Infinite latitudes')
                     try:
                         a2 = numpy.arange(self.cleaned_data['min_longitude'], self.cleaned_data['max_longitude'], self.cleaned_data['delta_longitude'])
                         if len(a1) > max_len:
                             raise django.forms.ValidationError('Too many longitudes: %i.' % (len(a1)))
                     except ZeroDivisionError:
                         raise django.forms.ValidationError('Infinite longitudes')
                     try:
                         a3 = numpy.arange(self.cleaned_data['min_altitude'], self.cleaned_data['max_altitude'], self.cleaned_data['delta_altitude'])
                         if len(a1) > max_len:
                             raise django.forms.ValidationError('Too many altitudes: %i.' % (len(a1)))
                     except ZeroDivisionError:
                         raise django.forms.ValidationError('Infinite altitudes')
                     total = len(a1) * len(a2) * len(a3)
                     if total > max_len:
                         raise django.forms.ValidationError('Too many calculations: %i' % (total))
             class GetMetadataForm(django.forms.Form):
                 """GetMetadataForm is the form for the getMetadata page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(GetMetadataForm, self).__init__(*args, **kwargs)
                     fileTypeChoices = (("0", "Experiment Table"),
                                        ("1", "File Table"),
                                        ("3", "Instrument Table"),
                                        ("4", "Parameter Table"),
                                        ("5", "Site Table"),
                                        ("6", "Type Table"),
                                        ("7", "Instrument Kindat Table"),
                                        ("8", "Instrument Parameter Table"),
                                        ("9", "Madrigal categories table"),
                                        ("10", "Instrument categories table"),)
                     self.fields['fileType'] = django.forms.ChoiceField(widget = django.forms.RadioSelect,
                                                                        choices=fileTypeChoices,
                                                                        initial="0",
                                                                        label="Choose the metadata file type to download")
             class LookerSelectForm(django.forms.Form):
                 """LookerSelectForm is the form for the looker_form page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerSelectForm, self).__init__(*args, **kwargs)
                     lookerOptionChoices = (("1", "Geodetic latitude, longitude and altitude of the points"),
                                            ("2", "Apex latitude, longitude and altitude of the points"),
                                            ("3", "Geodetic latitude, longitude and altitude of the points"),
                                            ("4", "Azimuth, elevation and range of the points from a specified instrument (output includes aspect angle)"),
                                            ("5", "Azimuth, elevation, range from specified instrument"),
                                            ("6", "Geodetic latitude, longitude, altitude of a point on the field line"),
                                            ("7", "Apex latitude, longitude of the field line"),
                                            ("8", "Geodetic latitude, longitude and altitude of the points"))
                     self.fields['looker_options'] = django.forms.ChoiceField(widget = django.forms.RadioSelect,
                                                                        choices=lookerOptionChoices,
                                                                        initial="1")
             class LookerGeodeticRadar(django.forms.Form):
                 """LookerGeodeticRadar is the form for the geodetic to radar page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerGeodeticRadar, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="1",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "1"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, 'Set location manually', local=False),
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lat'] = django.forms.FloatField(initial=30.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lat'] = django.forms.FloatField(initial=50.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lat'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lon'] = django.forms.FloatField(initial=-100.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lon'] = django.forms.FloatField(initial=-80.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lon'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerGeomagRadar(django.forms.Form):
                 """LookerGeomagRadar is the form for the geomagnetic to radar page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerGeomagRadar, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="2",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "2"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, 'Set location manually', local=False),
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lat'] = django.forms.FloatField(initial=30.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lat'] = django.forms.FloatField(initial=50.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lat'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lon'] = django.forms.FloatField(initial=-100.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lon'] = django.forms.FloatField(initial=-80.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lon'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerGeomagFromGeodetic(django.forms.Form):
                 """LookerGeomagFromGeodetic is the form for the geomagnetic from geodetic page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerGeomagFromGeodetic, self).__init__(*args, **kwargs)
                     self.fields['looker_options'] = django.forms.CharField(initial="3",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "3"}))
                     self.fields['start_lat'] = django.forms.FloatField(initial=30.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lat'] = django.forms.FloatField(initial=50.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lat'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lon'] = django.forms.FloatField(initial=-100.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lon'] = django.forms.FloatField(initial=-80.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lon'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerGeomagFromRadar(django.forms.Form):
                 """LookerGeomagFromRadar is the form for the geomagnetic from radar page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerGeomagFromRadar, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="4",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "4"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, local=False)[1:],
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_az'] = django.forms.FloatField(initial=-180.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_az'] = django.forms.FloatField(initial=180.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_az'] = django.forms.FloatField(initial=45.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_el'] = django.forms.FloatField(initial=0.0, min_value=0.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_el'] = django.forms.FloatField(initial=90.0, min_value=0.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_el'] = django.forms.FloatField(initial=30.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_range'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_range'] = django.forms.FloatField(initial=600.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_range'] = django.forms.FloatField(initial=200.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerFieldLineFromRadar(django.forms.Form):
                 """LookerFieldLineFromRadar is the form for the field line from radar page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerFieldLineFromRadar, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="5",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "5"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, 'Set location manually', local=False),
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_az'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_el'] = django.forms.FloatField(initial=45.0, min_value=0.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_range'] = django.forms.FloatField(initial=1000.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=1000.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerFieldLineFromGeodetic(django.forms.Form):
                 """LookerFieldLineFromGeodetic is the form for the field line from geodetic page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerFieldLineFromGeodetic, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="6",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "6"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, 'Set location manually', local=False),
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_lat'] = django.forms.FloatField(initial=45.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_lon'] = django.forms.FloatField(initial=-90.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=1000.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerFieldLineFromApex(django.forms.Form):
                 """LookerFieldLineFromApex is the form for the field line from apex coordinates page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerFieldLineFromApex, self).__init__(*args, **kwargs)
                     madDB = madrigal.metadata.MadrigalDB()
                     madInstData = madrigal.metadata.MadrigalInstrumentData(madDB)
                     dict1 = {'isGlobal': True, 'categories': "0"}
                     self.fields['looker_options'] = django.forms.CharField(initial="7",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "7"}))
                     self.fields['instruments'] = django.forms.ChoiceField(widget = django.forms.Select(attrs={'size':'3'}),
                                                                           choices=getInstrumentList([], dict1, madInstData, 'Set location manually', local=False),
                                                                           required=False, label='Instrument: ')
                     self.fields['inst_lat'] = django.forms.FloatField(initial=0.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_lon'] = django.forms.FloatField(initial=0.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['inst_alt'] = django.forms.FloatField(initial=0.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_apex_lat'] = django.forms.FloatField(initial=65.0, min_value=-00.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['fl_apex_lon'] = django.forms.FloatField(initial=-90.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=1000.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     now = datetime.datetime.utcnow()
                     self.fields['year'] = django.forms.FloatField(initial=float(now.year), min_value=1950.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
             class LookerConjugateFromGeodetic(django.forms.Form):
                 """LookerConjugateFromGeodetic is the form for the geomagnetic/conjugate from geodetic page
                 """
                 def __init__(self, *args, **kwargs):
                     """
                     """
                     super(LookerConjugateFromGeodetic, self).__init__(*args, **kwargs)
                     parmChoices = [("MAGCONJLAT", 'Magnetic conjugate latitude'),
                                    ("MAGCONJLON", 'Magnetic conjugate longitude'),
                                    ("SZEN", 'Solar zenith angle'),
                                    ("SZENC", 'Magnetic conjugate solar zenith angle'),
                                    ("SDWHT", 'Shadow height (km)'),
                                    ("MAGCONJSDWHT", 'Magnetic conjugate shadow height (km)')]
                     parmInitial = [key for key, value in parmChoices]
                     self.fields['looker_options'] = django.forms.CharField(initial="8",
                                                                        widget=django.forms.HiddenInput(attrs={'value': "8"}))
                     self.fields['start_lat'] = django.forms.FloatField(initial=30.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lat'] = django.forms.FloatField(initial=50.0, min_value=-90.0, max_value=90.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lat'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_lon'] = django.forms.FloatField(initial=-100.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_lon'] = django.forms.FloatField(initial=-80.0, min_value=-180.0, max_value=180.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_lon'] = django.forms.FloatField(initial=10.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['start_alt'] = django.forms.FloatField(initial=100.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['stop_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     self.fields['step_alt'] = django.forms.FloatField(initial=500.0, min_value=0.0,
                                                                            widget=django.forms.TextInput(attrs={'size':5}))
                     # time selection
                     now = datetime.datetime.utcnow()
                     self.fields['datetime'] = django.forms.SplitDateTimeField(input_date_formats=['%Y-%m-%d'], input_time_formats=['%H:%M:%S'],
                                                                               label='Select UT datetime',
                                                                               help_text='Select the UT time at which to run this calcuation',
                                                                               initial=datetime.datetime(now.year,1,1))
                     self.fields['pList'] = django.forms.MultipleChoiceField(widget=django.forms.CheckboxSelectMultiple(),
                                                                             choices=parmChoices, initial=parmInitial)

source/madpy/djangoMad/madweb/templates/madweb/show_experiment.html +8 0

             {% extends "base.html" %}
             {% comment %}
             	Written by Bill Rideout brideout@haystack.mit.edu
             	Base template for Madrigal show experiment web interface
             	$Id: show_experiment.html 7310 2021-03-02 14:31:06Z brideout $
             {% endcomment %}
             {% block title %}Show Madrigal experiment{% endblock %}
             {% block extra_head %}
                 <script>
                     function changeFile (select) {
                     	var basename = select.options[select.selectedIndex].value;
                     {% if form.exp_id %}
             			var url = '{% url 'change_files' %}' + '?experiment_list={{ form.exp_id.label }}&file_list=' + basename;
             		{% else %}
             			var exp_id = $("#id_experiment_list")[0].options[$("#id_experiment_list")[0].selectedIndex].value;
             			var url = '{% url 'change_files' %}' + '?experiment_list=' + exp_id + '&file_list=' + basename;
             		{% endif %}
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#file_buttons" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the file_list html if '0' not selected
                         if (basename != '0') {
                         	    $(".single_form").slice(divIndex,divIndex+1).load(url);
                         }
                     }
                     {% include "madweb/fileDownload.js" %}
                 </script>
             {% endblock %}
             {% block content %}
             	<center><h4> {{ form.exp_desc.label }} </h4></center>
             	{% include "madweb/file_list.html" %}
             	<!-- file select div -->
             	<div class="col-md-12 single_form" id="file_buttons">
             		{% if form.file_buttons %}
             			{% include "madweb/file_buttons.html" %}
             		{% endif %}
             	</div> <!-- end subdivide -->
             	<div>&nbsp;</div>
             	<!-- file select div -->
             	<div class="col-md-12 single_form" id="file_data">
             		{% if form.show_plots %}
             			{% include "madweb/show_plots.html" %}
             		{% elif form.plot_list %}
             			{% include "madweb/show_plots.html" %}
             		{% endif %}
             	</div> <!-- end subdivide -->
+            	<!-- file select div -->
+            	<div class="col-md-12 single_form" id="file_plot">
+            		{% if form.show_plots %}
+            			{% include "madweb/parameter_selection.html" %}
+            		{% endif %}
+            	</div> <!-- end subdivide -->
             	{% endblock %}

source/madpy/djangoMad/madweb/templates/madweb/single.html +9 0

             {% extends "base_single.html" %}
             {% comment %}
             	Written by Bill Rideout brideout@haystack.mit.edu
             	Final template for Madrigal single experiment web interface
             	$Id: single.html 7290 2021-01-13 21:07:21Z brideout $
             {% endcomment %}
             {% block ajax_js %}
                 <script type="text/javascript">
                     {% if years %}
                     $( document ).ready(function() {
             		    createCalendar();
             		});
                     {% endif %}
                 	var redirectLookup = {
                 	  "0": function() { return ""; },
                 	  {% for redirect in redirect_list %}
             		  "{{ redirect.0 }}": function() { return "{{ redirect.1|safe }}"; },
             		  {% endfor %}
             		};
                     function populateCat (checkbox) {
                         var is_global = 0;
                         if (checkbox.checked) {
                         	is_global = 1;
                         }
                         var url = '{% url 'get_categories' %}' + '?isGlobal=' + is_global;
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#categories" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the categories html
                         $(".single_form").slice(divIndex,divIndex+1).load(url);
                     }
                     function populateInst (select) {
                         var is_global = 0;
                         if ($("#id_isGlobal")[0].checked) {
                         	is_global = 1;
                         }
                         var category = select.options[select.selectedIndex].value;
                         var url = '{% url 'get_instruments' %}' + '?isGlobal=' + is_global + '&categories=' + category;
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#instruments" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the instruments html if '0' not selected
                         if (category != '0') {
                         	$(".single_form").slice(divIndex,divIndex+1).load(url);
                         }
                     }
                     function populateYear (select) {
                         var is_global = 0;
                         if ($("#id_isGlobal")[0].checked) {
                         	is_global = 1;
                         }
                         // this method may redirect if instrument is not local
                         var kinst = select.options[select.selectedIndex].value;
                         var redirectUrl = redirectLookup[kinst]();
                         if (redirectUrl.length > 0) {
                            // redirect
                            alert('Because this data is not local, you will be redirected to ' + redirectUrl);
                            window.location.href = redirectUrl;
                         } else {
                         	var url = '{% url 'get_years' %}' + '?isGlobal=' + is_global + '&instruments=' + kinst;
             	            // first delete all forms that are now out of date
             	            divIndex = $(".single_form").index($( "#years" ))
                         	$(".single_form").slice(divIndex).empty()
             	            // second populate the years html if '0' not selected
             	            if (kinst != '0') {
             	            	$(".single_form").slice(divIndex,divIndex+1).load(url);
             	            }
                         }
                     }
                     function populateMonth (select) {
                         var year = select.options[select.selectedIndex].value;
             			var kinst = $("#id_instruments")[0].options[$("#id_instruments")[0].selectedIndex].value;
             			var is_global = 0;
                         if ($("#id_isGlobal")[0].checked) {
                         	is_global = 1;
                         }
                     	var url = '{% url 'get_months' %}' + '?isGlobal=' + is_global + '&instruments=' + kinst + '&years=' + year;
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#months" ))
                     	$(".single_form").slice(divIndex).empty()
                         // second populate the years html if '0' not selected
                         if (kinst != '0') {
                         	$(".single_form").slice(divIndex,divIndex+1).load(url);
                         }
                     }
                     function populateCalendar (select) {
                     	var year = $("#id_years")[0].options[$("#id_years")[0].selectedIndex].value;
                     	var month = select.options[select.selectedIndex].value;
             			var kinst = $("#id_instruments")[0].options[$("#id_instruments")[0].selectedIndex].value;
             			var is_global = 0;
                         if ($("#id_isGlobal")[0].checked) {
                         	is_global = 1;
                         }
             			var url = '{% url 'get_calendar' %}' + '?isGlobal=' + is_global + '&instruments=' + kinst + '&years=' + year + '&months=' + month;
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#calendar" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the calendar html if '0' not selected
                         if (year != '0') {
                         	$(".single_form").slice(divIndex,divIndex+1).load(url, function() {
               					createCalendar();
             				});
                         }
                     }
                     function populateFile (select) {
                     	var expId = select.options[select.selectedIndex].value;
             			var url = '{% url 'get_files' %}' + '?experiment_list=' + expId;
                         // first delete all forms that are now out of date
             	        divIndex = $(".single_form").index($( "#file_select" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the file_list html if '0' not selected
                         if (expId != '0') {
                         	$(".single_form").slice(divIndex,divIndex+1).load(url);
                         }
                     }
                     function changeFile (select) {
                     	var basename = select.options[select.selectedIndex].value;
                     {% if form.exp_id %}
             			var url = '{% url 'change_files' %}' + '?experiment_list={{ form.exp_id.label }}&file_list=' + basename;
             		{% else %}
             			var exp_id = $("#id_experiment_list")[0].options[$("#id_experiment_list")[0].selectedIndex].value;
             			var url = '{% url 'change_files' %}' + '?experiment_list=' + exp_id + '&file_list=' + basename;
             		{% endif %}
                         // first delete all forms that are now out of date
                         divIndex = $(".single_form").index($( "#file_buttons" ))
                         $(".single_form").slice(divIndex).empty()
                         // second populate the file_list html if '0' not selected
                         if (basename != '0') {
                         	$(".single_form").slice(divIndex,divIndex+1).load(url);
                         }
                     }
                     {% include "madweb/fileDownload.js" %}
                 </script>
             {% endblock %}
             {% block isGlobal %}
             				<div class="col-md-12 single_form" id="isGlobal">
             				{{ form.isGlobal.label }} {{ form.isGlobal }}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block categories %}
                             <!-- subdivide selection column for categories to be possibly filled in by ajax - single_form 0 -->
             				<div class="col-md-12  single_form" id="categories">
             		{% if form.categories %}
             			{% include "madweb/categories.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block instruments %}
             				<!-- subdivide selection column for instruments to be possibly filled in by ajax - single_form 0 -->
             				<div class="col-md-12 single_form" id="instruments">
             		{% if form.instruments %}
             			{% include "madweb/instruments.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block years %}
             				<!-- subdivide selection column for year to be possibly filled in by ajax - single_form 1 -->
             				<div class="col-md-12 single_form" id="years">
             		{% if form.years %}
             			{% include "madweb/years.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block months %}
             				<!-- subdivide selection column for month  to be possibly filled in by ajax - single_form 1 -->
             				<div class="col-md-12 single_form" id="months">
             		{% if form.months %}
             			{% include "madweb/months.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block calendar %}
             				<!-- subdivide selection column for calendar to be possibly filled in by ajax - single_form 2 -->
             				<div class="col-md-12 single_form" id="calendar">
             		{% if form.days %}
             			{% include "madweb/calendar.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block experiment_select %}
             				<!-- this select only appears if there are multiple experiments in the day -->
             				<div class="col-md-12 single_form" id="experiment_select">
             		{% if form.experiment_list %}
             			{% include "madweb/exp_list.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block file_select %}
             				<!-- file select div -->
             				<div class="col-md-12 single_form" id="file_select">
             		{% if form.file_list|length > 1 %}
             			{% include "madweb/file_list.html" %}
             		{% elif form.days and not form.experiment_list %}
             		    <center><p> This experiment has no Madrigal CEDAR format Hdf5 files. Showing only plots and auxillary files instead.</p></center>
             			{% include "madweb/show_plots.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
             {% block file_buttons %}
             				<!-- file select div -->
             				<div class="col-md-12 single_form" id="file_buttons">
             		{% if form.file_buttons %}
             			{% include "madweb/file_buttons.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             				<div>&nbsp;</div>
             {% endblock %}
             {% block file_data %}
             				<!-- file select div -->
             				<div class="col-md-12 single_form" id="file_data">
             		{% if form.show_plots %}
             			{% include "madweb/show_plots.html" %}
             		{% endif %}
             				</div> <!-- end subdivide -->
             {% endblock %}
+            {% block file_plot %}
+            				<!-- file select div -->
+            				<div class="col-md-12 single_form" id="file_plot">
+            		{% if form.show_plots %}
+            			{% include "madweb/parameter_selection.html" %}
+            		{% endif %}
+            				</div> <!-- end subdivide -->
+            {% endblock %}

source/madpy/djangoMad/madweb/urls.py +3 0

             '''
             Created on Jul 16, 2013
             @author: Jose Antonio Sal y Rosas Celi
             @contact: arturo.jasyrc@gmail.com
             As imported and slightly modified by Bill Rideout Jan 20, 2015
             $Id: urls.py 7246 2020-10-12 14:54:26Z brideout $
             '''
             from django.conf.urls import url
             from . import views
             urlpatterns = [        url(r'^$',
                                        views.index,
                                        name='index'),
                                    url(r'^index.html/?$',
                                        views.index,
                                        name='index'),
                                    url(r'^single/?$',
                                        views.check_registration(views.view_single),
                                        name='view_single'),
                                    url(r'^register/?$',
                                        views.view_registration,
                                        name='view_registration'),
                                    url(r'^getCategories/?$',
                                        views.get_categories,
                                        name='get_categories'),
                                    url(r'^getInstruments/?$',
                                        views.get_instruments,
                                        name='get_instruments'),
                                    url(r'^getYears/?$',
                                        views.get_years,
                                        name='get_years'),
                                    url(r'^getMonths/?$',
                                        views.get_months,
                                        name='get_months'),
                                    url(r'^getCalendar/?$',
                                        views.get_calendar,
                                        name='get_calendar'),
                                    url(r'^populateCalendarExperiment/?$',
                                        views.populate_calendar_experiment,
                                        name='populate_calendar_experiment'),
                                    url(r'^getFiles/?$',
                                        views.get_files,
                                        name='get_files'),
                                    url(r'^changeFiles/?$',
                                        views.change_files,
                                        name='change_files'),
                                    url(r'^showPlots/?$',
                                        views.show_plots,
                                        name='show_plots'),
+                                   url(r'^view_plot/?$',
+                                       views.view_plot,
+                                       name='plot'),
                                    url(r'^downloadAsIs/?$',
                                        views.download_as_is,
                                        name='download_as_is'),
                                    url(r'^downloadFileAsIs/?$',
                                        views.download_file_as_is,
                                        name='download_file_as_is'),
                                    url(r'^printAsIs/?$',
                                        views.print_as_is,
                                        name='print_as_is'),
                                    url(r'^listRecords/?$',
                                        views.list_records,
                                        name='list_records'),
                                    url(r'^showInfo/?$',
                                        views.show_info,
                                        name='show_info'),
                                    url(r'^showDoi/?$',
                                        views.show_doi,
                                        name='show_doi'),
                                    url(r'^getAdvanced/?$',
                                        views.get_advanced,
                                        name='get_advanced'),
                                    url(r'^advancedDownload/?$',
                                        views.advanced_download,
                                        name='advanced_download'),
                                    url(r'^advancedPrint/?$',
                                        views.advanced_print,
                                        name='advanced_print'),
                                    url(r'^list/?$',
                                        views.check_registration(views.view_list),
                                        name='view_list'),
                                    url(r'^downloadAsIsScript/?$',
                                        views.download_as_is_script,
                                        name='download_as_is_script'),
                                    url(r'^generateDownloadFilesScript/?$',
                                        views.generate_download_files_script,
                                        name='generate_download_files_script'),
                                    url(r'^downloadAdvancedScript/?$',
                                        views.download_advanced_script,
                                        name='download_advanced_script'),
                                    url(r'^generateDownloadAdvancedScript/?$',
                                        views.generate_download_advanced_script,
                                        name='generate_download_advanced_script'),
                                    url(r'^generateParmsScript/?$',
                                        views.generate_parms_script,
                                        name='generate_parms_script'),
                                    url(r'^generateParmsFiltersScript/?$',
                                        views.generate_parms_filters_script,
                                        name='generate_parms_filters_script'),
                                    url(r'^listExperiments/?$',
                                        views.list_experiments,
                                        name='list_experiments'),
                                    url(r'^viewRecordPlot/?$',
                                        views.view_record_plot,
                                        name='view_record_plot'),
                                    url(r'^viewRecordImage/?$',
                                        views.view_record_image,
                                        name='view_record_image'),
                                    url(r'^showExperiment/?$',
                                        views.check_registration(views.show_experiment),
                                        name='show_experiment'),
                                    url(r'^madExperiment.cgi/*$',
                                        views.check_registration(views.show_experiment_v2),
                                        name='show_experiment_v2'),
                                    url(r'^chooseScript/?$',
                                        views.check_registration(views.choose_script),
                                        name='choose_script'),
                                    url(r'^ftp/$',
                                        views.check_registration(views.ftp),
                                        name='ftp'),
                                    url(r'^ftp/fullname/([^/]+)/email/([^/]+)/affiliation/([^/]+)/kinst/(\d+)/$',
                                        views.ftp_instrument,
                                        name='ftp_instrument'),
                                    url(r'^ftp/fullname/([^/]+)/email/([^/]+)/affiliation/([^/]+)/kinst/(\d+)/year/(\d+)/$',
                                        views.ftp_year,
                                        name='ftp_year'),
                                    url(r'^ftp/fullname/([^/]+)/email/([^/]+)/affiliation/([^/]+)/kinst/(\d+)/year/(\d+)/kindat/(\d+)/$',
                                        views.ftp_kindat,
                                        name='ftp_kindat'),
                                    url(r'^ftp/fullname/([^/]+)/email/([^/]+)/affiliation/([^/]+)/kinst/(\d+)/year/(\d+)/kindat/(\d+)/format/([^/]+)/$',
                                        views.ftp_files,
                                        name='ftp_files'),
                                    url(r'^ftp/fullname/([^/]+)/email/([^/]+)/affiliation/([^/]+)/kinst/(\d+)/year/(\d+)/kindat/(\d+)/format/([^/]+)/fullFilename/([^/]+)/$',
                                        views.ftp_download,
                                        name='ftp_download'),
                                    url(r'ftpMultipleDownload/$',
                                        views.ftp_multiple_download,
                                        name='ftp_multiple_download'),
                                    url(r'^instMetadata/?$',
                                        views.instrument_metadata,
                                        name='instrument_metadata'),
                                    url(r'^siteMetadata/?$',
                                        views.site_metadata,
                                        name='site_metadata'),
                                    url(r'^parameterMetadata/?$',
                                        views.parameter_metadata,
                                        name='parameter_metadata'),
                                    url(r'^kindatMetadata/?$',
                                        views.kindat_metadata,
                                        name='kindat_metadata'),
                                    url(r'^madCalculator/?$',
                                        views.madrigal_calculator,
                                        name='madrigal_calculator'),
                                    url(r'^madCalculatorOutput/?$',
                                        views.madrigal_calculator_output,
                                        name='madrigal_calculator_output'),
                                    url(r'^getMetadata/*$',
                                        views.get_metadata,
                                        name='get_metadata'),
                                    url(r'^looker/?$',
                                        views.looker_main,
                                        name='looker_main'),
                                    url(r'^lookerForm/?$',
                                        views.looker_form,
                                        name='looker_form'),
                                    url(r'^lookerOutput/?$',
                                        views.looker_output,
                                        name='looker_output'),
                                    url(r'^getVersionService.py/*$',
                                        views.get_version_service,
                                        name='get_version_service'),
                                    url(r'^getInstrumentsService.py/*$',
                                        views.get_instruments_service,
                                        name='get_instruments_service'),
                                    url(r'^getExperimentsService.py/*$',
                                        views.get_experiments_service,
                                        name='get_experiments_service'),
                                    url(r'^getExperimentFilesService.py/*$',
                                        views.get_experiment_files_service,
                                        name='get_experiment_files_service'),
                                    url(r'^getParametersService.py/*$',
                                        views.get_parameters_service,
                                        name='get_parameters_service'),
                                    url(r'^isprintService.py/*$',
                                        views.isprint_service,
                                        name='isprint_service'),
                                    url(r'^getMadfile.cgi/*$',
                                        views.get_madfile_service,
                                        name='get_madfile_service'),
                                    url(r'^madCalculatorService.py/*$',
                                        views.mad_calculator_service,
                                        name='mad_calculator_service'),
                                    url(r'^madTimeCalculatorService.py/*$',
                                        views.mad_time_calculator_service,
                                        name='mad_time_calculator_service'),
                                    url(r'^madCalculator2Service.py/*$',
                                        views.mad_calculator2_service,
                                        name='mad_calculator2_service'),
                                    url(r'^madCalculator2Service.py',
                                        views.mad_calculator2_service,
                                        name='mad_calculator2_service'),
                                    url(r'^madCalculator3Service.py/*$',
                                        views.mad_calculator3_service,
                                        name='mad_calculator3_service'),
                                    url(r'^madCalculator3Service.py',
                                        views.mad_calculator3_service,
                                        name='mad_calculator3_service'),
                                    url(r'^geodeticToRadarService.py',
                                        views.geodetic_to_radar_service,
                                        name='geodetic_to_radar_service'),
                                    url(r'^radarToGeodeticService.py',
                                        views.radar_to_geodetic_service,
                                        name='radar_to_geodetic_service'),
                                    url(r'^listFileTimesService.py',
                                        views.list_file_times_service,
                                        name='list_file_times_service'),
                                    url(r'^downloadWebFileService.py',
                                        views.download_web_file_service,
                                        name='download_web_file_service'),
                                    url(r'^traceMagneticFieldService.py',
                                        views.trace_magnetic_field_service,
                                        name='trace_magnetic_field_service'),
                                    url(r'^globalFileSearchService.py',
                                        views.global_file_search_service,
                                        name='global_file_search_service'),
                                    url(r'^getUrlListFromGroupIdService.py',
                                        views.get_url_list_from_group_id_service,
                                        name='get_url_list_from_group_id_service'),
                                    url(r'^setGroupIdFromUrlListService.py',
                                        views.set_group_id_from_url_list_service,
                                        name='set_group_id_from_url_list_service'),
                                    url(r'docs/name/(.+)$',
                                        views.docs,
                                        name='docs'),
                                 ]

source/madpy/djangoMad/madweb/views.py +207 -3

             '''
             @author: Bill Rideout
             @contact: brideout@haystack.mit.edu
             $Id: views.py 7345 2021-03-30 18:30:32Z brideout $
             '''
             # standard python imports
             import os.path
             import urllib
             import os, sys
             import json
             import datetime, time
             import glob
             import re
             import subprocess
             import io
             import collections
             import shutil
             import mimetypes
             import tempfile
             import random
             # django imports
             from django.shortcuts import render, redirect
             from django.views.decorators.csrf import csrf_exempt
             from django.template.context import RequestContext
             #from django.conf import settings
             try:
                 from django.urls import reverse
             except ImportError:
                 from django.core.urlresolvers import reverse
             from django.http import HttpResponse, HttpResponseRedirect, StreamingHttpResponse
             import django.utils.http
             import django.core.files
             import django.utils.safestring
             from wsgiref.util import FileWrapper
             # third party imports
             import numpy
+            import plotly.offline as py
+            import plotly.graph_objs as go
+            import h5py
             # madrigal imports
             import madrigal._derive
             import madrigal.metadata
             import madrigal.ui.web
             import madrigal.cedar
             import madrigal.isprint
             import madweb.forms
             # temp only
             import logging
             # constants
             formatDict = collections.OrderedDict()
             formatDict['hdf5'] = 'Hdf5'
             formatDict['netCDF4'] = 'netCDF4'
             formatDict['ascii'] = 'Column-delimited ascii'
             maxSize = 50000000 # 50 MB cutoff
             def index(request):
                 """index is the home page view
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 welcome = madDB.getIndexHead()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 rulesRoadHtml = madDB.getLocalRulesOfRoad()
                 template_dict = {'home_active': 'class="active"', 'site_name': siteName, 'site_list': siteList,
                                  'rulesOfRoad':django.utils.safestring.mark_safe(rulesRoadHtml),
                                  'bg_color': bg_color, 'welcome': welcome}
                 return render(request, 'madweb/index.html', template_dict)
             @csrf_exempt
             def check_registration(view):
                 def check_cookies(request, *args, **kwargs):
                     # this view checks if all the needed cookies are set
                     cookieDict = request.COOKIES
                     try:
                         cookieDict['user_fullname']
                         cookieDict['user_email']
                         cookieDict['user_affiliation']
                         # no need to register
                         return(view(request, *args, **kwargs))
                     except KeyError:
                         return(HttpResponseRedirect(reverse('view_registration') + '?redirect=%s' % (request.get_full_path())))
                 return(check_cookies)
             def view_registration(request):
                 madDB = madrigal.metadata.MadrigalDB()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWeb.getSiteInfo()
                 redirect = 'index' # default is to redirect to home page
                 if request.method == 'GET':
                     if 'redirect' in request.GET:
                         redirect = request.GET['redirect']
                         for key in request.GET:
                             if key not in ('redirect', 'user_fullname', 'user_email', 'user_affiliation'):
                                 redirect += '&%s=%s' % (key, request.GET[key])
                     if len(list(request.GET.keys())) > 0 and 'user_fullname' in request.GET:
                         form = madweb.forms.RegisterForm(request.GET)
                         if form.is_valid():
                             # write cookies and continue to main page
                             max_age = 3600*24*365 # one year
                             if redirect == 'index':
                                 response = HttpResponseRedirect(reverse('index'))
                             else:
                                 response = HttpResponseRedirect(redirect)
                             response.set_cookie('user_fullname', form.cleaned_data['user_fullname'], max_age=max_age, samesite='Strict')
                             response.set_cookie('user_email', form.cleaned_data['user_email'], max_age=max_age, samesite='Strict')
                             response.set_cookie('user_affiliation', form.cleaned_data['user_affiliation'], max_age=max_age, samesite='Strict')
                             return(response)
                     else:
                         form = madweb.forms.RegisterForm()
                 else:
                     form = madweb.forms.RegisterForm()
                 return render(request, 'madweb/register.html', {'form': form, 'home_active': 'class="active"',
                                                                 'site_name': siteName, 'site_list': siteList,
                                                                 'redirect': redirect})
             def view_single(request):
                 """view_single is the single experiment view.  It is supplemented by ajax views to speed performamnce,
                 but this view can also create the entire page given a complete query string
                 """
                 responseDict = {'single_active': 'class="active"'}
                 cookieDict = request.COOKIES
                 user_email = cookieDict['user_email']
                 queryDict = request.GET.copy()
                 queryDict['user_email'] = user_email
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWeb.getSiteInfo()
                 form = madweb.forms.SingleExpDefaultForm(queryDict)
                 if not form.is_valid():
                     # new page
                     form = madweb.forms.SingleExpDefaultForm()
                 responseDict['form'] = form
                 responseDict['site_name'] = siteName
                 responseDict['site_list'] = siteList
                 responseDict['redirect_list'] = madWeb.getSingleRedirectList()
                 if 'instruments' in request.GET:
                     responseDict['instruments'] = request.GET['instruments']
                 if 'years' in request.GET:
                     responseDict['years'] = request.GET['years']
                 if 'months' in request.GET:
                     responseDict['months'] = request.GET['months']
                 try:
                     # add extra keys if choosing a file
                     form.fields['file_list']
                     responseDict['loader'] = 'loadSingleForm'
                     responseDict['redirect'] = reverse('get_files')
                     # handle the case with no files
                     if len(form.fields['file_list'].choices) < 2:
                         form2 = madweb.forms.SingleExpPlotsForm({'experiment_list':form['exp_id'].initial})
                         form.fields['plot_list'] = form2.fields['plot_list']
                 except:
                     pass
                 responseDict['bg_color'] = bg_color
                 return render(request, 'madweb/single.html', responseDict)
             def get_categories(request):
                 """get_categories is a Ajax call that returns the categories select html to support the
                 single experiment UI.  Called when a user modifies the isGlobal checkbox.
                 Inputs:
                     request
                 """
                 form = madweb.forms.SingleExpDefaultForm(request.GET)
                 return render(request, 'madweb/categories.html', {'form': form})
             def get_instruments(request):
                 """get_instruments is a Ajax call that returns the instruments select html to support the
                 single experiment UI.  Called when a user modifies the categories select field.
                 Inputs:
                     request
                 """
                 form = madweb.forms.SingleExpInstForm(request.GET)
                 return render(request, 'madweb/instruments.html', {'form': form})
             def get_years(request):
                 """get_years is a Ajax call that returns the years select html to support the
                 single experiment UI.  Called when a user modifies the instruments select field.
                 Inputs:
                     request
                 """
                 form = madweb.forms.SingleExpYearForm(request.GET)
                 is_global = madweb.forms.getIsGlobal([], request.GET)
                 return render(request, 'madweb/years.html', {'isGlobal': is_global,
                                                                 'form': form})
             def get_months(request):
                 """get_months is a Ajax call that returns the months select html to support the
                 single experiment UI.  Called when a user modifies the years select field.
                 Inputs:
                     request
                 """
                 form = madweb.forms.SingleExpMonthForm(request.GET)
                 is_global = madweb.forms.getIsGlobal([], request.GET)
                 year = int(request.GET['years'])
                 kinst =int(request.GET['instruments'])
                 return render(request, 'madweb/months.html', {'isGlobal': is_global,
                                                                  'years': year,
                                                                  'form': form})
             def get_calendar(request):
                 """get_calendar is a Ajax call that returns the calendar html  to support the
                 single experiment UI.  Called when a user selects month field.
                 Inputs:
                     request
                 """
                 is_global = madweb.forms.getIsGlobal([], request.GET)
                 year = int(request.GET['years'])
                 month = int(request.GET['months'])
                 kinst =int(request.GET['instruments'])
                 form = madweb.forms.SingleExpCalendarForm({'years': year,
                                                            'months': month,
                                                            'instruments': kinst})
                 return render(request, 'madweb/calendar.html', {'isGlobal': is_global,
                                                                    'years': year,
                                                                    'months': month,
                                                                    'instruments': kinst,
                                                                    'form': form})
             def populate_calendar_experiment(request):
                 """populate_calendar_experiment is a ajax view that returns a json object used by the
                 calender widget to populate itself.
                 Inputs:
                     request
                 """
                 is_global = madweb.forms.getIsGlobal([], request.GET)
                 year = int(request.GET['years'])
                 month = int(request.GET['months'])
                 kinst =int(request.GET['instruments'])
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 catId = madInstObj.getCategoryId(kinst)
                 expDays = madWebObj.getDays(kinst, year, month)
                 if len(expDays) == 0:
                     expDays = madWebObj.getDays(kinst, year, month, optimize=False)
                 color = "#999"
                 jsonListFinal = []
                 for expDay in expDays:
                     newdate = '%i/%i/%i' % (expDay.day, expDay.month, expDay.year)
                     urlperDate = reverse('view_single')
                     query_str = '?'
                     if is_global:
                         query_str += 'isGlobal=on&'
                     query_str += 'categories=%i&instruments=%i&years=%i&months=%i&days=%i' % (catId, kinst, year,
                                                                                               expDay.month, expDay.day)
                     urlperDate += query_str
                     dayList = [newdate, "", urlperDate, color]
                     jsonListFinal.append(dayList)
                 return HttpResponse(json.dumps(jsonListFinal), content_type='application/json')
             def get_files(request):
                 """get_files is a Ajax call that returns the files select html to support the
                 single experiment UI.  Called when a user modifies the calendar or experiments fields.
                 Inputs:
                     request
                 """
                 cookieDict = request.COOKIES
                 user_email = cookieDict['user_email']
                 queryDict = request.GET.copy()
                 queryDict['user_email'] = user_email
                 form = madweb.forms.SingleExpFileForm(queryDict)
                 is_global = madweb.forms.getIsGlobal([], request.GET)
                 return render(request, 'madweb/file_list.html', {'isGlobal': is_global,
                                                                     'form': form,
                                                                     'loader': 'loadSingleForm',
                                                                     'redirect': reverse('get_files')})
             def change_files(request):
                 """change_files is a Ajax call that returns the files options html to support the
                 single experiment UI.  Called when a user modifies the files select field.
                 Inputs:
                     request
                 """
                 expID =int(request.GET['experiment_list'])
                 basename = request.GET['file_list']
                 madDB = madrigal.metadata.MadrigalDB()
                 form = madweb.forms.SingleExpButtonsForm(request.GET)
                 return render(request, 'madweb/file_buttons.html', {'form': form,
                                                                     'plot_label': madDB.getPlotButtonLabel()})
             def show_plots(request):
                 """show_plots is a Ajax call that returns the files data html with plots to support the
                 single experiment UI.  Called when a user modifies the files select field.
                 Inputs:
                     request
                 """
+                madDB = madrigal.metadata.MadrigalDB()
+                madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
+                madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 try:
                     expID = int(request.GET['experiment_list'])
                 except ValueError:
                     # convert expPath to expID
-                    madDB = madrigal.metadata.MadrigalDB()
-                    madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                     expID = madWebObj.getExpIDFromExpPath(request.GET['experiment_list'], True)
+                plotList = madExpObj.getExpLinksByExpId(expID)
+                if len(plotList) != 0:
                     form = madweb.forms.SingleExpPlotsForm(request.GET)
+                    template = 'madweb/show_plots.html'
+                    context = {'form': form}
+                else:
+                    template = 'madweb/parameter_selection.html'
+                    form = madweb.forms.SingleExpPlotsSelectionForm(request.GET)
+                    context = {'form': form, 'expID': expID}
+                return render(request, template, context)
+            def view_plot(request):
+                param1d = int(request.GET.get('param1d','0'))
+                param2d = int(request.GET.get('param2d','0'))
+                madDB = madrigal.metadata.MadrigalDB()
+                madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
+                madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
+                expID =int(request.GET['expID'])
+                expDir = madExpObj.getExpDirByExpId(expID)
+                if expDir is None:
+                    raise ValueError('No expDir found for exp_id %i' % (int(expID)))
-                return render(request, 'madweb/show_plots.html', {'form': form})
+                fileList = madWebObj.getFileFromExpID(expID, False)
+                firsttuple = [a_tuple[0] for a_tuple in fileList]
+                basename = firsttuple[0]
+                fullFilename = os.path.join(expDir, basename)
+                with h5py.File(fullFilename, "r") as f:
+                    # Get the data
+                    data = f[list(f.keys())[0]]
+                    if 'Array Layout' in list(data.keys()):
+                        array = data[list(data.keys())[0]]
+                        timestamps = array[list(array.keys())[4]]
+                        datatime = [datetime.datetime.fromtimestamp(t) for t in list(timestamps)]
+                        range = array[list(array.keys())[3]]
+                        datarange = list(range)
+                        if param1d==0:
+                            parameters_2d = array[list(array.keys())[1]]
+                            paramname = list(parameters_2d.keys())[param2d]
+                            param = parameters_2d[list(parameters_2d.keys())[param2d]]
+                            dataparam = list(param)
+                            plot = plot_heatmap(datatime,datarange,dataparam,paramname)
+                        else:
+                            parameters_1d = array[list(array.keys())[0]]
+                            paramname = list(parameters_1d.keys())[param1d]
+                            param = parameters_1d[list(parameters_1d.keys())[param1d]]
+                            dataparam = list(param)
+                            plot = plot_scatter(datatime,dataparam,paramname)
+                    else:
+                        table = data[list(data.keys())[0]]
+                        a = list(table.dtype.fields.keys())
+                        index = a.index('ut2_unix')
+                        v = a[index:]
+                        paramname = v[param1d]
+                        dataparam = list(table[paramname])
+                        datatime = [datetime.datetime.fromtimestamp(t) for t in list(table['ut2_unix'])]
+                        plot = plot_scatter(datatime,dataparam,paramname)
+                return HttpResponse(plot)
+            def plot_scatter(datatime,dataparam,paramname):
+                if (numpy.isnan(dataparam).all()):
+                    plot = "There is no valid data available for this plot"
+                else:
+                    fig = go.Figure()
+                    fig.add_trace(go.Scatter(x=datatime, y=dataparam))
+                    fig.update_yaxes(title_text=paramname)
+                    delta = datatime[-1] - datatime[1]
+                    if (delta>datetime.timedelta(days=30)):
+                        # Add range slider
+                        fig.update_layout(
+                            xaxis=dict(
+                                rangeselector=dict(
+                                    buttons=list([
+                                        dict(count=1,
+                                            label="1m",
+                                            step="month",
+                                            stepmode="backward"),
+                                        dict(count=6,
+                                            label="6m",
+                                            step="month",
+                                            stepmode="backward"),
+                                        dict(count=1,
+                                            label="1y",
+                                            step="year",
+                                            stepmode="backward"),
+                                        dict(step="all")
+                                    ])
+                                ),
+                                rangeslider=dict(
+                                    visible=True
+                                ),
+                                type="date"
+                            )
+                        )
+                    plot = py.plot(fig, include_plotlyjs=False, output_type='div')
+                return plot
+            def plot_heatmap(datatime,datarange,dataparam,paramname):
+                if (numpy.isnan(dataparam).all()):
+                    plot = "There is no valid data available for this plot"
+                else:
+                    fig = go.Figure()
+                    fig.add_trace(go.Heatmap(x=datatime,y=datarange,z= dataparam,colorscale='Jet',colorbar={"title":paramname}))
+                    fig.update_yaxes(title_text="range")
+                    fig.update_layout(
+                        updatemenus=[
+                            dict(
+                                buttons=list([
+                                    dict(
+                                        args=["colorscale", "Jet"],
+                                        label="Jet",
+                                        method="restyle"
+                                    ),
+                                    dict(
+                                        args=["colorscale", "RdBu"],
+                                        label="Red-Blue",
+                                        method="restyle"
+                                    ),
+                                    dict(
+                                        args=["colorscale", "Viridis"],
+                                        label="Viridis",
+                                        method="restyle"
+                                    ),
+                                    dict(
+                                        args=["colorscale", "Cividis"],
+                                        label="Cividis",
+                                        method="restyle"
+                                    ),
+                                    dict(
+                                        args=["colorscale", "Greens"],
+                                        label="Greens",
+                                        method="restyle"
+                                    ),
+                                ]),
+                                type = "dropdown",
+                                direction="down",
+                                pad={"r": 10, "t": 10},
+                                showactive=True,
+                                x=0.1,
+                                xanchor="left",
+                                y=1.05,
+                                yanchor="top"
+                            ),
+                            dict(
+                                buttons=list([
+                                    dict(
+                                        args=[{"contours.showlines": False, "type": "contour"}],
+                                        label="Hide lines",
+                                        method="restyle"
+                                    ),
+                                    dict(
+                                        args=[{"contours.showlines": True, "type": "contour"}],
+                                        label="Show lines",
+                                        method="restyle"
+                                    ),
+                                ]),
+                                direction="down",
+                                pad={"r": 10, "t": 10},
+                                showactive=True,
+                                x=0.32,
+                                xanchor="left",
+                                y=1.05,
+                                yanchor="top"
+                            ),
+                        ]
+                    )
+                    fig.update_layout(
+                        annotations=[
+                            dict(text="Colorscale", showarrow=False,
+                                                x=0, xref="paper", y=1.03, yref="paper", align="left"),
+                            dict(text="Lines", x=0.25, xref="paper", y=1.03, yref="paper",
+                                         showarrow=False)
+                        ]
+                    )
+                    plot = py.plot(fig, include_plotlyjs=False, output_type='div')
+                return plot
             def download_as_is(request):
                 """download_as_is is a Ajax call that returns the download as is html to support the
                 single experiment UI.  Called when a user selects download/as is link.
                 Inputs:
                     request
                 """
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for downloadAsIs</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 expID =int(request.GET['experiment_list'])
                 file_list = request.GET['file_list']
                 form = madweb.forms.SingleExpDownloadAsIsForm({'format_select':file_list,
                                                                'expID': expID})
                 return render(request, 'madweb/download_as_is.html', {'form': form, 'exp_id':expID,
                                                                          'user_fullname':user_fullname,
                                                                          'user_email':user_email,
                                                                          'user_affiliation': user_affiliation})
             def download_file_as_is(request):
                 """download_file_as_is is a Ajax call that actually downloads a madrigal file.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 user_fullname = urllib.parse.unquote_plus(request.GET['user_fullname'])
                 user_email = request.GET['user_email']
                 user_affiliation = urllib.parse.unquote_plus(request.GET['user_affiliation'])
                 exp_id = request.GET['exp_id']
                 basename = request.GET['basename']
                 downloadFile = madWebObj.downloadFileAsIs(exp_id, basename, user_fullname, user_email, user_affiliation)
                 f = open(downloadFile, 'rb')
                 filename = os.path.basename(downloadFile)
                 chunk_size = 8192
                 file_type = mimetypes.guess_type(downloadFile)[0]
                 if file_type is None:
                     file_type = 'application/octet-stream'
                 response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                  content_type=file_type)
                 response['Content-Length'] = os.path.getsize(downloadFile)
                 response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                 response.set_cookie('fileDownload', 'true', path='/', samesite='Strict')
                 return(response)
             def print_as_is(request):
                 """print_as_is is a Ajax call that returns the text of the ascii file to support the
                 single experiment UI if request.GET has key "text", or the length of the file to be
                 downloaded if not.  Called when a user selects print/as is link.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 madParmObj = madrigal.data.MadrigalParameters(madDB)
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for printAsIs</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 expID =int(request.GET['experiment_list'])
                 basename = request.GET['file_list']
                 expDir = madExpObj.getExpDirByExpId(int(expID))
                 if expDir is None:
                     raise ValueError('No expDir found for exp_id %i' % (int(expID)))
                 fullFilename = os.path.join(expDir, basename)
                 # determine if we need to return the full file text, or just the size and name
                 if 'text' in request.GET:
                     madFileObj = madrigal.data.MadrigalFile(fullFilename, madDB)
                     measParms = madFileObj.getMeasuredParmList()
                     measParmMnemList = madParmObj.getParmMnemonicList(measParms) + madFileObj.getStandardParms(upper=True)
                     measParmDescList = madParmObj.getParmDescriptionList(measParmMnemList)
                     parmList = list(zip(measParmMnemList, measParmDescList))
                     f = open(request.GET['text'])
                     text = f.read()
                     f.close()
                     return render(request, 'madweb/print_as_is.html', {'text': text, 'parmList': parmList})
                 else:
                     tmpFilename = madWebObj.printFileAsIs(fullFilename, user_fullname, user_email, user_affiliation)
                     filesize = os.path.getsize(tmpFilename)
                     return(HttpResponse('%s:%s' % (filesize, tmpFilename)))
             def list_records(request):
                 """list_records is a Ajax call that returns the list records text.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 expID =int(request.GET['experiment_list'])
                 basename = request.GET['file_list']
                 expDir = madExpObj.getExpDirByExpId(int(expID))
                 if expDir is None:
                     raise ValueError('No expDir found for exp_id %i' % (int(expID)))
                 fullFilename = os.path.join(expDir, basename)
                 text = madWebObj.listRecords(fullFilename)
                 return render(request, 'madweb/list_records.html', {'expDir': expDir,
                                                                        'basename': basename,
                                                                        'text': text})
             def view_record_plot(request):
                 """view_record_plot returns the view individual record page.
                 Inputs:
                     request
                 """
                 expDir = request.GET['expDir']
                 basename = request.GET['basename']
                 recno = int(request.GET['recno'])
                 return render(request, 'madweb/view_record_plot.html', {'expDir': expDir,
                                                                            'basename': basename,
                                                                            'recno': recno})
             def view_record_image(request):
                 """view_record_plot is a Ajax call that returns the record plot.
                 Inputs:
                     request
                 """
                 expDir = request.GET['expDir']
                 basename = request.GET['basename']
                 recno = int(request.GET['recno'])
                 pngFiles = glob.glob(os.path.join(expDir, 'plots', basename, 'records/*%05i*.png' % (recno)))
                 image_data = open(pngFiles[0], "rb").read()
                 return HttpResponse(image_data, content_type="image/png")
             def show_info(request):
                 """show_info is a Ajax call that returns the text of the catalog/header text to support the
                 single experiment UI.  Called when a user selects show info link.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 expID =int(request.GET['experiment_list'])
                 basename = request.GET['file_list']
                 expDir = madExpObj.getExpDirByExpId(int(expID))
                 if expDir is None:
                     raise ValueError('No expDir found for exp_id %i' % (int(expID)))
                 fullFilename = os.path.join(expDir, basename)
                 madFileObj = madrigal.data.MadrigalFile(fullFilename, madDB)
                 text = madFileObj.getCatalogHeaderStr()
                 return render(request, 'madweb/show_info.html', {'text':text})
             def show_doi(request):
                 """show_doi is a Ajax call that returns the permanent url for references to support the
                 single experiment UI.  Called when a user selects show doi link.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 expID =request.GET['experiment_list']
                 basename = request.GET['file_list']
                 expDir = madExpObj.getExpDirByExpId(int(expID))
                 # get experiment PI and institution
                 PI = madExpObj.getPIByExpId(int(expID))
                 kinst = madExpObj.getKinstByExpId(int(expID))
                 startDTList = madExpObj.getExpStartDateTimeByExpId(int(expID))
                 yearStr = str(startDTList[0])
                 if PI is None:
                     PI = madInstObj.getContactName(kinst)
                 institution = madInstObj.getContactAddress1(kinst)
                 try:
                     madFileObj = madrigal.metadata.MadrigalMetaFile(madDB, os.path.join(expDir, 'fileTab.txt'))
                     url = madFileObj.getFileDOIUrlByFilename(basename)
                 except:
                     url = 'Unknown - please contact madrigal@haystack.mit.edu'
                 return render(request, 'madweb/show_doi.html', {'url':url, 'PI': PI, 'year': yearStr,
                                                                    'institution': institution})
             def get_advanced(request):
                 """get_advanced is a view that allows user to download/print files with selected parms
                 and filters.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWeb.getSiteInfo()
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 webFormatObj = madrigal.ui.web.MadrigalWebFormat()
                 madParmObj = madrigal.data.MadrigalParameters(madDB)
                 parmList = webFormatObj.getFormat('Comprehensive')
                 measParmList = []
                 derivedParmList = []
                 allParmList = []
                 sureParmList = []
                 if 'experiment_list' in request.GET:
                     expID = int(request.GET['experiment_list'])
                 else:
                     return(HttpResponse('<p>experiment_list required for getAdvanced</p>'))
                 basename = request.GET['file_list']
                 type = request.GET['type']
                 expDir = madExpObj.getExpDirByExpId(int(expID))
                 if expDir is None:
                     raise ValueError('No expDir found for exp_id %i' % (int(expID)))
                 fullFilename = os.path.join(expDir, basename)
                 expName, kindatDesc = madWeb.getInfoFromFile(fullFilename)
                 madFileObj = madrigal.data.MadrigalFile(fullFilename, madDB)
                 earliestTime = madFileObj.getEarliestTime()
                 latestTime = madFileObj.getLatestTime()
                 earliestDT = datetime.datetime(*earliestTime)
                 latestDT = datetime.datetime(*latestTime)
                 madFileObj.getMeasDervBothParmLists(parmList, measParmList, derivedParmList, allParmList, sureParmList)
                 allParmDescList = madParmObj.getParmDescriptionList(allParmList)
                 dataDict = {'type': type,
                             'fullFilename': fullFilename,
                             'madFileObj': madFileObj, 'parameters': [],
                             'measParmList': measParmList, 'derivedParmList': derivedParmList,
                             'allParmList': allParmList, 'allParmDescList': allParmDescList,
                             'madDB': madDB, 'madParmObj': madParmObj}
                 min_alt = madFileObj.getMinValidAltitude()
                 max_alt = madFileObj.getMaxValidAltitude()
                 try:
                     float(min_alt)
                     float(max_alt)
                     dataDict['min_alt'] = '%9.2f' % (min_alt)
                     dataDict['max_alt'] = '%9.2f' % (max_alt)
                 except:
                     pass
                 if 'AZM' in allParmList:
                     dataDict['min_az'] = '-180.0'
                     dataDict['max_az'] = '180.0'
                     dataDict['min_az2'] = '0.0'
                     dataDict['max_az2'] = '0.0'
                 if 'ELM' in allParmList:
                     dataDict['min_el'] = '0.0'
                     dataDict['max_el'] = '90.0'
                     dataDict['min_el2'] = '0.0'
                     dataDict['max_el2'] = '0.0'
                 if 'PL' in allParmList:
                     min_pl = madFileObj.getMinPulseLength()
                     max_pl = madFileObj.getMaxPulseLength()
                     try:
                         float(min_pl)
                         float(max_pl)
                         dataDict['min_pl'] = '%9.2f' % (min_pl)
                         dataDict['max_pl'] = '%9.2f' % (max_pl)
                     except:
                         pass
                 if type == 'download':
                     defaultFormat = 'Hdf5'
                 else:
                     defaultFormat = 'ascii'
                 dataDict['formats'] = defaultFormat
                 dataDict['missing'] = 'NaN'
                 dataDict['start_date'] = earliestDT
                 dataDict['end_date'] = latestDT
                 isprintForm = madweb.forms.IsprintForm(dataDict)
                 return render(request, 'madweb/get_advanced.html', {'form': isprintForm,
                                                                        'parmList': isprintForm.parmList,
                                                                        'measParmList': measParmList,
                                                                        'site_name': siteName, 'site_list': siteList,
                                                                        'expName': expName, 'kindatDesc': kindatDesc,
                                                                        'basename': os.path.basename(fullFilename),
                                                                        'type': type, 'bg_color': bg_color,
                                                                        'datetime': True})
             def advanced_download(request):
                 """advanced_download is a view that downloads a file with selected parms
                 and filters.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 webFormatObj = madrigal.ui.web.MadrigalWebFormat()
                 madParmObj = madrigal.data.MadrigalParameters(madDB)
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for advancedDownload</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 parmList = webFormatObj.getFormat('Comprehensive')
                 measParmList = []
                 derivedParmList = []
                 allParmList = []
                 sureParmList = []
                 madFileObj = madrigal.data.MadrigalFile(request.GET['fullFilename'], madDB)
                 madFileObj.getMeasDervBothParmLists(parmList, measParmList, derivedParmList, allParmList, sureParmList)
                 allParmDescList = madParmObj.getParmDescriptionList(allParmList)
                 request.GET._mutable = True
                 request.GET['madFileObj']=madFileObj
                 request.GET['measParmList']=measParmList
                 request.GET['derivedParmList']=derivedParmList
                 request.GET['allParmList']=allParmList
                 request.GET['allParmDescList']=allParmDescList
                 request.GET['start_date'] = request.GET['start_date'].strip()
                 request.GET['end_date'] = request.GET['end_date'].strip()
                 # convert dates to datetime
                 request.GET['start_date'] = datetime.datetime.strptime(request.GET['start_date'], '%Y-%m-%dT%H:%M:%S')
                 request.GET['end_date'] = datetime.datetime.strptime(request.GET['end_date'], '%Y-%m-%dT%H:%M:%S')
                 request.GET['madDB'] = madDB
                 request.GET['madParmObj'] = madParmObj
                 isprintForm = madweb.forms.IsprintForm(request.GET)
                 if not isprintForm.is_valid():
                     raise ValueError(str(isprintForm.errors))
                 downloadFile = madWeb.downloadIsprintFileFromIsprintForm(isprintForm.cleaned_data, user_fullname, user_email, user_affiliation)
                 f = open(downloadFile, 'rb')
                 filename = os.path.basename(downloadFile)
                 chunk_size = 8192
                 file_type = mimetypes.guess_type(downloadFile)[0]
                 if file_type is None:
                     file_type = 'application/octet-stream'
                 response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                  content_type=file_type)
                 response['Content-Length'] = os.path.getsize(downloadFile)
                 response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                 return(response)
             def advanced_print(request):
                 """advanced_download is a view that print a file with selected parms
                 and filters.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 webFormatObj = madrigal.ui.web.MadrigalWebFormat()
                 madParmObj = madrigal.data.MadrigalParameters(madDB)
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for advancedPrint</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 parmList = webFormatObj.getFormat('Comprehensive')
                 measParmList = []
                 derivedParmList = []
                 allParmList = []
                 sureParmList = []
                 madFileObj = madrigal.data.MadrigalFile(request.GET['fullFilename'], madDB)
                 madFileObj.getMeasDervBothParmLists(parmList, measParmList, derivedParmList, allParmList, sureParmList)
                 allParmDescList = madParmObj.getParmDescriptionList(allParmList)
                 fullFilename = request.GET['fullFilename']
                 expName, kindatDesc = madWeb.getInfoFromFile(fullFilename)
                 request.GET._mutable = True
                 request.GET['madFileObj']=madFileObj
                 request.GET['measParmList']=measParmList
                 request.GET['derivedParmList']=derivedParmList
                 request.GET['allParmList']=allParmList
                 request.GET['allParmDescList']=allParmDescList
                 request.GET['start_date'] = request.GET['start_date'].strip()
                 request.GET['end_date'] = request.GET['end_date'].strip()
                 # convert dates to datetime
                 request.GET['start_date'] = datetime.datetime.strptime(request.GET['start_date'], '%Y-%m-%dT%H:%M:%S')
                 request.GET['end_date'] = datetime.datetime.strptime(request.GET['end_date'], '%Y-%m-%dT%H:%M:%S')
                 request.GET['madDB'] = madDB
                 request.GET['madParmObj'] = madParmObj
                 isprintForm = madweb.forms.IsprintForm(request.GET)
                 if not isprintForm.is_valid():
                     raise ValueError(str(isprintForm.errors))
                 downloadFile = madWeb.downloadIsprintFileFromIsprintForm(isprintForm.cleaned_data, user_fullname, user_email, user_affiliation)
                 f = open(downloadFile, 'r')
                 file_text = f.read()
                 f.close()
                 os.remove(downloadFile)
                 return render(request, 'madweb/advanced_print.html', {'expName': expName, 'kindatDesc': kindatDesc,
                                                                        'basename': os.path.basename(fullFilename),
                                                                        'file_text': file_text, 'bg_color': bg_color})
             def view_list(request):
                 """view_list is the list experiment view.
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 responseDict = {'list_active': 'class="active"'}
                 form = madweb.forms.ListExpForm()
                 responseDict['form'] = form
                 responseDict['categoryList'] = form.categories
                 responseDict['instrumentList'] = form.instruments
                 responseDict['site_name'] = siteName
                 responseDict['site_list'] = siteList
                 responseDict['datetime'] = True
                 responseDict['bg_color'] = bg_color
                 return render(request, 'madweb/list.html', responseDict)
             def list_experiments(request):
                 """list_experiments is a view that lists all selected experiments.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWeb = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWeb.getSiteInfo()
                 listForm = madweb.forms.ListExpForm(request.GET)
                 try:
                     if not listForm.is_valid():
                         return(HttpResponse(str(listForm.errors)))
                 except KeyError:
                     return(HttpResponse('<p>Missing arguments in list_experiments</p>'))
                 kinstList = [int(kinst) for kinst in listForm.cleaned_data['instruments']]
                 startDate = listForm.cleaned_data['start_date']
                 startDT = datetime.datetime(startDate.year, startDate.month, startDate.day, 0, 0, 0)
                 endDate = listForm.cleaned_data['end_date']
                 endDT = datetime.datetime(endDate.year, endDate.month, endDate.day, 23, 59, 59)
                 localOnly = not listForm.cleaned_data['isGlobal']
                 expList = madWeb.getExperimentList(kinstList, startDT, endDT, localOnly)
                 return render(request, 'madweb/list_experiments.html', {'expList':expList, 'localOnly':localOnly,
                                                                            'list_active': 'class="active"', 'site_name': siteName,
                                                                            'site_list': siteList, 'bg_color': bg_color})
             def show_experiment(request):
                 """show_experiment call that returns the experiment page to support the list experiments UI.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 cookieDict = request.COOKIES
                 user_email = cookieDict['user_email']
                 queryDict = request.GET.copy()
                 queryDict['user_email'] = user_email
                 if 'show_plots' in queryDict:
                     plotsForm = madweb.forms.SingleExpPlotsForm(queryDict)
                 form = madweb.forms.SingleExpFileForm(queryDict)
                 if 'show_plots' in queryDict:
                     form.fields['plot_list'] = plotsForm.fields['plot_list']
                 if len(form.fields['file_list'].choices) > 1:
                     # this experiment has data files
                     return render(request, 'madweb/show_experiment.html', {'list_active': 'class="active"',
                                                                               'form': form, 'site_name': siteName,
                                                                               'site_list': siteList,
                                                                               'loader': 'loadPage',
                                                                               'bg_color': bg_color,
                                                                               'redirect': reverse('show_experiment')})
                 else:
                     # this experiment has no data files
                     form2 = madweb.forms.SingleExpPlotsForm(request.GET)
                     exp_desc = form.fields['exp_desc'].label
                     return render(request, 'madweb/show_exp_no_files.html', {'list_active': 'class="active"',
                                                                                 'form': form2, 'exp_desc': exp_desc,
                                                                                 'site_name': siteName,
                                                                                 'site_list': siteList,
                                                                                 'loader': 'loadPage',
                                                                                 'bg_color': bg_color,
                                                                                 'redirect': reverse('show_experiment')})
             def show_experiment_v2(request):
                 """show_experiment_v2 is a slight variant of show_experiment to accept old form
                 calls from Madrigal2 sites.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 cookieDict = request.COOKIES
                 user_email = cookieDict['user_email']
                 queryDict = request.GET.copy()
                 queryDict['user_email'] = user_email
                 queryDict['experiment_list'] = queryDict['exp']
                 form = madweb.forms.SingleExpFileForm(queryDict)
                 return render(request, 'madweb/show_experiment.html', {'list_active': 'class="active"',
                                                                           'form': form, 'site_name': siteName,
                                                                           'site_list': siteList,
                                                                           'loader': 'loadPage',
                                                                           'bg_color': bg_color,
                                                                           'redirect': reverse('show_experiment')})
             def choose_script(request):
                 """choose_script that returns the choose script page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 return render(request, 'madweb/choose_script.html', {'script_active': 'class="active"', 'site_name': siteName,
                                                                         'site_list': siteList, 'bg_color': bg_color})
             def download_as_is_script(request):
                 """download_as_is_script that returns the download_as_is_script script page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 responseDict = {'script_active': 'class="active"'}
                 form = madweb.forms.DownloadAsIsScriptForm()
                 responseDict['form'] = form
                 responseDict['categoryList'] = form.categories
                 responseDict['instrumentList'] = form.instruments
                 responseDict['kindatList'] = form.kindats
                 responseDict['site_name'] = siteName
                 responseDict['site_list'] = siteList
                 responseDict['datetime'] = True
                 responseDict['bg_color'] = bg_color
                 return render(request, 'madweb/download_as_is_script.html', responseDict)
             def generate_download_files_script(request):
                 """generate_download_files_script is a Ajax call that returns the generated file download script.
                 Inputs:
                     request
                 """
                 form = madweb.forms.DownloadAsIsScriptForm(request.GET)
                 if not form.is_valid():
                     raise ValueError('Form error: %s' % (form.errors))
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for generateDownloadFilesScript</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 madWebObj = madrigal.ui.web.MadrigalWeb()
                 script_text = madWebObj.generateDownloadFileScriptFromForm(form.cleaned_data, user_fullname,
                                                                            user_email, user_affiliation)
                 return render(request, 'madweb/download_files_script.html', {'script_text': script_text})
             def download_advanced_script(request):
                 """download_advanced_script that returns the download_advanced_script script page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 responseDict = {'script_active': 'class="active"'}
                 form = madweb.forms.DownloadAdvancedScriptForm()
                 responseDict['form'] = form
                 responseDict['categoryList'] = form.categories
                 responseDict['instrumentList'] = form.instruments
                 responseDict['kindatList'] = form.kindats
                 responseDict['site_name'] = siteName
                 responseDict['site_list'] = siteList
                 responseDict['datetime'] = True
                 responseDict['bg_color'] = bg_color
                 return render(request, 'madweb/download_advanced_script.html', responseDict)
             def generate_download_advanced_script(request):
                 """generate_download_advanced_script is a Ajax call that returns the generated advanced download script.
                 Inputs:
                     request
                 """
                 form1 = madweb.forms.DownloadAdvancedScriptForm(request.GET)
                 if not form1.is_valid():
                     raise ValueError('Form error: %s' % (form1.errors))
                 form2 = madweb.forms.AdvScriptParmsForm(request.GET)
                 if not form2.is_valid():
                     raise ValueError('Form error: %s' % (form2.errors))
                 form3 = madweb.forms.AdvScriptParmsFiltersForm(request.GET)
                 if not form3.is_valid():
                     raise ValueError('Form error: %s' % (form3.errors))
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for generateAdvancedDownloadScript</p>'))
                 user_fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 user_email = cookieDict['user_email']
                 user_affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 madWebObj = madrigal.ui.web.MadrigalWeb()
                 script_text = madWebObj.generateGlobalIsprintScriptFromForm(form1.cleaned_data, form2.cleaned_data,
                                                                             form3.cleaned_data, user_fullname,
                                                                             user_email, user_affiliation)
                 return render(request, 'madweb/download_files_script.html', {'script_text': script_text})
             def generate_parms_script(request):
                 """generate_parms_script is a Ajax call that returns the generated parameter script.
                 Inputs:
                     request
                 """
                 form = madweb.forms.AdvScriptParmsForm(request.GET)
                 return render(request, 'madweb/download_adv_parms_script.html', {'form': form,
                                                                                     'parmList': form.parmList})
             def generate_parms_filters_script(request):
                 """generate_parms_filters_script is a Ajax call that returns the generated parameter filters script.
                 Inputs:
                     request
                 """
                 form = madweb.forms.AdvScriptParmsFiltersForm(request.GET)
                 return render(request, 'madweb/download_adv_parms_filters_script.html', {'form': form})
             def ftp(request):
                 """ftp creates the first ftp page listing instruments
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 cookieDict = request.COOKIES
                 if not 'user_fullname' in cookieDict:
                     return(HttpResponse('<p>Cookie with user_fullname required for ftp</p>'))
                 fullname = django.utils.http.urlquote_plus(cookieDict['user_fullname'])
                 email = cookieDict['user_email']
                 affiliation = django.utils.http.urlquote_plus(cookieDict['user_affiliation'])
                 # create instrument with data list with tuple (instrument_name, kinst)
                 madInstDataObj = madrigal.metadata.MadrigalInstrumentData(madDB)
                 madInstList = [(instrument_name, kinst) for kinst, instrument_name, site_id in madInstDataObj.getInstruments(local=True)]
                 return render(request, 'madweb/ftp_instruments.html', {'madInstList': madInstList, 'fullname': fullname,
                                                                           'email': email, 'affiliation':affiliation, 'site_name': siteName,
                                                                           'site_list': siteList, 'bg_color': bg_color})
             def ftp_instrument(request, fullname, email, affiliation, kinst):
                 """ftp_instrument creates the first ftp instrument page listing years
                 Inputs: kinst selected
                 """
                 kinst = int(kinst)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madInstDataObj = madrigal.metadata.MadrigalInstrumentData(madDB)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 inst_name = madInstObj.getInstrumentName(kinst)
                 yearList = madInstDataObj.getInstrumentYears(kinst)
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 return render(request, 'madweb/ftp_years.html',{'yearList':yearList, 'kinst':kinst,
                                                                    'inst_name':inst_name, 'fullname': fullname,
                                                                    'email': email, 'affiliation':affiliation,
                                                                    'site_name': siteName, 'site_list': siteList,
                                                                    'bg_color': bg_color })
             def ftp_year(request, fullname, email, affiliation, kinst, year):
                 """ftp_year creates the first ftp year page listing kindats
                 Inputs: kinst selected, year selected
                 """
                 kinst = int(kinst)
                 year = int(year)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 inst_name = madInstObj.getInstrumentName(kinst)
                 madInstKindatObj = madrigal.metadata.MadrigalInstrumentKindats(madDB)
                 kindatList = madInstKindatObj.getKindatListForInstrumentYear(kinst, year)
                 madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                 # create kindatDescList, a list of tuples of (kindat_desc, kindat) for that kinst, year
                 kindatDescList = []
                 for kindat in kindatList:
                     kindatDescList.append((madKindatObj.getKindatDescription(kindat, kinst), kindat))
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 return render(request, 'madweb/ftp_kindats.html', {'kindatDescList': kindatDescList, 'year': year,
                                                                       'kinst': kinst, 'inst_name':inst_name, 'fullname': fullname,
                                                                       'email': email, 'affiliation':affiliation,
                                                                       'site_name': siteName, 'site_list': siteList,
                                                                       'bg_color': bg_color })
             def ftp_kindat(request, fullname, email, affiliation, kinst, year, kindat):
                 """ftp_kindat creates the first ftp format page listing formats to choose from
                 Inputs: kinst selected, year selected, kindat selected
                 """
                 kinst = int(kinst)
                 kindat = int(kindat)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                 kindat_desc = madKindatObj.getKindatDescription(kindat, kinst)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 inst_name = madInstObj.getInstrumentName(kinst)
                 formatDescList =  [(formatDict[key], key) for key in  list(formatDict.keys())]
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 return render(request, 'madweb/ftp_formats.html', {'formatDescList': formatDescList, 'year': year,
                                                                       'kinst': kinst, 'inst_name': inst_name, 'kindat': kindat,
                                                                       'kindat_desc': kindat_desc, 'fullname': fullname,
                                                                       'email': email, 'affiliation': affiliation,
                                                                       'site_name': siteName, 'site_list': siteList,
                                                                       'bg_color': bg_color } )
             def ftp_files(request, fullname, email, affiliation, kinst, year, kindat, format):
                 """ftp_files creates the ftp files page listing individual files
                 Inputs: kinst selected, year selected, kindat selected
                 """
                 kinst = int(kinst)
                 year = int(year)
                 dt = datetime.datetime(year,1,1) # speed up search
                 kindat = int(kindat)
                 if format not in ('hdf5', 'netCDF4', 'ascii'):
                     raise ValueError('Unknown format %s' % (format))
                 if format == 'netCDF4':
                     thisExt = '.nc'
                 elif format == 'ascii':
                     thisExt = '.txt'
                 format_desc = formatDict[format]
                 # create a list of full names, where each item is a tuple of
                 # (fullFilename in Madrigal, output basename with correct extension, date string)
                 fileList = []
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                 kindat_desc = madKindatObj.getKindatDescription(kindat, kinst)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 inst_name = madInstObj.getInstrumentName(kinst)
                 pi = madInstObj.getContactName(kinst)
                 pi_email = madInstObj.getContactEmail(kinst)
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDB)
                 startIndex = madExpObj.getStartPosition(dt) + 1
                 for loop in (0,1):
                     # we normally only loop once, but sometimes multi-year experiments require a slow full search
                     if loop == 0:
                         thisStartIndex = startIndex
                     else:
                         thisStartIndex = 0 # should only get to this case for rare multi-year experiments
                     for i in range(thisStartIndex, madExpObj.getExpCount()):
                         if kinst != madExpObj.getKinstByPosition(i):
                             continue
                         stTuple = madExpObj.getExpStartDateTimeByPosition(i)[0:6]
                         etTuple = madExpObj.getExpEndDateTimeByPosition(i)[0:6]
                         expTitle = madExpObj.getExpNameByPosition(i)
                         sDT = datetime.datetime(*stTuple)
                         eDT = datetime.datetime(*etTuple)
                         if sDT.year > year:
                             break
                         if eDT.year < year:
                             continue
                         dateStr = ' From %s to %s: %s' % (sDT.strftime('%Y-%m-%d %H:%M:%S'), eDT.strftime('%Y-%m-%d %H:%M:%S'), str(expTitle))
                         expDir = madExpObj.getExpDirByPosition(i)
                         # look at this exp for the right kindat
                         try:
                             madFileObj = madrigal.metadata.MadrigalMetaFile(madDB, os.path.join(expDir, 'fileTab.txt'))
                         except:
                             pass
                         for j in range(madFileObj.getFileCount()):
                             if madFileObj.getCategoryByPosition(j) not in (0,1):
                                 # skip history and alternate files
                                 continue
                             if madFileObj.getKindatByPosition(j) != kindat:
                                 continue
                             statusStr = ' : %s' % (str(madFileObj.getStatusByPosition(j)))
                             fullFilename = os.path.join(expDir, madFileObj.getFilenameByPosition(j))
                             fullBasename = os.path.basename(fullFilename)
                             if format != 'hdf5':
                                 base, file_extension = os.path.splitext(fullFilename)
                                 basename = os.path.basename(base + thisExt)
                             else:
                                 basename = os.path.basename(fullFilename)
                             # make sure this file isn't too big to create a cache
                             file_size = os.path.getsize(fullFilename)
                             if file_size > maxSize and format != 'hdf5':
                                 # make sure cached file exists before adding
                                 if format == 'netCDF4':
                                     cachedFile = os.path.join(expDir, 'overview', fullBasename + thisExt)
                                 else:
                                     cachedFile = os.path.join(expDir, 'overview', fullBasename + thisExt + '.gz')
                                 if not os.path.exists(cachedFile):
                                     continue
                             fileList.append((urllib.parse.quote_plus(fullFilename), basename, dateStr + statusStr))
                     if len(fileList) > 0:
                         break # usually we avoid the slow full loop
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 return render(request, 'madweb/ftp_files.html', {'fullFilenames': fileList, 'year': year, 'kindat_desc': kindat_desc,
                                                                     'kinst': kinst, 'inst_name':inst_name, 'fullname': fullname,
                                                                     'kindat': kindat, 'format': format, 'format_desc': format_desc,
                                                                     'email': email, 'affiliation':affiliation,
                                                                     'site_name': siteName, 'site_list': siteList,
                                                                     'pi_email': pi_email, 'pi_name': pi,
                                                                     'bg_color': bg_color})
             def ftp_download(request, user_fullname, user_email, user_affiliation, kinst, year, kindat, format, fullHdf5Filename):
                 """ftp_download creates the first ftp kindat page listing individual files
                 Inputs: kinst selected, year selected, kindat selected
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 user_fullname = urllib.parse.unquote_plus(user_fullname)
                 user_affiliation = urllib.parse.unquote_plus(user_affiliation)
                 fullHdf5Filename = urllib.parse.unquote_plus(fullHdf5Filename)
                 fullFilename = madWebObj.downloadFullFileAsIs(fullHdf5Filename, format, user_fullname, user_email, user_affiliation)
                 f = open(fullFilename, 'rb')
                 filename = os.path.basename(fullFilename)
                 chunk_size = 8192
                 file_type = mimetypes.guess_type(fullFilename)[0]
                 if file_type is None:
                     file_type = 'application/octet-stream'
                 response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                  content_type=file_type)
                 response['Content-Length'] = os.path.getsize(fullFilename)
                 response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                 return(response)
             @csrf_exempt
             def ftp_multiple_download(request):
                 """ftp_download creates the first ftp kindat page listing individual files
                 Inputs: kinst selected, year selected, kindat selected
                 """
                 if request.method == 'POST':
                     reqDict = request.POST
                 else:
                     reqDict = request.GET
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 user_fullname = urllib.parse.unquote_plus(reqDict.get('user_fullname'))
                 user_email = reqDict.get('user_email')
                 user_affiliation = urllib.parse.unquote_plus(reqDict.get('user_affiliation'))
                 format = reqDict.get('format')
                 fileList = reqDict.getlist('fullFilename')
                 fileList = [urllib.parse.unquote_plus(filename) for filename in fileList]
                 if len(fileList) > 10:
                     # send user an email with warning
                     tmpDir = os.path.join(madDB.getMadroot(), 'experiments/stage')
                     fullFilename = os.path.join(tmpDir, 'result_error_%06i.txt' % (random.randint(0,999999)))
                     f = open(fullFilename, 'w')
                     f.write('Error - you requested %i files, maximum is 10\n' % (len(fileList)))
                     f.close()
                 else:
                     fullFilename = madWebObj.downloadMultipleFiles(fileList, format, user_fullname, user_email, user_affiliation)
                 f = open(fullFilename, 'rb')
                 filename = os.path.basename(fullFilename)
                 chunk_size = 8192
                 file_type = mimetypes.guess_type(fullFilename)[0]
                 if file_type is None:
                     file_type = 'application/octet-stream'
                 response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                  content_type=file_type)
                 response['Content-Length'] = os.path.getsize(fullFilename)
                 response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                 return(response)
             def instrument_metadata(request):
                 """instrument_metadata returns the instrument_metadata page.
                 Inputs:
                     request
                 """
                 # create a list of tuples of (kinst, name, category, latitude, longitude, altitude, pi, pi_email, mnemonic)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 instList = []
                 for name, mnemonic, kinst, category, catID in madInstObj.getOrderedInstrumentList():
                     latitude = madInstObj.getLatitude(kinst)
                     longitude = madInstObj.getLongitude(kinst)
                     altitude = madInstObj.getAltitude(kinst)
                     pi = madInstObj.getContactName(kinst)
                     pi_email = madInstObj.getContactEmail(kinst)
                     instList.append((kinst, name, category, latitude, longitude, altitude, pi, pi_email, mnemonic))
                 responseDict = {'inst_active': 'class="active"', 'instList': instList,
                                 'site_name': siteName, 'site_list': siteList, 'bg_color': bg_color}
                 return render(request, 'madweb/instrument_metadata.html', responseDict)
             def site_metadata(request):
                 """site_metadata returns the site_metadata page.
                 Inputs:
                     request
                 """
                 # create a list of tuples of (siteId, name, url, contact, contact email, version)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, otherSiteList = madWebObj.getSiteInfo()
                 madSiteObj = madrigal.metadata.MadrigalSite(madDB)
                 siteList = []
                 for siteId, siteName in madSiteObj.getSiteList():
                     if madSiteObj.getSiteServer(siteId).find('http') == -1:
                         url = 'http://' + os.path.join(madSiteObj.getSiteServer(siteId),
                                                        madSiteObj.getSiteDocRoot(siteId))
                     else:
                         url = os.path.join(madSiteObj.getSiteServer(siteId),
                                            madSiteObj.getSiteDocRoot(siteId))
                     contact = madSiteObj.getSiteContactName(siteId)
                     contact_email = madSiteObj.getSiteEmail(siteId)
                     version = madSiteObj.getSiteVersion(siteId)
                     siteList.append((siteId, siteName, url, contact, contact_email, version))
                 responseDict = {'site_active': 'class="active"', 'siteList': siteList,
                                 'site_name': siteName, 'site_list': otherSiteList, 'bg_color': bg_color}
                 return render(request, 'madweb/site_metadata.html', responseDict)
             def parameter_metadata(request):
                 """parameter_metadata returns the site_metadata page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 madParmObj = madrigal.data.MadrigalParameters(madDB)
                 madParmCatObj = madrigal.metadata.MadrigalParmCategory(madDB)
                 parmDict = {} # key is category string, value is list of category tuples (mnemonic, description, units, code)
                 parmList = [] # list of tuples, each tuple either a single category, or (mnemonic, description, units, code)
                 categoryList = []
                 categoryUrlList = []
                 for mnemonic in madParmObj.getSortedMnemonicList():
                     description = madParmObj.getSimpleParmDescription(mnemonic)
                     units = madParmObj.getParmUnits(mnemonic)
                     code = madParmObj.getParmCodeFromMnemonic(mnemonic)
                     category = madParmObj.getParmCategory(mnemonic)
                     if category is None:
                         # deprecated prolog parm
                         continue
                     if category in list(parmDict.keys()):
                         parmDict[category].append((mnemonic, description, units, code))
                     else:
                         parmDict[category] = [(mnemonic, description, units, code)]
                 # now loop through all categories
                 for thisCategory, catId in madParmCatObj.getCategoryList():
                     parmList.append((thisCategory,))
                     categoryList.append(thisCategory)
                     categoryAnchor = thisCategory.replace(' ','_')
                     categoryUrlList.append('<a href="#%s">%s</a>' % (categoryAnchor, thisCategory))
                     for values in parmDict[thisCategory]:
                         parmList.append(values)
                 responseDict = {'parm_active': 'class="active"', 'parmList': parmList,
                                 'categoryUrlList':categoryUrlList,
                                 'site_name': siteName, 'site_list': siteList, 'bg_color': bg_color}
                 return render(request, 'madweb/parameter_metadata.html', responseDict)
             def kindat_metadata(request):
                 """kindat_metadata returns the kindat_metadata page.
                 Inputs:
                     request
                 """
                 # create a list of tuples of (kindat, description, kinst, instrument_name)
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madKindatObj = madrigal.metadata.MadrigalKindat(madDB)
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDB)
                 madInstKindatObj = madrigal.metadata.MadrigalInstrumentKindats(madDB)
                 # create a dict of key = kindat code, value list of associated instruments
                 kindatDict = {}
                 for name, mnem, kinst in madInstObj.getInstrumentList():
                     thisKindatList = madInstKindatObj.getKindatListForInstruments(kinst)
                     for kindat in thisKindatList:
                         if kindat not in kindatDict:
                             kindatDict[kindat] = [kinst]
                         else:
                             kindatDict[kindat].append(kinst)
                 kindatList = []
                 for description, code_str in madKindatObj.getKindatList():
                     try:
                         kinst, kindat = code_str.split('_')
                         instName = madInstObj.getInstrumentName(int(kinst))
                     except:
                         kindat = code_str
                         try:
                             kinst = str(kindatDict[int(kindat)][0])
                             instName = madInstObj.getInstrumentName(int(kinst))
                         except KeyError:
                             kinst = '-'
                             instName = 'Unspecified'
                     kindatList.append((kindat, description, kinst, instName))
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 responseDict = {'kindat_active': 'class="active"', 'kindatList': kindatList,
                                 'site_name': siteName, 'site_list': siteList, 'bg_color': bg_color}
                 return render(request, 'madweb/kindat_metadata.html', responseDict)
             def madrigal_calculator(request):
                 """madrigal_calculator returns the Madrigal Calculator page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 # original blank form
                 madCalculatorForm = madweb.forms.MadCalculatorForm()
                 parmList = [(parm, madCalculatorForm.parmDescDict[parm]) for parm in list(madCalculatorForm.parmDescDict.keys())]
                 return render(request, 'madweb/madrigal_calculator.html', {'madCalculator_active': 'class="active"',
                                                                               'form': madCalculatorForm,
                                                                               'parmList': parmList,
                                                                               'site_name': siteName, 'site_list': siteList,
                                                                               'bg_color': bg_color, 'datetime': True})
             def madrigal_calculator_output(request):
                 """madrigal_calculator returns the output from the Madrigal Calculator page.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 madCalculatorForm = madweb.forms.MadCalculatorForm(request.GET)
                 try:
                     if not madCalculatorForm.is_valid():
                         return(HttpResponse(str(madCalculatorForm.errors)))
                 except KeyError:
                     return(HttpResponse('<p>Missing arguments in madCalculatorOutput</p>'))
                 text = madWebObj.runMadrigalCalculatorFromForm(madCalculatorForm.cleaned_data)
                 return render(request, 'madweb/madrigal_calculator_output.html', {'madCalculator_active': 'class="active"',
                                                                                      'text': text,
                                                                                      'site_name': siteName, 'site_list': siteList,
                                                                                      'bg_color': bg_color})
             def get_metadata(request):
                 """get_metadata allows local metadata files to be downloaded.
                 Inputs:
                     request
                 """
                 fileDict = {'0':'expTab.txt',
                             '1': 'fileTab.txt',
                             '3': 'instTab.txt',
                             '4': 'parmCodes.txt',
                             '5': 'siteTab.txt',
                             '6': 'typeTab.txt',
                             '7': 'instKindatTab.txt',
                             '8': 'instParmTab.txt',
                             '9': 'madCatTab.txt',
                             '10': 'instType.txt'}
                 form = madweb.forms.GetMetadataForm(request.GET)
                 if form.is_valid():
                     madDB = madrigal.metadata.MadrigalDB()
                     downloadFile = os.path.join(madDB.getMetadataDir(),
                                                 fileDict[form.cleaned_data['fileType']])
                     f = open(downloadFile, 'rb')
                     filename = os.path.basename(downloadFile)
                     chunk_size = 8192
                     response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                      content_type=mimetypes.guess_type(downloadFile)[0])
                     response['Content-Length'] = os.path.getsize(downloadFile)
                     response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                     return(response)
                 else:
                     madDB = madrigal.metadata.MadrigalDB()
                     bg_color = madDB.getBackgroundColor()
                     form = madweb.forms.GetMetadataForm()
                     return render(request, 'madweb/get_metadata.html', {'form': form, 'bg_color': bg_color})
             def looker_main(request):
                 """looker_main loads the main looker selection form.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 lookerSelectForm = madweb.forms.LookerSelectForm()
                 return render(request, 'madweb/looker_main.html', {'looker_active': 'class="active"',
                                                                       'form': lookerSelectForm,
                                                                       'site_name': siteName, 'site_list': siteList,
                                                                       'bg_color': bg_color})
             def looker_form(request):
                 """looker_form loads the appropriate looker form.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 if not 'looker_options' in request.GET:
                     return(HttpResponse('<p>looker form requires looker_options</p>'))
                 form = madweb.forms.LookerSelectForm(request.GET)
                 if form.is_valid():
                     option = form.cleaned_data['looker_options']
                     if option == '1':
                         form = madweb.forms.LookerGeodeticRadar()
                         return render(request, 'madweb/looker_geodetic_to_radar.html', {'looker_active': 'class="active"',
                                                                                            'form': form,
                                                                                            'site_name': siteName, 'site_list': siteList,
                                                                                            'bg_color': bg_color})
                     elif option == '2':
                         form = madweb.forms.LookerGeomagRadar()
                         return render(request, 'madweb/looker_geomagnetic_to_radar.html', {'looker_active': 'class="active"',
                                                                                               'form': form,
                                                                                               'site_name': siteName, 'site_list': siteList,
                                                                                               'bg_color': bg_color})
                     elif option == '3':
                         form = madweb.forms.LookerGeomagFromGeodetic()
                         return render(request, 'madweb/looker_geomagnetic_from_geodetic.html', {'looker_active': 'class="active"',
                                                                                                    'form': form,
                                                                                                    'site_name': siteName, 'site_list': siteList,
                                                                                                    'bg_color': bg_color})
                     elif option == '4':
                         form = madweb.forms.LookerGeomagFromRadar()
                         return render(request, 'madweb/looker_geomagnetic_from_radar.html', {'looker_active': 'class="active"',
                                                                                                 'form': form,
                                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                                 'bg_color': bg_color})
                     elif option == '5':
                         form = madweb.forms.LookerFieldLineFromRadar()
                         return render(request, 'madweb/looker_field_line_from_radar.html', {'looker_active': 'class="active"',
                                                                                                'form': form,
                                                                                                'site_name': siteName, 'site_list': siteList,
                                                                                                'bg_color': bg_color})
                     elif option == '6':
                         form = madweb.forms.LookerFieldLineFromGeodetic()
                         return render(request, 'madweb/looker_field_line_from_geodetic.html', {'looker_active': 'class="active"',
                                                                                                   'form': form,
                                                                                                   'site_name': siteName, 'site_list': siteList,
                                                                                                   'bg_color': bg_color})
                     elif option == '7':
                         form = madweb.forms.LookerFieldLineFromApex()
                         return render(request, 'madweb/looker_field_line_from_apex.html', {'looker_active': 'class="active"',
                                                                                               'form': form,
                                                                                               'site_name': siteName, 'site_list': siteList,
                                                                                               'bg_color': bg_color})
                     elif option == '8':
                         form = madweb.forms.LookerConjugateFromGeodetic()
                         return render(request, 'madweb/looker_conjugate_from_geodetic.html', {'looker_active': 'class="active"',
                                                                                                  'form': form,
                                                                                                  'site_name': siteName, 'site_list': siteList,
                                                                                                  'bg_color': bg_color,
                                                                                                  'datetime': True})
                 else:
                     raise ValueError(str(form.errors))
             def looker_output(request):
                 """looker_output loads the appropriate looker output.
                 Inputs:
                     request
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 bg_color = madDB.getBackgroundColor()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 if not 'looker_options' in request.GET:
                     return(HttpResponse('<p>looker missing arguments</p>'))
                 if request.GET['looker_options'] == "1":
                     form = madweb.forms.LookerGeodeticRadar(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Az, El, Range to Geodetic points',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "2":
                     form = madweb.forms.LookerGeomagRadar(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Az, El, Range to Geomagnetic (apex) points',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "3":
                     form = madweb.forms.LookerGeomagFromGeodetic(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Apex Geomagnetic coordinates from Geodetic grid',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "4":
                     form = madweb.forms.LookerGeomagFromRadar(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Apex Geomagnetic and geodetic coordinates and aspect angle from a grid of azimuth, elevation, and range',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "5":
                     form = madweb.forms.LookerFieldLineFromRadar(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Field line coordinates for a field line set by radar parameters',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "6":
                     form = madweb.forms.LookerFieldLineFromGeodetic(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Field line coordinates and radar look parameters for given field line',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "7":
                     form = madweb.forms.LookerFieldLineFromApex(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Field line coordinates and radar look parameters for given field line',
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 elif request.GET['looker_options'] == "8":
                     form = madweb.forms.LookerConjugateFromGeodetic(request.GET)
                     if form.is_valid():
                         text = madWebObj.runLookerFromForm(form.cleaned_data)
                         return render(request, 'madweb/looker_output.html', {'looker_active': 'class="active"',
                                                                                 'type': 'Point/Magnetic Conjugate Point vs Latitude, Longitude, Altitude',
                                                                                 'datetime': form.cleaned_data['datetime'],
                                                                                 'text': text,
                                                                                 'site_name': siteName, 'site_list': siteList,
                                                                                 'bg_color': bg_color})
                     else:
                         raise ValueError(str(form.errors))
                 else:
                     raise ValueError('Unknown looker_option <%s>' % (str(request.GET['looker_options'])))
             def get_version_service(request):
                 """get_version_service runs the getVersionService.py service.
                 Inputs:
                     request (ignored)
                     Returns a single line of text, with the version in the form <major_version_int>.<minor_version_int>[.<sub_version_int>]
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 siteID = madDB.getSiteID()
                 madSiteObj = madrigal.metadata.MadrigalSite(madDB)
                 return(HttpResponse(madSiteObj.getSiteVersion(siteID)))
             def get_instruments_service(request):
                 """get_instruments_service runs the getInstrumentsService.py service.
                 Inputs:
                     request (ignored)
                     Returns comma-delimited data, one line for each experiment, with the following fields:
 . instrument.name  Example: 'Millstone Hill Incoherent Scatter Radar'
 . instrument.code Example: 30
 . instrument.mnemonic (3 char string) Example: 'mlh'
 . instrument.latitude  Example: 45.0
 . instrument.longitude  Example: 110.0
 . instrument.altitude   Example: 0.015 (km)
 . instrument.category  Example: 'Incoherent Scatter Radars'
 . contact name
 . contact email
                 """
                 # create MadrigalDB obj
                 madDBObj = madrigal.metadata.MadrigalDB()
                 # create MadrigalInstument object
                 madInst = madrigal.metadata.MadrigalInstrument(madDBObj)
                 # get instrument list
                 instList = madInst.getInstrumentList()
                 # loop through each instrument
                 instStr = ''
                 for inst in instList:
                     name = inst[0]
                     code = inst[2]
                     mnemonic = inst[1]
                     latitude = madInst.getLatitude(code)
                     if latitude == None:
                         latitude = 0.0
                     longitude = madInst.getLongitude(code)
                     if longitude == None:
                         longitude = 0.0
                     altitude = madInst.getAltitude(code)
                     if altitude == None:
                         altitude = 0.0
                     category = madInst.getCategory(code)
                     if category == None:
                         category = ''
                     # print data
                     contactName = madInst.getContactName(code)
                     contactEmail = madInst.getContactEmail(code)
                     instStr += '%s,%i,%s,%f,%f,%f,%s,%s,%s\n' % (name,
                                                                  code,
                                                                  mnemonic,
                                                                  latitude,
                                                                  longitude,
                                                                  altitude,
                                                                  category,
                                                                  str(contactName),
                                                                  str(contactEmail))
                 return render(request, 'madweb/service.html', {'text': instStr})
             def get_experiments_service(request):
                 """get_experiments_service runs the getExperimentsService.py service.
                 Inputs:
                     request/url - contains arguments:
                         code - one or more kindat values
                         startyear, startmonth, startday, starthour, startmin, startsec
                         endyear, endmonth, endday, endhour, endmin, endsec
                         local (defaults to True)
                 Returns comma-delimited data, one line for each experiment, with the following fields:
 . experiment.id (int) Example: 10000111
 . experiment.url (string) Example: 'http://www.haystack.mit.edu/cgi-bin/madtoc/1997/mlh/03dec97'
 . experiment.name (string) Example: 'Wide Latitude Substorm Study'
 . experiment.siteid (int) Example: 1
 . experiment.sitename (string) Example: 'Millstone Hill Observatory'
 . experiment.instcode (int) Code of instrument. Example: 30
 . experiment.instname (string) Instrument name. Example: 'Millstone Hill Incoherent Scatter Radar'
 . experiment.start year (int) year of experiment start
 . experiment.start month (int) month of experiment start
 . experiment.start day (int) day of experiment start
 . experiment.start hour (int) hour of experiment start
 . experiment.start minute (int) min of experiment start
 . experiment.start second (int) sec of experiment start
 . experiment.end year (int) year of experiment end
 . experiment.end month (int) month of experiment end
 . experiment.end day (int) day of experiment end
 . experiment.end hour (int) hour of experiment end
 . experiment.end minute (int) min of experiment end
 . experiment.end second (int) sec of experiment end
 . experiment.isLocal (int) 1 if local, 0 if not
 .experiment.PI (string) Experiment PI name Example: 'Phil Erickson'
 . experiment.PIEmail (string) Experiment PI email Example: 'perickson@haystack.mit.edu'
 . utc timestamp of last update to experiment
 . security value
                 """
                 codeList = request.GET.getlist('code')
                 codeList = [int(code) for code in codeList]
                 startyear = int(request.GET['startyear'])
                 startmonth = int(request.GET['startmonth'])
                 startday = int(request.GET['startday'])
                 starthour = int(request.GET['starthour'])
                 startmin = int(request.GET['startmin'])
                 startsec = int(request.GET['startsec'])
                 endyear = int(request.GET['endyear'])
                 endmonth = int(request.GET['endmonth'])
                 endday = int(request.GET['endday'])
                 endhour = int(request.GET['endhour'])
                 endmin = int(request.GET['endmin'])
                 endsec = int(request.GET['endsec'])
                 try:
                     local = int(request.GET['local'])
                 except:
                     local = 1
                 # if startsec or endsec in (60, 61), handle correctly
                 if startsec in (60, 61):
                     tmpTime = datetime.datetime(startyear,
                                                 startmonth,
                                                 startday,
                                                 starthour,
                                                 startmin,
 )
                     tmpTime += datetime.timedelta(0, startsec - 59)
                     startyear = tmpTime.year
                     startmonth = tmpTime.month
                     startday = tmpTime.day
                     starthour = tmpTime.hour
                     startmin = tmpTime.minute
                     startsec = tmpTime.second
                 if endsec in (60, 61):
                     tmpTime = datetime.datetime(endyear,
                                                 endmonth,
                                                 endday,
                                                 endhour,
                                                 endmin,
 )
                     tmpTime += datetime.timedelta(0, endsec - 59)
                     endyear = tmpTime.year
                     endmonth = tmpTime.month
                     endday = tmpTime.day
                     endhour = tmpTime.hour
                     endmin = tmpTime.minute
                     endsec = tmpTime.second
                 # if codeList is empty or contains 0, change it to only contain 0
                 if len(codeList) == 0 or 0 in codeList:
                     codeList = [0]
                 retStr = ''
                 # create MadrigalDB obj
                 madDBObj = madrigal.metadata.MadrigalDB()
                 # get the local site id
                 localSiteId = madDBObj.getSiteID()
                 # create MadrigalInstrument obj to convert kinst to instrument names
                 madInstObj = madrigal.metadata.MadrigalInstrument(madDBObj)
                 # create MadrigalSite obj to convert site id to site name
                 madSiteObj = madrigal.metadata.MadrigalSite(madDBObj)
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDBObj)
                 trusted = madWebObj.isTrusted()
                 # create starttime for filter, if possible
                 if startyear != None:
                     startTimeFilter = datetime.datetime(startyear,
                                     startmonth,
                                     startday,
                                     starthour,
                                     startmin,
                                     startsec)
                 else:
                     startTimeFilter = None
                 # create endtime for filter, if possible
                 if endyear != None:
                     endTimeFilter = datetime.datetime(endyear,
                                       endmonth,
                                   endday,
                                   endhour,
                                   endmin,
                                   endsec)
                 else:
                     endTimeFilter = None
                 # create MadrigalExperiments for local or all files
                 if local == 1:
                     madExpObj = madrigal.metadata.MadrigalExperiment(madDBObj)
                 else:
                     # use file expTabAll.txt to get all experiments
                     filename = madDBObj.getMadroot()
                     if filename[-1] != '/':
                         filename += '/'
                     filename += 'metadata/expTabAll.txt'
                     madExpObj = madrigal.metadata.MadrigalExperiment(madDBObj, filename)
                 madExpObj.sortByDateSite()
                 # loop through the data
                 if not startTimeFilter is None:
                     position = madExpObj.getStartPosition(startTimeFilter)
                 else:
                     position = 0
                 while(True):
                     thisId = madExpObj.getExpIdByPosition(position)
                     # check for end
                     if thisId == None:
                         break
                     thisUrl = madExpObj.getExpUrlByPosition(position)
                     thisName = madExpObj.getExpNameByPosition(position)
                     thisSiteId = madExpObj.getExpSiteIdByPosition(position)
                     thisSiteName = madSiteObj.getSiteName(thisSiteId)
                     thisInstCode = madExpObj.getKinstByPosition(position)
                     thisInstName =madInstObj.getInstrumentName(thisInstCode)
                     thisStart = madExpObj.getExpStartDateTimeByPosition(position)
                     thisEnd = madExpObj.getExpEndDateTimeByPosition(position)
                     thisSecurity = madExpObj.getSecurityByPosition(position)
                     if thisSiteId == localSiteId:
                         thisLocal = 1
                     else:
                         thisLocal = 0
                     thisPI = madExpObj.getPIByPosition(position)
                     if thisPI in (None, ''):
                         thisPI = madInstObj.getContactName(thisInstCode)
                     thisPIEmail = madExpObj.getPIEmailByPosition(position)
                     if thisPIEmail in (None, ''):
                         thisPIEmail = madInstObj.getContactEmail(thisInstCode)
                     expDir = madExpObj.getExpDirByPosition(position)
                     position += 1
                     # some experiments set the end of the day to 24:00:00 - not
                     # technically correct - reset to 23:59:59
                     if (thisStart[3] == 24 and thisStart[4] == 0 and thisStart[5] == 0):
                         thisStart[3] = 23
                         thisStart[4] = 59
                         thisStart[5] = 59
                     if (thisEnd[3] == 24 and thisEnd[4] == 0 and thisEnd[5] == 0):
                         thisEnd[3] = 23
                         thisEnd[4] = 59
                         thisEnd[5] = 59
                     # apply filters
                     # first apply instrument code filter
                     if codeList[0] != 0:
                         if thisInstCode not in codeList:
                             continue
                     # apply starttime and endtime filters
                     thisStartTime = datetime.datetime(thisStart[0],
                                                       thisStart[1],
                                                       thisStart[2],
                                                       thisStart[3],
                                                       thisStart[4],
                                                       thisStart[5])
                     thisEndTime = datetime.datetime(thisEnd[0],
                                                     thisEnd[1],
                                                     thisEnd[2],
                                                     thisEnd[3],
                                                     thisEnd[4],
                                                     thisEnd[5])
                     if startTimeFilter != None:
                         if thisEndTime < startTimeFilter:
                             continue
                     if endTimeFilter != None:
                         if thisStartTime > endTimeFilter:
                             continue
                     # apply local filer
                     if local == 1 and thisLocal == 0:
                         continue
                     # apply security filter
                     if trusted == 0 and thisSecurity not in (0,2):
                         continue
                     # create exp timestamp
                     if local == 1:
                         thisUTTimestamp = int(os.stat(expDir).st_mtime + time.timezone)
                     else:
                         thisUTTimestamp = 0
                     # add this experiment
                     retStr += '%i,%s,%s,%i,%s,%i,%s,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%s,%s,%i,%i\n' % \
                             (thisId,
                             thisUrl,
                             thisName,
                             thisSiteId,
                             thisSiteName,
                             thisInstCode,
                             thisInstName,
                             thisStart[0],
                             thisStart[1],
                             thisStart[2],
                             thisStart[3],
                             thisStart[4],
                             thisStart[5],
                             thisEnd[0],
                             thisEnd[1],
                             thisEnd[2],
                             thisEnd[3],
                             thisEnd[4],
                             thisEnd[5],
                             thisLocal,
                             str(thisPI),
                             str(thisPIEmail),
                             thisUTTimestamp,
                             thisSecurity)
                 return render(request, 'madweb/service.html', {'text': retStr})
             def get_experiment_files_service(request):
                 """get_experiment_files_service runs the getExperimentFilesService.py service.
                 Inputs:
                     request/url - contains arguments:
                         id - local experiment id
                     Returns comma-delimited data, one line for each experiment file, with the following fields:
 . file.name (string) Example '/opt/mdarigal/blah/mlh980120g.001'
 . file.kindat (int) Kindat code.  Example: 3001
 . file.kindat desc (string) Kindat description: Example 'Basic Derived Parameters'
 . file.category (int) (1=default, 2=variant, 3=history, 4=real-time)
 . file.status (string)('preliminary', 'final', or any other description)
 . file.permission (int)  0 for public, 1 for private.  For now will not return private files.
 . file DOI (string) - citable url to file
                     Returns empty string if experiment id not found.  Skips files that are not Hdf5
                 """
                 id = int(request.GET['id'])
                 # create MadrigalDB obj
                 madDBObj = madrigal.metadata.MadrigalDB()
                 # create MadrigalExperiments object to get full file name
                 madExpObj = madrigal.metadata.MadrigalExperiment(madDBObj)
                 # create Madrigal Kindat to get Kindat descriptions
                 madKindatObj = madrigal.metadata.MadrigalKindat(madDBObj)
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDBObj)
                 trusted = madWebObj.isTrusted()
                 retStr = ''
                 thisUrl = madExpObj.getExpUrlByExpId(id)
                 if thisUrl is None:
                     raise IOError('No such id: %i' % (id))
                 expPath = madExpObj.getExpDirByExpId(id)
                 kinst = madExpObj.getKinstByExpId(id)
                 if os.access(os.path.join(expPath, 'fileTab.txt'), os.R_OK):
                     madFileObj = madrigal.metadata.MadrigalMetaFile(madDBObj, os.path.join(expPath, 'fileTab.txt'))
                     for i in range(madFileObj.getFileCount()):
                         basename = madFileObj.getFilenameByPosition(i)
                         name = os.path.join(expPath, basename)
                         base_filename, file_extension = os.path.splitext(name)
                         if file_extension not in ('.hdf5', '.hdf', '.h5'):
                             continue
                         kindat = madFileObj.getKindatByPosition(i)
                         kindatdesc = madKindatObj.getKindatDescription(kindat, kinst)
                         category = madFileObj.getCategoryByPosition(i)
                         status = madFileObj.getStatusByPosition(i)
                         permission = madFileObj.getAccessByPosition(i)
                         doi = madFileObj.getFileDOIUrlByPosition(i)
                         # skip private files if not trusted
                         if trusted == 0 and int(permission) != 0:
                             continue
                         retStr += '%s,%i,%s,%i,%s,%i,%s\n' % \
                                (name,
                                 kindat,
                                 kindatdesc,
                                 category,
                                 status,
                                 permission,
                                 doi)
                 return render(request, 'madweb/service.html', {'text': django.utils.safestring.mark_safe(retStr)})
             def get_parameters_service(request):
                 """get_parameters_service runs the getParametersService.py service.
                 Inputs:
                     request/url - contains arguments:
                         filename=<full path to data file>
                     Returns backslash-delimited data, one for each parameter either measured or derivable, with the following fields:
 . parameter.mnemonic (string) Example 'dti'
 . parameter.description (string) Example:
                             "F10.7 Multiday average observed (Ott)"
 . parameter.isError (int) 1 if error parameter, 0 if not
 . parameter.units (string) Example "W/m2/Hz"
 . parameter.isMeasured (int) 1 if measured, 0 if derivable
 . parameter.category (string) Example: "Time Related Parameter"
 . parameter.isSure (int) - 1 if parameter can be found for every record, 0 if can only be found for some.
                             Not relevant to Madrigal 3, where always 1
 . parameter.isAddIncrement - 1 if additional increment, 0 if normal (Added in Madrigal 2.5)
                             Not relevant to Madrigal 3, where always -1
                 """
                 filename = request.GET['filename']
                 # create MadrigalDB obj
                 madDBObj = madrigal.metadata.MadrigalDB()
                 # create Madrigal File object
                 madFileObj = madrigal.data.MadrigalFile(filename, madDBObj)
                 # create Madrigal Parameter object
                 madParmObj = madrigal.data.MadrigalParameters(madDBObj)
                 # create Madrigal web object
                 madWebObj = madrigal.ui.web.MadrigalWebFormat()
                 # create lists of parameters
                 measParmList = []
                 derivedParmList = []
                 allParmList = []
                 sureParmList = []
                 # use the comprehensive list of parameters to check if derivable
                 parmList = madWebObj.getFormat('Comprehensive')
                 # populate lists
                 madFileObj.getMeasDervBothParmLists(parmList,
                                                     measParmList,
                                                     derivedParmList,
                                                     allParmList,
                                                     sureParmList)
                 retStr = ''
                 # loop through allParmList and output results
                 for parm in allParmList:
                     description = madParmObj.getSimpleParmDescription(parm)
                     isNorm = madParmObj.getParmType(parm)
                     if isNorm == 1:
                         isError = 0
                     else:
                         isError = 1
                     units = madParmObj.getParmUnits(parm)
                     if parm in measParmList:
                         isMeasured = 1
                     else:
                         isMeasured = 0
                     if parm in sureParmList:
                         isSure = 1
                     else:
                         isSure = 0
                     category = madParmObj.getParmCategory(parm)
                     try:
                         if madParmObj.isAddIncrement(parm):
                             isAddIncrement = 1
                         else:
                             isAddIncrement = 0
                     except:
                         isAddIncrement = -1
                     # print out this parm
                     retStr += '%s\\%s\\%i\\%s\\%i\\%s\\%i\\%i\n' % (parm,
                                                             description,
                                                             isError,
                                                             units,
                                                             isMeasured,
                                                             category,
                                                             isSure,
                                                             isAddIncrement)
                 return render(request, 'madweb/service.html', {'text': retStr})
             def isprint_service(request):
                 """isprint_service runs the isprintService.py service.
                 Inputs:
                     request/url - contains arguments:
                         'file': The full path to the file to be analyzed by isprint.  If over 50 MB, returns error message.
                         'parms': Multiple requested parameters, space (+) separated.
                         'filters': Multiple of filters desired, as in isprint command
                         'user_fullname'     user name
                         'user_email'        user email
                         'user_affiliation'  user affiliation
                         'output' - option argument specifying output file basename.  Will be Hdf5 format if extension in
                             ('hdf5', 'h5', 'hdf').  Will be netCDF4 is extension is '.nc'. Otherwise ascii. If not
                             given, output is ascii.
                         'header':  t for headers, f for no header.  Defaults to no header. Ignored if not ascii output
                 Returns data as either column delimited ascii, Hdf5, or netCDF4.
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 # get required arguments
                 thisFile = request.GET['file']
                 parms = request.GET.getlist('parms')
                 filters = request.GET.getlist('filters')
                 user_fullname = request.GET['user_fullname']
                 user_email = request.GET['user_email']
                 user_affiliation = request.GET['user_affiliation']
                 # get optional arguments
                 try:
                     output = os.path.basename(request.GET['output'])
                     filename, file_extension = os.path.splitext(output)
                     if file_extension in ('.hdf5', '.h5', '.hdf'):
                         format = 'Hdf5'
                     elif file_extension in ('.nc',):
                         format = 'netCDF4'
                     else:
                         format = 'ascii'
                 except:
                     format = 'ascii'
                     output = None
                 # verify thisFile exists, not too big
                 errorMessage = None
                 if not os.access(thisFile, os.R_OK):
                     errorMessage = 'File %s not found' % (thisFile)
                 elif os.path.getsize(thisFile) > 200.0E6:
                     errorMessage = 'File %s greater than 200 MB in size - running dynamic file creation not possible.  Please use  -- download as is -- instead.' % (thisFile)
                 if not errorMessage is None:
                     return render(request, 'madweb/service.html', {'text': errorMessage})
                 if not output is None:
                     # we need to write to a download file
                     downloadFile = os.path.join(tempfile.gettempdir(), output)
                     if os.access(downloadFile, os.R_OK):
                         try:
                             os.remove(downloadFile)
                         except:
                             pass
                 try:
                     header = request.GET['header']
                     if header not in ('t', 'f'):
                         raise ValueError('Unknown header value <%s>' % (header))
                 except:
                     header = 'f'
                 # log data access
                 madWebObj.logDataAccess(thisFile, user_fullname, user_email, user_affiliation)
                 # run isprint command
                 cmd = '%s/bin/isprint file=%s ' % (madDB.getMadroot(), thisFile)
                 if not output is None:
                     cmd += 'output=%s ' % (downloadFile)
                 delimiter = ' '
                 cmd += delimiter.join(parms) + ' '
                 filterStr = delimiter.join(filters)
                 cmd += filterStr + ' '
                 if format == 'ascii':
                     cmd += 'summary=f '
                     cmd += 'header=%s ' % (header)
                 if output is None:
                     # text response
                     #result = subprocess.check_output(cmd.split())
                     p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
                     result,errtext = p.communicate()
                     if p.returncode != 0:
                         result = errtext
                     if type(result) in (bytes, numpy.bytes_):
                         result = result.decode('utf-8')
                     if header == 'f':
                         index = result.find('\n')
                         result = result[index+1:]
                     return render(request, 'madweb/service.html', {'text': result})
                 else:
                     # file download response
                     #subprocess.check_call(cmd.split())
                     p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
                     result,errtext = p.communicate()
                     if p.returncode != 0:
                         # write the error to result file
                         f = open(downloadFile, 'w')
                         if type(errtext) in (bytes, numpy.bytes_):
                             errtext = errtext.decode('utf-8')
                         f.write(errtext)
                         f.close()
                     f = open(downloadFile, 'rb')
                     filename = os.path.basename(downloadFile)
                     chunk_size = 8192
                     file_type = mimetypes.guess_type(downloadFile)[0]
                     if file_type is None:
                         file_type = 'application/octet-stream'
                     response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                      content_type=file_type)
                     response['Content-Length'] = os.path.getsize(downloadFile)
                     response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                     os.remove(downloadFile)
                     return(response)
             def get_madfile_service(request):
                 """get_madfile_service runs the getMadfile.cgi service.
                 Inputs:
                     request/url - contains arguments:
                         'fileName': The full path to the file to be downloaded as.
                         'fileType': -1 for ascii, -2 for Hdf5, -3 for netCDF4. No other values supported
                         'user_fullname'     user name
                         'user_email'        user email
                         'user_affiliation'  user affiliation
                 Returns file as either column delimited ascii, Hdf5, or netCDF4.
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 # get required arguments
                 fileName = request.GET['fileName']
                 fileType = int(request.GET['fileType'])
                 user_fullname = request.GET['user_fullname']
                 user_email = request.GET['user_email']
                 user_affiliation = request.GET['user_affiliation']
                 if fileType not in (-1, -2, -3):
                     return(HttpResponse('<p>fileType %i not allowed: -1 for ascii, -2 for Hdf5, -3 for netCDF4</p>' % (fileType)))
                 # log data access
                 madWebObj.logDataAccess(fileName, user_fullname, user_email, user_affiliation)
                 if fileType in (-1, -3):
                     # may need to create temp file
                     filepath, file_extension = os.path.splitext(fileName)
                     basename = os.path.basename(filepath)
                     dirname = os.path.dirname(fileName)
                     if fileType == -1:
                         cachedTxtFile = os.path.join(dirname, 'overview', os.path.basename(fileName) + '.txt.gz')
                         tmpFile = os.path.join(tempfile.gettempdir(), basename + '.txt.gz')
                         if os.access(cachedTxtFile, os.R_OK):
                             shutil.copy(cachedTxtFile, tmpFile)
                         else:
                             tmpFile = os.path.join(tempfile.gettempdir(), basename + '.txt')
                             madrigal.cedar.convertToText(fileName, tmpFile)
                     else:
                         cachedNCFile = os.path.join(dirname, 'overview', os.path.basename(fileName) + '.nc')
                         tmpFile = os.path.join(tempfile.gettempdir(), basename + '.nc')
                         if os.access(cachedNCFile, os.R_OK):
                             shutil.copy(cachedNCFile, tmpFile)
                         else:
                             try:
                                 madrigal.cedar.convertToNetCDF4(fileName, tmpFile)
                             except IOError:
                                 cedarObj = madrigal.cedar.MadrigalCedarFile(fileName)
                                 cedarObj.write('netCDF4', tmpFile)
                 else:
                     tmpFile = fileName
                 f = open(tmpFile, 'rb')
                 filename = os.path.basename(tmpFile)
                 chunk_size = 8192
                 file_type = mimetypes.guess_type(tmpFile)[0]
                 if file_type is None:
                     file_type = 'application/octet-stream'
                 response = StreamingHttpResponse(FileWrapper(f, chunk_size),
                                                  content_type=file_type)
                 response['Content-Length'] = os.path.getsize(tmpFile)
                 response['Content-Disposition'] = "attachment; filename=%s" % (filename)
                 if fileType in (-1, -3):
                     os.remove(tmpFile)
                 return(response)
             def mad_calculator_service(request):
                 """mad_calculator_service runs the madCalculator service.
                 Inputs:
                     request/url - contains arguments:
                         year, month, day, hour, min, sec
                         startLat - Starting geodetic latitude, -90 to 90 (float)
                         endLat - Ending geodetic latitude, -90 to 90 (float)
                         stepLat - Latitude step (0.1 to 90) (float)
                         startLong - Starting geodetic longitude, -180 to 180  (float)
                         endLong - Ending geodetic longitude, -180 to 180 (float)
                         stepLong - Longitude step (0.1 to 180) (float)
                         startAlt - Starting geodetic altitude, >= 0 (float)
                         endAlt - Ending geodetic altitude, > 0 (float)
                         stepAlt - Altitude step (>= 0.1) (float)
                         parms - comma delimited string of Madrigal parameters desired
                         oneD - zero or more mnemonics,float values to set input 1D values
                 Returns comma-delimited data, one line for each combination of lat, long, and alt,
                 with the following fields:
 . latitude
 . longitude
 . altitude
 . Values for each Madrigal parameter listed in argument parms, separated by whitespace
                 """
                 year = int(request.GET['year'])
                 month = int(request.GET['month'])
                 day = int(request.GET['day'])
                 hour = int(request.GET['hour'])
                 minute = int(request.GET['min'])
                 second = int(request.GET['sec'])
                 try:
                     dt = datetime.datetime(year, month, day, hour, minute, second)
                 except:
                     return(HttpResponse('Illegal time: year %i, month %i, day %i, hour %i, minute %i, second %i' % (year, month, day, hour, minute, second)))
                 startLat = float(request.GET['startLat'])
                 endLat = float(request.GET['endLat'])
                 if startLat == endLat:
                     endLat += 0.001
                 elif startLat > endLat:
                     return(HttpResponse('startLat %s cannot be greater than endLat %s' % (str(startLat), str(endLat))))
                 stepLat = float(request.GET['stepLat'])
                 if stepLat < 0.0:
                     return(HttpResponse('stepLat %s cannot be less than zero' % (str(stepLat))))
                 elif stepLat == 0.0:
                     stepLat = 0.001
                 latList = list(numpy.arange(startLat, endLat, stepLat))
                 startLong = float(request.GET['startLong'])
                 endLong = float(request.GET['endLong'])
                 if startLong == endLong:
                     endLong += 0.001
                 elif startLong > endLong:
                     return(HttpResponse('startLong %s cannot be greater than endLong %s' % (str(startLong), str(endLong))))
                 stepLong = float(request.GET['stepLong'])
                 if stepLong < 0.0:
                     return(HttpResponse('stepLong %s cannot be less than zero' % (str(stepLong))))
                 elif stepLong == 0.0:
                     stepLong = 0.001
                 lonList = list(numpy.arange(startLong, endLong, stepLong))
                 startAlt = float(request.GET['startAlt'])
                 endAlt = float(request.GET['endAlt'])
                 if startAlt == endAlt:
                     endAlt += 0.001
                 elif startAlt > endAlt:
                     return(HttpResponse('startAlt %s cannot be greater than endAlt %s' % (str(startAlt), str(endAlt))))
                 stepAlt = float(request.GET['stepAlt'])
                 if stepAlt < 0.0:
                     return(HttpResponse('stepAlt %s cannot be less than zero' % (str(stepAlt))))
                 elif stepAlt == 0.0:
                     stepAlt = 0.01
                 altList = list(numpy.arange(startAlt, endAlt, stepAlt))
                 # limit total calculations to 1E5
                 total = len(latList) * len(lonList) * len(altList)
                 if total > 1.0E5:
                     return(HttpResponse('Too many points for madCalculatorService: %i' % (total)))
                 parms = request.GET['parms']
                 desiredParmList = [item.strip() for item in ['gdlat','glon','gdalt'] + parms.split(',')]
                 oneDList = request.GET.getlist('oneD')
                 oneDParmDict = {}
                 for oneDStr in oneDList:
                     mnem, strValue = oneDStr.split(',')
                     oneDParmDict[mnem] = [float(strValue)]
                 # capture stdout
                 old_stdout = sys.stdout
                 sys.stdout = mystdout = io.StringIO()
                 madrigal.isprint.MadCalculatorGrid(None, desiredParmList, [dt], latList, lonList, altList,
                                                oneDParmDict, summary=None)
                 text = mystdout.getvalue()
                 sys.stdout = old_stdout
                 return render(request, 'madweb/service.html', {'text': text})
             def mad_time_calculator_service(request):
                 """mad_time_calculator_service runs the madTimeCalculator service.  Input parameters must not be location dependent
                 Inputs:
                     request/url - contains arguments:
 . startyear - int
 . startmonth - int
 . startday - int
 . starthour - int
 . startmin - int
 . startsec - int
 . endyear - int
 . endmonth - int
 . endday - int
 . endhour - int
 . endmin - int
 . endsec - int
 . stephours - float - number of hours per time step
 . parms - comma delimited string of Madrigal parameters desired (must not depend on location)
                 Returns comma-delimited data, one line for each year, month, day, hour, minute, and second,
                 with the following fields:
 -6: year, month, day, hour, minute, and second
 . requested parm fields
                 """
                 startyear = int(request.GET['startyear'])
                 startmonth = int(request.GET['startmonth'])
                 startday = int(request.GET['startday'])
                 starthour = int(request.GET['starthour'])
                 startminute = int(request.GET['startmin'])
                 startsecond = int(request.GET['startsec'])
                 endyear = int(request.GET['endyear'])
                 endmonth = int(request.GET['endmonth'])
                 endday = int(request.GET['endday'])
                 endhour = int(request.GET['endhour'])
                 endminute = int(request.GET['endmin'])
                 endsecond = int(request.GET['endsec'])
                 dt1 = datetime.datetime(startyear, startmonth, startday, starthour, startminute, startsecond)
                 dt2 = datetime.datetime(endyear, endmonth, endday, endhour, endminute, endsecond)
                 if dt1 > dt2:
                     return(HttpResponse('End Datetime %s cannot be before start datetime %s' % (str(dt2), str(dt1))))
                 stephours = float(request.GET['stephours'])
                 if stephours <= 0.0:
                     return(HttpResponse('stephours cannot be non-positive: %f' % (stephours)))
                 dtList = []
                 while dt1 <= dt2:
                     dtList.append(dt1)
                     dt1 += datetime.timedelta(hours=stephours)
                 parms = request.GET['parms']
                 desiredParmList = [item.strip() for item in ['year','month','day','hour','min','sec'] + parms.split(',')]
                 # no spatial data
                 latList = lonList = altList = []
                 # capture stdout
                 old_stdout = sys.stdout
                 sys.stdout = mystdout = io.StringIO()
                 madrigal.isprint.MadCalculatorGrid(None, desiredParmList, dtList, latList, lonList, altList,
                                                summary=None)
                 text = mystdout.getvalue()
                 sys.stdout = old_stdout
                 return render(request, 'madweb/service.html', {'text': text})
             @csrf_exempt
             def mad_calculator2_service(request):
                 """mad_calculator2_service runs the madCalculator2 service.
                 Differs from madCalulator in that positions are a list rather than a grid.
                 Inputs:
                     request/url - contains arguments:
                         year, month, day, hour, min, sec
                         lats - comma separated list of latitudes to analyze
                         longs - comma separated list of longitudes to analyze. Len must == len(lats)
                         alts - comma separated list of altitudes to analyze. Len must == len(lats)
                         parms - comma delimited string of Madrigal parameters desired
                         oneD - zero or more mnemonics,float values to set input 1D values
                             Example:  &oneD=kinst,31.0&oneD=elm,45.0
                         twoD - zero or more mnemonics,comma-separate float list of len(lats) to set input 2D values
                             Example:  twoD=te,1000,1100,1200  twoD=ti,1000,1000,1000
                                       where there are 3 lats
                 Returns comma-delimited data, one line for each lat value,
                 with the following fields:
 . latitude
 . longitude
 . altitude
 . Values for each Madrigal parameter listed in argument parms, separated by whitespace
                 """
                 if request.method == 'POST':
                     reqDict = request.POST
                 else:
                     reqDict = request.GET
                 try:
                     year = int(reqDict.get('year'))
                 except TypeError:
                     return(HttpResponse('<p>madCalculator2Service requires year</p>'))
                 month = int(reqDict['month'])
                 day = int(reqDict['day'])
                 hour = int(reqDict['hour'])
                 minute = int(reqDict['min'])
                 second = int(reqDict['sec'])
                 dt = datetime.datetime(year, month, day, hour, minute, second)
                 latsStr = reqDict['lats']
                 lats = [float(item) for item in latsStr.split(',')]
                 longsStr = reqDict['longs']
                 longs = [float(item) for item in longsStr.split(',')]
                 altsStr = reqDict['alts']
                 alts = [float(item) for item in altsStr.split(',')]
                 parms = reqDict['parms']
                 desiredParmList = [item.strip() for item in ['gdlat','glon','gdalt'] + parms.split(',')]
                 oneDList = reqDict.getlist('oneD')
                 oneDParmDict = {}
                 for oneDStr in oneDList:
                     mnem, strValue = oneDStr.split(',')
                     oneDParmDict[mnem] = [float(strValue)]
                 twoDList = reqDict.getlist('twoD')
                 twoDParmDict = {}
                 for twoDStr in twoDList:
                     items = twoDStr.split(',')
                     if len(items) != 1 + len(lats):
                         raise ValueError('twoDstr %s not correct number of points' % (str(twoDStr)))
                     mnem = items[0]
                     floatValues = [float(item) for item in items[1:]]
                     # now we need to expand these values to be two dimensional 1 x len(lats)
                     values = numpy.zeros((1,len(lats)), dtype=numpy.float)
                     values[0][:] = floatValues
                     twoDParmDict[mnem] = values
                 # capture stdout
                 old_stdout = sys.stdout
                 sys.stdout = mystdout = io.StringIO()
                 madrigal.isprint.MadCalculatorList(None, desiredParmList, [dt], lats, longs, alts,
                                                    oneDParmDict, twoDParmDict, summary=None)
                 text = mystdout.getvalue()
                 sys.stdout = old_stdout
                 return render(request, 'madweb/service.html', {'text': text})
             @csrf_exempt
             def mad_calculator3_service(request):
                 """mad_calculator3_service runs the madCalculator3 service.
                 Differs from madCalulator in that multiple times, each with a unique list of positions, can be passed in.
                 Inputs:
                   request/url - contains arguments:
                     year - a comma-separated list of years - (required)
                     month  - a comma-separated list of months - (required)
                     day - a comma-separated list of days - (required)
                     hour - a comma-separated list of hours - (required)
                     min - a comma-separated list of minutes - (required)
                     sec - a comma-separated list of seconds - (required)
                     numPos - a comma-sepatated list of the number of positions for each time - (required)
                     lats - a comma-separated list of geodetic latitudes, -90 to 90 (required).  Listed
                               for first time, then second, etc.  Total must be equal to the sum
                               of numPos.
                     longs - a comma-separated list of longitudes (required) Listed
                               for first time, then second, etc.  Total must be equal to the sum
                               of numPos.
                     alts - a comma-separated list of geodetic altitudes in km (required) Listed
                               for first time, then second, etc.  Total must be equal to the sum
                               of numPos.
                     parms - comma delimited string of Madrigal parameters desired (required)
                     oneD - string in form <parm>,<comma-separated values> This argument allows the user to
                                         set any number of one-D parameters to be used in the calculation.
                                         Value must be parameter name, comma, list of values as double,
                                         where length of list is equal to number of times.
                                         Example:  &oneD=kinst,31.0,31.0&oneD=elm,45.0,50
                                         (optional - 0 or more allowed)
                      twoD=<parm>,<values>  (optional - 0 or more allowed) This argument allows the user to
                                         set any number of two-D parameters to be used in the calculation.
                                         Value must be parameter name, comma, comma-separated values.
                                         Number of values must equal the sum of numPos.  Order is
                                         first time values first, then second time values, etc
                                         Example:  twoD=te,1000,1100,1200,1000,1100,1200 &twoD=ti,1000,1000,1000,1000,1000,1000
                                         where numPos=3,3
                 Returns comma-delimited data, one line for each location.  Separate times are delimited by line
                 TIME MM/DD/YYYY HH:MM:SS
                 Data lines have the following fields:
 . latitude
 . longitude
 . altitude
 . Values for each Madrigal parameter listed in argument parms, separated by whitespace
                 """
                 if request.method == 'POST':
                     reqDict = request.POST
                 else:
                     reqDict = request.GET
                 try:
                     yearList = [int(item) for item in reqDict.get('year').split(',')]
                 except AttributeError:
                     return(HttpResponse('<p>madCalculator3Service requires year</p>'))
                 monthList = [int(item) for item in reqDict.get('month').split(',')]
                 dayList = [int(item) for item in reqDict.get('day').split(',')]
                 hourList = [int(item) for item in reqDict.get('hour').split(',')]
                 minList = [int(item) for item in reqDict.get('min').split(',')]
                 secList = [int(item) for item in reqDict.get('sec').split(',')]
                 dtList = [datetime.datetime(yearList[i], monthList[i], dayList[i],
                                             hourList[i], minList[i], secList[i]) for i in range(len(yearList))]
                 numPosStr = reqDict['numPos']
                 numPosList = [int(item) for item in numPosStr.split(',')]
                 totalPos = 0
                 for numPos in numPosList:
                     totalPos += numPos
                 latsStr = reqDict['lats']
                 lats = [float(item) for item in latsStr.split(',')]
                 if len(lats) != totalPos:
                     return(HttpResponse('wrong number of lats, expected %i' % (totalPos)))
                 longsStr = reqDict['longs']
                 longs = [float(item) for item in longsStr.split(',')]
                 if len(longs) != totalPos:
                     return(HttpResponse('wrong number of longs, expected %i' % (totalPos)))
                 altsStr = reqDict['alts']
                 alts = [float(item) for item in altsStr.split(',')]
                 if len(alts) != totalPos:
                     return(HttpResponse('wrong number of alts, expected %i' % (totalPos)))
                 parms = reqDict['parms']
                 desiredParmList = [item.strip() for item in ['gdlat','glon','gdalt'] + parms.split(',')]
                 oneDList = reqDict.getlist('oneD')
                 twoDList = reqDict.getlist('twoD')
                 # since the positions can change with each call, we need to call madrigal.isprint.MadCalculatorGrid once for each time
                 startIndex = 0
                 endIndex = 0
                 fullText = ''
                 for timeIndex, numPos in enumerate(numPosList):
                     startIndex = endIndex
                     endIndex += numPos
                     thisLats = lats[startIndex:endIndex]
                     thisLongs = longs[startIndex:endIndex]
                     thisAlts = alts[startIndex:endIndex]
                     oneDParmDict = {}
                     for oneDStr in oneDList:
                         values = oneDStr.split(',')
                         if len(values) != 1+len(dtList):
                             return(HttpResponse('wrong number of values given for 1D parm %s' % (values[0])))
                         oneDParmDict[values[0]] = [float(values[timeIndex+1])]
                     twoDParmDict = {}
                     for twoDStr in twoDList:
                         values = twoDStr.split(',')
                         if len(values) != 1 + totalPos:
                             return(HttpResponse('twoDstr %s not correct number of points' % (str(twoDStr))))
                         mnem = values[0]
                         floatValues = [float(item) for item in values[1+startIndex:1+endIndex]]
                         # now we need to expand these values to be two dimensional - 1,len(thisLats)
                         values2D = numpy.zeros((1,len(thisLats)), dtype=numpy.float)
                         values2D[0][:] = floatValues
                         twoDParmDict[mnem] = values2D
                     # capture stdout
                     old_stdout = sys.stdout
                     sys.stdout = mystdout = io.StringIO()
                     madrigal.isprint.MadCalculatorList(None, desiredParmList, [dtList[timeIndex]], thisLats,
                                                        thisLongs, thisAlts,
                                                        oneDParmDict, twoDParmDict, summary=None)
                     text = mystdout.getvalue()
                     sys.stdout = old_stdout
                     fullText += 'TIME %s\n' % (dtList[timeIndex].strftime('%m/%d/%Y %H:%M:%S'))
                     fullText += text
                 return render(request, 'madweb/service.html', {'text': fullText})
             def geodetic_to_radar_service(request):
                 """geodetic_to_radar_service runs the geodeticToRadar service.
                 Inputs:
                   request/url - contains arguments:
                     slatgd  - radar geodetic latitude
                     slon - radar longitude
                     saltgd - radar geodetic altitude
                     gdlat - a comma-separated list of geodetic latitude of point
                     glon - a comma-separated list of longitude of point. Len must be same as gdlat
                     gdalt - a comma-separated list of geodetic altitude of point. Len must be same as gdlat
                 Returns comma-delimited data, one line for point in lists (points treated as individual combinations, not grids):
 . radar azimuth in degrees (0 = north)
 . radar elevation in degrees
 . radar range in km
                 """
                 slatgd = float(request.GET['slatgd'])
                 slon = float(request.GET['slon'])
                 saltgd = float(request.GET['saltgd'])
                 oneDParmDict = {'GDLATR': [slatgd],
                                 'GDLONR': [slon],
                                 'GALTR': [saltgd]}
                 gdlatStr = request.GET['gdlat']
                 gdlatList = [float(item) for item in gdlatStr.split(',')]
                 glonStr = request.GET['glon']
                 glonList = [float(item) for item in glonStr.split(',')]
                 gdaltStr = request.GET['gdalt']
                 gdaltList = [float(item) for item in gdaltStr.split(',')]
                 desiredParmList = ['azm', 'elm', 'range']
                 dtList = [datetime.datetime(2001,1,1)] # not relevant
                 if len(gdlatList) != len(glonList) or len(gdlatList) != len(gdaltList):
                     return(HttpResponse('all point list lengths must be equal'))
                 fullText = ''
                 delimiter = ','
                 for i in range(len(gdlatList)):
                      # capture stdout
                     old_stdout = sys.stdout
                     sys.stdout = mystdout = io.StringIO()
                     madrigal.isprint.MadCalculatorGrid(None, desiredParmList, dtList, [gdlatList[i]],
                                                    [glonList[i]], [gdaltList[i]], summary=None,
                                                    oneDParmDict=oneDParmDict)
                     text = mystdout.getvalue()
                     sys.stdout = old_stdout
                     for line in text.split('\n'):
                         items = line.split()
                         fullText += delimiter.join(items) + '\n'
                 return render(request, 'madweb/service.html', {'text': fullText})
             def radar_to_geodetic_service(request):
                 """radar_to_geodetic_service runs the radarToGeodetic service.
                 Inputs:
                   request/url - contains arguments:
                     slatgd  - radar geodetic latitude
                     slon - radar longitude
                     saltgd - radar geodetic altitude
                     azs - a comma-separated list of azimuths of point
                     els - a comma-separated list of elevations of point. Len must be same as azs
                     ranges - a comma-separated list of ranges to point. Len must be same as azs
                 Returns comma-delimited data, one line for point in lists  (points treated as individual combinations, not grids):
 . geodetic latitude
 . longitude (-180 to 180)
 . geodetic altitude in km
                 """
                 slatgd = float(request.GET['slatgd'])
                 slon = float(request.GET['slon'])
                 saltgd = float(request.GET['saltgd'])
                 azStr = request.GET['az']
                 azList = [float(item) for item in azStr.split(',')]
                 elStr = request.GET['el']
                 elList = [float(item) for item in elStr.split(',')]
                 rangeStr = request.GET['range']
                 rangeList = [float(item) for item in rangeStr.split(',')]
                 if len(azList) != len(elList) or len(azList) != len(rangeList):
                     return(HttpResponse('all point list lengths must be equal'))
                 fullText = ''
                 for i in range(len(azList)):
                     gdlat,glon,gdalt = madrigal._derive.radarToGeodetic(slatgd, slon, saltgd,
                                                                         azList[i], elList[i], rangeList[i])
                     fullText += '%f,%f,%f\n' % (gdlat,glon,gdalt)
                 return render(request, 'madweb/service.html', {'text': fullText})
             def list_file_times_service(request):
                 """list_file_times_service runs the listFileTimes service.
                 Inputs:
                   request/url - contains arguments:
                     Optional: expDir - experiment directory to list.  Can be absolute or relative to
                         experiments[0-9]*. Default is all files in $MADROOT/experiments*
                 Returns comma-delimited data, one for each file:
 . Full path of file
 . File modification time in form YYYY-MM-DD HH:MM:SS (UT time)
                 """
                 expDir = None
                 try:
                     expDir = request.GET['expDir']
                 except:
                     pass
                 madDB = madrigal.metadata.MadrigalDB()
                 fileList = madDB.listFileTimes(expDir)
                 fullText = '\n\n'
                 for filename, filetime in fileList:
                     fullText += "\'%s\', %s\n" % (filename, filetime.strftime('%Y-%m-%d %H:%M:%S'))
                 return render(request, 'madweb/service.html', {'text': django.utils.safestring.mark_safe(fullText)})
             def download_web_file_service(request):
                 """download_web_file_service runs the downloadWebFile service.
                 Inputs:
                   request/url - contains arguments:
                     expPath - path to file starting at experiments*
                 Returns comma-delimited data, one for each file:
 . Full path of file
 . File modification time in form YYYY-MM-DD HH:MM:SS (UT time)
                 """
                 expPath = request.GET['expPath']
                 madDB = madrigal.metadata.MadrigalDB()
                 downloadFile = os.path.join(madDB.getMadroot(), expPath)
                 f = open(downloadFile, 'rb')
                 thisFile = django.core.files.File(f)
                 response = HttpResponse(thisFile, content_type='application/x-octet-stream')
                 response['Content-Disposition'] = 'attachment; filename="' + os.path.basename(downloadFile) + '"'
                 response['Content-Length'] = os.path.getsize(downloadFile)
                 return(response)
             def trace_magnetic_field_service(request):
                 """trace_magnetic_field_service runs the traceMagneticField service.
                 Inputs:
                   request/url - contains arguments:
                     year, month, day, hour, min, sec
                     inputType (0 for geodetic, 1 for GSM)
                     outputType (0 for geodetic, 1 for GSM)
                         The following parameter depend on inputType:
                     in1 - a comma-separated list of geodetic altitudes or ZGSMs of starting point
                     in2 - a comma-separated list of geodetic latitudes or XGSMs of starting point
                     in3 - a comma-separated list of longitude or YGSM of starting point
                         Length of all three lists must be the same
                     model - 0 for Tsyganenko, 1 for IGRF
                     qualifier - 0 for conjugate, 1 for north_alt, 2 for south_alt, 3 for apex, 4 for GSM XY plane
                     stopAlt - altitude in km to stop trace at, if qualifier is north_alt or south_alt.
                     If other qualifier, this parameter is not required.
                 Returns comma-delimited data, one line for point in in lists:
 . geodetic altitude or ZGSM of ending point
 . geodetic latitude or XGSM of ending point
 . longitude or YGSM of ending point
                 """
                 year = int(request.GET['year'])
                 month = int(request.GET['month'])
                 day = int(request.GET['day'])
                 hour = int(request.GET['hour'])
                 minute = int(request.GET['min'])
                 second = int(request.GET['sec'])
                 dt = datetime.datetime(year, month, day, hour, minute, second)
                 inputType = int(request.GET['inputType'])
                 if inputType not in (0,1):
                     return(HttpResponse('inputType must be 0 or 1, not %i' % (inputType)))
                 outputType = int(request.GET['outputType'])
                 if outputType not in (0,1):
                     return(HttpResponse('outputType must be 0 or 1, not %i' % (outputType)))
                 in1Str = request.GET['in1']
                 in1List = [float(item) for item in in1Str.split(',')]
                 in2Str = request.GET['in2']
                 in2List = [float(item) for item in in2Str.split(',')]
                 in3Str = request.GET['in3']
                 in3List = [float(item) for item in in3Str.split(',')]
                 if len(in1List) != len(in2List) or len(in1List) != len(in3List):
                     return(HttpResponse('All three in* lists must have same length'))
                 model = int(request.GET['model'])
                 if model not in (0,1):
                     return(HttpResponse('model must be 0 or 1, not %i' % (model)))
                 qualifier = int(request.GET['qualifier'])
                 if qualifier not in (0,1,2,3,4):
                     return(HttpResponse('model must be in 0,1,2,3,4 not %i' % (model)))
                 try:
                     stopAlt = float(request.GET['stopAlt'])
                 except:
                     stopAlt = 0.0
                 fullText = ''
                 resultArr = numpy.zeros((3,), dtype='f8')
                 madDB = madrigal.metadata.MadrigalDB()
                 madDeriveObj = madrigal.derivation.MadrigalDerivationMethods(madDB.getMadroot())
                 for i in range(len(in1List)):
                     madDeriveObj.traceMagneticField(year, month, day, hour, minute, second,
                                                     inputType, outputType, in1List[i], in2List[i], in3List[i],
                                                     model, qualifier, stopAlt, resultArr)
                     fullText += '%f,%f,%f\n' % (resultArr[0], resultArr[1], resultArr[2])
                 return render(request, 'madweb/service.html', {'text': fullText})
             def global_file_search_service(request):
                 """global_file_search_service returns a list of full paths to files or citable urls based on search arguments
                 Inputs:
                     request/url - contains arguments:
                         startDate: start date in form YYYY-MM-DD to filter experiments before
                         endDate: end date in form YYYY-MM-DD to filter experiments after
                         inst: (optional, multiple allowed) an instrument code or name. For names,
                             fnmatch will be used. If not set, all instruments used.
                         kindat: (optional, multiple allowed) a kind of data codes or name. For names,
                             fnmatch will be used. If not set, all kinds of data used.
                         seasonalStartDate: (optional) in form MM/DD, rejects all days earlier in year. If not set
                             implies 01/01
                         seasonalEndDate: (optional) in form MM/DD, rejects all days later in year. If not set
                             implies 12/31
                         includeNonDefault: (optional) if "True", include realtime files when there are no default.
                             If not set, only default files.
                         expName: (optional)  - filter experiments by the experiment name.  fnmatch rules
                             If not set, no filtering by experiment name.
                         excludeExpName: (optional)  - exclude experiments by the experiment name.  fnmatch rules
                             If not set, no excluding experiments by experiment name.
                         fileDesc: (optional) filter files using input file Description string via fnmatch.
                             If not set, in no filtering by file name
                         returnCitation: (optional) if True, return a list of file citations.  If not set, return
                             a list of full paths to the files selected
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 # get required arguments
                 startDate = request.GET['startDate']
                 endDate = request.GET['endDate']
                 startDate = datetime.datetime.strptime(startDate, '%Y-%m-%d')
                 endDate = datetime.datetime.strptime(endDate, '%Y-%m-%d')
                 # get optional arguments
                 inst = request.GET.getlist('inst')
                 if inst == []:
                     inst = None
                 kindat = request.GET.getlist('kindat')
                 if kindat == []:
                     kindat = None
                 seasonalStartDate = request.GET.get('seasonalStartDate', default = None)
                 seasonalEndDate = request.GET.get('seasonalEndDate', default = None)
                 includeNonDefault = bool(request.GET.get('includeNonDefault', default = False))
                 expName = request.GET.get('expName', default = None)
                 excludeExpName = request.GET.get('excludeExpName', default = None)
                 fileDesc = request.GET.get('fileDesc', default = None)
                 returnCitation = bool(request.GET.get('returnCitation', default = False))
                 result = madWebObj.global_file_search(startDate, endDate, inst, kindat,
                                                       seasonalStartDate, seasonalEndDate,
                                                       includeNonDefault, expName, excludeExpName,
                                                       fileDesc, returnCitation)
                 fullText = ''
                 for item in result:
                     fullText += '%s\n' % (item)
                 return render(request, 'madweb/service.html', {'text': django.utils.safestring.mark_safe(fullText)})
             def get_url_list_from_group_id_service(request):
                 """get_url_list_from_group_id_service returns a list of citable urls associated with group id.
                 Inputs:
                     request/url - contains arguments:
                         id - group id
                     Returns one line for each citable url
                     Returns empty string if experiment id not found.  Skips files that are not Hdf5
                 """
                 id = int(request.GET['id'])
                 # create MadrigalDB obj
                 madDBObj = madrigal.metadata.MadrigalDB()
                 urlList = madDBObj.getListFromGroupId(id)
                 retStr = ''
                 for url in urlList:
                     retStr += '%s\n' % (url)
                 return render(request, 'madweb/service.html', {'text': django.utils.safestring.mark_safe(retStr)})
             def set_group_id_from_url_list_service(request):
                 """set_group_id_from_url_list sets a list of citable urls to a group id .
                 Inputs:
                     request/url - contains arguments:
                         'user_fullname'     user name
                         'user_email'        user email
                         'user_affiliation'  user affiliation
                         'url' -  citable url.  Multiple arguments allowed
                 Returns group id (integer) set
                 """
                 madDB = madrigal.metadata.MadrigalDB()
                 print(request.GET)
                 # get required arguments
                 urls = request.GET.getlist('url')
                 user_fullname = request.GET['user_fullname']
                 user_email = request.GET['user_email']
                 user_affiliation = request.GET['user_affiliation']
                 id = madDB.createGroupIdWithList(user_fullname, user_email, user_affiliation, urls)
                 return render(request, 'madweb/service.html', {'text': str(id)})
             ### doc pages ###
             def docs(request, name):
                 madDB = madrigal.metadata.MadrigalDB()
                 openMadObj = madrigal.openmadrigal.OpenMadrigal(madDB)
                 bg_color = madDB.getBackgroundColor()
                 if name.find('..') != -1:
                     # no trying to look elsewhere
                     return(HttpResponse('Illegal name passed to docs: <%s>' % (name)))
                 # check if siteSpecitic.html
                 siteSpecificPath = os.path.join(madDB.getMadroot(), 'source/madpy/djangoMad/madweb/templates/madweb/siteSpecific.html')
                 if os.access(siteSpecificPath, os.R_OK):
                     siteSpecific = reverse('docs', args=['siteSpecific.html'])
                 else:
                     siteSpecific = '#'
                 openmadrigal = openMadObj.getOpenMadrigalUrl()
                 # since google insists filenames are case insensitive, convert to right name if there is no direct match if possible
                 this_file = os.path.join(madDB.getMadroot(), 'source/madpy/djangoMad/madweb/templates/madweb', name)
                 if not os.access(this_file, os.R_OK):
                     found = False
                     existing_files = glob.glob(os.path.join(madDB.getMadroot(), 'source/madpy/djangoMad/madweb/templates/madweb/*.html'))
                     for existing_file in existing_files:
                         if name.lower() == os.path.basename(existing_file).lower():
                             name = os.path.basename(existing_file)
                             found = True
                             break # correct name found and name modified
                     if not found:
                         return(HttpResponse('<p>Cannot find %s</p>' % (str(name))))
                 if os.path.isdir(this_file):
                     return(HttpResponse('<p>%s is a directory</p>' % (str(name))))
                 return render(request, 'madweb/%s' % (name), {'bg_color': bg_color, 'siteSpecific': siteSpecific,
                                                                  'openmadrigal': openmadrigal})
   No newline at end of file

source/madpy/djangoMad/templates/base_single.html +2 0

             {% load bootstrap3 %}
             {% comment %}
             	Written by Bill Rideout brideout@haystack.mit.edu
             	Base template for Madrigal single experiment web interface
             	$Id: base_single.html 7320 2021-03-04 21:23:07Z brideout $
             {% endcomment %}
             {# Load CSS and JavaScript #}
             {% bootstrap_css %}
             {% bootstrap_javascript %}
             {% load static %}
             <link rel="stylesheet" href="{% static "bootstrap_calendar/css/bootstrap_calendar.css" %}" type="text/css" />
             <script type="text/javascript" src="{% static "bootstrap_calendar/js/bootstrap_calendar.js" %}"></script>
             <!DOCTYPE html>
             <html>
             <head>
             	<meta charset="UTF-8">
             	<meta name="viewport" content="width=device-width, initial-scale=1.0">
             	<link rel="shortcut icon" type="image/png" href="/static/favicon.ico"/>
+            	<script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
             	<title>{% block title %}Madrigal Database{% endblock %}</title>
                 <style type="text/css">
             		html body {
             	    	background-color: {{bg_color}};
             		}
             		.breadcrumb > li + li:before {
             		    content: none;
             		}
             	</style>
                 {% block extra_head %}{% endblock %}
                 {% block ajax_js %}{% endblock %}
             </head>
             <body>
             	<div class="loader" style="display:none"></div>
             	<div class="container-fluid">
             	{% include "navbar.html" %}
             	   <center><h4>Select single Madrigal experiment</h4></center>
             		<div class="row">
             			<div class="col-sm-12">
             		    {% bootstrap_messages %}
             		    </div>
             	    </div>
             	    {% if form.errors %}
             	    <div class="row">
             			<div class="col-sm-12">
             		    <p style="color: red;">
             		        Please correct the error{{ form.errors|pluralize }} below.
             		        {{ form.errors }}
             		    </p>
             		    </div>
             	    </div>
             	    {% endif %}
             	    <div class="row">
             			<div class="col-sm-3">
             			{% block isGlobal %}{% endblock %}
             			{% block categories %}{% endblock %}
             			{% block instruments %}{% endblock %}
             	    	{% block years %}{% endblock %}
             	    	{% block months %}{% endblock %}
             	    	{% block calendar %}{% endblock %}
             			</div>
             			<div class="col-sm-9">
             			{% block experiment_select %}{% endblock %}
             			{% block file_select %}{% endblock %}
             			{% block file_buttons %}{% endblock %}
             			{% block file_data %}{% endblock %}
+            			{% block file_plot %}{% endblock %}
             			</div>
             		</div>
             	    <p></p>
             	    {% comment %}
             	    <div class="row">
             	    	<div class="col-sm-12">{% block download %}{% endblock %}</div>
             	    </div>
             	    <p></p>
             	    <div class="row">
             		    <div class="col-sm-12">{% block information %}{% endblock %}</div>
             	    </div>{% endcomment %}
             	    <p><hr></p>
             	    <footer class="row">
             	        <div class="col-sm-6">
             	            <p>Madrigal database</p>
             	        </div>
             	        <div class="col-sm-6" style="text-align:right">
             	            <p>
             	            </p>
             	        </div>
             	    </footer>
             	</div> <!-- container-fluid -->
             	<script>
             	    $('[data-toggle="tooltip"]').tooltip();
             	    $('[data-toggle="tooltip"]').on('show.bs.tooltip', function() {
             		    // Only one tooltip should ever be open at a time
             		    $('.tooltip').not(this).hide();
             		});
             	    $('.my-dropdown').dropdown();
             		$('.my-dropdown').tooltip();
             	</script>
             </body>
             </html>

source/madpy/djangoMad/templates/navbar.html +1 0

             {% comment %}
             	Written by Bill Rideout brideout@haystack.mit.edu
             	Generic navbar code shared by all Madrigal pages
             	$Id: navbar.html 6641 2018-11-06 18:02:21Z brideout $
             {% endcomment %}
             		<style>
             		/* --- Style --- This CSS for a custom color navbar for Madrigal was generated using url http://work.smarchal.com/twbscolor/css/e74c3cc0392becf0f1ffbbbc0 */
             		.navbar-default {
             		  background-color: #21A7EB;
             		  border-color: #2182EB;
             		}
             		.navbar-default .navbar-brand {
             		  color: #ecf0f1;
             		}
             		.navbar-default .navbar-brand:hover, .navbar-default .navbar-brand:focus {
             		  color: #ffbbbc;
             		}
             		.navbar-default .navbar-text {
             		  color: #ecf0f1;
             		}
             		.navbar-default .navbar-nav > li > a {
             		  color: #ecf0f1;
             		}
             		.navbar-default .navbar-nav > li > a:hover, .navbar-default .navbar-nav > li > a:focus {
             		  color: #ffbbbc;
             		}
             		.navbar-default .navbar-nav > li > .dropdown-menu {
             		  background-color: #21A7EB;
             		}
             		.navbar-default .navbar-nav > li > .dropdown-menu > li > a {
             		  color: #ecf0f1;
             		}
             		.navbar-default .navbar-nav > li > .dropdown-menu > li > a:hover,
             		.navbar-default .navbar-nav > li > .dropdown-menu > li > a:focus {
             		  color: #ffbbbc;
             		  background-color: #2182EB;
             		}
             		.navbar-default .navbar-nav > li > .dropdown-menu > li > .divider {
             		  background-color: #21A7EB;
             		}
             		.navbar-default .navbar-nav > .active > a, .navbar-default .navbar-nav > .active > a:hover, .navbar-default .navbar-nav > .active > a:focus {
             		  color: #ffbbbc;
             		  background-color: #2182EB;
             		}
             		.navbar-default .navbar-nav > .open > a, .navbar-default .navbar-nav > .open > a:hover, .navbar-default .navbar-nav > .open > a:focus {
             		  color: #ffbbbc;
             		  background-color: #2182EB;
             		}
             		.navbar-default .navbar-toggle {
             		  border-color: #2182EB;
             		}
             		.navbar-default .navbar-toggle:hover, .navbar-default .navbar-toggle:focus {
             		  background-color: #2182EB;
             		}
             		.navbar-default .navbar-toggle .icon-bar {
             		  background-color: #ecf0f1;
             		}
             		.navbar-default .navbar-collapse,
             		.navbar-default .navbar-form {
             		  border-color: #ecf0f1;
             		}
             		.navbar-default .navbar-link {
             		  color: #ecf0f1;
             		}
             		.navbar-default .navbar-link:hover {
             		  color: #ffbbbc;
             		}
             		@media (max-width: 767px) {
             		  .navbar-default .navbar-nav .open .dropdown-menu > li > a {
             		    color: #ecf0f1;
             		  }
             		  .navbar-default .navbar-nav .open .dropdown-menu > li > a:hover, .navbar-default .navbar-nav .open .dropdown-menu > li > a:focus {
             		    color: #ffbbbc;
             		  }
             		  .navbar-default .navbar-nav .open .dropdown-menu > .active > a, .navbar-default .navbar-nav .open .dropdown-menu > .active > a:hover, .navbar-default .navbar-nav .open .dropdown-menu > .active > a:focus {
             		    color: #ffbbbc;
             		    background-color: #2182EB;
             		  }
             		}
             		</style>
                 	<nav class="navbar navbar-default" role="navigation">
                         <div class="navbar-header">
                             <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#collapse">
                               <span class="sr-only">Toggle navigation</span>
                               <span class="glyphicon glyphicon-arrow-down"></span>
                               MENU
                             </button>
                         </div>
                         <div class="collapse navbar-collapse" id="collapse">
                             <ul class="nav navbar-nav">
                                 <li {{ home_active|safe }}><a href="{% url 'index' %}" data-toggle="tooltip" data-original-title="Click here to return to the home page of the {{ site_name }} Madrigal site." data-placement="bottom">{{ site_name }} Home</a></li>
                                 <li class="dropdown"><a href="#" data-toggle="dropdown" class="my-dropdown" title="Use this dropdown menu to access all data anywhere on any Madrigal site.  See the tooltips for each choice for more information." data-placement="right">Access data<span class="caret"></span></a>
                                 	<ul class="dropdown-menu">
                                     	<li {{ list_active|safe }}><a href="{% url 'view_list' %}" data-toggle="tooltip" data-original-title="List a range of experiments on any Madrigal site that you can then choose from, and then access its data" data-placement="right">List experiments</a></li>
                                     	<li {{ single_active|safe }}><a href="{% url 'view_single' %}" data-toggle="tooltip" data-original-title="Navigate to a single experiment on any Madrigal site, and access that experiment&#39;s data" data-placement="right">Select single experiment</a></li>
                                         <li {{ script_active|safe }}><a href="{% url 'choose_script' %}" data-toggle="tooltip" data-original-title="Use this link to create a command that will download data from a range of experiments at once" data-placement="right">Create a command to download multiple exps</a></li>
                                         <li {{ ftp_active|safe }}><a href="{% url 'ftp' %}" data-toggle="tooltip" data-original-title="Simple ftp-like UI" data-placement="right">FTP-like access</a></li>
                                     </ul>
                                 </li>
                                 <li class="dropdown"><a href="#" data-toggle="dropdown" class="my-dropdown" title="Use this dropdown menu to access all Madrigal metadata. See the tooltips for each choice for more information." data-placement="right">Access metadata<span class="caret"></span></a>
                                 	<ul class="dropdown-menu">
                                 	    <li {{ site_active|safe }}><a href="{% url 'site_metadata' %}" data-toggle="tooltip" data-original-title="List all metadata related to individual Madrigal sites." data-placement="right">Madrigal site metadata</a></li>
                                     	<li {{ inst_active|safe }}><a href="{% url 'instrument_metadata' %}" data-toggle="tooltip" data-original-title="List all metadata related to individual Madrigal instruments." data-placement="right">Instrument metadata</a></li>
                                         <li {{ parm_active|safe }}><a href="{% url 'parameter_metadata' %}" data-toggle="tooltip" data-original-title="List all metadata related to individual CEDAR parameters." data-placement="right">CEDAR Parameters</a></li>
                                         <li {{ kindat_active|safe }}><a href="{% url 'kindat_metadata' %}" data-toggle="tooltip" data-original-title="List all metadata related to individual Madrigal kind of data file codes (also called kindats). Each Madrigal file has a single kind of data code." data-placement="right">Kind of data metadata</a></li>
                                         <li {{ filter_active|safe }}><a href="{% url 'docs' 'filter_desc.html' %}" data-toggle="tooltip" data-original-title="Describe use of filters in Madrigal." data-placement="right">Filter string metadata</a></li>
                                     </ul>
                                 </li>
                                 <li class="dropdown"><a href="#" data-toggle="dropdown" class="my-dropdown" title="Click here to access modeling tools associated with Madrigal." data-placement="right">Run models<span class="caret"></span></a>
                                 	<ul class="dropdown-menu">
                                 	    <li {{ madCalculator_active|safe }}><a href="{% url 'madrigal_calculator' %}" data-toggle="tooltip" data-original-title="Calculate any Madrigal parameter for a given time and range of lat, lon, and alt." data-placement="right">Run Madrigal derivation engine</a></li>
                                     	<li {{ looker_active|safe }}><a href="{% url 'looker_main' %}" data-toggle="tooltip" data-original-title="Simple Geodetic and Geomagnetic (IGRF) coordinate transformations (aka looker)." data-placement="right">Looker</a></li>
                                         <li><a href="http://models.haystack.mit.edu/models/" data-toggle="tooltip" data-original-title="Run ISR empirical models developed from historical ISR data by Shunrong Zhang." data-placement="right">ISR empirical models</a></li>
                                     </ul>
                                 </li>
                                 <li {{ doc_active|safe }}><a href="docs/name/madContents.html" data-toggle="tooltip" data-original-title="Click here to see Madrigal documentation on the web interface, using scripts to automate data access, Madrigal administration, and information for Madrigal developers." data-placement="bottom">Documentation</a></li>
                                 <li class="dropdown"><a href="#" data-toggle="dropdown" class="my-dropdown" title="Use this dropdown menu to navigate to another Madrigal site."  data-placement="left">Other Madrigal sites<span class="caret"></span></a>
                                 	<ul class="dropdown-menu">
                                 	{% for siteName, siteUrl in site_list %}
                                     	<li><a href="{{ siteUrl }}" data-toggle="tooltip" data-original-title="Navigate to Madrigal site at {{ siteName }}" data-placement="left">{{ siteName }}</a></li>
                                     {% endfor %}
                                     </ul>
                                 </li>
                                 <li><a href="http://cedar.openmadrigal.org/openmadrigal" data-toggle="tooltip" data-original-title="Click here to go to OpenMadrigal, where you can download API&#39;s in python, Matlab, and IDL to run Madrigal scripts, and access Madrigal&#39;s source code." data-placement="bottom">OpenMadrigal</a></li>
+            					<li><a href="{% url 'updata:updata_index' %}" data-toggle="tooltip" data-original-title="Click here to upload data to Madrigal database." data-placement="bottom">Upload Madrigal Data</a></li>
                             </ul>
                         </div>
                      </nav>

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages