Migrated from GitHub

.gitattributes

@@ -57,3 +57,132 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/bionetgen/win32Standalone/BNG2_32bit.exe filter=lfs diff=lfs merge=lfs -text
+data/bionetgen/win64Standalone/BNG2.exe filter=lfs diff=lfs merge=lfs -text
+data/docker/build/installers/icons/vcell.icns filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/linux32/libjhdf.so filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/linux32/libjhdf5.so filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/linux64/libjhdf.so filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/linux64/libjhdf5.so filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/mac64/libjhdf.jnilib filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/mac64/libjhdf5.jnilib filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/jhdf.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/jhdf5.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/msvcp100.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/msvcp100d.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/msvcr100.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win32/msvcr100d.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win64/jhdf.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win64/jhdf5.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win64/msvcp100.dll filter=lfs diff=lfs merge=lfs -text
+data/nativelibs/win64/msvcr100.dll filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/OmexWithThirdPartyResults/BIOMD0000000003_tellurium_A_minimal_cascade_model_for_th.spec.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/OmexWithThirdPartyResults/BIOMD0000000006_tellurium_Modeling_the_cell_division_cyc.spec.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/OmexWithThirdPartyResults/BIOMD0000000036_tellurium_A_simple_model_of_circadian_rh.spec.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/OmexWithThirdPartyResults/BIOMD0000000300.spec.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000005.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000175.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000302.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000561.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000569.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000618.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000651.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000668.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000669.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000676.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000679.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000680.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000681.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000684.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000718.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000724.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000731.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000842.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000843.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000915.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000932.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000968.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000972.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000983.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000989.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000000997.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001010.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001014.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001018.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001061.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001064.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/misc-projects/BIOMD0000001072.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Caravagna-J-Theor-Biol-2010-tumor-suppressive-oscillations.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-Fehlberg.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Ciliberto-J-Cell-Biol-2003-morphogenesis-checkpoint-continuous.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Edelstein-Biol-Cybern-1996-Nicotinic-excitation.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Parmar-BMC-Syst-Biol-2017-iron-distribution.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Szymanska-J-Theor-Biol-2009-HSP-synthesis.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Varusai-Sci-Rep-2018-mTOR-signaling-LSODA-LSODAR-SBML.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Vilar-PNAS-2002-minimal-circardian-clock-continuous.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/sbml-core/Vilar-PNAS-2002-minimal-circardian-clock.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/combine_archive/CombineArchiveHasSedDocumentsInNestedDirectories/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/combine_archive/CombineArchiveHasSedDocumentsWithSameNamesInDifferentInNestedDirectories/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/combine_archive/WhenACombineArchiveHasAMasterFileSimulatorOnlyExecutesThisFile/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/combine_archive/WhenACombineArchiveHasNoMasterFileSimulatorExecutesAllSedDocuments/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/docker_image/SingularityImageExecutesSimulationsSuccessfully/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/log/SimulatorReportsTheStatusOfTheExecutionOfCombineArchives/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/log/SimulatorReportsTheStatusOfTheExecutionOfSedDocuments/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/log/SimulatorReportsTheStatusOfTheExecutionOfSedOutputs/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/log/SimulatorReportsTheStatusOfTheExecutionOfSedTasks/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/results_report/SimulatorGeneratesReportsOfSimulationResults/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorCanResolveModelSourcesDefinedByUriFragments/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorCanResolveModelSourcesDefinedByUriFragmentsAndInheritChanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesLinear2DPlots/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesLinear2DPlots/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesLogarithmic2DPlots/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesLogarithmic2DPlots/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesMultiplePlots/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorProducesMultiplePlots/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsAddReplaceRemoveModelElementChanges/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsAddReplaceRemoveModelElementChanges/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsAddReplaceRemoveModelElementChanges/3.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsAlgorithmParameters/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsComputeModelChanges/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsComputeModelChanges/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsDataGeneratorsWithDifferentShapes/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsDataSetsWithDifferentShapes/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsModelAttributeChanges/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsModelAttributeChanges/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsModelsSimulationsTasksDataGeneratorsAndReports/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsMultipleReportsPerSedDocument/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsMultipleTasksPerSedDocument/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithChanges/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithChanges/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithFunctionalRangeVariables/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithFunctionalRangeVariables/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithFunctionalRanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithLinearUniformRanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithLogarithmicUniformRanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithMultipleSubTasks/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithNestedFunctionalRanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithNestedRepeatedTasks/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithSubTasksOfMixedTypes/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithSubTasksOfMixedTypes/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsRepeatedTasksWithVectorRanges/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsSubstitutingAlgorithms/1.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsSubstitutingAlgorithms/2.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsSubstitutingAlgorithms/3.execute-should-fail.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsSubstitutingAlgorithms/4.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsUniformTimeCoursesWithNonZeroInitialTimes/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/synths/sedml/SimulatorSupportsUniformTimeCoursesWithNonZeroOutputStartTimes/1.execution-should-succeed.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/bsts-omex/vcml/Powers-Pflugers-Arch-2016-Drosophila-synaptic-strength.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-cli/src/test/resources/org/vcell/cli/run/plotting/MultiplePlotsTest.omex filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/AccessingSimResults[[:space:]]copy.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/SimResSpatialSliceView.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/analyticGeometrySubdomainOps.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/rxdiag.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/vcell.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/vcellMain.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/UserDocumentation/originalXML/topics/originalImages/vcellMain.psd~master filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/src/main/resources/cubes.blend filter=lfs diff=lfs merge=lfs -text
+data/vcell-client/src/main/resources/vcellSplash7.psd filter=lfs diff=lfs merge=lfs -text
+data/vcell-core/src/test/resources/cbit/vcell/simdata/SimID_946368938_0_.hdf5 filter=lfs diff=lfs merge=lfs -text
+data/vcell-rest/src/test/resources/flybrain-035.tif filter=lfs diff=lfs merge=lfs -text
+data/vcell-rest/src/test/resources/mitosis.tif filter=lfs diff=lfs merge=lfs -text
+data/vcell-rest/src/test/resources/small-mitosis.tif filter=lfs diff=lfs merge=lfs -text

data/.dockerignore

@@ -0,0 +1,460 @@
+.settings
+
+# ignore .git and .cache folders
+.git
+.cache
+
+# ignore all markdown files (md) beside all README*.md
+*.md
+!README*.md
+
+### PuTTY template
+# Private key
+*.ppk
+
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs-misc/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+### NotepadPP template
+# Notepad++ backups #
+*.bak
+
+### Xcode template
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
+*.xcscmblueprint
+*.xccheckout
+
+## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+DerivedData/
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+
+## Gcc Patch
+/*.gcno
+
+### VirtualEnv template
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+[Ss]cripts
+pyvenv.cfg
+pip-selfcheck.json
+
+### macOS template
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# result dir
+results/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Java template
+# Compiled class file
+# Log file
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+### C template
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+### C++ template
+# Prerequisites
+# Compiled Object files
+*.slo
+# Precompiled Headers
+# Compiled Dynamic libraries
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+# Executables
+### VisualStudioCode template
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+### Eclipse template
+.metadata
+bin/
+tmp/
+*.tmp
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# CDT- autotools
+.autotools
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Annotation Processing
+.apt_generated/
+.apt_generated_test/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+
+# Uncomment this line if you wish to ignore the project description file.
+# Typically, this file would be tracked if it contains build/dependency configurations:
+#.project
+

data/.mailmap

@@ -0,0 +1,5 @@
+Anvin Thomas <anvin@localhost>
+Frank Morgan <frm@uchc.edu> <frm@frmdev2.cam.uchc.edu>
+Jim Schaff <schaff@uchc.edu> <schaff@nrcamdev5.cam.uchc.edu>
+Kevin Gaffney <kgaffney@localhost>
+Mike Wilson <mpw6@users.noreply.github.com>

data/.quarkus/cli/plugins/quarkus-cli-catalog.json

@@ -0,0 +1,5 @@
+{
+  "version" : "v1",
+  "lastUpdate" : "01/11/2023 16:25:33",
+  "plugins" : { }
+}

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,123 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[vcell_support@uchc.edu](mailto:vcell_support@uchc.edu).
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html).
+
+The Community Impact Guidelines were inspired by [Mozilla's Code of Conduct Enforcement ladder](https://github.com/mozilla/diversity).
+
+Answers to common questions about this code of conduct are available at
+https://www.contributor-covenant.org/faq. Translations of this code of conduct are available at
+https://www.contributor-covenant.org/translations.

data/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# Guide to contributing to the Virtual Cell
+
+We believe - and we hope you do too - that learning how to code, how to think, and how to contribute to open source can delegate the next generation of coders and creators. We exuberantly welcome contributions to Virtual Cell! This document describes how developers can contribute to the Virtual Cell. Modelers can contribute new models to VCell via multi-platform standalone application downloading from http://vcell.org.
+
+If you have never contributed to an open-source project before and you’re just getting started, consider exploring these resources.
+
+[A Step by Step Guide to Making Your First GitHub Contribution](https://codeburst.io/a-step-by-step-guide-to-making-your-first-github-contribution-5302260a2940)
+
+[How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
+
+
+To get some insights about Github terminologies, consider exploring these resources.
+
+[Collaborating With Issues And Pull Requests](https://help.github.com/categories/collaborating-with-issues-and-pull-requests/)
+
+
+If you are still facing some issues while contributing to the repository, please reach us on [VCell Support](mailto:vcell_support@uchc.edu).
+
+**Note** : Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+
+## Coordinating contributions, Issues, and bugs
+
+Before getting started, please contact the lead developers at [vcell_support@uchc.edu](mailto:vcell_support@uchc.edu) to coordinate your planned contributions with other ongoing efforts. VCell Support is open at all junctures, emails about issues, bugs, and enhancements. 
+
+## Setting up your development environment
+
+To contribute to Virtual Cell, please follow README.MD file instructions to the setup development environment. 
+
+## Submitting changes
+
+Please use GitHub pull requests to submit changes. Each submission should include a brief description of the new and/or modified features upon each pull request. Pull requests will be approved after the review by one of the developers.
+
+

data/Dockerfile

@@ -0,0 +1,90 @@
+FROM eclipse-temurin:17-jammy as jre-build
+
+# Create a custom Java runtime
+RUN $JAVA_HOME/bin/jlink \
+         --add-modules ALL-MODULE-PATH \
+         --strip-debug \
+         --no-man-pages \
+         --no-header-files \
+         --compress=2 \
+         --output /javaruntime
+
+# Define base image and copy in jlink created minimal Java 17 environment
+FROM ubuntu:jammy
+ENV JAVA_HOME=/opt/java/openjdk
+ENV PATH "${JAVA_HOME}/bin:${PATH}"
+COPY --from=jre-build /javaruntime $JAVA_HOME
+
+# now we have Java 17 and Python 3.9
+ARG SIMULATOR_VERSION="7.5.0.11"
+ARG MAX_JAVA_MEM=0
+# Make sure you don't sap all of docker's memory when you set this.
+ENV ENV_SIMULATOR_VERSION=$SIMULATOR_VERSION
+ENV MAX_JAVA_MEM_MB=$MAX_JAVA_MEM
+
+# metadata
+LABEL \
+    org.opencontainers.image.title="VCell" \
+    org.opencontainers.image.version="${SIMULATOR_VERSION}" \
+    org.opencontainers.image.description="Open-source software package for modeling cell biological systems that is built on a central database and disseminated as a standalone application." \
+    org.opencontainers.image.url="http://vcell.org/" \
+    org.opencontainers.image.documentation="https://vcell.org/support" \
+    org.opencontainers.image.source="https://github.com/biosimulators/Biosimulators_VCell" \
+    org.opencontainers.image.authors="BioSimulators Team <info@biosimulators.org>" \
+    org.opencontainers.image.vendor="BioSimulators Team" \
+    org.opencontainers.image.licenses="MIT" \
+    \
+    base_image="ubuntu:22.04" \
+    version="${SIMULATOR_VERSION}" \
+    software="Virtual Cell" \
+    software.version="${SIMULATOR_VERSION}" \
+    about.summary="Open-source software package for modeling cell biological systems that is built on a central database and disseminated as a standalone application." \
+    about.home="http://vcell.org/" \
+    about.documentation="https://vcell.org/support" \
+    about.license_file="https://github.com/virtualcell/vcell/blob/master/license.txt" \
+    about.license="SPDX:MIT" \
+    about.tags="rule-based modeling,kinetic modeling,dynamical simulation,systems biology,BNGL,SED-ML,COMBINE,OMEX" \
+    maintainer="BioSimulators Team <info@biosimulators.org>"
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt -y update && apt install -y software-properties-common
+RUN apt install -y --no-install-recommends curl python3.10 python3-pip build-essential dnsutils \
+    apt-utils libfreetype6 fontconfig fonts-dejavu
+
+RUN mkdir -p /usr/local/app/vcell/lib && \
+    mkdir -p /usr/local/app/vcell/simulation && \
+    mkdir -p /usr/local/app/vcell/installDir && \
+    mkdir -p /usr/local/app/vcell/installDir/python/vcell_cli_utils && \
+    mkdir -p /usr/local/app/vcell/installDir/bionetgen
+
+RUN python3 -m pip install poetry &&  poetry config cache-dir "/poetry/.cache"
+ENV PATH="/root/.poetry/bin:/root/.local/bin:$PATH"
+
+# Copy JAR files
+COPY ./vcell-cli/target/vcell-cli-0.0.1-SNAPSHOT.jar \
+     ./vcell-cli/target/maven-jars/*.jar \
+     /usr/local/app/vcell/lib/
+
+# Install required python-packages
+COPY ./vcell-cli-utils/ /usr/local/app/vcell/installDir/python/vcell_cli_utils/
+RUN cd /usr/local/app/vcell/installDir/python/vcell_cli_utils/ && \
+    poetry config cache-dir "/poetry/.cache" --local && \
+    chmod 755 poetry.toml && \
+    poetry install
+
+# Add linux local solvers only
+ADD ./localsolvers /usr/local/app/vcell/installDir/localsolvers
+ADD ./nativelibs /usr/local/app/vcell/installDir/nativelibs
+COPY ./docker_run.sh /usr/local/app/vcell/installDir/
+COPY ./bionetgen/BNG2.pl ./bionetgen/*.txt ./bionetgen/VERSION /usr/local/app/vcell/installDir/bionetgen/
+COPY ./bionetgen/Perl2 /usr/local/app/vcell/installDir/bionetgen/Perl2
+COPY ./biosimulations_log4j2.xml /usr/local/app/vcell/installDir/
+
+# Declare supported environment variables
+ENV ALGORITHM_SUBSTITUTION_POLICY=SIMILAR_VARIABLES
+EXPOSE 1433
+
+
+# Entrypoint
+ENTRYPOINT ["/usr/local/app/vcell/installDir/docker_run.sh"]
+CMD []

data/README_BioSim.md

@@ -0,0 +1,115 @@
+![Build the Docker Image](https://github.com/biosimulators/Biosimulators_vcell/workflows/Build%20the%20Docker%20Image/badge.svg)  
+[![GitHub issues](https://img.shields.io/github/issues/biosimulators/Biosimulators_vcell?logo=GitHub)](https://github.com/biosimulators/Biosimulators_vcell/issues)
+
+---
+# Biosimulators_vcell
+BioSimulators-compliant command-line interface to the [VCell](http://vcell.org/) simulation program.
+
+## Contents
+* [Installation](#installation)
+    * [Project setup IntelliJ IDEA](#to-setup-the-project-in-intellij-idea)
+    * [Project setup Eclipse](#to-setup-the-project-in-eclipse)
+    * [Maven installation](#maven-installation-package)
+* [Usage](#local-usage)
+* [License](#license)
+* [Development team](#development-team)
+* [Questions and comments](#questions-and-comments)
+
+## Installation
+
+### To set up the project in IntelliJ IDEA
+* Requirements: Git, Maven, Python 3.10, Poetry, Jetbrains IntelliJ IDEA and Java JDK 17
+1. Clone the repo
+2. Open the project as new project in IntelliJ
+3. Go to `Files` > `Project Structure...` > `Modules` and select all modules and then click apply.
+4. follow instructions in [README.md](./README.md) to build python dependencies
+5. Run `mvn clean install dependency:copy-dependencies` to build the project
+6. For creating Run/Debug Configurations:
+	* Go to `Run/Debug Configurations` > `+` > select `Application`
+	* Name it `VCell-CLI`
+	* Now setup the configuration
+		* Add `org.vcell.cli.CLIStandalone` for `Main class:`
+		* For `VM options:` 
+			```
+			-Dvcell.installDir=<Your-Project-Directory-Path>
+			-Dvcell.softwareVersion="frm_VCell_7.2"
+			```
+		* eg for `<Your-Project-Directory-Path>`: `/Users/akhil/projects/Biosimulators_vcell`
+		* Add `-h` for `Program arguments:` (refer [Local Usage](#local-usage) for more options)
+		* `Working Directory:` is `<Your-Project-Directory-Path>`
+		* Select `vcell-cli` as `Use classpath of module:`
+8. Click `apply` and `build`
+
+### To setup the project in Eclipse
+  * Requirements: Git, Maven, Python 3.10, Poetry, Eclipse IDE and Java JDK 17
+  1. Open terminal, navigate to the Eclipse workspace folder.
+  2. Clone the repo
+  3. follow instructions in [README.md](./README.md) to build python dependencies
+  4. Run `mvn clean install dependency:copy-dependencies` to build the project
+  4. Open Eclipse, Import the project using Maven. Depending on the Eclipse version there'll be small differences with the importing steps.
+  5. Create a `Debug configuration` as a `Java Application`.
+     * the Main Class is `org.vcell.cli.CLIStandalone`
+     * Leave the 'Program Arguments' blank.
+     * The VM needed arguments are:
+         ```
+        -Dvcell.installDir=<Your-Project-Directory-Path>
+        -Dvcell.softwareVersion="VCell_7.3.0.0"
+        ```
+
+### Program arguments for both Eclipse and IntelliJ
+
+1. For running a simulation from OMEX and VCML files as an input:
+    `-i "/PATH/TO/OMEX/OR/VCML" -o "/PATH/TO/SAVE"`
+2. For converting a VCML to OMEX file:
+    `convert -i "/PATH/TO/VCML" -o "/PATH/TO/SAVE/OMEX"`
+ 
+           
+### Maven installation package
+
+` `
+
+
+
+### Install Docker image
+```
+docker pull ghcr.io/biosimulators/vcell
+```
+
+## Local usage
+```
+usage: vcell [-h] [-d] [-q] -i ARCHIVE [-o OUT_DIR] [-v]
+
+BioSimulators-compliant command-line interface to the VCELL simulation program <http://vcell.org>.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -d, --debug           full application debug mode
+  -q, --quiet           suppress all console output
+  -i ARCHIVE, --archive ARCHIVE
+                        Path to OMEX file which contains one or more SED-ML-
+                        encoded simulation experiments or VCML file
+  -o OUT_DIR, --out-dir OUT_DIR
+                        Directory to save outputs
+  -v, --version         show program's version number and exit
+```
+
+## Usage through Docker container
+```
+docker run \
+  --tty \
+  --rm \
+  --mount type=bind,source="$(pwd)"/tests/fixtures,target=/root/in,readonly \
+  --mount type=bind,source="$(pwd)"/tests/results,target=/root/out \
+  ghcr.io/biosimulators/vcell:latest \
+    -i /root/in/BIOMD0000000297.omex \
+    -o /root/out
+```
+
+## License
+This package is released under the [MIT license](LICENSE).
+
+## Development team
+This package was developed by the BioSimulators Team of the [Center for Reproducible Biomedical Modeling](https://reproduciblebiomodels.org).
+
+## Questions and comments
+Please contact the [BioSimulators Team](mailto:info@biosimulators.org) with any questions or comments.

data/auto.docker

@@ -0,0 +1,2 @@
+/opt/vcelldata -fstype=nfs,tcp,hard,intr,noatime,nfsvers=3 cfs05:/vcellroot
+

data/auto.vcellapps

@@ -0,0 +1,9 @@
+# +auto.vcellapps
+vcell5parallel  -fstype=nfs,tcp,noac,nosharecache,hard,intr,noatime,nfsvers=3 cfs09:/vcell5
+vcell3parallel  -fstype=nfs,tcp,hard,intr,noatime,noac,nfsvers=3 cfs09:/vcellparallel
+vcell2  -fstype=nfs,tcp,hard,intr,noatime,nfsvers=3 cfs02:/ifs/RAID/vcell
+vcell3  -fstype=nfs,tcp,hard,intr,noatime,nfsvers=3 cfs09:/vcell
+vcell7  -fstype=nfs,tcp,hard,intr,noatime,nfsvers=3 cfs07:/ifs/vcell
+vcell5  -fstype=nfs,tcp,hard,intr,noatime,nosharecache,nfsvers=3 cfs09:/vcell5
+vcell10  -fstype=nfs,tcp,hard,intr,noatime,nosharecache,nfsvers=3 cfs10:/vcell
+vcell12  -fstype=nfs,tcp,hard,intr,noatime,nosharecache,nfsvers=3 cfs12:/vcell

data/bionetgen/BNG2.pl

@@ -0,0 +1,251 @@
+#!/usr/bin/perl
+
+#    BioNetGen : rule-based modeling language and simulation platform
+#
+#                  Copyright (C) 2006,2009,2012 by
+#
+#      James R. Faeder    (faeder at pitt dot edu)
+#      Justin S. Hogg     (justinshogg at gmail dot com)
+#      Leonard A. Harris  (lh64 at cornell dot com)
+#      John A. P. Sekar   (johnarul dot sekar at gmail dot com)
+#      Jose Juan Tapia
+#      Arshi Arora
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use Config;
+use File::Spec;
+use FindBin;
+use Getopt::Long;
+use IO::Handle;
+
+# get Perl2 Module directory: look for environment variables BNGPATH or BioNetGenRoot.
+# If neither are defined, use RealBin module
+use lib File::Spec->catdir( ( exists $ENV{'BNGPATH'}
+                              ? $ENV{'BNGPATH'}
+                              : ( exists $ENV{'BioNetGenRoot'} 
+                                  ? $ENV{'BioNetGenRoot'}
+                                  : $FindBin::RealBin
+                                )
+                            ),
+                            'Perl2'
+                          );
+# BNG Modules
+use BNGUtils;
+use BNGModel;
+use Console;
+
+
+# Set up Signal Handlers..
+# Define global variable to store PID of child process.
+$::CHILD_PID = undef;
+# Get signal names
+my $i = 0;
+my %SIGNO=();
+defined($Config{sig_name}) or die "No signals defined";
+foreach my $signame ( split " ", $Config{sig_name} )
+{
+    $SIGNO{$signame} = $i;
+    $i++;
+}
+# TERM signal handler: make sure any child processes are shutdown before termination
+$SIG{'TERM'} = sub
+{
+    if (defined $::CHILD_PID)
+    {   # kill off child process
+        print "\n>>> relaying TERM signal to child with PID: ", $::CHILD_PID, " <<<\n";
+        kill $SIGNO{"TERM"}, $::CHILD_PID;
+    }
+    exit_error( sprintf "BioNetGen received TERM signal (%d)", $SIGNO{"TERM"} );
+};
+# INT signal handler: make sure any child processes are shutdown before termination
+$SIG{'INT'} = sub
+{
+    if (defined $::CHILD_PID)
+    {   # kill off child process
+        print "\n>>> relaying INT signal to child with PID: ", $::CHILD_PID, " <<<\n";
+        kill $SIGNO{"INT"}, $::CHILD_PID;
+    }
+    exit_error( sprintf "BioNetGen received TERM signal (%d)", $SIGNO{"INT"} );
+};
+
+
+
+# Defaults params for File mode
+my %default_args         = ( 'write_xml'     => 0,  'write_mfile'      => 0,
+                             'write_SBML'    => 0,  'generate_network' => 0,
+                             'skip_actions'  => 0,  'action_skip_warn' => 1,
+                             'logging'       => 0,  'no_exec'          => 0,
+                             'allow_perl'    => 0,  'no_nfsim'         => 0,
+                             'output_dir'    => File::Spec->curdir(),
+                             'no_atomizer'   => 0,
+							 'write_autos'   => 0
+                           );
+# Default params for Console mode
+my %default_args_console = ( 'write_xml'     => 0,  'write_mfile'      => 0,
+                             'write_SBML'    => 0,  'generate_network' => 0,
+                             'skip_actions'  => 1,  'action_skip_warn' => 1,
+                             'logging'       => 0,  'no_exec'          => 0,
+                             'allow_perl'    => 0,  'no_nfsim'         => 0,
+                             'output_dir'    => File::Spec->curdir(),
+                             'no_atomizer'   => 0,
+							 'write_autos'   => 0
+                           );
+
+
+# variables to contain user args
+my $console = 0;
+my $findbin = '';
+my $help    = 0;
+my $version = 0;
+my %user_args = ( 'console' => \$console,
+                  'findbin' => \$findbin,
+                  'help'    => \$help,
+                  'version' => \$version
+                );
+
+# parse command line arguments
+GetOptions( \%user_args, 
+            'help|h',
+            'version|v',
+            'console',
+            'findbin=s',
+            'skip_actions|check',
+            'no_nfsim|no-nfsim',
+            'no_atomizer|no-atomizer',
+            'output_dir|outdir=s',
+            'logging|log',
+            'generate_network|netgen',
+            'write_SBML|sbml',
+            'write_mfile|mfile',
+            'write_xml|xml',
+			'write_autos|autos'
+          )
+or die "Error in command line arguments (try: BNG2.pl --help)";
+
+# display help if requested
+if ($help)
+{
+    display_help();
+    exit(0);
+}
+
+# display version info
+if ($version)
+{
+    printf "BioNetGen version %s\n", BNGversion();
+    exit(0);
+}
+
+# try to find binary
+if (not( $findbin eq ''))
+{
+    # exit with value 0 if binary is found, 1 otherwise
+    exit( BNGModel::findExec($findbin) ? 0 : 1 );
+}
+
+
+
+if ( $console )
+{
+    # get arguments
+    my %args = ();
+    while ( my ($opt,$val) = each %default_args_console )
+    {
+        $args{$opt} = exists $user_args{$opt} ? $user_args{$opt} : $val;
+    }
+
+    # check if output directory exists and is writable
+    unless ( -d $args{output_dir} )
+    {  send_warning( sprintf "Default output directory '%s' is not a directory.", $args{output_dir});  }
+    unless ( -w $args{output_dir} )
+    {  send_warning( sprintf "Not able to write to default output directory '%s'.", $args{output_dir});  }
+
+    # start console
+    my $err = BNGconsole( \%args );
+    exit_error($err) if ($err);
+}
+else
+{
+    unless (@ARGV)
+    {  display_help();  }
+
+    # get arguments
+    my %args = ();
+    while ( my ($opt,$val) = each %default_args )
+    {
+        $args{$opt} = exists $user_args{$opt} ? $user_args{$opt} : $val;
+    }
+
+    # check if output directory exists and is writable
+    unless ( -d $args{output_dir} )
+    {  send_warning( sprintf "Default output directory '%s' is not a directory.", $args{output_dir});  }
+    unless ( -w $args{output_dir} )
+    {  send_warning( sprintf "Not able to write to default output directory '%s'.", $args{output_dir});  }
+
+    # Process any files
+    while ( my $file = shift @ARGV )
+    {
+        # create BNGMOdel object
+        my $model = BNGModel->new();
+        $model->initialize();
+        $BNGModel::GLOBAL_MODEL = $model;
+
+        # set file argument
+        $args{'file'} = $file;
+
+        # read and process Model file
+        my $err = $model->readFile( \%args );
+        exit_error($err) if ($err);
+
+        # undefine model
+        %$model = ();  undef %$model;
+        $BNGModel::GLOBAL_MODEL = undef;
+    }
+}
+
+# all done!
+exit(0);
+
+
+
+
+# Display Help Menu
+sub display_help
+{
+    printf "\nBioNetGen version %s\n", BNGversion();
+    print  "--------------------------------------------------/ HELP MENU /-----\n"
+          ."  SYNOPSIS                                                          \n"
+          ."    process MODEL:      BNG2.pl [OPTION]... MODEL...                \n"
+          ."    start BNG console:  BNG2.pl --console                           \n"
+          ."    display help:       BNG2.pl -h                                  \n" 
+          ."    display version:    BNG2.pl -v                                  \n"           
+          ."                                                                    \n"
+          ."  OPTIONS                                                           \n"
+          ."    --log          write log to file MODEL.log (default is STDOUT)  \n"
+          ."    --xml          write XML output after processing MODEL          \n"
+          ."    --mfile        write MATLAB M-file output after processing MODEL\n"
+          ."    --sbml         write SBML output after processing MODEL         \n"
+          ."    --check        read MODEL, but do not execute actions           \n"
+          ."    --outdir PATH  change default output path                       \n"
+          ."                                                                    \n"
+          ."  For more information, visit bionetgen.org                         \n"
+          ."--------------------------------------------------------------------\n";
+}
+

data/bionetgen/CHANGES.txt

@@ -0,0 +1,467 @@
+CHANGES to BioNetGen
+updated 25 May 2016
+https://github.com/RuleWorld/bionetgen/
+
+=======
+== BioNetGen-2.3.0 (testing release) ==
+'''''date tbd'''''
+
+==== New Features ====
+* Show graph automorphisms and statistical factor calculations for rules and reactions: BNG2.pl model.bngl --write_autos (or) BNG2.pl model.bngl --autos
+
+==== SBML-to-BNGL Translator ====
+* Atomizer will now query BioGrid and PathWay commons when determining the active or binding site in a complex. Include the 'pathwaycommons' flag during model import to active this option
+* Several bugfixes to the lexical analysis engine
+* The SBML-to-BNGL translator was moved to its own repository@https://github.com/RuleWorld/atomizer. The Atomizer source code can also be found in the XXX directory within the BioNetGen distribution
+
+==== Bug Fixes ====
+* Fixed a bug where <big><tt>resetParameters</tt></big> was not restoring parameters to their original values after calls to <big><tt>setParameter</tt></big>.
+* Fixed a bug where a regex meant to remove the equality operator '=' in functions was inadvertently also removing the assignment operator '=='.
+* Fixed a bug causing an error when reading a .net file with 'readFile' when multiple reactions with functional rate laws have identical stoichiometries.
+* <big><tt>simulate_nf</tt></big> now throws an error if <big><tt>continue=>1</tt></big> is defined (previously threw a warning).
+
+==== Visualization ====
+* New styles for visualization.
+* Updates to visualization algorithms.
+* Supported types: conventional, compact, regulatory, opts, contactmap, reaction_network.
+* Supported regulatory graph options: background, opts, groups, collapse, ruleNames, doNotUseContextWhenGrouping, doNotCollapseEdges.
+
+==== Minor changes ===
+* BioNetGen will now automatically run the generate_network command if one of simulate_pla/simulate_ode/simulate_ssa methods are called and a network wasn't loaded into the system otherwise
+* Dangling bonds graph specifications of the kind A(b!1) are no longer allowed.
+* Added support for the <big><tt>atomize</tt></big> and <big><tt>blocks</tt></big> arguments of the <big><tt>readFile</tt></big> action to the BNGConsole <big><tt>load</tt></big> command, e.g., <big><tt>load path_to_model/sbml_model.xml --atomize 1</tt></big>
+
+== BioNetGen-2.2.6-stable ==
+'''''2015 June 22'''''
+
+==== New Language Conventions ====
+* Whitespace is no longer allowed in rule names.
+* All labels and BNG objects (except for bonds and states) must begin with a letter or underscore character.
+* Labels must now be followed by a colon (':') with no intervening whitespace.
+** Example: <big><tt>RuleX: A(s~0) -> A(s~1) k</tt></big>
+* Leading indices in the <big><tt>molecule types</tt></big>, <big><tt>observables</tt></big>, and <big><tt>energy patterns</tt></big> blocks have been deprecated.
+** '''Note''': These are not yet formally deprecated for the <big><tt>parameters</tt></big>, <big><tt>species</tt></big>, and <big><tt>functions</tt></big> blocks because they exist within BNG-generated NET files, which can be read in using <big><tt>readFile</tt></big>. Deprecating them completely will thus require changing the format of NET files.
+* Unnamed rules are now given automatic names beginning with "<big><tt>_R</tt></big>" followed by a digit (e.g., "<big><tt>_R1</tt></big>", "<big><tt>_R2</tt></big>", etc.).
+* Reverse rules are now named by prepending "<big><tt>_reverse_</tt></big>" to the forward rule name.
+
+===== Actions & Arguments =====
+* Added a new argument, <big><tt>par_scan_vals</tt></big>, to the <big><tt>parameter_scan</tt></big> action to allow parameter scans over unevenly spaced intervals.
+** Example: <big><tt>parameter_scan({method=>"ode", t_end=>20, parameter=>"k1", par_scan_vals=>[1,5,20]})</tt></big>
+** NOTE: If <big><tt>par_min</tt></big>, <big><tt>par_max</tt></big>, and <big><tt>n_scan_pts</tt></big> 
+are all defined, they will take precedence over <big><tt>par_scan_vals</tt></big> if it is defined.
+
+==== Minor Changes ====
+* Both the BioNetGen version and codename (e.g., "<big><tt>2.2.6-stable</tt></big>") are now included in the headers of files written with <big><tt>writeBNGL</tt></big> (e.g., NET files).
+* validate_examples.pl now ignores trailing comments in file comparisons.
+* Windows executables now contain the bitness of the architecture in their names 
+(e.g., <big><tt>run_network_MSWin32-64bit.exe</tt></big>).
+* The run_network and sbmlTranslator executables no longer contain the architecture they are built for within the file name definition.
+
+==== Bug Fixes ====
+* An error is now thrown if an unrecognized block name is encountered.
+* An error is now thrown if duplicate rule names are detected.
+* Fixes a case where synthesis rules in cBNGL would fail if the product used the compartment prefix notation.
+
+== BioNetGen-2.2.6-testing ==
+'''''2015 March 3'''''
+
+==== New Features ====
+
+===== SBML-to-BNGL Translator =====
+* The SBML-to-BNGL translator can perform both a flat (one-to-one) translation 
+of an SBML model in terms of unstructured species and an "atomized" translation 
+that recovers the implicit molecular structure (binding sites and states) of the 
+species within the model. The translator can be accessed in the following three ways:
+# Using the readFile() BioNetGen action: The 'atomize' argument specifies whether a 
+flat or atomized translation is to be performed (default is flat, i.e., 
+atomize). The translated model is written to [sbml_filename].bngl, 
+which is then read and loaded into memory. This allows additional actions [e.g., simulate(), 
+parameter_scan()] to be performed on the model if desired.  See the 
+[[BioNetGen_Actions_and_Arguments | BioNetGen Actions & Arguments Guide]] for a comprehensive 
+listing of all actions and arguments, including readFile().
+# Running the [BNGPATH]/bin/sbmlTranslator executable directly: 
+This provides the functionality described above along with additional customization flags. 
+Run ./sbmlTranslator --help> for a complete list of options with descriptions.
+# As a standalone web application at [http://ratomizer.appspot.com/translate http://ratomizer.appspot.com/translate].
+
+For further information, see the SBML-to-BNGL documentation.
+
+===== Visualization Tools =====
+* Visualization tools can be accessed by calling the visualize() action in a BNGL model file 
+or running the visualize.pl script included in 
+[BNGPATH]/Perl2/Visualization. The output is generated in Graph Modeling 
+Language (GML) format, which can be processed by graph editors such as yEd 
+([http://www.yworks.com/yed www.yworks.com/yed]) and Cytoscape 
+([http://www.cytoscape.org www.cytoscape.org]). Currently supported visualizations are:
+** Model visualization as a contact map: >visualize({type=>"contactmap"})
+** Model visualization as a regulatory graph: visualize({type=>"regulatory"})
+** Rule visualization as a Petri net: visualize({type=>"ruleviz_pattern"})
+** Rule visualization using graph operations: visualize({type=>"ruleviz_operation"})
+
+For further information, call visualize({help=>1}) or run ./visualize.pl --help.
+
+===== Actions & Arguments =====
+* Added a 'reset_conc' argument to parameter_scan() that suppresses the call to resetConcentrations() 
+if set to 0 (default value is 1). This allows simulations in the scan to be started from the end point 
+of the previous simulation (used in bifurcate(); see below).
+* Added a new bifurcate() action that takes the same arguments as parameter_scan() (except 'reset_conc'). 
+The method automatically runs two scans, one from 'par_min' to 'par_max' and the other in the reverse 
+direction. Each simulation in the scans starts from the end point of the previous simulation by passing 
+<big><tt>reset_conc=>0</tt></big> to parameter_scan(). Output files are then generated for each observable 
+containing the parameter values vs. final observable values for both forward and reverse directions.
+* Modified readFile() to allow specific model blocks to be read using the 'blocks' argument.
+** Example: <big><tt>readFile({file=>"mymodel.bngl",blocks=>["parameters","seed species"]})</tt></big>
+* Added support for <big><tt>method=>"nf"</tt></big> in simulate(). This allows NFsim to be used in 
+parameter_scan() and bifurcate() as well.
+* Added support for compartments in writeSBML() and upgraded the supported version of SBML to Level 2 Version 3.
+
+==== Minor Changes ====
+* Upgraded muParser ([http://muparser.beltoforion.de http://muparser.beltoforion.de]) to version 2.2.4.
+* Modified parameter_scan() to set <big><tt>get_final_state=>0</tt></big> if <big><tt>reset_conc=>1</tt></big> 
+(the default). This prevents BNG from unnecessarily reading in the final species populations at the end of 
+NFsim simulations if they are going to be reset anyway. This is important as the read step can be extremely 
+expensive for models with high degrees of symmetry.
+* Modified setConcentration() to retain parameter names in expressions (rather than evaluating to a number). 
+This allows setConcentration() to be used with parameter_scan(). However, observables and functions are 
+still evaluated to numbers.
+* Modified NET file output to list all rules that generate a given reaction in the comment following each 
+line of the <big><tt>reactions</tt></big> block. This is useful when a reaction is generated by multiple 
+different rules. Often this is unintentional and can be problematic since BNG multiplies the rate constant 
+by the number of duplicates generated. Listing all rules that generate a reaction can help identify and 
+debug situations like this.
+* Added a default PLA configuration for <big><tt>simulate(method=>"pla")</tt></big>. If the 'pla_config' 
+argument is not defined, the configuration is set to <big><tt>fEuler|pre-neg:sb|eps=0.03</tt></big>, i.e., 
+a standard tau-leaping method (1st order) with species-based preleap tau calculations, negative-population 
+postleap checking, and error control parameter 'eps' of 0.03.
+* Modified <big><tt>validate_examples.pl</tt></big> to only report a stochastic validation failure if the 
+validation fails twice in a row.
+* Added functionality to readFile() to convert forward slashes (/) to back slashes (\), and vice versa, 
+in '''''relative''''' paths, depending on the OS. This improves cross-platform portability and makes it 
+easier to share models.
+
+==== Bug Fixes ====
+* An error is now thrown if zero-order synthesis products do not have compartments.
+* BNG will no longer switch to "compartmental" mode if the <big><tt>compartments</tt></big> block is empty.
+* Expressions for compartment volumes are now correctly evaluated when generating a BNG-XML file.
+* Fixed an inconsistency where forward referencing of parameters/observables was allowed for functions 
+defined in the <big><tt>functions</tt></big> block but not in the <big><tt>reaction rules</tt></big> block. 
+* Fixed a bug where in rare cases a function defined in the <big><tt>reaction rules</tt></big> block would 
+be typed as a 'ConstantExpression'. This would cause simulation to fail since it would be placed in the 
+<big><tt>parameters</tt></big> block of the generated NET file.
+* Fixed a bug in the handling of 'max_stoich' constraints. In versions 2.2.3, 2.2.4, and 2.2.5, the 
+constraints were sometimes ignored during network generation and complexes larger than the maximum 
+specified could be constructed. Also added code to check that molecule names passed in the argument are 
+valid. This is useful since users often specify patterns, such as 'A()', rather than the actual molecule 
+name 'A'. Without an error message this can cause confusion.
+* Fixed a bug where BNG was not passing to NFsim the random seed that it was generating when the 'seed' 
+argument was not explicitly set by the user. This made it difficult to debug problems in NFsim since it 
+was not outputting a random seed in the error messages.
+
+== BioNetGen-2.2.5-stable ==
+'''''2013 July 30'''''
+
+==== New Features ====
+
+===== BioNetGen-to-MCell Converter =====
+The converter creates spatial MCell models from BioNetGen. It is called 
+by adding "<big><tt>writeMDL()</tt></big>" to the actions of a BioNetGen 
+model file. It also requires a geometry input file externally created using 
+CellBlender, an addon to the Blender software for creating MCell geometries. 
+Execution of a BioNetGen model integrates the reaction network and geometry 
+information and creates a MCell model file (.mdl). Alternatively,
+"writeMDL()" enables direct execution and import of BioNetGen models from 
+CellBlender. The imported BioNetGen model can be integrated with geometries 
+created in CellBlender and exported from CellBlender as MCell model files. 
+
+===== AutoHPP =====
+AutoHPP automates the construction and simulation of Hybrid Particle/Population
+systems. AutoHPP profiles species populations during a test simulation,
+identifies species with average population graater than a threshold, and then
+constructs and simulates an HPP system where the identified species are treated
+as lumped populations. Auto HPP is implemented in the "auto_hpp.pl" script
+found in the "Perl2" subfolder (requires NFsim).
+
+==== Minor changes ====
+* If "BNG2.pl" is called without a model argument, the help menu is printed to
+STDOUT. (In prior releases, BNG2.pl exited silently.)
+* When parsing a global function ratelaw, BNG will not create a reference to
+the function in the parameter table unless the function call is part of an
+inline math expression. (Note that use of inline expressions within ratelaws is 
+advised against, since this is not supported by NFsim.)
+* Modified the behavior of the '<big><tt>prefix</tt></big>' argument. Previously,
+the argument was assumed to be an absolute path. Now, it is checked using 
+<big><tt>File::Spec->file_name_is_absolute()</tt></big> to determine whether or
+not it is an absolute path. If it is not an absolute path, then the output 
+directory remains the current working directory and only the model name is 
+modified.
+
+==== Bug Fixes ====
+* Fixed bug in Network3 code that caused an error if an "if()" function was used 
+in the <big><tt>parameters</tt></big> block. This situation arises when a local 
+function is defined that includes an "if()" function. Thus, logical local functions 
+are now supported for network simulations.
+* Fixed bug that caused simulations of HPP models containing global functions
+to fail after loading from file. The problem was fixed by tracking global
+functions directly rather than creating a reference in the parameter table.
+* Fixed "--check" command line option (i.e., parse model, but do not execute
+actions). 
+
+== BioNetGen-2.2.4-stable ==
+'''''2013 May 16'''''
+
+==== Errata ====
+'''''2013 July 30''''' A bug was discovered in the handling of max_stoich
+constraints. In some cases, the constraints will be ignored during network
+generation, and complexes larger than the maximum specified may be constructed.
+(Fixed in 2.2.6)
+
+'''''2013 July 24''''' The "--check" command line switch is broken in this
+version. BNG will parse the model and execute actions regardless of the switch.
+
+'''''2013 July 22''''' HPP models with global functions fail to simulate in
+NFsim after loading from file. The problem can be circumvented by simulating
+the HPP model immediately after construction by passing the "execute=>1"
+argument to "generate_hybrid_model()".
+
+==== New Features ====
+
+===== Modular model source files =====
+BNG now supports multiple and recursive calls of the readFile() action. This
+allows modular assembly of BNGL models from multiple source files. For example,
+the model definitions can be stored in one file and parameter values in
+a second file.
+
+==== Changes to BNG action commands ====
+* Complex bookkeeping option, "complex", is now enabled by default in the
+simulate_nf() action, i.e. "complex=>1".
+* Default value for option 'get_final_state' for simulate_nf() action has been
+changed to TRUE. Consequently, the final state of a NF simulation will be
+loaded into the BNG by default. However, to avoid the ''slow'' process of
+canonically labeling massive complexes, any species composed of more than
+20 molecules will be labeled using a quasi-canonical method. If this is still
+too slow, set the option to FALSE (0).
+
+==== New Example and Validation Models ====
+* Added catalysis.bngl to Models2 directory. This model demonstrates
+the implementation of energy consuming reactions in energy BNGL.
+
+==== Bug Fixes ====
+* Fixed minor bug that caused unnecessary retention of temporary labels in HPP
+rules. This bug did not cause errors per se, but did result in a lot of
+unnecessary warning messages.
+* Fixed minor bug in HNauty labeling method that led to failure for species
+graphs with bond wildcards. Note that this bug only affected pattern labels
+(used in HPP) and not proper species.
+
+==== Code refactoring ====
+* Command line argument parsing in BNG2.pl is now handled by the core
+module GetOpts::Long. This change should result in more robust parsing and
+reduced maintaince in the future.
+
+== BioNetGen-2.2.4-testing ==
+'''''2013 March 31'''''
+
+==== Errata ====
+'''''2013 July 30''''' A bug was discovered in the handling of max_stoich
+constraints. In some cases, the constraints will be ignored during network
+generation, and complexes larger than the maximum specified may be constructed.
+(Fixed in 2.2.6)
+
+'''''2013 April 10''''' The original release notes for 2.2.4-testing stated that
+the simulate_nf() action enabled complex bookkeeping by default. However, the
+implementation of this change was flawed! 2.2.4-testing still defaults to
+complex bookkeeping disabled. To enable complex bookkeeping, add the option
+"complex=>1". This will be corrected in the next release.
+
+'''''2013 April 10''''' The original release notes for 2.2.4-testing stated that
+the time() function is available for use in any math expression. This is
+incorrect. The time() function is only available in math expressions defined
+in the functions block of BNGL model.
+
+==== Hardware and Operating System Support ====
+
+===== Mac OS/X run_network executable is now compiled for x86_64 =====
+The run_network Mac executable distributed with BioNetGen was previously
+compiled for i686 architecture (32-bit). In this and future distributions,
+Mac OS/X executables will be compiled for x86_64 (64-bit). If a 32-bit
+executable is required, browse to the "Network3" subdirectory and follow the
+compilation instructions.
+
+==== New Features ====
+
+===== Empty species symbol "0" supported for compartmental BNGL =====
+We introduced the new symbol "0" in 2.2.3 for representing an empty
+pattern or species. This is useful anywhere BNG expects a pattern or
+species but the modeler wants the empty set. For example, "0" may be
+used on the LHS of a reaction rule for zero-order synthesis, or
+the RHS for degradation rules. This feature is now supported in
+compartmental BNGL
+
+'''''NOTE:''''' compartmental BNGL adopts the convention that zero order
+synthesis rate constants are given as intensive units (conc/time or
+counts/vol/time). Hence, the total rate of synthesis depends on the rate
+constant AND the volume of the compartment.
+
+===== Energy BNGL (testing) =====
+Energy modeling is a new approach to rule-based modeling where
+kinetics are derived from changes in free-energy and activation barriers.
+This approach was pioneered by J. Ollivier, et al. (PLoS Comp. Bio. 2010)
+and generalized by Vincent Danos. Energy modeling has a number of advantages,
+including: detailed balance is guaranteed, reaction rules are simplified,
+and allostery/cooperativity easily implemented. A simple example of energy
+modeling, 'energy_example1.bngl' was added to the Models2 directory. Keep an
+eye out for more documentation and examples of energy modeling in BNG.
+
+===== Time-dependent functions (testing) =====
+Implemented a special function "time()" that refers to the current time 
+in a simulation. The time function may be used
+in any mathematical expression. '''''CORRECTION:''''' ''The time() function is
+only recognized in math expressions defined in the functions block.'' This is
+useful for ratelaws or events that depend on time. Time is recognized by
+run_network but not (presently) by NFsim. 
+
+'''''CAUTION:''''' Discontinuities in ratelaws may cause problems for
+ODE integrators. If a timed event causes a discrete change
+in a ratelaw, it is best to stop and restart the simulator.
+
+'''''CAUTION:''''' Time-dependent rates in SSA simulations may introduce
+substantial error if the relative rate change is fast in time. Advanced
+methods exist for managing time-dependent rates accurately; however,
+these methods are not currently implemented in run_network.
+
+===== Molecule-scoped local functions =====
+Added support for local functions evaluated on the scope of a tagged
+molecule. This feature was already supported by NFsim, but is now
+available for network generation and network simulation. See the NFsim
+manual (chapter 7) for examples of molecule-scoped local functions.
+
+==== Improvements to Existing Features ====
+
+===== On-the-fly network generation is fixed =====
+Run_network supports on-the-fly network generation again. However, the
+implementation is not very efficient. NFsim is recommended for 
+applications with large networks.
+
+===== Added support for functional rate laws in SBML export =====
+Fixed SBML export for functional rate laws. Global functions are now
+output in the same way as parameter expressions. Local functions are NOT
+output to SBML because they are evaluated down to a number by BNG during
+network generation so they're unnecessary. Note that the "Group_" prefix
+has been removed from the SBML IDs of observables so that they can be
+easily referenced in function expressions. This is not a problem because
+parameters and observables occupy the same namespace so there is no
+possibility of conflicts.
+
+===== Better handling of mathematical expression in output =====
+BioNetGen now exports mathematical expressions by default, rather than
+evaluating to a number. This preserves the original math when models or
+networks are written to file. Support for mathematical expressions in the
+parameters block was added to run_network.
+
+===== Upgrades to MATLAB export via writeMfile() =====
+* Improved error capture when calling MATLAB's ODE23s integrator.
+* Support for "if" functions: "if(cond,val1,val2)" is translated
+to "(cond~=0)*val1 + (cond==0)*val2". This isn't a perfect solution since it
+requires that val1 and val2 both evaluate to finite numbers. Unfortunately,
+MATLAB does not support the ternary conditional (a better solution).
+* Eliminated redundancy of expression evaluation, resulting in better 
+run-time efficiency.
+
+==== Bug Notices ====
+* run_network fails to parse math expressions properly if a parameter name in
+the expression begins with a number. We recommend that parameter names begin
+with a letter character. Parameter names beginning with numbers will likely
+be deprecated in a future release.
+
+==== Bug Fixes ====
+* Fixed bug where parameters beginning with "and" or "or" were confused
+with the logical operations. The problem was traced to the muParser
+library. Upgrading to muParser v2.2.3 solved this problem.
+* Fixed bug where setConcentration (and potentially other actions) fail to
+parse arguments that contain species definitions with compartmental syntax.
+* Fixed bug in BNG math expression parser where unary operators were parsed
+incorrectly in some circumstances.
+* Fixed bug where run_network reported incorrect line number in error message.
+* Fixed potential bug in isomorphic detection method, where BNG attempts to
+access undefined nodes if graphs have unequal size. This is prevented by
+checking the size of the graphs prior to comparison.
+* Fixed bug that caused generate_network() action to return an error if no
+seed species are defined. This fix permits network generation for models with
+0-order synthesis but no seed species.
+* Fixed bug where scan_var.pl generated invalid scripts if the BNGL model file
+does not end with a new line.
+* Fixed bug where functions comprised of more than 512 characters could not 
+be read. There is now no limit to the number of characters.
+
+==== Minor Syntax Changes ====
+* Deprecated use of fixed quantity flag "$"  within reactant rules.
+The fixed quantity flag should only be used in the seed species block.
+* Use of "fake" species such as "NULL", "TRASH", or "SINK" as placeholders
+in reaction rules with zero reactants and products is now deprecated.
+We advise the use of the special symbol "0" instead.
+* Labels are now permitted before definitions in all BNGL blocks.
+
+==== Changes to BNG action commands ====
+* Added 'continue' option to generate_network() action. If this option
+is enabled, BNG will continue generating a network from the last
+completed iteration. If disabled, BNG will start reset the network
+and generate from scratch. The option is enabled by default, i.e.'continue=>1'.
+* Complex bookkeeping option, 'complex', is now enabled by default in the
+simulate_nf() action, i.e. 'complex=>1'. '''''CORRECTION:''''' ''The
+implementation of this change was flawed. The 2.2.4-testing release still
+defaults to complex bookkeeping disabled. To enable complex bookkeeping, add
+the option complex=>1''.
+* The 'exact' option for generate_hybrid_model() was renamed to 'safe'. This
+avoids confusion over whether the standard method is exact. Indeed, both
+methods are exact if population lumping is instantaneous. However, only
+the 'safe' method is exact for finite lumping rates. The default is
+'safe=>0'. The old 'exact' option will be supported up to (and including) the
+next stable release.
+
+==== Error and Warning Message Changes ====
+* Useless {MatchOnce} attribute in species definitions are now detected and
+reported.
+* Improved detection of illegal dangling bonds and wildcards in reaction rules.
+* Improved clarity of error messages for unrecognized BNG version strings
+and missing ratelaw arguments.
+* scan_var.pl utility reports an error is the BNGL model does not contain an
+"end model" directive.
+* run_network will now allow commented lines in the functions block of the
+NET file.
+* run_network no longer complains is there are no parameters in the model.
+
+==== New Example and Validation Models ====
+* Added gene_expr_func.bngl and localfunc.bngl to Models2 directory.
+NOTE: these models were previous distributed as validation models.
+* A simple example of energy modeling, 'energy_example1.bngl' was added to
+the Models2 directory.
+* Adding two new validation files: (1) isingspin_energy.bngl implements an
+ising spin model on a 3x3 toroidal lattice using the energy approach, (2)
+isingspin_localfcn.bngl implements the ising spin model (same topology) using
+local functions. Both models test the SSA equillibrium distribution. Model 2
+also tests the NF equillibrium distribution.  NOTE: the energy approach is
+not supported in NFsim, hence this version won't scale to a larger lattice.
+
+==== Code refactoring ====
+* Enabled strict and warning pragmas in BNGModel.pm
+* Migrated to muParser 2.2.3 (from v134) for parsing math expressions in
+run_network. Implemented a static "If()" function in network.h that gets
+called as "if()" in muParser [parser.DefineFun("if",If) in
+network::read_functions_array()]. This should solve the problem of if()
+being deprecated in the muparser_v2_2_3. Also modified run_network.cpp and
+network.cpp to no longer replace "&&" with "and" and "||" with "or".
+* Reformulated generate_network so that observables and energy patterns are
+updated as species are generated, rather than after an iteration of
+network generation completes.
+* The Expression type "FUN" was renamed as "FunctionCall". The original type
+name caused some confusion as to whether the expression was a function
+definition or a function call. To clarify, the type was renamed FunctionCall.
+The Function object holds the definition (RHS) for a function. For further
+reference: the Param type Function associates a name to a Function object.
+A function without an associated Param is anonymous (i.e. cannot be found in
+the ParamList).
+
+== BioNetGen-2.2.3-testing ==
+See "Release Notes" at http://bionetgen.org for changes to older versions of
+BioNetGen.
+

data/bionetgen/CREDITS.txt

@@ -0,0 +1,88 @@
+The following people have contributed to BioNetGen code development:
+
+Michael L. Blinov <blinov@uchc.edu>
+   * Original author.
+   * Testing and development of new ideas.
+   * Developed interface to Virtual Cell.
+
+James R. Faeder <faeder@lanl.gov>
+   * Primary BioNetGen developer since version 1.0.
+   * Testing and development of new ideas.
+   * Code maintainer.
+   * Current project co-PI.
+
+William S. Hlavacek <wish@lanl.gov>
+   * Driving force in the development.
+   * Testing and development of new ideas.
+   * Current project PI.
+
+Byron Goldstein <bxg@lanl.gov>
+   * Pioneered concept of signaling models based on multivalent interactions.
+   * Original project PI.
+
+Justin Hogg <justinshogg@gmail.com>
+   * Compartmental BNGL (cBNGL).
+   * General maintenance.
+
+Leonard Harris <lh64@cornell.edu>
+   * Network3 development: global functions, accelerated stochastics (PLA)
+
+Ilya Korsunsky
+   * Initial deployment of global functions for Network3.
+
+John Sekar <johnarul.sekar@gmail.com>
+   * Visualization - rule visualization, regulatory graphs.
+
+Jose Juan Tapia <jjtapia@pitt.edu>
+   * BioNetGen grammars development and implementation
+   * SBML2BNGL developer
+
+Adam Smith
+   * RuleBender developer
+      
+Michael Sneddon <michael.sneddon@yale.edu>
+   * Author and maintainer of NFsim.
+   * Contributor to BNGXML and maintainer of BNG-NFsim interface.      
+
+Thierry Emonet <thierry.emonet@yale.edu>
+   * NFsim PI 
+   
+Jeremy Kozdon
+   * Code for use of sparse Jacobian in CVODE calls, which greatly accelerates
+ODE integration for large networks (sparse=>1 option).
+
+Nathan Lemons
+   * HNauty code for canonical labeling of hierarchical graphs, which is (optionally) used
+in network generation,.
+
+Matthew Fricke <matthew@gofigure.org>
+   * Primary author of RuleBuilder.
+
+Leigh Fanning <leigh@verseira.net>
+   * Contributor to RuleBuilder development.
+   * Developed RuleBuilder help system.
+
+Robert Seletsky <robert1unm@yahoo.com>
+   * Testing of BioNetGen and RuleBuilder.
+
+Sarah Faeder <smgfaeder@gmail.com>
+   * Contributor of PhiBPlot.
+   * Testing and bug fixes for RuleBuilder.
+
+Nikolay Borisov <nikolay.borisov@jefferson.edu>
+   * Primary developer of Macro module.
+   * Testing of BioNetGen.
+
+Mikhail Kravchenko <krmisha@rambler.ru>
+   * Implementation of macro code.
+   * Streamlining of BioNetGen interface.
+
+Alexander S. Chistopolsky <eroxi@savelovo.net>
+   * Developer of macro algorithm
+
+Marc Birtwistle <mrbirdy@udel.edu>
+   * Contributor of parameter sensitivity code.
+
+Dipak Barua 
+   * BNGL to MDL converter.
+

data/bionetgen/LICENSE.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

data/bionetgen/Perl2/Aux2/MakeBin.pl

@@ -0,0 +1,66 @@
+#!/usr/bin/perl
+
+$bindir="../PerlBin";
+
+@scripts= qw(
+BNG2.pl
+);
+
+@modules= qw(
+BNGModel.pm
+BNGUtils.pm
+Component.pm
+ComponentType.pm
+Map.pm
+Molecule.pm
+MoleculeType.pm
+MoleculeTypesList.pm
+Observable.pm
+Param.pm
+ParamList.pm
+RateLaw.pm
+Rxn.pm
+RxnList.pm
+RxnRule.pm
+Species.pm
+SpeciesGraph.pm
+SpeciesList.pm
+);
+ 
+#print join(" ", @modules),"\n";
+print "Compiling modules.\n";
+$n_compiled=0;
+for my $module (@modules){
+  $modfile= "${bindir}/$module";
+  if (!-e $modfile || (-M $module < -M $modfile)){
+    print "Compiling module $module\n";
+    # Makes byte compiled version of each module
+    print `perlcc -B -o ${bindir}/$module $module`;
+    ++$n_compiled;
+  } else {
+    print "Module $module up to date\n";
+  }
+}
+if (!$n_compiled){
+  print "All modules up to date.\n";
+}
+
+print "Compiling scripts.\n";
+$n_compiled=0;
+for my $script (@scripts){
+  $sfile= "${bindir}/$script";
+  $sfile=~ s/[.]pl$//;
+  if (!-e $sfile || (-M $script < -M $sfile)){
+    print "Compiling script $script\n";
+    # Makes byte compiled version of each module
+    print `perlcc -B -o ${bindir}/$sfile $script`;
+    ++$n_compiled;
+  } else {
+    print "Script $script up to date\n";
+  }
+}
+if (!$n_compiled){
+  print "All scripts up to date.\n";
+}
+
+

data/bionetgen/Perl2/Aux2/bnglstat.pl

@@ -0,0 +1,12 @@
+#!/usr/bin/perl
+
+use FindBin;
+use lib $FindBin::Bin;
+use BNGModel;
+use BNGUtils;
+
+while (@ARGV){
+  my $file= shift(@ARGV);
+  my $model= BNGModel->new();
+  if ($err=$model->readFile($file,{no_exec=>1})){exit_error($err);}
+}

data/bionetgen/Perl2/Aux2/count_blocks.pl

@@ -0,0 +1,26 @@
+#!/usr/bin/perl
+
+for $file (@ARGV){
+  open(FILE,$file) || die "Couldn't open $file: $!\n";
+  print "$file:\n";
+  while(<FILE>){
+    if (/^s*begin\s+(\S.*)$/){
+      $bname= $1;
+      $bname=~ s/\s*$//;
+      $nentry=0;
+      while(<FILE>){
+	if (/^\s*end\s+(\S.*)$/){
+	  my $ename= $1;
+	  $ename=~ s/\s*$//;
+	  if ($bname ne $ename){
+	    die "end $ename not compatible with $bname\n";
+	  }
+	  last;
+	}
+        ++$nentry;
+      }
+      printf  "%7d %s\n", $nentry, $bname;
+    }
+  }
+  close(FILE);
+}

data/bionetgen/Perl2/Aux2/count_lines.pl

@@ -0,0 +1,51 @@
+#!/usr/bin/perl
+
+$source=<<"EOF";
+BNGAgent.pm
+BNGMessages.pm
+BNGModel.pm
+BNGOptions.pm
+BNGUtils.pm
+Compartment.pm
+CompartmentList.pm
+Component.pm
+ComponentType.pm
+Expression.pm
+HNauty.pm
+MacroBNGModel.pm
+Map.pm
+Molecule.pm
+MoleculeType.pm
+MoleculeTypesList.pm
+Observable.pm
+Param.pm
+ParamList.pm
+RateLaw.pm
+Rxn.pm
+RxnList.pm
+RxnRule.pm
+Species.pm
+SpeciesGraph.pm
+SpeciesList.pm
+EOF
+
+# count lines of source code by the number of ;'s
+
+if (@ARGV){
+  @files=@ARGV;
+} else {
+  @files= split(' ',$source);
+}
+my $n_lines_tot=0;
+for my $file (@files){
+  my $n_lines=0;
+  open(IN,$file) || die "Couldn't open $file:$?\n";
+  while(<IN>){
+    if (/;\s*$/){
+      ++$n_lines;
+    }  
+  }
+  print "$file:$n_lines\n";
+  $n_lines_tot+= $n_lines;
+}
+print "TOTAL:$n_lines_tot\n";

data/bionetgen/Perl2/Aux2/countdown.pl

@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+
+# doesn't work
+for $i (10..1){
+  print "$i\n";
+}

data/bionetgen/Perl2/Aux2/diff_cdat.pl

@@ -0,0 +1,120 @@
+#!/usr/bin/perl 
+
+# Program verify.pl compares two time course files.  For the
+# purpose of computing the norm error, the second file is the reference.
+#
+# Usage verify.pl datafile1 [datafile2]
+#
+# If no second filename is given, the script will automatically look in the
+# database of results in the $BioNetGenRoot/VERIFY directory.
+#
+# Outputs: 
+#  NORMERR: The computed norm error is printed
+#  Either SUCCESSFUL BUILD or PROBLEM WITH BUILD depending upon magnitude of
+#    norm error.  The configuration variable $BUILD_ERR_THRESH can be set in
+#    bngrc or the local .bngrc file.
+#
+# Thanks to Robert Seletsky, the original author of this script, and Stan
+# Steinberg, who suggested using the norm error 
+#   err= |m2-m1|/|m2|
+#      = sqrt( sum_{ij}((m2_{ij} - m1_{ij})**2)/ sum_{ij}(m2_{ij})**2),
+# where m1 and m2 are the arrays containing the time course data at i time
+# points for j variables.
+
+
+$BUILD_ERR_THRESH= 1e-7;
+$COLUMN_OFFSET=0;
+
+# Read command line arguments
+while ($ARGV[0] =~ /^-/){
+  $_ = shift;
+  if (/^-offset$/){
+    $COLUMN_OFFSET= shift;
+  }
+  else{
+    exit_error("Unrecognized command line option $_");
+  }
+}
+
+if (($#ARGV!= 1)) {
+  die "Usage: $0 filename filename2\n";
+}
+$rfilename = shift;
+$rfilename2= shift;
+
+#print "Comparing $rfilename $rfilename2\n";
+
+open (RFILE, $rfilename) or die "Can't open $rfilename: $!\n";
+$i=0;
+@data=();
+@times=();
+while (<RFILE>){
+   s/\#.*$//; # remove comments
+   next unless /\S+/;
+   ($time, @dat)= split(' ');
+   push @times, $time;
+   foreach $j (0..$#dat){
+      $data[$i][$j]= $dat[$j];
+   }
+   ++$i;
+}
+close(RFILE);
+
+open (RFILE, $rfilename2) or die "Can't open $rfilename2: $!\n";
+$i=0;
+@data2=();
+@times2=();
+while (<RFILE>){
+   s/\#.*$//; # remove comments
+   next unless /\S+/;
+   ($time, @dat)= split(' ');
+   push @times2, $time;
+   foreach $j (0..$#dat){
+      $data2[$i][$j]= $dat[$j];
+   }
+   ++$i;
+}
+close(RFILE);
+
+# Check that the time points in the two files are the same
+if ($#times != $#times2){
+  printf "Time points are incompatible\n";
+  printf "%d time point(s)in $rfilename.\n", $#times+1;
+  printf "%d time point(s)in $rfilename2.\n", $#times2+1;
+  exit(1);
+}
+for $i (0..$#times){
+  if ($times[$i]!= $times2[$i]){
+    printf "Time points are incompatible\n";
+    exit(1);
+  }
+} 
+
+# Compute normerr
+$sresult= &normerr(\@data, \@data2);
+print "$sresult\n";
+exit(0);
+
+
+# Compute norm error between two data sets stored in two rectangular arrays m1
+# and m2 of the same dimension (not checked)
+sub normerr {
+  my $m1= shift;
+  my $m2= shift;
+
+  my $del2=0;
+  my $ref2=0;
+
+  my $ilast= $#$m1;
+  my $jlast= $#{$$m1[0]};
+  for my $i (0..$ilast){
+    for my $j (0..$jlast){
+      my $j2= $j+$COLUMN_OFFSET;
+#      print $$m2[$i][$j]," ", $$m1[$i][$j],"\n";
+#      printf "$j $j2 %.2e %.2e\n", $$m1[$i][$j], $$m2[$i][$j2];
+      $del2+= ($$m2[$i][$j2] - $$m1[$i][$j])**2;
+      $ref2+= ($$m2[$i][$j2])**2;
+    }
+  }
+  return (sqrt($del2/$ref2));
+}

data/bionetgen/Perl2/Aux2/express.pl

@@ -0,0 +1,164 @@
+#!/usr/bin/perl
+
+use Data::Dumper;
+
+$express= {
+	   type=>'AND',
+#	   type=>'OR',
+#	   arg1=>{type=>'REF', arg1=>'a'},
+	   arg1=>{type=>'NOT', arg1=>{type=>'REF', arg1=>'a'}},
+   	   arg2=>{type=>'REF', arg1=>'b'}
+	  };
+
+$list= ['a','b', 'ab','abc', 'ac', 'c','bc'];
+
+#print Dumper($express);
+#print Dumper($list);
+
+# WARNING: NOT doesn't work properly unless it's surrounded by parenthesis
+
+#$string= "a AND (NOT c) AND b";
+#$string= "NOT (a AND b AND c)";
+#$string= "(a AND (NOT b)) OR (b AND (NOT a))";
+#$string= "(a OR b) AND (NOT (a AND b))";
+$string= "(a) AND (b)";
+$express= read_express(\$string);
+print Dumper($express),"\n";
+print join(" ",@{eval_express($express, $list)}),"\n";
+
+sub eval_express{
+  my $express= shift;
+  my $list= shift;
+
+  my $type= $express->{type};
+  my $arg1= $express->{arg1};
+  my $arg2= $express->{arg2};
+  if ($type eq 'AND'){
+    return(eval_express($arg2, eval_express($arg1,$list)));
+  } 
+  elsif ($type eq 'OR'){
+    my $list1= eval_express($arg1, $list);
+    my $list2= eval_express($arg2, $list);
+    return([@$list1,@$list2]);
+  } 
+  elsif ($type eq 'XOR'){
+    my $list1= eval_express($arg1, $list);
+    my $list2= eval_express($arg2, $list);
+    my %remove=();
+    for my $item (@$list1){
+      $remove{$item}=1;
+    }
+    my @lnew=();
+    for my $item (@$list2){
+      push @lnew, $item if (!($remove{$item}));
+    }
+    return([@lnew]);
+  }
+  elsif ($type eq 'NOT'){
+    my $list1= eval_express($arg1, $list);
+    my %remove=();
+    for my $item (@$list1){
+      $remove{$item}=1;
+    }
+    my @lnew=();
+    for my $item (@$list){
+      push @lnew, $item if (!($remove{$item}));
+    }
+    return([@lnew]);
+  } 
+  elsif ($type eq 'REF'){
+    my @lnew= ();
+    for my $item (@$list){
+      if ($item=~ /$arg1/){
+	push @lnew, $item;
+      }
+    }
+    return([@lnew]);
+  }   
+  else {
+    return("");
+  }
+}
+ 
+{
+  my $open=0;
+
+  sub read_express {
+    my $string= shift;
+    my $express="";
+    my $expect_arg1=0;
+    my $expect_arg2=0;
+    while ($$string ne ""){
+      my $nh={};
+      $$string=~ s/^\s+//;
+      if ($$string=~ s/^\(// ){
+	++$open;
+	$nh= read_express($string);
+      }
+      elsif ($$string=~ s/^AND\s+//){
+	$nh->{type}= 'AND';
+	die "Null first operand for AND" unless ($express ne "");
+	$nh->{arg1}= $express;
+	$express= $nh;
+	$expect_arg2=1;
+	next;
+      }
+      elsif ($$string=~ s/^OR\s+//){
+	$nh->{type}= 'OR';
+	die "Null first operand for OR" unless ($express ne "");
+	$nh->{arg1}= $express;
+	$express= $nh;
+	$expect_arg2=1;
+	next;
+      }
+      elsif ($$string=~ s/^XOR\s+//){
+	die "XOR not yet implemented";
+	$nh->{type}= 'XOR';
+	die "Null first operand for XOR" unless ($express ne "");
+	$nh->{arg1}= $express;
+	$express= $nh;
+	$expect_arg2=1;
+	next;
+      }
+      elsif ($$string=~ s/^NOT\s+//){
+	$nh->{type}= 'NOT';
+	$express= $nh;
+	$expect_arg1=1;
+	next;
+      }
+      elsif ($$string=~ s/^([^\s\)]+)//){
+	$nh->{type}='REF';
+	$nh->{arg1}=$1;
+      }
+      elsif ($$string=~ s/^\)// ){
+	--$open;
+	die "Unmatched end parenthesis" if ($open<0);
+	die "Empty parenthesis" if ($express eq "");
+	return($express);
+      }
+      # print Dumper($nh),"\n";
+      if ($express eq ""){
+	$express= $nh;
+      } 
+      elsif($expect_arg1){
+	$express->{arg1}=$nh;
+	$expect_arg1=0;
+      }
+      elsif($expect_arg2){
+	$express->{arg2}=$nh;
+	$expect_arg2=0;
+      }
+      else{
+	die "Expression without operator";
+      }
+    }
+    if ($expect_arg1){
+      die "Missing unary operand";
+    }
+    if ($expect_arg2){
+      die "Missing binary operand";
+    }
+    die "Missing end parenthesis" unless ($open==0);
+    return($express);
+  }
+}

data/bionetgen/Perl2/Aux2/express_main.pl

@@ -0,0 +1,114 @@
+#!/usr/bin/perl
+
+use FindBin;
+use lib $FindBin::Bin;
+use Param;
+use ParamList;
+use Expression;
+
+$a1= Expression->new;
+$a1->Type('NUM');
+$a1->Arglist([5]);
+
+$a2= Expression->new;
+$a2->Type('NUM');
+$a2->Arglist([12]);
+
+#$a3= Expression->new;
+
+$expr= Expression->new;
+$expr->Type('-');
+$expr->Arglist([($a1,$a2)]);
+
+printf "a1 evaluates to %s\n", $a1->evaluate();
+printf "a2 evaluates to %s\n", $a2->evaluate();
+
+($val,$err) = $expr->evaluate();
+if ($err){
+  die $err;
+}
+printf "expr evaluates to %s\n", $val;
+
+$string="45e-26";
+if (($number=getNumber(\$string)) ne ""){
+  printf "Number is %g\n", $number;
+} else {
+  printf "%s does not start with a valid number\n", $string;
+}
+
+$plist= ParamList->new();
+$plist->set("a",5);
+$plist->set("b",10);
+$plist->set("c",-10);
+
+#$estring="1.01e-2*2-a/b+c^2";
+$estring="-a^2 + b";
+$estring_sav=$estring;
+$expr= Expression->new();
+if ($err=$expr->readString(\$estring,$plist)){
+  die $err;
+}
+printf "expr $estring_sav prints as %s\n", $expr->toString($plist);
+($val,$err) = $expr->evaluate($plist);
+if ($err){
+  die $err;
+}
+printf "expr $estring_sav evaluates to %g\n", $val;
+
+printf "Before assignment, a=%d\n", $plist->evaluate("a");
+$estring="a=a+5";
+$err= ($expr=Expression->new())->readString(\$estring,$plist);
+printf "After assignment, a=%d\n", $plist->evaluate("a");
+
+$estring="x=(-a+5)/(c-10)";
+#$estring="x=5";
+$estring_sav=$estring;
+$expr= Expression->new();
+if ($err=$expr->readString(\$estring,$plist)){
+  die $err;
+}
+printf "expr $estring_sav prints as %s\n", $expr->toString($plist);
+$val = $expr->evaluate($plist);
+if ($expr->Err){
+  die $expr->Err;
+}
+printf "expr $estring_sav evaluates to %g\n", $val;
+
+$estring="y=100^(d=1/2) g";
+$estring_sav=$estring;
+$expr= Expression->new();
+if ($err=$expr->readString(\$estring,$plist,'\s')){
+  die $err;
+}
+printf "expr $estring_sav prints as %s\n", $expr->toString($plist);
+$val = $expr->evaluate($plist);
+if ($expr->Err){
+  die $expr->Err;
+}
+printf "expr $estring_sav evaluates to %g\n", $val;
+
+print $plist->writeBNGL();
+print $plist->toString();
+
+#sub getNumber(){
+sub getNumber{
+  my $string=shift;
+  my $number="";
+
+  # Decimal part
+  if ($$string=~ s/^([+-]?\d+[.]?\d*)//){
+    $number=$1;
+  }
+  elsif ($$string=~ s/^([+-]?[.]\d+)//){
+    $number=$1;
+  } else {
+    return("");
+  }
+
+  # Exponent part
+  if ($$string=~ s/^([DEFGdefg][+-]?\d+)//){
+    $number.=$1;
+  }
+  return($number);
+}
+

data/bionetgen/Perl2/Aux2/group_size.pl

@@ -0,0 +1,17 @@
+#!/usr/bin/perl
+# Count number of species matching a group
+my @gnames;
+my %gsize;
+while(<>){
+  next unless (/^begin groups/);
+  while(<>){
+    last if (/^end groups/);
+    (my $index, my $name, my $glist)= split(' ');
+    my @specs= split(',',$glist);
+    push @gnames, $name;
+    $gsize{$name}=scalar(@specs); 
+  }
+}
+foreach $group (@gnames){
+  printf "%s %d\n", $group, $gsize{$group};
+}

data/bionetgen/Perl2/Aux2/runBNG.pl

@@ -0,0 +1,135 @@
+#!/usr/bin/perl
+# $Id: runBNG.pl,v 1.2 2007/10/20 04:18:21 faeder Exp $
+
+use FindBin;
+use lib $FindBin::Bin;
+use BNGModel;
+use SpeciesList;
+use BNGUtils;
+use strict;
+
+# Set to nonzero value to equilibrate model prior to introduction of one
+# or more species.  This is required for the fceri model because there is a
+# constitutive (present without ligand) interaction between Lyn and FceRI.
+my $t_equil=1000;
+my $max_equil=100;
+my @spec_equil=("Lig(l,l)");
+
+# End point of production simulation and time point at which outputs will
+# be reported.
+my $t_end=600;
+my $n_steps=1;
+# Names of observables reported at integration end point
+my @output_vars=("RecSykPS");
+
+# Force regeneration of network prior to simulation 
+my $force_netgen=0;
+
+#------ END OF USER DEFINED PARAMETERS -------
+
+my $model= BNGModel->new();
+my %params=();
+while ($ARGV[0] =~ /^-/){
+  $_ = shift;
+  if (/^-g$/){
+    $force_netgen=1;
+  }
+  else{
+    exit_error("Unrecognized command line option $_");
+  }
+}
+
+# Get prefix and determine whether network has been generated
+my $prefix= shift(@ARGV);
+
+# Dup original STDOUT
+open my $oldout, ">&STDOUT"     or die "Can't dup STDOUT: $!";
+
+# Redirect STDOUT to logfile 
+open(STDOUT,">${prefix}_runBNG.log");
+
+# turn off output buffering on STDOUT
+(select(*STDOUT), $|=1)[0];
+
+printf "BioNetGen version %s\n", BNGversion();
+
+if (!$force_netgen && -r "$prefix.net"){
+	# Read previously generate net file
+	my $file= "$prefix.net";
+	$params{file}=$file;
+	if (my $err=$model->readFile(\%params)){exit_error($err);}
+} elsif (-r "$prefix.bngl") {
+	# Read BNGL file and generate network 
+	my $file= "$prefix.bngl";
+	$params{file}=$file;
+	if (my $err=$model->readFile(\%params)){exit_error($err);}
+	if (my $err=$model->generate_network({overwrite=>1})){exit_error($err);}
+} else {
+	exit_error("No BNGL or NET file could be found with prefix $prefix.");
+}	
+
+# Hash indices of observables
+my %obs_ind=();
+my $oind=0;
+for my $obs (@{$model->Observables}){
+	$obs_ind{$obs->Name}= $oind++;
+}
+
+# Set parameters to value of arguments
+my $iparam=0;
+for my $pvalue (@ARGV){
+	if (my $err=$model->ParamList->setIndex($iparam,$pvalue)){exit_error($err);}
+	++$iparam;
+}	
+
+# Perform equilibration
+if ($t_equil>0){
+	# Set equilibration variables to zero
+	my %val_equil=();
+	my $oldval;
+	for my $spec (@spec_equil){
+		# determine whether variable is species or concentration
+		(my $err, my $oldval)= $model->setConcentration($spec,0);
+		$err && exit_error($err);
+ 		$val_equil{$spec}= $oldval;
+	}
+	my $suff="runBNG_equil";
+	if (my $err=$model->simulate_ode({suffix=>$suff,t_end=>$t_equil,n_steps=>$max_equil,steady_state=>1,sparse=>1})){exit_error($err);}
+	# Reset equilibration variables	
+	for my $spec (@spec_equil){
+		(my $err, my $oldval)= $model->setConcentration($spec,$val_equil{$spec});
+		$err && exit_error($err);
+	}
+}
+
+# Run simulation
+my $suff="runBNG_run";
+if (my $err=$model->simulate_ode({suffix=>$suff,t_end=>$t_end,n_steps=>$n_steps})){exit_error($err);}	
+
+# Report results
+my $gdatfile= $prefix."_".$suff.".gdat";
+my @output=();
+if (-r "$gdatfile"){
+  print "Updating observable concentrations from $gdatfile\n";
+  open(GDAT, "$gdatfile");
+  my $last="";
+  while(<GDAT>){
+    $last=$_;
+  }
+  close(GDAT);
+  (my $time, my @gconc)= split(' ', $last);
+  for my $oname (@output_vars){
+#    push @output, "$oname:".$gconc[$obs_ind{$oname}];
+    push @output, $gconc[$obs_ind{$oname}];
+  }
+}else {
+  exit_error("Could not find $gdatfile");
+}
+
+printf "CPU TIME: total %.1f s.\n", cpu_time(0);
+
+open STDOUT, ">&", $oldout or die "Can't dup \$oldout: $!";
+# Print results to real STDOUT (to be read by Matlab)
+print join(" ",@output),"\n";
+
+

data/bionetgen/Perl2/Aux2/test.pl

@@ -0,0 +1,21 @@
+#!/usr/bin/perl
+# $Id: BNG2.pl,v 1.5 2005/11/08 16:41:35 faeder Exp $
+
+use FindBin;
+use lib $FindBin::Bin;
+use BNGModel;
+use SpeciesList;
+use BNGUtils;
+use strict;
+
+# turn off output buffering on STDOUT
+#(select(*STDOUT), $|=1)[0];
+
+#printf "BioNetGen version %s\n", BNGversion();
+ 
+#$model= BNGModel->new();
+my ($a, $b, $c);
+
+my $s= \"111";
+
+print $$s,"\n";

data/bionetgen/Perl2/Aux2/test_compartment.pl

@@ -0,0 +1,56 @@
+#!/usr/bin/perl
+
+use FindBin;
+use lib $FindBin::Bin;
+use Compartment;
+use CompartmentList;
+
+my $clist= CompartmentList->new;
+my $plist= ParamList->new;
+$clist->setDefault();
+# Check valid compartment setup/listing
+print $clist->toString();
+
+# Test adjacency function
+for my $comp1 (@{$clist->Array}){
+  for my $comp2 (@{$clist->Array}){
+    if ($comp1->adjacent($comp2)){
+      printf "%s adjacent to %s\n", $comp1->Name, $comp2->Name;
+    }
+  }
+}
+
+
+# Check setting of compartment volume
+my $x="100";
+if ($err=$clist->lookup("PM")->setVolume($x,$plist)){
+  die $err;
+}
+print "After setting PM volume to $x\n";
+print $clist->setVolumeStrings();
+
+# Test connected function
+
+if (!($clist->lookup("EC")->connected($clist->lookup("NM"), $clist->lookup("NU")))){
+  print "Connected PASSED test 1\n";
+} else {
+  print "Connected FAILED test 1\n";
+}
+
+if (($clist->lookup("EC")->connected($clist->lookup("CP"), $clist->lookup("PM")))){
+  print "Connected PASSED test 2\n";
+} else {
+  print "Connected FAILED test 2\n";
+}
+
+if (($clist->lookup("EC")->connected($clist->lookup("CP")))){
+  print "Connected FAILED test 3\n";
+} else {
+  print "Connected PASSED test 3\n";
+}
+
+if (($clist->lookup("EC")->connected($clist->lookup("CP"), $clist->lookup("PM"), $clist->lookup("NM")))){
+  print "Connected PASSED test 4\n";
+} else {
+  print "Connected FAILED test 4\n";
+}

data/bionetgen/Perl2/Aux2/test_molorder.pl

@@ -0,0 +1,20 @@
+#!/usr/bin/perl
+
+
+$perm= [3,1,2];
+@molecules=("a","b","c");
+print "before sort: ",join(" ",@molecules),"\n";
+
+# Reorder Molecules according to canonical order
+my @mol_perm=();
+
+#$imol=0;
+#for $mol (@molecules){
+#  push @mol_perm, [$$perm[$imol],$mol];
+#  ++$imol;
+#}
+@mol_perm= map {[$perm->[$_],$molecules[$_]]} (0..$#molecules);
+@mol_perm= sort {$a->[0]<=>$b->[0]} @mol_perm;
+@molecules= map {$_->[1]} @mol_perm;
+print " after sort: ",join(" ",@molecules),"\n";
+

data/bionetgen/Perl2/Aux2/test_redirect.pl

@@ -0,0 +1,19 @@
+#!/usr/bin/perl
+
+open my $oldout, ">&STDOUT"     or die "Can't dup STDOUT: $!";
+open OLDERR,     ">&", \*STDERR or die "Can't dup STDERR: $!";
+
+open STDOUT, '>', "$0.out" or die "Can't redirect STDOUT: $!";
+open STDERR, ">&STDOUT"     or die "Can't dup STDOUT: $!";
+
+select STDERR; $| = 1;	# make unbuffered
+select STDOUT; $| = 1;	# make unbuffered
+
+print STDOUT "stdout 1\n";	# this works for
+print STDERR "stderr 1\n"; 	# subprocesses too
+
+open STDOUT, ">&", $oldout or die "Can't dup \$oldout: $!";
+open STDERR, ">&OLDERR"    or die "Can't dup OLDERR: $!";
+
+print STDOUT "stdout 2\n";
+print STDERR "stderr 2\n";

data/bionetgen/Perl2/Aux2/test_sub.pl

@@ -0,0 +1,13 @@
+#!/usr/bin/perl
+
+use FindBin;
+use lib $FindBin::Bin;
+use SpeciesGraph;
+
+while(<>){
+  next unless /S+/;
+  my $sg= SpeciesGraph->new;
+  chomp;
+  $err=$sg->readString(\$_);
+  if ($err){die($err);}
+}

data/bionetgen/Perl2/BNGAction.pm

@@ -0,0 +1,1931 @@
+package BNGModel;
+# BNGAction is part of the BNGModel package. This file contains Action commands
+# including:  simulate, simulate_nf, simulate_pla, generate_hybrid_model, ...
+
+#
+# pragmas
+use strict;
+use warnings;
+
+###
+###
+###
+
+
+
+sub simulate_ode
+{
+    my $model = shift @_;
+    my $params = (@_) ? shift @_ : {};
+
+    $params->{method} = 'cvode';
+    my $err = $model->simulate( $params );
+    return $err;
+}
+
+
+sub simulate_ssa
+{
+    my $model = shift @_;
+    my $params = (@_) ? shift @_ : {};
+
+    $params->{method} = 'ssa';
+    my $err = $model->simulate( $params );
+    return $err;
+}
+
+
+sub simulate_pla
+{
+    my $model = shift @_;
+    my $params = (@_) ? shift @_ : {};
+
+    $params->{method} = 'pla';
+    my $err = $model->simulate( $params );
+    return $err;
+}
+
+
+
+###
+###
+###
+
+
+# all purpose simulation method (supports NFsim by calling 'simulate_nf' if method = "nf")
+sub simulate
+{
+    use IPC::Open3;
+    use IO::Select;
+
+    my $model  = shift @_;
+    my $params = (@_) ? shift @_ : {};
+    my $err;
+
+    my $METHODS =
+    {
+        cvode => { binary=>'run_network', type=>'Network', input=>'net',
+                   options=>{ atol=>1, rtol=>1, sparse=>1, steady_state=>1 } },
+        ssa   => { binary=>'run_network', type=>'Network', input=>'net', 
+                   options=>{ seed=>1 }                                      },
+        pla   => { binary=>'run_network', type=>'Network', input=>'net',
+                   options=>{ seed=>1 }                                      },
+        nf    => { binary=>'NFsim', type=>'NetworkFree', input=>'xml',
+                   options=>{ seed=>1 }                                      }
+    };
+
+    return '' if $BNGModel::NO_EXEC;
+
+    # Read simulation arguments from file
+    my @sample_times;
+    my $argfile = defined $params->{argfile} ? $params->{argfile} : undef;
+    if ($argfile)
+    {
+        print "Reading simulation arguments from $argfile.\n";
+        open(ARGS, "<", $argfile) or return "Could not open argfile '$argfile'.";
+        my $lineCounter = 0;
+        while (my $line = <ARGS>)
+        {
+            ++$lineCounter;
+            # trim comments
+            $line =~ s/#.*$//;
+            # skip empty lines
+            next unless ( $line =~ /\S/ );
+            # split tokens
+            my @args = split " ", $line; 
+
+            unless (@args == 2)
+            {   return "Could not process line $lineCounter in $argfile: wrong number of arguments.";   }
+
+            print "Processing argument: ";
+            # Check if Arg is already defined in action call
+            if ( !(defined $params->{$args[0]}) )
+            {   
+                if ( $args[0] ne 'sample_times' ){
+                    $params->{$args[0]} = $args[1];
+                    printf "$args[0] => %s\n", (looks_like_number($args[1]) ? $args[1] : "'$args[1]'");
+                }
+                else
+                {   # Special handling for sample_times array
+                    print "$args[0] => $args[1]\n";
+                    # evaluate sample_times string to get array ref (hopefully)
+                    my $sample_times = eval $args[1];
+                    if ($@)
+                    {    return "Problem parsing 'sample_times': Sample times must be comma-separated (no spaces) ints or floats "
+                             . "(exponential format ok) enclosed in square brackets, e.g., [5e-1,1,5.0,1E1].";
+                    }
+                    @sample_times = @$sample_times;
+                    foreach my $sample (@sample_times)
+                    {   # check that sample time is a number
+                        unless ( looks_like_number($sample) )
+                        {    return "Problem parsing 'sample_times': Sample times must be comma-separated (no spaces) ints or floats "
+                             . "(exponential format ok) enclosed in square brackets, e.g., [5e-1,1,5.0,1E1].";
+                        }
+                    }
+                }
+            }
+            else
+            {   # Args in the action call take precedence
+                if ( $args[0] ne 'sample_times' )
+                {   printf "'$args[0]' already defined with value %s, moving on...\n",
+                           (looks_like_number($params->{$args[0]}) ? "$params->{$args[0]}" : "'$params->{$args[0]}'");
+                }
+                else
+                {   printf "'$args[0]' already defined in action call, moving on...\n";   }
+            }
+        }
+        close ARGS;
+        printf "Finished.\n";
+    }
+
+    # general options
+    my $method        = defined $params->{method} ? $params->{method} : undef;
+    my $verbose       = defined $params->{verbose} ? $params->{verbose} : 0;
+    my $prefix        = defined $params->{prefix} ? $model->getOutputPrefix( $params->{prefix} ) : $model->getOutputPrefix();
+    my $suffix        = defined $params->{suffix} ? $params->{suffix} : undef;
+    my $netfile       = defined $params->{netfile} ? $params->{netfile} : undef;
+    my $print_end     = defined $params->{print_end} ? $params->{print_end} : 0;
+    my $print_net     = defined $params->{print_net} ? $params->{print_net} : 0;
+    my $save_progress = defined $params->{save_progress} ? $params->{save_progress} : 0; # Same as 'print_net'
+    my $continue      = defined $params->{'continue'} ? $params->{'continue'} : 0;    
+    my $print_active  = defined $params->{print_n_species_active} ? $params->{print_n_species_active} : 0;
+    my $print_cdat    = defined $params->{print_CDAT} ? $params->{print_CDAT} : 1; # Default is to print .cdat
+    my $print_fdat    = defined $params->{print_functions} ? $params->{print_functions} : 0; # Default is to NOT print .fdat
+	my $stop_if       = defined $params->{stop_if} ? $params->{stop_if} : undef; # stop condition
+	my $print_on_stop = defined $params->{print_on_stop} ? $params->{print_on_stop} : undef; # print at point that stop condition is met
+	my $max_sim_steps = defined $params->{max_sim_steps} ? $params->{max_sim_steps} : undef;
+	my $output_step_interval = defined $params->{output_step_interval} ? $params->{output_step_interval} : undef;
+    
+    # continuous options
+    my $atol         = defined $params->{atol}         ? $params->{atol}         : 1e-8;
+    my $rtol         = defined $params->{rtol}         ? $params->{rtol}         : 1e-8;
+    my $sparse       = defined $params->{sparse}       ? $params->{sparse}       : 0;
+    my $steady_state = defined $params->{steady_state} ? $params->{steady_state} : 0;
+
+    # stochastic options
+#    my $seed         = defined $params->{seed} ? $params->{seed} : floor(rand 2**31);
+	if ( not defined $params->{seed} ){ 
+    		# do this so that NFsim gets the seed generated by BNG --LAH
+    		$params->{seed} = floor(rand 2**31);
+	}
+	my $seed        = $params->{seed};
+
+    # check method
+    unless ( $method )
+    {  return "simulate() requires 'method' parameter (ode, ssa, pla, nf).";  }
+    if ($method =~ /^ode$/){  $method = 'cvode';  } # Support 'ode' as a valid method
+    unless ( exists $METHODS->{$method} )
+    {  return "Simulation method '$method' is not a valid option.";  }
+
+    printf "ACTION: simulate( method=>\"%s\" )\n", $method;
+
+    # add optional suffix to output prefix
+    if ( defined $suffix )
+    {  $prefix .= "_" . $suffix;  }
+
+	# If stop condition is defined add it to the list of functions
+	if ($stop_if){
+		(my $ref, $err) = $model->ParamList->lookup("_stop_if");
+		if (!$ref){
+			my $fun = Function->new();
+			if ( $err = $fun->readString( "_stop_if() " . $stop_if, $model ) ){  return $err;  }
+			# check paramlist for unresolved dependency, etc
+			if ( $err = $model->ParamList->check() ){  return $err;  }
+			# update netfile since new function was added
+			$model->UpdateNet(1)
+		}
+	}
+
+    # Find binary
+    my $binary = $METHODS->{$method}->{binary}; 
+    printf "%s simulation using %s\n", $METHODS->{$method}->{type}, $method;
+    my $program;
+    unless ( $program = findExec($binary) )
+    {   return "Could not find executable $binary";   }
+
+    # If method = "nf", call simulate_nf() and return
+    if ( $method eq 'nf' ){
+	    return $model->simulate_nf( $params );
+    }
+
+	# Network simulation
+    # Find or Create netfile
+    my $netpre;
+    if ($netfile)
+    {
+        # user defined netfile
+        # Make sure NET file has proper suffix
+        ($netpre = $netfile) =~ s/[.]([^.]+)$//;
+        unless ( $1 =~ /net/i )
+        {   return "File $netfile does not have .net suffix";   }
+    }
+    else
+    {
+        # default to [prefix].net
+        $netfile = "${prefix}.net";
+        $netpre  = $prefix;
+
+        # Generate NET file if not already created or if updateNet flag is set
+        if ( !(-e $netfile) or $model->UpdateNet or defined $params->{prefix} or defined $suffix )
+        {
+            $err = $model->writeNetwork({include_model=>0, overwrite=>1, prefix=>"$netpre"});
+            if ($err) { return $err; }
+        }
+    }
+    
+    # Begin writing command: start with program
+    my @command = ($program);
+
+    # add output prefix
+    push @command, "-o", "$prefix";
+    
+    # add method to command
+    push @command, "-p", "$method";
+    
+    # pla-specific arguments
+    if ($method eq 'pla')
+    {
+        if (!exists $params->{pla_config}){
+        		$params->{pla_config} = "fEuler|pre-neg:sb|eps=0.03";
+        		send_warning("'pla_config' not defined, using default: $params->{pla_config}");
+        }
+        push @command, $params->{pla_config};
+        if (defined $params->{pla_output}){
+        		push @command, "--pla_output", $params->{pla_output};
+        }
+    }
+    
+    # add method options
+    {
+        my $opts = $METHODS->{$method}->{options};
+        if ( exists $opts->{seed} )
+        {   # random seed
+            push @command, "-h", $seed;
+        }
+        if ( exists $opts->{atol} )
+        {   # absolute tolerance
+            push @command, "-a", $atol;
+        }
+        if ( exists $opts->{rtol} )
+        {   # absolute tolerance
+            push @command, "-r",  $rtol;
+        }
+        if ( exists $opts->{sparse} )
+        {   # sparse methods
+            if ($sparse) { push @command, "-b"; }
+        }
+        if ( exists $opts->{steady_state} )
+        {   # check for steady state
+            if ($steady_state) { push @command, "-c"; }
+        }
+    }
+
+    # define update_interval
+    my $update_interval = defined $params->{update_interval} ? $params->{update_interval} : 1.0;
+
+    # define expand
+    my $expand =  defined $params->{expand} ? $params->{expand} : 'lazy';
+    if ( $expand eq 'lazy' ) { }
+    elsif ( $expand eq 'layered' ) { }
+    else { return "Unrecognized expand method $expand";    }
+
+    # define maximum # of sim steps
+    if (defined $max_sim_steps)
+    {   push @command, "-M", $max_sim_steps;  }
+
+    # define output step interval
+    if (defined $output_step_interval)
+    {   push @command, "-I", $output_step_interval;  }
+    
+    # stop condition
+    if ($stop_if){   
+	    	push @command, "--stop_cond", $stop_if;
+	    	if ($print_on_stop){
+	    		push @command, $print_on_stop;
+	    	}
+	    	else{
+	    		push @command, "1"; # Default is to print on stop
+	    	}
+    }
+    
+    # output concentrations data
+    push @command, "--cdat", $print_cdat;
+    # output function values
+    push @command, "--fdat", $print_fdat;
+
+    # define print_net (save_progress)
+    if (defined $params->{print_net} && defined $params->{save_progress}){ # Don't let them both be defined
+        return "'print_net' and 'save_progress' are the same thing, cannot define both. " 
+                . "Please only define one ('save_progress' is preferred).";
+    }    
+    if ($print_net || $save_progress) { push @command, "-n"; }
+    # define print_end
+    if ($print_end) { push @command, "-e"; }
+    # More detailed output
+    if ($verbose)   { push @command, "-v"; }
+    # Continuation
+    if ($continue)  { push @command, "-x"; }    
+    # Print number of active species
+    if ($print_active) { push @command, "-j"; }
+
+
+    # Set start time for trajectory
+    my $t_start;
+    if ( defined $params->{t_start} )
+    {
+        $t_start = $params->{t_start};        
+        # if this is a continuation, check that model time equals t_start
+        if ($continue)
+        {
+            unless ( defined($model->Time)  and  ($model->Time == $t_start) )
+            {  return "t_start must equal current model time for continuation.";  }
+        }
+    }
+    else
+    {   # t_start defaults to 0
+        if ( $continue   and   defined($model->Time) )
+        {  $t_start = $model->Time; }
+         else
+        {  $t_start = 0.0;  }
+    }
+
+    # Set the model time to t_start
+    $model->Time($t_start);
+
+      # To preserve backward compatibility: only output start time if != 0
+    unless ( $t_start == 0.0 )
+    {  push @command, "-i", "$t_start";  }
+
+    # Use program to compute observables
+    push @command, "-g", $netfile;
+
+    # Read network from $netfile
+    push @command, $netfile;
+
+    # define t_end and n_steps
+    my ($n_steps, $t_end);
+    if ( (defined $params->{n_steps} || defined $params->{n_output_steps}) && 
+         (defined $params->{sample_times} || @sample_times) ){
+        # Throw warning if both n_steps and sample_times are defined
+        my $x = ( defined $params->{n_steps} ) ? "n_steps" : "n_output_steps";
+        send_warning("$x and sample_times both defined. $x takes precedence.");
+    }
+    if ( defined $params->{n_steps} || defined $params->{n_output_steps} || 
+       ( !defined $params->{sample_times} && !@sample_times) )
+       {
+        if ( defined $params->{n_steps} && defined $params->{n_output_steps} ){ # Don't let them both be defined
+            return "'n_steps' and 'n_output_steps' are the same thing, cannot define both. "
+                    . "Please only define one ('n_output_steps' is preferred).";
+        }
+
+        if ( defined $params->{t_end} ){
+            $t_end = $params->{t_end};
+        }
+        else{
+            return "Parameter t_end must be defined.";
+        }
+        
+        if ( ($t_end - $t_start) <= 0.0 )
+        {
+        	send_warning("t_end (" . $t_end . ") is not greater than t_start (" . $t_start . "). " .
+                  	 "Simulation won't run.");
+        }
+        
+        if (defined $params->{n_steps}){
+            $n_steps = $params->{n_steps};
+        }
+        elsif (defined $params->{n_output_steps}){
+            $n_steps = $params->{n_output_steps};
+        }
+        else{
+            $n_steps = 1;
+        }
+        
+        my $step_size = ($t_end - $t_start) / $n_steps;
+        push @command, $step_size, $n_steps;
+    }
+    else
+    {
+        if (defined $params->{sample_times})
+        { @sample_times = @{$params->{sample_times}}; }
+        @sample_times = sort {$a <=> $b} @sample_times; # numeric sort
+        if ( @sample_times > 2 ){
+        	# remove all sample times <= t_start --Do this in run_network (LAH)
+#        	while ($sample_times[0] <= $t_start){ 
+#        		shift @sample_times;
+#            }
+            if ( defined $params->{t_end} ){
+                $t_end = $params->{t_end};
+                # remove all sample times >= t_end --Do this in run_network (LAH)
+#                while ($sample_times[ $#sample_times ] >= $t_end){ 
+#                    pop @sample_times;
+#                }
+                # push t_end as final sample time
+                push @sample_times, $t_end; 
+            }
+            else{
+                $t_end = $sample_times[ $#sample_times ];
+            }
+            push @command, @sample_times; # add sample times to argument list
+        }
+        else{
+            return "'sample_times' array must contain 3 or more points.";
+        }
+    }
+    
+    # Determine index of last rule iteration
+    my $n_iter = 0;
+    if ( $model->SpeciesList )
+    {
+        foreach my $spec ( @{$model->SpeciesList->Array} )
+        {
+            my $iter = $spec->RulesApplied;
+            $n_iter = ( $iter > $n_iter ) ? $iter : $n_iter;
+        }
+    }
+
+
+    ### RUN SIMULATION ###
+    print  "Running run_network on ", `hostname`;
+    printf "full command: %s\n", join(" ", @command);
+
+    # disable dospath warnings for Windows OS.
+    use Config;
+    if ( $Config{'osname'} eq 'MSWin32' )
+    {   $ENV{'CYGWIN'}='nodosfilewarning';   }
+
+    # start simulator as child process with communication pipes
+    local ( *Reader, *Writer, *Err );
+    my $pid = eval{ open3( \*Writer, \*Reader, \*Err, @command ) };
+    if ($@) { return sprintf("%s failed: $@", join(" ", @command)); }
+
+    # remember child PID
+    $::CHILD_PID = $pid;
+    print "[simulation PID is: $pid]\n";
+
+    # Wait for messages from the Simulator
+    my $last_msg = '';
+    my $steady_state_reached = 0;
+    my $edge_warning = 0;
+    my $otf = 0;
+
+    while ( my $message = <Reader> )
+    {
+        # If network generation is on-the-fly, look for signal that
+        # species at the edge of the network is newly populated
+        if ( $message =~ /Steady state reached/ )
+        {   # steady state message
+            $steady_state_reached = 1;
+        }
+        elsif ( $message =~ s/^edgepop:\s*// )
+        {
+            # remember that we've attempted On-the-fly!
+            $otf = 1;
+
+            unless ( $model->SpeciesList )
+            {   # Can't generate new species if running from netfile
+                # TODO: I don't think it's sufficient to check if SpeciesList is defined.
+                #  It's possible that it exists but the Network generation infrastructure is missing --Justin
+                ++$edge_warning;
+                print Writer "continue\n";
+                next;
+            }
+
+            # parse edgepop message
+            my (@newspec) = split /\s+/, $message;
+
+            my $species;
+            ++$n_iter;
+            if ( $expand eq 'lazy' )
+            {
+                my (@sarray, $spec);
+                foreach my $sname (@newspec)
+                {
+                    unless ( $spec = $model->SpeciesList->lookup_bystring($sname) )
+                    {  return "Couldn't find species $sname.";  }
+                    push @sarray, $spec;
+                }
+                if ($verbose)
+                {  printf "Applying rules to %d species\n", scalar @sarray;  }
+                $species = \@sarray;
+            }
+            else
+            {   # Do full next iteration of rule application
+                $species = $model->SpeciesList->Array;
+            }
+
+            # Apply reaction rules
+            my $nspec = $model->SpeciesList->size();
+            my $nrxn  = $model->RxnList->size();
+            my $irule = 1;
+            my ($n_new, $t_off);
+            foreach my $rset ( @{$model->RxnRules} )
+            {
+                if ($verbose) {  $t_off = cpu_time(0);  }
+                $n_new = 0;
+                foreach my $rr (@$rset)
+                {
+                    # expand rule
+                    my ($err, $nr) = $rr->expand_rule( $species, $model, $params );
+                    if (defined $err)
+                    {   return "Some problem expanding rule (OTF): $err";   }                    
+                    $n_new += $nr;
+
+                }
+                if ($verbose)
+                {
+                    printf "Rule %3d: %3d new reactions %.2e s CPU time\n",
+                      $irule, $n_new, cpu_time(0) - $t_off;
+                }
+                ++$irule;
+            }
+
+            # Set RulesApplied attribute to everything in @$species
+            foreach my $spec (@$species)
+            {
+                $spec->RulesApplied($n_iter) unless ($spec->RulesApplied);
+            }
+
+            # Set RulesApplied attribute to everything in SpeciesList
+            my $new_species = [];
+            foreach my $spec ( @{$model->SpeciesList->Array} )
+            {
+                push @$new_species, $spec  unless ($spec->RulesApplied);
+            }
+
+            # Print new species, reactions, and observable entries
+            if ( $model->RxnList->size() > $nrxn )
+            {
+                print Writer "read\n";
+                $model->SpeciesList->print( *Writer, $nspec );
+                $model->RxnList->print( *Writer, $nrxn );
+                print Writer "begin groups\n";
+                my $i = 1;
+                foreach my $obs ( @{$model->Observables} )
+                {
+                    print Writer "$i ";
+                    $obs->printGroup( *Writer, $model->SpeciesList->Array, $nspec );
+                    ++$i;
+                }
+                print Writer "end groups\n";
+            }
+            else
+            {
+                print Writer "continue\n";
+            }
+        }
+        else
+        {
+            print $message;
+            $last_msg = $message;
+        }
+    }
+
+    # Simulator is finished
+    my @err = <Err>;
+    close Writer;
+    close Reader;
+    close Err;
+    waitpid( $pid, 0 );
+
+    # clear child pid
+    $::CHILD_PID = undef;
+
+    # Report number of times edge species became populated without network expansion
+    if ($edge_warning)
+    {   send_warning("Edge species of truncated network became populated $edge_warning times.");   }
+
+    if (@err)
+    {   # print any errors received from 
+        print @err;
+        return sprintf("%s\n  did not run successfully.", join(" ", @command));
+    }
+
+    unless ( $last_msg =~ /^Program times:/ )
+    {   return sprintf("%s\n  did not run successfully.", join(" ", @command));  }
+
+
+
+    
+    # At this point, the simulation seems to be ok.
+    #  Go ahead and print out final netfile (if there are new reactions or species)
+    if ( $otf  and  $model->SpeciesList )
+    {   # TODO: I don't think it's sufficient to check if SpeciesList is defined.
+        #  It's possible that it exists but the Network generation infrastructure is missing --Justin
+        $err = $model->writeNetwork({include_model=>0, overwrite=>1, prefix=>"$netpre"});
+        if ($err) { return $err; }
+    }
+
+
+    # Report steady state
+    if ($steady_state)
+    {
+        if ($steady_state_reached)
+        {   # let user know simulation reached steady state
+            print "Simulation reached steady state by t_end=${t_end}\n";
+        }
+        else
+        {   # warn user about failure to acheive steady state
+            send_warning("Steady_state status = $steady_state_reached.");
+            return "Simulation did not reach steady state by t_end=${t_end}";
+        }
+    }
+
+    # If there are no errors or flags so far, let's load output concentrations
+    if ( !($model->RxnList) )
+    {   # TODO: what does this accomplish? --Justin
+        send_warning("Not updating species concentrations because no model has been read.");
+    }
+    elsif ( -e "$prefix.cdat" )
+    {
+        print "Updating species concentrations from $prefix.cdat\n";
+        open CDAT, '<', "$prefix.cdat" ;
+        my $last_line = '';
+        while (my $line = <CDAT>) {  $last_line = $line;  }
+        close CDAT;
+
+        # Update Concentrations with concentrations from last line of CDAT file
+        my $conc;
+        ($t_end, @$conc) = split ' ', $last_line;
+        my $species = $model->SpeciesList->Array;
+        unless ( $#$conc == $#$species )
+        {
+            $err = sprintf "Number of species in model (%d) and CDAT file (%d) differ", scalar @$species, scalar @$conc;
+            return $err;
+        }
+        $model->Concentrations( $conc );
+        $model->UpdateNet(1);
+    }
+    else
+    {    return "CDAT file is missing";   }
+
+    # Set model time to t_end
+    $model->Time($t_end);
+
+    # all finished!
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+sub simulate_nf
+{
+    use IPC::Open3;
+
+    my $model  = shift @_;
+    my $params = shift @_;
+    my $err;
+
+    printf "ACTION: simulate_nf( )\n";
+
+    # get simulation output prefix
+    my $prefix  = defined $params->{prefix} ? $model->getOutputPrefix( $params->{prefix} ) : $model->getOutputPrefix();
+    my $suffix  = defined $params->{suffix} ? $params->{suffix} : "";
+
+    unless ($suffix eq "")
+    {  $prefix .= "_${suffix}";  }
+
+    # TODO: detect unrecognized parameters
+
+    # map BNG options to NFsim flags
+    my %nfparams =
+    (   # option name        type              defaults              simulator flags (one or more)
+        binary_output   => { type => 'switch', default_arg => 0,     flags => ["-b"]                      },
+        complex         => { type => 'switch', default_arg => 1,     flags => ["-cb"]                     },
+        equil           => { type => 'param',  default_arg => undef, flags => ["-eq"]                     },
+        get_final_state => { type => 'switch', default_arg => 1,     flags => ["-ss","${prefix}.species"] },
+        gml             => { type => 'param',  default_arg => undef, flags => ["-gml"]                    },
+        nocslf          => { type => 'switch', default_arg => 0,     flags => ["-nocslf"]                 },
+        notf            => { type => 'switch', default_arg => 0,     flags => ["-notf"]                   },
+        print_functions => { type => 'switch', default_arg => 0,     flags => ["-ogf"]                    },
+        seed            => { type => 'param',  default_arg => undef, flags => ["-seed"]                   },
+        utl             => { type => 'param',  default_arg => undef, flags => ["-utl"]                    },
+        verbose         => { type => 'switch', default_arg => 0,     flags => ["-v"]                      }
+    );
+
+    # get nfsim arguments
+    my @args = ();
+    while ( my ($arg,$arg_hash) = each %nfparams )
+    {
+        if ($arg_hash->{type} eq "switch")
+        {
+            if (defined $params->{$arg})
+            {   # user switch
+                if ($params->{$arg})
+                {   push @args, @{$arg_hash->{flags}};  }
+            }
+            elsif (defined $arg_hash->{default_arg})
+            {   # default switch
+                $params->{$arg} = $arg_hash->{default_arg};
+                if ($arg_hash->{default_arg})
+                {   push @args, @{$arg_hash->{flags}};  }
+                
+            }
+        }
+        elsif ($arg_hash->{type} eq "param")
+        {
+            if (defined $params->{$arg})
+            {   # user parameter
+                push @args, @{$arg_hash->{flags}}, $params->{$arg};
+            }
+            elsif (defined $arg_hash->{default_arg})
+            {   # user parameter
+                push @args, @{$arg_hash->{flags}}, $arg_hash->{default_arg};
+                $params->{$arg} = $arg_hash->{default_arg};
+            }
+        }
+    }
+
+    # append other command line arguments not recognized by BNG
+    if ( defined $params->{param} )
+    {  push @args, split " ", $params->{param};  }
+
+    # exit here if we're not executing
+    return '' if $BNGModel::NO_EXEC;
+
+    if ( $model->Params->{no_nfsim} )
+    {   # don't execute NFsim if no_nfsim parameter is true
+        send_warning( "simulate_nf(): skipping simulation, 'no-nfsim' flag is true.");
+        return '';
+    }
+
+
+    # continue with simulation...
+#    print "Netfree simulation using NFsim\n";
+    my $program;
+    unless ( $program = findExec("NFsim") )
+    {  return "Could not find executable NFsim";  }
+    my @command = ($program);
+
+    # Write BNG xml file
+    $model->writeXML( {'prefix'=>$prefix} );
+
+    # Define command line
+    push @command, "-xml", "${prefix}.xml", "-o", "${prefix}.gdat";
+
+    # Append the run time and output intervals
+    my $t_start;
+    if (defined $params->{t_start})
+    {
+        $t_start = $params->{t_start};
+        $model->Time($t_start);
+    }
+    else
+    {
+        $t_start = defined $model->Time ? $model->Time : 0;
+    }
+
+
+    unless ($t_start == 0)
+    {   # warn user if t_start > 0
+        send_warning("simulate_nf(): NFsim timepoints are reported as time elapsed since t_start=$t_start.");
+    }
+
+    if ($params->{continue})
+    {   # warn user that continue is not supported
+#        send_warning("simulate_nf(): NFsim does not support 'continue' option. NFsim will overwrite any existing trajectories.");
+        return "NFsim does not support 'continue' option.";
+    }
+
+    my $t_end;
+    if ( defined $params->{n_steps} )
+    {
+        my ($n_steps, $t_end);
+        $n_steps = $params->{n_steps};
+        if ( $n_steps < 1 )
+        {   return "No simulation output requested: set n_steps>0";   }
+
+        if ( defined $params->{t_end} )
+        {   $t_end = $params->{t_end};   }
+        else
+        {   return "Parameter t_end must be defined";   }
+
+        unless ( $t_end > $t_start )
+        {   return "t_end must be greater than t_start.";   }
+
+        push @command, "-sim", ($t_end-$t_start), "-oSteps", $n_steps;
+    }
+    elsif ( defined $params->{sample_times} )
+    {
+        return "sample_times not supported in this version of NFsim";
+    }
+    else
+    {
+        return "No simulation output requested: set n_steps>0";
+    }
+
+
+    # Append the other command line arguments
+    push @command, @args;
+
+
+    # Run NFsim
+    print "Running NFsim on ", `hostname`;
+    printf "full command: %s\n", join(" ", @command);
+
+    # Compute timecourses using nfsim
+    # start simulator as child process with communication pipes
+    local ( *Reader, *Writer, *Err );
+    my $pid = eval{ open3( \*Writer, \*Reader, \*Err, @command ) };
+    if ($@) { return sprintf("%s failed: $@", join(" ", @command)); }
+
+    # remember child PID
+    $::CHILD_PID = $pid;
+    print "[simulation PID is: $pid]\n";
+
+    my $last = '';
+    while ( <Reader> )
+    {
+        print;
+        $last = $_;
+    }
+    ( my @err = <Err> );
+
+    close Writer;
+    close Reader;
+    close Err;
+    waitpid( $pid, 0 );
+
+    # clear child pid
+    $::CHILD_PID = undef;
+
+    if (@err) {
+        print "Error log:\n", @err;
+		foreach my $e (@err){
+			unless ( $e =~ /^\s*WARNING/i ){
+	        	return sprintf("%s did not run successfully.", join(" ", @command));
+			}
+	    }
+    }
+
+    if ( $params->{get_final_state} )
+    {   # Update final species concentrations to allow trajectory continuation
+        if (my $err = $model->readNFspecies("${prefix}.species"))
+        {  return $err;  }
+        #if ( $params->{verbose} )
+        #{  print $model->SpeciesList->writeBNGL( $model->Concentrations, $model->ParamList );  }
+    }
+    else
+    {
+        send_warning( "system state was not retrieved following simulate_nf. "
+                     ."To retreive system state, call simulate_nf with option: get_final_state=>1." );
+    }
+
+    $model->Time($t_end);
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+sub readNFspecies 
+{
+    # This function reads a list of species strings from NFsim output to form a 
+    # canonical species list with correct concentrations. Note that it overwrites
+    # any existing species.
+    my $model = shift @_;
+    my $fname = shift @_;
+
+    my $conc_vec;
+    if ($model->SpeciesList)
+    {
+        $conc_vec = [ (0) x scalar @{$model->SpeciesList->Array} ];
+    }
+    else
+    {        
+        $conc_vec = [];
+        # create species list
+        $model->SpeciesList( SpeciesList->new );
+    }
+    my $slist = $model->SpeciesList;
+
+    # tell SpeciesLabel to use Quasi method for species w/ large number of molecules
+    my $maxMols = 20;
+    my $save_maxMols = SpeciesGraph::getSpeciesLabelMethod_MaxMols();
+    SpeciesGraph::setSpeciesLabel( SpeciesGraph::getSpeciesLabelMethod(), $maxMols );
+
+    # Read NFsim species file
+    print "readNFspecies::Reading from file $fname\n";
+    #my $FH;
+    open(my $FH, "<", $fname)
+        or return "Couldn't read from file $fname: $!";
+
+    my $n_spec_read = 0;
+    my $n_spec_new = 0;
+    my $line_num = 0;
+    while ( my $string = <$FH> )
+    {
+        ++$line_num;
+        chomp $string;                 # remove line return
+        $string =~ s/^\s+//;           # remove leading whitespace
+        $string =~ s/\#.*$//;          # remove comments
+        next unless $string =~ /\S+/;  # skip blank lines
+
+        # Read species string
+        my $sg = SpeciesGraph->new();
+        my $err = $sg->readString( \$string, $model->CompartmentList, 1, '^\s+', 
+                                    $model->MoleculeTypesList );
+        if ($err) {  return $err." at line $line_num of file $fname";  }
+
+        # Read species concentration - may only be integer value
+        my $conc;
+        if ( $string=~ /^\s*(\d+)\s*$/ )
+        {   $conc = $1;   }
+        else
+        {   return "species concentration must be single integer at line $line_num of file $fname";   }
+
+        # Check if isomorphic to existing species 
+        my $existing_sg = $model->SpeciesList->lookup( $sg );
+        if ($existing_sg)
+        { 
+            # Add concentration to concentration of existing species
+            $conc_vec->[$existing_sg->Index - 1] += $conc;
+        }
+        else
+        {
+            # Create new Species entry in SpeciesList with zero default concentration
+            my $newspec = $model->SpeciesList->add( $sg, 0 );
+            $conc_vec->[ $newspec->Index - 1 ] = $conc;
+            ++$n_spec_new;
+        }
+        ++$n_spec_read;
+    }
+    close $FH;
+
+    $model->Concentrations( $conc_vec );
+    printf "Read %d unique species of %d total.\n", $n_spec_new, $n_spec_read;
+
+    # return SpeciesLable method to original setting
+    SpeciesGraph::setSpeciesLabel( SpeciesGraph::getSpeciesLabelMethod(), $save_maxMols );
+
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+# construct a hybrid particle population (HPP) model
+#  --Justin, 21mar2011
+sub generate_hybrid_model
+{
+    my $model        = shift;
+    my $user_options = shift;
+
+
+    my $indent = '    ';
+    my $step_index = 0;
+    printf "ACTION: generate_hybrid_model( %s )\n", $model->Name;
+
+
+    # default options
+    my $options =
+    {   'prefix'       => undef,
+        'suffix'       => 'hpp',
+        'overwrite'    => 0,
+        'verbose'      => 0,
+        'actions'      => ['writeXML()'],
+        'execute'      => 0,
+        'safe'         => 0
+    };
+    # get user options
+    foreach my $opt (keys %$user_options)
+    {
+        my $val = $user_options->{$opt};
+        if ($opt eq "exact")
+        {   # TODO: temporary patch to allow the old "exact" option
+            send_warning("The 'exact' option has been renamed 'safe', please use this in the future.");
+            $opt = "safe";
+        }
+
+        unless ( exists $options->{$opt} )
+        {   return "Unrecognized option $opt in call to generate_hybrid_model";   }
+        
+        # overwrite default option
+        $options->{$opt} = $val;
+    }
+    # print options
+    print "options = \n";
+    while ( my ($par,$val) = each %$options )
+    {   
+        next unless (defined $val);
+        if ( ref $val eq 'ARRAY')
+        {   printf( "%12s => %-60s\n", $par, "[array]" );   }
+        elsif ( ref $val eq 'HASH')
+        {   printf( "%12s => %-60s\n", $par, "{hash}" );   }
+        elsif ( ref \$val eq 'SCALAR')
+        {   printf( "%12s => %-60s\n", $par, $val );   }
+    }
+
+    # do nothing if $NO_EXEC is true
+    return '' if $BNGModel::NO_EXEC;
+
+    # determine HPP model name
+    # (1) if prefix is defined, try to extract the file basename
+    # (2) otherwise use the name of the parent model
+#    my $modelname;
+#    my $outdir;
+#    if (defined $options->{prefix})
+#    {
+#        my ($vol,$dir,$filebase) = File::Spec->splitpath($options->{prefix});
+#        if ($filebase eq '')
+#        { return sprintf "Prefix value '%s' does not end with a file basename", $options->{prefix}; }
+#        $outdir = File::Spec->catpath($vol, $dir);
+#        $modelname = $filebase;
+#    }
+#    else
+#    {   
+ #   	$outdir = defined $options->{output_dir} ? $options->{output_dir} : $model->getOutputDir();
+#        $modelname = $model->Name;
+#    }
+    # add suffix
+#    $modelname .= "_" . $options->{suffix};
+
+
+    # define prefix
+#    my $prefix = defined $options->{prefix} ? $options->{prefix} : File::Spec->catfile($outdir, $modelname);
+    my $prefix = defined $options->{prefix} ? $model->getOutputPrefix( $options->{prefix} ) : $model->getOutputPrefix();
+	$prefix .= "_" . $options->{suffix};
+
+	# define outdir and modelname
+	my ($vol,$dir,$modelname) = File::Spec->splitpath($prefix);
+	my $outdir = File::Spec->catpath($vol, $dir);
+	
+    # define filename
+#    my $modelfile = $modelname . ".bngl";
+	my $modelfile = $prefix . ".bngl";
+
+    if ( -e $modelfile )
+    {
+        if ($options->{overwrite})
+        {
+            send_warning( "Overwriting older model file: $modelfile" );
+            unlink $modelfile;
+        }
+        else
+        {
+            return "Model file $modelfile already exists. Set overwrite=>1 option to force overwrite.";
+        }
+    }
+
+    # check if a ParamList exists
+    unless ( defined $model->ParamList )
+    {   return sprintf "Cannot continue! Model %s does not have a parameter list.", $model->Name;   }
+
+    # Check for MoleculeTypes
+    unless ( defined $model->MoleculeTypesList  and  %{$model->MoleculeTypesList->MolTypes} )
+    {   return sprintf "Nothing to do! Model %s has zero molecule type definitions.", $model->Name;   }     
+
+    # check if a SpeciesList exists
+    unless ( defined $model->SpeciesList  and  @{$model->SpeciesList->Array} )
+    {   return sprintf "Nothing to do! Model %s has zero seed species definitions.", $model->Name;   }
+
+    # Check for RxnRules
+    unless ( defined $model->RxnRules  and  @{$model->RxnRules} )
+    {   return sprintf "Nothing to do! Model %s has zero reaction rule definitions.", $model->Name;   } 
+
+    # check if PopulationTypesList exists
+    unless ( defined $model->PopulationTypesList  and  %{$model->PopulationTypesList->MolTypes} )
+    {   return sprintf "Nothing to do! Model %s has zero population type definitions.", $model->Name;   }
+
+    # check if PopulationList exists
+    unless ( defined $model->PopulationList  and  @{$model->PopulationList->List} )
+    {   return sprintf "Nothing to do! Model %s has zero population map definitions.", $model->Name;   }
+   
+    
+    # create new model!
+    my $hybrid_model = BNGModel::new();
+    
+    $hybrid_model->Name( $modelname );
+    $hybrid_model->Version( $model->Version );
+    $hybrid_model->SubstanceUnits( $model->SubstanceUnits );
+
+    # copy options    
+    %{$hybrid_model->Options} = %{$model->Options};
+    # set prefix
+    $hybrid_model->Options->{prefix} = $prefix;
+    #set output_dir
+	$hybrid_model->setOutputDir($outdir);
+	
+    # copy the constants in the parameter list
+    #  NOTE: we'll add observable and functions later
+    print $indent . "$step_index:Fetching model parameters.. ";  ++$step_index;
+    my $plist_new = $model->ParamList->copyConstant();
+    $hybrid_model->ParamList( $plist_new );
+    print sprintf "found %d constants and expressions.\n", scalar @{$plist_new->Array};
+    
+    
+    # Copy compartments
+    my $clist_new = undef;
+    if ( defined $model->CompartmentList )
+    {
+        print $indent . "$step_index:Fetching compartments.. "; ++$step_index;
+        $clist_new = $model->CompartmentList->copy( $plist_new );
+        $hybrid_model->CompartmentList( $clist_new );
+        print $indent . sprintf "found %d compartments.\n", scalar @{$clist_new->Array};
+        send_warning( "generate_hybrid_model() does not support compartments at this time." ) if (@{$clist_new->Array});  
+    }
+    
+    
+    
+    # Copying the moleculeTypesList and add population types
+    print $indent . "$step_index:Fetching molecule types..   "; ++$step_index;
+    my $mtlist_new =  $model->MoleculeTypesList->copy();
+    $hybrid_model->MoleculeTypesList( $mtlist_new );
+    print sprintf "found %d molecule types.\n", scalar keys %{$mtlist_new->MolTypes};
+    {
+        # Add population types
+        print $indent . "$step_index:Adding population types..   "; ++$step_index;
+        foreach my $name ( keys %{$model->PopulationTypesList->MolTypes} )
+        {
+            my $mt = $model->PopulationTypesList->MolTypes->{$name};
+            my $mt_copy = $mt->copy();
+            $mt_copy->PopulationType(1);
+            unless ( $mtlist_new->add($mt_copy) )
+            {   return "PopulationType $name clashes with MoleculeType of the same name";  }
+        }
+        print sprintf "found %d population types.\n", scalar keys %{$model->PopulationTypesList->MolTypes};
+    }
+
+
+    # Copy seed species, replacing with populations if possible, and add empty populations
+    my $slist_new = SpeciesList::new();
+    $hybrid_model->SpeciesList( $slist_new );   
+    {    
+        print $indent . "$step_index:Fetching seed species..\n"; ++$step_index; 
+ 
+        # loop over species in species list
+        foreach my $species ( @{$model->SpeciesList->Array} )
+        {
+            my $sg   = $species->SpeciesGraph;
+            my $conc = $species->Concentration;
+        
+            # check if this is isomorphic to any of our populations
+            my $is_pop = 0;
+            foreach my $pop ( @{$model->PopulationList->List} )
+            {
+                if ( SpeciesGraph::isomorphicTo($species->SpeciesGraph, $pop->SpeciesGraph) )
+                {   # add the population instead of the speciesGraph
+                    my $sg_copy = $pop->Population->copy();
+                    $sg_copy->relinkCompartments( $hybrid_model->CompartmentList );
+                    $slist_new->add( $sg_copy, $species->Concentration );
+                    $is_pop = 1;
+                    if ( $options->{verbose} )
+                    {
+                        print $indent.$indent
+                            . sprintf "replaced species %s with population %s.\n", $sg->toString(), $sg_copy->toString();
+                    }
+                    last;
+                }
+            }
+            unless ($is_pop)
+            {   # this isn't a population, so add SpeciesGraph directly.
+                my $sg_copy = $species->SpeciesGraph->copy();
+                $sg_copy->relinkCompartments( $hybrid_model->CompartmentList );
+                $slist_new->add( $sg_copy, $species->Concentration );
+            }
+        }
+        print $indent . sprintf "  ..found %d seed species.\n", scalar @{$slist_new->Array};    
+    }
+
+    
+    # Add population species to seed species
+    {
+        print $indent . "$step_index:Adding populations with zero counts to seed species..\n"; ++$step_index;     
+        my $zero_pops = 0;
+        foreach my $pop ( @{$model->PopulationList->List} )
+        {
+            my ($sp) = $slist_new->lookup( $pop->Population );
+            unless ( $sp )
+            {
+                my $sg_copy = $pop->Population->copy();
+                $sg_copy->relinkCompartments( $hybrid_model->CompartmentList );  
+                $slist_new->add( $sg_copy, 0 );
+                ++$zero_pops;
+            }
+        }
+        print $indent . sprintf "  ..added %d populations to seed species list.\n", $zero_pops;      
+    }
+            
+
+    # Copy the observables and add matches to populations (also register observable names in parameter list)
+    my $obslist_new = [];
+    $hybrid_model->Observables( $obslist_new );
+    {
+        print $indent . "$step_index:Fetching observables and adding population matches..\n"; ++$step_index;         
+        # loop over observables
+        foreach my $obs ( @{$model->Observables} )
+        {
+            my $obs_copy = $obs->copy();
+            $obs_copy->relinkCompartments( $hybrid_model->CompartmentList );
+            push @{$obslist_new}, $obs_copy;
+        
+            # get a parameter that points to this observable
+            if ( $plist_new->set( $obs_copy->Name, '0', 1, "Observable", $obs_copy) )
+            {
+                  my $name = $obs_copy->Name;
+                return "Observable name $name clashes with previously defined Observable or Parameter";
+            }
+      
+            # find populations to add to observable
+            my @add_patterns = ();
+            foreach my $pop ( @{$model->PopulationList->List} )
+            {
+                my $matches = $obs_copy->match( $pop->SpeciesGraph );
+            
+                if ($matches)
+                {   
+                    my $ii = 0;
+                    while ( $ii < $matches )
+                    {
+                        push @add_patterns, $pop->Population->copy()->relinkCompartments( $hybrid_model->CompartmentList );
+                        ++$ii
+                    }
+                    if ( $options->{verbose} )
+                    {
+                        print $indent.$indent . sprintf "observable '%s':  +%d match%s to %s.\n",
+                                                        $obs_copy->Name, $matches, ($matches>1 ? 'es' : ''), $pop->Population->toString();
+                    }
+                }
+            }      
+            push @{$obs_copy->Patterns}, @add_patterns;      
+        }
+        print $indent . sprintf "  ..found %d observables.\n", scalar @{$obslist_new};
+    }
+    
+    
+    # Copy functions
+    {
+        print $indent . "$step_index:Fetching functions.. "; ++$step_index;     
+        my $fcn_copies = $model->ParamList->copyFunctions();
+        foreach my $fcn ( @$fcn_copies )
+        {
+            $hybrid_model->ParamList->set( $fcn->Name, $fcn->Expr, 0, 'Function', $fcn );
+        }
+        print sprintf "found %d functions.\n", scalar @{$fcn_copies};
+    }
+   
+
+    # Expand rules
+    my $rxnrules_new = [];
+    $hybrid_model->RxnRules( $rxnrules_new );
+    {
+        print $indent . "$step_index:Expanding rules with respect to population objects..\n"; ++$step_index;   
+    
+        # get the species graphs corresponding to each population
+        my $pop_species = [];
+        foreach my $pop ( @{$model->PopulationList->List} )
+        {   push @$pop_species, $pop->SpeciesGraph;   }
+        my $n_popspec = scalar @$pop_species;
+    
+        # loop over rules
+        my $rule_count = 0;
+        foreach my $rset ( @{$model->RxnRules} )
+        {
+            # NOTE: each element of @RxnRules is an array of rules.
+            #  If a rule is unidirectional, then the array has a single element.
+            #  If a rule is bidirectional, then the array has two elements (forward and reverse)    
+            foreach my $rr (@$rset)
+            {    
+                # first copy the rule so we don't mess with the orginal model
+                my $rr_copy = $rr->copy();
+                $rr_copy->resetLabels();
+            
+                # apply rule to population species
+                my $child_rule_list = $rr_copy->expandRule(  $pop_species, $model, $hybrid_model, $options );
+                foreach my $child_rule ( @$child_rule_list )
+                {
+                    push @$rxnrules_new, [$child_rule];
+                }
+                if ( $options->{verbose} )
+                {
+                    print $indent.$indent . sprintf "Rule '%s': expanded to %d child rule%s.\n",
+                                                    $rr_copy->Name, scalar @$child_rule_list, ((scalar @$child_rule_list > 1)?'s':'');
+                }
+                ++$rule_count;
+            }
+        }
+        print $indent . sprintf "  ..finished processing %d reaction rules.\n", $rule_count;
+    }
+
+
+    # Add population maps to the list of rules
+    {
+        print $indent . "$step_index:Fetching population maps.. "; ++$step_index;
+        foreach my $pop ( @{$model->PopulationList->List} )
+        {
+            # write rule as string
+            my $rr_string = $pop->MappingRule->toString();
+            # remove the linebreak
+            $rr_string =~ s/\\\s//;
+            # parse string to create "copy" of rule
+            my ($rrs, $err) = RxnRule::newRxnRule( $rr_string, $hybrid_model );
+            push @$rxnrules_new, $rrs;
+        }
+        print sprintf "found %d maps.\n", scalar @{$model->PopulationList->List};
+    }
+
+
+    # create empty RxnList
+    print $indent . "$step_index:Creating empty reaction list.\n"; ++$step_index;        
+    my $rxnlist_new = RxnList::new();
+    $hybrid_model->RxnList( $rxnlist_new );
+    
+
+    # Print hybrid model to file
+    my $FH;
+    print $indent . "$step_index:Attempting to write hybrid BNGL.. "; ++$step_index;        
+    unless ( open $FH, '>', $modelfile ) {  return "Couldn't write to $modelfile: $!\n";  }
+
+    print $FH $hybrid_model->writeBNGL( {'format'=>'bngl', 'include_model'=>1,'include_network'=>0,
+                                         'pretty_formatting'=>1,'evaluate_expressions'=>0 } );
+    # writing actions!
+    if ( @{$options->{actions}} )
+    {
+        my $action_string = "\n\n## model actions ##\n";
+        foreach my $action ( @{$options->{actions}} )
+        {
+            $action_string .= "$action\n";
+        }
+        $action_string .= "\n";
+        print $FH $action_string;
+    }
+    close $FH;
+    
+    
+    print "done.\n";
+    print "Wrote hybrid model to file $modelfile.\n";
+    
+    
+    if ( $options->{execute} )
+    {   # execute actions
+        $BNGModel::GLOBAL_MODEL = $hybrid_model;
+        my $errors = [];
+        foreach my $action ( @{$options->{actions}} )
+        {
+            my $action_string = "\$hybrid_model->$action";
+            my $err = eval "$action_string";
+            if ($@)   {  warn $@;  }
+            if ($err) {  push @$errors, $err;  }
+        }
+        $BNGModel::GLOBAL_MODEL = $model;
+        if (@$errors) {  return join "\n", $errors;  }
+    }
+    
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+sub bifurcate
+{
+	my $model = shift @_;
+    my $params = @_ ? shift @_ : {};
+    
+    my @scanfiles = ();
+    my ($i,$j,$err);
+    
+    # don't reset concentrations after each run
+    $params->{reset_conc} = 0;
+    
+    # update user
+    printf "ACTION: bifurcate(par: %s, min: %s, max: %s, n_pts: %s, log: %s)\n", 
+    		(exists $params->{parameter}  ? $params->{parameter}  : "UNKNOWN"),
+    		(exists $params->{par_min}    ? $params->{par_min}    : "UNKNOWN"),
+    		(exists $params->{par_max}    ? $params->{par_max}    : "UNKNOWN"),
+    		(exists $params->{n_scan_pts} ? $params->{n_scan_pts} : "UNKNOWN"),
+    		(exists $params->{log_scale}  ? $params->{log_scale}  : 0);
+    		    
+    # forward scan
+    if (exists $params->{suffix}){ $params->{suffix} .= "_forward"; }
+    else{ $params->{suffix} = "forward"; }
+    $err = $model->parameter_scan( $params );
+    if ($err){ return $err }
+    push @scanfiles, $params->{scanfile}; # 'outfile' param set in parameter_scan
+    
+    # backwards scan
+    $params->{suffix} =~ s/forward/backward/;
+    my $par_min = $params->{par_min};
+    $params->{par_min} = $params->{par_max};
+    $params->{par_max} = $par_min;
+    $err = $model->parameter_scan( $params );
+    if ($err){ return $err }
+    push @scanfiles, $params->{scanfile}; # 'outfile' param set in parameter_scan
+    
+    # extract forward scan data
+    my @forward;
+    open FILE, $scanfiles[0] or die "Couldn't open file: $!"; 
+    my $line = <FILE>; # first line
+    chomp $line;
+    $line =~ s/^\s*#\s+//; # remove leading # and whitespace
+    my @header = split('\s+',$line); # scan param + observable names
+    $i = 0;
+	while ($line = <FILE>){
+		chomp $line;
+		$line =~ s/^\s*//; # remove leading whitespace
+		my @tmp = split('\s+',$line);
+		for ($j=0;$j < scalar(@tmp);$j++){
+			$forward[$i][$j] = $tmp[$j];
+		}
+		$i++;
+	}
+	close FILE;
+	
+	# extract backward scan data
+	my @backward;
+	open FILE, $scanfiles[1] or die "Couldn't open file: $!"; 
+    $line = <FILE>; # first line
+    $i = 0;
+	while ($line = <FILE>){
+		chomp $line;
+		$line =~ s/^\s*//; # remove leading whitespace
+		my @tmp = split('\s+',$line);
+		for ($j=0;$j < scalar(@tmp);$j++){
+			$backward[$i][$j] = $tmp[$j];
+		}
+		$i++;
+	}
+	close FILE;
+
+	# generate one output file for each observable
+    my $prefix = $scanfiles[0];
+    $prefix =~ s/_forward.scan$/_bifurcation_/;
+    for (my $j=1;$j < scalar(@header);$j++){
+    		open FILE, '>', ($prefix . $header[$j] . ".scan") or die "Couldn't open file: $!";
+		printf FILE "# %+14s %+16s %+16s\n",$header[0],"$header[$j]_fwd","$header[$j]_bwd";
+		for (my $i=0;$i < scalar(@forward);$i++){
+			printf FILE "%16.8e %16.8e %16.8e\n",$forward[$i][0],$forward[$i][$j],$backward[scalar(@forward)-1-$i][$j];
+		}
+		close FILE;
+    }
+	
+	# delete scan files and return
+    unlink @scanfiles;
+	return;
+}
+
+
+
+###
+###
+###
+
+
+sub parameter_scan
+{
+    my $model = shift @_;
+    my $params = @_ ? shift @_ : {};
+
+    # define default params
+    my $default_params = {  'prefix'   	=> $model->getOutputPrefix(),
+                            'log_scale'	=> 0,
+                            'reset_conc' => 1
+                         };
+
+    # copy default values for undefined keys
+    while ( my ($key, $val) = each %$default_params )
+    {
+        unless ( defined $params->{$key} )
+        {   $params->{$key} = $val;   }
+    }
+
+	# If resetting concentrations, don't need to read in final state
+	# (important for NFsim simulations, where read can be expensive)
+	if ( $params->{'reset_conc'} ){
+		$params->{'get_final_state'} = 0;
+	}
+    
+    # Output prefix
+   	$params->{prefix} = $model->getOutputPrefix($params->{prefix});
+
+    # check for required parameters
+    unless ( defined $params->{parameter} )
+    {   return "Error in parameter_scan: 'parameter' is not defined.";   }
+
+	unless ( defined $params->{par_scan_vals} ){
+		
+	    unless ( defined $params->{par_min} )
+	    {   return "Error in parameter_scan: 'par_min' must be defined if 'par_scan_vals' is not.";   }
+	
+	    unless ( defined $params->{par_max} )
+	    {   return "Error in parameter_scan: 'par_max' must be defined if 'par_scan_vals' is not.";   }
+	    
+	    unless ( defined $params->{n_scan_pts} )
+	    {   return "Error in parameter_scan: 'n_scan_pts' must be defined if 'par_scan_vals' is not.";   }
+	    
+	    if ($params->{par_max} == $params->{par_min}){
+		    	if ($params->{n_scan_pts} < 1){
+		    		return "Error in parameter_scan: 'n_scan_pts' must be >= 1 if 'par_max' = 'par_min'.";
+		    	}
+	    }
+	    elsif ($params->{n_scan_pts} <= 1){
+		    	return "Error in parameter_scan: 'n_scan_pts' must be > 1 if 'par_max' != 'par_min'.";
+	    }
+	}
+
+	# defined min/max takes precedence over par_scan_vals
+	if ( defined $params->{par_min} and defined $params->{par_max} and defined $params->{n_scan_pts} ){
+		# define parameter scan range
+	    my $par_min = $params->{log_scale} ? log $params->{par_min} : $params->{par_min};
+	    my $par_max = $params->{log_scale} ? log $params->{par_max} : $params->{par_max};
+	    my $delta = ($par_max - $par_min) / ($params->{n_scan_pts} - 1); # note that this may be negative if par_max < par_min (not a problem)
+		
+		# add parameter values to 'par_scan_vals'
+		$params->{par_scan_vals} = ();
+		for ( my $k = 0;  $k < $params->{n_scan_pts};  ++$k ){
+			my $par_value = $par_min + $k*$delta;
+	        if ( $params->{log_scale} )
+	        {   $par_value = exp $par_value;   }
+	        push @{$params->{par_scan_vals}}, $par_value;
+		}
+	}
+	
+	# array of parameter scan values
+	my @par_scan_vals = @{$params->{par_scan_vals}};
+
+    # update user
+#    printf "ACTION: parameter_scan(par: $params->{parameter}, min: $params->{par_min}, max: $params->{par_max}, ";
+#    printf "n_pts: $params->{n_scan_pts}, log: $params->{log_scale})\n";
+	printf "ACTION: parameter_scan( )";
+
+    # define basename for scan results
+    my $basename = $params->{prefix};
+    if ( $params->{suffix} )
+    {   $basename .= "_" . $params->{suffix};   }
+    else
+    {   $basename .= "_" . $params->{parameter};      }
+
+    # define working directory for simulation data
+    my $workdir = $basename;
+    # define output file for parameter scan results
+    my $outfile = $basename . ".scan";
+    # define file prefix for output results
+    my ($vol, $dir, $file_prefix) = File::Spec->splitpath( $basename );
+
+    # create working directory
+    if (-d $workdir)
+    {   # delete working directory
+        my $all_files = File::Spec->catfile( ($workdir), '*' );
+        unlink <$all_files>;
+        #system "rm -r $workdir";
+    }
+    else
+    {   mkdir $workdir;   }
+
+    # remember concentrations!
+    $model->saveConcentrations("SCAN");
+
+    # loop over scan points
+	for ( my $k = 0;  $k < @par_scan_vals;  ++$k )
+    {
+        # define prefix
+        my $local_prefix = File::Spec->catfile( ($workdir), sprintf("%s_%05d", $file_prefix, $k+1) );
+    	
+        # define parameter value
+        my $par_value = $par_scan_vals[$k];
+
+        # set parameter
+        $model->setParameter( $params->{parameter}, $par_value );
+
+        # reset concentrations
+        if ( $params->{reset_conc} ){
+        		$model->resetConcentrations("SCAN");
+        }
+
+        # define local params
+        my $local_params;
+        %$local_params = %$params;
+        $local_params->{prefix} = $local_prefix;
+        delete $local_params->{suffix};
+
+        # run simulation
+        my $err = $model->simulate( $local_params );
+        if ( $err )
+        {   # return error message
+            $err = "Error in parameter_scan (step " . ($k+1) . "): $err";
+            return $err;
+        }   
+    }
+
+    # recover concentrations
+    if ( $params->{reset_conc} ){
+    		$model->resetConcentrations("SCAN");
+    }
+
+    # Extract last timepoint from each simulation and write to outfile
+    my $ofh;
+    unless ( open $ofh, '>', $outfile )
+    {   return "Error in parameter_scan: problem opening parameter scan output file $outfile";   }
+
+    for ( my $k = 0;  $k < @par_scan_vals;  ++$k )
+    {
+        my $par_value = $par_scan_vals[$k];
+
+        # Get data from gdat file
+        my $data_file = File::Spec->catfile( ($workdir), sprintf("%s_%05d.gdat", $file_prefix, $k+1) );
+        print "Extracting observable trajectory from $data_file\n";
+        my $ifh;
+        unless ( open $ifh,'<', $data_file )
+        {   return "Error in parameter_scan: problem opening observable file $data_file";   }
+
+        # write header
+        if ( $k == 0 )
+        {
+            my $headline = <$ifh>;
+            $headline =~ s/^\s*\#//;
+            my @headers = split ' ', $headline;
+            shift @headers;
+            printf $ofh "# %+14s", $params->{parameter};
+            foreach my $header (@headers)
+            {
+                printf $ofh " %+16s", $header;
+            }
+            print $ofh "\n";
+        }
+
+        # get last line
+        my $lastline;
+        while ( my $linein = <$ifh> )
+        {   $lastline = $linein;   }
+        
+        # close input file
+        close $ifh;
+
+        # extract data and write to output file
+        my @data = split ' ', $lastline;
+        my $time = shift @data;
+        printf $ofh "%16.8e", $par_value;
+        foreach my $data ( @data )
+        {
+            printf $ofh " %16.8e", $data;
+        }
+        print $ofh "\n";
+    }  
+    close $ofh;
+
+    # return without error
+    $params->{scanfile} = $outfile; # in case another method needs this (e.g. 'bifurcate')
+	return;
+}
+
+
+
+###
+###
+###
+
+
+
+sub LinearParameterSensitivity
+{
+    #This function will perform a brute force linear sensitivity analysis
+    #bumping one parameter at a time according to a user specified bump
+    #For each parameter, simulations are saved as:
+    #'netfile_paramname_suffix.(c)(g)dat', where netfile is the .net model file
+    #and paramname is the bumped parameter name, and c/gdat files have meaning as normal
+
+    ######################
+    # TODO: NOT IMPLEMENTED YET!!
+    #Additional files are written containing the raw sensitivity coefficients
+    #for each parameter bump
+    #format: 'netfile_paramname_suffix.(c)(g)sc'
+    #going across rows is increasing time
+    #going down columns is increasing species/observable index
+    #first row is time
+    #first column is species/observable index
+    ######################
+
+    #Starting time assumed to be 0
+
+    #Input Hash Elements:
+    #REQUIRED PARAMETERS
+    #net_file:  the base .net model to work with; string;
+    #t_end:  the end simulation time; real;
+    #OPTIONAL PARAMETERS
+    #bump:  the percentage parameter bump; real; default 5%
+    #inp_ppert:  model input parameter perturbations; hash{pnames=>array,pvalues=>array};
+    #default empty
+    #inp_cpert:  model input concentration perturbations; hash{cnames=>array,cvalues=>array};
+    #default empty
+    #stochast:  simulate_ssa (1) or simulate_ode (0) is used; boolean; default 0 (ode)
+    #CANNOT HANDLE simulate_ssa CURRENTLY
+    #sparse:    use sparse methods for integration?; boolean; 1
+    #atol:  absolute tolerance for simulate_ode; real; 1e-8
+    #rtol:  relative tolerance for simulate_ode; real; 1e-8
+    #init_equil:  equilibrate the base .net model; boolean; default 1 (true)
+    #re_equil:  equilibrate after each parameter bump but before simulation; boolean; default 1 (true)
+    #n_steps:  the number of evenly spaced time points for sensitivity measures; integer;
+    #default 50
+    #suffix:  added to end of filename before extension; string; default ""
+
+    #Variable Declaration and Initialization
+    use strict;
+    my $model;     #the BNG model
+    my %params;    #the input parameter hash table
+    my $net_file = "";
+    my %inp_pert;
+    my $t_end;
+    my %readFileinputs;
+    my %simodeinputs;
+    my $simname;
+    my $basemodel = BNGModel->new();
+    my $plist;
+    my $param_name;
+    my $param_value;
+    my $new_param_value;
+    my $pperts;
+    my $cperts;
+    my $pert_names;
+    my $pert_values;
+#    my $pert_names;
+#    my $pert_values;
+    my $newbumpmodel = BNGModel->new();
+    my $foo;
+    my $i;
+
+    #Initialize model and input parameters
+
+    $model  = shift;
+    my $params = shift;
+
+    #Required params
+    if ( defined( $params->{net_file} ) ) {
+        $net_file = $params->{net_file};
+    }
+    else {
+        $net_file = $model->getOutputPrefix();
+    }
+    if ( defined( $params->{t_end} ) ) {
+        $t_end = $params->{t_end};
+    }
+    else {
+        return ("t_end not defined");
+    }
+
+    #Optional params
+    my $bump     = ( defined( $params->{bump} ) )     ? $params->{bump}     : 5;
+    my $stochast = ( defined( $params->{stochast} ) ) ? $params->{stochast} : 0;
+    my $sparse   = ( defined( $params->{sparse} ) )   ? $params->{sparse}   : 1;
+    my $atol = ( defined( $params->{atol} ) ) ? $params->{atol} : 1e-8;
+    my $rtol = ( defined( $params->{rtol} ) ) ? $params->{rtol} : 1e-8;
+    my $init_equil =
+      ( defined( $params->{init_equil} ) ) ? $params->{init_equil} : 1;
+    my $t_equil = ( defined( $params->{t_equil} ) ) ? $params->{t_equil} : 1e6;
+    my $re_equil = ( defined( $params->{re_equil} ) ) ? $params->{re_equil} : 1;
+    my $n_steps = ( defined( $params->{n_steps} ) ) ? $params->{n_steps} : 50;
+    my $suffix  = ( defined( $params->{suffix} ) )  ? $params->{suffix}  : "";
+
+    #Run base case simulation
+    %readFileinputs = ( file => "$net_file.net" );
+    $basemodel->readFile( \%readFileinputs );
+
+    #if initial equilibration is required
+    if ($init_equil) {
+        $simname      = "_baseequil_";
+        %simodeinputs = (
+            prefix       => "$net_file$simname$suffix",
+            t_end        => $t_equil,
+            sparse       => $sparse,
+            n_steps      => $n_steps,
+            steady_state => 1,
+            atol         => $atol,
+            rtol         => $rtol
+        );
+        $basemodel->simulate_ode( \%simodeinputs );
+    }
+    $simname      = "_basecase_";
+    %simodeinputs = (
+        prefix       => "$net_file$simname$suffix",
+        t_end        => $t_end,
+        sparse       => $sparse,
+        n_steps      => $n_steps,
+        steady_state => 0,
+        atol         => $atol,
+        rtol         => $rtol
+    );
+
+    #Implement input perturbations
+    if ( defined( $params->{inp_ppert} ) ) {
+        $pperts      = $params->{inp_ppert};
+        $pert_names  = $pperts->{pnames};
+        $pert_values = $pperts->{pvalues};
+        $i           = 0;
+        while ( $pert_names->[$i] ) {
+            $param_name  = $pert_names->[$i];
+            $param_value = $pert_values->[$i];
+            $basemodel->setParameter( $param_name, $param_value );
+            $i = $i + 1;
+        }
+    }
+    if ( defined( $params->{inp_cpert} ) ) {
+        $cperts      = $params->{inp_cpert};
+        $pert_names  = $cperts->{cnames};
+        $pert_values = $cperts->{cvalues};
+        $i           = 0;
+        while ( $pert_names->[$i] ) {
+            $param_name  = $pert_names->[$i];
+            $param_value = $pert_values->[$i];
+            $basemodel->setConcentration( $param_name, $param_value );
+            $i = $i + 1;
+        }
+    }
+    $basemodel->simulate_ode( \%simodeinputs );
+
+    $plist = $basemodel->ParamList;
+
+    #For every parameter in the model
+    foreach my $model_param ( @{ $plist->Array } )
+    {
+        $param_name      = $model_param->Name;
+        $param_value     = $model_param->evaluate();
+        $new_param_value = $param_value * ( 1 + $bump / 100 );
+
+        #Get fresh model and bump parameter
+        $newbumpmodel->readFile( \%readFileinputs );
+        $newbumpmodel->setParameter( $param_name, $new_param_value );
+
+        #Reequilibrate
+        if ($re_equil) {
+            $simname = "equil_${param_name}";
+            %simodeinputs = ( prefix       => "${net_file}_${simname}_${suffix}",
+                              t_end        => $t_equil,
+                              sparse       => $sparse,
+                              n_steps      => $n_steps,
+                              steady_state => 1,
+                              atol         => $atol,
+                              rtol         => $rtol
+                            );
+            $newbumpmodel->simulate_ode( \%simodeinputs );
+        }
+
+        #Implement input and run simulation
+        $simname = $param_name;
+        %simodeinputs = (
+            prefix       => "${net_file}_${simname}_${suffix}",
+            t_end        => $t_end,
+            sparse       => $sparse,
+            n_steps      => $n_steps,
+            steady_state => 0,
+            atol         => $atol,
+            rtol         => $rtol
+        );
+        if ( defined( $params->{inp_ppert} ) ) {
+            $pperts      = $params->{inp_ppert};
+            $pert_names  = $pperts->{pnames};
+            $pert_values = $pperts->{pvalues};
+            $i           = 0;
+            while ( $pert_names->[$i] ) {
+                $param_name  = $pert_names->[$i];
+                $param_value = $pert_values->[$i];
+                $newbumpmodel->setParameter( $param_name, $param_value );
+                $i = $i + 1;
+            }
+        }
+        if ( defined( $params->{inp_cpert} ) ) {
+            $cperts      = $params->{inp_cpert};
+            $pert_names  = $cperts->{cnames};
+            $pert_values = $cperts->{cvalues};
+            $i           = 0;
+            while ( $pert_names->[$i] ) {
+                $param_name  = $pert_names->[$i];
+                $param_value = $pert_values->[$i];
+                $newbumpmodel->setConcentration( $param_name, $param_value );
+                $i = $i + 1;
+            }
+        }
+        $newbumpmodel->simulate_ode( \%simodeinputs );
+
+        #Evaluate sensitivities and write to file
+
+        #Get ready for next bump
+        $newbumpmodel = BNGModel->new();
+    }
+
+  
+}
+
+###
+###
+###
+
+1;

data/bionetgen/Perl2/BNGMessages.pm

@@ -0,0 +1,46 @@
+package BNGMessages;
+use strict;
+use warnings;
+
+use Class::Struct;
+
+use Exporter 'import';
+our @EXPORT_OK = qw(error warning message);
+
+struct BNGMessages => {
+  errors=>    '%',
+  messages=>	  '%',
+  warnings=>	  '%',
+  lasterror=> '$'	      
+};
+
+#begin error
+sub error{
+    my @msgs= @_;
+    print STDERR "ABORT: ";
+    for my $msg (@msgs){
+	print STDERR $msg,"\n";
+    }
+    exit(1);	
+}
+#end error
+
+#begin warning
+sub warning{
+    my @msgs= @_;
+    print STDOUT "WARNING: ";
+    for my $msg (@msgs){
+	print STDOUT $msg,"\n";
+    }
+}
+#end warning
+
+#begin message
+sub message{
+    my @msgs= @_;
+    for my $msg (@msgs){
+	print STDOUT $msg unless (BNGOptions::GetBNGOptions()->config->{silent});
+    }
+}
+#end message
+1;

data/bionetgen/Perl2/BNGModel.pm

@@ -0,0 +1,2614 @@
+package BNGModel;
+
+#    BioNetGen : rule-based modeling language and simulation platform
+#
+#                  Copyright (C) 2006,2009,2012,2014 by
+#
+#      James R. Faeder    (faeder at pitt dot edu)
+#      Justin S. Hogg     (justinshogg at gmail dot com)
+#      Leonard A. Harris  (lh64 at cornell dot com)
+#      John A. P. Sekar	  (johnarul dot sekar at gmail dot com)
+#      Jose Juan Tapia    (jjtapia at gmail dot com)
+#      Arshi Arora
+#      Dipak Barua
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# pragmas
+use strict;
+use warnings;
+no warnings 'redefine';
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+use File::Spec;
+use File::Spec::Win32;
+use POSIX ("floor", "ceil");
+use Scalar::Util ("looks_like_number");
+use Config;
+
+use Cwd;
+
+# BNGOutput contains BNGModel methods related to third-party output
+#  e.g. writeXML, writeSBML, writeMfile, writeMexfile, toSSC...
+#  Note that .NET and .BNGL writer methods are contained in THIS file.
+use BNGOutput;
+
+# BNGAction contains BNGModel action methods
+#  e.g. simulate, simulate_pla, simulate_nf, parameter_scan, generate_hybrid_model...
+#  Note that some core actions are contained here: generate_network, setParameter, etc.
+use BNGAction;
+
+# BNG Modules
+use Cache;
+use BNGUtils;
+use MoleculeTypesList;
+use ParamList;
+use Function;
+use Compartment;
+use CompartmentList;
+use SpeciesList;
+use RxnRule;
+use EnergyPattern;
+use Observable;
+use PopulationList;
+
+#Variables that determine whether the network has been generated
+my $NetFlag = 0; 
+
+# A place to store a reference to the current active model.
+# Useful when other classes need to find the model.
+$BNGModel::GLOBAL_MODEL = undef;
+
+# Global package variables
+my $NO_EXEC = 0;  # Prevents execution of functions to allow file syntax checking
+my $HAVE_PS = 0;  # Set to 0 for MS Windows systems with no ps command - disables
+                  #  reporting of memory usage at each iteration of network generation
+
+# Structure containing BioNetGen model data
+struct BNGModel =>
+{
+    Name                => '$',
+    Time                => '$',
+    Concentrations      => '@',
+    MoleculeTypesList   => 'MoleculeTypesList',
+    SpeciesList         => 'SpeciesList',
+    SeedSpeciesList     => 'SpeciesList',
+    RxnList             => 'RxnList',
+    RxnRules            => '@',
+    ParamList           => 'ParamList',
+    Observables         => '@',
+    EnergyPatterns      => '@',                  # for energy BNG only: Holds a list of energy patterns
+    CompartmentList     => 'CompartmentList',    # list of reaction compartments (volumes and surfaces)
+    PopulationTypesList => 'MoleculeTypesList',  # list of population molecule types
+    PopulationList      => 'PopulationList',     # list of population species
+    SubstanceUnits      => '$',
+    UpdateNet           => '$',  # This variable is set to force update of NET file before simulation.
+    Version             => '$',  # Indicates set of version requirements- output to BNGL and NET files
+    Options             => '%',  # Options used to control behavior of model and associated methods
+    Params              => '%',  # run-time parameters (not to be saved)
+    ParameterCache      => 'Cache',   
+    ConcentrationCache  => 'Cache',
+	VizGraphs			=> '$',
+};
+
+
+
+###
+###
+###
+
+
+
+# Initialize BNGModel data structures
+sub initialize
+{
+    my $model = shift @_;
+
+    $model->Name('');
+    $model->Version('');
+    $model->Time(0);
+    $model->UpdateNet(0);
+    $model->ParamList( ParamList->new() );
+    $model->MoleculeTypesList( MoleculeTypesList->new('StrictTyping'=>0) );
+    $model->PopulationTypesList( MoleculeTypesList->new('StrictTyping'=>0) );
+    $model->PopulationList( PopulationList->new() );
+    $model->CompartmentList( CompartmentList->new('Used'=>0) );
+    $model->SpeciesList( SpeciesList->new() );
+    $model->RxnList( RxnList->new('SpeciesList'=>$model->SpeciesList) );
+    $model->SubstanceUnits('');
+    $model->ConcentrationCache( Cache->new() );
+    $model->ParameterCache( Cache->new() );
+}
+
+
+# read Model from file
+# $err = $model->readModel({file=>FILENAME}) 
+sub readModel
+{
+    my $model = shift @_;
+    my $user_args = @_ ? shift @_ : {};
+
+    my %args = ();
+    # copy user_params into pass_params structures
+    while ( my ($key,$val) = each %$user_args )
+    {   $args{$key} = $val;    }
+
+    # writeFile will generate the output
+    return $model->readFile( \%args );
+}
+
+
+# read Network from file
+# $err = $model->readModel({file=>FILENAME}) 
+sub readNetwork
+{
+    my $model = shift @_;
+    my $user_args = @_ ? shift @_ : {};
+
+    my %args = ();
+    # copy user_params into pass_params structures
+    while ( my ($key,$val) = each %$user_args )
+    {   $args{$key} = $val;    }
+
+    # writeFile will generate the output
+    return $model->readFile( \%args );
+}
+
+sub readSBML
+{
+	my $model  = shift @_;
+	my $filepath = shift @_;
+	unless ( -e $filepath )
+    {   return 1, "Could not find '$filepath'";   }
+	my ($vol, $dir, $filename) = File::Spec->splitpath( $filepath );
+	$filename =~ s/\.xml//;
+	my $outfile = File::Spec->catpath('', $model->getOutputDir(), $filename.'.bngl');
+    my $user_args = @_ ? shift @_ : {};
+    
+    # Collect user arguments
+	my %args = ();
+    while ( my ($key,$val) = each %$user_args )
+    {   
+    		$args{$key} = $val;
+#    	printf "$key=>$val\n";
+    }
+    
+    # Find program and save path to directory
+    my $program;
+    unless ( $program = findExec("sbmlTranslator") )
+    {   return 1, "Could not find executable 'sbmlTranslator'";   }
+    ($vol, $dir, my $bin) = File::Spec->splitpath( $program );
+	my $bindir = File::Spec->catpath($vol, $dir);
+
+    # Begin writing command: start with 'program'
+    my $cmd = $program;
+	$cmd .= ' -i "' . $filepath .'"';
+	$cmd .= ' -o "' . $outfile . '"';
+	if ($args{"atomize"}){
+		$cmd .= ' -a';
+	}
+	
+	# Run the translator
+	printf "SBML translation: $cmd\n";
+	system($cmd);
+	
+	# Return full path to generated BNGL file
+	return 0, $outfile
+}
+
+
+# Read bionetgen data in blocks enclosed by begin param end param
+# lines.  Prevents overwriting of variables possible with eval.
+#
+# To do:
+# 1.  Receive a valid list of parameter names to be read
+# 2.  Check syntax of lines- this is currently done when parameter is
+#     handled.  Some basic checks could be done here.
+#
+# Lines between begin and end commands are put into arrays with the name given
+#  by the block name
+{
+
+    my ($filename, $line_number, $file_data);
+    my (@filename_stack, @line_number_stack, @file_data_stack, @params_stack);
+    my $level = -1;
+    my $MAX_LEVEL = 10;    # Sets maximum level of allowed recursion
+    my %bngdata;
+    my $t_start;
+    my $stdout_handle;
+
+    sub readFile
+    {
+        # get arguments
+        my $model  = shift @_;
+        my $params = @_ ? shift @_ : {};
+
+		# supported blocks
+		my %blocks = (
+			'parameters' => 1,
+			'compartments' => 1,
+			'molecule types' => 1,
+			'species' => 1,
+			'seed species' => 1,
+			'observables' => 1,
+			'functions' => 1,
+			'energy patterns' => 1,
+			'population types' => 1,
+			'population maps' => 1,
+			'reaction rules' => 1,
+			'reactions' => 1,
+			'groups' => 1,
+			'actions' => 1,
+		);
+
+		# user-specified list of blocks to read
+		if (exists $params->{blocks}){
+			my %tmp;
+			foreach my $block (@{$params->{blocks}}){
+				$tmp{$block} = 1;
+			}
+			foreach (keys %blocks){
+				unless (exists $tmp{$_}){
+					$blocks{$_} = 0;
+				}
+			}
+		}
+
+        # a place for error messages
+        my $err;
+
+        # get the filename
+        my $filename = exists $params->{file} ? $params->{file} : undef;
+        unless ( defined $filename )
+        {   # Filename argument is mandatory
+            $err = errgen( "'file' parameter is required for action readFile()" );
+            goto EXIT;
+        }
+        
+		# if file path is relative, change Unix path to Windows path, and vice versa,
+		# based on OS (improves cross-platform portability --LAH)
+		if ( not File::Spec::Win32->file_name_is_absolute( $filename ) ){
+			if ($Config{myarchname} =~ /MSWin32/)
+			{ $filename =~ s/\//\\/g; }
+			else
+			{ $filename =~ s/\\/\//g; }
+		}
+
+        # increment level
+        ++$level;
+        if ($level > $MAX_LEVEL)
+        {
+            $err = errgen( "Recursion level exceeds maximum of $MAX_LEVEL" );
+            goto EXIT;
+        }
+
+        # Top level stuff
+        if ($level==0)
+        {   
+            # get start time
+            $t_start = cpu_time(0);
+
+            # set model update flag
+            $model->UpdateNet(1);
+
+            # set model name
+            if ($model->Name eq '')
+            {
+                if ( $params->{basename} )
+                {   # set model name to basename
+                    $model->Name( $params->{basename} );
+                }
+                else
+                {   # determine model basename from filename
+                    my ($vol, $dir, $fn) = File::Spec->splitpath( $filename );
+					
+                    my $basename;
+                    # file = basename.ext
+                    if ( $fn =~ /^(.+)\.([^\.]+)$/ )
+                    {   $basename = $1;   }
+                    # file = basename
+                    elsif ( $fn =~ /^([^\.]+)$/ )
+                    {   $basename = $1;   }
+                    # file = ???
+                    else
+                    {   $basename = $fn;  }
+
+                    $model->Name($basename);
+                }
+            }
+
+            # set model parameters
+            $model->Params($params);
+
+            # set output directory
+            unless ( defined $model->Params->{output_dir} )
+            {   # default is current directory
+                $model->setOutputDir();
+            } 
+
+            # set up log file, if needed
+            if ( $model->Params->{logging} )
+            {  
+                # generate logfile name
+                my $logfilename = $model->getOutputPrefix() . ".log" ;
+                # remember where to find STDOUT
+                unless( open $stdout_handle, ">&STDOUT" )
+                {  $err = "Problem finding handle for STDOUT: $!";  goto EXIT;  }       
+                # redirect STDOUT to logfile
+                unless ( open STDOUT, '>', $logfilename )
+                {  $err = "Problem redirecting STDOUT to logfile: $!";;  goto EXIT;  }
+            }
+
+            # turn off output buffering on STDOUT
+            select STDOUT;  $| = 1;
+
+            # Say Hello to the user
+            printf "BioNetGen version %s\n", BNGversion();   
+        }
+        elsif ($level > 0)
+        {
+            # save state of previous level on stacks
+            push @filename_stack, $filename;
+            push @file_data_stack, $file_data;
+            push @line_number_stack, $line_number;
+            push @params_stack, $model->Params;
+
+            # inherit params from previous level
+            $model->Params( {%{$model->Params}} );
+            # overwrite any params that were explicitly changed
+            while ( my ($opt,$val) = each %$params )
+            {  $model->Params->{$opt} = $val;  }
+        }
+
+        # SBML translator
+		if ( $filename =~ /\.xml$/ )
+		{
+            if ( $model->Params->{no_atomizer} )
+            {
+                send_warning( "readFile(): BNG processing was halted. Attempted to import XML file with 'no-atomizer' flag activated.");
+                exit(0);
+            }
+			my $out;
+			($err, $out) = $model->readSBML($filename,$model->Params);
+			if ($err){
+				$err = $out;
+				goto EXIT;
+			}
+			$filename = $out
+			# Generated BNGL file will now be read in below
+		}
+		
+		# Read BNGL or NET file
+		if ( $filename =~ /\.bngl$/ || $filename =~ /\.net$/ )
+		{
+	        # Read BNG model data        
+	        print "Reading from file $filename (level $level)\n";
+	        unless( open FILE, '<', $filename )
+	        {   
+	        		unless (File::Spec->file_name_is_absolute( $filename )){
+	        			$filename = File::Spec->rel2abs( $filename );
+	        		}
+	            $err = "Couldn't read from file $filename: $!";
+	            goto EXIT;
+	        }
+	        # read all lines of the file into an array at $file_data
+	        $file_data = [<FILE>];
+	        # close file
+	        close FILE;
+	
+	
+	        # Read data from file into data hash
+	        $line_number = 0;
+	        my $begin_model = 0;
+	        my $in_model    = 1;
+	        while ( my $string = get_line() )
+	        {
+	            # chop leading spaces
+	            $string =~ s/^\s+//;
+	
+	            if ( $string =~ /^begin\s+model\s*$/ )
+	            {
+	                ++$begin_model;
+	                if ( $begin_model > 1 )
+	                {
+	                    $err = errgen("Only one model definition allowed per file");
+	                    goto EXIT;
+	                }
+	                $in_model = 1;
+	                next;
+	            }
+	            elsif ( $string =~ /^end\s+model\s*$/ )
+	            {
+	                unless ($in_model)
+	                {
+	                    $err = errgen("end model encountered without enclosing begin model");
+	                    goto EXIT;
+	                }
+	                $in_model = 0;
+	                next;
+	            }
+	
+	            # Process multi-line block
+	            if ( $string =~ s/^begin\s*// )
+	            {
+	                # get block name
+	                my $name = $string;
+	                # Remove trailing white space
+	                $name =~ s/\s*$//;
+	                # Remove repeated white space
+	                $name =~ s/\s+/ /g;
+	
+	                unless ($in_model or ($name eq 'actions'))
+	                {
+	                    $err = errgen("$name cannot be defined outside of a model");
+	                    goto EXIT;
+	                }
+	
+	                # Read block data
+	                my $block_dat;
+	                ( $block_dat, $err ) = read_block_array($name);
+	                if ($err) {  goto EXIT;  }
+#	                $bngdata{$name} = 1;
+	                
+	                # Move on if block has been suppressed by the user
+	                # (if the block name is not recognized, continue so an error will be thrown)
+					if (exists $blocks{$name} and $blocks{$name}==0) { next; }
+	
+	                ### Read Parameters Block
+	                if ( $name eq 'parameters' )
+	                {
+	                    # Read model parameters
+	                    my $plast = $model->ParamList->getNumParams();
+	                    my ($entry, $lno);
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        ($entry, $lno) = @$line;
+	                        $err = $model->ParamList->readString($entry);
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    # check parameter list
+	                    if ( $err = $model->ParamList->check() )
+	                    {
+	                        $err = errgen( $err, $lno );
+	                        goto EXIT;
+	                    }
+	                    # sort parameters
+	                    if ( $err = $model->ParamList->sort() )    
+	                    {
+	                        $err = errgen( $err, $lno );
+	                        goto EXIT;
+	                    }
+	                    # update user
+	                    printf "Read %d $name.\n", $model->ParamList->getNumParams() - $plast;
+	                }
+	
+	                    
+	                ### Read Functions Block
+	                elsif ( $name eq 'functions' )
+	                {
+	                    # Model functions
+	                    my $nread = 0;
+	                    my ($entry, $lno);
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        ($entry, $lno) = @{$line};
+	                        my $fun = Function->new();
+	                        $err = $fun->readString( $entry, $model );
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                        ++$nread;
+	                    }
+	                    
+	                    # check paramlist for unresolved dependency, etc
+	                    #   GIVE warning here, don't terminate!
+	                    if ( $err = $model->ParamList->check() )
+	                    {
+	                        $err = errgen( $err, $lno );
+	                        print "Warning: $err\n"
+	                             ."  (if parameter is defined in a subsequent block,\n"
+	                             ."  then this warning can be safely ignored.)\n";
+	                    }                            
+	                    # update user
+	                    printf "Read %d ${name}.\n", $nread;
+	                }
+	                
+	    
+	                ### Read Molecule Types block
+	                elsif ( $name eq 'molecule types' )
+	                {
+	                    # read MoleculeTypes
+	                    $model->MoleculeTypesList->StrictTyping(1);
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ( $entry, $lno ) = @$line;
+	                        $err = $model->MoleculeTypesList->readString($entry);
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    # update user
+	                    printf "Read %d molecule types.\n", $model->MoleculeTypesList->getNumMolTypes();
+	                }
+	
+	
+	                ### Read Population Types block
+	                elsif ( $name eq 'population types' )
+	                {
+	                    # read PopulationTypes
+	                    $model->PopulationTypesList->StrictTyping(1);
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ( $entry, $lno ) = @$line;
+	                        $err = $model->PopulationTypesList->readString($entry);
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    # update user
+	                    printf "Read %d population types.\n", $model->PopulationTypesList->getNumMolTypes();
+	                }
+	
+	
+	                ### Read Population Maps block
+	                elsif ( $name eq 'population maps' )
+	                {
+	                    unless ( $model->MoleculeTypesList->StrictTyping )
+	                    {
+	                        $err = errgen("A $name block cannot be defined unless molecule types are defined explicitly");
+	                        goto EXIT;        
+	                    }
+	                    # read Population Maps
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ($entry, $lno) = @$line;
+	                        $err = $model->PopulationList->readString($entry,$model);
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    # update user
+	                    printf "Read %d population maps.\n", $model->PopulationList->getNumPopulations;
+	                }
+	                
+	                    
+	                ### Read Compartments Block
+	                elsif ( $name eq 'compartments' )
+	                {	
+	                    # Read Compartments
+	                    my ($entry, $lno);
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        ($entry, $lno) = @$line;
+	                        $err = $model->CompartmentList->readString( $entry, $model->ParamList );
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    # validate compartments
+	                    if ( $err = $model->CompartmentList->validate() )
+	                    {
+	                        $err = errgen( $err, $lno );
+	                        goto EXIT;
+	                    }
+	                    if ($model->CompartmentList->getNumCompartments() > 0){
+	                    		# set flag to indicate compartments are being used
+	            				$model->CompartmentList->Used(1);
+	            				# update user
+	            				printf "Read %d compartments.\n", $model->CompartmentList->getNumCompartments;
+	                    }
+	                }
+	                
+	                    
+	                ### Read Species/Seed Species Block
+	                elsif ( ($name eq 'species') or ($name eq 'seed species') )
+	                {
+	                    # read Species
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ($entry, $lno) = @$line;
+	                        $err = $model->SpeciesList->readString( $entry, $model->ParamList,
+	                                                                $model->CompartmentList,
+	                                                                $model->MoleculeTypesList );
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }                            
+	                    }
+	                    # update user
+	                    printf "Read %d species.\n", $model->SpeciesList->getNumSpecies();
+	                }
+	                
+	
+	                ### Read Reaction Rules Block
+	                elsif ( $name eq 'reaction rules' )
+	                {
+	                		# Read reaction rules
+	                		my $nerr = 0;
+#						my $rrules = [];
+#	                    	$model->RxnRules( $rrules );
+	                    	my $rrules = $model->RxnRules;
+	                    	my $counter = 1;
+	                    	foreach my $line ( @$block_dat )
+	                    	{
+	                    		my ($entry, $lno) = @$line;
+	                        	# create new rule
+	                        	(my $rrs, $err) = RxnRule::newRxnRule( $entry, $model, $lno );
+	                        	if ($err)
+	                        	{   # some error encountered
+	                        		$err = errgen( $err, $lno );
+	                            	printf "ERROR: $err\n";
+	                            	++$nerr;
+	                        	}
+	                        	# check rule name (if given)
+	                        	elsif ( $rrs->[0]->Name ){
+	                            	foreach my $r (@$rrules){ # loop over all existing rules
+	                            		foreach my $x (@$r){  # consider forward and reverse (if exists) for existing rule (just to be safe)
+	                                		if ( $rrs->[0]->Name eq $x->Name ){ # duplicate rule name found
+											$err = "Duplicate rule name detected (\"" . $rrs->[0]->Name . "\").";
+											$err = errgen( $err, $lno );
+											printf "ERROR: $err\n";
+											++$nerr;
+											last;
+										}
+	                            		}
+								}
+	                        }
+	                        unless ($err)
+	                        {
+	                        		# rule is ok
+	                            push @$rrules, $rrs;
+
+	                            # give names, if not defined
+	                            unless ( $rrs->[0]->Name )
+	                            {   
+									#$rrs->[0]->Name( 'Rule' . scalar @$rrules );
+									my $rname = '_R' . $counter++;
+									# avoid duplicate names (just to be safe)
+									for (my $i=0; $i < @$rrules-1; $i++){
+										if ($rname eq @$rrules[$i]->[0]->Name){ # duplicate rule name
+											$rname = '_R' . $counter++;
+											$i = -1; # start over
+										}
+									}
+									$rrs->[0]->Name( $rname );
+	                            }
+	                            if ( @$rrs > 1 )
+	                            {
+	                                unless ($rrs->[1]->Name)
+	                                {   
+										#$rrs->[1]->Name( 'Rule' . scalar @$rrules . 'r' );
+										$rrs->[1]->Name( '_reverse_' . $rrs->[0]->Name);
+									}
+	                            }
+	                        }
+		                    if ($nerr)
+		                    {
+		                        $err = "Reaction rule list could not be read because of errors.";
+		                        goto EXIT;
+		                    }
+	                    	}
+	                    # update user
+	                    printf "Read %d reaction rule(s).\n", scalar @{$model->RxnRules};
+	                }
+	                
+	
+	                ### Read Reactions Block
+	                elsif ( $name eq 'reactions' )
+	                {
+	                    # Reactions (when reading NET file)
+	                    my $rlist = RxnList->new;
+	                    foreach my $line ( @{$block_dat} )
+	                    {
+	                        my ( $entry, $lno ) = @{$line};
+	                        $err = $rlist->readString( $entry,
+	                                                   $model->SpeciesList,
+	                                                   $model->ParamList    );
+	                        if ($err) {  $err = errgen( $err, $lno );  goto EXIT;  }
+	                    }
+	                    printf "Read %d reaction(s).\n", scalar( @{$block_dat} );
+	                    $model->RxnList($rlist);
+	                }
+	
+	
+	                ### Read Groups Block
+	                elsif ( $name eq 'groups' )
+	                {
+	                	my $iobs = 0;
+	                    if ( @{$model->Observables} )
+	                    {   # Associate groups with exisiting observables
+	                        # my $iobs   = 0;
+	                        foreach my $line ( @$block_dat )
+	                        {
+	                            my ($entry, $lno) = @$line;
+	                    
+	                            # split into tokens (note: using ' ' is different than / /, see perlfunc)
+	                            my @tokens = split ' ', $entry;
+	
+	                            # Skip first entry if it's an index
+	                            if ( $tokens[0] =~ /^\d+$/ ) {  shift @tokens;  }
+	     
+	                            if ( $iobs >= @{$model->Observables} )
+	                            {   # more groups than observables!
+	                                $err = errgen( "More groups than observables", $lno );
+	                                goto EXIT;
+	                            }
+	
+	                            # get observable
+	                            my $obs = $model->Observables->[$iobs];
+	
+	                            # Check that Observable and Group names match
+	                            my $group_name = @tokens ? shift @tokens : '';
+	                            unless ( $group_name eq $obs->Name )
+	                            {
+	                                $err = errgen("Group named '$tokens[0]' is not compatible with any observable", $lno );
+	                                goto EXIT;
+	                            }
+	
+	                            # get group weights
+	                            my @group_weights = split (/,/, $tokens[0]);
+	
+	                            # Zero the weights (TODO..)
+	                            @{$obs->Weights} = (0) x scalar @{$obs->Weights};
+	                            my ($weight, $species_idx);
+	                            foreach my $component (@group_weights)
+	                            {
+	                                if ( $component =~ m/^(\d+)\*(\d+)$/ )
+	                                {
+	                                    $weight = $1;
+	                                    $species_idx = $2;
+	                                }
+	                                elsif ( $component =~ m/^(\d+)$/ )
+	                                {
+	                                    $weight = 1;
+	                                    $species_idx = $1;
+	                                }
+	                                else
+	                                {
+	                                    $err = errgen( "Invalid group entry: $component", $lno );
+	                                    goto EXIT;
+	                                }
+	                                $obs->Weights->[$species_idx] += $weight;
+	                            }
+	                            ++$iobs;
+	                        }
+	                    }
+	                    else
+	                    {   # create a dummy observable for each group
+	                        send_warning("Found 'groups' block before 'observables': creating observables.");
+	
+	                        # get the number of species
+	                        my $n_species = $model->SpeciesList->getNumSpecies();
+	
+	                        #my $iobs   = 0;
+	                        foreach my $line ( @$block_dat )
+	                        {
+	                            my ($entry, $lno) = @$line;
+	                    
+	                            # split into tokens (note: using ' ' is different than / /, see perlfunc)
+	                            my @tokens = split ' ', $entry;
+	
+	                            # Skip first entry if it's an index
+	                            if ( $tokens[0] =~ /^\d+$/ ) {  shift @tokens;  }
+	
+	                            # Group name is next token
+	                            my $group_name = @tokens ? shift @tokens : '';
+	                            unless ( $group_name =~ /^\w+$/ )
+	                            {
+	                                $err = errgen("Invalid group name '$group_name'", $lno );
+	                                goto EXIT;
+	                            }                        
+	
+	                            # create dummy observable
+	                            my $obs = Observable->new( Name=>$group_name, Patterns=>[], Weights=>[], Type=>"Molecule", Output=>1 );
+	                            push @{$model->Observables}, $obs;
+	
+	                            # Add paramter to observable list
+	                            if ( $model->ParamList->set( $obs->Name, "0", 1, "Observable", $obs) )
+	                            {
+	                          	    my $name = $obs->Name;
+	                                $err = errgen( "Observable name $name matches previously defined Observable or Parameter", $lno );
+	                                goto EXIT;
+	                            }
+	
+	                            # get group weights
+	                            my @group_weights = ($tokens[0]) ? split( /,/ , $tokens[0] ) : ();
+	                            
+	                            # Zero the weights
+	                            @{$obs->Weights} = (0) x ($n_species+1);
+	                            my ($weight, $species_idx);
+	                            foreach my $component (@group_weights)
+	                            {
+	                                if ( $component =~ /^(\d+)\*(\d+)$/ )
+	                                {
+	                                    $weight = $1;
+	                                    $species_idx = $2;
+	                                }
+	                                elsif ( $component =~ /^(\d+)$/ )
+	                                {
+	                                    $weight = 1;
+	                                    $species_idx = $1;
+	                                }
+	                                else
+	                                {
+	                                    $err = errgen( "Invalid group entry: $component", $lno );
+	                                    goto EXIT;
+	                                }
+	                                $obs->Weights->[$species_idx] += $weight;
+	                            }
+	                            ++$iobs;
+	                        }
+	                    }
+	                    # update user
+	                    printf "Read %d group(s).\n", $iobs;
+	                }
+	
+	
+	                ### Read Observables Block
+	                elsif ( $name eq 'observables' )
+	                {
+	                    # Read observables
+	                    my ($entry, $lno );
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        ($entry, $lno ) = @$line;
+	                        my $obs = Observable->new();
+	                        $err = $obs->readString($entry, $model);
+	                        if ($err)
+	                        {
+	                            $err = errgen( $err, $lno );
+	                            goto EXIT;
+	                        }
+	                        push @{$model->Observables}, $obs;
+	                    }    
+	
+	                    # check paramlist for unresolved dependency, etc
+	                    #   GIVE warning here, don't terminate!                    
+	                    if ( $err = $model->ParamList->check() )
+	                    {
+	                        $err = errgen( $err, $lno );
+	                        print "Warning: $err\n"
+	                             ."  (if parameter is defined in a subsequent block,\n"
+	                             ."  then this warning can be safely ignored.)\n";
+	                    }                    
+	                    # update user            
+	                    printf "Read %d observable(s).\n", scalar @{$model->Observables};
+	                }
+	
+	                
+	                ### Read Energy Patterns Block
+	                elsif ( $name eq 'energy patterns' )
+	                {
+	                    # read energy patterns
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ($entry, $lno) = @$line;
+	                        my $epatt = EnergyPattern->new();
+	                        $err = $epatt->readString( $entry, $model );
+	                        if ($err) {  $err = errgen($err, $lno);  goto EXIT;  }
+	                        push @{$model->EnergyPatterns}, $epatt;
+	                    }
+	                    # update 
+	                    printf "Read %d energy patterns(s).\n", scalar @{$model->EnergyPatterns};  
+	                
+	                }                    
+	
+	                
+	                ### Read Actions Block
+	                elsif ( $name eq 'actions' )
+	                {
+	                    if ($model->Params->{'skip_actions'})
+	                    {
+	                        unless ($model->Params->{'action_skip_warn'})
+	                        {   send_warning( err_gen("Skipping actions") );   }
+	                        next;
+	                    }
+	                    # Read actions
+	                    foreach my $line ( @$block_dat )
+	                    {
+	                        my ($entry, $lno) = @$line;
+	                        # Remove (and ignore) leading index from line
+	                        $entry =~ s/^\d+\s+//;
+	                        # Get action and options
+	                        my ($action, $options);
+	                        if ( $entry =~ /^\s*(\w+)\s*\((.*)\);?\s*$/ )
+	                        {
+	                            $action  = $1;
+	                            $options = $2;
+	                            # replace double quotes with single quotes so that Perl won't
+	                            #  try to interpret special characters.    
+	                            $options =~ s/"/'/g;
+	                        }
+	                        else                        
+	                        {
+	                            $err = "Line $entry does not appear to contain a command";
+	                            $err = errgen( $err, $lno );
+	                        }
+	
+	                        # TODO: validate action                        
+	                        # TODO: validate option syntax
+	
+	                        # Perform self-consistency checks before operations are performed on model
+	                        if ( $err = $model->ParamList->check() )
+	                        {
+	                            $err = errgen($err);
+	                            goto EXIT;
+	                        }
+	
+	                        # execute action        
+	                        my $command = sprintf "\$model->%s(%s);", $action, $options;
+	                        my $t_start = cpu_time(0);
+	                        $err = eval $command;
+	                        if ($@)   { $err = errgen($@);    goto EXIT; }
+	                        if ($err) { $err = errgen($err);  goto EXIT; }
+	                        my $t_elapsed = cpu_time($t_start);
+	                        printf "CPU TIME: %s %.2f s.\n", $action, $t_elapsed;
+	                    }
+	                }
+	                
+	
+	                ### Try to read any other Block type (probably an error)
+	                else
+	                {   # exit
+	                    $err = errgen("Could not process block type '$name'");
+	                    goto EXIT;
+	                }
+	            }
+	
+	            elsif ( $string =~ /^\s*(setOption)\s*\((.*)\);?\s*$/ )
+	            {   # special action: setOption(opts)
+	                my $action = $1;
+	                my $options = $2;
+	                
+	                # Perform self-consistency checks before operations are performed on model
+	                if ( $err = $model->ParamList->check() )
+	                {  $err = errgen($err);  goto EXIT;  }
+	
+	                # call to methods associated with $model
+	                my $command = '$model->' . $action . '(' . $options . ');';
+	                $err = eval $command;
+	                if ($@)   {  $err = errgen($@);    goto EXIT;  }
+	                if ($err) {  $err = errgen($err);  goto EXIT;  }
+	            }
+	
+	            elsif ( $string =~ s/^\s*(parameter|param|par)\s+//i )
+	            {   # Define a parameter outside of the Parameter block
+	                unless ($in_model)
+	                {
+	                    $err = errgen("Parameter cannot be defined outside of a model");
+	                    goto EXIT;
+	                }
+	                # read parameter
+	                $err = $model->ParamList->readString($string);
+	                if ($err) {  $err = errgen($err);  goto EXIT;  }
+	            }
+	
+	            elsif ( $string =~ /^\s*(\w+)\s*\((.*)\);?\s*$/ )
+	            {   # execute an Action:  "action(options)"
+	                my $action = $1;
+	                my $options = $2;
+	                # replace double quotes with single quotes so that Perl won't
+	                #  try to interpret special characters.    
+	                $options =~ s/"/'/g;
+	
+	                if ($model->Params->{'skip_actions'})
+	                {
+	                    unless ($model->Params->{'action_skip_warn'})
+	                    {   send_warning( errgen("Skipping actions") );   }
+	                    next;
+	                }
+	
+	                # Perform self-consistency checks before operations are performed on model
+	                if ( $err = $model->ParamList->check() )
+	                {
+	                    $err = errgen($err);
+	                    goto EXIT;
+	                }
+	
+	                # execute action
+	                my $command = sprintf "\$model->%s(%s);", $action, $options;
+		
+			#Check if the network is being read from a file
+			if($action eq "readFile")
+			{
+				my $file_name = $options;
+				$file_name  =~ s/(.*)file(\s*)=>(\s*)("|')//;
+                                $file_name  =~ s/("|')(.*)//;
+				$file_name =~ s/(.*)\.//;
+				if($file_name eq 'net'){$NetFlag = 1;}
+			}
+					
+			#The user has generated the network
+			if($action eq "generate_network"){$NetFlag = 1;}
+			my $method_name;
+			if ($action eq "simulate" && $NetFlag == 0)
+			{
+				#Extract method
+				$method_name = $options;
+				$method_name =~ s/(.*)method(\s*)=>(\s*)('|")//;
+				$method_name  =~ s/("|')(.*)//;
+				if($method_name =~ /^(ode|ssa|pla)$/)
+				{
+				 	my $t_start = cpu_time(0);					
+					#The simulation method requires a network
+					#The user has not supplied a command. Use defaults
+					my $cmd = sprintf "\$model->%s(%s);", "generate_network", "({overwrite=>1})";
+                                	$err = eval $cmd;
+                                	if ($@)   { $err = errgen($@);    goto EXIT; }
+                                 	if ($err) { $err = errgen($err);  goto EXIT; }
+                                 	my $t_elapsed = cpu_time($t_start);
+                                 	printf "CPU TIME: %s %.2f s.\n","generate_network", $t_elapsed;
+				 	$NetFlag = 1;
+				}
+			
+			}
+
+			if ($action =~ /^(simulate_ode|simulate_ssa|simulate_pla)$/ && $NetFlag == 0)
+                        {
+				 #The simulation method requires a network and the user has not generated one
+				 my $t_start = cpu_time(0); 
+                                 my $cmd = sprintf "\$model->%s(%s);", "generate_network", "({overwrite=>1})";
+                                 $err = eval $cmd;
+				 if ($@)   { $err = errgen($@);    goto EXIT; }	 
+				 if ($err) { $err = errgen($err);  goto EXIT; }
+                                 my $t_elapsed = cpu_time($t_start);
+				 printf "CPU TIME: %s %.2f s.\n","generate_network", $t_elapsed;
+			         $NetFlag = 1;
+                        }
+
+				my $t_start = cpu_time(0);
+	                	$err = eval $command;
+	                	if ($@)   { $err = errgen($@);    goto EXIT; }
+	                	if ($err) { $err = errgen($err);  goto EXIT; }
+	                	my $t_elapsed = cpu_time($t_start);
+	                	printf "CPU TIME: %s %.2f s.\n", $action, $t_elapsed;
+
+		    }
+	            else
+	            {   # Try to execute general PERL code (Dangerous!!)
+	                if ( $model->Params->{allow_perl} )
+	                {
+	                    # General Perl code
+	                    eval $string;
+	                    if ($@) { $err = errgen($@);  goto EXIT; }
+	                }
+	                else
+	                {
+	                    send_warning( errgen("Unidentified input! Will not attempt to execute as Perl.") );
+	                    next;
+	                }
+	            }
+	        }
+    		} # end read BNGL or NET
+		else{
+			printf "$filename\n";
+			$filename =~ /(\.\w+)$/;
+			$err = errgen("Cannot read file $filename. Unknown file extension '$1'.");
+			goto EXIT;
+		}
+
+      EXIT:
+        unless ($err)
+        {   
+            # if we're back at level 0, perform any required actions
+            if ($level == 0)
+            {
+                if ( $model->Params->{'write_xml'} )
+                {  $model->writeXML();  }
+
+                if ( $model->Params->{'generate_network'} )
+                {  $model->generate_network({'overwrite'=>1});  }
+
+                if ( $model->Params->{'write_mfile'} )
+                {  $model->writeMfile();  }
+
+                if ( $model->Params->{'write_sbml'} )
+                {  $model->writeSBML();  }
+            }
+
+            # indicate that we're finished
+            print "Finished processing file $filename.\n";          
+            if ($level == 0)
+            {   # write time info
+                printf "CPU TIME: total %.2f s.\n", cpu_time($t_start);
+                # restore STDOUT
+                if ($params->{logging})
+                {
+                    unless( open STDOUT, ">&", $stdout_handle )
+                    {  $err = "Problem restoring STDOUT: $!\n";  } 
+                }
+            }
+        }
+
+        if ($level > 0)
+        {   # retrieve state of previous level from stack
+            $filename = pop @filename_stack;
+            $file_data = pop @file_data_stack;
+            $line_number = pop @line_number_stack;
+            $model->Params( pop @params_stack );
+        }    
+        # drop a level
+        --$level;
+        # return with any error messages
+        return $err;
+    }
+
+    ###
+    ###
+
+    sub read_block_array
+    {
+        my $name  = shift @_;
+        my @array = ();
+
+        my $got_end = 0;
+        while ( $_ = get_line() )
+        {
+            # Look for end of block or errors
+            if ( s/^\s*end\s+// )
+            {
+                my $ename = $_;
+                $ename =~ s/\s*$//;
+                $ename =~ s/\s+/ /g;
+                if ( $ename ne $name )
+                {
+                    return ( [], errgen("end $ename does not match begin $name") );
+                }
+                else
+                {
+                    $got_end = 1;
+                    #print "end at $line_number\n";
+                    last;
+                }
+            }
+            elsif ( /^\s*begin\s*/ )
+            {
+                return [], errgen("begin block before end of previous block $name");
+            }
+
+            # Add declarations from current line
+            push @array, [$_, $line_number];
+
+            #print "$_ $line_number\n";
+        }
+
+        unless ($got_end)
+        {  return [], errgen("begin $name has no matching end $name");  }
+
+        return [@array];
+    }
+
+    ###
+    ###
+
+    sub errgen
+    {
+        my $err = shift @_;
+        my $lno = @_ ? shift @_ : $line_number;
+        $err =~ s/[*]/\*/g;
+        my $reterr = sprintf "%s\n  at line $lno", $err;
+        if (defined $filename) { $reterr .= " of file '$filename'"; }
+        return $reterr;
+    }
+
+    ###
+    ###
+
+    sub get_line
+    {
+        my $line;
+        while ( $line = shift @$file_data )
+        {
+            ++$line_number;
+            chomp $line;                         # remove newline character
+            $line =~ s/\#.*$//;                  # remove comments
+            next unless ($line =~ /\S+/);        # skip blank lines
+            while ( $line =~ s/\\\s*$// )
+            {   # line continuations "\"
+                last unless (@$file_data);       # end if there are no more lines
+                ++$line_number;
+                my $nline = shift @$file_data;
+                chomp $nline;
+                $nline =~ s/\#.*$//;             # remove comments
+                $line .= $nline;                 # append to previous line    
+            }
+            last;
+        }
+        return $line;
+    }
+
+    # END of readFile method
+}
+
+
+
+###
+###
+###
+
+
+
+# write Model to file (default is BNGL format)
+# $err = $model->writeModel({opt=>val,..}) 
+sub writeModel
+{
+    use strict;
+    use warnings;
+
+    my $model       = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    my %params = (
+        'evaluate_expressions' => 0,
+        'format'               => 'bngl',
+        'include_model'        => 1,
+        'include_network'      => 0,
+        'overwrite'            => 0,
+        'pretty_formatting'    => 1,
+    );
+
+    # copy user_params into pass_params structures
+    while ( my ($key,$val) = each %$user_params )
+    {   $params{$key} = $val;    }
+
+    # writeFile will generate the output
+    return $model->writeFile( \%params );
+}
+
+
+# write Network in NET format
+# $err = $model->writeNetwork({opt=>val,..}) 
+sub writeNetwork
+{
+    use strict;
+    use warnings;
+
+    my $model       = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    my %params = (
+        'evaluate_expressions' => 0,
+        'format'               => 'net',
+        'include_model'        => 0,
+        'include_network'      => 1,
+        'overwrite'            => 0,
+        'pretty_formatting'    => 0,
+    );
+
+    # copy user_params into pass_params structures
+    while ( my ($key,$val) = each %$user_params )
+    {   $params{$key} = $val;    }
+
+    # writeFile will generate the output
+    return $model->writeFile( \%params );
+}
+
+
+# Write Reaction Network to .NET file
+# This action will be Deprecated! writeModel and writeNetwork should be used instead
+sub writeNET
+{
+    my $model       = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    # default parameters
+    my %params = (
+        'evaluate_expressions' => 1,
+        'format'               => 'net',
+        'include_model'        => 1,
+        'include_network'      => 1,
+        'overwrite'            => 1,
+        'pretty_formatting'    => 0,
+        'TextReaction'         => 0,
+        'TextSpecies'          => 1,
+    );
+
+    # get any user parameters 
+    while ( my ($key,$val) = each %$user_params )
+    {   $params{$key} = $val;   }
+
+    # call writeFile to output the network
+    return $model->writeFile( \%params );
+}
+
+
+# This is a general method for writing the model and/or network to a file in various formats.
+#  (This method does the heavy lifting for writeModel and writeNetwork)
+#
+# $err = $model->writeFile({OPT=>VAL,..})
+#
+# OPTIONS:
+#   evaluate_expressions => 0,1 : evaluate math expressions output as numbers (default=0).
+#   format => "FORMAT"          : select output format, where FORMAT=bngl,net,xml,sbml,ssc (default=net).
+#   include_model => 0,1        : include model blocks in output file (default=1).
+#   include_network => 0,1      : include network blocks in output file (default=1).
+#   overwrite => 0,1            : allow writeFile to overwrite exisiting files (default=0).
+#   prefix => "string"          : set prefix of output file name (default=outdir/MODELNAME).
+#   pretty_formatting => 0,1    : write output in "pretty" form (default=0).
+#   suffix => "string"          : set suffix of output file name (default=NONE).
+#   TextReaction => 0,1         : write reactions as BNGL strings (default=0).
+#   TextSpecies => 0,1          : write species as BNGL string (default=1).
+#
+# TODO: set up additional formats: SBML, SSC, etc.
+sub writeFile
+{
+    use strict;
+    use warnings;
+
+    my $model       = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    my %params = (
+        'evaluate_expressions' => 0,
+        'format'               => 'net',
+        'include_model'        => 1,
+        'include_network'      => 1,
+        'overwrite'            => 1,
+        'prefix'               => $model->getOutputPrefix(),
+        'pretty_formatting'    => 1,
+        'suffix'               => '',
+        'TextReaction'         => 0,
+        'TextSpecies'          => 1,
+    );
+
+    # change this to a constant?
+    my %allowed_formats = ( 'net'=>1, 'bngl'=>1, 'sbml'=>0, 'xml'=>1, 'ssc'=>0 );
+
+    # copy user_params into params and pass_params structures
+    foreach my $key ( keys %$user_params )
+    {
+        my $val = $user_params->{$key};
+        if ( exists $params{$key} )
+        {   $params{$key} = $val;   }
+        else
+        {   die "writeFile(): Unrecognized option parameter $key.";   }
+    }
+
+    # check if format is allowed
+    unless ( $allowed_formats{ $params{'format'} } )
+    {
+        return sprintf( "writeFile() does not currently support '%s' format.", $params{'format'} );
+    }
+
+    # check if there's anything to write
+    unless ( $params{'include_model'} or $params{'include_network'} )
+    {
+        return "writeFile() has nothing to write! Include model or network and try again.";
+    }
+
+    # check for reactions if we're writing the network
+    if ( $params{include_network} )
+    {
+        if ( @{$model->RxnList->Array} == 0 )
+        {
+            return "writeFile() was asked to write the network, but no reactions were found.\n"
+                  ."Did you remember to call generate_network() before writing network output?\n";
+        }
+    }
+
+    # do nothing if we're not executing actions
+    return undef if $NO_EXEC;
+
+    ## Execute the Action ##
+    # first, build output filename
+    my $file = $params{prefix};
+    unless ( $params{suffix} eq '' )
+    {   $file .= "_$params{suffix}";   }
+    $file .= ".$params{format}";
+
+    # now check if we're overwriting an existing file
+    if ( -e $file )
+    {
+        if ( $params{overwrite} )
+        {
+            send_warning("writeFile(): Overwriting existing file $file.");
+            unlink $file;
+        }
+        else
+        {   return "writeFile(): file $file exists. Set option overwrite=>1 to overwrite.";   }
+    }
+
+    # make a string that describes outputs to user
+    my @outputs; 
+    if ( $params{'include_model'} )
+    {   push @outputs, "model";   }
+    if ( $params{'include_network'} )
+    {   push @outputs, "network";   }   
+    my $output = join " and ", @outputs;
+
+    # get file output in string format
+    my $file_string;
+    if ( $params{'format'} eq 'net' )
+    {   # write NET format
+        $file_string = $model->writeBNGL( \%params );
+    }
+    elsif ( $params{'format'} eq 'bngl' )
+    {   # write BNGL format
+        $file_string = $model->writeBNGL( \%params );
+    }
+    elsif ( $params{'format'} eq 'xml' )
+    {   # write XML format
+        $file_string = $model->toXML( \%params );
+    }
+
+    # write the string to file
+    my $FH;
+    open($FH, '>', $file)  or  return "Couldn't write to $file: $!\n";
+    print $FH $file_string;
+    close $FH;
+
+    # all done
+    print sprintf( "Wrote %s in %s format to %s.\n", $output, $params{'format'}, $file);
+    return undef;
+}
+
+
+# Write Model to a BNGL formatted string.
+# This method returns a string and does NOT write to file.
+#  (also writes reaction network, if it exists)
+sub writeBNGL
+{
+    use strict;
+    use warnings;
+
+    my $model = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    # Default parameters required by this method.
+    # NOTE: since this method is not a user action, we don't need to check parameters.
+    # Instead, we assume the programmers call this method with valid options.
+    my %params = (
+        'convert_intensive_to_extensive_units' => 1,
+        'evaluate_expressions' => 0,
+        'format'               => 'net',
+        'include_model'        => 1,
+        'include_network'      => 1,
+        'pretty_formatting'    => 1,
+        'TextReaction'         => 0,
+        'TextSpecies'          => 1,
+    );
+
+    # get any user parameters 
+    while ( my ($key,$val) = each %$user_params )
+    {   $params{$key} = $val;    }
+
+    return '' if $NO_EXEC;
+
+
+    # !!! Begin writing file !!!
+    my $out    = '';
+
+    # Header
+    my $version = BNGversion();
+    my $codename = BNGcodename();
+    $out .= "# Created by BioNetGen ${version}-${codename}\n";
+
+    # Version requirements
+    unless ( $model->Version eq '' )
+    {  $out .= sprintf "version(\"%s\")\n", $model->Version;  }
+
+    # Options
+    while ( my ($opt,$val) = each %{$model->Options} )
+    {
+        next if ( $opt eq 'prefix' ); # don't write prefix
+        next if ( $opt eq 'suffix' ); # don't write suffix
+        $out .= "setOption(\"$opt\",\"$val\")\n";
+    }
+
+    # Units
+    unless ($model->SubstanceUnits eq '')
+    {  $out .= sprintf "substanceUnits(\"%s\")\n", $model->SubstanceUnits;  }
+
+    # Begin Model (BNGL only)
+    $out .= "\nbegin model\n"  if ( $params{'format'} eq 'bngl'  and  $params{'pretty_formatting'} );
+
+    # Parameters
+    $out .= $model->ParamList->writeBNGL( \%params );
+
+    # Model blocks
+    if ( $params{'include_model'} )
+    {
+        # Compartments
+        if ( defined $model->CompartmentList  and  @{$model->CompartmentList->Array} )
+        {   $out .= $model->CompartmentList->toString( $model->ParamList );   }
+
+        # MoleculeTypes
+        if ( $model->MoleculeTypesList->StrictTyping )
+        {   $out .= $model->MoleculeTypesList->writeBNGL( \%params );   }
+
+        # Observables    
+        if ( @{$model->Observables} )
+        {
+            # find max length of observable name
+            my $max_length = 0;
+            foreach my $obs ( @{$model->Observables} )
+            {
+                $max_length = ( length $obs->Name > $max_length ) ? length $obs->Name : $max_length;
+            }
+            
+            $out .= "begin observables\n";
+            my $io = 1;
+            foreach my $obs ( @{$model->Observables} )
+            {
+                if ( $params{'pretty_formatting'} )
+                {   # no observable index
+                    $out .= sprintf "  %s\n", $obs->toString($max_length);
+                }
+                else
+                {   # include index
+                    $out .= sprintf "%5d %s\n", $io, $obs->toString();
+                }
+                ++$io;
+            }    
+            $out .= "end observables\n";
+        }
+
+        # Energy Patterns
+        if ( @{$model->EnergyPatterns} )
+        {
+            $out .= "begin energy patterns\n";
+            my $io = 1;
+            foreach my $epatt ( @{ $model->EnergyPatterns } )
+            {
+                if ( $params{'pretty_formatting'} )
+                {   # no energy pattern index
+                    $out .=  sprintf "  %s\n", $epatt->toString($model->ParamList);
+                }
+                else
+                {   # include index
+                    $out .=  sprintf "%5d %s\n", $io, $epatt->toString($model->ParamList);
+                }
+
+                ++$io;
+            };        
+            $out .= "end energy patterns\n";
+        }
+    }
+
+    # Functions
+    $out .= $model->ParamList->writeFunctions( \%params );
+        
+    # Species
+    $out .= $model->SpeciesList->writeBNGL( $model->Concentrations, $model->ParamList, \%params );
+
+
+    # Model Blocks
+    if ( $params{include_model} )
+    {
+        # Reaction rules
+        $out .= "begin reaction rules\n";
+        {
+            my $irxn = 1;
+            foreach my $rset ( @{$model->RxnRules} )
+            {
+                my $rreverse = ( @$rset > 1 ) ? $rset->[1] : undef;
+
+                # write BNGL rule
+                $out .= sprintf "  %s\n", $rset->[0]->toString($rreverse);
+        
+                # write actions
+                if ( $params{'pretty_formatting'} )
+                {   # pretty, don't write actions
+                    # do nothing!
+                }
+                else
+                {   # write actions
+                    $out .= $rset->[0]->listActions();
+                    if ( defined $rreverse )
+                    {
+                        $out .= "  # Reverse\n";
+                        $out .= $rset->[1]->listActions();
+                    }    
+                }
+                ++$irxn;
+            }
+        }
+        $out .= "end reaction rules\n";
+    }
+
+    # Network blocks
+    if ( $params{'include_network'} )
+    {
+        # Reactions    
+        if ( $params{'TextReaction'} )
+        {   print "Writing full species names in reactions.\n";   }
+        $out .= $model->RxnList->writeBNGL( \%params, $model->ParamList );
+
+        # Groups
+        if ( @{$model->Observables} )
+        {
+            $out .= "begin groups\n";
+            my $io = 1;
+            foreach my $obs ( @{$model->Observables} )
+            {
+                $out .= sprintf "%5d %s\n", $io, $obs->toGroupString( $model->SpeciesList );
+                ++$io;
+            }
+            $out .= "end groups\n";
+        }
+    }
+
+    # End Model (BNGL only)
+    $out .= "end model\n"  if ( $params{'format'} eq 'bngl' and  $params{'pretty_formatting'} );
+
+    return $out;
+}
+
+
+
+###
+###
+###
+
+
+
+# Syntax
+#   setOption(name,value,name,value,...) Set option value pairs
+# First call will cause initialization with default values.
+sub setOption
+{
+    my $model = shift @_;
+    my $err   = '';
+
+    # Process options
+    while (@_)
+    {
+        my $arg = shift @_;
+        unless (@_) { return "No value specified for option $arg"; }
+        my $val = shift @_;
+        
+        # TODO: print arg and val to user?
+
+        if ( $arg eq "SpeciesLabel" )
+        {
+            # SpeciesLabel method can only be changed prior to reading species.
+            # Otherwise, inconsistent behavior could arise from changing the
+            # labeling method.
+            if ( $model->SpeciesList->size() )
+            {   return "$arg option can only be changed prior to defining species.";  }
+            $err = SpeciesGraph::setSpeciesLabel($val);
+            if ($err) { return $err; }
+            $model->Options->{$arg} = $val;
+        }
+        elsif ( $arg eq "energyBNG" )
+        {   # enable energy mode
+            send_warning("The energyBNG option is now deprecated (energy features available by default).");
+        }
+        elsif ( $arg eq "NumberPerQuantityUnit" )
+        {   # set conversion from quantity units to pure numbers
+            # TODO: allow this to be a parameter?
+            $model->Options->{$arg} = $val;
+        }
+        elsif ( $arg eq "MoleculesObservables" )
+        {   # set molecules observables mode
+            unless ($val eq "CountUnique"  or $val eq "CountAll")
+            {   return "Invalid option for or $arg (valid options are 'CountUnique' and 'CountAll')";   }
+            $model->Options->{$arg} = $val;
+        }
+        elsif ( $arg eq "SpeciesObservables" )
+        {   # set species observables mode
+            unless ($val eq "CountUnique"  or $val eq "CountAll")
+            {   return "Invalid option for or $arg (valid options are 'CountUnique' and 'CountAll')";   }
+            $model->Options->{$arg} = $val;
+        }
+        else
+        {
+            return "Unrecognized option $arg in setOption";
+        }
+    }
+
+    return '';
+}
+
+
+sub substanceUnits
+{
+    my $model = shift @_;
+    my $units = shift @_;
+
+    my $ucommand = "";
+    if ( $units =~ /^conc/i ) {
+        $ucommand = "Concentration";
+    }
+    elsif ( $units =~ /^num/i ) {
+        $ucommand = "Number";
+    }
+    else {
+        return "Invalid argument to subtanceUnits $units: valid arguments are Number and Concentration";
+    }
+
+    print "SubstanceUnits set to $ucommand.\n";
+    $model->SubstanceUnits($ucommand);
+    return '';
+}
+
+
+sub setVolume
+{
+    my $model            = shift @_;
+    my $compartment_name = shift @_;
+    my $value            = shift @_;
+
+    return $model->CompartmentList->setVolume( $compartment_name, $value );
+}
+
+
+
+###
+###
+###
+
+
+
+sub setParameter
+{
+    my $model = shift @_;
+    my $pname = shift @_;
+    my $value = shift @_;
+
+    return '' if $NO_EXEC;
+
+    my $plist = $model->ParamList;
+    my ($param, $err);
+
+    # Error if parameter doesn't exist
+    ( $param, $err ) = $plist->lookup($pname);
+    if ($err) { return ($err) }
+
+    # Read expression
+    my $expr    = Expression->new();
+    my $estring = "$pname=$value";
+    if ( $err = $expr->readString( \$estring, $plist ) ) { return $err; }
+
+    # Set flag to update netfile when it's used
+    $model->UpdateNet(1);
+
+    printf "Set parameter %s to value %s\n", $pname, $expr->evaluate($plist);
+    return '';
+}
+
+
+# Save the current parameter definitions.
+#  Optionally specify a label to associate with the saved parameters.
+sub saveParameters
+{
+    my $model = shift @_;
+    my $label = @_ ? shift @_ : Cache::DEFAULT_LABEL;
+
+    return '' if $NO_EXEC;
+
+    # copy paramList (exclude non-constant types)
+    my $paramlist = $model->ParamList->copyConstant();
+
+    # put saved concentration into cache
+    $model->ParameterCache->cache($paramlist,$label);
+    # Send message to user
+    printf "Saved current parameters with label '%s'\n", $label;
+    return undef;
+} 
+
+
+# Reset parameters to saved defintions.
+#  Optionally specify a label used to find the saved parameters
+sub resetParameters
+{
+    my $model = shift @_;
+    my $label = @_ ? shift @_ : Cache::DEFAULT_LABEL;
+
+    return '' if $NO_EXEC;
+    
+	# get a COPY so that subsequent 'setParameter' calls don't modify the saved list
+    my $saved_paramlist = $model->ParameterCache->browse($label)->copyConstant();
+
+    unless (defined $saved_paramlist)
+    {   return "resetParameters(): cannot find saved parameters";   }
+
+    unless (ref $saved_paramlist eq 'ParamList')
+    {   return "resetParameters(): problem retrieving saved parameters";   }
+
+    # copy saved parameters into main ParamList
+    my $err;
+    foreach my $param ( @{$saved_paramlist->Array} )
+    {
+        $err = $model->ParamList->add( $param );
+        if ($err) { return "resetParameters(): problem resetting parameters ($err)"; }
+    }
+
+    # Set flag to update netfile when it's used
+    $model->UpdateNet(1);
+
+    # Send message to user
+    printf "Reloaded parameters saved with label '%s'\n", $label;
+    # all done
+    return undef;
+}
+
+
+
+###
+###
+###
+
+
+
+# Set the concentration of a species to specified value.
+# Value may be a number or a parameter.
+sub setConcentration
+{
+    my $model = shift @_;
+    my $sname = shift @_;
+    my $value = shift @_;
+    
+    return '' if $NO_EXEC;
+
+    my $plist = $model->ParamList;
+    my $err;
+
+    # SpeciesGraph specified by $sname
+    my $sg = SpeciesGraph->new;
+    $err = $sg->readString( \$sname, $model->CompartmentList, 1, '', $model->MoleculeTypesList );
+    if ($err) { return $err; }
+
+    # Should check that this SG specifies a complete species, otherwise
+    # may match a number of species.
+
+    # Find matching species
+    my $spec;
+    unless ( $spec = $model->SpeciesList->lookup($sg) )
+    {
+        $err = sprintf "Species %s not found in SpeciesList", $sg->toString();
+        return $err;
+    }
+
+    # Read expression
+    my $expr    = Expression->new();
+    my $estring = $value;
+    if ( my $err = $expr->readString( \$estring, $plist ) ){
+        return '', $err;
+    }
+    
+    # Evaluate observable and function names to values and reset
+    # the expression. Don't do this for parameters so that parameter 
+    # scans can be run.
+    my $estring2 = $value;
+    my $variables = $expr->getVariables($plist);
+	foreach my $var ($variables->{'Observable'}){ # Observables
+		foreach my $name (keys %{$var}){
+			my $val = $plist->evaluate($name);
+			$estring2 =~ (s/$name/$val/g);
+		}
+	}
+	foreach my $var ($variables->{'Function'}){ # Functions
+		foreach my $name (keys %{$var}){
+			my $val = $plist->evaluate($name);
+			$estring2 =~ (s/$name(\(\))?/$val/g);
+		}
+	}
+	if ( my $err = $expr->readString( \$estring2, $plist ) ){
+        return '', $err;
+    }
+    
+    # Either evaluate expression or create a new one with prefix 'NewConc'
+    my $conc; # = $expr->evaluate($plist);
+    if ( $expr->Type eq 'NUM' ){
+    		$conc = $expr->evaluate();
+    }
+    else{
+        $conc = $expr->getName( $plist, 'NewConc' );
+    }
+
+    # load Concentration array (if not already done)
+    $model->SpeciesList->checkOrInitConcentrations( $model->Concentrations );
+
+    # set concentration
+    $model->Concentrations->[$spec->Index - 1] = $conc;
+
+    # Set flag to update netfile when it's used
+    $model->UpdateNet(1);
+
+    printf "Set concentration of species %s to value %s\n", $spec->SpeciesGraph->StringExact, 
+    		($expr->Type eq 'NUM' ? $conc : $expr->toString());
+    return undef;
+}
+
+
+# Add concentration to a species.
+# Value may be a number or a parameter.
+sub addConcentration
+{
+    my $model = shift @_;
+    my $sname = shift @_;
+    my $value = shift @_;
+    
+    return '' if $NO_EXEC;
+
+    my $plist = $model->ParamList;
+    my $err;
+
+    # SpeciesGraph specified by $sname
+    my $sg = SpeciesGraph->new;
+    $err = $sg->readString( \$sname, $model->CompartmentList, 1, '', $model->MoleculeTypesList );
+    if ($err) { return $err; }
+
+    # Should check that this SG specifies a complete species, otherwise
+    # may match a number of species.
+
+    # Find matching species
+    my $spec;
+    unless ( $spec = $model->SpeciesList->lookup($sg) )
+    {
+        $err = sprintf "Species %s not found in SpeciesList", $sg->toString();
+        return $err;
+    }
+
+    # Read expression
+    my $expr    = Expression->new();
+    my $estring = $value;
+    if ( my $err = $expr->readString( \$estring, $plist ) )
+    {
+        return ( '', $err );
+    }
+    my $add_conc = $expr->evaluate($plist);
+
+    # load Concentration array (if not already done)
+    $model->SpeciesList->checkOrInitConcentrations( $model->Concentrations );
+
+    # Add original concentration 
+    my $orig_conc = $model->Concentrations->[$spec->Index - 1];
+    unless ( isReal($orig_conc) )
+    {   # evaluate parameter
+        $orig_conc = $plist->evaluate($spec->Concentration);
+    }        
+    my $conc = $add_conc + $orig_conc;
+
+    # set new concentration
+    $model->Concentrations->[$spec->Index - 1] = $conc;
+
+    # Set flag to update netfile when it's used
+    $model->UpdateNet(1);
+
+    printf "Add %s counts (or concentration units) to species %s for total of %s\n",
+         $add_conc, $spec->SpeciesGraph->StringExact, $conc;
+    return undef;
+}
+
+
+# Save the current species concentrations.
+#  Optionally specify a label to associate with the saved state.
+sub saveConcentrations
+{
+    my $model = shift @_;
+    my $label = @_ ? shift @_ : Cache::DEFAULT_LABEL;
+
+    return '' if $NO_EXEC;
+
+    # create new concentration array
+    my $conc = [];
+    if (@{$model->Concentrations})
+    {   # copy concentration from primary concentration array
+        @$conc = @{$model->Concentrations};
+    }
+    else
+    {   # if that's not defined, copy directly from SpeciesList
+        @$conc = map {$_->Concentration} @{$model->SpeciesList->Array};
+    }
+    # put saved concentration into cache
+    $model->ConcentrationCache->cache($conc,$label);
+    print "Saved current species concentrations with label \"$label\"\n";
+    return undef;
+}
+
+
+# Reset species concentrations to saved values.
+#  Optionally specify a label used to find the saved concentrations
+sub resetConcentrations
+{
+    my $model = shift @_;
+    my $label = @_ ? shift @_ : Cache::DEFAULT_LABEL;
+
+    return '' if $NO_EXEC;
+
+    # lookup up concentrations in the cashe
+    my $saved_conc = $model->ConcentrationCache->browse($label);
+
+    my $conc;
+    if ( (defined $saved_conc) and (ref $saved_conc eq 'ARRAY') )
+    {   # get a copy of the values (don't want to mess with originals)
+        @$conc = @$saved_conc;
+    }
+    elsif ( !(defined $saved_conc) )
+    {   # didn't find anything in the cache ...
+        if ( $label eq Cache::DEFAULT_LABEL )
+        {   # if we were looking for default values, get them directly from the species objects ...
+            @$conc = map {$_->Concentration} @{$model->SpeciesList->Array};
+        }
+        else
+        {   # otherwise return an error
+            return "resetConcentrations(): cannot find saved concentrations with label \"$label\"";
+        }
+    }
+    else
+    {   # cache returned unexpected reference type
+        return "resetConcentrations(): some problem retrieving saved concentrations";
+    }
+
+    if ( @$conc > @{$model->SpeciesList->Array} )
+    {   # this case is not well-defined
+        return "resetConcentrations(): length of concentration vector is larger than the number of species";
+    }
+    elsif ( @$conc < @{$model->SpeciesList->Array} )
+    {   # pad with zeros
+        my $n_zeros = @{$model->SpeciesList->Array} - @$conc;
+        push @$conc, (0) x $n_zeros;
+    }
+
+    # finally, set concentrations to the saved values
+    $model->Concentrations($conc);
+    # Set flag to update netfile when it's used
+    $model->UpdateNet(1);
+    # all done
+    print "Reset species concentrations to \"$label\" saved values.\n";
+    return undef;
+}
+
+
+
+###
+###
+###
+
+
+
+sub setModelName
+{
+    my $model = shift @_;
+    my $name  = shift @_;
+
+    $model->Name($name);
+    return '';
+}
+
+
+###
+###
+###
+
+
+
+# Function to require the version conform to specified requirement
+# Syntax: version(string);
+# string = major[.minor][.dist][+-][codename]
+#
+# major, minor, and dist. indicate the major, minor, and distribution number
+# respectively against which the BioNetGen version numbers will be compared.
+# + indicates version should be the specified version or later (default)
+# - indicates version should be the specified version or earlier
+sub version
+{
+    my $model   = shift @_;
+    my $vstring = shift @_;
+
+    return '' if $NO_EXEC;
+
+    if (@_)
+    {   # complain about too many arguments
+        return "Version called with too many arguments.";
+    }
+
+    # extract version and codename
+    my ($version, $relation, $codename) = ( $vstring =~ /^(\d+\.\d+\.\d+)([+-]?)\s*(\w*)/ );
+
+    unless ( defined $version )
+    {   # complain that version is invalid
+        return "version argument '$vstring' has invalid format (make sure argument is enclosed in double quotes \"\").";
+    }
+
+    if ( $relation eq "" )
+    {   # default relation is "+"
+        $relation = "+";
+    }
+
+    my $bng_version = BNGversion();
+    if ( $bng_version eq 'UNKNOWN' )
+    {   # complain that BNG version is unknown
+        return "BNG version is UNKNOWN!";
+    }
+
+    # compare versions (returns -1 if version < bng_version)
+    my $comp = compareVersions($version,$bng_version);
+
+    # is active BNG version suitable?
+    if    ( $relation eq '+'  and  $comp == 1 )
+    {   # BNG version is less than minimum required!
+        return "Requested BioNetGen version $version or greater. Active version is $bng_version.";
+    }
+    elsif ( $relation eq '-'  and  $comp == -1 )
+    {   # BNG version is greater than maximum allowed!
+        return "Requested BioNetGen version $version or lesser. Active version is $bng_version.";
+    }
+    
+    # check codename
+    unless ($codename eq "")
+    {
+        my $bng_codename = BNGcodename();
+        unless ( $codename eq $bng_codename )
+        {
+            return "Requested BioNetGen codename '${codename}'. Active codename is '${bng_codename}'.";
+        }
+    }
+    
+    # Set version requirement
+    $model->Version( $vstring );
+
+    # everything is good
+    return undef;
+}
+
+sub codename
+{
+    my $model    = shift @_;
+    my $codename = shift @_;
+
+    return '' if $NO_EXEC;
+
+    if (@_)
+    {   # complain about too many arguments
+        return "Codename called with too many arguments.";
+    }
+
+    unless ( $codename )
+    {   # complaiin about empty codename
+        return "codename argument is empty.";
+    }
+
+    # get BNG codename
+    my $bng_codename = BNGcodename();
+    if ( $bng_codename eq 'UNKNOWN' )
+    {   # complain that BNG codename is unknown
+        return "BNG version is UNKNOWN!";
+    }
+
+    # compare codename
+    unless ($codename eq $bng_codename)
+    {   # BNG codename is not correct
+        return "Requested BioNetGen codename $codename. Active version is $bng_codename.";
+    }
+    
+    # Add current version requirement to the model
+    push @{$model->Codename}, $codename;
+
+    # everything is good
+    return undef;
+}
+
+
+###
+###
+###
+
+
+
+sub quit
+{
+    # quick exit. no cleanup. no error messages
+    # This is useful when the user desires to exit before
+    #  performing a set of actions and it would be tedious to 
+    #  comment out all those actions.
+    print "quitting BioNetGen!\n";
+    exit(0);
+}
+
+
+
+###
+###
+###
+
+
+
+# Add equilibrate option, which uses additional parameters
+# t_equil and spec_nonequil.  If spec_nonequil is set, these
+# species are not used in equilibration of the network and are only
+# added after equilibration is performed. Network generation should
+# re-commence after equilibration is performed if spec_nonequil has
+# been set.
+
+sub generate_network
+{
+    my $model       = shift @_;
+    my $user_params = @_ ? shift @_ : {};
+
+    printf "ACTION: generate_network( %s )\n", $model->Name;
+
+    # default params
+    my %params = (
+        'continue'     => 1,
+        'max_iter'     => 100,
+        'max_agg'      => 1e9,
+        'max_stoich'   => {},
+        'check_iso'    => 1,
+        'prefix'       => $model->getOutputPrefix(),
+        'suffix'       => undef,
+        'overwrite'    => 0,
+        'print_iter'   => 0,
+        'TextSpecies'  => 1,
+        'TextReaction' => 0,
+        'verbose'      => 0,
+		'write'		   => 1
+    );
+
+    # overwrite default params with user params
+    foreach my $key (keys %$user_params)
+    {
+        my $val = $user_params->{$key};
+        unless ( exists $params{$key} )
+        {   return "Unrecognized parameter $key in generate_network";   }
+
+        $params{$key} = $val;
+    }
+
+    return '' if $NO_EXEC;
+    
+    # Output prefix
+    if (defined $user_params->{prefix}){
+    	$params{prefix} = $model->getOutputPrefix($user_params->{prefix});
+    }
+    
+    # add optional suffix to output prefix
+    if ( $params{suffix} )
+    {  $params{prefix} .= "_" . $params{suffix};  }
+
+    # default params for calling writeNetwork
+    # (only need to change if we want non-default)
+    my $params_writeNetwork = {
+        'include_model' => 0,
+        'overwrite'     => 1,
+        'prefix'        => $params{prefix},
+        'TextSpecies'   => $params{TextSpecies},
+        'TextReaction'  => $params{TextReaction}
+    };
+
+    # default params for calling expand_rule
+    my $params_expand_rule = {
+        'check_iso'  => $params{check_iso},
+        'max_agg'    => $params{max_agg},
+        'max_stoich' => $params{max_stoich},
+        'verbose'    => $params{verbose},
+    };
+
+	# make sure 'max_stoich' molecules are valid names
+	foreach my $mol ( keys %{$params{'max_stoich'}} ){
+		if ( not $mol =~ /^[A-Za-z_]\w*$/ ){
+			return "Error in max_stoich: '$mol' is not a valid molecule name.";
+		}
+	}
+	
+    # check verbose option
+    my $verbose = $params{verbose};
+
+    # Check if existing net file has been created since last modification time of .bngl file
+    my $prefix = $params{prefix};
+    if ( -e "$prefix.net"  and  -e "$prefix.bngl" )
+    {
+        if ($params{overwrite})
+        {
+            send_warning("Removing old network file $prefix.net.");
+            unlink "$prefix.net";
+        }
+        elsif ( -M "$prefix.net" < -M "$prefix.bngl" )
+        {
+            send_warning("$prefix.net is newer than $prefix.bngl so reading NET file.");
+            my $err = $model->readFile({file=>"${prefix}.net"});
+            return $err;
+        }
+        else
+        {
+            return "Previously generated $prefix.net exists.  Set overwrite=>1 option to overwrite.";
+        }
+    }
+    
+    if ( $model->SpeciesList->size() == 0 )
+    {   # warn user if the seed species list is empty.
+        send_warning("The seed species block is empty: reaction network will be empty "
+                    ."unless zero-order synthesis rules are defined.");
+    }
+
+    # nothing to do if no rules are defined
+    if ( @{$model->RxnRules} == 0 )
+    {   return "Nothing to do: no reaction rules defined.";   }
+
+    # if no reactions have been generated previously, then we have to initialize some things...
+    if ( $model->RxnList->size()==0 or $params{'continue'}==0 )
+    {
+        # initialize rules
+        foreach my $rset ( @{$model->RxnRules} )
+        {
+            foreach my $rr (@$rset)
+            {   $rr->initializeRule();   }
+        }
+        # Initialize observables
+        foreach my $obs ( @{$model->Observables} )
+        {   
+            $obs->reset_weights( $model->SpeciesList->size() );
+            $obs->update( $model->SpeciesList->Array );
+        }
+        # Initialize energy patterns (for energy BNG only)
+        foreach my $epatt ( @{$model->EnergyPatterns} )
+        {
+            $epatt->reset_weights($model->SpeciesList->size());
+            $epatt->update($model->SpeciesList->Array);
+        }
+        # remember that we applied the observables
+        foreach my $sp ( @{$model->SpeciesList->Array} )
+        {   $sp->ObservablesApplied(1);   }
+    }
+    else
+    {   # friendly warning that we're continuing network generation 
+        send_warning("Reaction list is already populated. Continuing network generation from where we last left off.");
+    }
+
+
+    my @rule_timing = ();
+    my @rule_nrxn   = ();
+    
+    # update user with initial report
+    report_iter( 0, $model->SpeciesList->size(), $model->RxnList->size() );
+
+    # now perform network generation steps
+    foreach my $niter ( 1 .. $params{max_iter} )
+    {
+        my $t_start_iter = cpu_time(0);
+        my @species = @{$model->SpeciesList->Array};
+
+        # Apply reaction rules
+        my $irule = 0;
+        my ($n_new, $t_off, $n_new_tot);
+        $n_new_tot = 0;
+        # NOTE: each element of @{$model->RxnRules} is an array of reactions.
+        #  If a rule is unidirectional, then the array has a single element.
+        #  If a rule is bidirectional, then the array has two elements (forward and reverse)
+        foreach my $rset ( @{$model->RxnRules} )
+        {
+            if ($verbose) { printf "Rule %d:\n", $irule + 1; }
+            $n_new = 0;
+            $t_off = cpu_time(0);
+            my $dir = 0;
+            foreach my $rr (@$rset)
+            {
+                if ($verbose)
+                {
+                    if ($dir == 0) { print "  forward:\n"; }
+                    else           { print "  reverse:\n"; }
+                }
+                # expand rule
+                my ($err, $nr) = $rr->expand_rule( \@species, $model, $params_expand_rule );
+                if (defined $err) { return "Some problem expanding rule: $err"; }
+                $n_new += $nr;
+                ++$dir;
+            }
+        
+            my $time = cpu_time(0) - $t_off;
+            $rule_timing[$irule] += $time;
+            $rule_nrxn[$irule]   += $n_new;
+
+            if ($verbose)
+            {   printf "Result: %5d new reactions %.2e CPU s\n", $n_new, $time;   }
+
+            $n_new_tot += $n_new;
+            ++$irule;
+        }
+
+        # update RulesApplied for species processed in this interation
+        foreach my $spec (@species)
+        {   $spec->RulesApplied($niter) unless ($spec->RulesApplied);   }
+
+        # report iteration to user
+        report_iter( $niter, $model->SpeciesList->size(), $model->RxnList->size(), $t_start_iter );
+
+        # Free memory associated with RxnList hash
+        $model->RxnList->resetHash();
+
+        # Stop iteration if no new species were generated
+        last if ( $model->SpeciesList->size() == scalar @species );
+
+        # Print network after current iteration to netfile
+        if ( $params{print_iter} and $params{write} )
+        {
+            $params_writeNetwork->{prefix} = "${prefix}_${niter}";
+            my $err = $model->writeNetwork($params_writeNetwork);
+            if ($err) { return $err; }
+            $params_writeNetwork->{prefix} = $prefix;
+        }
+    }
+        
+                
+    # Print rule timing information
+    printf "Cumulative CPU time for each rule\n";
+    my $t_tot = 0;
+    my $n_tot = 0;
+    foreach my $irule ( 0 .. $#{$model->RxnRules} )
+    {
+        my $eff = ( $rule_nrxn[$irule] ) ? $rule_timing[$irule] / $rule_nrxn[$irule] : 0.0;
+        printf "Rule %3d: %5d reactions %.2e CPU s %.2e CPU s/rxn\n",
+                   $irule + 1, $rule_nrxn[$irule], $rule_timing[$irule], $eff;
+        $t_tot += $rule_timing[$irule];
+        $n_tot += $rule_nrxn[$irule];
+    }
+    my $eff = ($n_tot) ? $t_tot / $n_tot : 0.0;
+    printf "Total   : %5d reactions %.2e CPU s %.2e CPU s/rxn\n", $n_tot, $t_tot, $eff;
+
+	
+	# this is used in visualization, where a network is generated, but not written.
+	return if ($params{write}==0);
+	
+    # Print result to netfile
+    my $err = $model->writeNetwork($params_writeNetwork);
+    if ($err) { return $err; }
+	
+	# STATISTICAL FACTOR FOR REACTIONS- DEBUGGING
+	# OUTPUTS A FILE FOR EACH RULE 
+	# SHOWING REACTION INSTANCES AND LUMPING
+	# DURING generate_network()
+	# NAME YOUR RULES FIRST!
+	# - JOHN SEKAR
+	
+	my $aut = $BNGModel::GLOBAL_MODEL->Params->{'write_autos'};
+	if($aut==1)
+	{
+	foreach my $rxn(@{$model->RxnList->Array})
+		{
+		my $str = $rxn->toString(1);
+		my %inst = %{$rxn->InstanceHash};
+		my @k = keys %inst;
+		foreach my $rule(@k)
+			{
+			my $modelname = $BNGModel::GLOBAL_MODEL->Name;
+			my $rulename = $rule;
+			my $filename = join("_",($modelname,$rulename,"StatFactorCalculation")).".txt";
+			open(my $autfile,">>",$filename) or die "Not found!";
+			print $autfile "\nReaction\n".$str;
+			print $autfile "\nLumpFactor ".$inst{$rule};
+			print $autfile "\nReactionStatFactor: RuleStatFactor*LumpFactor = ".$rxn->StatFactor."\n";
+			close($autfile);
+			}
+		}
+	}
+
+    return '';
+
+
+    ###
+    ###
+
+
+    sub report_iter
+    {
+        my $niter = shift @_;
+        my $nspec = shift @_;
+        my $nrxn  = shift @_;
+        my $t_start_iter = @_ ? shift @_ : undef;
+
+        printf "Iteration %3d: %5d species %6d rxns", $niter, $nspec, $nrxn;
+        my $t_cpu = defined $t_start_iter ? cpu_time(0) - $t_start_iter : 0;
+        printf "  %.2e CPU s", $t_cpu;
+        if ($HAVE_PS) {
+            my ( $rhead, $vhead, $rmem, $vmem ) = split ' ', `ps -o rss,vsz -p $$`;
+            printf " %.2e (%.2e) Mb real (virtual) memory.",
+                    $t_cpu, $rmem / 1000, $vmem / 1000;
+        }
+        printf "\n";
+    }
+
+}
+
+
+
+###
+###
+###
+
+
+
+# given a generic program name, returns the specific executable binary.
+#  returns empty string if binary can't be found
+sub findExec
+{
+    use Config;
+    my $prog = shift @_;
+
+    my $base = BNGpath( "bin", $prog );
+    my $arch = $Config{myarchname};
+    
+    # First look for generic binary in BNGpath
+    my $exec = $base;
+    if ($arch =~ /MSWin32/) { $exec .= ".exe"; }
+    if (-x $exec) { return $exec; }
+
+    # Then look for OS-specific binary
+    $exec = "${base}_${arch}";
+    if ($arch =~ /MSWin32/){
+    		my $bitness = $Config{longsize}*8;
+    		$exec .= "-${bitness}bit" . ".exe";
+    }
+
+    if (-x $exec) { return $exec; }
+    else
+    {
+        print "findExec: $exec not found.\n";
+        return '';
+    }
+}
+
+
+
+###
+###
+###
+
+
+
+# get output prefix = outputDir/modelName[_outputSuffix]
+sub getOutputPrefix
+{
+    my $model = shift @_;
+    my $file_prefix = @_ ? shift @_ : $model->Name;
+
+    my $is_absolute = File::Spec->file_name_is_absolute( $file_prefix );
+
+    if ( $model->Params->{suffix} )
+    {   $file_prefix .= '_' . $model->Params->{output_suffix};   }
+
+    if ($is_absolute or $model->getOutputDir() eq "")
+    {
+        return $file_prefix;
+    }
+    else
+    {
+        return File::Spec->catfile( ($model->getOutputDir()), $file_prefix );
+    }
+}
+
+###
+###
+
+# set the output directory, defaults to curdir if no argument is provided 
+sub setOutputDir
+{
+    my $model = shift @_;
+    my $dir   = @_ ? shift @_ : undef;
+
+    unless (defined $dir)
+    {   # default to current directory
+        $dir = File::Spec->curdir();
+    }
+
+    # set output directory
+    $model->Params->{output_dir} = $dir;
+}
+
+###
+###
+
+# get the output directory
+sub getOutputDir
+{
+    my $model = shift @_;
+
+    unless ( defined $model->Params->{output_dir} )
+    {   # output directory not defined, set to default
+        $model->setOutputDir();
+    }
+
+    return $model->Params->{output_dir};
+}
+
+
+
+###
+###
+###
+
+1;
+

data/bionetgen/Perl2/BNGOptions.pm

@@ -0,0 +1,66 @@
+package BNGOptions;
+use strict;
+use warnings;
+
+use Getopt::Long;
+use Class::Struct;
+
+use BNGMessages qw(error warning message);
+
+struct BNGOptions => {
+	config=>    '%',
+	nored=>		'@',      
+};
+
+#begin GetBNGOptions
+sub GetBNGOptions
+{
+	my $self = shift;
+	$self->config->{macro}='';         #default value (false) - enable macromodel
+	$self->config->{silent}='';        #default value (false) - disable all (my only) messages
+	$self->config->{debug}= 1;         #default value (false) - enable debug mode (debug output files)
+	$self->config->{bnglfile}='';
+	$self->config->{filetype}='';
+	$self->config->{prefix}='';
+	$self->config->{ModelID}='';
+	$self->config->{MAX_LEVEL}=5;       #sets maximum level of allowed recursion
+	
+	
+	GetOptions ('silent' => \$self->config->{silent},
+	            'macro' => \$self->config->{macro},
+	            'debug' => \$self->config->{debug},
+	            'nored=s'=> \@{$self->nored});
+
+	if ($self->config->{macro})
+	{
+		$self->config->{ModelID}="BNGModels::MacroBNGModel";
+	}
+	else
+	{
+		$self->config->{ModelID}="BNGModels::MicroBNGModel";
+	}
+	
+	local $SIG{'__DIE__'} = sub { };
+	local $SIG{'__WARN__'} = sub { };
+	eval 'use '.$self->config->{ModelID};
+	if ($@) {
+		@_ = split( "\n", $@ );
+		$_ = join( "\n\t", @_ );
+        error("Module $self->config->{ModelID} not loaded because: \n\t$_");
+	}
+	else
+	{
+		eval 'use '.$self->config->{ModelID};
+	}
+	
+	for my $file(@ARGV)
+	{
+	  error("File $file does not have required .bngl extension.") unless ( ($file=~ /[.]bngl/));
+	  $self->config->{bnglfile}=$file;
+	  $self->config->{prefix}=$file;
+	  $self->config->{prefix}=~ s/[.]([^.]+)$//;
+	  $self->config->{filetype}=uc("bngl");
+	}
+}
+#end GetBNGOptions
+1;

data/bionetgen/Perl2/BNGUtils.pm

@@ -0,0 +1,599 @@
+package BNGUtils;
+# TODO use strict;
+
+# Perl Modules
+use FindBin;
+use lib $FindBin::Bin;
+use File::Spec;
+use Cwd;
+use List::Util ("sum");
+
+use constant VERSION_FILENAME => "VERSION";
+use constant DEFAULT_VERSION  => "UNKNOWN";
+use constant DEFAULT_CODENAME => "";
+
+
+require Exporter;
+our @ISA = qw( Exporter );
+our @EXPORT = qw( BNGversion BNGcodename compareVersions isReal booleanToInt BNGroot BNGpath exit_error send_warning cpu_time average_runs create_sbml 
+	              head split_obj split_comp verify_pattern process_val_string
+		          validate_rate_law MIN MAX SQR log10 );
+
+# Jim Faeder 3/13/2005.
+{
+    my $BNG_VERSION;
+    my $BNG_CODENAME;
+    my $BNG_ROOT;
+
+    # find the BNG root directory
+    sub BNGroot
+    {
+        unless ($BNG_ROOT)
+        {   # Determine BNG root directory
+
+            # Use environment variable BNGPATH, if defined and valid
+            if ( exists $ENV{BNGPATH} ) 
+            {
+	            my $bin_dir = File::Spec->catdir( ($ENV{BNGPATH}) );
+                if ( -d $bin_dir )
+                {   $BNG_ROOT = $bin_dir;   }
+                else
+                {   send_warning( "While looking for BNG root: environment variable 'BNGPATH' does not point to a valid directory!" );   }
+            }
+            # Use environment variable BioNetGenRoot, if defined and valid
+            elsif ( exists $ENV{BioNetGenRoot} )
+            {
+	            my $bin_dir = File::Spec->catdir( ($ENV{BioNetGenRoot}) );
+                if ( -d $bin_dir )
+                {   $BNG_ROOT = $bin_dir;   }
+                else
+                {   send_warning( "While looking for BNG root: environment variable 'BioNetGenRoot' does not point to a valid directory!" );   }
+            }
+
+
+            # Otherwise, try the same
+            unless ( defined $BNG_ROOT )
+            {
+                if (-d $FindBin::RealBin)
+                {   $BNG_ROOT = $FindBin::RealBin;   }
+                else
+                {   send_warning( "While looking for BNG root: could not get RealBin directory!" );   }
+            }
+
+            # As last resort, try current working directory
+            unless ( defined $BNG_ROOT )
+            {   
+                $BNG_ROOT = Cwd::getcwd();
+                send_warning( "While looking for BNG_ROOT: defaulting to current working directory!" );    
+            }
+        }
+        return $BNG_ROOT;
+    }
+  
+    sub BNGpath
+    {
+        unless ($BNG_ROOT)
+        {   # find BNG root directory
+            BNGroot();
+        }
+        return File::Spec->catdir( ($BNG_ROOT, @_) );
+    }
+
+    # extract BNG_VERSION and BNG_CODENAME from the version file located
+    #  at BNG_ROOT/VERSION.
+    sub readVersionFile
+    {
+        unless ($BNG_ROOT)
+        {   # find BNG root directory
+            BNGroot();
+        }
+
+        # Get BioNetGen version number
+        unless (defined $BNG_VERSION)
+        {
+            # read version info from VERSION file
+            if ( open my $fh, '<', File::Spec->catfile($BNG_ROOT, VERSION_FILENAME) )
+            {
+                # get first line of file
+                my $version_string = <$fh>;
+	            close $fh;
+	            
+                # extract version number
+   				$version_string =~ s/^\s*(\d+\.\d+\.\d+)\s*//;
+	            
+                $BNG_VERSION = $1;
+                unless ( defined $BNG_VERSION )
+                {   $BNG_VERSION = DEFAULT_VERSION;   }
+
+                # extract codename (if any)
+                $version_string =~ s/^(\w+)//;
+                $BNG_CODENAME = $1;
+                unless ( defined $BNG_VERSION )
+                {   $BNG_CODENAME = DEFAULT_CODENAME;   }
+            } 
+            else
+            {
+	            $BNG_VERSION  = DEFAULT_VERSION;
+                $BNG_CODENAME = '';
+            }
+        }
+        return;
+    }
+
+    # get BNG_VERSION
+    sub BNGversion
+    {
+        unless (defined $BNG_VERSION)
+        {   # find BNG root directory
+            readVersionFile();
+        }
+        return $BNG_VERSION;
+    }
+
+    # get BNG_CODENAME
+    sub BNGcodename
+    {
+        unless (defined $BNG_CODENAME)
+        {   # find BNG root directory
+            readVersionFile();
+        }
+        return $BNG_CODENAME;
+    }
+
+    # compare versions: returns -1 if version1  < version2,
+    #                            1 if version1  > version2,
+    #                            0 if version1 == version2
+    sub compareVersions
+    {
+        my ($version1, $version2) = @_;
+        
+        my (@version1) = split (/\./, $version1);
+        my (@version2) = split (/\./, $version2);
+
+        # compare major, minor and release numbers
+        while (@version1 and @version2)
+        {
+            my $comp = ( shift @version1 <=> shift @version2 );
+            if ($comp) {  return $comp;  }
+        }
+        
+        # if versions are equal so far, the version with finer defintion
+        #  is greater than the other.
+        # (e.g.  2.1.7 is greater than 2.1)
+        return ( @version1 ? 1 : (@version2 ? -1 : 0) );
+    }
+}
+
+
+# Determine if a string corresponds to a float or a double
+sub isReal{
+  my $string=shift;
+  my $isdec=0;
+
+  if ($string=~ s/^[+-]?\d+[.]?\d*//){
+    $isdec=1;
+  }
+  elsif ($string=~ s/^[+-]?[.]\d+//){
+    $isdec=1;
+  } else {
+    return(0);
+  }
+  if ($string eq ""){return(1);}
+
+  if ($string=~ s/^[DEFGdefg][+-]?\d+$//){
+    return(1);
+  }
+  return(0);
+}
+
+# Determine if a string is a Boolean
+sub isBoolean{
+  my $string=shift;
+  my $isboo;
+
+  if ($string=~/^true$/i){
+    $isboo=1;
+  } elsif ($string=~/^false$/i){
+    $isboo=1;
+  } else {
+    $isboo=0;
+  }
+  return($isboo);
+}
+
+# Convert boolean to integer False=0 True=1 notBoolean=-1
+sub booleanToInt{
+  my $string=shift;
+  my $intval;
+
+  if ($string=~/^true$/i){
+    $intval=1;
+  } 
+  elsif ($string=~/^false$/i){
+    $intval=0;
+  } 
+  # Boolean that is not a assigned a value is True by default
+  elsif ($string eq ""){
+    $intval=1;
+  }
+  else {
+    $intval=-1;
+  }
+  return($intval);
+}
+ 
+##---------------------------------------------------------------------------
+# Check that a pattern referring to species objects is valid.
+
+sub verify_pattern{
+  my $pattern= shift;
+  my $is_spec= shift;
+  my $mol_ncomp= shift;
+  
+  $patt=$pattern;
+  # remove valid termination characters
+  $patt=~s/\.\*$//;
+  $patt=~s/\*$//;
+  
+  # split pattern into molecules and check that each is valid
+  my @molecules= split('\.',$patt);
+  for my $mol (@molecules){
+    my ($head, @components)= split_obj($mol);
+    if ($head eq $mol){
+      if ($#molecules>0){
+	return(1, "Single state species $head may not appear in a complex.")
+      } 
+      elsif (!defined($$is_spec{$mol})){
+	return(0, "Species not declared: $pattern");
+      }
+    } else {
+      # Check that number of components matches species declaration 
+      if (!defined($$mol_ncomp{$head})){
+	return(1, "Molecule $head not defined.");
+      } elsif ($$mol_ncomp{$head}!= $#components){
+	return(1, "Number of components for molecule $head doesn't match species declaration.");
+      }
+
+      # Check that each component is valid
+      for my $comp (@components){
+	if ($comp=~/[^0-9\*]/){
+	  return(1, "Invalid component state $comp: May only use integers or wildcard.",$entry);
+	}
+#	if ($comp=~/[^A-Za-z0-9_\-\*]/){
+#	  return(1, "Invalid component state $comp in pattern $pattern: May only use alphanumeric characters, '-','_', or '*'.");
+#	}
+      }
+    }
+  }
+  
+  if ($#molecules<0){
+    return(1, "No molecules specified in matching string\n");
+  }    
+  return(0,"");
+}
+
+##---------------------------------------------------------------------------
+# Handle a value that is either a number, a parameter name, or a
+# product of a number and a parameter name.
+
+sub process_val_string{
+    my $val_string= shift;
+    my $entry= shift;
+    my $parameters= shift;
+
+    my ($fac,$val, $value);
+    
+    $value=$val_string;
+    if ($value=~/(\S+)[*](\S+)/){
+      $fac= $1;
+      $val=$2;
+    } else {
+      $fac= 1;
+      $val=$value;
+    }
+
+    # Make sure val is valid parameter if it is not a number.
+    # NOTE: The checking here would be much easier with a perl routine
+    # isnum(string) (which is part of Acme::Utils) that returns true if the
+    # string is a number (in the C/Fortran sense).  I didn't use this routine
+    # because it requires installation of additional perl modules, which might
+    # be beyond the capabilities of our target user.
+    if ($val=~/^[a-zA-Z]/){
+      # Determine if parameters are allowed
+      ($parameters) || exit_error("Parameter not allowed for value.",$entry);
+      # Make sure parameter is valid
+      defined($$parameters{$val}) || exit_error("Parameter $val is not defined.",$entry);
+      # Make sure value is non-negative
+      if ($$parameters{$val}{val}<0){exit_error("Parameter value must be non-negative.",$entry);}
+      $value= $fac*$$parameters{$val}{val};
+    } else {
+      # Substitute numerical value 
+      $value= $fac*$val;
+      # Make sure value is non-negative
+      if ($value<0){&exit_error("Parameter value must be non-negative",$entry);}
+    }
+
+#    print "fac:$fac val:$val value:$value\n";
+    return($value);
+}
+
+
+# Send error message to STDERR and exit.
+sub exit_error
+{
+    my @msgs = @_;
+    print STDERR "ABORT: ";
+    foreach my $msg (@msgs)
+    {
+	    print STDERR $msg, "\n";
+    }
+    exit(1);
+}
+
+
+# Send error message to STDERR, but do not exit.
+sub send_error
+{
+    my @msgs = @_;
+    print STDERR "ERROR: ";
+    foreach my $msg (@msgs)
+    {  print STDERR $msg, "\n";  }
+    return 0;
+}
+
+
+# send warning to STDOUT
+sub send_warning
+{
+    my @msgs = @_;
+    print STDOUT "WARNING: ";
+    foreach my $msg (@msgs)
+    {  print STDOUT $msg,"\n";  }
+    # Could have $STRICT flag to force exit
+    return 0;
+}
+
+
+# send error message with line number
+sub line_error
+{
+    my ($msg, $lno) = @_;
+    print STDERR sprintf( "ABORT: [at line %s] %s\n", $lno, $msg );
+    exit 1;
+}
+
+# send warning message with line number
+sub line_warning
+{
+    my ($msg, $lno) = @_;
+    print STDOUT sprintf( "WARNING: [at line %s] %s\n", $lno, $msg );
+}
+
+
+##------------------------------------------------------------------------
+# Used to create list of all multi-state objects from a list of
+# dimensions.  It returns an array containing all elements of the
+# multidimensional array named $name.  
+# e.g. expand_object("R", 2,2) returns the array
+# (R(0,0), R(1,0), R(0,1), R(1,1)
+# Earlier indices vary faster than later ones.
+
+sub expand_object{
+    my $name= shift;
+    my @lengths=@{$t=shift};
+    my @equiv=@{$t=shift};
+    my @olist=("");
+
+    for my $i (0..$#lengths){
+	my @new_olist=();
+	my $sep= ($i==$#lengths) ? "" : ",";
+	# array of earlier indices that are equivalent to index $i
+	my @eq=();
+	if (my $class= $equiv[$i]){
+	    for $j (0..$i-1){
+		($equiv[$j]==$class) && push @eq,$j;
+	    }
+	}
+	for $state (0..($lengths[$i]-1)){
+	  OBJ:
+	    for $obj (@olist){
+		# Skip this object if the current state is greater
+    	        # than the state of index equivalent to the current one.
+		if (@eq){
+		    my @states=split(',',$obj);
+		    for $j (@eq){
+			($state>$states[$j]) && next OBJ;
+		    }
+		}
+		push @new_olist, $obj.$state.$sep;
+	    }
+	}
+	@olist= @new_olist;
+    }
+
+    # Enclose indices in parentheses and prepend spcies name
+    for $obj (@olist){
+	$obj= $name."(".$obj.")";
+    }
+
+    return(@olist);
+}
+
+##---------------------------------------------------------------------------
+# Create aggregates from lists of species in rows of matrix a.
+# This subroutine uses a depth first algoritm, meaning here that the
+# most distant index changes fastest.
+# The second subroutine uses a breadth first algoritm, meaning here that the
+# most nearest index changes fastest.
+##---------------------------------------------------------------------------
+
+sub make_aggregates{
+    my @a= @{$t= shift};
+
+    my $idepth=0;
+    my $max_depth=$#a;
+    my @olist=();
+    my @agg=();
+    my %agg_hash=();
+
+    for $i (0..$#a){$iptrs[$i]=0;}
+    push @olist, $a[0][0];
+    
+    while(1){
+	#descend until idepth==max_depth
+	while($idepth<$max_depth){
+	    ++$idepth;
+	    last if ($idepth==$max_depth);
+	    # set ptr at new depth to start of array
+	    $iptrs[$idepth]=0;
+	    push @olist, $a[$idepth][0];
+	}
+	
+	# loop over ptrs at lowest depth
+	my @obj_low= @{$a[$max_depth]};
+#	my $eq=$equiv[$idepth];
+	for $obj (@obj_low){
+	    push @olist, $obj;
+	    my $new_agg= join(".", sort by_obj @olist);
+	    my $new_agg_sort= join(".", sort by_obj @olist);
+	    # Only add aggregate that is in sort order
+	    #($new_agg eq $new_agg_sort) && push @agg, $new_agg;
+	    # Another way is to add aggregate first time it is encountered
+	    ($agg_hash{$new_agg}++==0) && push @agg, $new_agg;
+	    pop @olist;
+	}
+	
+	# go back up to depth where elements are not exhausted
+	# stop when no more elements at any level
+	while($idepth>=0){
+	    --$idepth;
+	    last if ($idepth<0);
+	    pop @olist;
+	    if (($iptr=++$iptrs[$idepth])<=$#{$a[$idepth]}){
+		push @olist, $a[$idepth][$iptr];
+		last;
+	    }
+	}
+	last if ($idepth<0);
+    }
+#    print join("\n", @agg),"\n";
+    return(@agg);
+}
+
+##------------------------------------------------------------------------
+# Returns the total cputime (user+system) of the current process and
+# all children since the last call to cpu_time.
+# Optional argument can be used to reset the offset.
+# Call cpu_time(0) to tare (i.e. "zero") the clock.
+{
+    my $store_time=0;
+    sub cpu_time
+    {
+        my $prev_time = @_ ? shift @_ : $store_time;
+        my $curr_time = sum times;
+        $store_time = $curr_time;
+        return $curr_time - $prev_time;
+    }
+}
+
+# Compute average and standard deviation over a set of data in
+# format 
+#   time1 y1 ... yN
+#   ...
+#   timeM y1 ... yN
+# 
+
+# This routine returns data sets in xmgrace format.
+# Sets are written separately, in format time val dval, where dval
+# is the standard deviation of the average over all runs.
+
+sub average_runs{
+  my $outfile=shift;
+
+  my $nfile=0;
+  my @t=();
+  my $ng;
+  for my $file (@_){
+    open(IN, $file);
+    my $i_t=0;
+    while(<IN>){
+      next if (/^\#/);
+      my($time, @dat)=split(' ');
+      if ($nfile==1){
+	push @t, $time;
+	$ng= $#dat;
+      }
+      for my $j(0..$#dat){
+	$y[$i_t][$j][$nfile]= $dat[$j];
+      }
+      ++$i_t;
+    }
+    close(IN);
+    ++$nfile;
+  }
+
+  # Write results to outfile
+  open(OUT,">$outfile");
+    for $j (0..$ng){
+      for my $i (0..$#t){
+	print OUT $t[$i];
+	my ($sig, $avg)= &stddev(@{$y[$i][$j]});
+	print OUT " ", $avg;
+	print OUT " ", $sig;
+	print OUT "\n";
+      }
+      print OUT "&\n";
+  }
+  close(OUT);
+}
+
+sub average{
+    return -1 unless $#_>=0;
+    local($sum)=0.0;
+    foreach $val (@_){
+        $sum+=$val;
+    }
+    return $sum/($#_+1);
+}
+
+sub stddev{
+    return -1 unless $#_>=0;
+    local($sum)=0.0;
+    local($average)= &average(@_);
+    foreach $val (@_){
+        $sum+=SQR($val-$average);
+    }
+    return (sqrt($sum/$#_), $average); # This is the correct formula for the 
+                                       # variance---denom contains (n-1)
+}
+
+# Basic utilities
+
+sub SQR{
+    local($x)=shift;
+    return ($x*$x);
+}
+
+
+sub log10 {
+  my $x=shift;
+  return log($x)/log(10);
+}
+
+sub MAX{
+  my $a=shift;
+  my $b=shift;
+
+  return(($a>=$b)? $a : $b);
+}
+
+sub MIN{
+  my $a=shift;
+  my $b=shift;
+
+  return(($a<=$b)? $a : $b);
+}
+
+sub bynum {$a<=>$b;}
+
+1;

data/bionetgen/Perl2/Boolean2BNGL/ABC_example.txt

@@ -0,0 +1,7 @@
+A = False
+B = False
+C = True
+
+1: A* = B or C
+1: B* = not A and C
+1: C* = A and not C

data/bionetgen/Perl2/Boolean2BNGL/Boolean2BNGL.pl

@@ -0,0 +1,222 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use File::Spec;
+
+my @NODES = ();
+
+my @parameters = ();
+my @molecule_types = ();
+my @seed_species = ();
+my @observables = ();
+my @functions = ();
+my @reaction_rules = ();
+
+my $file = shift @ARGV;
+
+my $update_mode = (@ARGV) ? shift @ARGV : 'GSP'; # ROA, GA, GSP
+$update_mode =~ tr/a-z/A-Z/; # make upper case
+if ( $update_mode eq 'ROA' || $update_mode eq 'GA' || $update_mode eq 'GSP' ){
+	printf "Boolean update mode: '$update_mode'\n";
+}
+else{
+	printf "Boolean update mode '$update_mode' not recognized. Allowed modes are 'ROA', 'GA', and 'GSP'.\n";
+}
+
+my $include_reset = ($update_mode eq 'GSP') ? 0 : 1;
+
+# determine output filename
+if (not File::Spec->file_name_is_absolute( $file )){
+	$file = File::Spec->rel2abs($file);
+}
+my ($vol, $dir, $filename) = File::Spec->splitpath( $file );
+my $outfile = $filename;
+$outfile =~ s/\.\w+$/_$update_mode\.bngl/;
+$outfile = File::Spec->catfile( $vol, $dir, $outfile );
+
+# read entire file as a string
+local $/ = undef;
+open FILE, $file or die "Couldn't open file: $!";
+binmode FILE;
+my $text = <FILE>;
+close FILE;
+$text =~ s/\r\n*/\n/g; # remove Windows-style carriage returns
+my @lines = split('\n', $text);
+
+# read line-by-line
+my $n_rules = 0;
+foreach my $line (@lines) 
+{ 
+	$line =~ tr/A-Z/a-z/; # Make everything lower case
+    if ( $line =~ /^\s*(\w+)\s*=\s*([t|f])/ )
+    {
+		# MOLECULE TYPES
+		my $mt = $1;
+		$mt .= "(state~0~1";
+		if ($include_reset){ $mt .= ",reset~N~Y" }
+		$mt .= ")";
+		push @molecule_types, $mt;
+		
+		# SEED SPECIES
+		my $ss = $1;
+		my $state = ($2 eq 't') ? '1' : '0';
+		$ss .= "(state~$state";
+		if ($include_reset){ $ss .= ",reset~N"; }
+		$ss .= ") 1";
+		push @seed_species, $ss;
+		
+		# OBSERVABLES
+		my $obs = $1;
+		$obs =~ tr/a-z/A-Z/; # Make observable names all upper case
+		$obs = "Molecules " . $obs . " " . $1 . "(state~1)";
+		push @observables, $obs;
+    }
+    elsif( $line =~ /^\s*(\d+):\s*(\w+)\*\s*=\s*(.+)/ )
+    {
+	    	my $rank = $1;
+	    	my $node = $2;
+	    	my $func = $3;
+	    	
+	    	push @NODES, $node;
+	    	
+	    	# FUNCTIONS
+	    	my $fname = "${node}_func()";
+	    	
+	    	$func =~ tr/a-z/A-Z/;            # make everything upper case
+	    	$func =~ s/\(\s+/\(/g;           # remove whitespace after '(' character
+	    	$func =~ s/\s+\)/\)/g;           # remove whitespace before ')' character
+	    	$func =~ s/\s+or\s+/ \|\| /ig;   # replace 'or' with '||'
+	    	$func =~ s/\s+and\s+/ \&\& /ig;  # replace 'and' with '&&'
+	    	$func =~ s/(\s*)not\s+/$1!/ig;   # replace 'not' with '!' (also remove trailing whitespace)
+	    	$func =~ s/(\w+)/$1>0.5/g;       # replace all 'ABC' with 'ABC>0.5'
+	    	$func =~ s/!(\w+)>0.5/$1<0.5/g;  # replace all '!ABC>0.5' with 'ABC<0.5'
+	    	
+	    	$func = "$fname if($func, 1, 0)";
+	    	push @functions, $func;
+
+		# RULES
+		my $rate = "1";
+		if ($rank > 1){ $rate .= "/$rank"; }
+		
+		$n_rules++;
+		my $rule_f = "R" . $n_rules . ": $node(state";
+		if ($include_reset){ $rule_f .= ",reset~N"; }
+		$rule_f .= ") -> $node(state~1";
+		if ($include_reset){ $rule_f .= ",reset~Y"; }
+		$rule_f .= ") if($fname>0.5,$rate,0)";
+		push @reaction_rules, $rule_f;
+		
+		$n_rules++;
+		my $rule_r = "R" . $n_rules . ": $node(state"; 
+		if ($include_reset){ $rule_r .= ",reset~N"; }
+		$rule_r .= ") -> $node(state~0";
+		if ($include_reset){ $rule_r .= ",reset~Y"; }
+		$rule_r .= ") if($fname<0.5,$rate,0)";			
+		push @reaction_rules, $rule_r;
+    }
+}
+
+if ($update_mode eq 'GA'){
+	push @reaction_rules, "\n   # reset rules";
+	foreach my $node (@NODES){
+		$n_rules++;
+		my $rule = "R" . $n_rules . ": $node(reset~Y) -> $node(reset~N) 1e10";
+		push @reaction_rules, $rule;
+	}
+}
+elsif ($update_mode eq 'ROA'){
+	push @parameters, "N_NODES " . scalar(@NODES);
+	unshift @molecule_types, "RESET(reset~N~Y)\n   #";
+	unshift @seed_species, "RESET(reset~N) 1\n   #";
+	my $obs = "Molecules N_FIRED";
+	foreach my $node (@NODES){
+		$obs .= " $node(reset~Y)"
+	}
+	unshift @observables, $obs . "\n   #";
+	push @reaction_rules, "\n   # reset rules";
+	$n_rules++;
+	push @reaction_rules, "R" . $n_rules . ": RESET(reset~N) <-> RESET(reset~Y)  1e10*if(N_FIRED>(N_NODES-0.5),1,0), 1e10*if(N_FIRED<0.5,1,0)";
+	foreach my $node (@NODES){
+		$n_rules++;
+		my $rule = "R" . $n_rules . ": $node(reset~Y) + RESET(reset~Y) -> $node(reset~N) + RESET(reset~Y) 1e10";
+		push @reaction_rules, $rule;
+	}
+}
+
+# Print to file
+open FILE, ">", $outfile or die "Couldn't open file: $!";
+
+print FILE "# Translation of Boolean model in " . $filename . " to BNGL format within the " . $update_mode . " (" . 
+	( ($update_mode eq 'ROA') ? "random-order asynchronous" : ($update_mode eq 'GA') ? "general asynchronous" :
+	($update_mode eq 'GSP') ? "Gillespie" : "UNKNOWN" ) . ") update mode.\n";
+
+print FILE "begin model\n";
+
+print FILE "begin parameters\n";
+foreach my $i (@parameters){
+	print FILE "   $i\n";
+}
+print FILE "end parameters\n";
+
+print FILE "begin molecule types\n";
+foreach my $i (@molecule_types){
+	print FILE "   $i\n";
+}
+print FILE "end molecule types\n";
+
+print FILE "begin seed species\n";
+foreach my $i (@seed_species){
+	print FILE "   $i\n";
+}
+print FILE "end seed species\n";
+
+print FILE "begin observables\n";
+foreach my $i (@observables){
+	print FILE "   $i\n";
+}
+print FILE "end observables\n";
+
+print FILE "begin functions\n";
+foreach my $i (@functions){
+	print FILE "   $i\n";
+}
+print FILE "end functions\n";
+
+print FILE "begin reaction rules\n";
+foreach my $i (@reaction_rules){
+	print FILE "   $i\n";
+}
+print FILE "end reaction rules\n";
+
+print FILE "end model\n";
+
+# actions
+print FILE "\n";
+print FILE "# generate_network({overwrite=>1})\n\n";
+
+my $n_nodes = scalar(@NODES);
+
+if ($update_mode eq 'ROA'){
+	my $n_rounds = 15;
+	print FILE "# Simulate for N_ROUNDS = 15 update rounds, outputting every round. Note that with N_NODES = $n_nodes, the\n";
+	print FILE "# average time for each update round is 1 + 1/2 + 1/3 + ... + 1/$n_nodes < $n_nodes. Thus, 't_end' is set to\n";
+	print FILE "# $n_nodes*$n_rounds*100 (N_NODES*N_ROUNDS*100), a number large enough to ensure that 'max_sim_steps' is reached first.\n";
+	print FILE "#\n";
+	print FILE "# simulate({method=>\"ssa\",t_end=>($n_nodes*$n_rounds*100),output_step_interval=>($n_nodes*2+2),max_sim_steps=>(($n_nodes*2+2)*$n_rounds),print_CDAT=>0,verbose=>1})\n";
+}
+elsif ($update_mode eq 'GA'){
+	print FILE "# Simulate for 30 time units, outputting every time unit.\n";
+	print FILE "#\n";
+	print FILE "# simulate({method=>\"ssa\",t_end=>30,n_steps=>30,print_CDAT=>0,verbose=>1})\n\n";
+	
+	print FILE "# Simulate for 30 \"update rounds\", outputting every round. This allows for a comparison with the ROA update scheme.\n";
+	print FILE "# With N_NODES = $n_nodes, each round corresponds to $n_nodes*2 reaction firings (one state-change and one reset rule per node).\n";
+	print FILE "# On average, this takes one time unit. Thus, 't_end' is set to 30*100 to ensure that 'max_sim_steps' is reached first.\n";
+	print FILE "#\n";
+	print FILE "# simulate({method=>\"ssa\",t_end=>(30*100),output_step_interval=>($n_nodes*2),max_sim_steps=>(($n_nodes*2)*30),print_CDAT=>0,verbose=>1})\n";
+}
+elsif ($update_mode eq 'GSP'){
+	print FILE "# Simulate for 30 time units, outputting every time unit.\n";
+	print FILE "# simulate({method=>\"ssa\",t_end=>30,n_steps=>30,print_CDAT=>0,verbose=>1})\n";
+}

data/bionetgen/Perl2/Boolean2BNGL/Tcell_model_Nov2013_LAH.txt

@@ -0,0 +1,110 @@
+FLUSH = False
+TCR = False
+TCR_LOW = False
+TCR_HIGH = True
+CD28 = True
+TGFBETA = False
+IL2 = False
+IL2R = False
+AP1 = False
+FOS = False
+FOS_D =False
+FOS_DD = False
+FOS_DDD = False
+JUN = False
+ERK = False
+MEK2 = False
+TAK1 = False
+MKK7 = False
+JNK = False
+RAF = False
+RAS = False
+CA = False
+NFAT = False
+PKCTHETA = False
+NFKAPPAB = False
+PI3K_LOW = False
+PI3K_HIGH = False
+PI3K = False
+PIP3_LOW = False
+PIP3_HIGH = False
+PIP3 = False
+PTEN = True
+PDK1 = False
+AKT = False
+MTORC1 = False
+MTORC2 = False
+MTOR = False
+MTORC1_D = False
+MTORC2_D = False
+MTORC2_DD = False
+MTOR_D = False
+MTOR_DD = False
+MTOR_DDD = False
+MTOR_DDDD = False
+RHEB = False
+TSC = True
+S6K1 = False
+PS6 = False
+SMAD3 = False
+JAK3 = False
+STAT5 = False
+STAT5_D = False
+STAT5_DD = False
+STAT5_DDD = False
+FOXP3 = False
+CD25 = False
+CD122 = True
+CD132 = True
+IL2_EX = False
+AKT_OFF = False
+MTORC1_OFF = False
+NFAT_OFF = False
+
+1: TCR_HIGH* = not FLUSH
+1: TCR* = TCR_LOW or TCR_HIGH
+1: RAS* = (TCR and CD28) or (RAS and IL2_EX and IL2R)
+1: RAF* = RAS
+1: MEK2* = RAF
+1: ERK* = MEK2
+1: FOS* = ERK
+1: PKCTHETA* = TCR_HIGH or (TCR_LOW and CD28 and MTORC2)
+1: TAK1* = PKCTHETA
+1: MKK7* = TAK1
+1: JNK* = MKK7
+1: JUN* = JNK
+1: FOS_D* = FOS
+1: FOS_DD* = FOS_D
+1: AP1* = FOS_DD and JUN
+1: CA* = TCR
+1: NFKAPPAB* = PKCTHETA or AKT
+1: NFAT* = CA and not NFAT_OFF
+1: IL2* = ((AP1 and NFAT and NFKAPPAB) or IL2) and not FOXP3
+1: IL2R* = CD25 and CD122 and CD132
+1: PI3K_LOW* = (TCR_LOW and CD28) or (PI3K_LOW and IL2_EX and IL2R)
+1: PI3K_HIGH* = (TCR_HIGH and CD28) or (PI3K_HIGH and IL2_EX and IL2R)
+1: PI3K* = PI3K_LOW or PI3K_HIGH
+1: PIP3_HIGH* = PI3K_HIGH and not PTEN
+1: PIP3_LOW* = PI3K_LOW and not PTEN
+1: PIP3* = PIP3_LOW or PIP3_HIGH
+1: PDK1* = PIP3
+1: AKT* = PDK1 and MTORC2 and not AKT_OFF
+1: TSC* = not AKT
+1: RHEB* = not TSC
+1: MTORC1* = RHEB and not MTORC1_OFF
+1: MTORC2* = PI3K_HIGH or (PI3K_LOW and not S6K1)
+1: MTORC1_D* = MTORC1 
+1: MTORC2_D* = MTORC2
+1: MTOR* = MTORC1_D and MTORC2_D
+1: MTOR_D* = MTOR
+1: MTOR_DD* = MTOR_D
+1: S6K1* = MTORC1
+1: PS6* = S6K1
+1: SMAD3* = TGFBETA
+1: JAK3* = IL2R and IL2_EX
+1: STAT5* = JAK3
+1: STAT5_D* = STAT5
+1: FOXP3* = (not MTOR_DD and STAT5) or (NFAT and SMAD3)
+1: CD25* = FOXP3 or (AP1 and NFAT and NFKAPPAB) or STAT5
+1: PTEN* = (not TCR_HIGH and PTEN) or (not TCR_HIGH and FOXP3)
+1: IL2_EX* = IL2 or IL2_EX

data/bionetgen/Perl2/Boolean2BNGL/Tcell_model_Oct2013.txt

@@ -0,0 +1,108 @@
+TCR = False
+TCR_LOW = False
+TCR_HIGH = True
+CD28 = True
+TGFBETA = False
+IL2 = False
+IL2R = False
+AP1 = False
+FOS = False
+FOS_D =False
+FOS_DD = False
+FOS_DDD = False
+JUN = False
+ERK = False
+MEK2 = False
+TAK1 = False
+MKK7 = False
+JNK = False
+RAF = False
+RAS = False
+CA = False
+NFAT = False
+PKCTHETA = False
+NFKAPPAB = False
+PI3K_LOW = False
+PI3K_HIGH = False
+PI3K = False
+PIP3_LOW = False
+PIP3_HIGH = False
+PIP3 = False
+PTEN = True
+PDK1 = False
+AKT = False
+MTORC1 = False
+MTORC2 = False
+MTOR = False
+MTORC1_D = False
+MTORC2_D = False
+MTORC2_DD = False
+MTOR_D = False
+MTOR_DD = False
+MTOR_DDD = False
+MTOR_DDDD = False
+RHEB = False
+TSC = True
+S6K1 = False
+PS6 = False
+SMAD3 = False
+JAK3 = False
+STAT5 = False
+STAT5_D = False
+STAT5_DD = False
+STAT5_DDD = False
+FOXP3 = False
+CD25 = False
+CD122 = True
+CD132 = True
+IL2_EX = False
+AKT_OFF = False
+MTORC1_OFF = False
+NFAT_OFF = False
+
+1: TCR* = TCR_LOW or TCR_HIGH
+1: RAS* = ( TCR and CD28 ) or (RAS and IL2_EX and IL2R)
+1: RAF* = RAS
+1: MEK2* = RAF
+1: ERK* = MEK2
+1: FOS* = ERK
+1: PKCTHETA* = TCR_HIGH or (TCR_LOW and CD28 and MTORC2)
+1: TAK1* = PKCTHETA
+1: MKK7* = TAK1
+1: JNK* = MKK7
+1: JUN* = JNK
+1: FOS_D* = FOS
+1: FOS_DD* = FOS_D
+1: AP1* = FOS_DD and JUN
+1: CA* = TCR
+1: NFKAPPAB* = PKCTHETA or AKT
+1: NFAT* = CA and not NFAT_OFF
+1: IL2* = ((AP1 and NFAT and NFKAPPAB) or IL2) and not FOXP3
+1: IL2R* = CD25 and CD122 and CD132
+1: PI3K_LOW* = (TCR_LOW and CD28) or (PI3K_LOW and IL2_EX and IL2R)
+1: PI3K_HIGH* = (TCR_HIGH and CD28) or (PI3K_HIGH and IL2_EX and IL2R)
+1: PI3K* = PI3K_LOW or PI3K_HIGH
+1: PIP3_HIGH* = PI3K_HIGH and not PTEN
+1: PIP3_LOW* = PI3K_LOW and not PTEN
+1: PIP3* = PIP3_LOW or PIP3_HIGH
+1: PDK1* = PIP3
+1: AKT* = PDK1 and MTORC2 and not AKT_OFF
+1: TSC* = not AKT
+1: RHEB* = not TSC
+1: MTORC1* = RHEB and not MTORC1_OFF
+1: MTORC2* = PI3K_HIGH or (PI3K_LOW and not S6K1)
+1: MTORC1_D* = MTORC1 
+1: MTORC2_D* = MTORC2
+1: MTOR* = MTORC1_D and MTORC2_D
+1: MTOR_D* = MTOR
+1: MTOR_DD* = MTOR_D
+1: S6K1* = MTORC1
+1: PS6* = S6K1
+1: SMAD3* = TGFBETA
+1: JAK3* = IL2R and IL2_EX
+1: STAT5* = JAK3
+1: STAT5_D* = STAT5
+1: FOXP3* = (not MTOR_DD and STAT5) or (NFAT and SMAD3)
+1: CD25* = FOXP3 or (AP1 and NFAT and NFKAPPAB) or STAT5
+1: PTEN* = (not TCR_HIGH and PTEN) or (not TCR_HIGH and FOXP3)
+1: IL2_EX* = IL2 or IL2_EX

data/bionetgen/Perl2/Boolean2BNGL/Tcell_model_v16.txt

@@ -0,0 +1,20 @@
-TCR_LOW = False
-TCR_HIGH = True
-CD28 = True
-TGFBETA = False
-IL2 = False
-IL2R = False
-AP1 = False
-FOS = False
-FOS_D =False
-FOS_DD = False
-FOS_DDD = False
-JUN = False
-ERK = False
-MEK2 = False
-TAK1 = False
-MKK7 = False
-JNK = False
-RAF = False
-RAS = False
-CA = False
-NFAT = False
-PKCTHETA = False
-NFKAPPAB = False
-PI3K_LOW = False
-PI3K_HIGH = False
-PI3K = False
-PIP3_LOW = False
-PIP3_HIGH = False
-PIP3 = False
-PTEN = True
-PDK1 = False
-AKT = False
-MTORC1 = False
-MTORC2 = False
-MTOR = False
-MTORC1_D = False
-MTORC2_D = False
-MTORC2_DD = False
-MTOR_D = False
-MTOR_DD = False
-MTOR_DDD = False
-MTOR_DDDD = False
-RHEB = False
-TSC = True
-S6K1 = False
-PS6 = False
-SMAD3 = False
-JAK3 = False
-STAT5 = False
-STAT5_D = False
-STAT5_DD = False
-STAT5_DDD = False
-FOXP3 = False
-CD25 = False
-CD122 = True
-CD132 = True
-IL2_EX = False
-1: TCR* = TCR_LOW or TCR_HIGH
-1: RAS* = (TCR and CD28) or (RAS and IL2_EX and IL2R)
-1: RAF* = RAS
-1: MEK2* = RAF
-1: ERK* = MEK2
-1: FOS* = ERK
-1: PKCTHETA* = TCR_HIGH or (TCR_LOW and CD28 and MTORC2)
-1: TAK1* = PKCTHETA
-1: MKK7* = TAK1
-1: JNK* = MKK7
-1: JUN* = JNK
-1: FOS_D* = FOS
-1: FOS_DD* = FOS_D
-1: AP1* = FOS and JUN
-1: CA* = TCR
-1: NFKAPPAB* = PKCTHETA or AKT
-1: NFAT* = CA and not NFAT_OFF
-1: IL2* = ((AP1 and NFAT and NFKAPPAB) or IL2) and not FOXP3
-1: IL2R* = CD25 and CD122 and CD132
-1: PI3K_LOW* = (TCR_LOW and CD28) or (PI3K_LOW and IL2RA_D)
-1: PI3K_HIGH* = (TCR_HIGH and CD28) or (PI3K_HIGH and IL2RA_D)
-1: PI3K* = PI3K_LOW or PI3K_HIGH
-1: PIP3_HIGH* = PI3K_HIGH and not PTEN
-1: PIP3_LOW* = PI3K_LOW and not PTEN
-1: PIP3* = PIP3_LOW or PIP3_HIGH
-1: PDK1* = PIP3
-1: AKT* = (PDK1 and MTORC2) and not AKT_OFF
-1: TSC* = not AKT
-1: RHEB* = not TSC
-1: MTORC1* = RHEB and not MTORC1_OFF
-1: MTORC2* = PI3K_HIGH or (PI3K_LOW and not S6K1)
-1: MTORC1_D* = MTORC1 
-1: MTORC2_D* = MTORC2
-1: MTOR* = MTORC1_D and MTORC2_D
-1: MTOR_D* = MTOR
-1: MTOR_DD* = MTOR_D
-1: S6K1* = MTORC1
-1: PS6* = S6K1
-1: SMAD3* = TGFBETA
-1: JAK3* = IL2R and IL2_EX
-1: STAT5* = JAK3
-1: STAT5_D* = STAT5
-1: FOXP3* = (not MTOR_DD and (STAT5 or (NFAT and AP1 and STAT5 and FOXO1))) or (NFAT and SMAD3)
-1: CD25* = FOXP3 or (AP1 and NFAT and NFKAPPAB) or STAT5
-1: PTEN* = (FOXO1 and MEK1) and not CK2
-1: IL2_EX* = IL2 or IL2_EX
+TCR = False
+MEK1 = False
+FOXO1 = True
+FOXO1_P = False
+FOXO1_P_D = False
+FOXO1_P_DD = False
+FOXO1_P_DDD = False
+CK2 = False
+AKT_OFF = False
+MTORC1_OFF = False
+NFAT_OFF = False
+IL2RA = False
+IL2RA_D = False
+
+1: CK2* = TCR_HIGH
+1: MEK1* = RAF
+1: IL2RA* = IL2 and IL2R
+1: IL2RA_D* = IL2RA
+1: MTOR_DDD* = MTOR_DD
+1: FOXO1* = not AKT

data/bionetgen/Perl2/Cache.pm

@@ -0,0 +1,93 @@
+package Cache;
+# a simple class for stowing and fetching things by label
+
+# pragmas
+use strict;
+use warnings;
+
+use constant DEFAULT_LABEL => 'DEFAULT';
+
+# Structure containing BioNetGen model data
+sub new 
+{
+    my ($class) = @_;
+    my $cache = {};
+    bless ($cache, $class);
+    return $cache;
+};
+
+# copy cache (this will NOT copy objects contained in cache)
+sub copy
+{
+    my ($cache) = @_;
+    my $copy = {};
+    %$copy = %$cache;
+    bless ($copy, ref $cache);
+    return $copy;
+}
+
+# stow an item in cache
+sub cache
+{
+    my ($cache, $item, $label) = @_;
+
+    unless (defined $label)
+    {   $label = DEFAULT_LABEL;   }
+
+    $cache->{$label} = $item;
+}
+
+# browse an item in cache (get item reference, but do not remove from cache)
+sub browse
+{
+    my ($cache, $label) = @_;
+
+    unless (defined $label)
+    {   $label = DEFAULT_LABEL;   }
+
+    return (exists $cache->{$label} ? $cache->{$label} : undef);
+}
+
+# fetch an item from cache (item is removed from cache!)
+sub fetch
+{
+    my ($cache, $label) = @_;
+
+    unless (defined $label)
+    {   $label = DEFAULT_LABEL;   }
+
+    my $item = undef;
+    if (exists $cache->{$label})
+    {
+        $item = $cache->{$label};
+        delete $cache->{$label};
+    }
+    return $item;
+}
+
+# check if a label is defined
+sub is_label_defined
+{
+    my ($cache, $label) = @_;
+    
+    unless (defined $label)
+    {   $label = DEFAULT_LABEL;   }
+
+    return exists $cache->{$label};
+}
+
+# get the number of items in the cache
+sub size
+{
+    my ($cache) = @_;
+    return (scalar keys %$cache);
+}
+
+# empty the cache
+sub empty
+{
+    my ($cache) = @_;
+    $cache = {};
+}
+
+1;

data/bionetgen/Perl2/CartesianProduct.pm

@@ -0,0 +1,309 @@
+package CartesianProduct;
+### A class for iterating over elements of a cartesian product
+
+
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+use warnings;
+use strict;
+
+
+### Members
+struct CartesianProduct =>
+{
+    Lists        => '@',    # a list of references to lists
+    NumLists     => '$',    # the number of lists participating in this CartesianProduct
+    ListPosition => '$',    # minimum of list indices that were changed in last advance
+    FirstIdx     => '@',    # a list of indices corresponding to the minimum element to iterate over
+    CurrentIdx   => '@',    # a list of indices corresponding to the current element of the Cartesian product
+    LastIdx      => '@',    # a list of indices corresponding to the end of each list
+    MoreElements => '$'     # a boolean value: 1 if there are more elements in the Cartesian product, 0 otherwise.
+};
+
+
+### Methods:
+###
+### (public)
+###   $cp  = CartesianProduct::new();
+###   $cp_copy = $cp->copy();
+###   bool = $cp->initialize( \@lists );
+###   bool = $cp->getNext( \@elem );
+###   bool = $cp->update( \@new_items, $list_idx );
+###   bool = $cp->validate( );
+###
+### (private)
+###   void = $cp->advance( );
+###
+
+
+
+# Copy the Cartesian Product
+sub copy
+{
+    my $cp = shift @_;
+
+    my $cp_copy = CartesianProduct::new();
+    $cp_copy->Lists( [@{$cp->Lists}] );
+    $cp_copy->NumLists( $cp->NumLists );
+    $cp_copy->ListPosition( $cp->ListPosition );
+    $cp_copy->FirstIdx( [@{$cp->FirstIdx}] );
+    $cp_copy->CurrentIdx( [@{$cp->CurrentIdx}] );
+    $cp_copy->LastIdx( [@{$cp->LastIdx}] );
+    $cp_copy->MoreElements( $cp->MoreElements );
+
+    return $cp_copy;
+}
+
+
+
+###
+###
+###
+
+
+
+# Call this method to initialize a new CartesianProduct with a reference
+#  to a set of lists provided as the first argument.  Returns true if the CartesianProduct
+#  is initialized correctly.
+sub initialize
+{
+    my $cp    = shift;
+    my $lists = shift;
+    
+    # get item lists
+    unless ( ref $lists eq 'ARRAY' )
+    {   return 0;   }
+    
+    $cp->Lists( $lists );
+    $cp->NumLists( scalar @$lists );
+
+
+    # setup index vectors    
+    my $current_idx = [];
+    my $first_idx   = [];
+    my $last_idx    = [];
+    
+    my $elem_exist = 1;
+    my $ii = 0;
+    while ( $ii < $cp->NumLists )
+    {
+        push @$current_idx, 0;
+        push @$first_idx, 0;
+        push @$last_idx, scalar @{$cp->Lists->[$ii]};       
+        $elem_exist *= scalar @{$cp->Lists->[$ii]};
+        ++$ii;
+    }
+
+    $cp->ListPosition( 0 );
+    $cp->FirstIdx( $first_idx );
+    $cp->CurrentIdx( $current_idx );
+    $cp->LastIdx( $last_idx );      
+    $cp->MoreElements( $elem_exist );
+    
+    return 1;
+}
+
+
+
+###
+###
+###
+
+
+
+# call this method to load the next element of the CartesianProduct
+#  into the reference provided as the first argument. Returns true if next
+#  element was loaded into array at pointer $elem; returns false if no more elements
+#  are available.
+sub getNext
+{
+    my $cp   = shift;    # this CartesianProduct object
+    my $elem = shift;    # pointer to array that store elements
+    
+    if ( $cp->MoreElements )
+    {   # load current element and return true
+        my $ii = $cp->ListPosition;
+        while ( $ii < $cp->NumLists )
+        {
+            $elem->[$ii] = $cp->Lists->[$ii]->[ $cp->CurrentIdx->[$ii] ];
+            ++$ii;
+        }
+        $cp->advance();
+        return 1;
+    }
+    else
+    {   # no more elements, return false
+        return 0;
+    }
+}
+
+
+###
+###
+###
+
+
+
+# After iterating through all elements of the CartesianProduct,
+#  add @$new_items to the list at index $list_idx.
+#  Continue calling getNext to iterate over new elements of the cartesian product
+#  NOTE: must iterate through all new elements before calling update again
+sub update
+{
+    my $cp = shift;
+    my $list_idx = shift;
+    my $new_items = shift;
+    
+    if (     $cp->MoreElements
+         or  $cp->NumLists != scalar @{$cp->Lists}
+         or  $list_idx < 0 
+         or  $list_idx >= $cp->NumLists 
+         or  ref $new_items ne 'ARRAY'             )
+    {   # invalid update!
+        return 0;
+    }
+    else
+    {
+        # update FirstIdx: point to first element in each list, except the updated list
+        #  that will point to the first new element.
+        $cp->FirstIdx( [(0) x $cp->NumLists] );
+        $cp->FirstIdx->[$list_idx] = @{$cp->Lists->[$list_idx]};
+                
+        # CurrentIdx is the same as FirstIdx
+        $cp->CurrentIdx( [@{$cp->FirstIdx}] );
+               
+        # add new_items to list
+        push @{$cp->Lists->[$list_idx]}, @$new_items;
+        
+        # update lastIdx
+        my $ii = 0;
+        my $elem_exist = $cp->NumLists ? 1 : 0;
+        while ( $ii < $cp->NumLists )
+        {
+            $cp->LastIdx->[$ii] = scalar @{$cp->Lists->[$ii]};
+            $elem_exist *= scalar @{$cp->Lists->[$ii]};
+            ++$ii;
+        }    
+    
+        $cp->ListPosition( 0 );
+    
+        if ( scalar @$new_items  and  $elem_exist )
+        {   $cp->MoreElements(1);   }
+        
+        return 1;
+    }
+}
+
+
+
+###
+###
+###
+
+
+
+# This private method advances the index vector
+sub advance
+{
+    my $cp = shift;
+    
+    if ( $cp->MoreElements )
+    {
+        my $ii = $cp->NumLists - 1;
+        while ( $ii >= 0 )
+        {
+            ++($cp->CurrentIdx->[$ii]);
+            last if ( $cp->CurrentIdx->[$ii] < $cp->LastIdx->[$ii] );
+            $cp->CurrentIdx->[$ii] = $cp->FirstIdx->[$ii];
+            --$ii;
+        }
+        
+        $cp->ListPosition($ii);
+        if ( $ii < 0 ) {  $cp->MoreElements(0);  }
+    }
+}
+
+
+
+
+
+
+###
+###
+###
+
+
+
+# This method validates the CartesianProduct state.
+#  Returns true if everything looks good, false otherwise.
+sub validate
+{
+    my $cp = shift;
+    my $elem = (@_) ? shift : undef;
+
+    # check for correct number of lists
+    unless (      defined $cp->NumLists 
+             and  @{$cp->Lists} == $cp->NumLists )
+    {   return 0;   }
+
+    # check that ListPosition is correctly defined
+    unless (      defined $cp->ListPosition
+             and  $cp->ListPosition >= 0
+             and  $cp->ListPosition < $cp->NumLists )
+    {   return 0;   }
+    
+    # check that CurrentIdx is defined
+    unless ( defined $cp->CurrentIdx )
+    {   return 0;   }
+    
+    # check that LastIdx is defined
+    unless ( defined $cp->LastIdx )
+    {   return 0;   }    
+     
+    # If we were passed $elem, check that its the correct size
+    if ( defined $elem )
+    {
+        unless ( @$elem == @{$cp->Lists} ) {  return 0;  }
+    }
+    
+    # loop over lists and check that everything is in order
+    my $ii = 0;
+    while ( $ii < $cp->NumLists )
+    {
+        # make sure things are defined
+        unless (      defined $cp->Lists->[$ii]
+                 and  defined $cp->CurrentIdx->[$ii] 
+                 and  defined $cp->LastIdx->[$ii]    )
+        {   return 0;   }
+    
+        # check that lastIndex is correct
+        unless ( $cp->LastIdx->[$ii] == @{$cp->Lists->[$ii]} )
+        {   return 0;   }
+        
+        # check that currentIndex has a valid range
+        unless (      $cp->CurrentIdx->[$ii] >= 0
+                 and  $cp->CurrentIdx->[$ii] < @{$cp->Lists->[$ii]} )  
+        {   return 0;   }
+        
+        #  If we were passed $elem check that its defined correctly up to ListPosition
+        if ( defined $elem  and  $ii < $cp->ListPosition )
+        {
+            unless ( $elem->[$ii] == $cp->Lists->[$ii]->[ $cp->CurrentIdx->[$ii] ] )
+            {   return 0;   }
+        }
+        ++$ii;    
+    }
+    
+    # everything checks out!
+    return 1;
+}
+
+
+###
+###
+###
+
+
+1;

data/bionetgen/Perl2/Compartment.pm

@@ -0,0 +1,449 @@
+# $Id: Compartment.pm,v 1.1 2006/09/25 04:50:31 faeder Exp $
+
+package Compartment;
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+# BNG Modules
+use Expression;
+
+
+
+struct Compartment => {
+  Name => '$',               # name of compartment (valid chars: \w).
+  SpatialDimensions => '$',  # dimension of compartment: 0-3.
+  Size => 'Expression',      # volume/area/length expression.
+  Outside => 'Compartment',  # ref to compartment (if any) that contains this.
+  Inside => '@',             # list of compartments contained by Compartment. [JSH]
+};
+
+
+# get copy of compartment
+# (careful here.. the Outside and Inside continue pointing to the same old place.
+#    If copying an entire compartment list, these references need to be updated after copy!)
+sub copy
+{
+    my $comp = shift;
+    my $plist = (@_) ? shift : undef;
+    
+    my $comp_copy = Compartment::new();
+    $comp_copy->Name( $comp->Name );
+    $comp_copy->SpatialDimensions( $comp->SpatialDimensions );
+    
+    $comp_copy->Size( $comp->Size->clone($plist) ) if ( defined $comp->Size );
+    $comp_copy->Outside( $comp->Outside )         if ( defined $comp->Outside );
+    
+    @{ $comp_copy->Inside } = @{ $comp->Inside };
+
+    return $comp_copy;
+}
+
+
+
+###
+###
+###
+
+
+
+# after copying a compartment list, we need to relink the inside and outside neighbors
+#    the arguments should be the copied compartment and list
+sub relinkNeighbors
+{
+    my $comp = shift;
+    my $clist = shift;
+    
+    # relink outside
+    $comp->Outside = $clist->lookup( $comp->Outside->Name );
+    # relink inside
+    foreach my $inside_comp ( @{$comp->Inside} )
+    {
+        $inside_comp = $clist->lookup( $inside_comp->Name );
+    }
+}
+
+
+
+###
+###
+###
+
+
+sub newCompartment
+# ($comp_ref, $err) = Compartment->newCompartment(name,dim,size[,outside]);
+# creates a new compartment object
+# sub added by justinshogg@gmail.com 18feb09
+{
+   my ($class, $name, $dim, $size, $outside) = @_;
+
+   $name =~ /^[\w]+$/  or  return( undef, "newCompartment: attempt to define compartment with invalid name: '$name'." );
+   $dim =~ /^[2-3]$/   or  return( undef, "newCompartment: spatialDimension '$dim' must be integer in [2,3]." );
+   ref $size eq 'Expression'  or  return( undef, "newCompartment: size parameter '$size' must be an expression." );
+
+   my $err = '';  
+   my $comp = Compartment->new(Name=>$name,SpatialDimensions=>$dim,Size=>$size);
+   $err = $comp->put_inside($outside) if ( defined $outside );
+
+   return($comp, $err);
+}
+
+
+###
+###
+###
+
+
+sub put_inside
+# $err = $comp->put_inside( $outside ); 
+# set $comp1->Outside = $comp;
+{
+   my ($comp, $outside) = @_;
+
+   # check that $outside is a compartment!
+   ref $outside eq 'Compartment'
+       ||  return("Compartment->put_inside > Outside parameter '$outside' must be a Compartment.");
+
+   !defined($comp->Outside)
+       ||  return("Compartment->put_inside: compartment is already contained by another compartment.");
+
+   # enforce topology.  (1) alternating dimensions:  ..->volume->surface->volume->surface->..
+   abs( $comp->SpatialDimensions - $outside->SpatialDimensions ) == 1
+       ||  return("Compartment->put_inside: Outside has same dimension as compartment.");
+
+   # enforce topology.  (2) only one volume inside a surface
+   if ($comp->SpatialDimensions == 3  &&  $outside->SpatialDimensions == 2)
+   {
+     (@{$outside->Inside} == 0)
+         ||  return("Compartment->put_inside: Outside 2-D compartment already contains a 3-D compartment.");
+   }
+
+   # all good, do the operation.
+   $comp->Outside($outside);
+   push @{$outside->Inside}, $comp;
+   return '';
+}
+
+
+
+
+sub adjacent
+# int = $comp1->adjacent( $comp2 )
+# return +1 if $comp1 is Outside of Comp2
+# return -1 if $comp2 is Outside of Comp1
+# return 0 if compartments are not adjacent
+{
+    my $comp1 = shift;
+    my $comp2 = shift;
+
+    # Compartment 1 contains Compartment 2
+    if ( defined $comp2->Outside )
+    {
+        if ( $comp2->Outside == $comp1 )
+        {  return 1;  }
+    }
+    # Compartment 2 contains Compartment 1
+    if ( defined $comp1->Outside )
+    {
+        if ( $comp1->Outside == $comp2 )
+        {  return -1;  }
+    }
+    return 0;
+}
+
+
+
+
+sub is_surface_of
+# int = $comp1->is_surface_of($comp2)
+# return 1 if $comp1 is a surface facing volume $comp2
+# return -1 if $comp2 is a surface facing volume $comp1
+# else return 0.
+# justinshogg@gmail.com 16feb2009
+{
+  my ($comp1,$comp2) = @_;
+  my $adj = $comp1->adjacent($comp2);
+  if ($adj)
+  {  return($comp2->SpatialDimensions - $comp1->SpatialDimensions);  }
+  else
+  {  return 0;  }
+}
+
+
+
+sub separated_by_surface
+# int = Compartment1->separated_by_surface(Compartment2) 
+# return 1 if Compartment1 and Compartment2 are volumes
+#   separated by a surface and Comp1 is outer-most compartment.
+# return -1 if Compartment1 and Compartment2 are volumes
+#   separated by a surface and Comp2 is outer-most compartment.
+# return 0 otherwise.
+#
+# Note: assumes alternating tree topology
+{
+  my ($comp1, $comp2) = @_;
+
+  # comp1 and comp2 must be volumes
+  return 0 unless ( ($comp1->SpatialDimensions==3)  and  ($comp2->SpatialDimensions==3) );
+
+  # check if comp1 and comp2 are separated by a membrane
+  # and comp1 is outer-most:
+  return -1  if (  defined $comp1->Outside
+                    and  defined $comp1->Outside->Outside 
+                    and  ($comp1->Outside->Outside == $comp2)       );
+
+  # and comp2 is outer-most:
+  return  1  if (  defined $comp2->Outside
+                    and  defined $comp2->Outside->Outside 
+                    and  ($comp2->Outside->Outside == $comp1)       );
+
+  return  0;
+}
+
+
+sub separated_by_volume
+# int = Compartment1->separated_by_surface(Compartment2) 
+# return 1 if Compartment1 and Compartment2 are surfaces
+#   separated by a volume and the volume does not contain both surfaces.
+# return -1 if Compartment1 and Compartment2 are surfaces
+#   separated by a volume and the volume contains both surfaces.
+# return 0 otherwise.
+#
+# NOTE: assumes alternating tree topology
+# for endocytosis: Both the Outside volume of the outermost surface
+#                    and Inside volume of the innermost surface MUST EXIST.
+# for exocytosis: Both of the Surfaces must have an Inside volume defined.
+{
+  my ($comp1, $comp2) = @_;
+
+  # comp1 and comp2 must be surfaces
+  return 0 unless ( ($comp1->SpatialDimensions==2)  and  ($comp2->SpatialDimensions==2) );
+
+  # exocytosis
+  # check if comp1 and comp2 have the same Outside (and both contain some volume)
+  return -1  if (  defined $comp1->Outside
+                    and  defined $comp2->Outside
+                    and  ($comp1->Outside == $comp2->Outside) 
+                    and  exists $comp1->Inside->[0]
+                    and  exists $comp2->Inside->[0] 
+                );
+
+  # endocytosis
+  # Check if comp1 Outside == comp2 Inside
+  return  1  if (  defined $comp1->Outside
+                    and  defined $comp1->Outside->Outside 
+                    and  ($comp1->Outside->Outside == $comp2)
+                    and  exists $comp1->Inside->[0]
+                    and  defined $comp2->Inside
+                );
+
+  # endocytosis
+  # Check if comp2 Outside == comp1 Inside
+  return  1  if (  defined $comp2->Outside
+                    and  defined $comp2->Outside->Outside 
+                    and  ($comp2->Outside->Outside == $comp1)
+                    and  exists $comp2->Inside->[0]
+                    and  defined $comp1->Outside
+                );
+
+  return  0;
+}
+
+
+
+
+sub connected {
+# $bool = connected( $comp1, $comp2, .. $comp3 );
+# check if a list of compartments are connected
+  my @nodes_conn= (shift);
+  my @nodes_left= @_;
+
+  my $link_found;
+  while(@nodes_left){
+    $link_found=0;
+    for my $n1 (@nodes_conn){
+      for my $i (0..$#nodes_left){
+	     if ($n1->adjacent($nodes_left[$i])){
+	       push @nodes_conn, $nodes_left[$i];
+	       splice @nodes_left, $i, 1;
+	       $link_found=1;
+	       last;
+	     }
+      }
+      last if $link_found;
+    }
+    last unless $link_found;
+  }
+  # Compartment graph is not connected unless link was found on last loop
+  return($link_found)
+}
+
+
+
+
+sub toString{
+  my $comp=shift;
+  my $plist=(@_) ? shift : "";
+
+  my $string="";
+
+  $string.=$comp->Name;
+  $string.=" ".$comp->SpatialDimensions;
+  if ($plist){
+    $string.=" ".$comp->Size->toString($plist);
+  }
+  if (my $ccomp=$comp->Outside){
+    $string.=" ".$ccomp->Name;
+  }
+  return($string);
+}
+
+
+
+
+sub toXML{
+  my $comp=shift;
+  my $indent=shift;
+  my $plist = (@_) ? shift : undef;
+
+  my $string=$indent."<compartment";
+
+  # Attributes
+  # id
+  $string.=" id=\"".$comp->Name."\"";
+  # spatialDimensions
+  $string.= " spatialDimensions=\"".$comp->SpatialDimensions."\"";
+  # size
+  my $size = $comp->Size->toString();
+  unless ( BNGUtils::isReal($size) )
+  {   $size = $comp->Size->evaluate($plist);   } # evaluate to a number
+#  $string.= " size=\"".$comp->Size->toString()."\"";
+  $string.= " size=\"".$size."\"";
+  # outside
+  if ($comp->Outside){
+    $string.= " outside=\"".$comp->Outside->Name."\"";
+  }
+
+  $string.="/>\n"; # short tag termination
+
+  return($string);
+}
+
+############DB###################
+# This function calculates scaling factor for the compartment volumes/areas of compartments based on the user-specified volumes 
+#provided in the BNGL file. The scaling is determined by the ration of the user-specified volume and the default volume of a 
+# M-cell produced geometry, which in this case is a sphere. The default size of a MCell/Blender-created is r = 1 micron (volume
+# = 4.19 cubic micron, and surface area is 12.57 sq. micron. The function first determines size of a sphere based on the sum of 
+# all nested compartment volumes (by calling the getMDLSize function). It then determines the linear scaling factor, which is the 
+# ratio from the volume of the sphere and the volume of the MCell/Blender-created default sphere. In addition, the function
+# stores the first word from the first line into a hash called %shape. The first word referes to the name of the geometry object itself (in this 
+# case it is "Sphere". 
+
+ 
+sub getMDLgeometry
+{
+   my $comp = shift; 
+   my $plist = shift; 
+   my $geometry = shift; 
+   my $object = shift; 
+   my $shape = shift; 
+   my $scale = shift; 
+   my $string = ""; 
+   
+    my $surf; 
+   my $i=0; 
+   foreach (@{$geometry}){
+        if ($_ =~ /POLYGON_LIST/){
+	    $object->{$comp->Name} = $_;
+	    $object->{$comp->Name} =~ s/POLYGON_LIST//; 
+	    $object->{$comp->Name} =~ s/^\s*//; 
+	    $object->{$comp->Name} =~ s/\s*$//;
+	    $object->{$comp->Name} = $comp->Name."_".$object->{$comp->Name}; 
+	    }
+	    
+	if ($_ =~ /DEFINE_SURFACE_REGIONS/){
+	    $surf = $geometry->[$i+2];
+	    $surf =~ s/^\s*//;
+	    $surf =~ s/\s*$//;
+	    }
+	++$i; 
+   }
+
+   my $volume_mcell;   
+   my $area_mcell; 
+   my $volume; 
+   my $area; 
+   
+   if ($object->{$comp->Name} =~ /Sphere/){
+      $volume_mcell = 4.1904762;  # Default volume of sphere in Blender;
+      $area_mcell = 12.571429;  # Default surface area of sphere in Blender;
+      $volume = getMDLSize($comp, $plist);  # Volume of sphere inclosing the compartment and nested inside compartments
+      $area = 4.836624601*($volume)**(2/3);  # Surface area of sphere
+      }
+      
+   
+   if ((!$comp->Outside) || ($comp->SpatialDimensions == 2)){ # Write geometries defined by 2D surfaces
+      $string = join "", map {$_=~ /POLYGON_LIST/ ? $comp->Name."_".$_ : $_ } (@{$geometry}); 
+      $shape->{$comp->Name} .= $object->{$comp->Name}."[$surf]";
+      my ($volume, $area) = ($comp->SpatialDimensions == 3) ? ($volume, undef) : (undef, $area);  
+      # $volume is relevant only in the case of the outermost space if it has no defined boundary (in BNGL). 
+      $scale->{$comp->Name} = (defined $volume) ? ($volume/$volume_mcell)**(1/3) : sqrt($area/$area_mcell); 
+      }
+     
+   if (@{$comp->Inside}){
+        foreach my $incomp (@{$comp->Inside}){
+            $string .= getMDLgeometry($incomp,$plist,$geometry,$object,$shape,$scale);  # Recursive call 
+	}  
+   }
+   return $string; 
+}
+
+# This function returns a reference to an array. The first array element is a compartment name. Subsequent elements are the names of nested compartments. 
+sub getMDLRelSite
+{
+   my $comp = shift; 
+   my @array;
+   if ($comp->SpatialDimensions == 2){
+       push(@array, $comp->Name);    # The array contains a single element because membrane compartment does not hold any nested compartments. 
+       return \@array;
+       }
+   
+   push (@array, $comp->Outside ? $comp->Outside->Name : $comp->Name); # If outermost 3D space, then name the 'hypothetical' outer membrane with  the same name as the compartment 
+   foreach (@{$comp->Inside}){
+       push (@array, $_->Name);   # First element is the primary compartment. Subsequent elements are nested compartments. 
+       }
+   return \@array;     
+} 
+ 
+# This function calculates total volume of a sphere (i.e., volume of (compartment + all inside compartments).
+# Membrane volume is assumed zero regardless of the user-assigned value
+# because potential contradiction can arise from independently assigning both the membrane and enclosed volume size
+# Size of a sphere is only based on the assigned 3D volumes.
+ 
+sub getMDLSize
+{
+  my $comp = shift; 
+  my $plist = shift; 
+  my $custom_geometry = shift; 
+  my $volume = 0;
+  my $childvolume = 0; 
+  
+  $volume = $comp->Size->evaluate($plist);
+  return $volume if ($custom_geometry);
+  
+  $volume =  0 if ($comp->SpatialDimensions == 2);  
+  
+  foreach my $child (@{$comp->Inside}){    # Calculate volume of all nested compartments inside the current compartment 
+          $childvolume = $childvolume + $child->getMDLSize($plist, $custom_geometry); 
+	  }
+  $volume = $volume + $childvolume; # Sphere volume = volume of (current compartment + all nested compartments inside)
+  return ($volume); 	    
+}   
+
+1;

data/bionetgen/Perl2/CompartmentList.pm

@@ -0,0 +1,240 @@
+# $Id:$
+
+package CompartmentList;
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+# BNG Modules
+use Compartment;
+use ParamList;
+
+
+
+
+struct CompartmentList =>
+{
+    Array => '@',   # list of Compartments
+    Hash  => '%',   # map from Compartment name to compartment object ref.
+    Used  => '$'    # Flag to indicate that compartment attribute is set in 1 or more species in model 
+};
+
+
+# copy the entire CompartmentList and all Compartments it contains
+sub copy
+{
+    my $clist = shift @_;
+    my $plist = @_ ? shift @_ : undef;
+    
+    # create copy of list
+    my $clist_copy = CompartmentList->new();
+    foreach my $comp ( @{$clist->Array} )
+    {
+        my $comp_copy = $comp->copy( $plist );
+        push @{$clist_copy->Array}, $comp_copy;
+        $clist_copy->Hash->{$comp_copy->Name} = $comp_copy;
+    }
+    $clist_copy->Used($clist->Used);  # TODO: is this the best assumption?
+        
+    # fix links to inside and outside neighbors
+    foreach my $comp ( @{$clist_copy->Array} )
+    {
+        $comp->relinkNeighbors( $clist_copy );
+    }
+    
+    return $clist_copy;
+}
+
+
+###
+###
+###
+
+
+
+sub getNumCompartments
+{
+    my $clist = shift;
+    return scalar @{$clist->Array};
+}
+
+
+###
+###
+###
+
+
+# lookup a compartment by name.  Returns reference or empty string
+sub lookup
+{
+    my $clist = shift;
+    my $name  = shift;
+  
+    if ( exists $clist->Hash->{$name} )
+    {
+        return $clist->Hash->{$name};
+    }
+    else
+    {
+        return '';
+    }
+}
+
+
+###
+###
+###
+
+
+sub add
+# '' = @clist->add( cref1, cref2, ... crefN )
+# add compartment to a compartment list
+# updated by justinshogg@gmail.com 17feb2009
+# overloaded method to add compartments by
+# reference.
+{
+    my $clist = shift;  # CompartmentList ref
+    my $comp = shift;
+
+    ref $comp eq 'Compartment'
+         || return "CompartmentList: Attempt to add non-compartment object $comp to CompartmentList.";   
+
+    if ( exists $clist->Hash->{ $comp->Name } )
+    {   # compartment with same name is already in list
+        # swap old compartment for the new one
+        my $cref = $clist->Hash->{ $comp->Name };
+        %{$cref} = %{$comp};
+    }
+    else
+    {   # add new compartment
+        $clist->Hash->{ $comp->Name } = $comp;
+        push @{$clist->Array}, $comp;
+    }
+
+    # continue adding compartments (recursive)
+    if ( @_ )
+    {  return $clist->add(@_);  }
+    else
+    {  return '';  }
+}
+
+
+
+
+sub toString
+{
+    my $clist = shift;
+    my $plist = (@_) ? shift : undef;
+
+    my $string = "begin compartments\n";
+    foreach my $comp (@{$clist->Array}){
+        $string .= '  ' . $comp->toString($plist) . "\n";
+    }
+    $string .= "end compartments\n";
+
+    return $string;
+}
+
+
+
+
+sub readString
+# $err = $clist->readString(compartment_string,param_list)
+# Reads a single compartment specification from a string with the following format:
+# name type volume [outside compartments]
+# updates by justinshogg@gmail.com 17feb2009
+{
+    my $clist  = shift;  # CompartmentList
+    my $string = shift;  # compartment string to parse
+    my $plist  = shift;  # parameter list
+	
+	# Remove leading whitespace
+    $string =~ s/^\s*//;
+	
+	# Remove leading label, if any
+	if ($string =~ s/^\s*(\w+)\s*:\s+//)
+	{
+	    # Check label for leading number
+		my $label = $1;
+		if ($label =~ /^\d/) {  return "Syntax error (label begins with a number) at '$label'";  }
+	}
+	
+    # Read name (required argument), check for starting number
+    $string =~ s/^([A-Za-z_]\w*)//   or return "Invalid compartment name in '$string' (must begin with a letter or underscore)";
+    my $name = $1;
+	
+    # Read spatialDimensions (required argument)
+    $string =~ s/^\s*(\d+)//   or return "Invalid Spatial Dimensions for Compartment in '$string'"; 
+    my $spatialDimensions = $1;
+    # moved spatial dimension check to newCompartment sub in Compartment module
+
+    # Read size expression (required argument, expression created on the fly)
+    my $size = Expression->new();
+    $size->setAllowForward(1);
+    $size->readString(\$string, $plist)  and return $_;
+
+    # Read outside compartment (optional argument, but compartment must be in list if specified)
+    my $outside = undef;
+    if ( $string =~ s/^([A-Za-z_0-9]+)\s*// )
+    {
+        my $cname = $1;
+        # Get compartment reference
+        $outside = $clist->Hash->{$cname}
+            ||  return("Outside compartment $cname is not in CompartmentList");
+    }
+
+    # check for extraneous arguments
+    if ( $string =~ /\S+/ )
+    {  return "Unrecognized trailing syntax in compartment specification";  }
+
+    # create compartment
+    my ($comp, $err) = Compartment->newCompartment($name, $spatialDimensions, $size, $outside);
+    return $err if ($err);
+
+    # add compartment to list
+    return $clist->add($comp);
+}
+
+
+
+
+sub toXML
+{
+    my $clist  = shift;
+    my $indent = shift;
+    my $plist  = (@_) ? shift : undef;
+
+    my $string = $indent."<ListOfCompartments>\n";
+  
+    foreach my $comp (@{$clist->Array}){
+        $string .= $comp->toXML("  ".$indent, $plist);
+    }
+
+    $string .= $indent."</ListOfCompartments>\n";
+    return $string;
+}
+
+
+
+
+sub validate
+{
+    my $clist = shift;
+
+    foreach my $comp (@{$clist->Array})
+    {
+        if ($comp->SpatialDimensions eq '')
+        {
+            my $err = sprintf "Compartment %s referred to but not defined", $comp->Name;
+        }
+    }
+    return '';
+}
+
+1;

data/bionetgen/Perl2/Component.pm

@@ -0,0 +1,453 @@
+# $Id: Component.pm,v 1.10 2007/01/22 19:22:48 faeder Exp $
+
+package Component;
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+# BNG Modules
+use BNGUtils;
+use Compartment;
+
+# constants
+use constant { TRUE                 => 1,
+               FALSE                => 0
+             };
+
+
+struct Component => {
+    Name  => '$',
+    State => '$',
+    #Type  => 'ComponentType',
+    Edges => '@',
+    Label => '$', 
+    Compartment => 'Compartment'
+};
+
+
+
+###
+###
+###
+
+
+
+sub newComponent
+{
+    my $strptr = shift;
+
+    my $comp = Component->new();
+    my $err = $comp->readString($strptr);
+
+    return ($comp, $err);
+}
+
+
+
+###
+###
+###
+
+
+
+sub readString
+{
+    my $comp   = shift @_;
+    my $strptr = shift @_;
+    my $clist  = @_ ? shift @_ : undef;
+
+    my $string_left = $$strptr;
+    
+    # Get component name (cannot start with a number)
+	if ( $string_left =~ s/^([A-Za-z_]\w*)// )
+	{
+		$comp->Name($1);
+	}
+	else
+	{
+		return undef, "Invalid component name in '$string_left' (must begin with a letter or underscore).";
+	}
+
+    # Get component state (marked by ~) edges (marked by !) and label (marked by %) 
+    my $edge_wildcard = 0;
+    my $edge_labels = 0;
+    while ($string_left)
+    {
+        if ( $string_left =~ s/^([~%!@])(\w+|\+|\?)// )
+        {
+            my $type = $1;
+            my $arg  = $2;
+            if ($type eq '~')
+            {
+                # State label
+	            if (defined $comp->State)
+                {   return undef, "Multiple state definitions";   }
+	            $comp->State($arg);
+            }
+            elsif ($type eq '!')
+            {
+                # Bond label or wildcard
+	            if ( $arg =~ /^[+?]$/ )
+                { 
+	                if ($edge_wildcard or $edge_labels)
+                    {   return undef, "Multiple edge wildcards in component";   }
+	                $edge_wildcard=1;
+	            }
+                else
+                {
+                    if ($edge_wildcard)
+                    {   return undef, "Labeled edges mixed with wildcard";   }
+                }
+	            push @{$comp->Edges}, $arg;
+            }
+            elsif ($type eq '%')
+            {
+                # Tag label
+	            if (defined $comp->Label)
+                {   return undef, "Multiple label definitions";   }
+	            $comp->Label($arg);
+            }
+            elsif ($type eq '@')
+            {
+                # Compartment label
+	            if (defined $comp->Compartment)
+                {   return undef, "Multiple compartment definitions";   }
+
+                if ( defined $clist )
+                {
+				    if ( my $compart = $clist->lookup($arg) )
+                    {   $comp->Compartment($compart);   }
+                }
+				else
+                {
+					return undef, "Undefined compartment $arg";
+				}
+            }
+        }
+        elsif ( $string_left =~ /^[,)]/ )
+        {   # Terminator characters for component
+            last;
+        }
+        else
+        {   return undef, "Invalid syntax at $string_left";   }
+    }
+
+    $$strptr = $string_left;
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+sub toString
+{
+    my $comp = shift @_;
+    my $print_edges      = @_ ? shift @_ : TRUE;
+    my $print_attributes = @_ ? shift @_ : TRUE;
+
+    my $string .= $comp->Name;
+
+    if (defined $comp->State )
+    {   $string .= sprintf "~%s", $comp->State;   }
+
+    if ($print_attributes)
+    {   $string .= sprintf("%%%s", $comp->Label)  if (defined $comp->Label);   }
+
+    if ( defined $comp->Compartment )
+    {   $string .= sprintf "@%s", $comp->Compartment->Name;   }
+
+    if (defined $comp->Edges )
+    {
+        if ($print_edges)
+        {
+            my $wildcard='';
+            foreach my $edge (@{$comp->Edges})
+            {
+                if ($edge=~ /^\d+$/)
+                {   $string .= sprintf "!%d", $edge+1;   }
+                else
+                {   $wildcard = "!$edge";   }
+            }
+            $string .= $wildcard;
+        } 
+        else
+        {   $string .= "!" x @{$comp->Edges};   }
+    }
+
+    return $string;
+}
+
+
+
+###
+###
+###
+
+
+
+sub toStringSSC
+{
+    my $comp        = shift @_;
+    my $comp_label  = @_ ? shift @_: 0;
+    my $print_edges = @_ ? shift @_ : TRUE;
+
+    my $string      = $comp->Name;
+    if ( $comp_label != 0 ) { $string .= $comp_label; } # for checking components with same name
+                                                        # if comp_label != 0 same component exists
+
+    if (defined $comp->Label)
+    {   printf STDERR "ERROR: SSC Does not implement Label \n";   }
+
+    if (defined $comp->Compartment)
+    {   printf STDERR "ERROR: Compartments not implemented \n";   }
+
+    if (defined $comp->State)
+    {
+        $string.= sprintf "=\"%s\"", $comp->State;
+        if ($comp_label ==0 )
+        {   # just appends <component name>Binds, as SSC doesnt allow states to bind
+            $string .= ", " . $comp->Name . "Binds";
+        }
+        else
+        {
+            $string .= ", " . $comp->Name . $comp_label ."Binds";
+        }
+    }
+
+    if (defined $comp->Edges)
+    {
+        $string .= "#"; #As SSC considers every non-bound component as empty, so attaching #
+        if ($print_edges)
+        {
+            my $wildcard="";
+            foreach my $edge (@{$comp->Edges})
+            {
+                if ($edge=~ /^\d+$/)
+                {
+                    $string.= sprintf "%d", $edge+1;
+                }
+                else
+                {
+                    $wildcard="$edge";
+                }
+                $string.=$wildcard;
+            }
+        }
+        else
+        {
+            $string.= ""x scalar(@{$comp->Edges});
+        }
+    }
+    $string =~ s/\+/_/; # SSC equivalent of '+' is '_', substituting that
+    return $string;
+}
+
+
+
+###
+###
+###
+
+
+
+sub toXML
+{
+    my $comp   = shift @_;
+    my $indent = shift @_;
+    my $id     = shift @_;
+    my $index  = (@_) ? shift @_ : '';
+
+    my $string = $indent . "<Component";
+
+    # Attributes
+    # id
+    my $cid = sprintf "${id}_C%d", $index;
+    $string .= " id=\"".$cid."\"";
+    # type
+    $string .= " name=\"" . $comp->Name . "\"";
+    # state
+    if (defined $comp->State)
+    {
+        $string .= " state=\"" . $comp->State . "\"";
+    }
+    if (defined $comp->Label)
+    {
+        $string .= " label=\"" . $comp->Label . "\"";
+    }
+    if ($comp->Compartment)
+    {
+        $string .= " compartment=\"" . $comp->Compartment->Name . "\"";
+    }
+
+    # NumberOfBonds
+    my $nbonds = 0;
+    my $wildcard = '';
+    foreach my $edge (@{$comp->Edges})
+    {
+        if ($edge=~ /^[?+]$/)
+        {
+            $wildcard = $edge;
+        }
+        else
+        {
+            ++$nbonds;
+        }
+    }
+    if ($wildcard)
+    {
+        $nbonds = ($nbonds>0) ? $nbonds.$wildcard : $wildcard;
+    }
+    $string .= " numberOfBonds=\"" . $nbonds . "\"";
+
+    # Objects contained
+    my $indent2 = '  ' . $indent;
+    my $ostring = '';
+
+    # Termination
+    if ($ostring)
+    {   # terminate tag opening
+        $string .= ">\n";
+        $string .= $ostring;
+        $string .= $indent . "</Component>\n";
+    }
+    else
+    {   # short tag termination
+        $string .= "/>\n"; 
+    }
+}
+
+
+
+###
+###
+###
+
+
+
+# Make an exact copy of a component.
+sub copy
+{
+    # get component that we want to copy
+    my $comp = shift @_;
+    # should we copy labels?
+    my $copy_labels = (@_) ? shift @_ : 1;
+    # prefix for edge names?
+    my $prefix = (@_) ? shift @_ : '';
+
+    # create a new component
+    my $comp_copy = Component->new();
+
+    # copy scalar attributes
+    $comp_copy->Name( $comp->Name );
+    $comp_copy->Label( $comp->Label ) if ($copy_labels);
+    $comp_copy->State( $comp->State );
+    $comp_copy->Compartment( $comp->Compartment ) if (defined $comp->Compartment);
+
+    # copy edges
+    if ( @{$comp->Edges} )
+    {
+        # add prefix to edge label, unless its a wildcard
+        $comp_copy->Edges( [map {$_=~/^[*+?]$/ ? $_ : $prefix.$_} @{$comp->Edges}] );
+    }
+
+    # return the copy component  
+    return $comp_copy;
+}
+
+
+
+###
+###
+###
+
+
+
+# call this method to link Compartments to a new CompartmentList
+sub relinkCompartments
+{
+    my $comp  = shift @_;
+    my $clist = shift @_;
+    
+    my $err;
+    unless ( ref $clist eq 'CompartmentList' )
+    {   return "Component->relinkCompartments: Error!! Method called without CompartmentList object";   }
+    
+    if ( defined $comp->Compartment )
+    {
+        my $new_compart = $clist->lookup( $comp->Compartment->Name );
+        unless ($new_compart)
+        {   return "Molecule->relinkCompartments: Error!! could not find compartment name in list";   }
+        $comp->Compartment( $new_compart );
+    }
+    
+    return undef;
+}
+
+
+
+###
+###
+###
+
+
+
+# Component comparison for isomorphism
+sub compare_local
+{
+    my $a = shift;
+    my $b = shift;
+
+    my $cmp;
+    # Component name
+    if ( $cmp = ($a->Name cmp $b->Name) )
+    {   return $cmp;   }
+
+    # Component state
+    if ( defined $a->State )
+    {
+        unless (defined $a->State) { return 1; }
+        if ( $cmp = ($a->State cmp $b->State) )
+        {   return $cmp;   }
+    }
+    elsif ( defined $b->State )
+    {
+        return -1;
+    }
+
+    # Component compartment
+    if ( defined $a->Compartment )
+    {
+        unless (defined $b->Compartment) { return 1; }
+        if ( $cmp = ($a->Compartment <=> $b->Compartment) )
+        {   return $cmp;   }
+    }
+    elsif ( defined $b->Compartment )
+    {
+        return -1;
+    }
+
+    # Number of edges
+    if ( $cmp = (@{$a->Edges} <=> @{$b->Edges}) )
+    {   return $cmp;   }
+
+    return 0;
+}
+
+
+
+###
+###
+###
+
+1;

data/bionetgen/Perl2/ComponentType.pm

@@ -0,0 +1,157 @@
+# $Id: ComponentType.pm,v 1.3 2006/05/01 03:32:43 faeder Exp $
+
+# Objects for typing and checking Components of Molecules
+package ComponentType;
+
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+struct ComponentType=> {
+  Name=> '$',
+  States=> '@', # First element of States array is the default state, which 
+                # is used in creating new molecules that don't have user-specified
+                # state attributes.
+  Edges=> '@',         # Last two are not currently used in checking
+  Compartments=> '@'
+};
+sub readString{
+  my $ctype= shift;
+  my $strptr= shift;
+
+  my $string_left=$$strptr;
+  
+  # Get component name (cannot start with a number)
+  if ( $string_left =~ s/^([A-Za-z_]\w*)// )
+  {
+  	$ctype->Name($1);
+  }
+  else
+  {
+	return undef, "Invalid component name in '$string_left' (must begin with a letter or underscore).";
+  }
+	
+  # Get component state (marked by ~) edges (marked by !)
+  my @states=();
+  my @compartments=();
+  my @elabels=();
+  while ($string_left){
+    if ($string_left=~ s/^([~!@])([A-Za-z0-9_]+)//){
+      my $type=$1;
+      my $arg=$2;
+      if ($type eq '~'){
+	push @states, $arg;
+      }
+      elsif ($type eq '!'){
+	push @elabels, $arg;
+      }
+      elsif ($type eq '@'){
+	push @compartments, $arg;
+      }
+    }
+    elsif ($string_left=~ /^[,)]/){ # Terminator characters for component
+      last;
+    }
+    else {
+      return("Invalid syntax at $string_left");
+    }
+  }
+
+  if (@states){
+    $ctype->States([@states]);
+  }
+  if (@elabels){
+    $ctype->Edges([@elabels]);
+  }
+  if (@compartments){
+    $ctype->Compartments([@compartments]);
+  }
+  
+  $$strptr= $string_left;
+  return("");
+}
+
+
+sub copy
+{
+    my $comp = shift;
+    
+    my $comp_copy = ComponentType::new();    
+    $comp_copy->Name( $comp->Name );
+    $comp_copy->States( [@{$comp->States}] );
+    $comp_copy->Edges( [@{$comp->Edges}] );
+    $comp_copy->Compartments( [@{$comp->Compartments}] );            
+    
+    return $comp_copy;   
+}
+
+sub toString{
+  my $ctype= shift;
+  my $string="";
+
+  $string.= $ctype->Name;
+  for my $state (@{$ctype->States}){
+    $string.= "~$state";
+  }
+  return($string);
+}
+
+sub toStringSSC{
+  my $ctype= shift;
+  my $string="";
+  $string.= $ctype->Name;
+  $string .= "#";
+  for my $state (@{$ctype->States}){
+    $string.= "=\"$state\"";
+  }
+  return($string);
+}
+
+sub toXML{
+  my $ctype= shift;
+  my $indent= shift;
+  my $string=$indent."<ComponentType";
+
+  # Attributes
+  # id
+  $string.=" id=\"".$ctype->Name."\"";
+
+  # Objects
+  my $indent2= "  ".$indent;
+  my $ostring="";
+  if (@{$ctype->States}){
+    $ostring.= $indent2."<ListOfAllowedStates>\n";
+    for my $state (@{$ctype->States}){
+      $ostring.=$indent2."  <AllowedState";
+      $ostring.=" id=\"".$state."\"";
+      $ostring.="/>\n";
+    }
+    $ostring.= $indent2."</ListOfAllowedStates>\n";
+  }
+
+  if ($ostring){
+    $string.=">\n";
+    $string.=$ostring;
+    $string.=$indent."</ComponentType>\n";
+  } else {
+    $string.="/>\n";
+  }
+
+  return($string);
+}
+
+sub writeMDL
+{
+    my $ctype = shift; 
+    my $string = $ctype->Name; 
+    
+    if (@{$ctype->States}){
+       foreach my $state (@{$ctype->States}){
+              $string .= "~".$state; 
+	      }
+     }
+    return $string; 
+}
+
+
+1;

data/bionetgen/Perl2/Console.pm

@@ -0,0 +1,228 @@
+# This package contains routines for running BNG as an interactive console
+package Console;
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use FindBin;
+use lib $FindBin::Bin;
+use File::Spec;
+
+require Exporter;
+our @ISA = qw( Exporter );
+our @EXPORT = qw( BNGconsole );
+
+# BNG Modules
+use BNGUtils;
+use BNGModel;
+
+
+
+# global variables
+my $BNG_PROMPT = 'BNG> ';
+
+
+sub BNGconsole
+{   # take actions from interactive console!
+    my $params = (@_) ? shift : {};
+ 
+    # TODO:
+    # + differentiate between STDIN from console and file?
+    # + add more model query commands
+
+
+    # Am I interacting with a user, or a pipeline?
+    my $interactive = ( -t STDIN ) ? 1 : 0;
+
+    # turn off output buffering on STDOUT
+    select STDOUT;  $| = 1;
+
+    # say hello!
+    printf "BioNetGen version %s\n", BNGversion();
+    print "Entering BNG console mode.\n";
+    print $BNG_PROMPT;
+
+    # model begins as undefined
+    my $model = undef;
+
+    # read input
+    while ( my $linein = <STDIN> )
+    {
+        unless ($interactive) {  print $linein;  }
+        
+
+        # trim leading and trailing white space
+        $linein =~ s/^\s+//;        
+        $linein =~ s/\s+$//;       
+
+        PROCESS_INPUT:
+        {
+            # READ a model
+            if ( $linein =~ s/^load\s+// )
+            {
+                if (defined $model)
+                {
+                    send_warning( "Attempted to load model while another model is active." );
+                    last PROCESS_INPUT;
+                }
+    
+                # get filename
+                $linein =~ s/^(\S+)\s*//;
+                my $filename = $1;
+                unless ($filename and -e $filename)
+                {
+                    send_warning( "Attempted to load model, but file '$filename' was not found." );
+                    last PROCESS_INPUT;
+                }
+
+                # initialize parameters
+                my $local_params = { %$params };
+                # add filename to params
+                $local_params->{file} = $filename;
+
+                # process long args ('atomize' and 'blocks')
+                while ( $linein ){
+					my ($key, $val);
+					# --atomize INT
+					if ( $linein =~ s/\s*--(\w+)\s+(\w+)// ){ 
+						$key = $1;
+						$val = $2;
+					}
+					# --blocks ["STRING", "STRING", ...]
+					elsif( $linein =~ s/\s*--(\w+)\s+\[(.+)\]// ){ 
+						$key = $1;
+						$val = [ split( '\s*,\s*', $2 ) ];
+						foreach my $v (@$val){
+							$v = eval $v; # need to evaluate each entry to a string
+						}
+					}
+					else{
+	                    send_warning( "Error processing command line arguments: " . $linein );
+	                    last PROCESS_INPUT;
+	                }
+					$local_params->{$key} = $val;
+                }
+
+                # create BNGModel object
+                $model = BNGModel->new();
+                $model->initialize();
+                $BNGModel::GLOBAL_MODEL = $model;
+                {   # read model file
+                    my $err = $model->readFile($local_params);
+                    if ($err)
+                    {   # undefine model and send warning
+                        %$model = ();  undef %$model;  $model = undef;
+                        $BNGModel::GLOBAL_MODEL = undef;
+                        send_warning( "Some problem processing '$filename': $err" );
+                        last PROCESS_INPUT;
+                    }
+                }
+            }
+    
+            # EXECUTE an action
+            elsif ( $linein =~ s/^action\s+// )
+            {
+                unless (defined $model)
+                {
+                    send_warning( "Attempt to execute action without loading model." );
+                    last PROCESS_INPUT;
+                }
+                   
+                my ($action, $options); 
+			    if ( $linein =~ /^\s*(\w+)\s*\((.*)\);?\s*$/ )
+			    {   # syntax:  "action(options)"
+                    $action = $1;
+                    $options = $2;
+                }
+                else
+                {
+                    send_warning( "Invalid action syntax. Try: action actionName(options)." );
+                    last PROCESS_INPUT;
+                }
+		    	
+                # define action
+                my $command = '$model->' . $action . '(' . $options . ');';
+                print "Begin action $action\n";
+    
+	            # Perform self-consistency checks before operations are performed on model
+                {
+                    my $err = $model->ParamList->check();
+                    if ($err)
+                    {
+                        send_warning( "Problem executing action: paramlist failed consistency check." );
+                        last PROCESS_INPUT;
+                    }
+                }
+		    	
+                # execute action
+                my $t_start = cpu_time(0);
+                {
+		    	    my $err = eval $command;
+                    if ($@)
+                    {
+                        send_warning("Problem executing action: $@.");
+                        last PROCESS_INPUT;
+                    }
+                    if ($err)
+                    {
+                        send_warning("Problem executing action: $err.");
+                        last PROCESS_INPUT;
+                    }
+		    	    my $t_elapsed = cpu_time($t_start);
+                    printf "CPU TIME: %s %.2f s.\n", $action, $t_elapsed;
+		    	}
+            }
+    
+            # CLEAR model
+            elsif ( $linein =~ m/clear/ )
+            {
+                unless (defined $model)
+                {
+                    send_warning( "Attempt to clear model without loaded model." );
+                    last PROCESS_INPUT;
+                }
+                # undefine model
+                %$model = ();
+                undef %$model;
+                $model = undef;
+                $BNGModel::GLOBAL_MODEL = undef;
+            }
+
+            # DONE
+            elsif ( $linein =~ m/done/ )
+            {
+                undef $model;
+                print "Leaving BNG console.\n";
+                exit(0);
+            }
+    
+            elsif ( $linein =~ m/help/ )
+            {
+                print "HELP menu for BNG console\n";
+                print "/-----------------------------------------------\n";
+                print "  load MODEL [OPTS] : load a BNG model file         \n";
+                print "  done              : leave BNG console             \n";
+                print "  clear             : clear BNG model               \n";
+                print "  action ACTION     : execute ACTION on loaded model\n";
+                print "\n";
+                print "  OPTS:\n";
+                print "    --atomize INT\n";
+                print "    --blocks [\"STRING\", \"STRING\", ...]\n";
+                print "-----------------------------------------------/\n";
+            }
+
+            # unrecognized command
+            else
+            {
+                send_warning( "Unrecognized input. Type 'help' for information" );
+            }
+        }
+
+        print $BNG_PROMPT;
+    }
+    
+    # stdin close
+    return 0;
+}

data/bionetgen/Perl2/EnergyPattern.pm

@@ -0,0 +1,252 @@
+package EnergyPattern;
+# This class defines an energy pattern which contributes to the overall
+#  energy of a Species and influences reaction rates.   --Justin
+
+# pragmas
+use strict;
+use warnings;
+no warnings 'redefine';
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+# BNG Modules
+use BNGUtils;
+use BNGModel;
+use SpeciesGraph;
+
+
+
+struct EnergyPattern => 
+{		   
+    Pattern => 'SpeciesGraph',  # pattern graph
+    Gf      => 'Expression',    # free-energy parameter (per match)
+    Weights => '@'              # number of matches to each species
+};
+
+
+###
+###
+###
+
+
+sub readString
+{
+    my ($epatt, $string, $model) = @_;
+
+    my $err;
+
+	# strip any leading whitesace
+    $string =~ s/^\s+//;
+
+    # Check if first token is an index (This index will be ignored)
+    # DEPRECATED as of BNG 2.2.6
+    if($string =~ s/^\s*\d+\s+//)
+    {
+    		return "Leading index detected at '$string'. This is deprecated as of BNG 2.2.6.";
+    }
+
+    # Remove leading label, if exists
+    if ($string =~ s/^\s*(\w+)\s*:\s+//)
+    {
+	    # Check label for leading number
+		my $label = $1;
+		if ($label =~ /^\d/) {  return "Syntax error (label begins with a number) at '$label'";  }
+    }
+    
+	# Check name for leading number
+	my $string_left = $string;
+	unless ( $string_left =~ s/^([A-Za-z_]\w*)// )
+	{ 
+		return "Syntax error (pattern name begins with a number) at $string.";
+	}
+    
+    # Next read the SpeciesGraph that will define the Energy Pattern
+    my $sep = '^\s+';
+    my $sg = SpeciesGraph->new();
+    $err = $sg->readString( \$string, $model->CompartmentList, 0, $sep, $model->MoleculeTypesList, 1 );
+    if ($err) { return "While reading Energy Pattern: $err"; }
+
+    $epatt->Pattern($sg);
+
+    # Look for free-energy of formation expression (Gf)
+    #  and construct equillibrium factor
+    my $Gf_expr = Expression->new();
+    if ( $string =~ /\S+/ )
+    {
+        # Read expression
+        $err = $Gf_expr->readString( \$string, $model->ParamList );
+        if ($err) { return undef, $err; }
+    }
+    else
+    {
+        $err = sprintf "Missing free-energy token for energy pattern %s", $epatt->Pattern->toString();
+        return $err;
+    }
+    # set Keq expression
+    $epatt->Gf($Gf_expr);
+    
+    # set Weights and RxnStoich to empty array
+    $epatt->Weights([]);
+
+    # return with error (if defined)
+    return $err;
+}
+
+
+
+sub toString
+{
+    my $epatt = shift;
+    my $plist = (@_) ? shift : undef;
+    my $string = '';
+
+    $string .=  $epatt->Pattern->toString() . "  "
+              . $epatt->Gf->toString($plist);
+
+    return $string;
+}
+
+
+
+sub toMatlabString
+{
+   my $epatt = shift;
+   my $string = '';
+   
+   # TODO
+     
+   return $string, '';
+}
+
+
+
+sub toMexString
+{
+    my $epatt = shift;
+    my $string = '';
+   
+    # TODO
+   
+    return $string, '';
+}
+
+
+
+sub toXML
+{
+    my $epatt  = shift;
+    my $indent = shift;
+    my $index  = shift;
+    
+    my $string = '';
+    
+    # TODO
+    
+    return $string, '';
+}
+
+
+
+sub toMathMLString
+{
+        my $epatt  = shift;
+    my $string = '';
+
+    # TODO
+
+    return $string, '';
+}
+
+
+# reset the observable weights to zero
+sub reset_weights
+{
+    my $epatt   = shift @_;
+    my $alloc = @_ ? shift @_ : 0;
+    $epatt->Weights( [(0) x ($alloc+1)] );
+}
+
+
+
+sub update
+{
+    my $epatt   = shift @_;
+    my $species = shift @_;
+    my $idx_start = @_ ? shift @_ : 0;
+
+    my $err = undef;
+    for ( my $ii = $idx_start; $ii < @$species; ++$ii )
+    {
+        my $spec = $species->[$ii];
+        next if ($spec->ObservablesApplied);
+        my @matches = $epatt->Pattern->isomorphicToSubgraph($spec->SpeciesGraph);
+        $epatt->Weights->[$spec->Index] = (scalar @matches)/($epatt->Pattern->Automorphisms);
+    }
+    return $err;
+}
+
+
+
+sub getStoich
+# returns an integer value corresponding to the stoichiometry of
+#  this pattern w.r.t. a given reaction.
+{
+    my ($epatt, $rxn) = @_;
+    
+    my $err;
+    my $stoich = 0;
+    foreach my $reactant (@{$rxn->Reactants})
+    {
+        if ( $epatt->Weights->[$reactant->Index] )
+        {   $stoich -= $epatt->Weights->[$reactant->Index];   }
+    }
+    foreach my $product (@{$rxn->Products})
+    {
+        if ( $epatt->Weights->[$product->Index] )
+        {   $stoich += $epatt->Weights->[$product->Index];   }
+    }
+    return $stoich, $err;
+}
+
+
+
+sub getDeltaEnergy
+{
+    my ($epatt, $rxn, $plist) = @_;
+    
+    my $err;
+    my $stoich;
+ 
+    # get stoichiometry of this pattern w.r.t. this rxn
+    ($stoich, $err) = $epatt->getStoich($rxn);
+    if ( $err ) { return undef, $err; }
+    
+    # construct a rate constant expression
+    my $rate_expr = undef;
+    if ( $stoich!=0 )
+    {
+        if ( $stoich == 1 )
+        {
+            $rate_expr = $epatt->Gf;
+        }
+        elsif ( $stoich == -1 )
+        {
+            $rate_expr = Expression::operate("-", [$epatt->Gf], $plist);    
+        }
+        else
+        {
+            $rate_expr = Expression::operate("*", [$stoich, $epatt->Gf], $plist);
+        }
+    }
+    
+    return $rate_expr, $err;
+}
+
+###
+###
+###
+
+1;

data/bionetgen/Perl2/Expression.pm

@@ -0,0 +1,1987 @@
+# $Id: Expression.pm,v 1.7 2007/02/20 17:39:38 faeder Exp $
+
+# updated by msneddon, 2009/11/04
+#   -added if statement as built in function
+#   -added binary logical operators, <,>.<=,>=,==,!=,~=,&&,||
+#    to the basic functional parser, the toString function, and 
+#    to the evaluate function
+
+#   -todo: add binary operators to method toMathMLString function
+#   -todo: add the unary operator not: '!' (this is implemented, but not tested. --JSH)
+
+package Expression;
+
+# pragmas
+use strict;
+use warnings;
+no warnings 'redefine';
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+use Scalar::Util ("looks_like_number");
+
+# BNG Modules
+use Param;
+use ParamList;
+
+#use POSIX qw/floor ceil/; # safer to use 'floor' and 'ceil' instead of 'int'
+use POSIX qw/floor/; # 'floor' and 'ceil' not supported by muParser. Use 'floor' for 'rint'.
+use Math::Trig qw(tan asin acos atan sinh cosh tanh asinh acosh atanh pi); 
+use List::Util qw(min max sum);
+
+struct Expression =>
+{
+    Type    => '$',    # Valid types are 'NUM', 'VAR', 'FunctionCall', '+', '-', '*', '/', '^', '**',
+                       # '>','<','>=','<=','==','!=','~=','&&','||','!','~'
+    Arglist => '@',
+    Err     => '$',
+};
+
+
+# NOTE: it's weird that some built-in functions with names (like exp, cos, etc) are handled
+#  differently thant built-ins with operator symbols (like +, -, etc).  We could really simplify this.
+#  --Justin
+# Supported most muParser built-in functions. --LAH 
+# See http://muparser.sourceforge.net/mup_features.html#idDef2 for the complete list.
+my %functions =
+(
+  "_pi"   => { FPTR => sub { pi },                   NARGS => 0 }, # <pi>
+  "_e"    => { FPTR => sub { exp(1) },               NARGS => 0 }, # <exponentiale> (MathML 2.0)
+  "time"  => { FPTR => sub 
+  	{ 
+  		if (defined($BNGModel::GLOBAL_MODEL->time)) 
+  		{$BNGModel::GLOBAL_MODEL->time} 
+  		else {0} 
+  	}, 												 NARGS => 0 }, # ???
+  "exp"   => { FPTR => sub { exp( $_[0] ) },         NARGS => 1 }, # <exp/> (MathML 2.0)
+  "ln"    => { FPTR => sub { log( $_[0] ) },         NARGS => 1 }, # <ln/>
+  "log10" => { FPTR => sub { log($_[0])/log(10) },   NARGS => 1 }, # <log/>
+  "log2"  => { FPTR => sub { log($_[0])/log(2) },    NARGS => 1 }, # <log/><logbase><cn>2</cn></logbase>
+  "abs"   => { FPTR => sub { abs( $_[0] ) },         NARGS => 1 }, # <abs/>
+# "int"   => { FPTR => sub { int( $_[0] ) },         NARGS => 1 }, # deprecated!
+# "floor" => { FPTR => sub { floor( $_[0] ) },       NARGS => 1 }, # not supported by muParser
+# "ceil"  => { FPTR => sub { ceil( $_[0] ) },        NARGS => 1 }, # not supported by muParser
+  "rint"  => { FPTR => sub { floor( $_[0] + 0.5 ) }, NARGS => 1 }, # requires special handling (see toMathMLString)
+  "sqrt"  => { FPTR => sub { sqrt( $_[0] ) },        NARGS => 1 }, # <root/>
+  "cos"   => { FPTR => sub { cos( $_[0] ) },         NARGS => 1 }, # <cos/>
+  "sin"   => { FPTR => sub { sin( $_[0] ) },         NARGS => 1 }, # <sin/>
+  "tan"   => { FPTR => sub { tan( $_[0] ) },         NARGS => 1 }, # <tan/>
+  "asin"  => { FPTR => sub { asin( $_[0] ) },        NARGS => 1 }, # <arcsin/>
+  "acos"  => { FPTR => sub { acos( $_[0] ) },        NARGS => 1 }, # <arccos/>
+  "atan"  => { FPTR => sub { atan( $_[0] ) },        NARGS => 1 }, # <arctan/>
+  "sinh"  => { FPTR => sub { sinh( $_[0] ) },        NARGS => 1 }, # <sinh/>
+  "cosh"  => { FPTR => sub { cosh( $_[0] ) },        NARGS => 1 }, # <cosh/>
+  "tanh"  => { FPTR => sub { tanh( $_[0] ) },        NARGS => 1 }, # <tanh/>
+  "asinh" => { FPTR => sub { asinh( $_[0] ) },       NARGS => 1 }, # <arcsinh/> (MathML 2.0)
+  "acosh" => { FPTR => sub { acosh( $_[0] ) },       NARGS => 1 }, # <arccosh/> (MathML 2.0)
+  "atanh" => { FPTR => sub { atanh( $_[0] ) },       NARGS => 1 }, # <arctanh/> (MathML 2.0)
+  "if"    => { FPTR => sub { if($_[0]) { $_[1] } else { $_[2] } }, NARGS => 3 }, # requires special handling (see toMathMLString)
+  "min"   => { FPTR => sub { min(@_) },              NARGS => scalar(@_) }, # <min/>
+  "max"   => { FPTR => sub { max(@_) },              NARGS => scalar(@_) }, # <max/>
+  "sum"   => { FPTR => sub { sum(@_) },              NARGS => scalar(@_) }, # <sum/>
+  "avg"   => { FPTR => sub { sum(@_)/scalar(@_) },   NARGS => scalar(@_) }, # <mean/>
+);
+
+my $MAX_LEVEL = 500;    # Prevent infinite loop due to dependency loops
+
+# this hash maps operators to the min and max number of arguments
+my %NARGS = ( '+'  => { 'min'=>2           }, # <plus/>
+              '-'  => { 'min'=>1           }, # <minus/>
+              '*'  => { 'min'=>2           }, # <times/>
+              '/'  => { 'min'=>2           }, # <divide/>
+              '^'  => { 'min'=>2, 'max'=>2 }, # <power/>
+              '**' => { 'min'=>2, 'max'=>2 }, # Not supported by muParser
+              '&&' => { 'min'=>2           }, # <and/>
+              '||' => { 'min'=>2           }, # <or/>
+              '<'  => { 'min'=>2, 'max'=>2 }, # <lt/>
+              '>'  => { 'min'=>2, 'max'=>2 }, # <gt/>
+              '<=' => { 'min'=>2, 'max'=>2 }, # <leq/>
+              '>=' => { 'min'=>2, 'max'=>2 }, # <geq/>
+              '!=' => { 'min'=>2, 'max'=>2 }, # <neq/>
+              '~=' => { 'min'=>2, 'max'=>2 }, # Not supported by muParser
+              '==' => { 'min'=>2, 'max'=>2 }, # <equivalent/> (MathML 2.0)
+              '!'  => { 'min'=>1, 'max'=>1 }, # Not supported by muParser
+              '~'  => { 'min'=>1, 'max'=>1 }  # Not supported by muParser
+            );
+
+# muParser operators
+# ------------------
+# +   addition	 
+# -   subtraction	 
+# *   multiplication	 
+# /   division	 
+# ^   raise x to the power of y	 
+# &&  logical and	 
+# ||  logical or	 
+# <   less than	 
+# >   greater than	 
+# <=  less or equal	 
+# >=  greater or equal	 
+# !=  not equal	 
+# ==  equal	 
+
+
+# this regex matches param names (letter followed optional by word characters)
+my $PARAM_REGEX  = '^\w+$';
+
+
+###
+###
+###
+
+sub isBuiltIn
+{
+	my $name = shift @_;
+	return (exists $functions{$name} ? 1 : 0);
+}
+
+###
+###
+###
+
+
+# get a recursive copy of an expression.
+#   Note that the recursion does not descend past VAR and FunctionCall type expressions.
+#   Returns a reference to the clone and any error messages.
+sub clone
+{
+    my $expr = shift;
+    my $plist = (@_) ? shift : undef;
+    my $level = (@_) ? shift : 0;
+    
+    if ( $level > $MAX_LEVEL ) {  die "Max recursion depth $MAX_LEVEL exceeded.";  }
+    
+    my $err = '';
+
+    # create a new array for cloned argument    
+    my $clone_args = [];
+    # create clone
+    my $clone = Expression->new();
+    $clone->Type( $expr->Type );
+    $clone->Arglist( $clone_args );
+    $clone->Err( '' );
+
+    # clone argument expressions
+    foreach my $arg (  @{$expr->Arglist} )
+    {
+        my $clone_arg;
+        if ( ref $arg eq 'Expression' )
+        {
+            # recursively expand expressions
+            my $clone_arg;
+            ($clone_arg, $err) = $arg->clone($plist,$level+1);
+            push @$clone_args, $clone_arg;   
+        }
+        else
+        {
+            push @$clone_args, $arg;
+        }      
+    }      
+ 
+    return ($clone, $err);
+}
+
+
+# TODO: simplify method
+# eliminate 1's from mulitplications and divisions
+# eliminate 0's from additions and subtractions.
+# cancel terms in basic arthimetic operations.
+
+
+###
+###
+###
+
+
+# create a new expression from a number or a param name
+sub newNumOrVar
+{
+    my $value = shift @_;
+    my $plist = (@_) ? shift @_ : undef;
+    
+    my $expr;
+    my $err;
+    # is this a number?
+    if ( looks_like_number($value) )
+    {   # create a new number expression
+        $expr = Expression->new();
+        $expr->Type('NUM');
+        $expr->Arglist( [$value] );
+        $expr->Err( undef );
+    }
+    # or possibly a parameter name?
+    elsif ( $value =~ /$PARAM_REGEX/ )
+    {
+        # we need a paramlist to continue
+        if ( ref $plist eq "ParamList" )
+        {
+            # check that parameter exists
+            (my $param, $err) = $plist->lookup( $value );
+            if (defined $param)
+            {   # create a new number expression
+                $expr = Expression->new();
+                $expr->Type('VAR');
+                $expr->Arglist( [$value] );
+                $expr->Err( undef );            
+            }
+        }
+    }
+    
+    unless (defined $expr)
+    {   die "Expression::newNumOrVar() - Attempted but failed to create number or variable expression";   }
+
+    # return expression or undefined
+    return $expr;
+}
+
+
+###
+###
+###
+
+
+# Creates a new expression from a list of existing expressions.
+# The type argument indicates the operation used to combine the expressions.
+#   E.g. '+', '-', 'FunctionCall'.
+# If the type is 'FunctionCall', then the first argument should be the name of
+#   a built-in or user-defined function.
+sub operate
+{
+    my ($type, $args, $plist) = @_;
+   
+    # can't do anything without arguments!
+    unless (@$args) { return undef; }
+    
+    # operate is unhappy without a paramlist!
+    unless (ref $plist eq 'ParamList') { return undef; }
+    
+    my $err;
+    my $args_copy;
+    
+    # copy the arguments
+    @$args_copy = @$args;
+        
+    # Check for the right number of arguments..
+   
+    # is this a function?
+    if ( $type eq 'FunctionCall' )
+    {
+        # get function name (first argument)
+        my $fcn_name = $args_copy->[0];
+
+        # is this a built-in function?
+        if ( defined $fcn_name  and  exists $functions{$fcn_name} )
+        {   # correct number of arguments?
+            return undef  unless ( $functions{$fcn_name}->{NARGS} == (@$args_copy - 1) );
+        }   
+        # or is this custom?
+        else
+        {
+            # lookup function in parameter list
+            (my $fcn_param, $err) = $plist->lookup( $fcn_name );
+            if ( $err  or  !defined($fcn_param) ) {   return undef;   }
+
+            if ( ref $fcn_param  ne 'Param'  or  $fcn_param->Type ne 'Function' )
+            {   return undef;  }
+
+            # correct number of arguments?
+            unless (  @{$fcn_param->Ref->Args} == (@$args_copy - 1)  )
+            {   return undef;   }
+        }
+        
+        # clone arguments (not first argument, which is the fcn name)
+        foreach my $arg ( @$args_copy[1..$#$args_copy] )
+        {
+            # clone argument, if it's an expression
+            if ( ref $arg eq 'Expression' ) 
+            {   ($arg, $err) = $arg->clone($plist);   }
+        
+            # if arg isn't an expression, try to create one  
+            else      
+            {   $arg = Expression::newNumOrVar( $arg );   }
+    
+            # check that are is still defined
+            unless (defined $arg) { return undef; }
+        }        
+    }
+    # or an operator?
+    else
+    {
+        # check that the operator exists and has the right number of arguments      
+        unless ( exists $NARGS{$type} )
+        {   return undef;   }
+        if (  (exists $NARGS{$type}->{min})  and  (($NARGS{$type}->{min}) > (@$args_copy))  )
+        {   return undef;   } 
+        if (  (exists $NARGS{$type}->{max})  and  (($NARGS{$type}->{max}) < (@$args_copy))  )
+        {   return undef;   }
+        
+        # clone arguments
+        foreach my $arg ( @$args_copy )
+        {
+            # clone argument, if it's an expression
+            if ( ref $arg eq 'Expression' ) 
+            {   ($arg, $err) = $arg->clone($plist);   }
+        
+            # if arg isn't an expression, try to create one  
+            else      
+            {   $arg = Expression::newNumOrVar($arg,$plist);   }
+    
+            # check that are is still defined
+            unless (defined $arg) { return undef; }  
+        }             
+    }
+            
+    # return undefined if there were any errors
+    if ($err) { return undef; }
+   
+    # create the new expression
+    my $expr = Expression->new();
+    $expr->Type( $type );
+    $expr->Arglist( $args_copy );
+    $expr->Err( undef );
+    
+    # return reference to expression!
+    return $expr;
+}
+
+
+###
+###
+###
+
+
+# load an expression by parsing a string
+{
+    my $string_sav;
+    my $variables = {};
+    my $allowForward = 0;
+
+
+    sub setAllowForward
+    {
+        my $expr = shift @_;
+        $allowForward = shift @_;
+    }
+
+
+    sub readString
+    {
+        # get arguments
+        my $expr      = shift @_;
+        my $sptr      = shift @_;
+        my $plist     = @_ ? shift @_ : undef;
+        my $end_chars = @_ ? shift @_ : '';
+        my $level     = @_ ? shift @_ : 0;
+        
+        my $err       = '';
+        my $ops_bi    = '\*\*|[+\-*/^]|>=|<=|[<>]|==|!=|~=|&&|\|\|';
+        my $ops_un    = '[+\-!~]';
+
+        if ( $level==0 )
+        {
+            $string_sav = $$sptr;
+            %$variables  = ();
+        }
+
+        # parse string into form expr op expr op ...
+        # a+b*(c+d)
+        # -5.0e+3/4
+        my $last_read       = '';
+        my $expr_new        = '';
+        my @list            = ();
+        my $expect_op       = 0;
+        my $assign_var_name = '';
+        while ( $$sptr ne '' )
+        {
+            # OPERATORS
+            if ($expect_op)
+            {
+                # Binary operator
+                if ( $$sptr =~ s/^\s*($ops_bi)// )
+                {
+                    my $express = Expression->new( Type=>$1 );
+                    push @list, $express;
+                    $expect_op = 0;
+                    next;
+                }
+    
+                # Assignment using '='.  Valid syntax is PARAM = EXPRESSION
+                # NOTE: this really stops the current expression (which should be a PARAM) and
+                #  starts parsing a RHS expression which will be assigned to PARAM.
+                elsif ( $$sptr =~ s/^\s*=// )
+                {
+                    # Check that only preceding argument is variable
+                    unless ( @list==1 )
+                    {  return "Invalid assignment syntax (VAR = EXPRESSION) in $string_sav at $$sptr";  }
+
+                    my $param      = $list[0];
+                    my $param_name = $param->Arglist->[0];
+                    
+					# Make sure parameter name not the same as built-in functions --Leonard
+					if ( exists $functions{ $param_name } ){
+						return "Cannot use built-in function name '$param_name' as a parameter name.";
+					}
+					
+                    unless ( $param->Type eq 'VAR' )
+                    {   return "Attempted assignment to non-variable type in $string_sav at $$sptr.";   }
+
+                    # save old variables
+                    my $old_variables;
+                    %{$old_variables} = %{$variables};
+                    %{$variables} = ();
+                    # save old string_sav
+                    my $old_string_sav = $string_sav;
+
+                    # Read remainder as expression
+                    my $rhs = Expression->new();
+                    $err = $rhs->readString( $sptr, $plist, $end_chars, $level + 1 );
+                    if ($err) {  return $err;  }
+
+                    # check for recursive definitions
+                    if ( exists $variables->{$param_name} )
+                    {  return "Parameter $param_name is defined recursively.";  }
+
+                    # fetch old variables and string_sav
+                    %{$variables} = %{$old_variables};
+                    $string_sav = $old_string_sav;
+
+                    # assign the rhs expression to the parameter $vname
+                    $plist->set( $param_name, $rhs );
+                    last;
+                }
+    
+                # Look for end characters
+                elsif ( $end_chars  and  ( $$sptr =~ /^\s*${end_chars}/ ) )
+                {   # end of expression
+                    last;
+                }
+                else
+                {   # nothing more to do
+                    # TODO: add warning for trailing characters?
+                    $$sptr =~ s/^\s*//;
+                    last;
+                }
+            }
+    
+            # Chop leading whitespace
+            $$sptr =~ s/^\s*//;
+    
+            # look for a NUMBER
+            if ( my $num_expr = getNumber($sptr) )
+            {
+                push @list, $num_expr;
+                $expect_op = 1;
+                next;
+            }
+    
+            # look for a function call
+            if ( $$sptr =~ s/^($ops_un)?\s*(\w+)\s*\(// )
+            {
+                my $express_u;
+                if ( my $op = $1 )
+                {   # (optional) UNARY OP at start of expression, as in -a + b, or -a^2
+                    $express_u = Expression->new( Type=>$1 );
+                }
+
+                my $name  = $2;
+                my @fargs = ();
+                my $type  = '';
+                my $nargs;
+                my ($param, $err);
+                if ($plist)
+                { 
+                    ($param, $err) = $plist->lookup($name); 
+                }
+                if ( exists $functions{$name} )
+                {
+                    $type  = "B";
+                    $nargs = $functions{$name}->{NARGS};
+                }
+#                elsif ( $param  and  ($param->Type eq 'Observable') )
+                elsif ( $param  and defined $param->Type and ($param->Type eq 'Observable') )
+                {
+                    $type = "O";
+                    # number of args may be zero or one.
+                }
+#                elsif ( $param  and  ($param->Type eq 'Function') )
+                elsif ( $param  and defined $param->Type and ($param->Type eq 'Function') )
+                {
+                    $type  = "F";
+                    $nargs = scalar( @{ $param->Ref->Args } );
+                }
+                else
+                {
+					unless ( defined $param )
+					{
+	                    if ($allowForward)
+	                    { $plist->set($name); }
+	                    else
+	                    {
+	                        return "Function $name is not a built-in function, Observable, or defined Function";
+	                    }
+					}
+                }
+    
+                # Read arguments to function
+                while (1)
+                {
+                    my $express = Expression->new();
+                    $err = $express->readString( $sptr, $plist, ',\)', $level + 1 );
+                    if ($err) { return $err; }
+                    if ($express->Type) { push @fargs, $express; }
+                    
+                    if ( $$sptr =~ s/^\)// )
+                    {   last;   }
+                    elsif ( $$sptr =~ s/^,// )
+                    {   next;   }
+                }
+    
+                # Check Argument list for consistency with function
+                if ( $type eq "O" )
+                {
+                    $nargs= scalar(@fargs);
+                    if  ($nargs>1){
+                        return ("Observables $name is called with too many arguments");
+                    }
+                    elsif ($nargs==1)
+                    {
+                        # Argument must be VAR
+                        if ($fargs[0]->Type ne "VAR"){
+                            return("Argument to observable must be a variable");
+                        }
+                        # Argument to Observable must be Local type
+                        (my $lv) = $plist->lookup($fargs[0]->Arglist->[0]);
+                        if ($lv->Type ne "Local"){
+                            return( "Argument to observable must be a local variable" );
+                        }
+                    }
+                }
+                else
+                {
+#					if ( $param  and  ($nargs != @fargs) )
+					if ( $type ne '' and $param  and  ($nargs != @fargs) )
+                    {   return "Incorrect number of arguments to function $name";   }
+                }
+                my $express = Expression->new( Type=>'FunctionCall', Arglist=>[$name, @fargs] );
+
+                if (defined $express_u)
+                {
+                    push @{$express_u->Arglist}, $express;
+                    push @list, $express_u;
+                } 
+                else
+                {   push @list, $express;   }
+
+                $expect_op = 1;
+                next;
+            }
+    
+            # VARIABLE
+            elsif ( $$sptr =~ s/^($ops_un)?\s*(\w+)// )
+            {
+                my $express_u;
+                if ( my $op = $1 )
+                {   # (optional) UNARY OP at start of expression, as in -a + b, or -a^2
+                    $express_u = Expression->new( Type=>$1 );
+                }
+                my $name = $2;
+
+                # Validate against ParamList, if present
+                if ($plist)
+                {
+                    # Create and set variable if next token is '='
+                    # otherwise create referenced variable but leave its Expr unset
+                    unless ( $$sptr =~ /^\s*=/ )
+                    {
+                        my ( $param, $err ) = $plist->lookup($name);
+                        unless ( defined $param )
+                        {
+                            if ($allowForward)
+                            {   $plist->set($name);   }
+                            else
+                            {   return "Can't reference undefined parameter $name";   }
+                        }
+                    }
+                }
+                else
+                {   return "No parameter list provided";   }
+
+                my $express = Expression->new( Type=>'VAR', Arglist=>[$name] );
+                ++($variables->{$name});
+
+                if (defined $express_u)
+                {
+                    push @{$express_u->Arglist}, $express;
+                    push @list, $express_u;
+                } 
+                else
+                {   push @list, $express;   }
+
+                $expect_op = 1;
+                next;
+            }
+
+            # Get expression enclosed in parentheses
+            elsif ( $$sptr =~ s/^($ops_un)?\s*\(// )
+            {
+                my $express_u;
+                if ( my $op = $1 )
+                {   # (optional) UNARY OP at start of expression, as in -a + b, or -a^2
+                    $express_u = Expression->new( Type=>$1 );
+                }
+                my $express = Expression->new();
+                $err = $express->readString( $sptr, $plist, '\)', $level + 1 );
+                if ($err) {  return ($err);  }
+                unless ( $$sptr =~ s/^\s*\)// )
+                {   return "Missing end parentheses in $string_sav at $$sptr";   }
+    
+                #printf "express=%s %s\n", $express->toString($plist), $$sptr;
+                if (defined $express_u)
+                {
+                    push @{$express_u->Arglist}, $express;
+                    push @list, $express_u;
+                } 
+                else
+                {   push @list, $express;   }
+
+                $expect_op = 1;
+                next;
+            }
+            elsif ( $end_chars  and  ($$sptr =~ /^\s*[${end_chars}]/) )
+            {   last;   }
+          
+            # ERROR
+            else
+            {   return "Expecting operator argument in $string_sav at $$sptr";   }
+        }
+
+        # Transform list into expression preserving operator precedence
+        if (@list) { $expr->copy(arrayToExpression(@list)); }
+        
+        return $err;
+    }
+}
+
+
+###
+###
+###
+
+
+
+
+# check if expression depends on parameter "varname"
+sub depends
+{
+    my $expr    = shift;
+    my $plist   = shift;
+    my $varname = shift;
+    my $level   = (@_) ? shift : 0;
+    my $dep     = (@_) ? shift : {};
+
+    my $retval = '';
+    my $err    = '';
+
+    my $type = $expr->Type;
+    if ( $type eq 'NUM' )
+    {
+        # this expression is a number: no dependency on varname
+    }
+    elsif ( $type eq 'VAR' )
+    {
+        # this expression is a parameter name: check if parameter depends on varname
+        my $param_name = $expr->Arglist->[0];
+
+        if ( exists $dep->{$param_name} and $dep->{$param_name} )
+        {
+            # cyclic dependency detected
+            $err = sprintf "Cycle in parameter $param_name looking for dep in %s", $varname;
+            print "$err\n";
+            $retval = $param_name;
+        }
+        else
+        {
+            if ( $varname eq $param_name )
+            {
+                # the parameter is varname: we found a dependency!
+                $retval = $param_name;
+            }
+            elsif ($plist)
+            {
+                # lookup parameter and see what it depends on..
+                (my $param) = $plist->lookup($param_name);
+                if ( defined $param )
+                {
+                    # copy dependency hash and pass it down
+                    my $new_dep = { %$dep };
+                    $new_dep->{$param_name} = 1;
+                    (my $ret, $err) = $param->Expr->depends($plist, $varname, $level+1, $new_dep);
+                    if ($ret)
+                    {
+                        $retval = $param_name . '->' . $ret;
+                    }
+                }
+            }
+        }
+    }
+    else
+    {
+        # this expression is an operator, function or observable
+        # ..check if this depends on varname
+        my @arglist = @{ $expr->Arglist };
+        # Skip function name if this is a function
+        if ( $type eq 'FunctionCall' ) {  shift @arglist;  }
+        foreach my $expr (@arglist)
+        {
+            ($retval, $err) = $expr->depends($plist, $varname, $level + 1, $dep);
+            last if $retval;
+        }
+    }
+
+    return ($retval, $err);
+}
+
+
+
+###
+###
+###
+
+
+
+# copy the contents of this expression into a second expression.
+#  NOTE: this is not recursive!!  use the clone method to get a recursive copy
+sub copy
+{
+    my $edest   = shift;
+    my $esource = shift;
+
+    $edest->Type( $esource->Type );
+    $edest->Arglist( [ @{ $esource->Arglist } ] );
+    return ($edest);
+}
+
+
+
+###
+###
+###
+
+
+# evaluate an expression and return a numerical value
+sub evaluate
+{
+    my $expr  = shift;
+    my $plist = (@_) ? shift : undef;
+    my $level = (@_) ? shift : 0;
+
+    if ( $level > $MAX_LEVEL ) {  die "Max recursion depth $MAX_LEVEL exceeded.";  }
+
+    my $val = undef;
+    if ( $expr->Type eq 'NUM' )
+    {
+        $val = $expr->Arglist->[0];
+    }
+    elsif ( $expr->Type eq 'VAR' )
+    {        
+        unless (defined $plist)
+        {  die "Expression->evaluate: Error! Cannot evaluate VAR type without ParamList.";  }
+    
+        my $name = $expr->Arglist->[0];
+        $val = $plist->evaluate( $name, [], $level+1 );
+        unless (defined $val)
+        {  die "Expression->evaluate: Error! Parameter $name is not defined!\n";  }
+    }
+    elsif ( $expr->Type eq 'FunctionCall' )
+    {
+        # first argument is function name
+        my $name  = $expr->Arglist->[0];
+
+        if ( ref $name eq "Function" )
+        {   # anonymous function (TODO: double-check that its ok to be lazy about evaluating the args
+            $val = $name->evaluate( $expr->Arglist, $plist, $level+1);
+        }
+        elsif ( exists $functions{$name} )
+        {   # built-in function
+            my $f = $functions{$name}->{FPTR};
+            # evaluate all the remaining arguments
+            my $eval_args = [];
+            my $ii=1;
+            while ( $ii < @{$expr->Arglist} )
+            {
+                push @$eval_args, $expr->Arglist->[$ii]->evaluate($plist, $level+1);
+                ++$ii;
+            }             
+            $val = $f->(@$eval_args);
+        }
+        
+        else
+        {   # lookup user-defined function in paramlist
+            unless (defined $plist)
+            {  die "Expression->evaluate: Error! Cannot evaluate user Function without ParamList.";  }
+        
+            $val = $plist->evaluate( $name, $expr->Arglist, $level+1 );
+        }
+    }
+    else
+    {
+        my $eval_string;
+        my $operator = $expr->Type;
+
+        # replace non-perl operators with the perl equivalents
+        if    ( $operator eq '~=' ) {  $operator = '!=';  }
+        elsif ( $operator eq '^'  ) {  $operator = '**';  }
+        elsif ( $operator eq '~'  ) {  $operator = '!';   } 
+        
+        if ( @{$expr->Arglist} == 1 )
+        {   # handle unary operators
+            if ( $operator eq "/" )
+            {
+                $eval_string = "1.0/(\$expr->Arglist->[0]->evaluate(\$plist,\$level+1))";
+            }
+            else
+            {
+                $eval_string = "$operator(\$expr->Arglist->[0]->evaluate(\$plist,\$level+1))";
+            }
+        
+        }
+        else
+        {
+            my $last = @{$expr->Arglist} - 1;
+            $eval_string = join "$operator", map {"(\$expr->Arglist->[$_]->evaluate(\$plist,\$level+1))"} (0..$last);
+        }
+        
+        # check if this is boolean type
+        if ( $operator =~ /[<>|&!=]/ )
+        {
+            # evaluate the expression
+            local $SIG{__WARN__} = sub {};
+            $val = eval "$eval_string" ? 1 : 0;
+            if ($@) {  die $@;  }
+        }
+        else
+        {
+            # evaluate the expression
+            local $SIG{__WARN__} = sub {};
+            $val = eval "$eval_string";
+            if ($@) {  die $@;  }
+        }
+    }
+
+    return $val;
+}
+
+
+
+###
+###
+###
+
+
+
+# Call this method to clone an expression and then descend into the expression
+#  and evaluate any local observables.  The method returns the cloned variable
+#  with local observables evaluated as numbers.  NOTE: this method will not
+#  work correctly if observables haven't been computed prior to the call.
+sub evaluate_local
+{
+    my $expr  = shift @_;
+    my $plist = @_ ? shift @_ : undef;
+    my $level = @_ ? shift @_ : 0;
+    
+    if ( $level > $MAX_LEVEL ) {  return (undef, "Max recursion depth $MAX_LEVEL exceeded.");  }
+    unless (defined $plist)    {  die "Expression->evaluate_local: Error! Function called without required ParamList.";  }    
+    
+    # local variables
+    my $local_expr = undef;
+    my $err = '';
+
+    # clone expression
+    ($local_expr, $err) = $expr->clone( $plist, $level+1 );
+
+    # evaluate local dependencies in arguments
+    foreach my $arg ( @{$local_expr->Arglist} )
+    {
+        # only need to do this for expression arguments
+        if ( ref $arg eq 'Expression' )
+        {   $arg = $arg->evaluate_local($plist, $level+1);   }
+    } 
+   
+    # some additional handling for Function expressions!
+    if ( $expr->Type eq 'FunctionCall' )
+    {
+        # if local arguments are passed to this function, then we
+        #  must go into the function and evaluate the local bits.  Then
+        #  we need to create a clone of the function that has the local bits evaluated.
+        #  Yuck!
+        
+        # First argument is the function name
+        my $name = $expr->Arglist->[0];
+
+        if ( ref $name eq "Function" )
+        {   # anonymous function..
+            my $fcn = $name;
+            # get locally evaluated function
+            my ($local_fcn, $elim_args) = $fcn->evaluate_local( $local_expr->Arglist, $plist, $level+1 );
+
+            # if the local_fcn does not refer to observables of named functions,
+            # then we can convert it to a constant expression
+            my $dependencies = $local_fcn->Expr->getVariables($plist);
+            if ( @{$local_fcn->Args}==0
+                 and not exists $dependencies->{'Observable'}
+                 and not exists $dependencies->{'Function'}   )
+            {   # replace this fcn call with the localfcn expression
+                $local_expr = $local_fcn->Expr;
+            }                
+            else
+            {   # point this fcn call to the local expr
+                $local_expr->Arglist->[0] = $local_fcn;
+                # eliminate unused arguments
+                foreach my $iarg (@$elim_args)
+                {   splice @{$local_expr->Arglist}, $iarg, 1;   }
+            }
+        }
+        elsif ( exists $functions{$name} )
+        {
+            # nothing to do
+        }
+        else
+        {   # custom, named function 
+            # lookup function parameter:
+            (my $fcn_param) = $plist->lookup( $name );
+            
+            # Is this a true function or an observable??
+            if ( $fcn_param->Type eq 'Function' )
+            {                    
+                # get locally evaluated function
+                my ($local_fcn, $elim_args) = $fcn_param->Ref->evaluate_local( $local_expr->Arglist, $plist, $level+1 );
+
+                # if the local_fcn does not refer to observables of named functions,
+                # then we can convert it to a constant expression
+                my $dependencies = $local_fcn->Expr->getVariables($plist);
+                if ( @{$local_fcn->Args}==0
+                     and not exists $dependencies->{'Observable'}
+                     and not exists $dependencies->{'Function'}   )
+                {   # replace this fcn call with the localfcn expression
+                    $local_expr = $local_fcn->Expr;
+                }                
+                else
+                {   # point this fcn call to the local expr
+                    $local_expr->Arglist->[0] = $local_fcn;
+                    # eliminate unused arguments
+                    foreach my $iarg (@$elim_args)
+                    {   splice @{$local_expr->Arglist}, $iarg, 1;   }
+                }
+            }
+            # This function is Really an Observable!!    
+            elsif ( $fcn_param->Type eq 'Observable' )
+            {         
+                if ( @{$expr->Arglist} > 1 )
+                {
+                    # get locally evaluated function
+                    my $val = $fcn_param->Ref->evaluate( $local_expr->Arglist, $plist, $level+1 );      
+           
+                    # replace local expression with the evaluation
+                    my $args = [ $val ];
+                    $local_expr->Type('NUM');
+                    $local_expr->Arglist($args);
+                    $local_expr->Err(undef);
+                }
+            }
+            # The reference type is not known, abort with error!
+            else
+            {   $err = "ERROR in Expression->evaluate_local(): expression is a function, but ref type is unknown!";   }   
+        }
+    }
+
+    return $local_expr;
+}
+
+
+
+###
+###
+###
+
+
+# check for local observable dependency, return true if found
+sub checkLocalDependency
+{
+    my $expr  = shift;
+    my $plist = shift;
+    my $level = (@_) ? shift : 0;
+
+    unless ( defined $plist )
+    {   die "Expression->checkLocalDependency: Error! Missing argument ParamList!";   }
+    
+
+    # check dependence of arguments
+    foreach my $arg ( @{$expr->Arglist} )
+    {
+        if ( ref $arg eq 'Expression' )
+        {
+            return 1  if ( $arg->checkLocalDependency( $plist, $level+1 ) );
+        }
+    }    
+       
+    if ( $expr->Type eq 'FunctionCall' )
+    {    
+        my $name = $expr->Arglist->[0];
+
+        if ( ref $name eq "Function" )
+        {   # anonymous function..
+            my $fcn = $name;        
+            return 1  if ( $fcn->checkLocalDependency( $plist, $level+1 ) );
+        }
+        elsif ( exists $functions{$name} )
+        {
+            # nothing to do
+        }
+        else
+        {   # lookup custom function by name
+            my ($fcn_param) = $plist->lookup( $expr->Arglist->[0] );
+            # is this a true function or an observable?
+            if ( $fcn_param->Type eq 'Function' ) 
+            {   
+                my $fcn = $fcn_param->Ref;            
+                return 1  if ( $fcn->checkLocalDependency( $plist, $level+1 ) );
+            }
+            elsif ( $fcn_param->Type eq 'Observable' )
+            {
+                # function observables are locally dependent!!
+                return (@{$expr->Arglist} > 1 ? 1 : 0);
+            }
+        }
+    }
+    
+    return 0;
+}
+
+
+###
+###
+###
+
+
+# check if two expressions are equivalent
+sub equivalent
+{
+    my $expr1 = shift @_;
+    my $expr2 = shift @_;
+    my $plist = (@_) ? shift : undef;
+    my $level = (@_) ? shift : 0;
+  
+    # make sure we have defined expressions!
+    return 0  unless ( defined $expr1  and  ref $expr1 eq 'Expression' );
+    return 0  unless ( defined $expr2  and  ref $expr2 eq 'Expression' );
+
+    # shortcut: first check if we're looking at the same object
+    return 1  if ( $expr1 == $expr2 );
+    
+    # check type equivalence
+    return 0  unless ( $expr1->Type  eq  $expr2->Type );
+    
+    # check for equal number of arguments
+    return 0  unless ( @{$expr1->Arglist} == @{$expr2->Arglist} );
+    
+    # now we have to look deeper into the arguments
+    if    ( $expr1->Type eq 'NUM' )
+    {
+        # compare numbers
+        return ( $expr1->Arglist->[0]  ==  $expr2->Arglist->[0] );
+    }
+    elsif ( $expr2->Type eq 'VAR' )
+    {
+        # compare var names
+        return ( $expr1->Arglist->[0]  eq  $expr2->Arglist->[0] );
+    }
+    elsif ( $expr2->Type eq 'FunctionCall' )
+    {
+        # compare function names (or refs)
+        return 0  unless ( ref $expr1->Arglist->[0] eq ref $expr2->Arglist->[0] );
+        return 0  unless ( $expr1->Arglist->[0] eq $expr2->Arglist->[0] );
+    
+        # check argument equivalence
+        for ( my $i = 1;  $i < @{$expr1->Arglist};  ++$i )
+        {   
+            return 0
+                unless ( Expression::equivalent($expr1->Arglist->[$i], $expr2->Arglist->[$i], $plist, $level+1) );
+        }
+    }
+    else
+    {
+        # check argument equivalence
+        for ( my $i = 0;  $i < @{$expr1->Arglist};  ++$i )
+        {   
+            return 0
+                unless ( Expression::equivalent($expr1->Arglist->[$i], $expr2->Arglist->[$i], $plist, $level+1) );
+        }
+    }
+    
+    # return true if no differences have been found   
+    return 1;
+}
+
+
+
+
+# write this expression as a string.
+#  The expression is expanded up to the named Parameters and Functions.
+sub toString
+{
+    my $expr   = shift;
+    my $plist  = (@_) ? shift : undef;
+    my $level  = (@_) ? shift : 0;
+    my $expand = (@_) ? shift : 0;
+
+    # simple error checking
+    if ( $level > $MAX_LEVEL ) { die "Max recursion depth $MAX_LEVEL exceeded."; }
+    if ( $expand  and  !$plist ) { die "Can't expand expression past parameters without a parameter list."; }
+
+    # local variables
+    my $err;
+    my $string;
+    
+    # different handling depending on the type
+    my $type = $expr->Type;
+    if ( $type eq 'NUM' )
+    {
+        # if number, print the numerical value!
+        $string = $expr->Arglist->[0];
+        #print "NUM=$string\n";
+    }
+    elsif ( $type eq 'VAR' )
+    {
+        if ( $expand )
+        {   # descend recursively into parameter!
+            ( my $param, $err ) = $plist->lookup( $expr->Arglist->[0] );
+             $string = $param->toString( $plist, $level+1, $expand );
+        }
+        else
+        {   # just write the parameter name
+            $string = $expr->Arglist->[0];
+        }
+        #$string= $expr->evaluate($plist);
+        #print "VAR=$string\n";
+    }
+    elsif ( $type eq 'FunctionCall' )
+    {
+        my $name = $expr->Arglist->[0];
+        if ( $expand  or  (ref $name eq "Function") )
+        {   # expand the function
+            my @sarr = ($expr->Arglist->[0]);
+            foreach my $i ( 1 .. $#{$expr->Arglist} )
+            {   push @sarr, $expr->Arglist->[$i]->toString($plist, $level+1, $expand);   }
+
+            if (ref $name eq "Function")
+            {   # anonymous function
+                my $fcn = $name;
+                (my $local_fcn) = $fcn->evaluate_local( \@sarr, $plist, $level+1 );
+                $string = $local_fcn->Expr->toString( $plist, $level+1, $expand );
+            }
+            elsif ( exists $functions{$name} )
+            {   # built-in function
+                $string = $expr->Arglist->[0] . "(" . join(",", @sarr[1..$#sarr]) . ")";
+            }
+            else
+            {   # lookup custom function by name and expand
+                ( my $param, $err ) = $plist->lookup($name);
+                (my $local_fcn) = $param->Ref->evaluate_local( \@sarr, $plist, $level+1 );
+                $string = $local_fcn->Expr->toString( $plist, $level+1, $expand );
+            }
+        }
+        else
+        {   # just write the function and its argument values
+            my @sarr = ();
+            foreach my $i ( 1 .. $#{$expr->Arglist} )
+            {
+                push @sarr, $expr->Arglist->[$i]->toString( $plist, $level + 1 );
+            }
+            $string = $name . '(' . join( ',', @sarr ) . ')';
+        }
+    }
+    else
+    {
+        if ( $expand )
+        {
+            my @sarr = ();
+            foreach my $e ( @{ $expr->Arglist } ) {
+                push @sarr, $e->toString( $plist, $level+1, $expand );
+            }
+            if ( $#sarr > 0 )
+            {   $string = join( $type, @sarr );   }
+            else
+            {   $string = $type . $sarr[0];       }
+
+            # enclose in brackets if not at top level
+            #    print "level=$level\n";
+            if ($level)
+            {   $string = '(' . $string . ')';    }          
+        }
+        else
+        {
+            my @sarr = ();
+            foreach my $e ( @{ $expr->Arglist } ) {
+                push @sarr, $e->toString( $plist, $level + 1 );
+            }
+            if ( $#sarr > 0 )
+            {
+                $string = join( $type, @sarr );
+            }
+            else {
+                $string = $type . $sarr[0];
+            }
+
+            # enclose in brackets if not at top level
+            #    print "level=$level\n";
+            if ($level) {
+                $string = '(' . $string . ')';
+            }
+            #printf "%s=$string\n", $expr->Type;
+        }
+    }
+
+    return $string;
+}
+
+
+
+# write this expression as an XML string.
+#  Same as toString, except a few operators are replaced to avoid clashes with XML
+sub toXML
+{
+    my $expr   = shift;
+    my $plist  = (@_) ? shift : undef;
+    my $level  = (@_) ? shift : 0;
+    my $expand = (@_) ? shift : 0;
+
+    # simple error checking
+    if ( $level > $MAX_LEVEL ) { die "Max recursion depth $MAX_LEVEL exceeded."; }
+    if ( $expand  and  !$plist ) { die "Can't expand expression past parameters without a parameter list."; }
+
+    # local variables
+    my $err;
+    my $string;
+    
+    # different handling depending on the type
+    my $type = $expr->Type;
+    if ( $type eq 'NUM' )
+    {
+        # if number, print the numerical value!
+        $string = $expr->Arglist->[0];
+    }
+    elsif ( $type eq 'VAR' )
+    {
+        if ( $expand )
+        {
+            # descend recursively into parameter!
+            ( my $param, $err ) = $plist->lookup( $expr->Arglist->[0] );
+             $string = $param->toXML( $plist, $level+1, $expand );
+        }
+        else
+        {
+            # just write the parameter name
+            $string = $expr->Arglist->[0];
+        }
+    }
+    elsif ( $type eq 'FunctionCall' )
+    {
+        if ( $expand )
+        {
+            # TODO
+            my @sarr = ();
+            foreach my $i ( 1 .. $#{$expr->Arglist} )
+            {
+                push @sarr, $expr->Arglist->[$i]->toXML( $plist, $level + 1 );
+            }
+            $string = $expr->Arglist->[0] . '(' . join( ',', @sarr ) . ')';
+        }
+        else
+        {
+            my @sarr = ();
+            foreach my $i ( 1 .. $#{$expr->Arglist} )
+            {
+                push @sarr, $expr->Arglist->[$i]->toXML( $plist, $level + 1 );
+            }
+            $string = $expr->Arglist->[0] . '(' . join( ',', @sarr ) . ')';
+        }
+    }
+    else
+    {
+        if ( $expand )
+        {
+            my @sarr = ();
+            foreach my $e ( @{$expr->Arglist} )
+            {
+                push @sarr, $e->toXML( $plist, $level+1, $expand );
+            }
+            if ( $#sarr > 0 )
+            {   $string = join( $type, @sarr );   }
+            else
+            {   $string = $type . $sarr[0];       }
+
+            # enclose in brackets if not at top level
+            #    print "level=$level\n";
+            if ($level)
+            {   $string = '(' . $string . ')';    }          
+        }
+        else
+        {
+            my @sarr = ();
+            foreach my $e ( @{ $expr->Arglist } ) {
+                push @sarr, $e->toXML( $plist, $level + 1 );
+            }
+            if ( $#sarr > 0 )
+            {
+                $string = join( $type, @sarr );
+            }
+            else {
+                $string = $type . $sarr[0];
+            }
+
+            # enclose in brackets if not at top level
+            #    print "level=$level\n";
+            if ($level) {
+                $string = '(' . $string . ')';
+            }
+            #printf "%s=$string\n", $expr->Type;
+        }
+    }
+
+    # TODO: special handling for XML output should be handled by a special option
+    #  or a toXML sub.  --Justin
+    
+    #BEGIN edit, msneddon
+    # for outputting to XML, we need to make sure we put in some special
+    # characters and operators to match the muParser library and to allow
+    # the XML parser to work.<" with "&lt;", ">" with "&gt;", and
+    #"&" with "&amp
+    #print "before XML replacement: $string\n";
+    $string =~ s/</&lt\;/;
+    $string =~ s/>/&gt\;/;
+    $string =~ s/&&/and/;
+    $string =~ s/\|\|/or/;
+    #print "after XML replacement: $string\n";
+    #END edit, msneddon
+
+    return ($string);
+}
+
+
+
+
+# write expression as a string suitable for
+#  export to CVode.  This is the same as toString,
+#  except variable names are replaced with pointers into
+#  arrays.
+sub toCVodeString
+{
+    my $expr   = shift;
+    my $plist  = (@_) ? shift : '';
+    my $level  = (@_) ? shift : 0;
+    my $expand = (@_) ? shift : 0;
+
+    if ( $level > $MAX_LEVEL ) {  die "Max recursion depth $MAX_LEVEL exceeded.";  }
+
+    my $string;
+    my $err;
+    
+    my $type   = $expr->Type;
+    
+    if ( $type eq 'NUM' )
+    {
+        $string = $expr->Arglist->[0];
+        # if this is a pure integer,
+        #  add a decimal place to make sure C knows this has type double
+        $string =~ s/^(\d+)$/$1.0/;
+    }
+    elsif ( $type eq 'VAR' )
+    {   
+        # lookup corresponding parameter ...
+        (my $param, $err) = $plist->lookup( $expr->Arglist->[0] );
+        if ($param)
+        {   # return cvode ref
+            $string = $param->getCVodeName();
+        }
+        else
+        {   # parameter not defined, assume it's a local argument and write its name
+            $string = $expr->Arglist->[0];
+        }
+    }
+    elsif ( $type eq 'FunctionCall' )
+    {
+        # the first argument is the function name
+        my $fcn_name = $expr->Arglist->[0];
+        
+        if ( ref $fcn_name eq "Function" )
+        {   # anonymous function
+            my $fcn = $fcn_name;
+            # we can't call function by name, so we have to expand the function expression with args in place
+            (my $local_fcn) = $fcn->evaluate_local( [@{$expr->Arglist}], $plist, $level+1 );
+            unless (defined $local_fcn) { die "Error in Expression->toMatlabString(): some problem evaluating anonymous function"; }
+            $string = $local_fcn->Expr->toCVodeString($plist, $level+1, $expand);
+        }
+        elsif ( exists $functions{ $expr->Arglist->[0] } )
+        {   # this is a built-in function
+            # handle built-ins with 1 argument that have the same name in the C library
+            if ( $fcn_name =~ /^(sin|cos|exp|log|abs|sqrt|floor|ceil)$/ )
+            {
+                my @sarr = ( map {$_->toCVodeString($plist, $level+1, $expand)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+                $string = $fcn_name .'('. join( ',', @sarr ) .')';
+            }
+            # handle the 'if' built-in with 3 arguments
+            elsif ( $fcn_name eq 'if' )
+            {   
+                # substitute the "?" operator for the if function
+                my @sarr = ( map {$_->toCVodeString($plist, $level+1)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+
+                if ( @sarr == 3)
+                {   $string = '('. $sarr[0] .' ? '. $sarr[1] .' : '. $sarr[2] .')';   }
+                else
+                {   die "Error in Expression->toCVodeString():  built-in function 'if' must have three arguments!";   }    
+            }
+            # fatal error if the built-in is not handled above
+            else
+            {   die "Error in Expression->toCVodeString():  don't know how to handle built-in function $fcn_name!";   }
+        }
+        else
+        {   # user-defined function or observable
+            # lookup function parameter:
+            (my $fcn_param) = $plist->lookup( $fcn_name );
+            unless ($fcn_param)
+            {   die "Error in Expression->toCVodeString: could not find function parameter!";   }
+            
+            # Is this a true function or an observable??
+            if ( $fcn_param->Type eq 'Function' )
+            {   # Handling a true Function!                            
+                # expand argument expressions up until named entities
+                my @sarr = ( map {$_->toCVodeString($plist, $level+1, $expand)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+                # pass arguments pointing to the expressions array and observables array
+                push @sarr, 'expressions', 'observables';
+                $string = $fcn_name . '(' . join( ',', @sarr ) . ')';
+            }
+            elsif ( $fcn_param->Type eq 'Observable' )
+            {
+                # TODO: if there are arguments, then we should warn the user that we can't evaluate a local
+                # observables in a CVode function!!
+                $string = $fcn_param->getCVodeName();
+            }
+            else
+            {   die "Error in Expression->toCVodeString(): don't know how to process function expression of non-function type!";   }
+            
+        }
+        
+    }
+    elsif ( ($type eq '**') or ($type eq '^') )
+    {  
+        # substitute the "pow" function for the exponentiation operator
+        my @sarr = ( map {$_->toCVodeString($plist, $level+1)} @{$expr->Arglist} );
+    
+        if ( @sarr == 2 )
+        {   $string = 'pow(' . $sarr[0] . ',' . $sarr[1] . ')';  }
+        else
+        {   die "Error in Expression->toCVodeString(): Exponentiation must have exactly two arguments!";   }
+    }
+    else
+    {   
+        # handling some other operator (+,-,*,/)
+        # enclose in brackets (always. just to be safe)        
+        my @sarr = ( map {$_->toCVodeString($plist, $level+1, $expand)} @{$expr->Arglist} );
+        if ( @sarr > 1 )
+        {   # binary or higher order
+            $string = '(' . join( $type, @sarr ) . ')';
+        }
+        else
+        {   # unary operator
+            $string = '(' . $type . $sarr[0] . ')';
+        }
+    }
+
+    return ($string);
+}
+
+
+
+
+# write expression as a string suitable for
+#  export to a Matlab M-file.
+sub toMatlabString
+{
+    my $expr   = shift @_;
+    my $plist  = @_ ? shift @_ : undef;
+    my $level  = @_ ? shift @_ : 0;
+    my $expand = @_ ? shift @_ : 0;
+
+    if ( $level > $MAX_LEVEL ) {  die "Max recursion depth $MAX_LEVEL exceeded.";  }
+
+    my $string;
+    my $err;
+    
+    my $type   = $expr->Type;
+    
+    if ( $type eq 'NUM' )
+    {
+        $string = $expr->Arglist->[0];
+    }
+    elsif ( $type eq 'VAR' )
+    {   
+        # lookup corresponding parameter ...
+        (my $param, $err) = $plist->lookup( $expr->Arglist->[0] );
+        if ($param)
+        {   # return matlab ref
+            $string = $param->getMatlabName();   
+        }
+        else
+        {   # parameter not defined, assume it's a local argument and write its name
+            $string = $expr->Arglist->[0];
+        }        
+    }
+    elsif ( $type eq 'FunctionCall' )
+    {
+        # the first argument is the function name
+        my $fcn_name = $expr->Arglist->[0];
+        
+        if ( ref $fcn_name eq "Function" )
+        {   # anonymous function!
+            my $fcn = $fcn_name;
+            # we can't call function by name, so we have to expand the function expression with args in place
+            (my $local_fcn) = $fcn->evaluate_local( [@{$expr->Arglist}], $plist, $level+1 );
+            unless (defined $local_fcn) { die "Error in Expression->toMatlabString(): some problem evaluating anonymous function"; }
+            $string = $local_fcn->Expr->toMatlabString($plist, $level+1, $expand);
+        }
+        elsif ( exists $functions{ $expr->Arglist->[0] } )
+        {
+            # handle built-ins with 1 argument that have the same name in Matlab
+            if ( $fcn_name =~ /^(sin|cos|exp|log|abs|sqrt|floor|ceil)$/ )
+            {
+                my @sarr = ( map {$_->toMatlabString($plist, $level+1, $expand)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+                $string = $fcn_name .'('. join( ',', @sarr ) .')';
+            }
+            # handle the 'if' built-in with 3 arguments
+            elsif ( $fcn_name eq 'if' )
+            {   
+                # substitute the "?" operator for the if function
+                my @sarr = ( map {$_->toMatlabString($plist, $level+1)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+
+                if ( @sarr == 3)
+                {   # TODO: find better solution here. this version will return NaN if either return value is Inf.
+                    $string = sprintf( "((%s~=0)*%s + (%s==0)*%s)", $sarr[0], $sarr[1], $sarr[0], $sarr[2]);
+                }
+                else
+                {   die "Error in Expression->toMatlabString():  built-in function 'if' must have three arguments!";   }    
+            }
+            # fatal error if the built-in is not handled above
+            else
+            {   die "Error in Expression->toMatlabString():  don't know how to handle built-in function $fcn_name!";   }
+        }
+        else
+        {   # this is a user-defined function or observable
+            # lookup function parameter:
+            (my $fcn_param) = $plist->lookup( $fcn_name );
+            unless ($fcn_param)
+            {   die "Error in Expression->toMatlabString: could not find function parameter!";   }
+            
+            # Is this a true function or an observable??
+            if ( $fcn_param->Type eq 'Function' )
+            {   # Handling a true Function!                            
+                # expand argument expressions up until named entities
+                my @sarr = ( map {$_->toMatlabString($plist, $level+1, $expand)} @{$expr->Arglist}[1..$#{$expr->Arglist}] );
+                # pass arguments pointing to the expressions array and observables array
+                push @sarr, 'expressions', 'observables';
+                $string = $fcn_name . '(' . join( ',', @sarr ) . ')';
+            }
+            elsif ( $fcn_param->Type eq 'Observable' )
+            {
+                # TODO: if there are arguments, then we should warn the user that we can't evaluate a local
+                # observables in a CVode function!!
+                $string = $fcn_param->getMatlabName();
+            }
+            else
+            {   die "Error in Expression->toMatlabString(): don't know how to process function expression of non-function type!";   }   
+        }
+        
+    }
+    else
+    {   
+        # handling some other operator (+,-,*,/)
+        # enclose in brackets (always. just to be safe)        
+        my @sarr = ( map {$_->toMatlabString($plist, $level+1, $expand)} @{$expr->Arglist} );
+        if ( @sarr > 1 )
+        {   # binary or higher order
+            $string = '(' . join( $type, @sarr ) . ')';
+        }
+        else
+        {   # unary operator
+            $string = '(' . $type . $sarr[0] . ')';
+        }
+    }
+
+    return $string;
+}
+
+
+###
+###
+###
+
+
+{
+    my %ophash =
+    (
+        '+'  => 'plus',
+        '-'  => 'minus',
+        '*'  => 'times',
+        '/'  => 'divide',
+        '**' => 'power',
+        '^'  => 'power',
+        '&&' => 'and',
+        '||' => 'or',
+        '<'  => 'lt',
+        '>'  => 'gt',
+        '<=' => 'leq',
+        '>=' => 'geq',
+        '!=' => 'neq',
+        '==' => 'equivalent'
+    );
+
+	my %fnhash =
+	(
+	  	'_pi'   => 'pi',
+  		'_e'    => 'exponentiale',
+		'exp'   => 'exp',
+  		'ln'    => 'ln',
+  		'log10' => 'log',
+#  		'log2'  => Requires special handling (see below)
+  		'abs'   => 'abs',
+#  		'rint'  => Requires special handling (see below)
+  		'sqrt'  => 'root',
+  		'cos'   => 'cos',
+  		'sin'   => 'sin',
+  		'tan'   => 'tan',
+  		'asin'  => 'arcsin',
+  		'acos'  => 'arccos',
+  		'atan'  => 'arctan',
+  		'sinh'  => 'sinh',
+  		'cosh'  => 'cosh',
+  		'tanh'  => 'tanh',
+  		'asinh' => 'arcsinh',
+  		'acosh' => 'arccosh',
+  		'atanh' => 'arctanh',
+#  		'if'    => Requires special handling (see below)
+  		'min'   => 'min',
+  		'max'   => 'max',
+  		'sum'   => 'sum',
+  		'avg'   => 'mean'		
+	);
+
+    sub toMathMLString
+    {
+        my $expr   = shift;
+        my $plist  = (@_) ? shift : '';
+        my $indent = (@_) ? shift : '';
+        my $level  = (@_) ? shift : 0;
+
+        if ( $level > $MAX_LEVEL ) { die "Max recursion depth $MAX_LEVEL exceeded."; }
+
+        my $string  = "";
+        my $indentp = $indent;
+        if ( $level == 0 )
+        {
+            $string .=
+            $indent . "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n";
+            $indentp .= "  ";
+        }
+
+        my $type = $expr->Type;
+        if ( $type eq 'NUM' )
+        {
+            $string .= sprintf "%s<cn> %s </cn>\n", $indentp, $expr->Arglist->[0];
+        }
+        elsif ( $type eq 'VAR' )
+        {
+            $string .= sprintf "%s<ci> %s </ci>\n", $indentp, $expr->Arglist->[0];
+        }
+        elsif ( $type eq 'FunctionCall' ) {
+			my @arglist  = @{ $expr->Arglist };
+			my $func_name = shift(@arglist); # Get function name
+			
+			# Built-in functions
+			if (isBuiltIn($func_name)){
+				
+				# Special handling for log2(x)
+				if ($func_name eq 'log2'){
+					$string .= $indentp . "<apply>\n"; 
+					$string .= $indentp . "  <log/><logbase><cn>2</cn></logbase>\n";
+					$string .= $arglist[0]->toMathMLString( $plist, $indentp . "  ", $level + 1 );
+					$string .= $indentp . "</apply>\n";
+				}
+				# Special handling for rint(x)
+				elsif ($func_name eq 'rint'){
+					$string .= $indentp . "<apply>\n"; 
+					$string .= $indentp . "  <floor/>\n";
+					$string .= $indentp . "  <apply>\n";
+					$string .= $indentp . "    <plus/>\n";
+					$string .= $indentp . "    <cn> 0.5 </cn>\n";
+					$string .= $arglist[0]->toMathMLString( $plist, $indentp . "    ", $level + 1 );
+					$string .= $indentp . "  </apply>\n";
+					$string .= $indentp . "</apply>\n";
+				}
+				# Special handling for if(x,y,z)
+				elsif ($func_name eq 'if'){
+					$string .= $indentp . "<piecewise>\n";
+				    $string .= $indentp . "  <piece>\n";
+					$string .= $arglist[1]->toMathMLString( $plist, $indentp . "    ", $level + 1 );
+					$string .= $arglist[0]->toMathMLString( $plist, $indentp . "    ", $level + 1 );
+				    $string .= $indentp . "  </piece>\n";
+					$string .= $indentp . "  <otherwise>\n";
+					$string .= $arglist[2]->toMathMLString( $plist, $indentp . "    ", $level + 1 );
+					$string .= $indentp . "  </otherwise>\n";
+					$string .= $indentp . "</piecewise>\n";
+				}
+				# All other built-ins
+				else{
+		            $string .= $indentp . "<apply>\n";
+		            my $indentpp = $indentp . "  ";
+		            $string .= sprintf "%s<%s/>\n", $indentpp, $fnhash{ $func_name }; #shift(@arglist);
+		            foreach my $e (@arglist)
+		            {
+		                $string .= $e->toMathMLString( $plist, $indentpp, $level + 1 );
+		            }
+		            $string .= $indentp . "</apply>\n";
+				}
+			}
+			# User-defined functions
+			else{
+				if (@arglist){ # There better not be any arguments
+					die "Expression::toMathMLString: User-defined functions should not have arguments.";
+				}
+				$string .= sprintf "%s<ci> %s </ci>\n", $indentp, $func_name;
+			}
+        }
+        else
+        {
+            $string .= $indentp . "<apply>\n";
+            my $indentpp = $indentp . "  ";
+            $string .= sprintf "%s<%s/>\n", $indentpp, $ophash{ $expr->Type };
+            foreach my $e ( @{ $expr->Arglist } )
+            {
+                $string .= $e->toMathMLString( $plist, $indentpp, $level + 1 );
+            }
+            $string .= $indentp . "</apply>\n";
+        }
+
+        if ( $level == 0 )
+        {
+            $string .= $indent . "</math>\n";
+        }
+        return $string;
+    }
+}
+
+# Convert an array of type EXPR OP EXPR OP ... to a single Expression.
+sub arrayToExpression
+{
+    my @earr = @_;
+
+    # list of optypes in order of precedence
+    my @operators = ('\*\*|\^', '[*/]', '[+-]', '[<>]|==|!=|~=|>=|<=', '&&|\|\|');
+    my $optype = shift @operators;
+    while ($optype)
+    {
+        my $i = 0;
+        # Consolidate EXPR OP EXPR into EXPR
+        while ($i < $#earr)
+        {
+            my $expr = $earr[$i];
+            if ( $expr->Type =~ /$optype/  and  !@{$expr->Arglist} )
+            {
+                if ( $i > 0 )
+                {
+                    $expr->Arglist->[0] = $earr[ $i - 1 ];
+                    $expr->Arglist->[1] = $earr[ $i + 1 ];
+                    splice @earr, $i - 1, 3, $expr;
+                    next;
+                }
+                else
+                {
+                    # Handle leading unary op, as in -a + b
+                    $expr->Arglist->[0] = $earr[ $i + 1 ];
+                    splice @earr, $i, 2, $expr;
+                    ++$i;
+                    next;
+                }
+            }
+            ++$i;
+        }
+        # Finished with current optype
+        $optype = shift @operators;
+    }
+
+    return $earr[0];
+}
+
+
+
+# extract a number expression from a BNG string.
+# NOTE: the method newNumOrVar is appropriate when
+#  the string ONLY contains a number or param name.  This
+#  method, however, is suitable for cases where the string 
+#  contains additional content.
+sub getNumber
+{
+    my $string = shift;
+
+    my $number = '';
+    # Decimal part
+    if ( $$string =~ s/^([+-]?\d+)([.]?\d*)// )
+    {
+        $number = $1;
+        if ($2 eq '.')
+        {   # pad number ending in decimal point
+            $number .= ".0";
+        }
+        else
+        {
+            $number .= $2;
+        }
+    }
+    elsif ( $$string =~ s/^([+-]?[.]\d+)// )
+    {
+        $number = $1;
+    }
+    else
+    {
+        return '';
+    }
+
+    # Exponent part
+    if ( $$string =~ s/^([DEFGdefg][+-]?\d+)// )
+    {
+        $number .= $1;
+    }
+    elsif ( $$string =~ /^[A-Za-z_]/ )
+    {
+        # String is non a number; restore value of string
+        $$string = $number . $$string;
+        return '';
+    }
+  
+    # create number expression and return
+    my $express = Expression->new();
+    $express->Type('NUM');
+    $express->Arglist( [$number] );
+    return $express;
+}
+
+
+
+# Returns name of VAR if expression is an existing VAR or
+# creates a new VAR with name derived from $basename and 
+# returns name of new VAR containing expression.
+sub getName
+{
+    my $expr      = shift @_;
+    my $plist     = shift @_;
+    my $basename  = @_ ? shift @_ : "k";
+    my $force_fcn = @_ ? shift @_ : 0; 
+
+    my $name;
+    if ( $expr->Type eq 'VAR'  and  !$force_fcn )
+    {
+        $name = $expr->Arglist->[0];
+    }
+    elsif ( $expr->Type eq "FunctionCall"
+             and @{$expr->Arglist}==1
+             and ref $expr->Arglist->[0] ne "Function" )
+    {   # function call without arguments, no need to create a new parameter
+        $name = $expr->Arglist->[0];
+    }
+    else 
+    {
+        # Find unused name
+        my $index = 1;
+        while (1)
+        {
+            my ($param, $err) = $plist->lookup($basename . $index);
+            last unless $param;
+            ++$index;
+        }
+        $name = $basename . $index;         
+        # set parameter in list (with type Function, if force)
+        $plist->set( $name, $expr, 0, ($force_fcn ? 'Function' : '') );
+    }
+
+    return $name;
+}
+
+
+
+# Return a hash of all the variable names referenced in the current expression.
+sub getVariables
+{
+    my $expr    = shift @_;
+    my $plist   = shift @_;
+    my $level   = @_ ? shift @_ : 0;
+    my $rethash = @_ ? shift @_ : {};
+
+    if ($level > $MAX_LEVEL) { die "Max recursion depth $MAX_LEVEL exceeded."; }
+
+    my $type = $expr->Type;
+    if ( $type eq 'NUM' )
+    {
+        # nothing to do
+    }
+    elsif ( $type eq 'VAR' )
+    {
+        my ($param, $err) = $plist->lookup( $expr->Arglist->[0] );
+        if ($err) { die $err };    # Shouldn't be an undefined variable name here
+        if ( defined $param->Type )
+        {   # add parameter name to type hash
+            $rethash->{$param->Type}->{$param->Name} = $param;
+        }
+        else
+        {   # this parameter has undefined type!
+            $rethash->{'UNDEF'}->{$param->Name} = $param;
+        }
+    }
+    elsif ( $type eq 'FunctionCall' )
+    {
+        if ( ref $expr->Arglist->[0] eq "Function" )
+        {   # anonymous function
+            # we have to descend into the function expression to see what it may reference
+            $expr->Arglist->[0]->Expr->getVariables($plist, $level+1, $rethash);
+        }
+        elsif ( exists $functions{$expr->Arglist->[0]} )
+        {   # built-in function..
+            # nothing to do
+        }
+        else
+        {   # named function
+            my ($param, $err) = $plist->lookup( $expr->Arglist->[0] );
+#			if (defined $param)
+            if (defined $param && defined $param->Type)
+            {   # add named function to rethash
+                $rethash->{$param->Type}->{$param->Name} = $param;
+            }
+        }
+
+        # handle the function arguments
+        foreach my $i ( 1 .. $#{$expr->Arglist} )
+        {
+            $expr->Arglist->[$i]->getVariables($plist, $level+1, $rethash);
+        }
+    }
+    else
+    {
+        foreach my $e ( @{$expr->Arglist} )
+        {
+            $e->getVariables($plist, $level + 1, $rethash);
+        }
+    }
+
+    return $rethash;
+}
+
+1;

data/bionetgen/Perl2/Function.pm

@@ -0,0 +1,543 @@
+package Function;
+
+# pragmas
+use strict;
+use warnings;
+
+# Perl Modules
+use Class::Struct;
+use FindBin;
+use lib $FindBin::Bin;
+
+# BNG Modules
+use ParamList;
+use Expression;
+
+
+
+struct Function =>
+{
+    Name => '$',
+    Args => '@',
+    Expr => 'Expression',
+    LocalHash => '%',
+};
+
+
+###
+###
+###
+
+
+# create a copy of this function.
+# 
+sub clone
+{
+    my $fcn   = shift @_;
+    my $plist = @_ ? shift @_ : undef;
+    my $level = @_ ? shift @_ : 0;
+    my $named = @_ ? shift @_ : 0;
+
+    # if the clone doesn't have a name, it will be anonymous
+    my $clone_name = $named ? $fcn->Name : undef;
+
+    my $err = '';
+    (my $clone_expr, $err) = $fcn->Expr->clone( $plist, $level+1 );
+    
+    my $clone = Function->new( Name=>$clone_name, Expr=>$clone_expr, Args=>[@{$fcn->Args}] );
+    return $clone, $err;
+}
+
+
+###
+###
+###
+
+sub evaluate
+{
+    my $fcn   = shift @_;
+    my $args  = @_ ? shift @_ : [];
+    my $plist = @_ ? shift @_ : undef;
+    my $level = @_ ? shift @_ : 0;
+
+    # create local parameterList
+    my $local_plist = $plist->getChildList();
+    
+    # set local variables equal to the arguments
+    my $ii=1;  # first arg is function name
+    while ( $ii < @$args )
+    {                
+        $local_plist->set( $fcn->Args->[$ii-1], $args->[$ii], 1, $args->[$ii]->Type );
+        ++$ii;
+    }
+       
+    # evaluate function expression
+    return $fcn->Expr->evaluate($local_plist, $level+1);
+}
+
+
+###
+###
+###
+
+
+
+# return a cloned function with local elements evaluated
+sub evaluate_local
+{
+    my $fcn   = shift;
+    my $args  = (@_) ? shift : [];
+    my $plist = (@_) ? shift : undef;
+    my $level = (@_) ? shift : 0;
+
+    my ($local_fcn, $err) = $fcn->clone( $plist, $level+1 );
+    
+    # create local parameterList
+    my $local_plist = $plist->getChildList();
+    # set local variables equal to the arguments
+    my $ii=1;  # first arg is function name
+    while ( $ii < @$args )
+    {
+        $local_plist->set( $fcn->Args->[$ii-1], $args->[$ii], 1 );
+        ++$ii;
+    }
+    
+    # locally evaluate function expression
+    my $expr = $local_fcn->Expr->evaluate_local($local_plist, $level+1);
+    $local_fcn->Expr($expr);
+
+    # check if local variables are unused
+    my $bad_args = [];
+    $ii=0;
+    while ( $ii < @{$local_fcn->Args} )
+    {
+        my ($dep, $err) = $expr->depends( $plist, $fcn->Args->[$ii] );
+        if ($dep)
+        {
+            # do nothing
+            ++$ii;
+        }
+        else
+        {
+            # remove argument
+            splice @{$local_fcn->Args}, $ii, 1;
+            push @$bad_args, $ii+1;
+        }
+    }    
+
+    return $local_fcn, $bad_args;
+}
+
+
+###
+###
+###
+
+
+# check for local observable dependency, return true if found
+sub checkLocalDependency
+{
+    my $fcn = shift;
+    my $plist = (@_) ? shift : undef;
+    my $level = (@_) ? shift : 0;
+
+    return  $fcn->Expr->checkLocalDependency( $plist, $level+1 );
+}
+
+
+###
+###
+###
+
+
+# check function equivalence
+sub equivalent
+{
+    my $fcn1 = shift;
+    my $fcn2 = shift;
+    my $plist = (@_) ? shift : undef;
+    
+    # make sure we have defined expressions!
+    return 0  unless ( defined $fcn1  and  ref $fcn1 eq 'Function' );
+    return 0  unless ( defined $fcn2  and  ref $fcn2 eq 'Function' );
+    
+    # check if this is the same function object!
+    return 0  if ( $fcn1 == $fcn2 );
+    
+    # don't compare names!!!
+    
+    # check for same number of arguments
+    return 0  unless ( @{$fcn1->Args} == @{$fcn2->Args} );
+    
+    # compare arguments
+    for ( my $i = 0;  $i < @{$fcn1->Args};  ++$i )
+    {
+        return 0 unless ( $fcn1->Args->[$i] eq $fcn2->Args->[$i] );
+    }
+    
+    # check Expr equivalence
+    return 0  unless ( Expression::equivalent($fcn1->Expr, $fcn2->Expr, $plist) );
+
+    # no differences found, return true!  
+    return 1;
+}
+
+
+###
+###
+###
+
+
+sub readString
+{
+    my $fun    = shift;
+    my $string = shift;
+    my $model  = shift;
+    my $err    = '';
+
+    my $plist = $model->ParamList;
+    
+    # Remove leading whitespace
+    $string =~ s/^\s*//;
+
+    # Check if first token is an index
+    $string =~ s/^\s*\d+\s+//; # Can't deprecate this because indices used in NET files
+
+    # Remove leading label, if exists
+    if ( $string =~ s/^\s*(\w+)\s*:\s+// )
+    {
+	    # Check label for leading number
+		my $label = $1;
+		if ($label =~ /^\d/) {  return "Syntax error (label begins with a number) at '$label'";  }
+    }
+    
+	# Check name for leading number
+	my $string_left = $string;
+	unless ( $string_left =~ s/^([A-Za-z_]\w*)// )
+	{ 
+		return "Syntax error (function name begins with a number) at '$string'";
+	}
+
+    # Next token is function Name
+    if ( $string =~ s/^\s*([A-Za-z0-9_]+)\s*// )
+    {
+        my $name = $1;
+        $fun->Name($name);
+    
+        # Make sure function name not the same as built-in functions --Leonard
+		if ( Expression::isBuiltIn($name) ){
+			return "Cannot use built-in function name '$name' as a user-defined function name.";
+		}
+    }
+    else
+    {
+        my ($name) = split( ' ', $string );
+        return ("Invalid function name '$name': may contain only alphanumeric characters and underscore");
+    }
+
+    # Process arguments to function (if any)
+    my @Args = ();
+    if ( $string =~ s/^[(]\s*// )
+    {
+        while (1)
+        {
+            if ( $string =~ s/^\s*([A-Za-z0-9_]+)\s*// )
+            {
+                my $arg = $1;
+                # Define argument as an allowed local variable in $plist
+                if ( $plist->set( $arg, '0', 1, 'Local' ) )
+                {
+                    my $name = $fun->Name;
+                    return ("Local argument $arg to Function $name matches previously defined variable");
+                }
+                #printf "Added argument %s to function %s\n", $arg, $fun->Name;
+                push @Args, $arg;
+            }
+            elsif ( $string =~ s/^[,]\s*// )
+            {
+                next;
+            }
+            elsif ( $string =~ s/^[)]\s*// )
+            {
+                last;
+            }
+            else
+            {
+                my $name= $fun->Name;
+                return ("Unrecognized argument at $string in declaration of function $name.");
+            }
+        }
+        $fun->Args( [@Args] );
+    }
+
+    # Remove '=' if present (but NOT '==')
+    $string=~ s/(?<!=)[=](?!=)\s*//;# use lookarounds to avoid matching '=='
+
+    # Read expression defining function.  Function arguments are "local" variables
+    my $expr = Expression->new();
+    $expr->setAllowForward(1);  # don't complain if expression refers to undefined parameters
+    if ( my $err = $expr->readString( \$string, $plist ) ) {  return ($err);  }
+    if ($string) {  return ("Syntax error at $string");  }
+    $expr->setAllowForward(0);
+
+    $fun->Expr($expr);
+
+    # Define parameter with name of the Function
+    if ( $plist->set( $fun->Name, $expr, 1, "Function", $fun ) )
+    {
+        my $name = $fun->Name;
+        return ("Function name $name matches previously defined variable");
+    }
+
+    $fun->unsetArgs($plist);
+
+    return '';
+}
+
+
+###
+###
+###
+
+
+sub toString
+{
+    my $fun   = shift @_;
+    my $plist = @_ ? shift @_ : undef;
+    my $include_equal = (@_) ? shift : 0;
+    # used for aligning columns nicely
+    my $max_length    = (@_) ? shift : 0;
+    
+    my $name = defined $fun->Name ? $fun->Name : "anon";
+    my $string = $name . '(' . join(',', @{$fun->Args}) . ')';
+    if ( $fun->Expr )
+    {
+        $string .= ($include_equal) ? ' = ' : ' ';
+        $string .= $fun->Expr->toString($plist);
+    }
+
+    if ($include_equal and $max_length)
+    {   # align equal signs
+        $string =~ /=/g;
+        my $n_spaces = $max_length - pos $string;
+        if ($n_spaces > 0)
+        {
+            my $spaces = ' ' x $n_spaces;
+            $string =~ s/=/$spaces=/;
+        }
+    }
+
+    return $string;
+}
+
+
+###
+###
+###
+
+
+sub toCVodeString
+# construct a call, declaration or definition for this function in CVode.
+{
+    my $fcn     = shift;                 # this function
+    my $plist   = (@_) ? shift : undef;  # reference to ParamList
+    my $arghash = (@_) ? shift : {};     # reference to argument hash
+   
+    # set default mode
+    unless ( exists $arghash->{fcn_mode} )
+    {    $arghash->{fcn_mode} = 'call';   }
+
+    # set default indent
+    unless ( exists $arghash->{indent} )
+    {    $arghash->{indent} = '';   }
+   
+    my $string = '';
+    if ( $arghash->{fcn_mode} eq 'call' )
+    {
+        # generate the function call
+        my @args = ( @{$fcn->Args}, 'expressions', 'observables' );
+        $string = $arghash->{indent} . $fcn->Name . '(' . join(',', @args) . ')';
+    }
+    elsif ( $arghash->{fcn_mode} eq 'declare' ) 
+    {
+        # generate a declaration string
+        my @args = ( (map { "double $_" } @{$fcn->Args}), 'N_Vector expressions', 'N_Vector observables' );
+        $string = $arghash->{indent} . "double " . $fcn->Name . " ( " . join(', ', @args) . " );\n";
+    }
+    elsif ( $arghash->{fcn_mode} eq 'define' )
+    {
+        # generate a definition string
+        my @args = ( (map { "double $_" } @{$fcn->Args}), 'N_Vector expressions', 'N_Vector observables' );
+
+        $string .= $arghash->{indent} . "/* user-defined function " . $fcn->Name . " */\n";
+        $string .= $arghash->{indent} . "double " . $fcn->Name . " ( " . join(', ', @args) . " )\n";
+        $string .= $arghash->{indent} . "{\n";
+        $string .= $arghash->{indent} . "    return " . $fcn->Expr->toCVodeString($plist) . ";\n"; 
+        $string .= $arghash->{indent} . "}\n";     
+    }
+    else
+    {    die "Error in Function->toCVodeString(): did not recognize fcn_mode argument!";   }
+
+    return $string;
+}
+
+
+
+###
+###
+###
+
+
+
+sub toMatlabString
+# construct a call, declaration or definition for this function in CVode.
+{
+    my $fcn     = shift @_;               # this function
+    my $plist   = @_ ? shift @_ : undef;  # reference to ParamList
+    my $arghash = @_ ? shift @_ : {};     # reference to argument hash
+   
+    # set default mode
+    unless ( exists $arghash->{fcn_mode} )
+    {    $arghash->{fcn_mode} = 'call';   }
+
+    # set default indent
+    unless ( exists $arghash->{indent} )
+    {    $arghash->{indent} = '';   }
+   
+    my $string = '';
+    if ( $arghash->{fcn_mode} eq 'call' )
+    {
+        # generate the function call
+        my @args = ( @{$fcn->Args}, 'expressions', 'observables' );
+        $string = $arghash->{indent} . $fcn->Name . '(' . join(',', @args) . ')';
+    }
+    elsif ( $arghash->{fcn_mode} eq 'declare' ) 
+    {
+        # generate a declaration string
+        # NOTHING TO DO: Matlab does not require function declarations
+        $string = '';
+    }
+    elsif ( $arghash->{fcn_mode} eq 'define' )
+    {
+        # generate a definition string
+        my @args = ( @{$fcn->Args}, 'expressions', 'observables' );
+        $string .= $arghash->{indent} . '% function ' . $fcn->Name . "\n";
+        $string .= $arghash->{indent} . 'function [val] = ' . $fcn->Name . '(' . join(', ', @args) . ")\n"
+                                      . '    val = ' . $fcn->Expr->toMatlabString($plist) . ";\n"
+                                      . "end\n";                      
+    }
+    else
+    {    die "Error in Function->toMatlabString(): did not recognize fcn_mode argument!";   }
+
+    return $string;
+}
+
+
+
+###
+###
+###
+
+
+
+sub setArgs
+{
+    my $fun= shift;
+    my $plist= shift;
+  
+    foreach my $arg ( @{$fun->Args} )
+    {
+        $plist->set( $arg, '0', 1, 'Local' ); 
+    }
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+sub unsetArgs
+{
+    my $fun   = shift;
+    my $plist = shift;
+  
+    # Delete ParamList entries for Local arguments
+    foreach my $arg ( @{$fun->Args} )
+    {
+        $plist->deleteLocal($arg);
+    }
+    return '';
+}
+
+
+
+###
+###
+###
+
+
+
+sub toXML
+{
+    my $fun    = shift;
+    my $plist  = (@_) ? shift : '';
+    my $indent = (@_) ? shift : '';
+
+    $fun->setArgs($plist);
+
+    my $indent2 = '  ' . $indent;
+    my $indent3 = '  ' . $indent2;
+    my $string  = $indent . "<Function";
+
+    # Attributes
+    # id
+    $string .= " id=\"".$fun->Name."\"";
+    $string .= ">\n";
+
+    # Arguments
+    if ( @{$fun->Args} )
+    {
+        $string.= $indent2 . "<ListOfArguments>\n";
+        foreach my $arg (@{$fun->Args})
+        {
+            $string .= $indent3 . "<Argument";
+            $string .= " id=" . "\"" . $arg . "\"";
+            $string .= "/>\n"
+        }
+        $string .= $indent2 . "</ListOfArguments>\n";
+    }
+
+    # References
+    $string.= $indent2."<ListOfReferences>\n";
+    my $vhash= $fun->Expr->getVariables($plist);
+  
+    foreach my $type (sort keys %{$vhash})
+    {
+        foreach my $var (sort keys %{$vhash->{$type}})
+        {
+            #print "$type $var\n";
+            $string .= $indent3 . ($vhash->{$type}->{$var})->toXMLReference('Reference', '', $plist);
+        }    
+    }
+    $string .= $indent2 . "</ListOfReferences>\n";
+    
+    $string .= $indent2 . "<Expression> ";
+    $string .= $fun->Expr->toXML($plist);
+    $string .= " </Expression>\n";
+
+    $string .= $indent."</Function>\n";
+
+    $fun->unsetArgs($plist);
+
+    return ($string);
+}
+
+
+
+
+
+1;