parsac 0.5.8__tar.gz

parsac-0.5.8/.github/dependabot.yml

@@ -0,0 +1,10 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      # Check for updates to GitHub Actions every week
+      interval: "weekly"

parsac-0.5.8/.github/workflows/parsac.yml

@@ -0,0 +1,22 @@
+name: Install and test
+on: push
+jobs:
+   test:
+      strategy:
+        matrix:
+          python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        fail-fast: false
+      runs-on: ubuntu-latest
+      steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install parsac
+        run: pip install .
+      - name: Test calibration
+        run: |
+          cd parsac/examples
+          parsac calibration run idealized.xml

parsac-0.5.8/.github/workflows/publish_to_pypi.yml

@@ -0,0 +1,41 @@
+name: Build and publish
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+    - name: Clone repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # for version detection by hatch-vcs/setuptools_scm
+    - name: Set up Python
+      uses: actions/setup-python@v5
+    - name: Install build
+      run: pip install build
+    - name: Build a binary wheel and a source tarball
+      run: python -m build
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+  publish-to-pypi:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/${{ github.event.repository.name }}
+    permissions:
+      id-token: write
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/      
+    - name: Publish package to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

parsac-0.5.8/.gitignore

@@ -0,0 +1,9 @@
+*.nc
+*.png
+*.db
+*.pyc
+*.whl
+*.egg-info/
+Licenses/
+*.ppjob
+build/

parsac-0.5.8/.zenodo.json

@@ -0,0 +1,18 @@
+{
+   "title": "parsac: parallel sensitivity analysis and calibration",
+   "creators": [
+      {
+         "name": "Jorn Bruggeman",
+         "affiliation": "Bolding & Bruggeman ApS",
+         "orcid": "0000-0003-2493-2323"
+      },
+      {
+         "name": "Karsten Bolding",
+         "affiliation": "Bolding & Bruggeman ApS",
+         "orcid": "0000-0001-8465-3196"
+      }
+   ],
+   "upload_type": "software",
+   "access_right": "open",
+   "license": "GPL-2.0"
+}

