DATABASES/madrigal Commit - r6:7771bbd8f772

Fix bugs and plots

jespinoza -

r6:7771bbd8f772

parent child

Context file:

r6:7771bbd8f772

nginx/app.conf +7 -7

             # configuration
             upstream djangomad {
                 server web:8000;
             }
             server {
-                listen 80;
+                listen 8080;
-                location / {
+                location /madrigal {
-                    proxy_http_version 1.1;
+                    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-                    proxy_set_header Upgrade $http_upgrade;
+                    proxy_set_header Host $host;
-                    proxy_set_header Connection "upgrade";
                     proxy_redirect off;
+                    proxy_set_header X-Script-Name /madrigal;
                     proxy_pass http://djangomad;
                 }
-                location /static/ {
+                location /madrigal/static/ {
                     alias /static/;
                 }
-            }
  No newline at end of file

source/madpy/djangoMad/apps/updata/views.py +1 -1

             from django.contrib.auth.decorators import login_required
             from django.shortcuts import render
             from .forms import UpdataForm, ExpForm
             from django.core.files.storage import FileSystemStorage
             from django.contrib import messages
             import os
             # madrigal imports
             import madrigal.metadata
             import madrigal.ui.web
             import madrigal.admin
-            @login_required
+            @login_required(login_url='/madrigal/accounts/login/')
             def index(request):
                 '''
                 Uploading experiments data view. Allows user to upload experiment files
                 '''
                 dbAdminObj = madrigal.admin.MadrigalDBAdmin()
                 madDB = madrigal.metadata.MadrigalDB()
                 madWebObj = madrigal.ui.web.MadrigalWeb(madDB)
                 siteName, siteList = madWebObj.getSiteInfo()
                 if request.method == 'POST':
                     form = UpdataForm(request.POST, request.FILES)
                     files = request.FILES.getlist('file')
                     if form.is_valid():
                         try:
                             description = form.cleaned_data['description']
                             instCode = int(form.cleaned_data['instruments'])
                             expId = form.cleaned_data['experiments']
                             perm = int(form.cleaned_data['type'])
                             #saving file
                             for f in files:
                                 fs = FileSystemStorage(location='/tmp')
                                 fs.save(f.name, f)
                                 madExp = madrigal.metadata.MadrigalExperiment()
                                 filepath = os.path.join('/tmp', f.name)
                                 expTitle = madExp.getExpNameByExpId(expId)
                                 dbAdminObj.createMadrigalExperiment(filepath,expTitle, perm, description, instCode)
                             madInstParams = madrigal.metadata.MadrigalInstrumentParameters()
                             madInstKindats = madrigal.metadata.MadrigalInstrumentKindats()
                             print('*** Updating local metadata ***')
                             dbAdminObj.__updateLocalMetadata__()
                             print('*** Rebuilding instParmTab.txt ***')
                             madInstParams.rebuildInstParmTable()
                             print('*** Rebuilding instKindatTab.txt ***')
                             madInstKindats.rebuildInstKindatTable()
                             messages.success(
                                 request, 'Experimento(s) creado(s) exitosamente')
                             form = UpdataForm()
                         except Exception as e:
                             messages.error(
                                 request, str(e))
                 else:
                     form = UpdataForm()
                 return render(request, 'updata/index.html', {
                     'form': form,
                     'site_name': siteName,
                     'site_list': siteList,
                 })
             def get_experiments(request):
                 """get_experiments is a Ajax call that returns the experiments select html to support the
                 updata UI.  Called when a user modifies the intruments select field.
                 Inputs:
                     request
                 """
                 form = ExpForm(request.GET)
                 return render(request, 'updata/experiments.html', {'form': form})

source/madpy/djangoMad/djangoMad/settings.py +3 -3

             """
             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 = '^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']
+            ALLOWED_HOSTS = ['localhost:8000', '127.0.0.1', 'localhost', '10.10.120.60']
             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.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'madweb',
                 'django_bootstrap_calendar',
                 'bootstrap3',
                 'apps.login',
                 'apps.updata',
             )
             MIDDLEWARE = [
                 'django.middleware.security.SecurityMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 '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/'
+            STATIC_URL = '/madrigal/static/'
             BOOTSTRAP3 = {
                 # Include jQuery with Bootstrap JavaScript (affects django-bootstrap3 template tags)
-                'jquery_url': '/static/jquery.min.js',
+                'jquery_url': '/madrigal/static/jquery.min.js',
                 'include_jquery': True,
             }

source/madpy/djangoMad/djangoMad/urls.py +5 -4

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

source/madpy/djangoMad/madweb/forms.py +12 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 check_mnemonic(s):
+                s.replace('vipe1', 'vipe')
+                s.replace('vipe2', 'vipe')
+                s.replace('vipn1', 'vipn')
+                s.replace('vipn2', 'vipn')
+                s.replace('vi72', 'vi7')
+                s.replace('vi82', 'vi8')
+                s.replace('dvipe1', 'dvipe')
+                s.replace('dvipe2', 'dvipe')
+                s.replace('dvipn1', 'dvipn')
+                s.replace('dvipn2', 'dvipn')
+                s.replace('dvi72', 'dvi7')
+                s.replace('dvi82', 'dvi8')
                 return s.replace('+', '%2b')
             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['Data']
                 choices1d = [(check_mnemonic(x[0].decode().lower()), x[1].decode()) for x in data['Array Layout']['1D Parameters']['Data Parameters']]
                 choices2d = [(check_mnemonic(x[0].decode().lower()), x[1].decode()) for x in data['Array Layout']['2D Parameters']['Data Parameters']]
                 choices = [[('0', 'Select Parameter')] + choices1d, [('0', 'Select Parameter')] + choices2d]
                 f.close()
                 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")
                 parameters = [(x[0].decode().lower(), x[1].decode()) for x in f['Metadata']['Data Parameters']]
                 f.close()
                 return [('0', 'Select Parameter')] + parameters
             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]
                         self.fields['param_list1d'] = django.forms.ChoiceField(widget = django.forms.Select(), choices=params1d, label="1D Parameters", required=False)
                         self.fields['param_list2d'] = django.forms.ChoiceField(widget = django.forms.Select(), choices=params2d, label="2D Parameters", required=False)
                     else:
                         params1d = get_params2(args, kwargs, madExpObj, madWebObj)
                         self.fields['param_list1d'] = django.forms.ChoiceField(widget = django.forms.Select(), choices=params1d, 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/static/favicon.ico binary modified 0 0

NO CONTENT: modified file, binary diff hidden

source/madpy/djangoMad/madweb/templates/madweb/admin.html +7 -7

             {% load static %}
             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml"><!-- InstanceBegin template="/Templates/doc_template.dwt" codeOutsideHTMLIsLocked="false" -->
             <head>
             <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
             <!-- InstanceBeginEditable name="doctitle" -->
             <title>Madrigal administrator's guide</title>
             <!-- InstanceEndEditable --><!-- InstanceBeginEditable name="head" --><!-- InstanceEndEditable -->
-            <link href="/static/madrigal.css" rel="stylesheet" type="text/css" />
+            <link href="/madrigal/static/madrigal.css" rel="stylesheet" type="text/css" />
             <style type="text/css">
             	html body {
             		background-color: {{bg_color}};
             	}
             </style>
             <!-- InstanceParam name="href_up_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_top" type="text" value="ad_appropriate.html" --><!-- InstanceParam name="href_back_top" type="text" value="rr_fortran95.html" --><!-- InstanceParam name="href_back_bottom" type="text" value="rr_fortran95.html" --><!-- InstanceParam name="href_up_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_bottom" type="text" value="ad_appropriate.html" --><!-- InstanceParam name="href_prev_top" type="text" value="rr_fortran95.html" --><!-- InstanceParam name="href_uptitle_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_top" type="text" value="ad_appropriate.html" --><!-- InstanceParam name="href_prevtitle_bottom" type="text" value="rr_fortran95.html" --><!-- InstanceParam name="href_uptitle_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_bottom" type="text" value="ad_appropriate.html" -->
             </head>
             <body>
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'rr_fortran95.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'rr_fortran95.html' %}"><img src="{% static 'previous.png' %}" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="{% static 'up.png' %}" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'ad_appropriate.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'ad_appropriate.html' %}"><img src="{% static 'next.png' %}" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleTop" -->Madrigal administrator's guide<!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'rr_fortran95.html' %}"><!-- InstanceBeginEditable name="PreviousTitle" -->Fortran95  remote API reference <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'ad_appropriate.html' %}"><!-- InstanceBeginEditable name="NextTitle" -->Is Madrigal appropriate?<!-- InstanceEndEditable --></A></div>
             <hr/>
             <!-- InstanceBeginEditable name="EditDoc" -->
             <h1 align="center">Madrigal administrator's guide</h1>
             <p>This section of the Madrigal documentation is meant for people considering installing Madrigal to hold data from their instruments, or those who have already installed Madrigal and are responsible for administering or updating it. This guide describes how to determine whether Madrigal is right for your data, and how to install it if it is. It also discusses how to create Madrigal data files, and how to add them to Madrigal. </p>
             <ul>
               <li><a href="{% url 'docs' 'ad_appropriate.html' %}">Is Madrigal appropriate for my instrument(s)?</a></li>
               <li><a href="{% url 'docs' 'ad_install.html' %}">Installing Madrigal for the first time </a></li>
               <li><a href="{% url 'docs' 'ad_upgrade.html' %}">Upgrading Madrigal to the latest release</a></li>
               <li><a href="{% url 'docs' 'ad_metadata.html' %}">The Madrigal data model and metadata files</a></li>
               <li><a href="{% url 'docs' 'ad_experiments.html' %}">How Madrigal data is organized</a></li>
               <li><a href="{% url 'docs' 'ad_createFiles.html' %}">Creating Madrigal data files</a></li>
               <li><a href="{% url 'docs' 'ad_createExp.html' %}">Creating and updating Madrigal experiments</a></li>
               <li><a href="{% url 'docs' 'ad_other.html' %}">Other administrative tasks</a></li>
               <li><a href="{% url 'docs' 'ad_logging.html' %}">User access logging</a></li>
               <li><a href="{% url 'docs' 'ad_links.html' %}">Creating direct links to experiments/files</a></li>
               <li><a href="{% url 'docs' 'ad_isprint.html' %}">Using isprint for file quick looks</a></li>
             </ul>
             <!-- InstanceEndEditable -->
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'rr_fortran95.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'rr_fortran95.html' %}"><img src="{% static 'previous.png' %}" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="{% static 'up.png' %}" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'ad_appropriate.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'ad_appropriate.html' %}"><img src="{% static 'next.png' %}" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleBottom" -->Madrigal administrator's guide<!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'rr_fortran95.html' %}"><!-- InstanceBeginEditable name="PreviousTitle2" -->Fortran95 remote API reference <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle2" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'ad_appropriate.html' %}"><!-- InstanceBeginEditable name="NextTitle2" -->Is Madrigal appropriate? <!-- InstanceEndEditable --></A></div>
             <hr/>
             <p>&nbsp;</p>
             </body>
             <!-- InstanceEnd --></html>

source/madpy/djangoMad/madweb/templates/madweb/dev_contents.html +7 -7

             {% load static %}
             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml"><!-- InstanceBegin template="/Templates/doc_template.dwt" codeOutsideHTMLIsLocked="false" -->
             <head>
             <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
             <!-- InstanceBeginEditable name="doctitle" -->
             <title>Madrigal developer's guide</title>
             <!-- InstanceEndEditable --><!-- InstanceBeginEditable name="head" --><!-- InstanceEndEditable -->
-            <link href="/static/madrigal.css" rel="stylesheet" type="text/css" />
+            <link href="{% static 'madrigal.css' %}" rel="stylesheet" type="text/css" />
             <style type="text/css">
             	html body {
             		background-color: {{bg_color}};
             	}
             </style>
             <!-- InstanceParam name="href_up_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_top" type="text" value="madrigal/index.html" --><!-- InstanceParam name="href_back_top" type="text" value="ad_isprint.html" --><!-- InstanceParam name="href_back_bottom" type="text" value="ad_isprint.html" --><!-- InstanceParam name="href_up_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_bottom" type="text" value="madrigal/index.html" --><!-- InstanceParam name="href_prev_top" type="text" value="ad_isprint.html" --><!-- InstanceParam name="href_uptitle_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_top" type="text" value="madrigal/index.html" --><!-- InstanceParam name="href_prevtitle_bottom" type="text" value="ad_isprint.html" --><!-- InstanceParam name="href_uptitle_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_bottom" type="text" value="madrigal/index.html" -->
             </head>
             <body>
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'ad_isprint.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'ad_isprint.html' %}"><img src="{% static 'previous.png' %}" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="{% static 'up.png' %}" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madrigal/index.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'madrigal/index.html' %}"><img src="{% static 'next.png' %}" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleTop" -->Madrigal developer's guide <!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'ad_isprint.html' %}"><!-- InstanceBeginEditable name="PreviousTitle" -->Using isprint<!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'madrigal/index.html' %}"><!-- InstanceBeginEditable name="NextTitle" -->Internal python API<!-- InstanceEndEditable --></A></div>
             <hr/>
             <!-- InstanceBeginEditable name="EditDoc" -->
             <h1 align="center">Madrigal developer's guide</h1>
             <p>This section of the Madrigal documentation is meant for developers working to extend or modify Madrigal. It is not meant for users of Madrigal or Madrigal administrators. </p>
             <p>With the release of Madrigal 3.0, Madrigal has only a single python API. The C and Fortran code installed in Madrigal is purely scientific code used in the derivation engine, and is exposed only as a python extension, madrigal._derive.</p>
             <p>The web interface is now a Django web application, and no direct cgi scripts remain. The django application is contained in MADROOT/source/madpy/djangoMad.</p>
             <ul>
               <li><a href="madrigal/index.html">Internal Madrigal Python API</a>
                 <ul>
                   <li><a href="{% url 'docs' 'madrigal/admin.m.html' %}">madrigal.admin</a></li>
                   <li><a href="{% url 'docs' 'madrigal/cedar.m.html' %}">madrigal.cedar</a></li>
                   <li><a href="{% url 'docs' 'madrigal/data.m.html' %}">madrigal.data</a></li>
                   <li><a href="{% url 'docs' 'madrigal/derivation.m.html' %}">madrigal.derivation</a></li>
                   <li><a href="{% url 'docs' 'madrigal/isprint.m.html' %}">madrigal.isprint</a></li>
                   <li><a href="{% url 'docs' 'madrigal/metadata.m.html' %}">madrigal.metadata</a></li>
                   <li><a href="{% url 'docs' 'madrigal/openmadrigal.m.html' %}">madrigal.openmadrigal</a></li>
                   <li><a href="{% url 'docs' 'madrigal/ui/index.html' %}">madrigal.ui</a>
                     <ul>
                       <li><a href="{% url 'docs' 'madrigal/ui/madrigalPlot.m.html' %}">madrigal.ui.madrigalPlot</a></li>
                       <li><a href="{% url 'docs' 'madrigal/ui/userData.m.html' %}">madrigal.ui.userData</a></li>
                       <li><a href="{% url 'docs' 'madrigal/ui/web.m.html' %}">madrigal.ui.web</a></li>
                     </ul>
                   </li>
                 </ul>
               </li>
               <li><a href="{% url 'docs' 'dev_derivation.html' %}">Madrigal derivation engine</a></li>
               <li><a href="/static/CEDARMadrigalHdf5Format.pdf">CEDAR Madrigal Hdf5 file format</a></li>
               <li><a href="/static/cedarFormat.pdf">Deprecated Cedar file format</a></li>
             </ul>
             <!-- InstanceEndEditable -->
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'ad_isprint.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'ad_isprint.html' %}"><img src="{% static 'previous.png' %}" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="{% static 'up.png' %}" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madrigal/index.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+            	  <td width="5%"><a href="{% url 'docs' 'madrigal/index.html' %}"><img src="{% static 'next.png' %}" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleBottom" -->Madrigal developer's guide<!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'ad_isprint.html' %}"><!-- InstanceBeginEditable name="PreviousTitle2" -->Using isprint <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle2" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'madrigal/index.html' %}"><!-- InstanceBeginEditable name="NextTitle2" -->Internal python API  <!-- InstanceEndEditable --></A></div>
             <hr/>
             <p>&nbsp;</p>
             </body>
             <!-- InstanceEnd --></html>

source/madpy/djangoMad/madweb/templates/madweb/madContents.html +1 -1

             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml">
             <head>
             <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
             <title>Madrigal documentation - v3.0</title>
-            <link href="/static/madrigal.css" rel="stylesheet" type="text/css" />
+            <link href="/madrigal/static/madrigal.css" rel="stylesheet" type="text/css" />
             <style type="text/css">
             	html body {
             		background-color: {{bg_color}};
             	}
             </style>
             </head>
             <body>
             <center>
               <h1>Madrigal Database v3.2.1 Documentation - Contents</h1>
               <table width="100%" border="1">
                 <tr>
                   <td class="navigation"><a href="/">Home</a></td>
                 </tr>
               </table>
             </center>
             <hr size="4" />
             <ul>
               <li><a href="{% url 'docs' 'madIntroduction.html' %}">1. Brief history of Madrigal</a></li>
             </ul>
             <ul>
               <li><a href="{% url 'docs' 'whatsNew.html' %}">2. What's new in Madrigal 3.2.1</a></li>
             </ul>
             <ul>
               <li><a href="{% url 'docs' 'wt_usersGuide.html' %}">3. Madrigal user's guide (How do I access Madrigal data?) </a>
                 <ul>
                   <li><a href="{% url 'docs' 'wt_contents.html' %}">2.1 Web interface tutorial </a></li>
                   <li><a href="{% url 'docs' 'rt_contents.html' %}">2.2 Remote data access programming tutorial</a></li>
                   <li><a href="{% url 'docs' 'rr_contents.html' %}">2.3 Remote data access programming reference guide</a></li>
                 </ul>
               </li>
             </ul>
             <ul>
               <li><a href="{% url 'docs' 'admin.html' %}">4. Madrigal Administrator's Guide</a></li>
             </ul>
             <ul>
               <li><a href="{% url 'docs' 'dev_contents.html' %}">5. Madrigal Developer's Guide</a></li>
             </ul>
             <ul>
               <li><a href="{{ siteSpecific }}">6. Site specific documentation</a></li>
             </ul>
             <p>&nbsp;</p>
             </body>
             </html>

source/madpy/djangoMad/madweb/templates/madweb/madIntroduction.html +8 -8

             {% load static %}
             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml"><!-- InstanceBegin template="/Templates/doc_template.dwt" codeOutsideHTMLIsLocked="false" -->
             <head>
             <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
             <!-- InstanceBeginEditable name="doctitle" -->
             <title>Madrigal history</title>
             <!-- InstanceEndEditable --><!-- InstanceBeginEditable name="head" -->
             <!-- InstanceEndEditable -->
-            <link href="/static/madrigal.css" rel="stylesheet" type="text/css" />
+            <link href="/madrigal/static/madrigal.css" rel="stylesheet" type="text/css" />
             <style type="text/css">
             	html body {
             		background-color: {{bg_color}};
             	}
             </style>
             <!-- InstanceParam name="href_up_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_top" type="text" value="whatsNew.html" --><!-- InstanceParam name="href_back_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_back_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_up_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_bottom" type="text" value="whatsNew.html" --><!-- InstanceParam name="href_prev_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_uptitle_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_top" type="text" value="whatsNew.html" --><!-- InstanceParam name="href_prevtitle_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_uptitle_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_bottom" type="text" value="whatsNew.html" -->
             </head>
             <body>
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/previous.png" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/up.png" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'whatsNew.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'whatsNew.html' %}"><img src="/madrigal/static/next.png" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleTop" -->Brief history of Madrigal <!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="PreviousTitle" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'whatsNew.html' %}"><!-- InstanceBeginEditable name="NextTitle" -->What's new in Madrigal 3.0?  <!-- InstanceEndEditable --></A></div>
             <hr/>
             <!-- InstanceBeginEditable name="EditDoc" -->
             <center>
               <h1>Brief history of Madrigal </h1>
             </center>
             <p>Madrigal is a database of ground-based measurements and models of   the Earth's upper atmosphere and ionosphere. It is the community database of the   Coupling, Energetics and Dynamics of Atmospheric Regions (<a href="http://cedarweb.vsp.ucar.edu/wiki/index.php/Main_Page">CEDAR</a>) program, which   is devoted to the characterization and understanding of the atmosphere above   about 60 km, with emphasis on the various processes that determine the basic   structure and composition of the atmosphere, and on the mechanisms that couple   different atmospheric regions. Instruments developed or upgraded under CEDAR   include interferometers, spectrometers, imagers, lidars and medium,   high-frequency and incoherent scatter radars.  The success of   CEDAR has been due, in large measure, to its ability to encourage collaborative   efforts coalescing observations, theory and modeling. The CEDAR community   includes about 800 scientists and students from around the world.</p>
             <p>From the inception of the CEDAR program in 1988, there has been a   great concern among the members of the CEDAR community to make the data   collected by the CEDAR instruments easily accessible for joint studies.   Consequently, a high priority was placed on establishing a repository for CEDAR   data and model results. An incoherent scatter radar database had been   established at the National Center for Atmospheric Research (NCAR) in 1985, and   this evolved into the CEDAR Database in 1989. By the end of 1997, it had grown   to include data from 44 instruments and 16 models. Over 200 users have requested   information from the Database. In 2012, the Madrigal database and the CEDAR database were combined into a single database system, the Madrigal CEDAR database, based at MIT Haystack Observatory.</p>
-            <p>A central element of the CEDAR Database is a standard data format.   With Madrigal 3.0 the file format is now Hdf5, with a well-defined layout and parameters. This new CEDAR Hdf5 format is described <a href="/static/CEDARMadrigalHdf5Format.pdf" target="_blank">here</a>. This format replaced the old <a href="/static/cedarFormat.pdf">16 bit integer based format</a> that evolved from the format used by the earlier incoherent scatter   database, which in turn evolved from an earlier version of Madrigal developed at the MIT Haystack   Observatory in 1980. </p>
+            <p>A central element of the CEDAR Database is a standard data format.   With Madrigal 3.0 the file format is now Hdf5, with a well-defined layout and parameters. This new CEDAR Hdf5 format is described <a href="/madrigal/static/CEDARMadrigalHdf5Format.pdf" target="_blank">here</a>. This format replaced the old <a href="/madrigal/static/cedarFormat.pdf">16 bit integer based format</a> that evolved from the format used by the earlier incoherent scatter   database, which in turn evolved from an earlier version of Madrigal developed at the MIT Haystack   Observatory in 1980. </p>
             <p>Haystack maintains and develops  the Madrigal CEDAR database as an open-source project with community contributions.  With the Madrigal CEDAR database, the site owner stores only their own data, which they can add to or update at any time. However, because the Madrigal database shares its metadata with all other Madrigal sites, users browsing any Madrigal site can search for data at any other Madrigal site. In addition, a central archival Madrigal site (<a href="http://cedar.openmadrigal.org" target="_self">cedar.openmadrigal.org</a>) archives all Madrigal sites and stores data not stored at other Madrigal sites.</p>
             <p>Madrigal data are arranged into &quot;experiments&quot;, which may contain   data files, images, documentation, links, etc.   A key feature of Madrigal is its  seamless integration   of archival and real-time data. A realtime file on Madrigal is accessed in exactly the same way as any archival file.</p>
             <p>Madrigal has been installed at numerous locations in addition to   Millstone Hill, including EISCAT, SRI International, and Jicamarca. The inventories of   experiments available at each installation are available to the other   installations through shared metadata.  New Madrigal sites can be automatically added at any time.</p>
             <p>Madrigal is an open source project with a central <a href="http://cedar.openmadrigal.org/openmadrigal">developer's web site</a> and a <a href="http://atlas.haystack.mit.edu/cgi-bin/millstone_viewvc.cgi/openmadrigal/" target="_self">central repository</a>. A complete Subversion archive of all   Madrigal software, including software which is not included with the standard   distribution, is available at the developer's web site. There is also an Open Madrigal mailing list   and developer's forum. Any group wishing to install Madrigal to distribute their instrument's data is welcome to - see the http://cedar.openmadrigal.org/openmadrigal web site for details. The  <a href="http://atlas.haystack.mit.edu/cgi-bin/millstone_viewvc.cgi/openmadrigal/" target="_self">central repository</a> link is a place where all data from all Madrigal sites is archived. It can also be used to access data, although accessing the local sites is preferred.</p>
             <!-- InstanceEndEditable -->
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/previous.png" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/up.png" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'whatsNew.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'whatsNew.html' %}"><img src="/madrigal/static/next.png" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleBottom" -->Brief overview of Madrigal <!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="PreviousTitle2" -->Doc Home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle2" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'whatsNew.html' %}"><!-- InstanceBeginEditable name="NextTitle2" -->What's new in Madrigal 3.0? <!-- InstanceEndEditable --></A></div>
             <hr/>
             <p>&nbsp;</p>
             </body>
             <!-- InstanceEnd --></html>

source/madpy/djangoMad/madweb/templates/madweb/parameter_selection.html +3 -3

                   <div class="row" style="margin-bottom: 20px">
                     Select parameter: <br>
                     {{ form.param_list1d.label }}
                     {{ form.param_list1d }}
                     {% if form.param_list2d %}
                       {{ form.param_list2d.label }}
                       {{ form.param_list2d }}
                     {% endif %}
                   </div>
                   <script>
                     $('#id_param_list2d').bind('change', function (e) {
                             var expID = '{{ expID }}';
                             var param = $(this).val();
-                            var url =  '{% url 'plot' %}' + '?expID=' + expID + '&param2d=' + param;
+                            var url =  '{% url 'plot' %}' + '?expID=' + expID + '&param2d=' + param + '&filename=' + $('#id_file_list').val();
                             console.log(url)
                             // first delete all forms that are now out of date
             	        			divIndex = $(".single_form").index($( "#file_plot" ))
             	        				$(".single_form").slice(divIndex).empty()
             				            // second populate the file_plot html if '0' not selected
             				            if (param != '0') {
             				            	$(".single_form").slice(divIndex,divIndex+1).html("<img src=\"static/loader.gif\" class=\"load_center\"/>").load(url);
                         				}
             						})
                   $('#id_param_list1d').bind('change', function (e) {
                             var expID = '{{ expID }}';
                             var param = $(this).val();
-                            var url =  '{% url 'plot' %}' + '?expID=' + expID + '&param1d=' + param;
+                            var url =  '{% url 'plot' %}' + '?expID=' + expID + '&param1d=' + param + '&filename=' + $('#id_file_list').val();
                             console.log(url)
                             // first delete all forms that are now out of date
             	        			divIndex = $(".single_form").index($( "#file_plot" ))
             	        				$(".single_form").slice(divIndex).empty()
             				            // second populate the file_plot html if '0' not selected
             				            if (param != '0') {
             				            	$(".single_form").slice(divIndex,divIndex+1).html("<img src=\"static/loader.gif\" class =\"load_center\"/>").load(url);
                         				}
             				    })
                   </script>
                   <style>
                     .load_center {
                       display: block;
                       margin-left: auto;
                       margin-right: auto;
                       margin-top: 100px;
                       margin-bottom: 100px;
                       width: 4%;
                       align-items: center;
                     }
-                  </style>
  No newline at end of file
+                  </style>

source/madpy/djangoMad/madweb/templates/madweb/whatsNew.html +7 -7

             {% load static %}
             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml"><!-- InstanceBegin template="/Templates/doc_template.dwt" codeOutsideHTMLIsLocked="false" -->
             <head>
             <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
             <!-- InstanceBeginEditable name="doctitle" -->
             <title>What's new in Madrigal 3.2?</title>
             <!-- InstanceEndEditable --><!-- InstanceBeginEditable name="head" --><!-- InstanceEndEditable -->
-            <link href="/static/madrigal.css" rel="stylesheet" type="text/css" />
+            <link href="/madrigal/static/madrigal.css" rel="stylesheet" type="text/css" />
             <style type="text/css">
             	html body {
             		background-color: {{bg_color}};
             	}
             </style>
             <!-- InstanceParam name="href_up_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_top" type="text" value="wt_usersGuide.html" --><!-- InstanceParam name="href_back_top" type="text" value="madIntroduction.html" --><!-- InstanceParam name="href_back_bottom" type="text" value="madIntroduction.html" --><!-- InstanceParam name="href_up_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_next_bottom" type="text" value="wt_usersGuide.html" --><!-- InstanceParam name="href_prev_top" type="text" value="madIntroduction.html" --><!-- InstanceParam name="href_uptitle_top" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_top" type="text" value="wt_usersGuide.html" --><!-- InstanceParam name="href_prevtitle_bottom" type="text" value="madIntroduction.html" --><!-- InstanceParam name="href_uptitle_bottom" type="text" value="madContents.html" --><!-- InstanceParam name="href_nexttitle_bottom" type="text" value="wt_usersGuide.html" -->
             </head>
             <body>
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'madIntroduction.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madIntroduction.html' %}"><img src="/madrigal/static/previous.png" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/up.png" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'wt_usersGuide.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'wt_usersGuide.html' %}"><img src="/madrigal/static/next.png" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleTop" -->What's new in Madrigal 3.0? <!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'madIntroduction.html' %}"><!-- InstanceBeginEditable name="PreviousTitle" -->Brief History <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'wt_usersGuide.html' %}"><!-- InstanceBeginEditable name="NextTitle" -->Madrigal user's guide <!-- InstanceEndEditable --></A></div>
             <hr/>
             <!-- InstanceBeginEditable name="EditDoc" -->
             <h1 align="center">What's new in Madrigal 3.2.2?</h1>
             <h1 align="center" style="text-align: left">Madrigal 3.2.2 Release - Jan 2021</h1>
               <p align="center" style="text-align: left">Fixed bug in linking to external data using the Select Single Experiment user interface. </p>
             <h1 align="center">What's new in Madrigal 3.2.1?</h1>
             <h1 align="center" style="text-align: left">Madrigal 3.2.1 Release - Nov 2020</h1>
             <h2 align="center" style="text-align: left">Allows Madrigal to create citations to groups of files</h2>
               <p align="center" style="text-align: left">With Madrigal 3.2.1, users can use the API to create citations to groups of files, and can display those groups with that citation. </p>
             <h1 align="center">What's new in Madrigal 3.1.1?</h1>
             <h1 align="center" style="text-align: left">Madrigal 3.1.1 Release - Nov 2019</h1>
             <h2 align="center" style="text-align: left">Allows Madrigal to run using https</h2>
               <p align="center" style="text-align: left">With Madrigal 3.1.1, the code is compatable with https. Instructions are given to install or convert Madrigal to https. </p>
             <h1 align="center">What's new in Madrigal 3.1?</h1>
             <h1 align="center" style="text-align: left">Madrigal 3.1 Release - Oct 2019</h1>
             <h2 align="center" style="text-align: left">Conversion to Python 3</h2>
               <p align="center" style="text-align: left">With Madrigal 3.1, all python code has been updated to use python 3 instead of python 2.  The functionality is unchanged from Madrigal 3.0.</p>
             <h1 align="center" style="text-align: left">Madrigal 3.0 Release - Sept 2017</h1>
             <blockquote>
               <h2 align="center" style="text-align: left">Migration to Hdf5 file format</h2>
               <p align="center" style="text-align: left">With Madrigal 3.0, the old 16 bit integer based file format has been replaced with Hdf5. However, all the data model and well-defined parameters have been retained. The CEDAR Hdf5 format is designed to be completely self-contained. That is, any user with an Hdf5 reader can fully understand all data in the file without any reference to documentation. A full description of the format can be found <a href="/static/CEDARMadrigalHdf5Format.pdf">here</a>.</p>
               <h2 align="center" style="text-align: left">Web interface generates scripts to download any amount of data</h2>
               <p align="center" style="text-align: left">With Madrigal 3, you can generate a script command to download a whole series of files with a few click. You can also create a script that will filter those same files and allow you to choose the parameters you want, again with just a few clicks. These scripts can be run with python, Matlab, or IDL.</p>
               <h2 align="center" style="text-align: left">Download files in a new format</h2>
               <p align="center" style="text-align: left">Prior to Madrigal 3, files could be downloaded only as ascii or Hdf5 (or the difficult to understand CEDAR format). Now they can be downloaded as ascii, Hdf5, or netCDF4.</p>
               <h2 align="center" style="text-align: left">Get data with selected/derived parameters and filters in new formats</h2>
               <p align="center" style="text-align: left">Prior to Madrigal 3, data with selected/derived parameters and filters was available
               only as ascii. Now it can be downloaded as ascii, Hdf5, or netCDF4.</p>
               <h2 align="center" style="text-align: left">Independent spatial parameters now built in to data model</h2>
               <p align="center" style="text-align: left">Prior to Madrigal 3.0, there was no way to automatically tell what the independent spatial parameters were in vector data. With Madrigal 3.0, any data with vector data must define its independent spatial parameters, which can be found in the Hdf5 Metadata group. This allows Madrigal to automatically add array layouts of the data, making for easier plotting.</p>
               <h2 align="center" style="text-align: left">All new web interface</h2>
               <p align="center" style="text-align: left">A much simplified web interface based on Django and bootstrap. Developed with much assistance from Jicamarca Observatory  and Jose Antonio Sal y Rosas Celi.</p>
               <h2 align="center" style="text-align: left">Simple FTP-like web interface added</h2>
               <p align="center" style="text-align: left">Designed for non-native English speakers. The url follows a very simple pattern that can be easily parsed if the user in unable to understand the Madrigal API's and automatically generated scripts.</p>
               <h2 align="center" style="text-align: left">Create CEDAR Hdf5 files with either Matlab or python</h2>
               <p align="center" style="text-align: left">Prior to Madrigal 3, there was only a python API to easily create Madrigal files. Now both Matlab and python can be used to create CEDAR Hdf5 files.</p>
               <h2 align="center" style="text-align: left">All metadata easily accessible</h2>
               <p align="center" style="text-align: left">The <em>Access metadata</em> menu item on the main navigation menu allows easy access to all Madrigal CEDAR metadata, including Madrigal sites, instruments, parameter definitions, and kind of data codes.</p>
             </blockquote>
             <h1>Madrigal 2.6.3.2 Release - March 22, 2012</h1>
             <p>Added support to file download cgi scripts to allow logging of remote API requests to download files.</p>
             <h1>Madrigal 2.6.3.1 Release - March 13, 2012</h1>
             <p>Added popup javascript window to warn users not to click &quot;Download File&quot; button multiple times.</p>
             <h1>Madrigal 2.6.3 Release - Febuary 27, 2012</h1>
             <p>Small bug fixes in 3 cgi scripts affecting plots: madExperiment.cgi, madDataDisplay, getMadplot.py</p>
             <h1>Madrigal 2.6.2 Release - Febuary 8, 2012</h1>
             <p>Small bug fix involving creating Hdf5 export files in data.py.</p>
             <h1>Madrigal 2.6.1 Release - January 20, 2012</h1>
             <p>Small bug fix involving a memory leak in _Madrec.c and a rare problem creating Hdf5 export files in data.py.	</p>
             <h1>Madrigal 2.6 Release - November 2011 </h1>
             <blockquote>
               <h2>New simple local web user interface </h2>
               <p>A new easy to use interface to access local Madrigal data was developed by Jicamarca with support from Millstone Hill staff. This interface in now very robust and has been tested with data from all Madrigal sites.</p>
               <h2>HDF5 file download availablity</h2>
               <p>Users can now download data files as HDF5, in addition to simple column delimited ascii and the more complex <a href="/static/cedarFormat.pdf" target="_self">CEDAR formats</a>. This is also the result of a Jicamarca/Millstone Hill collaborations.</p>
               <h2>Users can register interest in experiments or instruments</h2>
               <p>Users can now register interest in experiments or instruments, and get emails whenever that Madrigal experiment or instrument is updated.</p>
               <h2>Administrative improvements - can now add external disks to experiments</h2>
               <p>It is now easy to expand the Madrigal database by <a href="ad_other.html#experiments" target="_self">mounting additional hard disks</a> to make more room for data.</p>
               <h2>New metadata - experiment PI's and analyst</h2>
               <p>Experiments now have direct email links to the experiment PI. These PI's can be updated on an experiment or intrument basis.</p>
               <h2>Global seach now more robust</h2>
               <p>The global search UI now generates scripts so you can run the global search right from your computer using either the <a href="rt_python.html" target="_self">python remote API</a>, the <a href="rt_matlab.html" target="_self">Matlab remote API</a>, or the<a href="rt_idl.html" target="_self"> IDL remote API</a>.</p>
               <p>&nbsp;</p>
             </blockquote>
             <hr />
             <p>&nbsp;</p>
             <h1>Madrigal 2.5.2 Release - May 2009</h1>
             <blockquote>
               <p>A bug fix release - no new features. </p>
             </blockquote>
             <h1>Madrigal 2.5.1 Release - March 2009</h1>
             <blockquote>
               <p>This minor revision to Madrigal 2.5 was needed to support using Madrigal as an archiving database. The experiment metadata was expanded to allow archived experiments. Archived experiments are not shared between Madrigal sites, but are visible as local experiments. </p>
             </blockquote>
             <h1>Madrigal 2.5 Release - February 2009 </h1>
             <blockquote>
               <h2>Simplification of Web User Interface </h2>
               <p>Both the Browse for Individual Madrigal Experiments and the Global Madrigal Database Report web interface have been simplified. Searching for instruments under Browse for Individual Madrigal Experiments is now easier through the use of an instrument category selector.</p>
               <h2>One step file printing available</h2>
               <p>Under Browse for Individual Madrigal Experiments, users can now choose to print an ascii version of any Madrigal file with one click. With this option they can not include any derived parameters or data filters.</p>
               <h2>Installation simplified </h2>
               <p>Autotools is now used to compile all code, significantly reducing the number of parameters in the madrigal.cfg configuration file.</p>
               <h2>64-bit tested </h2>
               <p>Madrigal has now been fully tested as a 64-bit application. It is important that all Madrigal installations switch to 64-bit machines by the year 2037, because 32-bit unix cannot handle dates beyond then.</p>
               <h2>International Reference Ionosphere (IRI) derived parameters now available</h2>
               <p>All parameters calculated by the  International Reference Ionosphere (IRI) model can now be selected as derived parameters.</p>
               <h2>Additional automatic sharing of metadata added</h2>
               <p>For administrators: Now when new sites or instruments are added to Madrigal, these metadata files are automatically added to your site.  </p>
               <h2>Experiment level security</h2>
               <p>Previously, individual Madrigal files could be made public or private.   Now entire experiments can be made public, private, or hidden altogether. See the script <a href="ad_createExp.html#changeExpStatus">changeExpStatus.py</a> for details. </p>
               <h2>Experiment directory naming convention modified </h2>
               <p>Previous to Madrigal 2.5, all Madrigal experiments had to be stored in directory paths in the form:</p>
               <pre>$MADROOT/experiments/YYYY/&lt;3 letter inst mnemonic&gt;/ddMMMyy[letter],
             Example: /opt/madrigal/experiments/1998/mlh/20jan98b.</pre>
               <p>Under this convention, the date of the directory name represented the start date of the experiment, with one letter optionally added. This meant there was a limited number of experiments that could be created for a particular day for a particular experiment. This part of the directory naming convention has been dropped, and now the convention is:</p>
               <pre>$MADROOT/experiments/YYYY/&lt;3 letter inst mnemonic&gt;/*,
             Example: /opt/madrigal/experiments/1998/mlh/mlh_exp_234.
             </pre>
             </blockquote>
             <hr />
             <h1>Madrigal 2.4 Release - February 2006 </h1>
             <blockquote>
               <h2>Simple web UI added</h2>
               <p>A new web user-interface has been added that allows easy printing and plotting of basic Madrigal data. To make it easy to use, advanced Madrigal features such as derived parameters and filtering of data have been removed.</p>
               <h2>On-demand plot creation</h2>
               <p>Madrigal now allows users to create basic scatter plots and pcolor plots versus range or altitude of any measured or derived parameter in a data set.</p>
               <h2>Logging of user data access</h2>
               <p>Madrigal now <a href="ad_logging.html">logs user's names, emails, and affiliations</a> whenever data files are directly accessed in a file administrators can access. </p>
               <h2>Automatic updating of all geophysical data</h2>
               <p>Madrigal now automatically updates all its internal geophysical files (e.g., Kp, Fof2, Dst, Imf, etc) every time updateMaster is run.  </p>
               <h2>Simple-to-use python module to create and edit Madrigal files</h2>
               <p>There is now a <a href="ad_createFiles.html#python">simple-to-use python module</a> to create and edit Madrigal files.  </p>
               <h2>New administrative scripts to manage Madrigal experiments</h2>
               <p>Administrators can now add or modify all Madrigal experiments using <a href="ad_createExp.html">simple administrative scripts</a>, instead of trying to edit Madrigal metadata files themselves or use the complex genExp script. </p>
               <h2>Complete documentation rewrite</h2>
               <p>Madrigal documentation has now been completely rewritten and reorganized into three manuals: one for <a href="wt_usersGuide.html">users</a>, one for <a href="admin.html">administrators</a>, and one for <a href="dev_contents.html">developers</a>.  </p>
               <h2>Automatic graphics conversion</h2>
               <p>Madrigal will now allow users to select any graphics format they prefer for <a href="ad_createExp.html#auxillary">graphics administrators place in experiments</a>. This feature was contributed by Eiscat.  </p>
               <h2>Update of IGRF/MSIS</h2>
               <p>The Madrigal derivation engine is now using the <a href="http://www.ngdc.noaa.gov/IAGA/vmod/igrf.html">IGRF 2010 coefficients</a>, and the <a href="https://omniweb.gsfc.nasa.gov/vitmo/msis_vitmo.html">MSIS 2000 model</a>.  </p>
               <h2>Limiting of disk space used for global search files</h2>
               <p>Administrators can now limit the maximum amount of disk space used to store temporary global search files.  See the section on editing the madrigal.cfg file in the installation guide. </p>
             </blockquote>
             <p>&nbsp;</p>
             <hr />
             <p>&nbsp;</p>
             <h1>Madrigal 2.3 Release - March 2004</h1>
             <blockquote>
               <h2>Remote programming access to Madrigal via web services using any platform</h2>
               <p>Madrigal now exposes all the information and capabilities it has as web services, which allows
                 easy access to Madrigal from any computer on the internet using any platform (Unix, Windows, Mac, etc).
                 Madrigal's web services are basically cgi scripts with simple output that allows easy parsing of the
                 information.  Any language that supports the HTTP standard can then access any Madrigal site.  We have
                 written remote API's using python and Matlab, but almost any language could be used.  See the section
                 on <a href="{% url 'docs' 'rt_contents.html' %}">remote programming access</a> for details of these APIs and the underlying web services.</p>
               <p>Note that this approach of remotely accessing Madrigal data has been always possible before by parsing the
                 html output meant to be displayed in a web browser (this general programming method is referred to as "screen
                 scraping").  However, not only is this parsing difficult; but the code often breaks when the user interface
                 is modified in any way.  With web services the returned cgi scripts are designed to be both simple to parse
                 and stable.</p>
               <p>The web services are not implemented according to the SOAP or XMLRPC standard since not all scripting
                 languages have support for these standards (or for XML parsing).  Instead they use the simple approach
                 of returning data requested via a query as a delimited text file.  These web services are fully
                 documented  <a href="{% url 'docs' 'rt_webServices.html' %}">here.</a></p>
               <p>Users who want only to write programs to remotely access Madrigal, and not to install a Madrigal server
                 themselves, are now able to <a href="http://www.haystack.mit.edu/madrigal/madDownload.html"> download </a>
                 the remote python and Matlab API's from the
               <a href="http://www.openmadrigal.org">OpenMadrigal</a> site.</p>
               <h2> Command-line global search</h2>
               <p>As an example of remote programming access to Madrigal via web services, an application
                 <a href="rt_python.html#globalIsprint">globalIsprint</a> was written
                 using the python remote API that does a global search of data on any Madrigal site that has installed Madrigal version
 .3.  This application is installed as part of Madrigal, and also when the standalone remote python
                 API is installed.  It has all the filtering ability of the web-based global search.</p>
               <h2>Calculate any derivable Madrigal parameter for any time and point(s) in space</h2>
               <p>By clicking on "Run Models", users can calculate any derived Madrigal parameter (such as magnetic fields,
                 or geophysical parameters) for arbitrary times and ranges of position.  Note that this capability is also
                 available as a web service, and through the remote python and Matlab API's.</p>
               <h2>New derived parameters</h2>
               <ul>
                 <li>
                   CGM_LAT: <b>Corrected geomagnetic latitude</b> (deg) <br>
                   This parameter gives the location of a point in Corrected geomagnetic latitude.
                   This method uses code developed by Vladimir Papitashvili.  For more information on CGM coordinates
                   and this code, click <a href="https://omniweb.gsfc.nasa.gov/vitmo/cgmm_des.html"> here.</a></li>
                 <li>
                   CGM_LONG: <b>Corrected geomagnetic longitude</b> (deg) <br>
                   This parameter gives the location of a point in Corrected geomagnetic longitude.
                   This method uses code developed by Vladimir Papitashvili.  For more information on CGM coordinates
                   and this code, click <a href="https://omniweb.gsfc.nasa.gov/vitmo/cgmm_des.html"> here.</a></li>
                 <li>
                   TSYG_EQ_XGSM: <b>Tsyganenko field GSM XY plane X point</b> (earth radii) <br>
                   This parameter gives the X value in GSM coordinates of where the field line associated
                   with a given input point in space and time crosses the GSM XY plane (the magnetic equatorial plane).  GSM stands for
                   Geocentric Solar Magnetospheric System, and its XY plane is the equatorial plane of
                   the earth's magnetic dipole field.  The field lines are traced using the
                   Tsyganenko
                   Magnetospheric model, so external effects on the earth's magnetic field such the solar wind are
                   taken into account.  This code uses the 2001 Tsyganenko model, which averages solar wind values
                   over the past hour, instead of simply using present values.</li>
                 <li> TSYG_EQ_YGSM: <b>Tsyganenko field GSM XY plane Y point</b> (earth radii) <br>
                   This parameter gives the Y value in GSM coordinates of where the field line associated
                   with a given input point in space and time crosses the GSM XY plane (the magnetic equatorial plane).  GSM stands for
                   Geocentric Solar Magnetospheric System, and its XY plane is the equatorial plane of
                   the earth's magnetic dipole field.  The field lines are traced using the Tsyganenko
                     Magnetospheric model, so external effects on the earth's magnetic field such the solar wind are
                   taken into account.  This code uses the 2001 Tsyganenko model, which averages solar wind values
                   over the past hour, instead of simply using present values.</li>
                 <li> TSYG_EQ_XGSM: <b>Tsyganenko field GSE XY plane X point</b> (earth radii) <br>
                   This parameter gives the X value in GSE coordinates of where the field line associated
                   with a given input point in space and time crosses the GSE XY plane (the equatorial plane).  GSE stands for
                   Geocentric Solar Ecliptic System, and its XY plane is the equatorial plane of
                   the earth's rotation.  The field lines are traced using the Tsyganenko
                     Magnetospheric model, so external effects on the earth's magnetic field such the solar wind are
                   taken into account.  This code uses the 2001 Tsyganenko model, which averages solar wind values
                   over the past hour, instead of simply using present values.</li>
                 <li> TSYG_EQ_YGSM: <b>Tsyganenko field GSE XY plane Y point</b> (earth radii) <br>
                   This parameter gives the Y value in GSE coordinates of where the field line associated
                   with a given input point in space and time crosses the GSE XY plane (the equatorial plane).  GSE stands for
                   Geocentric Solar Ecliptic System, and its XY plane is the equatorial plane of
                   the earth's rotation.  The field lines are traced using the Tsyganenko
                     Magnetospheric model, so external effects on the earth's magnetic field such the solar wind are
                   taken into account.  This code uses the 2001 Tsyganenko model, which averages solar wind values
                   over the past hour, instead of simply using present values.</li>
                 <li> BHHMMSS and EHHMMSS: <b>Start and end time in HHMMSS</b> (suggested by Mary McCready at SRI)</li>
               </ul>
               <h2>Bug fixes</h2>
               <p>The Madrigal C API now no longer aborts when a Cedar file contains cycle marks (Cedar
                 parameter 95) that are not in order.  (Reported by Angela Li, SRI)</p>
               <p>A problem launching the global search with the python module os.spawnlp was fixed.
                 (Reported by Angela Li, SRI)</p>
             </blockquote>
             <p>&nbsp;</p>
             <hr></hr>
             <h1>
             Madrigal 2.2 Release - Feb 2003</h1>
             <blockquote>
               <h2>New derived parameters</h2>
               <ul>
                 <li>
                   SUNRISE_HOUR - <b>Ionospheric sunrise</b> (hour)<br>
                   This parameter gives the hour UT that sunrise occurs at that particular
                   point in space that particular day.  If that point in space is either in sunlight or in shadow
                   the entire UT day, sunrise_hour will be missing.  To find out which, display the
                   Shadow height (SDWHT) parameter.  If shadow height is less that the altitude of the
                   point, its in sunlight; if shadow height is greater than the altitude, its in the earth's shadow.</li>
                 <li>SUNSET_HOUR - <b>Ionospheric sunset</b> (hour)<br>
                   This parameter gives the hour UT that sunset occurs at that particular
                   point in space that particular day.  If that point in space is either in sunlight or in shadow
                   the entire UT day, sunset_hour will be missing.  To find out which, display the
                   Shadow height (SDWHT) parameter.  If shadow height is less that the altitude of the
                   point, its in sunlight; if shadow height is greater than the altitude, its in the earth's shadow.</li>
                 <li>CONJ_SUNRISE_H - <b>Magnetic conjugate point sunrise</b> (hour)<br>
                   This parameter gives the hour UT that sunrise occurs at the magnetic conjugate point of the particular
                   point in space that particular day.</li>
                 <li>CONJ_SUNSET_H - <b>Magnetic conjugate point sunset</b> (hour)<br>
                   This parameter gives the hour UT that sunset occurs at the magnetic conjugate point of the particular
                   point in space that particular day.</li>
                 <li>SZEN - <b>Solar zenith angle in measurement vol</b> (deg) <br>
                   This parameter gives the solar zenith angle in degrees.  If 0 degrees, the sun is directly
                   overhead.  A solar zenith angle of between 90 and 180 degrees does not mean the sun is not
                   visible, due to the finite solid angle of the sun and the altitude the point may be above the
                   earth's surface.</li>
                 <li>SZENC - <b>Conjugate solar zenith angle</b> (deg) <br>
                   This parameter gives the solar zenith angle at the magnetic conjugate point in degrees.</li>
                 <li>SDWHT - <b>Shadow height</b> (km) <br>
                   This parameter gives the height above the earth's surface at which any part of the sun can be seen.  It depends only
                   on the time, and on the geodetic latitude and longitude.  During the day shadow height will be zero.  Since the sun is
                   larger than the earth, the shadow height is always finite. If shadow height is less that the altitude of a given
                   point in space, its in sunlight; if shadow height is greater than the altitude, its in the earth's shadow.</li>
                 <li>MAGCONJSDWHT - <b>Magnetic conjugate shadow height</b> (km) <br>
                   This parameter gives the height above the earth's surface at the magnetic conjugate point's latitude and longitude at
                   which any part of the sun can be seen. </li>
                 <li><b>10 Interplanetary Magnetic Field parameters</b><br>
                   Includes field strength in GSM or GSE coordinates, solar wind plasma density, speed, and measuring satellite id.
                   Click on any parameter to see the definition of the two coordinate systems.</li>
               </ul>
               <h2>Filtering using any parameter</h2>
               <ul>
                 <li>There are now also free-form filters at the end
                   of the filter section, which allow you to set up filters based on any
                   single parameter or on two parameters either added,
                   subtracted, multiplied, or divided together.  For example, you can now filter on
                   Ti, the ratio Ti/dTi, or gdalt-sdwht (which is positive if the point is in sunlight).
                   See the tutorial for more details.</li>
               </ul>
               <h2>Better help understanding what each parameter means</h2>
               <ul>
                 <li>Complex parameters now have full html descriptions accessible from the isprint page.
                   Just click on the parameter name and you'll see the short description.  For more complex
                   parameters you'll also see a link to a more detailed explanation.</li>
               </ul>
               <h2>Improved data output</h2>
               <ul>
                 <li>If you select only 1D parameters, or derived parameters that depend only on other 1D parameters,
                   isprint will only print a single line per record, making it easier to read.</li>
                 <li>All filters used are printed at the beginning of the report.  Trivial filters that don't exclude
                   data (such as elevation from 0 to 90 degrees) are ignored.</li>
               </ul>
               <h2>Better consistency with Cedar standard</h2>
               <ul>
                 <li>All units are now consistent with the Cedar standard (when displaying Cedar parameters).</li>
                 <li>The special Cedar values "missing", "assumed", and "known bad" are differentiated in isprint output,
                   and not all lumped together as "missing" as before.</li>
                 <li>Unknown parameter codes displayed with a scale factor of 1.0.</li>
               </ul>
               <h2>New derived parameters are simple to add</h2>
               <ul>
                 <li>The isprint web page is now based on the madc library, and has been designed to
                   make it extremely simple to add new derived parameters.  See the
                   madc API documentation for details.</li>
               </ul>
             </blockquote>
             <!-- InstanceEndEditable -->
             <table width="100%" border="1" cellpadding="0" cellspacing="2" class="navigation">
               <tr>
-                <td width="5%"><a href="{% url 'docs' 'madIntroduction.html' %}"><img src="/static/previous.png" alt="previous" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madIntroduction.html' %}"><img src="/madrigal/static/previous.png" alt="previous" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/static/up.png" alt="up" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'madContents.html' %}"><img src="/madrigal/static/up.png" alt="up" width="32" height="32" /></a></td>
-                <td width="5%"><a href="{% url 'docs' 'wt_usersGuide.html' %}"><img src="/static/next.png" alt="next" width="32" height="32" /></a></td>
+                <td width="5%"><a href="{% url 'docs' 'wt_usersGuide.html' %}"><img src="/madrigal/static/next.png" alt="next" width="32" height="32" /></a></td>
                 <td width="54%"><!-- InstanceBeginEditable name="EditTitleBottom" -->What's new in Madrigal 3.0?<!-- InstanceEndEditable --></td>
                 <td width="13%"><a href="{% url 'docs' 'madContents.html' %}">Doc home </a></td>
                 <td width="18%"><a href="/">Madrigal home</a></td>
               </tr>
             </table>
             <div class='online-navigation'>
             <b class="navlabel">Previous:</b>
             <a class="sectref" href="{% url 'docs' 'madIntroduction.html' %}"><!-- InstanceBeginEditable name="PreviousTitle2" -->Brief History <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Up:</b>
             <a class="sectref" href="{% url 'docs' 'madContents.html' %}"><!-- InstanceBeginEditable name="UpTitle2" -->Doc home <!-- InstanceEndEditable --></A>
             <b class="navlabel">&nbsp;&nbsp;Next:</b>
             <a class="sectref" href="{% url 'docs' 'wt_usersGuide.html' %}"><!-- InstanceBeginEditable name="NextTitle2" -->Madrigal user's guide <!-- InstanceEndEditable --></A></div>
             <hr/>
             <p>&nbsp;</p>
             </body>
             <!-- InstanceEnd --></html>

source/madpy/djangoMad/madweb/urls.py 0 -1

             '''
             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 +23 -11

             '''
             @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
                     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 = request.GET.get('param1d', 0)
                 param2d = 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)))
-                fileList = madWebObj.getFileFromExpID(expID, False)
+                # fileList = madWebObj.getFileFromExpID(expID, False)
-                firsttuple = [a_tuple[0] for a_tuple in fileList]
+                # firsttuple = [a_tuple[0] for a_tuple in fileList]
-                basename = firsttuple[0]
+                basename = request.GET['filename']#firsttuple[0]
                 fullFilename = os.path.join(expDir, basename)
                 with h5py.File(fullFilename, "r") as f:
                     # Get the data
                     data = f['Data']
                     if 'Array Layout' in data:
                         array = data['Array Layout']
-                        datatime = [datetime.datetime.fromtimestamp(t) for t in array['timestamps']]
+                        datatime = [datetime.datetime.utcfromtimestamp(t-5*60*60) for t in array['timestamps']]
-                        yrange = array['gdalt']
+                        if 'gdalt' in array:
+                            yrange = array['gdalt']
+                        elif 'range' in array:
+                            yrange = array['range']
+                        else:
+                            return HttpResponse("There is no valid data for this plot: gdalt and/or range missing")
                         if param1d==0:
-                            plot = plot_heatmap(datatime, yrange, array['2D Parameters'][param2d], param2d)
+                            kindat = data['Table Layout']['kindat'][0]
+                            if kindat in (1950, 1911, 1913):
+                                plot = plot_scatter(datatime, array['2D Parameters'][param2d][0], param2d, array['2D Parameters']['d'+param2d][0])
+                            else:
+                                plot = plot_heatmap(datatime, yrange, array['2D Parameters'][param2d], param2d)
                         else:
                             plot = plot_scatter(datatime, array['1D Parameters'][param1d], param1d)
                     else:
                         table = data['Table Layout']
                         datatime = [datetime.datetime.fromtimestamp(t) for t in table['ut2_unix']]
                         plot = plot_scatter(datatime,table[param1d],param1d)
                 return HttpResponse(plot)
-            def plot_scatter(datatime,dataparam,paramname):
+            def plot_scatter(datatime,dataparam,paramname, error=[]):
                 if (numpy.isnan(dataparam).all()):
-                    plot = "There is no valid data available for this plot"
+                    plot = "There is no valid data available for this plot: Empty array"
                 else:
+                    mode = 'markers' if len(error)>0 else 'lines'
                     fig = go.Figure()
-                    fig.add_trace(go.Scatter(x=datatime, y=dataparam))
+                    fig.add_trace(go.Scatter(x=datatime, y=dataparam, mode=mode, error_y={'type':'data', 'array':error, 'visible':True, 'color':'rgba(255, 144, 14, 0.7)'}))
                     fig.update_yaxes(title_text=paramname)
+                    fig.update_xaxes(title_text='Time [LT]')
                     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.all(numpy.isnan(dataparam))):
-                    plot = "There is no valid data available for this plot"
+                    plot = "There is no valid data available for this plot: Empty array"
                 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_xaxes(title_text="Time [LT]")
                     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.05, yref="paper", align="left"),
                             dict(text="Lines", x=0.25, xref="paper", y=1.05, 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

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