parsac-0.5.8/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: parsac
+Version: 0.5.8
+Summary: Parallel Sensitivity Analysis and Calibration
+Home-page: https://github.com/BoldingBruggeman/parsac
+Author: Jorn Bruggeman
+Author-email: jorn@bolding-bruggeman.com
+License: GPL
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: License :: OSI Approved :: GNU General Public License (GPL)
+Classifier: Programming Language :: Python
+Requires-Dist: netCDF4
+
+# parsac
+
+parsac (formerly acpy) is a Python-based tool for sensitivity analysis and auto-calibration in parallel.
+It is designed for analysis of models that take significant time to run.
+For that reason, it focuses on storing and exploiting every single model result,
+and performing model runs in parallel on either a single machine or
+on computer clusters. It works with models that are run by calling one binary,
+that use text-based configuration files based on YAML or Fortran namelists,
+and that write their output to NetCDF.
+
+[![DOI](https://zenodo.org/badge/206791023.svg)](https://zenodo.org/badge/latestdoi/206791023) [![Build Status](https://travis-ci.com/BoldingBruggeman/parsac.svg?branch=master)](https://travis-ci.com/BoldingBruggeman/parsac)
+
+## Installation
+
+`pip install parsac --user`
+
+Remove `--user` to install in the system's shared Python directory (not recommended).
+Some systems have multiple versions of pip, e.g., pip for Python 2, pip3 for Python 3.
+Make sure you use the command that corresponds to the Python version you want to install into.
+
+### Dependencies
+
+parsac supports parallel simulations through [Parallel Python](https://www.parallelpython.com).
+This package supports Python 2 out of the box (`pip install pp --user`), but its Python 3 version
+is currently in beta. To install pp in Python 3, [download the zip file with the Python 3 port of Parallel Python](https://www.parallelpython.com/content/view/18/32), extract its contents, go to the contained directory and open a command prompt there, then run `python setup.py install`.
+
+parsac uses [SALib](https://github.com/SALib/SALib) for sensitivity analysis. Typically, this can be installed with `pip install SALib --user`. If you are using [the Anaconda Python distribution](https://www.anaconda.com), you can instead do `conda install SALib` (you may need to add `-c conda-forge`).
+
+## Known issues
+
+* On Windows, parallel runs may finish with several "ERROR: The process "xxx" not found." messages. These are harmless and can be ignored - the analysis has completed successfully and all results have been correctly processed.

parsac-0.5.8/README.md

@@ -0,0 +1,31 @@
+# parsac
+
+parsac (formerly acpy) is a Python-based tool for sensitivity analysis and auto-calibration in parallel.
+It is designed for analysis of models that take significant time to run.
+For that reason, it focuses on storing and exploiting every single model result,
+and performing model runs in parallel on either a single machine or
+on computer clusters. It works with models that are run by calling one binary,
+that use text-based configuration files based on YAML or Fortran namelists,
+and that write their output to NetCDF.
+
+[![DOI](https://zenodo.org/badge/206791023.svg)](https://zenodo.org/badge/latestdoi/206791023) [![Build Status](https://travis-ci.com/BoldingBruggeman/parsac.svg?branch=master)](https://travis-ci.com/BoldingBruggeman/parsac)
+
+## Installation
+
+`pip install parsac --user`
+
+Remove `--user` to install in the system's shared Python directory (not recommended).
+Some systems have multiple versions of pip, e.g., pip for Python 2, pip3 for Python 3.
+Make sure you use the command that corresponds to the Python version you want to install into.
+
+### Dependencies
+
+parsac supports parallel simulations through [Parallel Python](https://www.parallelpython.com).
+This package supports Python 2 out of the box (`pip install pp --user`), but its Python 3 version
+is currently in beta. To install pp in Python 3, [download the zip file with the Python 3 port of Parallel Python](https://www.parallelpython.com/content/view/18/32), extract its contents, go to the contained directory and open a command prompt there, then run `python setup.py install`.
+
+parsac uses [SALib](https://github.com/SALib/SALib) for sensitivity analysis. Typically, this can be installed with `pip install SALib --user`. If you are using [the Anaconda Python distribution](https://www.anaconda.com), you can instead do `conda install SALib` (you may need to add `-c conda-forge`).
+
+## Known issues
+
+* On Windows, parallel runs may finish with several "ERROR: The process "xxx" not found." messages. These are harmless and can be ignored - the analysis has completed successfully and all results have been correctly processed.

parsac-0.5.8/admin/pull_optimize

@@ -0,0 +1 @@
+git subtree pull --prefix parsac/optimize git@bitbucket.org:jbruggeman/optimize.git master --squash

parsac-0.5.8/admin/pull_optimize.bat

@@ -0,0 +1,3 @@
+set HOME=%USERPROFILE%
+git subtree pull --prefix parsac/optimize git@bitbucket.org:jbruggeman/optimize.git master
+`

parsac-0.5.8/admin/push_optimize

@@ -0,0 +1 @@
+git subtree push --prefix parsac/optimize git@bitbucket.org:jbruggeman/optimize.git master --squash

parsac-0.5.8/need_updates/clear_database.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+import optparse,sys
+
+import mysqlinfo
+
+parser = optparse.OptionParser()
+parser.add_option('-r', '--run', type='int', help='run identifier')
+parser.add_option('-j', '--job', type='int', help='job identifier')
+parser.add_option('--emptyrows', action='store_true', help='delete empty rows only')
+parser.set_defaults(emptyrows=False)
+(options, args) = parser.parse_args()
+
+db = mysqlinfo.connect(mysqlinfo.admin)
+
+c = db.cursor()
+
+addedwhere = ''
+selection = 'all'
+if options.emptyrows:
+    addedwhere = ' AND (`parameters`=\'\' OR `parameters`=NULL)'
+    selection = 'empty'
+
+def delRun(run):
+    print 'Removing %s records for run %i from the database...' % (selection,run)
+    c.execute('DELETE FROM `results` WHERE (`run`=%i%s);' % (run,addedwhere))
+    print '%i records removed from "results" table.' % db.affected_rows()
+    if not addedwhere:
+        c.execute('DELETE FROM `runs` WHERE `id`=%i;' % (run,))
+        print '%i records removed from "runs" table.' % db.affected_rows()
+
+if options.run is not None:
+    delRun(options.run)
+elif options.job is not None:
+    query = "SELECT `id` FROM `runs` WHERE `job`='%i'" % options.job
+    c.execute(query)
+    for run, in c:
+        delRun(run)
+else:
+    print 'Currently the clearing of the entire database is disabled for safety.'
+    sys.exit(1)
+    c.execute('DELETE FROM `results`;')
+    print '%i records removed from "results" table.' % db.affected_rows()
+    c.execute('DELETE FROM `runs`;')
+    print '%i records removed from "runs" table.' % db.affected_rows()
+
+db.commit()
+db.close()

parsac-0.5.8/need_updates/create_database.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+
+import sys
+import mysqlinfo
+
+# Get user name and password to be used to connect to MySQL server.
+db = mysqlinfo.connect(mysqlinfo.admin)
+c = db.cursor()
+
+print 'Connected to MySQL server %s.' % mysqlinfo.host
+
+# Get list of existing databases.
+c.execute('SHOW DATABASES;')
+dbs = [d[0] for d in c.fetchall()]
+
+if mysqlinfo.database in dbs:
+    resp = ''
+    while resp not in ('y','n'):
+        resp = raw_input('Database "%s" already exists. Do you want to drop it and create a new one? (y/n): ' % mysqlinfo.database)
+    if resp=='n':
+        print 'Database creation cancelled.'
+        sys.exit(0)
+    c.execute('DROP DATABASE `%s`;' % mysqlinfo.database)
+
+#c.execute('ALTER TABLE `runs` ADD COLUMN `job` INT AFTER `time`;')
+#c.execute('ALTER TABLE `results` MODIFY `parameters` VARCHAR(500);')
+
+# Delete and recreate database
+c.execute('CREATE DATABASE `%s`;' % mysqlinfo.database)
+
+# Create users and grant minimum permissions
+c.execute('CREATE USER \'%s\'@\'%%\' IDENTIFIED BY \'%s\';' % (mysqlinfo.runuser,mysqlinfo.runpassword))
+c.execute('CREATE USER \'%s\'@\'localhost\' IDENTIFIED BY \'%s\';' % (mysqlinfo.viewuser,mysqlinfo.viewpassword))
+c.execute('GRANT SELECT ON `%s`.* TO \'%s\'@\'localhost\';' % (mysqlinfo.database,mysqlinfo.viewuser))
+c.execute('GRANT INSERT ON `%s`.* TO \'%s\'@\'%%\';' % (mysqlinfo.database,mysqlinfo.runuser))
+
+# Create tables
+c.execute('USE `%s`;' % mysqlinfo.database)
+c.execute('CREATE TABLE `runs`    (`id` INT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY,`source` VARCHAR(50) NOT NULL,`time` DATETIME NOT NULL,`job` INT,`description` TEXT);')
+c.execute('CREATE TABLE `results` (`id` INT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE PRIMARY KEY,`run` INT UNSIGNED NOT NULL,`time` DATETIME NOT NULL,`parameters` VARCHAR(500) NOT NULL,`lnlikelihood` DOUBLE);')
+
+db.close()

parsac-0.5.8/need_updates/extractpop.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+# Import from standard Python library
+import sys,optparse
+
+# Import third-party modules
+import numpy
+
+# Import custom modules
+import mysqlinfo
+
+parser = optparse.OptionParser()
+(options, args) = parser.parse_args()
+
+assert len(args)>1, 'First argument must be the run identifier, second argument the file to save to.'
+
+db = mysqlinfo.connect(mysqlinfo.select)
+
+# Retrieve all results
+c = db.cursor()
+query = "SELECT `id`,`parameters` FROM `results` WHERE `run`=%i" % int(args[0])
+c.execute(query)
+history = []
+for resid,strpars in c:
+    parameters = map(float,strpars.split(';'))
+    history.append(parameters)
+db.close()
+print 'Found %i results.' % (len(history),)
+
+# Stop if no results were found
+if len(history)==0: sys.exit(0)
+
+# Convert results into numpy array
+res = numpy.zeros((len(history),len(history[0])))
+for i,v in enumerate(history):
+    res[i,:] = v
+
+res.dump(args[1])

parsac-0.5.8/need_updates/mysqlinfo.py

@@ -0,0 +1,48 @@
+host         = 'localhost'
+database     = 'optimize'
+runuser      = 'run'
+runpassword  = 'g0tm'
+viewuser     = 'jorn'
+viewpassword = '1r3z2g6$'
+adminuser     = None
+adminpassword = None
+defaultfile   = None
+
+admin  = 0
+select = 1
+insert = 2
+
+import getpass
+import MySQLdb
+
+def connect(task=None):
+    # Set default user naem/password based on chosen task.
+    username,password = None,None
+    if task==admin:
+        username,password = adminuser,adminpassword
+    elif task==select:
+        username,password = viewuser,viewpassword
+    elif task==insert:
+        username,password = runuser,viewpassword
+
+    # If we do not have a user name yet, and we do not have a default file either, ask the user interactively.
+    if username is None and defaultfile is None:
+        username = 'root'
+        print 'Connecting to MySQL server %s.' % host
+        username = raw_input('User name [root]: ')
+        if not username: username = 'root'
+
+    # If we do not have a passsword yet, and we do not have a default file either, ask the user interactively.
+    if password is None and defaultfile is None:
+        password = getpass.getpass('Password for user %s: ' % username)
+        
+    # Connect to database
+    kwargs = {}
+    if host     is not None: kwargs['host']   = host
+    if database is not None: kwargs['db']     = database
+    if username is not None: kwargs['user']   = username
+    if password is not None: kwargs['passwd'] = password
+    if defaultfile is not None: kwargs['read_default_file'] = defaultfile
+    db = MySQLdb.connect(**kwargs)
+    
+    return db

parsac-0.5.8/need_updates/runbadresult.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+import sys,math,optparse
+
+import acpy.run
+import acpy.gotmcontroller
+import mysqlinfo
+
+parser = optparse.OptionParser()
+parser.add_option('-i', '--index', type='int', help='index of bad result (>=0)')
+parser.set_defaults(index=0)
+(options, args) = parser.parse_args()
+
+if len(args)<1:
+    print 'No job identifier provided.'
+    sys.exit(2)
+jobid = int(args[0])
+
+print 'Looking for bad result %i of job %i.' % (options.index,jobid)
+
+# Connect to database and retrieve best parameter set.
+db = mysqlinfo.connect(mysqlinfo.select)
+c = db.cursor()
+c.execute("SELECT `parameters`,`lnlikelihood` FROM `runs`,`results` WHERE (`runs`.`id`=`results`.`run` AND `runs`.`job`=%i AND `lnlikelihood` IS NULL) LIMIT %i,1" % (jobid,options.index))
+parameters = None
+for strpars,lnlikelihood in c:
+    parameters = map(float,strpars.split(';'))
+db.close()
+if parameters==None:
+    print 'No bad results found. Exiting...'
+    sys.exit(0)
+
+job = acpy.run.getJob(jobid)
+
+# Show best parameter set
+print 'Testing bad parameter set number %i.' % options.index
+print 'Problem parameter set:'
+for i,val in enumerate(parameters):
+    pi = job.controller.parameters[i]
+    if pi['logscale']: val = math.pow(10.,val)
+    print '   %s = %.6g' % (pi['name'],val)
+
+# Initialize the GOTM controller.
+job.controller.initialize()
+
+# Run and retrieve results.
+nc = job.controller.run(parameters,showoutput=True)

parsac-0.5.8/need_updates/runyears.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+
+import re,os.path
+from Scientific.IO.NetCDF import NetCDFFile
+import matplotlib.pylab,numpy
+import acpy.gotmcontroller,acpy.run,acpy.optimizer
+
+jobid = 25
+scenpath = os.path.join('acpy','./scenarios/%i' % jobid)
+obsdir = os.path.join('acpy',acpy.run.obsdir)
+
+nmlfile = os.path.join(scenpath,'gotmrun.nml')
+
+for year in range(2000,2006):
+    print 'Running year %04i' % year
+    nmls,nmlorder = acpy.gotmcontroller.parseNamelistFile(nmlfile)
+    nmls['time']['start'] = '"%04i-01-01 00:00:00"' % year
+    nmls['time']['stop'] = '"%04i-01-01 00:00:00"' % (year+1)
+    acpy.gotmcontroller.writeNamelistFile(nmlfile,nmls,nmlorder)
+
+    job = acpy.optimizer.Job(jobid,
+                        scenpath,
+                        gotmexe=acpy.run.exe,
+                        transports=(acpy.transport.Dummy(),),
+                        copyexe=True)
+
+    job.verbose = False
+    job.addObservation(os.path.join(obsdir,'pottemp.obs'),'temp',maxdepth=310,cache=False)
+    job.addObservation(os.path.join(obsdir,'salt.obs'),'salt',maxdepth=310,cache=False)
+    job.verbose = True
+
+    job.initialize()
+
+    obsinfo = job.observations
+    outputvars = [oi['outputvariable'] for oi in obsinfo]
+
+    # Run and retrieve results.
+    ncpath = job.controller.run((),showoutput=False,returnncpath=True)
+    if ncpath==None:
+        print 'GOTM run failed - exiting.'
+        sys.exit(1)
+    nc = NetCDFFile(ncpath,'r')
+    res = acpy.run.job.controller.getNetCDFVariables(nc,outputvars,addcoordinates=True)
+    nc.close()
+
+    # Shortcuts to coordinates
+    tim_cent,z_cent,z1_cent = res['time_center'],res['z_center'],res['z1_center']
+    tim_stag,z_stag,z1_stag = res['time_staggered'],res['z_staggered'],res['z1_staggered']
+
+    # Find the depth index from where we start
+    ifirstz = z_cent.searchsorted(-300)
+    viewdepth = 300
+
+    hres = matplotlib.pylab.figure()
+    herr = matplotlib.pylab.figure()
+    for i,oi in enumerate(obsinfo):
+        modeldata = res[oi['outputvariable']]
+        obsdata = oi['observeddata']
+
+        modelmin = oi.get('modelminimum',None)
+        if modelmin!=None: modeldata[modeldata<modelmin] = modelmin
+
+        # Calculate model predictions on observation coordinates.
+        pred = acpy.gotmcontroller.interp2(tim_cent,z_cent,modeldata,obsdata[:,0],obsdata[:,1])
+
+        # If we do a relative fit, scale the model result to best match observations.
+        if oi['relativefit']:
+            if (pred==0.).all():
+                print 'ERROR: cannot calculate optimal scaling factor for %s because all model values equal zero.' % oi['outputvariable']
+                sys.exit(1)
+            scale = sum(obsdata[:,2]*pred)/sum(pred*pred)
+            print 'Optimal model-to-observation scaling factor for %s = %.6g.' % (oi['outputvariable'],scale)
+            pred *= scale
+            modeldata *= scale
+
+        varrange = (min(modeldata[:,ifirstz:].min(),obsdata[:,2].min()),max(modeldata[:,ifirstz:].max(),obsdata[:,2].max()))
+
+        diff = pred-obsdata[:,2]
+        print '%s: mean absolute error = %.4g, s.d. = %.4g.' % (oi['outputvariable'],numpy.mean(numpy.abs(diff)),numpy.sqrt(numpy.mean(diff**2)))
+
+        if False:
+            # Create figure for model-data comparison
+            matplotlib.pylab.figure(hres.number)
+
+            # Plot model result
+            matplotlib.pylab.subplot(len(obsinfo),2,i*2+1)
+            matplotlib.pylab.pcolor(tim_stag,z_stag,modeldata.transpose())
+            matplotlib.pylab.clim(varrange)
+            matplotlib.pylab.ylim(-viewdepth,0)
+            matplotlib.pylab.colorbar()
+            matplotlib.pylab.xlim(tim_stag[0],tim_stag[-1])
+            xax = matplotlib.pylab.gca().xaxis
+            loc = matplotlib.dates.AutoDateLocator()
+            xax.set_major_formatter(matplotlib.dates.AutoDateFormatter(loc))
+            xax.set_major_locator(loc)
+            matplotlib.pylab.grid(True)
+
+            # Plot observations
+            matplotlib.pylab.subplot(len(obsinfo),2,i*2+2)
+            matplotlib.pylab.scatter(obsdata[:,0],obsdata[:,1],s=10,c=obsdata[:,2],cmap=matplotlib.cm.jet,vmin=varrange[0],vmax=varrange[1],faceted=False)
+            matplotlib.pylab.ylim(-viewdepth,0)
+            matplotlib.pylab.xlim(tim_stag[0],tim_stag[-1])
+            matplotlib.pylab.clim(varrange)
+            xax = matplotlib.pylab.gca().xaxis
+            loc = matplotlib.dates.AutoDateLocator()
+            xax.set_major_formatter(matplotlib.dates.AutoDateFormatter(loc))
+            xax.set_major_locator(loc)
+            matplotlib.pylab.grid(True)
+
+            # Plot histogram with errors.
+            matplotlib.pylab.figure(herr.number)
+            matplotlib.pylab.subplot(len(obsinfo),1,i+1)
+            #matplotlib.pylab.plot(diff,obs[:,1],'o')
+            #matplotlib.pylab.figure()
+            n, bins, patches = matplotlib.pylab.hist(diff, 100, normed=1)
+            #y = matplotlib.pylab.normpdf(bins, 0., numpy.sqrt(ssq/len(diff)))
+            #l = matplotlib.pylab.plot(bins, y, 'r--', linewidth=2)
+
+if False: matplotlib.pylab.show()
+
+
+
+    
+
+

parsac-0.5.8/need_updates/showruninfo.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+
+# Import from standard Python library
+import sys,optparse
+
+# Import custom Python modules
+import mysqlinfo
+
+parser = optparse.OptionParser()
+(options, args) = parser.parse_args()
+
+if len(args)==0:
+    print 'No run identifier specified.'
+    sys.exit(1)
+runid = int(args[0])
+
+print 'Showing information for run with identifier %i' % runid
+
+# Retrieve run information
+db = mysqlinfo.connect(mysqlinfo.select)
+c = db.cursor()
+c.execute("SELECT `source`,`time`,`description` FROM `runs` WHERE `id`=%i" % runid)
+for (source,time,description) in c:
+    print 'Source: %s' % source
+    print 'Start time: %s' % time
+
+    if description==None:
+        print 'No description was provided.'
+        continue
+    import pickle
+    info = pickle.loads(description)
+    
+    print 'Parameters:'
+    for p in info['parameters']:
+        print '   %s/%s/%s, range: %.6g - %.6g, log scale: %s' % (p['namelistfile'],
+                                                               p['namelistname'],
+                                                               p['name'],
+                                                               p['minimum'],
+                                                               p['maximum'],
+                                                               p['logscale'])
+    print 'Observations:'
+    for p in info['observations']:
+        print '   file: %s, variable: %s, relative fit: %s' % (p['sourcepath'],p['outputvariable'],p['relativefit'])
+
+db.close()
+

parsac-0.5.8/parsac/.gitignore

@@ -0,0 +1,6 @@
+build
+dist
+scenarios
+obs
+Microsoft.VC80.CRT
+*.pyc

parsac-0.5.8/parsac/__init__.py

@@ -0,0 +1,48 @@
+import subprocess
+import argparse
+import sys
+
+from . import service
+service.read()
+from . import autocalibration
+from . import sensitivity
+from . import ensemble
+
+__version__ = 'version not available'
+
+import importlib.metadata
+try:
+    __version__ = importlib.metadata.version("parsac")
+except importlib.metadata.PackageNotFoundError:
+    try:
+        from setuptools_scm import get_version
+        __version__ = get_version(root='..', relative_to=__file__)
+    except ImportError:
+        pass
+
+def main():
+    parser = argparse.ArgumentParser(description='parsac - Parallel Sensitivity Analysis and Calibration')
+#    parser.add_argument('--help', action='help')
+    parser.add_argument('-v', '--version', action='version', version=__version__)
+    subparsers = parser.add_subparsers()
+
+    parser_sa = subparsers.add_parser('sensitivity', help='Sensitivity analysis')
+    sensitivity.configure_argument_parser(parser_sa)
+    parser_sa.set_defaults(func=sensitivity.main)
+
+    parser_ac = subparsers.add_parser('calibration', help='Auto calibration')
+    autocalibration.configure_argument_parser(parser_ac)
+    parser_ac.set_defaults(func=autocalibration.main)
+
+    parser_ensemble = subparsers.add_parser('ensemble', help='Ensemble simulation')
+    ensemble.configure_argument_parser(parser_ensemble)
+    parser_ensemble.set_defaults(func=ensemble.main)
+
+    parser_service = subparsers.add_parser('service', help='Service information')
+    parser_service.set_defaults(func=service.main)
+
+    args = parser.parse_args()
+    if getattr(args, 'func', None) is None:
+        print('parsac must be called with a subcommand. Use -h to see options')
+        sys.exit(2)
+    args.func(args)