From 45f9e9b95044109e30e5271090d60ee49925144a Mon Sep 17 00:00:00 2001
From: Dilawar Singh <dilawars@ncbs.res.in>
Date: Wed, 21 Jun 2017 11:18:10 +0530
Subject: [PATCH] Squashed 'moose-core/' changes from b3b597f41..2ecab963b
2ecab963b Merge commit 'af3c29a4cff12f8572527cd79095d50d16c5da84'
ad3ec12ec Fixes to allow moose module to be installed and imported (#220)
0fb32dec5 All changes from previous repository. No new file is added here.
git-subtree-dir: moose-core
git-subtree-split: 2ecab963b249229174cfef1fafd282977a7920c3
---
.gitignore | 3 +-
.travis/travis_build_linux.sh | 10 +-
.travis/travis_prepare_linux.sh | 1 -
CMakeLists.txt | 32 +-
CheckCXXCompiler.cmake | 2 +-
basecode/SparseMatrix.h | 39 +-
basecode/global.cpp | 2 +-
basecode/global.h | 2 +-
biophysics/CaConc.cpp | 20 +-
biophysics/CaConcBase.cpp | 50 +-
biophysics/ChanBase.cpp | 26 +-
biophysics/Compartment.cpp | 26 +-
biophysics/CompartmentBase.cpp | 125 +--
biophysics/DifBuffer.cpp | 90 +-
biophysics/DifBufferBase.cpp | 44 +-
biophysics/HHChannelBase.cpp | 29 +-
biophysics/IntFire.cpp | 6 +-
biophysics/MgBlock.cpp | 11 +-
biophysics/RandSpike.cpp | 22 +-
biophysics/ReadSwc.cpp | 6 +-
builtins/Streamer.cpp | 16 +-
cmake_modules/FindGSL.cmake | 42 +-
cmake_modules/FindNumPy.cmake | 2 +-
device/PulseGen.cpp | 82 +-
examples/Ex.cpp | 2 +-
examples/Example.cpp | 2 +-
hsolve/HSolve.cpp | 1 -
kinetics/BufPool.cpp | 2 +-
kinetics/CplxEnzBase.cpp | 18 +-
kinetics/Enz.cpp | 7 +-
kinetics/EnzBase.cpp | 15 +-
kinetics/Pool.cpp | 94 +-
kinetics/Pool.h | 10 +-
kinetics/PoolBase.cpp | 91 +-
kinetics/PoolBase.h | 14 -
kinetics/Reac.cpp | 1 +
kinetics/ReadCspace.cpp | 28 +-
kinetics/ReadKkit.cpp | 200 ++--
kinetics/WriteKkit.cpp | 112 +--
kinetics/lookupVolumeFromMesh.cpp | 30 +-
ksolve/Gsolve.cpp | 1468 ++++++++++++++---------------
ksolve/GssaVoxelPools.cpp | 14 +-
ksolve/KinSparseMatrix.cpp | 15 +
ksolve/KinSparseMatrix.h | 4 +
ksolve/ZombieBufPool.cpp | 4 -
ksolve/ZombieBufPool.h | 1 -
ksolve/ZombiePool.cpp | 5 -
ksolve/ZombiePool.h | 1 -
msg/SparseMsg.cpp | 134 +--
msg/SparseMsg.h | 19 +-
pymoose/CMakeLists.txt | 24 +-
pymoose/PyRun.cpp | 77 +-
pymoose/melement.cpp | 288 +++---
pymoose/mfield.cpp | 3 -
pymoose/moosemodule.cpp | 359 +++----
pymoose/pymooseinit.cpp | 18 +-
pymoose/test_moosemodule.cpp | 66 +-
pymoose/vec.cpp | 110 ++-
python/moose/SBML/readSBML.py | 124 +--
python/moose/SBML/writeSBML.py | 229 +----
python/moose/__init__.py | 624 +-----------
python/moose/genesis/writeKkit.py | 37 +-
python/moose/merge/merge.py | 234 ++---
python/moose/moose.py | 507 ++++++++++
python/moose/plot_utils.py | 35 +-
python/rdesigneur/rdesigneur.py | 14 +-
python/rdesigneur/rmoogli.py | 4 +-
python/setup.py | 2 +-
scheduling/Clock.cpp | 82 +-
synapse/CMakeLists.txt | 15 +-
synapse/RollingMatrix.cpp | 14 -
synapse/SeqSynHandler.cpp | 225 +----
synapse/SeqSynHandler.h | 50 +-
synapse/testSynapse.cpp | 114 +--
tests/python/test_difshells.py | 1 +
75 files changed, 2747 insertions(+), 3489 deletions(-)
create mode 100644 python/moose/moose.py
diff --git a/.gitignore b/.gitignore
index c3622c54..6208aede 100644
--- a/.gitignore
+++ b/.gitignore
@@ -58,7 +58,7 @@ tags
*.i*86
*.x86_64
*.hex
-moose
+/moose
CMakeCache.txt
CMakeFiles
@@ -132,3 +132,4 @@ Session.vim
*~
*.clean
+/VERSION
diff --git a/.travis/travis_build_linux.sh b/.travis/travis_build_linux.sh
index 3a2ebbfa..b993e109 100755
--- a/.travis/travis_build_linux.sh
+++ b/.travis/travis_build_linux.sh
@@ -20,22 +20,20 @@
set -o nounset # Treat unset variables as an error
set -e
+PYTHON2="/usr/bin/python2"
+PYTHON3="/usr/bin/python3"
#MAKEFLAGS="-j 4"
-PYTHON2="/usr/bin/python2"
# Bug: `which python` returns /opt/bin/python* etc on travis. For which numpy
# many not be available. Therefore, it is neccessary to use fixed path for
# python executable.
-PYTHON3="/usr/bin/python3"
(
# Old makefile based flow.
$PYTHON2 -m compileall -q .
if type $PYTHON3 > /dev/null; then $PYTHON3 -m compileall -q . ; fi
- ## DEPRECATED: No longer testing make file.
-
- ## Traditional make.
- #make
+ # Traditional make.
+ make
## CMAKE based flow
mkdir -p _GSL_BUILD && cd _GSL_BUILD && \
cmake -DDEBUG=ON -DPYTHON_EXECUTABLE="$PYTHON2" ..
diff --git a/.travis/travis_prepare_linux.sh b/.travis/travis_prepare_linux.sh
index d016aa5b..ce068f9b 100755
--- a/.travis/travis_prepare_linux.sh
+++ b/.travis/travis_prepare_linux.sh
@@ -29,4 +29,3 @@ apt-get install -qq libboost-all-dev
apt-get install -qq libgsl0-dev
apt-get install -qq python-pip python3-pip
apt-get install -qq libgraphviz-dev
-pip3 install numpy
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4f3667a5..aa1c243d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,11 +11,9 @@ endif(COMMAND cmake_policy)
project(MOOSE)
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
include(CheckCXXCompiler.cmake)
include(CheckIncludeFileCXX)
include(FindPkgConfig)
-include(GetRevision)
# If from command line, version info is not passed, use the git to generate a
# version file. If GIT fails, use the previous known version.
@@ -29,14 +27,14 @@ if( (NOT MOOSE_VERSION) AND GIT_EXEC)
OUTPUT_VARIABLE MOOSE_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
)
-endif( )
-
-# Default to current date.
-if( (NOT MOOSE_VERSION) )
- NOW(TIMESTAMP)
- set(MOOSE_VERSION "nightly-${TIMESTAMP}" )
+ message(STATUS "+ Writing ${MOOSE_VERSION} to ${VERSION_FILE}" )
+ file(WRITE ${VERSION_FILE} ${MOOSE_VERSION})
+elseif( (NOT MOOSE_VERSION) AND (NOT GIT_EXEC) )
+ message(STATUS "+ Reading ${VERSION_FILE}" )
+ file(READ ${VERSION_FILE} GIT_VERSION_OUTPUT )
elseif(MOOSE_VERSION)
message(STATUS "+ Using user specified VERSION = ${MOOSE_VERSION}" )
+ file(WRITE ${VERSION_FILE} ${MOOSE_VERSION})
else()
message(FATAL_ERROR "Could not determine MOOSE_VERSION" )
endif( )
@@ -44,9 +42,6 @@ endif( )
add_definitions( -DMOOSE_VERSION="${MOOSE_VERSION}")
message( STATUS "MOOSE Version ${MOOSE_VERSION}" )
-# Write VERSION to a file VERSION so that setup.py can use it.
-file(WRITE ${VERSION_FILE} ${MOOSE_VERSION} )
-
# This snippet is from LLVM project.
# Sanity check our source directory to make sure that we are not trying to
# generate an in-tree build (unless on MSVC_IDE, where it is ok), and to make
@@ -103,6 +98,9 @@ option(WITH_MPI "Enable Openmpi support" OFF)
option(WITH_BOOST "Use boost library instead of GSL" OFF)
option(WITH_GSL "Use gsl-library. Alternative is WITH_BOOST" ON)
+################################# CMKAE MACROS #################################
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
############################ BUILD CONFIGURATION #################################
@@ -307,9 +305,15 @@ if(WITH_MPI)
endif()
endif(WITH_MPI)
-# Always use private version of muparser. We have some custom edits.
-add_subdirectory(external/muparser)
-list(APPEND MOOSE_LIBRARIES muparser)
+pkg_check_modules(MUPARSER muparser)
+if(MUPARSER_FOUND)
+ message(STATUS "Using system muparser ${MUPARSER_VERSION}")
+ list(APPEND SYSTEM_SHARED_LIBS ${MUPARSER_LIBRARIES})
+else()
+ message(STATUS "Using private muparser")
+ add_subdirectory(external/muparser)
+ list(APPEND MOOSE_LIBRARIES muparser)
+endif()
# Add subdirectroeis
add_subdirectory(basecode)
diff --git a/CheckCXXCompiler.cmake b/CheckCXXCompiler.cmake
index a87acde8..15a4d730 100644
--- a/CheckCXXCompiler.cmake
+++ b/CheckCXXCompiler.cmake
@@ -37,7 +37,7 @@ if(COMPILER_SUPPORTS_CXX11)
elseif(COMPILER_SUPPORTS_CXX0X)
message(STATUS "Your compiler supports c++0x features. Enabling it")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
- add_definitions( -DENABLE_CPP11 )
+ add_definitions( -DENABLE_CXX11 )
add_definitions( -DBOOST_NO_CXX11_SCOPED_ENUMS -DBOOST_NO_SCOPED_ENUMS )
if(APPLE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++" )
diff --git a/basecode/SparseMatrix.h b/basecode/SparseMatrix.h
index ecbc71ea..88d2681c 100644
--- a/basecode/SparseMatrix.h
+++ b/basecode/SparseMatrix.h
@@ -423,19 +423,6 @@ public:
colIndexArg.begin(), colIndexArg.end() );
rowStart_[rowNum + 1] = N_.size();
}
- /// Here we expose the sparse matrix for MOOSE use.
- const vector< T >& matrixEntry() const
- {
- return N_;
- }
- const vector< unsigned int >& colIndex() const
- {
- return colIndex_;
- }
- const vector< unsigned int >& rowStart() const
- {
- return rowStart_;
- }
//////////////////////////////////////////////////////////////////
// Operations on entire matrix.
//////////////////////////////////////////////////////////////////
@@ -582,7 +569,7 @@ public:
void tripletFill( const vector< unsigned int >& row,
const vector< unsigned int >& col,
- const vector< T >& z, bool retainSize = false )
+ const vector< T >& z )
{
unsigned int len = row.size();
if ( len > col.size() ) len = col.size();
@@ -591,20 +578,16 @@ public:
for ( unsigned int i = 0; i < len; ++i )
trip[i]= Triplet< T >(z[i], row[i], col[i] );
sort( trip.begin(), trip.end(), Triplet< T >::cmp );
- unsigned int nr = nrows_;
- unsigned int nc = ncolumns_;
- if ( !retainSize ) {
- nr = trip.back().b_ + 1;
- nc = 0;
- for ( typename vector< Triplet< T > >::iterator i =
- trip.begin(); i != trip.end(); ++i )
- {
- if ( nc < i->c_ )
- nc = i->c_;
- }
- nc++;
- }
- setSize( nr, nc );
+ unsigned int nr = trip.back().b_ + 1;
+ unsigned int nc = 0;
+ for ( typename vector< Triplet< T > >::iterator i =
+ trip.begin(); i != trip.end(); ++i )
+ {
+ if ( nc < i->c_ )
+ nc = i->c_;
+ }
+ nc++;
+ setSize( nr, nc );
vector< unsigned int > colIndex( nc );
vector< T > entry( nc );
diff --git a/basecode/global.cpp b/basecode/global.cpp
index b54fc979..ec5a523e 100644
--- a/basecode/global.cpp
+++ b/basecode/global.cpp
@@ -87,7 +87,7 @@ namespace moose {
*
* @param x
*/
- void mtseed( int x )
+ void mtseed( unsigned int x )
{
moose::__rng_seed__ = x;
moose::rng.setSeed( x );
diff --git a/basecode/global.h b/basecode/global.h
index 40b2dba5..9b06b282 100644
--- a/basecode/global.h
+++ b/basecode/global.h
@@ -109,7 +109,7 @@ namespace moose
*
* @param seed
*/
- void mtseed( int seed );
+ void mtseed( unsigned int seed );
/**
* @brief Generate a random double between 0 and 1
diff --git a/biophysics/CaConc.cpp b/biophysics/CaConc.cpp
index 2ecf5034..40f3bf2b 100644
--- a/biophysics/CaConc.cpp
+++ b/biophysics/CaConc.cpp
@@ -17,13 +17,13 @@ const Cinfo* CaConc::initCinfo()
{
static string doc[] =
{
- "Name", "CaConc",
- "Author", "Upinder S. Bhalla, 2014, NCBS",
- "Description", "CaConc: Calcium concentration pool. Takes current from a "
- "channel and keeps track of calcium buildup and depletion by a "
- "single exponential process. ",
+ "Name", "CaConc \n",
+ "Author", "Upinder S. Bhalla, 2014, NCBS \n",
+ "Description", "CaConc: Calcium concentration pool. Takes current from a \n"
+ "channel and keeps track of calcium buildup and depletion by a \n"
+ "single exponential process. \n",
};
-
+
static Dinfo< CaConc > dinfo;
static Cinfo CaConcCinfo(
@@ -177,16 +177,16 @@ void testCaConc()
cc.setB( 5.2e-6 / 1e-15 );
// Faraday constant = 96485.3415 s A / mol
// Use a 1 pA input current. This should give (0.5e-12/F) moles/sec
- // influx, because Ca has valence of 2.
+ // influx, because Ca has valence of 2.
// So we get 5.2e-18 moles/sec coming in.
// Our volume is 1e-15 m^3
// So our buildup should be at 5.2e-3 moles/m^3/sec = 5.2 uM/sec
double curr = 1e-12;
// This will settle when efflux = influx
// dC/dt = B*Ik - C/tau = 0.
- // so Ca = CaBasal + tau * B * Ik =
+ // so Ca = CaBasal + tau * B * Ik =
// 0.0001 + 0.1 * 5.2e-6 * 1e3 = 0.000626
-
+
ProcInfo p;
p.dt = 0.001;
p.currTime = 0.0;
@@ -214,4 +214,4 @@ void testCaConc()
cout << "." << flush;
*/
}
-#endif
+#endif
diff --git a/biophysics/CaConcBase.cpp b/biophysics/CaConcBase.cpp
index c484b248..f569cbae 100644
--- a/biophysics/CaConcBase.cpp
+++ b/biophysics/CaConcBase.cpp
@@ -17,13 +17,13 @@
///////////////////////////////////////////////////////
/*
* This Finfo is used to send out Ca concentration to channels.
- *
+ *
* It is exposed here so that HSolve can also use it to send out
* Ca concentration to the recipients.
*/
// Static function.
SrcFinfo1< double >* CaConcBase::concOut() {
- static SrcFinfo1< double > concOut( "concOut",
+ static SrcFinfo1< double > concOut( "concOut",
"Concentration of Ca in pool" );
return &concOut;
}
@@ -33,10 +33,10 @@ const Cinfo* CaConcBase::initCinfo()
///////////////////////////////////////////////////////
// Shared message definitions
///////////////////////////////////////////////////////
- static DestFinfo process( "process",
+ static DestFinfo process( "process",
"Handles process call",
new ProcOpFunc< CaConcBase >( &CaConcBase::process ) );
- static DestFinfo reinit( "reinit",
+ static DestFinfo reinit( "reinit",
"Handles reinit call",
new ProcOpFunc< CaConcBase >( &CaConcBase::reinit ) );
@@ -45,10 +45,10 @@ const Cinfo* CaConcBase::initCinfo()
&process, &reinit
};
- static SharedFinfo proc( "proc",
+ static SharedFinfo proc( "proc",
"Shared message to receive Process message from scheduler",
processShared, sizeof( processShared ) / sizeof( Finfo* ) );
-
+
///////////////////////////////////////////////////////
// Field definitions
///////////////////////////////////////////////////////
@@ -82,10 +82,9 @@ const Cinfo* CaConcBase::initCinfo()
&CaConcBase::getB
);
static ElementValueFinfo< CaConcBase, double > thick( "thick",
- "Thickness of Ca shell, assumed cylindrical. Legal range is "
- "between zero and the radius. If outside this range it is "
- "taken as the radius. Default zero, ie, the shell is the entire "
- "thickness of the cylinder",
+ "Thickness of Ca shell, assumed cylindrical. Legal range is between 0 \n"
+ "and the radius. If outside this range it is taken as the radius. \n"
+ " Default zero, ie, the shell is the entire thickness of the cylinder \n",
&CaConcBase::setThickness,
&CaConcBase::getThickness
);
@@ -100,7 +99,8 @@ const Cinfo* CaConcBase::initCinfo()
&CaConcBase::getDiameter
);
static ElementValueFinfo< CaConcBase, double > ceiling( "ceiling",
- "Ceiling value for Ca concentration. If Ca > ceiling, Ca = ceiling. If ceiling <= 0.0, there is no upper limit on Ca concentration value.",
+ "Ceiling value for Ca concentration. If Ca > ceiling, Ca = ceiling. \n"
+ "If ceiling <= 0.0, there is no upper limit on Ca concentration value.",
&CaConcBase::setCeiling,
&CaConcBase::getCeiling
);
@@ -114,34 +114,34 @@ const Cinfo* CaConcBase::initCinfo()
// MsgDest definitions
///////////////////////////////////////////////////////
- static DestFinfo current( "current",
+ static DestFinfo current( "current",
"Calcium Ion current, due to be converted to conc.",
new EpFunc1< CaConcBase, double >( &CaConcBase::current )
);
- static DestFinfo currentFraction( "currentFraction",
+ static DestFinfo currentFraction( "currentFraction",
"Fraction of total Ion current, that is carried by Ca2+.",
new EpFunc2< CaConcBase, double, double >( &CaConcBase::currentFraction )
);
- static DestFinfo increase( "increase",
+ static DestFinfo increase( "increase",
"Any input current that increases the concentration.",
new EpFunc1< CaConcBase, double >( &CaConcBase::increase )
);
- static DestFinfo decrease( "decrease",
+ static DestFinfo decrease( "decrease",
"Any input current that decreases the concentration.",
new EpFunc1< CaConcBase, double >( &CaConcBase::decrease )
);
- static DestFinfo basal( "basal",
+ static DestFinfo basal( "basal",
"Synonym for assignment of basal conc.",
new EpFunc1< CaConcBase, double >( &CaConcBase::setCaBasal )
);
static Finfo* CaConcBaseFinfos[] =
{
- &proc, // Shared
+ &proc, // Shared
concOut(), // Src
&Ca, // Value
&CaBasal, // Value
@@ -167,13 +167,12 @@ const Cinfo* CaConcBase::initCinfo()
{
"Name", "CaConcBase",
"Author", "Upinder S. Bhalla, 2014, NCBS",
- "Description",
- "CaConcBase: Base class for Calcium concentration "
- "pool. Takes current from a channel and keeps track of "
- "calcium buildup and depletion by a "
- "single exponential process. ",
+ "Description",
+ "CaConcBase: Base class for Calcium concentration pool. \n"
+ "Takes current from a channel and keeps track of calcium buildup and \n"
+ " depletion by a single exponential process. ",
};
-
+
static ZeroSizeDinfo< int > dinfo;
static Cinfo CaConcBaseCinfo(
@@ -341,7 +340,7 @@ void CaConcBase::vSetSolver( const Eref& e, Id hsolve )
{;}
// static func
-void CaConcBase::zombify( Element* orig, const Cinfo* zClass,
+void CaConcBase::zombify( Element* orig, const Cinfo* zClass,
Id hsolve )
{
if ( orig->cinfo() == zClass )
@@ -355,7 +354,7 @@ void CaConcBase::zombify( Element* orig, const Cinfo* zClass,
unsigned int j = 0;
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const CaConcBase* cb =
+ const CaConcBase* cb =
reinterpret_cast< const CaConcBase* >( er.data() );
data[j + 0] = cb->getCa( er );
data[j + 1] = cb->getCaBasal( er );
@@ -386,4 +385,3 @@ void CaConcBase::zombify( Element* orig, const Cinfo* zClass,
j += 9; //was 7?
}
}
-
diff --git a/biophysics/ChanBase.cpp b/biophysics/ChanBase.cpp
index c3826c50..b483dbcb 100644
--- a/biophysics/ChanBase.cpp
+++ b/biophysics/ChanBase.cpp
@@ -13,21 +13,21 @@
SrcFinfo1< double >* ChanBase::permeability()
{
- static SrcFinfo1< double > permeability( "permeabilityOut",
+ static SrcFinfo1< double > permeability( "permeabilityOut",
"Conductance term going out to GHK object" );
return &permeability;
}
SrcFinfo2< double, double >* ChanBase::channelOut()
{
- static SrcFinfo2< double, double > channelOut( "channelOut",
+ static SrcFinfo2< double, double > channelOut( "channelOut",
"Sends channel variables Gk and Ek to compartment" );
return &channelOut;
}
SrcFinfo1< double >* ChanBase::IkOut()
{
- static SrcFinfo1< double > IkOut( "IkOut",
+ static SrcFinfo1< double > IkOut( "IkOut",
"Channel current. This message typically goes to concen"
"objects that keep track of ion concentration." );
return &IkOut;
@@ -38,10 +38,10 @@ const Cinfo* ChanBase::initCinfo()
/////////////////////////////////////////////////////////////////////
// Shared messages
/////////////////////////////////////////////////////////////////////
- static DestFinfo process( "process",
+ static DestFinfo process( "process",
"Handles process call",
new ProcOpFunc< ChanBase >( &ChanBase::process ) );
- static DestFinfo reinit( "reinit",
+ static DestFinfo reinit( "reinit",
"Handles reinit call",
new ProcOpFunc< ChanBase >( &ChanBase::reinit ) );
@@ -50,13 +50,13 @@ const Cinfo* ChanBase::initCinfo()
&process, &reinit
};
- static SharedFinfo proc( "proc",
+ static SharedFinfo proc( "proc",
"Shared message to receive Process message from scheduler",
processShared, sizeof( processShared ) / sizeof( Finfo* ) );
/////////////////////////////////////////////////////////////////////
/// ChannelOut SrcFinfo defined above.
- static DestFinfo Vm( "Vm",
+ static DestFinfo Vm( "Vm",
"Handles Vm message coming in from compartment",
new OpFunc1< ChanBase, double >( &ChanBase::handleVm ) );
@@ -64,7 +64,7 @@ const Cinfo* ChanBase::initCinfo()
{
channelOut(), &Vm
};
- static SharedFinfo channel( "channel",
+ static SharedFinfo channel( "channel",
"This is a shared message to couple channel to compartment. "
"The first entry is a MsgSrc to send Gk and Ek to the compartment "
"The second entry is a MsgDest for Vm from the compartment.",
@@ -79,7 +79,7 @@ const Cinfo* ChanBase::initCinfo()
{
&Vm, permeability()
};
- static SharedFinfo ghk( "ghk",
+ static SharedFinfo ghk( "ghk",
"Message to Goldman-Hodgkin-Katz object",
ghkShared, sizeof( ghkShared ) / sizeof( Finfo* ) );
@@ -104,7 +104,7 @@ const Cinfo* ChanBase::initCinfo()
&ChanBase::setModulation,
&ChanBase::getModulation
);
- static ElementValueFinfo< ChanBase, double > Ek( "Ek",
+ static ElementValueFinfo< ChanBase, double > Ek( "Ek",
"Reversal potential of channel",
&ChanBase::setEk,
&ChanBase::getEk
@@ -127,7 +127,7 @@ const Cinfo* ChanBase::initCinfo()
///////////////////////////////////////////////////////
// MsgDest definitions
///////////////////////////////////////////////////////
-
+
///////////////////////////////////////////////////////
static Finfo* ChanBaseFinfos[] =
{
@@ -141,7 +141,7 @@ const Cinfo* ChanBase::initCinfo()
IkOut(), // Src
&proc, // Shared
};
-
+
static string doc[] =
{
"Name", "ChanBase",
@@ -151,7 +151,7 @@ const Cinfo* ChanBase::initCinfo()
};
static ZeroSizeDinfo< int > dinfo;
-
+
static Cinfo ChanBaseCinfo(
"ChanBase",
Neutral::initCinfo(),
diff --git a/biophysics/Compartment.cpp b/biophysics/Compartment.cpp
index 569d6a50..dda3ee47 100644
--- a/biophysics/Compartment.cpp
+++ b/biophysics/Compartment.cpp
@@ -54,18 +54,18 @@ static const Cinfo* compartmentCinfo = Compartment::initCinfo();
/*
-const SrcFinfo1< double >* VmOut =
- dynamic_cast< const SrcFinfo1< double >* >(
- compartmentCinfo->findFinfo( "VmOut" ) );
+const SrcFinfo1< double >* VmOut =
+ dynamic_cast< const SrcFinfo1< double >* >(
+ compartmentCinfo->findFinfo( "VmOut" ) );
*/
-const SrcFinfo1< double >* axialOut =
+const SrcFinfo1< double >* axialOut =
dynamic_cast< const SrcFinfo1< double >* > (
- compartmentCinfo->findFinfo( "axialOut" ) );
+ compartmentCinfo->findFinfo( "axialOut" ) );
-const SrcFinfo2< double, double >* raxialOut =
+const SrcFinfo2< double, double >* raxialOut =
dynamic_cast< const SrcFinfo2< double, double >* > (
- compartmentCinfo->findFinfo( "raxialOut" ) );
+ compartmentCinfo->findFinfo( "raxialOut" ) );
//////////////////////////////////////////////////////////////////
// Here we put the Compartment class functions.
@@ -181,7 +181,7 @@ double Compartment::vGetInitVm( const Eref& e ) const
void Compartment::vProcess( const Eref& e, ProcPtr p )
{
//cout << "Compartment " << e.id().path() << ":: process: A = " << A_ << ", B = " << B_ << endl;
- A_ += inject_ + sumInject_ + Em_ * invRm_;
+ A_ += inject_ + sumInject_ + Em_ * invRm_;
if ( B_ > EPSILON ) {
double x = exp( -B_ * p->dt / Cm_ );
Vm_ = Vm_ * x + ( A_ / B_ ) * ( 1.0 - x );
@@ -208,7 +208,7 @@ void Compartment::vReinit( const Eref& e, ProcPtr p )
lastIm_ = 0.0;
sumInject_ = 0.0;
dt_ = p->dt;
-
+
// Send out the resting Vm to channels, SpikeGens, etc.
VmOut()->send( e, Vm_ );
}
@@ -293,7 +293,7 @@ void testCompartment()
double Vm = 0.0;
double tau = 1.0;
double Vmax = 1.0;
- for ( p.currTime = 0.0; p.currTime < 2.0; p.currTime += p.dt )
+ for ( p.currTime = 0.0; p.currTime < 2.0; p.currTime += p.dt )
{
Vm = c->getVm( compter );
double x = Vmax - Vmax * exp( -p.currTime / tau );
@@ -336,7 +336,7 @@ void testCompartmentProcess()
assert( ret );
Field< double >::setRepeat( cid, "inject", 0 );
// Only apply current injection in first compartment
- Field< double >::set( ObjId( cid, 0 ), "inject", 1.0 );
+ Field< double >::set( ObjId( cid, 0 ), "inject", 1.0 );
Field< double >::setRepeat( cid, "Rm", Rm );
Field< double >::setRepeat( cid, "Ra", Ra );
Field< double >::setRepeat( cid, "Cm", Cm );
@@ -363,7 +363,7 @@ void testCompartmentProcess()
shell->doSetClock( 0, dt );
shell->doSetClock( 1, dt );
// Ensure that the inter_compt msgs go between nodes once every dt.
- shell->doSetClock( 9, dt );
+ shell->doSetClock( 9, dt );
shell->doUseClock( "/compt", "init", 0 );
shell->doUseClock( "/compt", "process", 1 );
@@ -374,7 +374,7 @@ void testCompartmentProcess()
double Vmax = Field< double >::get( ObjId( cid, 0 ), "Vm" );
double delta = 0.0;
- // We measure only the first 50 compartments as later we
+ // We measure only the first 50 compartments as later we
// run into end effects because it is not an infinite cable
for ( unsigned int i = 0; i < size; i++ ) {
double Vm = Field< double >::get( ObjId( cid, i ), "Vm" );
diff --git a/biophysics/CompartmentBase.cpp b/biophysics/CompartmentBase.cpp
index 50297e3b..94ac948d 100644
--- a/biophysics/CompartmentBase.cpp
+++ b/biophysics/CompartmentBase.cpp
@@ -19,13 +19,13 @@ using namespace moose;
/*
* This Finfo is used to send out Vm to channels, spikegens, etc.
- *
+ *
* It is exposed here so that HSolve can also use it to send out
* the Vm to the recipients.
*/
// Static function.
SrcFinfo1< double >* CompartmentBase::VmOut() {
- static SrcFinfo1< double > VmOut( "VmOut",
+ static SrcFinfo1< double > VmOut( "VmOut",
"Sends out Vm value of compartment on each timestep" );
return &VmOut;
}
@@ -35,7 +35,7 @@ SrcFinfo1< double >* CompartmentBase::VmOut() {
// are still only Vm.
static SrcFinfo1< double >* axialOut() {
- static SrcFinfo1< double > axialOut( "axialOut",
+ static SrcFinfo1< double > axialOut( "axialOut",
"Sends out Vm value of compartment to adjacent compartments,"
"on each timestep" );
return &axialOut;
@@ -43,7 +43,7 @@ static SrcFinfo1< double >* axialOut() {
static SrcFinfo2< double, double >* raxialOut()
{
- static SrcFinfo2< double, double > raxialOut( "raxialOut",
+ static SrcFinfo2< double, double > raxialOut( "raxialOut",
"Sends out Raxial information on each timestep, "
"fields are Ra and Vm" );
return &raxialOut;
@@ -62,38 +62,38 @@ const Cinfo* CompartmentBase::initCinfo()
///////////////////////////////////////////////////////////////////
// Shared messages
///////////////////////////////////////////////////////////////////
- static DestFinfo process( "process",
+ static DestFinfo process( "process",
"Handles 'process' call",
new ProcOpFunc< CompartmentBase >( &CompartmentBase::process ) );
- static DestFinfo reinit( "reinit",
+ static DestFinfo reinit( "reinit",
"Handles 'reinit' call",
new ProcOpFunc< CompartmentBase >( &CompartmentBase::reinit ) );
-
+
static Finfo* processShared[] =
{
&process, &reinit
};
static SharedFinfo proc( "proc",
- "This is a shared message to receive Process messages "
- "from the scheduler objects. The Process should be called "
- "_second_ in each clock tick, after the Init message."
+ "This is a shared message to receive Process messages from the scheduler"
+ "objects. The Process should be called _second_ in each clock tick, after the Init message."
"The first entry in the shared msg is a MsgDest "
"for the Process operation. It has a single argument, "
"ProcInfo, which holds lots of information about current "
"time, thread, dt and so on. The second entry is a MsgDest "
- "for the Reinit operation. It also uses ProcInfo. ",
+ "for the Reinit operation. It also uses ProcInfo. "
+ "- Handles 'reinit' and 'process' calls.",
processShared, sizeof( processShared ) / sizeof( Finfo* )
);
///////////////////////////////////////////////////////////////////
-
- static DestFinfo initProc( "initProc",
+
+ static DestFinfo initProc( "initProc",
"Handles Process call for the 'init' phase of the CompartmentBase "
"calculations. These occur as a separate Tick cycle from the "
"regular proc cycle, and should be called before the proc msg.",
new ProcOpFunc< CompartmentBase >( &CompartmentBase::initProc ) );
- static DestFinfo initReinit( "initReinit",
+ static DestFinfo initReinit( "initReinit",
"Handles Reinit call for the 'init' phase of the CompartmentBase "
"calculations.",
new ProcOpFunc< CompartmentBase >( &CompartmentBase::initReinit ) );
@@ -102,7 +102,7 @@ const Cinfo* CompartmentBase::initCinfo()
&initProc, &initReinit
};
- static SharedFinfo init( "init",
+ static SharedFinfo init( "init",
"This is a shared message to receive Init messages from "
"the scheduler objects. Its job is to separate the "
"compartmental calculations from the message passing. "
@@ -113,13 +113,14 @@ const Cinfo* CompartmentBase::initCinfo()
"single argument, ProcInfo, which holds lots of "
"information about current time, thread, dt and so on. "
"The second entry is a dummy MsgDest for the Reinit "
- "operation. It also uses ProcInfo. ",
+ "operation. It also uses ProcInfo. "
+ "- Handles 'initProc' and 'initReinit' calls.",
initShared, sizeof( initShared ) / sizeof( Finfo* )
);
///////////////////////////////////////////////////////////////////
- static DestFinfo handleChannel( "handleChannel",
+ static DestFinfo handleChannel( "handleChannel",
"Handles conductance and Reversal potential arguments from Channel",
new EpFunc2< CompartmentBase, double, double >( &CompartmentBase::handleChannel ) );
// VmOut is declared above as it needs to be in scope for later funcs.
@@ -128,18 +129,19 @@ const Cinfo* CompartmentBase::initCinfo()
{
&handleChannel, CompartmentBase::VmOut()
};
- static SharedFinfo channel( "channel",
+ static SharedFinfo channel( "channel",
"This is a shared message from a compartment to channels. "
"The first entry is a MsgDest for the info coming from "
"the channel. It expects Gk and Ek from the channel "
- "as args. The second entry is a MsgSrc sending Vm ",
+ "as args. The second entry is a MsgSrc sending Vm "
+ "- Handles 'handleChannel' and 'VmOut' calls.",
channelShared, sizeof( channelShared ) / sizeof( Finfo* )
);
///////////////////////////////////////////////////////////////////
// axialOut declared above as it is needed in file scope
- static DestFinfo handleRaxial( "handleRaxial",
+ static DestFinfo handleRaxial( "handleRaxial",
"Handles Raxial info: arguments are Ra and Vm.",
- new OpFunc2< CompartmentBase, double, double >(
+ new OpFunc2< CompartmentBase, double, double >(
&CompartmentBase::handleRaxial )
);
@@ -147,7 +149,7 @@ const Cinfo* CompartmentBase::initCinfo()
{
axialOut(), &handleRaxial
};
- static SharedFinfo axial( "axial",
+ static SharedFinfo axial( "axial",
"This is a shared message between asymmetric compartments. "
"axial messages (this kind) connect up to raxial "
"messages (defined below). The soma should use raxial "
@@ -161,12 +163,13 @@ const Cinfo* CompartmentBase::initCinfo()
"of the target compartment. The second entry is a MsgDest "
"for the info coming from the other compt. It expects "
"Ra and Vm from the other compt as args. Note that the "
- "message is named after the source type. ",
+ "message is named after the source type. "
+ "- Handles 'axialOut' and 'handleRaxial' calls.",
axialShared, sizeof( axialShared ) / sizeof( Finfo* )
);
///////////////////////////////////////////////////////////////////
- static DestFinfo handleAxial( "handleAxial",
+ static DestFinfo handleAxial( "handleAxial",
"Handles Axial information. Argument is just Vm.",
new OpFunc1< CompartmentBase, double >( &CompartmentBase::handleAxial ) );
// rxialOut declared above as it is needed in file scope
@@ -174,78 +177,78 @@ const Cinfo* CompartmentBase::initCinfo()
{
&handleAxial, raxialOut()
};
- static SharedFinfo raxial( "raxial",
- "This is a raxial shared message between asymmetric "
- "compartments. The first entry is a MsgDest for the info "
- "coming from the other compt. It expects Vm from the "
- "other compt as an arg. The second is a MsgSrc sending "
- "Ra and Vm to the raxialFunc of the target compartment. ",
+ static SharedFinfo raxial( "raxial",
+ "This is a raxial shared message between asymmetric compartments. The \n"
+ "first entry is a MsgDest for the info coming from the other compt. It \n"
+ "expects Vm from the other compt as an arg. The second is a MsgSrc sending \n"
+ "Ra and Vm to the raxialFunc of the target compartment. \n"
+ "- Handles 'handleAxial' and 'raxialOut' calls.",
raxialShared, sizeof( raxialShared ) / sizeof( Finfo* )
);
///////////////////////////////////////////////////////////////////
// Value Finfos.
///////////////////////////////////////////////////////////////////
- static ElementValueFinfo< CompartmentBase, double > Vm( "Vm",
+ static ElementValueFinfo< CompartmentBase, double > Vm( "Vm",
"membrane potential",
&CompartmentBase::setVm,
&CompartmentBase::getVm
);
- static ElementValueFinfo< CompartmentBase, double > Cm( "Cm",
+ static ElementValueFinfo< CompartmentBase, double > Cm( "Cm",
"Membrane capacitance",
&CompartmentBase::setCm,
&CompartmentBase::getCm
);
- static ElementValueFinfo< CompartmentBase, double > Em( "Em",
+ static ElementValueFinfo< CompartmentBase, double > Em( "Em",
"Resting membrane potential",
&CompartmentBase::setEm,
&CompartmentBase::getEm
);
- static ReadOnlyElementValueFinfo< CompartmentBase, double > Im( "Im",
+ static ReadOnlyElementValueFinfo< CompartmentBase, double > Im( "Im",
"Current going through membrane",
&CompartmentBase::getIm
);
- static ElementValueFinfo< CompartmentBase, double > inject( "inject",
+ static ElementValueFinfo< CompartmentBase, double > inject( "inject",
"Current injection to deliver into compartment",
&CompartmentBase::setInject,
&CompartmentBase::getInject
);
- static ElementValueFinfo< CompartmentBase, double > initVm( "initVm",
+ static ElementValueFinfo< CompartmentBase, double > initVm( "initVm",
"Initial value for membrane potential",
&CompartmentBase::setInitVm,
&CompartmentBase::getInitVm
);
- static ElementValueFinfo< CompartmentBase, double > Rm( "Rm",
+ static ElementValueFinfo< CompartmentBase, double > Rm( "Rm",
"Membrane resistance",
&CompartmentBase::setRm,
&CompartmentBase::getRm
);
- static ElementValueFinfo< CompartmentBase, double > Ra( "Ra",
+ static ElementValueFinfo< CompartmentBase, double > Ra( "Ra",
"Axial resistance of compartment",
&CompartmentBase::setRa,
&CompartmentBase::getRa
);
- static ValueFinfo< CompartmentBase, double > diameter( "diameter",
+ static ValueFinfo< CompartmentBase, double > diameter( "diameter",
"Diameter of compartment",
&CompartmentBase::setDiameter,
&CompartmentBase::getDiameter
);
- static ValueFinfo< CompartmentBase, double > length( "length",
+ static ValueFinfo< CompartmentBase, double > length( "length",
"Length of compartment",
&CompartmentBase::setLength,
&CompartmentBase::getLength
);
- static ValueFinfo< CompartmentBase, double > x0( "x0",
+ static ValueFinfo< CompartmentBase, double > x0( "x0",
"X coordinate of start of compartment",
&CompartmentBase::setX0,
&CompartmentBase::getX0
);
- static ValueFinfo< CompartmentBase, double > y0( "y0",
+ static ValueFinfo< CompartmentBase, double > y0( "y0",
"Y coordinate of start of compartment",
&CompartmentBase::setY0,
&CompartmentBase::getY0
);
- static ValueFinfo< CompartmentBase, double > z0( "z0",
+ static ValueFinfo< CompartmentBase, double > z0( "z0",
"Z coordinate of start of compartment",
&CompartmentBase::setZ0,
&CompartmentBase::getZ0
@@ -260,16 +263,16 @@ const Cinfo* CompartmentBase::initCinfo()
&CompartmentBase::setY,
&CompartmentBase::getY
);
- static ValueFinfo< CompartmentBase, double > z( "z",
+ static ValueFinfo< CompartmentBase, double > z( "z",
"z coordinate of end of compartment",
&CompartmentBase::setZ,
&CompartmentBase::getZ
);
-
+
//////////////////////////////////////////////////////////////////
// DestFinfo definitions
//////////////////////////////////////////////////////////////////
- static DestFinfo injectMsg( "injectMsg",
+ static DestFinfo injectMsg( "injectMsg",
"The injectMsg corresponds to the INJECT message in the "
"GENESIS compartment. Unlike the 'inject' field, any value "
"assigned by handleInject applies only for a single timestep."
@@ -277,7 +280,7 @@ const Cinfo* CompartmentBase::initCinfo()
"injection current",
new EpFunc1< CompartmentBase, double >( &CompartmentBase::injectMsg )
);
-
+
static DestFinfo randInject( "randInject",
"Sends a random injection current to the compartment. Must be"
"updated each timestep."
@@ -285,24 +288,24 @@ const Cinfo* CompartmentBase::initCinfo()
new EpFunc2< CompartmentBase, double, double > (
&CompartmentBase::randInject ) );
- static DestFinfo cable( "cable",
+ static DestFinfo cable( "cable",
"Message for organizing compartments into groups, called"
"cables. Doesn't do anything.",
new OpFunc0< CompartmentBase >( &CompartmentBase::cable )
);
- static DestFinfo displace( "displace",
+ static DestFinfo displace( "displace",
"Displaces compartment by specified vector",
new OpFunc3< CompartmentBase, double, double, double>(
&CompartmentBase::displace )
);
- static DestFinfo setGeomAndElec( "setGeomAndElec",
+ static DestFinfo setGeomAndElec( "setGeomAndElec",
"Assigns length and dia and accounts for any electrical "
"scaling needed as a result.",
new EpFunc2< CompartmentBase, double, double>(
&CompartmentBase::setGeomAndElec )
);
///////////////////////////////////////////////////////////////////
- static Finfo* compartmentFinfos[] =
+ static Finfo* compartmentFinfos[] =
{
&Vm, // Value
&Cm, // Value
@@ -381,7 +384,7 @@ bool CompartmentBase::rangeWarning( const string& field, double value )
if ( value < RANGE ) {
cout << "Warning: Ignored attempt to set " << field <<
" of compartment " <<
- // c->target().e->name() <<
+ // c->target().e->name() <<
" to " << value << " as it is less than " << RANGE << endl;
return 1;
}
@@ -480,8 +483,8 @@ double CompartmentBase::getDiameter() const
void CompartmentBase::setLength( double value )
{
// If length is assigned correctly, also redo the end coords to match.
- if ( value > 0 && length_ > 0 &&
- doubleEq( length_ * length_,
+ if ( value > 0 && length_ > 0 &&
+ doubleEq( length_ * length_,
(x_-x0_)*(x_-x0_) + (y_-y0_)*(y_-y0_) + (z_-z0_)*(z_-z0_) ) ) {
double ratio = value / length_;
x_ = x0_ + ratio * ( x_ - x0_ );
@@ -499,7 +502,7 @@ double CompartmentBase::getLength() const
void CompartmentBase::updateLength()
{
- length_ = sqrt( (x_-x0_)*(x_-x0_) +
+ length_ = sqrt( (x_-x0_)*(x_-x0_) +
(y_-y0_)*(y_-y0_) + (z_-z0_)*(z_-z0_) );
}
@@ -585,7 +588,7 @@ void CompartmentBase::reinit( const Eref& e, ProcPtr p )
void CompartmentBase::initProc( const Eref& e, ProcPtr p )
{
- vInitProc( e, p );
+ vInitProc( e, p );
}
void CompartmentBase::initReinit( const Eref& e, ProcPtr p )
@@ -637,11 +640,11 @@ void CompartmentBase::setGeomAndElec( const Eref& e,
double len, double dia )
{
if ( length_ > 0 && diameter_ > 0 && len > 0 && dia > 0 &&
- doubleEq( length_ * length_,
+ doubleEq( length_ * length_,
(x_-x0_)*(x_-x0_) + (y_-y0_)*(y_-y0_) + (z_-z0_)*(z_-z0_) ) ) {
vSetRm( e, vGetRm( e ) * diameter_ * length_ / ( dia * len ) );
vSetCm( e, vGetCm( e ) * dia * len / ( diameter_ * length_ ) );
- vSetRa( e, vGetRa( e ) * len * (diameter_ * diameter_) /
+ vSetRa( e, vGetRa( e ) * len * (diameter_ * diameter_) /
( length_ * dia * dia ) );
// Rescale channel Gbars here
vector< ObjId > chans;
@@ -658,7 +661,7 @@ void CompartmentBase::setGeomAndElec( const Eref& e,
Field< double >::set( concs[i], "length", len );
Field< double >::set( concs[i], "diameter", dia );
}
-
+
setLength( len );
setDiameter( dia );
}
@@ -673,7 +676,7 @@ void CompartmentBase::vSetSolver( const Eref& e, Id hsolve )
{;}
// static func
-void CompartmentBase::zombify( Element* orig, const Cinfo* zClass,
+void CompartmentBase::zombify( Element* orig, const Cinfo* zClass,
Id hsolve )
{
if ( orig->cinfo() == zClass )
@@ -686,7 +689,7 @@ void CompartmentBase::zombify( Element* orig, const Cinfo* zClass,
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const CompartmentBase* cb =
+ const CompartmentBase* cb =
reinterpret_cast< const CompartmentBase* >( er.data() );
cdh[i].readData( cb, er );
}
diff --git a/biophysics/DifBuffer.cpp b/biophysics/DifBuffer.cpp
index 60763e82..cb77d41f 100644
--- a/biophysics/DifBuffer.cpp
+++ b/biophysics/DifBuffer.cpp
@@ -1,47 +1,47 @@
// DifBuffer.cpp ---
-//
+//
// Filename: DifBuffer.cpp
-// Description:
+// Description:
// Author: Subhasis Ray
-// Maintainer:
+// Maintainer:
// Created: Mon Feb 16 12:02:11 2015 (-0500)
-// Version:
+// Version:
// Package-Requires: ()
// Last-Updated: Mon Feb 23 13:07:56 2015 (-0500)
// By: Subhasis Ray
// Update #: 130
-// URL:
-// Doc URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
-//
-//
-//
+// URL:
+// Doc URL:
+// Keywords:
+// Compatibility:
+//
+//
+
+// Commentary:
+//
+//
+//
+//
// Change Log:
// 5/25/16 Completing DifBuffer -- Asia J-Szmek (GMU)
// 9/21/16 rewrote DifBuffer to account for DifBufferBase (AJS)
-//
-//
+//
+//
// 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 GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-//
-//
+//
+//
// Code:
@@ -141,7 +141,7 @@ void DifBuffer::vSetBFree(const Eref& e,double value)
bBound_ = bTot_ - bFree_;
prevFree_= bFree_;
prevBound_ = bBound_;
-
+
}
double DifBuffer::vGetBBound(const Eref& e) const
@@ -219,7 +219,7 @@ double DifBuffer::vGetD(const Eref& e) const
void DifBuffer::vSetD(const Eref& e,double value)
{
-
+
if ( value < 0.0 ) {
cerr << " Error: DifBuffer: Diffusion constant, D, cannot be negative!\n";
return;
@@ -248,7 +248,7 @@ void DifBuffer::vSetLength(const Eref& e, double length )
cerr << "Error: DifBuffer: length cannot be negative!\n";
return;
}
-
+
length_ = length;
}
@@ -263,7 +263,7 @@ void DifBuffer::vSetDiameter(const Eref& e, double diameter )
cerr << "Error: DifBuffer: diameter cannot be negative!\n";
return;
}
-
+
diameter_ = diameter;
}
@@ -278,7 +278,7 @@ void DifBuffer::vSetThickness( const Eref& e, double thickness )
cerr << "Error: DifBuffer: thickness cannot be negative!\n";
return;
}
-
+
thickness_ = thickness;
}
@@ -291,12 +291,12 @@ void DifBuffer::vSetVolume(const Eref& e, double volume )
{
if ( shapeMode_ != 3 )
cerr << "Warning: DifBuffer: Trying to set volume, when shapeMode is not USER-DEFINED\n";
-
+
if ( volume < 0.0 ) {
cerr << "Error: DifBuffer: volume cannot be negative!\n";
return;
}
-
+
volume_ = volume;
}
@@ -309,12 +309,12 @@ void DifBuffer::vSetOuterArea(const Eref& e, double outerArea )
{
if (shapeMode_ != 3 )
cerr << "Warning: DifBuffer: Trying to set outerArea, when shapeMode is not USER-DEFINED\n";
-
+
if ( outerArea < 0.0 ) {
cerr << "Error: DifBuffer: outerArea cannot be negative!\n";
return;
}
-
+
outerArea_ = outerArea;
}
@@ -327,12 +327,12 @@ void DifBuffer::vSetInnerArea(const Eref& e, double innerArea )
{
if ( shapeMode_ != 3 )
cerr << "Warning: DifBuffer: Trying to set innerArea, when shapeMode is not USER-DEFINED\n";
-
+
if ( innerArea < 0.0 ) {
cerr << "Error: DifBuffer: innerArea cannot be negative!\n";
return;
}
-
+
innerArea_ = innerArea;
}
@@ -369,16 +369,16 @@ void DifBuffer::vProcess( const Eref & e, ProcPtr p )
* then compute their incoming fluxes.
*/
-
-
+
+
Af_ += kb_ * bBound_;
Bf_ += kf_ * activation_;
-
+
bFree_ = integrate(bFree_,p->dt,Af_,Bf_);
bBound_ = bTot_ - bFree_;
prevFree_ = bFree_;
prevBound_ = bBound_;
-
+
/**
* Send ion concentration to ion buffers. They will send back information on
* the reaction (forward / backward rates ; free / bound buffer concentration)
@@ -395,11 +395,11 @@ void DifBuffer::vProcess( const Eref & e, ProcPtr p )
void DifBuffer::vReinit( const Eref& e, ProcPtr p )
{
-
+
Af_ = 0;
Bf_= 0;
double rOut = diameter_/2.;
-
+
double rIn = rOut - thickness_;
if (rIn<0)
@@ -419,9 +419,9 @@ void DifBuffer::vReinit( const Eref& e, ProcPtr p )
outerArea_ = 2*M_PI * rOut * length_;
innerArea_ = 2*M_PI * rIn * length_;
}
-
+
break;
-
+
/*
* Cylindrical Slice
*/
@@ -430,7 +430,7 @@ void DifBuffer::vReinit( const Eref& e, ProcPtr p )
outerArea_ = M_PI * diameter_ * diameter_ / 4.0;
innerArea_ = outerArea_;
break;
-
+
/*
* User defined
*/
@@ -438,18 +438,18 @@ void DifBuffer::vReinit( const Eref& e, ProcPtr p )
// Nothing to be done here. Volume and inner-, outer areas specified by
// user.
break;
-
+
default:
assert( 0 );
}
-
+
bFree_ = bTot_/(1+activation_*kf_/kb_);
prevFree_ = bFree_;
bBound_ = bTot_ - bFree_;
prevBound_ = bBound_;
innerDifSourceOut()->send( e, prevFree_, thickness_ );
outerDifSourceOut()->send( e, prevFree_, thickness_ );
-
+
}
void DifBuffer::vFluxFromIn(const Eref& e,double innerC, double innerThickness)
diff --git a/biophysics/DifBufferBase.cpp b/biophysics/DifBufferBase.cpp
index 40628a21..5c6c43a2 100644
--- a/biophysics/DifBufferBase.cpp
+++ b/biophysics/DifBufferBase.cpp
@@ -12,7 +12,7 @@ SrcFinfo4< double, double, double, double >* DifBufferBase::reactionOut()
" (free-buffer and bound-buffer molecules).");
return &reactionOut;
}
-
+
SrcFinfo2< double, double >* DifBufferBase::innerDifSourceOut(){
static SrcFinfo2< double, double > sourceOut("innerDifSourceOut",
@@ -34,20 +34,20 @@ const Cinfo * DifBufferBase::initCinfo()
static DestFinfo reinit( "reinit",
"Reinit happens only in stage 0",
new ProcOpFunc< DifBufferBase >( &DifBufferBase::reinit));
-
+
static Finfo* processShared[] = {
&process,
&reinit
};
static SharedFinfo proc(
- "proc",
+ "proc",
"Here we create 2 shared finfos to attach with the Ticks. This is because we want to perform DifBufferBase "
"computations in 2 stages, much as in the Compartment object. "
"In the first stage we send out the concentration value to other DifBufferBases and Buffer elements. We also",
processShared,
sizeof( processShared ) / sizeof( Finfo* ));
-
+
static DestFinfo concentration("concentration",
"Receives concentration (from DifShell).",
new EpFunc1<DifBufferBase, double>(&DifBufferBase::buffer));
@@ -72,13 +72,13 @@ const Cinfo * DifBufferBase::initCinfo()
static DestFinfo fluxFromOut( "fluxFromOut",
"Destination message",
new EpFunc2< DifBufferBase, double, double > ( &DifBufferBase::fluxFromOut ));
-
+
static Finfo* innerDifShared[] = {
&fluxFromOut,
DifBufferBase::innerDifSourceOut()
-
+
};
-
+
static SharedFinfo innerDif( "innerDif",
"This shared message (and the next) is between DifBufferBases: adjoining shells exchange information to "
"find out the flux between them. "
@@ -88,9 +88,9 @@ const Cinfo * DifBufferBase::initCinfo()
static DestFinfo fluxFromIn( "fluxFromIn", "",
new EpFunc2< DifBufferBase, double, double> ( &DifBufferBase::fluxFromIn) );
-
+
static Finfo* outerDifShared[] = {
- &fluxFromIn,
+ &fluxFromIn,
DifBufferBase::outerDifSourceOut(),
};
@@ -99,7 +99,7 @@ const Cinfo * DifBufferBase::initCinfo()
"Using this message, an outer shell sends to, and receives from its inner shell." ,
outerDifShared,
sizeof( outerDifShared ) / sizeof( Finfo* ));
-
+
////////////////////////////
// Field defs
////////////////////////////
@@ -130,7 +130,7 @@ const Cinfo * DifBufferBase::initCinfo()
static ElementValueFinfo<DifBufferBase, double> bTot("bTot",
"Total buffer concentration.",
&DifBufferBase::setBTot,
- &DifBufferBase::getBTot);
+ &DifBufferBase::getBTot);
static ElementValueFinfo<DifBufferBase, double> length("length",
"Length of shell",
&DifBufferBase::setLength,
@@ -143,12 +143,12 @@ const Cinfo * DifBufferBase::initCinfo()
"shape of the shell: SHELL=0, SLICE=SLAB=1, USERDEF=3",
&DifBufferBase::setShapeMode,
&DifBufferBase::getShapeMode);
-
+
static ElementValueFinfo<DifBufferBase, double> thickness("thickness",
"Thickness of shell",
&DifBufferBase::setThickness,
&DifBufferBase::getThickness);
-
+
static ElementValueFinfo<DifBufferBase, double> innerArea("innerArea",
"Inner area of shell",
&DifBufferBase::setInnerArea,
@@ -160,7 +160,7 @@ const Cinfo * DifBufferBase::initCinfo()
static ElementValueFinfo< DifBufferBase, double> volume( "volume", "",
&DifBufferBase::setVolume,
&DifBufferBase::getVolume );
-
+
////
// DestFinfo
////
@@ -168,7 +168,7 @@ const Cinfo * DifBufferBase::initCinfo()
//////////////////////////////////////////////////////////////////
// Field definitions
//////////////////////////////////////////////////////////////////
-
+
&activation,
&D,
&bFree,
@@ -199,7 +199,7 @@ const Cinfo * DifBufferBase::initCinfo()
//////////////////////////////////////////////////////////////////
// DestFinfo definitions
//////////////////////////////////////////////////////////////////
- &concentration,
+ &concentration,
};
static string doc[] = {
@@ -379,7 +379,7 @@ void DifBufferBase::buffer(const Eref& e,double C)
{
vBuffer(e,C);
}
-
+
void DifBufferBase::reinit( const Eref& e, ProcPtr p )
{
vReinit( e, p );
@@ -400,7 +400,7 @@ void DifBufferBase:: fluxFromIn(const Eref& e,double innerC, double innerThickne
void DifBufferBase::vSetSolver( const Eref& e, Id hsolve )
{;}
-void DifBufferBase::zombify( Element* orig, const Cinfo* zClass,
+void DifBufferBase::zombify( Element* orig, const Cinfo* zClass,
Id hsolve )
{
if ( orig->cinfo() == zClass )
@@ -413,10 +413,10 @@ void DifBufferBase::zombify( Element* orig, const Cinfo* zClass,
vector< double > data( num * len );
unsigned int j = 0;
-
+
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const DifBufferBase* ds =
+ const DifBufferBase* ds =
reinterpret_cast< const DifBufferBase* >( er.data() );
data[j + 0] = ds->getActivation( er );
data[j + 1] = ds->getBFree( er );
@@ -438,7 +438,7 @@ void DifBufferBase::zombify( Element* orig, const Cinfo* zClass,
j = 0;
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- DifBufferBase* ds =
+ DifBufferBase* ds =
reinterpret_cast< DifBufferBase* >( er.data() );
ds->vSetSolver(er,hsolve);
ds->setActivation(er, data[j+0]);
@@ -457,5 +457,5 @@ void DifBufferBase::zombify( Element* orig, const Cinfo* zClass,
ds->setInnerArea(er, data[j + 13]);
j += len; //??
}
-
+
}
diff --git a/biophysics/HHChannelBase.cpp b/biophysics/HHChannelBase.cpp
index 677d9554..147bb6e8 100644
--- a/biophysics/HHChannelBase.cpp
+++ b/biophysics/HHChannelBase.cpp
@@ -45,7 +45,7 @@ const Cinfo* HHChannelBase::initCinfo()
&HHChannelBase::setInstant,
&HHChannelBase::getInstant
);
- static ElementValueFinfo< HHChannelBase, double > X( "X",
+ static ElementValueFinfo< HHChannelBase, double > X( "X",
"State variable for X gate",
&HHChannelBase::setX,
&HHChannelBase::getX
@@ -60,7 +60,7 @@ const Cinfo* HHChannelBase::initCinfo()
&HHChannelBase::setZ,
&HHChannelBase::getZ
);
- static ElementValueFinfo< HHChannelBase, int > useConcentration(
+ static ElementValueFinfo< HHChannelBase, int > useConcentration(
"useConcentration",
"Flag: when true, use concentration message rather than Vm to"
"control Z gate",
@@ -76,7 +76,7 @@ const Cinfo* HHChannelBase::initCinfo()
///////////////////////////////////////////////////////
// MsgDest definitions
///////////////////////////////////////////////////////
- static DestFinfo concen( "concen",
+ static DestFinfo concen( "concen",
"Incoming message from Concen object to specific conc to use"
"in the Z gate calculations",
new EpFunc1< HHChannelBase, double >( &HHChannelBase::handleConc )
@@ -88,7 +88,7 @@ const Cinfo* HHChannelBase::initCinfo()
);
///////////////////////////////////////////////////////
// FieldElementFinfo definition for HHGates. Note that these are made
-// with the deferCreate flag off, so that the HHGates are created
+// with the deferCreate flag off, so that the HHGates are created
// right away even if they are empty.
// Assume only a single entry allocated in each gate.
///////////////////////////////////////////////////////
@@ -116,7 +116,7 @@ const Cinfo* HHChannelBase::initCinfo()
&HHChannelBase::getNumZgates
// 1
);
-
+
///////////////////////////////////////////////////////
static Finfo* HHChannelBaseFinfos[] =
{
@@ -134,7 +134,7 @@ const Cinfo* HHChannelBase::initCinfo()
&gateY, // FieldElement
&gateZ // FieldElement
};
-
+
static string doc[] =
{
"Name", "HHChannelBase",
@@ -144,9 +144,9 @@ const Cinfo* HHChannelBase::initCinfo()
"like the old tabchannel from GENESIS, but also presents "
"a similar interface as hhchan from GENESIS. ",
};
-
+
static ZeroSizeDinfo< int > dinfo;
-
+
static Cinfo HHChannelBaseCinfo(
"HHChannelBase",
ChanBase::initCinfo(),
@@ -168,9 +168,9 @@ static const Cinfo* hhChannelCinfo = HHChannelBase::initCinfo();
// Constructor
///////////////////////////////////////////////////
HHChannelBase::HHChannelBase()
- :
- Xpower_( 0.0 ),
- Ypower_( 0.0 ),
+ :
+ Xpower_( 0.0 ),
+ Ypower_( 0.0 ),
Zpower_( 0.0 ),
useConcentration_( 0 ),
modulation_( 1.0 )
@@ -321,7 +321,7 @@ HHGate* HHChannelBase::getZgate( unsigned int i )
return vGetZgate( i );
}
-void HHChannelBase::setNumGates( unsigned int num )
+void HHChannelBase::setNumGates( unsigned int num )
{ ; }
unsigned int HHChannelBase::getNumXgates() const
@@ -384,7 +384,7 @@ void HHChannelBase::zombify( Element* orig, const Cinfo* zClass, Id hsolve )
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const HHChannelBase* hb =
+ const HHChannelBase* hb =
reinterpret_cast< const HHChannelBase* >( er.data() );
*j = hb->vGetGbar( er );
*(j+1) = hb->vGetEk( er);
@@ -406,9 +406,8 @@ void HHChannelBase::zombify( Element* orig, const Cinfo* zClass, Id hsolve )
hb->vSetYpower( er, *(j+3) );
hb->vSetZpower( er, *(j+4) );
// hb->vSetUseConcentration( er, *(j+5) > 0.5 );
- // Disable this assignment because the Solver already reads the
+ // Disable this assignment because the Solver already reads the
// value, and it triggers an error msg.
j+= 6;
}
}
-
diff --git a/biophysics/IntFire.cpp b/biophysics/IntFire.cpp
index b4478a11..990e62d7 100644
--- a/biophysics/IntFire.cpp
+++ b/biophysics/IntFire.cpp
@@ -12,8 +12,8 @@
#include "IntFire.h"
static SrcFinfo1< double > *spikeOut() {
- static SrcFinfo1< double > spikeOut(
- "spikeOut",
+ static SrcFinfo1< double > spikeOut(
+ "spikeOut",
"Sends out spike events. The argument is the timestamp of "
"the spike. "
);
@@ -101,7 +101,7 @@ const Cinfo* IntFire::initCinfo()
static const Cinfo* intFireCinfo = IntFire::initCinfo();
IntFire::IntFire()
- : Vm_( 0.0 ), thresh_( 0.0 ), tau_( 1.0 ),
+ : Vm_( 0.0 ), thresh_( 0.0 ), tau_( 1.0 ),
refractoryPeriod_( 0.1 ), lastSpike_( -0.1 ),
activation_( 0.0 )
{
diff --git a/biophysics/MgBlock.cpp b/biophysics/MgBlock.cpp
index 2c946a51..a070e7aa 100644
--- a/biophysics/MgBlock.cpp
+++ b/biophysics/MgBlock.cpp
@@ -22,19 +22,19 @@ const Cinfo* MgBlock::initCinfo()
///////////////////////////////////////////////////////
// Dest definitions
///////////////////////////////////////////////////////
- static DestFinfo origChannel( "origChannel",
+ static DestFinfo origChannel( "origChannel",
"",
new EpFunc2< MgBlock, double, double > (&MgBlock::origChannel )
);
///////////////////////////////////////////////////////
// Field definitions
///////////////////////////////////////////////////////
- static ValueFinfo< MgBlock, double > KMg_A( "KMg_A",
+ static ValueFinfo< MgBlock, double > KMg_A( "KMg_A",
"1/eta",
&MgBlock::setKMg_A,
&MgBlock::getKMg_A
);
- static ValueFinfo< MgBlock, double > KMg_B( "KMg_B",
+ static ValueFinfo< MgBlock, double > KMg_B( "KMg_B",
"1/gamma",
&MgBlock::setKMg_B,
&MgBlock::getKMg_B
@@ -66,7 +66,7 @@ const Cinfo* MgBlock::initCinfo()
"Description", "MgBlock: Hodgkin-Huxley type voltage-gated Ion channel. Something "
"like the old tabchannel from GENESIS, but also presents "
"a similar interface as hhchan from GENESIS. ",
- };
+ };
static Dinfo< MgBlock > dinfo;
static Cinfo MgBlockCinfo(
"MgBlock",
@@ -87,7 +87,7 @@ static const Cinfo* MgBlockCinfo = MgBlock::initCinfo();
// Constructor
///////////////////////////////////////////////////
MgBlock::MgBlock()
- : Zk_( 0.0 ),
+ : Zk_( 0.0 ),
KMg_A_( 1.0 ), // These are NOT the same as the A, B state
KMg_B_( 1.0 ), // variables used for Exp Euler integration.
CMg_( 1.0 ), // Conc of Mg in mM
@@ -185,4 +185,3 @@ void MgBlock::origChannel( const Eref& e, double Gk, double Ek )
///////////////////////////////////////////////////
// Unit tests
///////////////////////////////////////////////////
-
diff --git a/biophysics/RandSpike.cpp b/biophysics/RandSpike.cpp
index ac5257d2..0c2e09ff 100644
--- a/biophysics/RandSpike.cpp
+++ b/biophysics/RandSpike.cpp
@@ -15,7 +15,7 @@
// MsgSrc definitions
///////////////////////////////////////////////////////
static SrcFinfo1< double > *spikeOut() {
- static SrcFinfo1< double > spikeOut( "spikeOut",
+ static SrcFinfo1< double > spikeOut( "spikeOut",
"Sends out a trigger for an event.");
return &spikeOut;
}
@@ -25,10 +25,10 @@ const Cinfo* RandSpike::initCinfo()
///////////////////////////////////////////////////////
// Shared message definitions
///////////////////////////////////////////////////////
- static DestFinfo process( "process",
+ static DestFinfo process( "process",
"Handles process call",
new ProcOpFunc< RandSpike >( &RandSpike::process ) );
- static DestFinfo reinit( "reinit",
+ static DestFinfo reinit( "reinit",
"Handles reinit call",
new ProcOpFunc< RandSpike >( &RandSpike::reinit ) );
@@ -37,10 +37,10 @@ const Cinfo* RandSpike::initCinfo()
&process, &reinit
};
- static SharedFinfo proc( "proc",
+ static SharedFinfo proc( "proc",
"Shared message to receive Process message from scheduler",
processShared, sizeof( processShared ) / sizeof( Finfo* ) );
-
+
//////////////////////////////////////////////////////////////////
// Dest Finfos.
//////////////////////////////////////////////////////////////////
@@ -48,7 +48,7 @@ const Cinfo* RandSpike::initCinfo()
//////////////////////////////////////////////////////////////////
// Value Finfos.
//////////////////////////////////////////////////////////////////
-
+
static ValueFinfo< RandSpike, double > rate( "rate",
"Specifies rate for random spike train. Note that this is"
"probabilistic, so the instantaneous rate may differ. "
@@ -72,7 +72,7 @@ const Cinfo* RandSpike::initCinfo()
&RandSpike::getFired
);
- static Finfo* spikeGenFinfos[] =
+ static Finfo* spikeGenFinfos[] =
{
spikeOut(), // SrcFinfo
&proc, // Shared
@@ -96,7 +96,7 @@ const Cinfo* RandSpike::initCinfo()
spikeGenFinfos, sizeof( spikeGenFinfos ) / sizeof( Finfo* ),
&dinfo,
doc,
- sizeof(doc)/sizeof(string)
+ sizeof(doc)/sizeof(string)
);
return &spikeGenCinfo;
@@ -105,7 +105,7 @@ const Cinfo* RandSpike::initCinfo()
static const Cinfo* spikeGenCinfo = RandSpike::initCinfo();
RandSpike::RandSpike()
- :
+ :
rate_( 0.0 ),
realRate_( 0.0 ),
refractT_(0.0),
@@ -159,11 +159,11 @@ void RandSpike::process( const Eref& e, ProcPtr p )
if ( refractT_ > p->currTime - lastEvent_ )
return;
double prob = realRate_ * p->dt;
- if ( prob >= 1.0 || prob >= mtrand() )
+ if ( prob >= 1.0 || prob >= mtrand() )
{
lastEvent_ = p->currTime;
spikeOut()->send( e, p->currTime );
- fired_ = true;
+ fired_ = true;
} else {
fired_ = false;
}
diff --git a/biophysics/ReadSwc.cpp b/biophysics/ReadSwc.cpp
index 69ca680a..6f6f5a2a 100644
--- a/biophysics/ReadSwc.cpp
+++ b/biophysics/ReadSwc.cpp
@@ -23,7 +23,6 @@ static const double MinRadius = 0.04;
ReadSwc::ReadSwc( const string& fname )
{
- bool verbose = false;
ifstream fin( fname.c_str() );
if ( !fin ) {
cerr << "ReadSwc:: could not open file " << fname << endl;
@@ -59,9 +58,10 @@ ReadSwc::ReadSwc( const string& fname )
", # Branches = " << branches_.size() <<
". # Segs = " << segs_.size() <<
", bad = " << badSegs <<
+ ", Validated = " << valid <<
+ ", numBranches = " << branches_.size() <<
endl;
- if ( verbose )
- diagnostics();
+ diagnostics();
}
bool ReadSwc::validate() const
diff --git a/builtins/Streamer.cpp b/builtins/Streamer.cpp
index fc21fc05..dd9c0bf2 100644
--- a/builtins/Streamer.cpp
+++ b/builtins/Streamer.cpp
@@ -136,7 +136,7 @@ static const Cinfo* tableStreamCinfo = Streamer::initCinfo();
// Class function definitions
-Streamer::Streamer()
+Streamer::Streamer()
{
// Not all compilers allow initialization during the declaration of class
// methods.
@@ -176,7 +176,7 @@ void Streamer::reinit(const Eref& e, ProcPtr p)
}
Clock* clk = reinterpret_cast<Clock*>( Id(1).eref().data() );
- for (size_t i = 0; i < tableIds_.size(); i++)
+ for (size_t i = 0; i < tableIds_.size(); i++)
{
int tickNum = tableIds_[i].element()->getTick();
double tick = clk->getTickDt( tickNum );
@@ -206,14 +206,14 @@ void Streamer::reinit(const Eref& e, ProcPtr p)
// Make sure all tables have same dt_ else disable the streamer.
vector<unsigned int> invalidTables;
- for (size_t i = 1; i < tableTick_.size(); i++)
+ for (size_t i = 1; i < tableTick_.size(); i++)
{
if( tableTick_[i] != tableTick_[0] )
{
LOG( moose::warning
, "Table " << tableIds_[i].path()
<< " has tick (dt) which is different than the first table."
- << endl
+ << endl
<< " Got " << tableTick_[i] << " expected " << tableTick_[0]
<< endl << " Disabling this table."
);
@@ -221,7 +221,7 @@ void Streamer::reinit(const Eref& e, ProcPtr p)
}
}
- for (size_t i = 0; i < invalidTables.size(); i++)
+ for (size_t i = 0; i < invalidTables.size(); i++)
{
tables_.erase( tables_.begin() + i );
tableDt_.erase( tableDt_.begin() + i );
@@ -320,7 +320,7 @@ void Streamer::addTables( vector<Id> tables )
void Streamer::removeTable( Id table )
{
int matchIndex = -1;
- for (size_t i = 0; i < tableIds_.size(); i++)
+ for (size_t i = 0; i < tableIds_.size(); i++)
if( table.path() == tableIds_[i].path() )
{
matchIndex = i;
@@ -383,7 +383,7 @@ void Streamer::setFormat( string fmt )
}
/* Get the format of all tables. */
-string Streamer::getFormat( void ) const
+string Streamer::getFormat( void ) const
{
return format_;
}
@@ -407,7 +407,7 @@ void Streamer::zipWithTime( )
{
#if 0
LOG( moose::debug
- , "Table " << tables_[i]->getName( ) << " is not functional. Filling with zero "
+ , "Table " << tables_[i]->getName( ) << " is not functional. Filling with zero "
);
#endif
tVec.resize( numEntriesInEachTable, 0 );
diff --git a/cmake_modules/FindGSL.cmake b/cmake_modules/FindGSL.cmake
index 99ad9ea8..93c2686f 100644
--- a/cmake_modules/FindGSL.cmake
+++ b/cmake_modules/FindGSL.cmake
@@ -63,34 +63,28 @@ ELSE(WIN32)
SET(GSL_CBLAS_LIB_NAMES gslcblas)
ENDIF( )
- if(GSL_ROOT_DIR)
- message(" Debug: Searching in user given path " )
- FIND_LIBRARY(GSL_LIB
- NAMES ${GSL_LIB_NAMES}
- PATHS ${GSL_ROOT_DIR}/lib ${GSL_ROOT_DIR}/lib64
- NO_DEFAULT_PATH
- )
-
- FIND_LIBRARY(GSLCBLAS_LIB
- NAMES ${GSL_CBLAS_LIB_NAMES}
- PATHS ${GSL_ROOT_DIR}/lib ${GSL_ROOT_DIR}/lib64
- NO_DEFAULT_PATH
- )
-
- FIND_PATH(GSL_INCLUDE_DIRS NAMES gsl/gsl_blas.h
- PATHS ${GSL_ROOT_DIR}/include
- NO_DEFAULT_PATH
- )
- else( )
- FIND_LIBRARY(GSL_LIB NAMES ${GSL_LIB_NAMES} )
- FIND_LIBRARY(GSLCBLAS_LIB NAMES ${GSL_CBLAS_LIB_NAMES})
- FIND_PATH(GSL_INCLUDE_DIRS NAMES gsl/gsl_blas.h )
- endif()
+ FIND_LIBRARY(GSL_LIB
+ NAMES ${GSL_LIB_NAMES}
+ PATHS
+ ${GSL_ROOT_DIR}/lib ${GSL_ROOT_DIR}/lib64
+ /opt/lib /opt/lib64
+ )
+ FIND_LIBRARY(GSLCBLAS_LIB
+ NAMES ${GSL_CBLAS_LIB_NAMES}
+ PATHS
+ ${GSL_ROOT_DIR}/lib ${GSL_ROOT_DIR}/lib64
+ /opt/lib /opt/lib64
+ )
IF (GSL_LIB AND GSLCBLAS_LIB)
SET (GSL_LIBRARIES ${GSL_LIB} ${GSLCBLAS_LIB})
ENDIF (GSL_LIB AND GSLCBLAS_LIB)
+ FIND_PATH(GSL_INCLUDE_DIRS NAMES gsl/gsl_blas.h
+ PATHS ${GSL_ROOT_DIR}/include /opt/include
+ )
+
+
ENDIF(WIN32)
# FIND version
@@ -106,7 +100,7 @@ endif(GSL_INCLUDE_DIRS)
IF(GSL_LIBRARIES AND GSL_VERSION)
IF(GSL_INCLUDE_DIRS)
- MESSAGE(STATUS "Found GSL: ${GSL_INCLUDE_DIRS}, ${GSL_LIBRARIES}")
+ MESSAGE(STATUS "Found GSL ${GSL_LIBRARIES}")
SET(GSL_FOUND 1)
ENDIF(GSL_INCLUDE_DIRS)
ENDIF()
diff --git a/cmake_modules/FindNumPy.cmake b/cmake_modules/FindNumPy.cmake
index 83c74d47..b2813e9c 100644
--- a/cmake_modules/FindNumPy.cmake
+++ b/cmake_modules/FindNumPy.cmake
@@ -52,7 +52,7 @@ if(NOT PYTHONINTERP_FOUND)
return()
endif()
-execute_process(COMMAND ${PYTHON_EXECUTABLE} -c
+execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
"import numpy as n; print(n.__version__); print(n.get_include());"
RESULT_VARIABLE _NUMPY_SEARCH_SUCCESS
OUTPUT_VARIABLE _NUMPY_VALUES_OUTPUT
diff --git a/device/PulseGen.cpp b/device/PulseGen.cpp
index 2112191a..105aa828 100644
--- a/device/PulseGen.cpp
+++ b/device/PulseGen.cpp
@@ -1,31 +1,31 @@
-// PulseGen.cpp ---
-//
+// PulseGen.cpp ---
+//
// Filename: PulseGen.cpp
-// Description:
+// Description:
// Author: Subhasis Ray
-// Maintainer:
+// Maintainer:
// Created: Mon Feb 20 01:41:12 2012 (+0530)
-// Version:
+// Version:
// Last-Updated: Mon May 27 11:49:31 2013 (+0530)
// By: subha
// Update #: 170
-// URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
-//
-//
-//
+// URL:
+// Keywords:
+// Compatibility:
+//
+//
+
+// Commentary:
+//
+//
+//
+//
// Change log:
-//
+//
// 2012-02-20 01:41:16 (+0530) - Subha - started porting from old
// moose.
-//
+//
// Code:
@@ -62,7 +62,7 @@ const Cinfo* PulseGen::initCinfo()
static ValueFinfo< PulseGen, double > firstDelay("firstDelay",
"Delay to start of the first pulse in a sequence",
&PulseGen::setFirstDelay,
- &PulseGen::getFirstDelay);
+ &PulseGen::getFirstDelay);
static ValueFinfo< PulseGen, double > secondLevel("secondLevel",
"Amplitude of the second pulse in a sequence",
&PulseGen::setSecondLevel,
@@ -112,7 +112,7 @@ const Cinfo* PulseGen::initCinfo()
static DestFinfo delayIn("delayIn",
"Handle delay value coming from other objects",
new OpFunc2< PulseGen, unsigned int, double >(&PulseGen::setDelay));
-
+
static DestFinfo input("input",
"Handle incoming input that determines gating/triggering onset. "
"Note that although this is a double field, the underlying field is"
@@ -131,7 +131,7 @@ const Cinfo* PulseGen::initCinfo()
{
&process, &reinit
};
-
+
static SharedFinfo proc( "proc",
"This is a shared message to receive Process messages "
"from the scheduler objects."
@@ -169,7 +169,7 @@ const Cinfo* PulseGen::initCinfo()
"Name", "PulseGen",
"Author", "Subhasis Ray",
"Description", "PulseGen: general purpose pulse generator. This can generate any "
- "number of pulses with specified level and duration.",
+ "number of pulses with specified level and duration.",
};
static Dinfo<PulseGen> dinfo;
static Cinfo pulseGenCinfo("PulseGen",
@@ -179,8 +179,8 @@ const Cinfo* PulseGen::initCinfo()
&dinfo,
doc,
sizeof(doc)/sizeof(string));
- return & pulseGenCinfo;
-
+ return & pulseGenCinfo;
+
}
static const Cinfo* pulseGenCinfo = PulseGen::initCinfo();
@@ -211,32 +211,32 @@ PulseGen::~PulseGen()
void PulseGen::setFirstLevel( double level)
{
- level_[0] = level;
+ level_[0] = level;
}
double PulseGen::getFirstLevel() const
{
return level_[0];
}
-
+
void PulseGen::setFirstWidth(double width)
{
- width_[0] = width;
+ width_[0] = width;
}
double PulseGen::getFirstWidth() const
{
- return width_[0];
+ return width_[0];
}
void PulseGen::setFirstDelay( double delay)
{
- delay_[0] = delay;
+ delay_[0] = delay;
}
double PulseGen::getFirstDelay() const
{
return delay_[0];
}
-
+
void PulseGen::setSecondLevel( double level)
{
if (level_.size() >= 2){
@@ -284,15 +284,15 @@ double PulseGen::getSecondDelay() const
void PulseGen::setBaseLevel( double level)
{
- baseLevel_ = level;
+ baseLevel_ = level;
}
double PulseGen::getBaseLevel() const
{
- return baseLevel_;
+ return baseLevel_;
}
void PulseGen::setTrigMode(unsigned int mode)
{
- trigMode_ = mode;
+ trigMode_ = mode;
}
unsigned int PulseGen::getTrigMode() const
{
@@ -326,7 +326,7 @@ void PulseGen::setCount(unsigned int count)
unsigned int PulseGen::getCount() const
{
- return level_.size();
+ return level_.size();
}
double PulseGen::getLevel(unsigned int index) const
@@ -338,7 +338,7 @@ double PulseGen::getLevel(unsigned int index) const
return 0.0;
}
}
-
+
void PulseGen::setLevel( unsigned int index, double level)
{
if (index < level_.size()){
@@ -413,7 +413,7 @@ void PulseGen::process(const Eref& e, ProcPtr p )
case PulseGen::EXT_TRIG:
if (input_ == 0){
if (trigTime_ < 0){
- phase = period;
+ phase = period;
}else{
phase = currentTime - trigTime_;
}
@@ -423,7 +423,7 @@ void PulseGen::process(const Eref& e, ProcPtr p )
}
phase = currentTime - trigTime_;
}
- prevInput_ = input_;
+ prevInput_ = input_;
break;
case PulseGen::EXT_GATE:
if(input_ == 0)
@@ -431,7 +431,7 @@ void PulseGen::process(const Eref& e, ProcPtr p )
phase = period; /* output = baselevel */
}
else
- { /* gate high */
+ { /* gate high */
if(prevInput_ == 0)
{ /* low -> high */
trigTime_ = currentTime;
@@ -443,7 +443,7 @@ void PulseGen::process(const Eref& e, ProcPtr p )
default:
cerr << "ERROR: PulseGen::newProcessFunc( const Conn* , ProcInfo ) - invalid triggerMode - " << trigMode_ << endl;
}
- if (phase >= period){ // we have crossed all pulses
+ if (phase >= period){ // we have crossed all pulses
output_ = baseLevel_;
return;
}
@@ -468,9 +468,9 @@ void PulseGen::reinit(const Eref& e, ProcPtr p)
trigTime_ = -1;
prevInput_ = 0;
output_ = baseLevel_;
- input_ = 0;
+ input_ = 0;
outputOut()->send(e, output_);
}
-//
+//
// PulseGen.cpp ends here
diff --git a/examples/Ex.cpp b/examples/Ex.cpp
index f10cdc49..49fb32e2 100644
--- a/examples/Ex.cpp
+++ b/examples/Ex.cpp
@@ -84,7 +84,7 @@ const Cinfo* Ex::initCinfo()
static SharedFinfo proc(
"proc",
- "Shared message to receive Process messages",
+ "Handles 'reinit' and 'process' calls from a clock.",
processShared,
sizeof(processShared) / sizeof(Finfo*)
);
diff --git a/examples/Example.cpp b/examples/Example.cpp
index 83897eed..de4a4d15 100644
--- a/examples/Example.cpp
+++ b/examples/Example.cpp
@@ -61,7 +61,7 @@ const Cinfo* Example::initCinfo(){
&process, &reinit
};
static SharedFinfo proc( "proc",
- "Shared message for process and reinit",
+ "Handles 'reinit' and 'process' calls from a clock.",
procShared, sizeof( procShared ) / sizeof( const Finfo* )
);
diff --git a/hsolve/HSolve.cpp b/hsolve/HSolve.cpp
index 2adad4f5..05d5ff8e 100644
--- a/hsolve/HSolve.cpp
+++ b/hsolve/HSolve.cpp
@@ -533,4 +533,3 @@ void testHSolvePassiveSingleComp()
#endif // if 0
-
diff --git a/kinetics/BufPool.cpp b/kinetics/BufPool.cpp
index 54e18378..230be5d6 100644
--- a/kinetics/BufPool.cpp
+++ b/kinetics/BufPool.cpp
@@ -78,6 +78,7 @@ void BufPool::vSetConcInit( const Eref& e, double conc )
vSetConc( e, conc );
}
+
//////////////////////////////////////////////////////////////
// MsgDest Definitions
//////////////////////////////////////////////////////////////
@@ -96,4 +97,3 @@ void BufPool::vReinit( const Eref& e, ProcPtr p )
//////////////////////////////////////////////////////////////
// Field Definitions
//////////////////////////////////////////////////////////////
-
diff --git a/kinetics/CplxEnzBase.cpp b/kinetics/CplxEnzBase.cpp
index 2b1498a9..361f672f 100644
--- a/kinetics/CplxEnzBase.cpp
+++ b/kinetics/CplxEnzBase.cpp
@@ -14,16 +14,16 @@
#include "CplxEnzBase.h"
static SrcFinfo2< double, double > *enzOut() {
- static SrcFinfo2< double, double > enzOut(
- "enzOut",
+ static SrcFinfo2< double, double > enzOut(
+ "enzOut",
"Sends out increment of molecules on product each timestep"
);
return &enzOut;
}
static SrcFinfo2< double, double > *cplxOut() {
- static SrcFinfo2< double, double > cplxOut(
- "cplxOut",
+ static SrcFinfo2< double, double > cplxOut(
+ "cplxOut",
"Sends out increment of molecules on product each timestep"
);
return &cplxOut;
@@ -40,8 +40,8 @@ DestFinfo* enzDest()
}
/*
-static DestFinfo* enzDest =
- dynamic_cast< DestFinfo* >(
+static DestFinfo* enzDest =
+ dynamic_cast< DestFinfo* >(
const_cast< Finfo* >(
EnzBase::initCinfo()->findFinfo( "enzDest" ) ) );
*/
@@ -142,11 +142,11 @@ const Cinfo* CplxEnzBase::initCinfo()
&cplx, // SharedFinfo
};
- static string doc[] =
+ static string doc[] =
{
"Name", "CplxEnzBase",
"Author", "Upi Bhalla",
- "Description:",
+ "Description:",
"Base class for mass-action enzymes in which there is an "
" explicit pool for the enzyme-substrate complex. "
"It models the reaction: "
@@ -264,7 +264,7 @@ void CplxEnzBase::zombify( Element* orig, const Cinfo* zClass, Id solver )
vector< double > kcat( num, 0.0 );
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const CplxEnzBase* ceb =
+ const CplxEnzBase* ceb =
reinterpret_cast< const CplxEnzBase* >( er.data() );
concK1[ i ] = ceb->getConcK1( er );
k2[ i ] = ceb->getK2( er );
diff --git a/kinetics/Enz.cpp b/kinetics/Enz.cpp
index 78555394..2362c0b3 100644
--- a/kinetics/Enz.cpp
+++ b/kinetics/Enz.cpp
@@ -115,7 +115,7 @@ void Enz::vProcess( const Eref& e, ProcPtr p )
cplxOut->send( e, r1_, r3_ + r2_ );
// cout << " proc: " << r1_ << ", " << r2_ << ", " << r3_ << endl;
-
+
r1_ = k1_;
}
@@ -181,7 +181,7 @@ double Enz::vGetKcat( const Eref& e ) const
void Enz::vSetKm( const Eref& e, double v )
{
Km_ = v;
- double volScale =
+ double volScale =
convertConcToNumRateUsingMesh( e, subOut, 1 );
k1_ = ( k2_ + k3_ ) / ( v * volScale );
}
@@ -207,7 +207,7 @@ double Enz::vGetNumKm( const Eref& e ) const
void Enz::vSetRatio( const Eref& e, double v )
{
k2_ = v * k3_;
- double volScale =
+ double volScale =
convertConcToNumRateUsingMesh( e, subOut, 1 );
k1_ = ( k2_ + k3_ ) / ( Km_ * volScale );
@@ -237,4 +237,3 @@ double Enz::vGetConcK1( const Eref& e ) const
}
return ( k2_ + k3_ ) / Km_;
}
-
diff --git a/kinetics/EnzBase.cpp b/kinetics/EnzBase.cpp
index 76a726f1..0c4c136c 100644
--- a/kinetics/EnzBase.cpp
+++ b/kinetics/EnzBase.cpp
@@ -15,16 +15,16 @@
#define EPSILON 1e-15
static SrcFinfo2< double, double > *subOut() {
- static SrcFinfo2< double, double > subOut(
- "subOut",
+ static SrcFinfo2< double, double > subOut(
+ "subOut",
"Sends out increment of molecules on product each timestep"
);
return &subOut;
}
static SrcFinfo2< double, double > *prdOut() {
- static SrcFinfo2< double, double > prdOut(
- "prdOut",
+ static SrcFinfo2< double, double > prdOut(
+ "prdOut",
"Sends out increment of molecules on product each timestep"
);
return &prdOut;
@@ -132,7 +132,7 @@ const Cinfo* EnzBase::initCinfo()
&remesh, // Destfinfo
};
- static string doc[] =
+ static string doc[] =
{
"Name", "EnzBase",
"Author", "Upi Bhalla",
@@ -253,7 +253,7 @@ double EnzBase::getKcat( const Eref& e ) const
unsigned int EnzBase::getNumSub( const Eref& e ) const
{
- const vector< MsgFuncBinding >* mfb =
+ const vector< MsgFuncBinding >* mfb =
e.element()->getMsgAndFunc( subOut()->getBindIndex() );
assert( mfb );
return ( mfb->size() );
@@ -285,7 +285,7 @@ void EnzBase::zombify( Element* orig, const Cinfo* zClass, Id solver )
vector< double > kcat( num, 0.0 );
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const EnzBase* eb =
+ const EnzBase* eb =
reinterpret_cast< const EnzBase* >( er.data() );
kcat[ i ] = eb->getKcat( er );
Km[ i ] = eb->getKm( er );
@@ -305,4 +305,3 @@ void EnzBase::setSolver( Id solver, Id orig )
{
;
}
-
diff --git a/kinetics/Pool.cpp b/kinetics/Pool.cpp
index f39b1af8..86508cf4 100644
--- a/kinetics/Pool.cpp
+++ b/kinetics/Pool.cpp
@@ -20,21 +20,54 @@ const Cinfo* Pool::initCinfo()
//////////////////////////////////////////////////////////////
// Field Definitions: All inherited from PoolBase.
//////////////////////////////////////////////////////////////
+ static ElementValueFinfo< Pool, bool > isBuffered(
+ "isBuffered",
+ "Flag: True if Pool is buffered. This field changes the "
+ "type of the Pool object to BufPool, or vice versa. "
+ "None of the messages are affected. "
+ "This object class flip can only be done in the non-zombified "
+ "form of the Pool.",
+ &Pool::setIsBuffered,
+ &Pool::getIsBuffered
+ );
+
//////////////////////////////////////////////////////////////
- // MsgDest Definitions: All inherited
+ // MsgDest Definitions: All but increment and decrement inherited
//////////////////////////////////////////////////////////////
+ static DestFinfo increment( "increment",
+ "Increments mol numbers by specified amount. Can be +ve or -ve",
+ new OpFunc1< Pool, double >( &Pool::increment )
+ );
+
+ static DestFinfo decrement( "decrement",
+ "Decrements mol numbers by specified amount. Can be +ve or -ve",
+ new OpFunc1< Pool, double >( &Pool::decrement )
+ );
+
+ static DestFinfo nIn( "nIn",
+ "Set the number of molecules by specified amount",
+ new OpFunc1< Pool, double >( &Pool::nIn )
+ );
+
//////////////////////////////////////////////////////////////
// SrcFinfo Definitions: All inherited.
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
// SharedMsg Definitions: All inherited.
//////////////////////////////////////////////////////////////
+ static Finfo* poolFinfos[] = {
+ &isBuffered, // ElementValueFinfo
+ &increment, // DestFinfo
+ &decrement, // DestFinfo
+ &nIn, // DestFinfo
+ };
+
static Dinfo< Pool > dinfo;
static Cinfo poolCinfo (
"Pool",
PoolBase::initCinfo(),
- 0,
- 0,
+ poolFinfos,
+ sizeof( poolFinfos ) / sizeof ( Finfo* ),
&dinfo
);
@@ -45,8 +78,8 @@ const Cinfo* Pool::initCinfo()
// Class definitions
//////////////////////////////////////////////////////////////
static const Cinfo* poolCinfo = Pool::initCinfo();
-const SrcFinfo1< double >& nOut =
- *dynamic_cast< const SrcFinfo1< double >* >(
+const SrcFinfo1< double >& nOut =
+ *dynamic_cast< const SrcFinfo1< double >* >(
poolCinfo->findFinfo( "nOut" ) );
Pool::Pool()
@@ -62,13 +95,13 @@ Pool::~Pool()
/**
* setIsBuffered is a really nasty operation, made possible only because
* BufPool is derived from Pool and has no other fields.
- * It uses a low-level replaceCinfo call to just change the
+ * It uses a low-level replaceCinfo call to just change the
* identity of the Cinfo used, leaving everything else as is.
*/
-void Pool::vSetIsBuffered( const Eref& e, bool v )
+void Pool::setIsBuffered( const Eref& e, bool v )
{
static const Cinfo* bufPoolCinfo = Cinfo::find( "BufPool" );
- if (vGetIsBuffered( e ) == v)
+ if (getIsBuffered( e ) == v)
return;
if (v) {
e.element()->replaceCinfo( bufPoolCinfo );
@@ -77,11 +110,8 @@ void Pool::vSetIsBuffered( const Eref& e, bool v )
}
}
-bool Pool::vGetIsBuffered( const Eref& e ) const
+bool Pool::getIsBuffered( const Eref& e ) const
{
- /// We need this explicit check because when the moose class is
- /// flipped, the internal C++ class isn't.
- /// Inherited by BufPool.
return e.element()->cinfo()->name() == "BufPool";
}
@@ -95,6 +125,14 @@ void Pool::vProcess( const Eref& e, ProcPtr p )
{
// double A = e.sumBuf( aSlot );
// double B = e.sumBuf( bSlot );
+ /*
+ if ( n_ < 0 )
+ cout << "nugh" << e.objId().path() << endl;
+ if ( B_ < 0 )
+ cout << "bugh" << e.objId().path() << endl;
+ if ( p->dt < 0 )
+ cout << "tugh" << e.objId().path() << endl;
+ */
if ( n_ > EPSILON && B_ > EPSILON ) {
double C = exp( -B_ * p->dt / n_ );
@@ -124,7 +162,7 @@ void Pool::vReac( double A, double B )
B_ += B;
}
-void Pool::vIncrement( double val )
+void Pool::increment( double val )
{
if ( val > 0 )
A_ += val;
@@ -132,7 +170,7 @@ void Pool::vIncrement( double val )
B_ -= val;
}
-void Pool::vDecrement( double val )
+void Pool::decrement( double val )
{
if ( val < 0 )
A_ -= val;
@@ -140,13 +178,37 @@ void Pool::vDecrement( double val )
B_ += val;
}
-void Pool::vnIn( double val)
+void Pool::nIn( double val)
{
n_ = val;
B_ = 0;
A_ = 0;
}
+/*
+void Pool::vRemesh( const Eref& e,
+ double oldvol,
+ unsigned int numTotalEntries, unsigned int startEntry,
+ const vector< unsigned int >& localIndices,
+ const vector< double >& vols )
+{
+ if ( e.dataIndex() != 0 )
+ return;
+ Neutral* n = reinterpret_cast< Neutral* >( e.data() );
+ assert( vols.size() > 0 );
+ double concInit = nInit_ / ( NA * oldvol );
+ if ( vols.size() != e.element()->dataHandler()->localEntries() )
+ n->setLastDimension( e, q, vols.size() );
+ // Note that at this point the Pool pointer may be invalid!
+ // But we need to update the concs anyway.
+ assert( e.element()->dataHandler()->localEntries() == vols.size() );
+ Pool* pooldata = reinterpret_cast< Pool* >( e.data() );
+ for ( unsigned int i = 0; i < vols.size(); ++i ) {
+ pooldata[i].nInit_ = pooldata[i].n_ = concInit * vols[i] * NA;
+ }
+}
+*/
+
void Pool::vHandleMolWt( const Eref& e, double v )
{
; // Here I should update DiffConst too.
@@ -177,7 +239,7 @@ double Pool::vGetNinit( const Eref& e ) const
}
// Conc is given in millimolar. Volume is in m^3
-void Pool::vSetConc( const Eref& e, double c )
+void Pool::vSetConc( const Eref& e, double c )
{
n_ = NA * c * lookupVolumeFromMesh( e );
}
diff --git a/kinetics/Pool.h b/kinetics/Pool.h
index 4a6b2d3c..dec4dfa4 100644
--- a/kinetics/Pool.h
+++ b/kinetics/Pool.h
@@ -57,8 +57,8 @@ class Pool: public PoolBase
/**
* Functions to examine and change class between Pool and BufPool.
*/
- void vSetIsBuffered( const Eref& e, bool v );
- bool vGetIsBuffered( const Eref& e) const;
+ void setIsBuffered( const Eref& e, bool v );
+ bool getIsBuffered( const Eref& e ) const;
//////////////////////////////////////////////////////////////////
// Dest funcs. These too override virtual funcs in the Pool base
@@ -69,13 +69,13 @@ class Pool: public PoolBase
void vProcess( const Eref& e, ProcPtr p );
void vReinit( const Eref& e, ProcPtr p );
void vReac( double A, double B );
- void vIncrement( double val );
- void vDecrement( double val );
- void vnIn( double val );
//////////////////////////////////////////////////////////////////
// Novel Dest funcs not present in Pool base class.
//////////////////////////////////////////////////////////////////
+ void increment( double val );
+ void decrement( double val );
+ void nIn( double val );
//////////////////////////////////////////////////////////////////
static const Cinfo* initCinfo();
diff --git a/kinetics/PoolBase.cpp b/kinetics/PoolBase.cpp
index 0324c05e..b67e70cf 100644
--- a/kinetics/PoolBase.cpp
+++ b/kinetics/PoolBase.cpp
@@ -84,18 +84,6 @@ const Cinfo* PoolBase::initCinfo()
&PoolBase::getSpecies
);
- static ElementValueFinfo< PoolBase, bool > isBuffered(
- "isBuffered",
- "Flag: True if Pool is buffered. "
- "In the case of Pool and BufPool the field can be assigned, to "
- "change the type of the Pool object to BufPool, or vice versa. "
- "None of the messages are affected. "
- "This object class flip can only be done in the non-zombified "
- "form of the Pool/BufPool. In Zombies it is read-only.",
- &PoolBase::setIsBuffered,
- &PoolBase::getIsBuffered
- );
-
//////////////////////////////////////////////////////////////
// MsgDest Definitions
//////////////////////////////////////////////////////////////
@@ -116,36 +104,18 @@ const Cinfo* PoolBase::initCinfo()
"Should only be used in SharedMsg with species.",
new EpFunc1< PoolBase, double >( &PoolBase::handleMolWt )
);
- //////////////////////////////////////////////////////////////
- // MsgDest Definitions: These three are used for non-reaction
- // calculations involving algebraically defined rate terms.
- //////////////////////////////////////////////////////////////
- static DestFinfo increment( "increment",
- "Increments mol numbers by specified amount. Can be +ve or -ve",
- new OpFunc1< PoolBase, double >( &PoolBase::increment )
- );
-
- static DestFinfo decrement( "decrement",
- "Decrements mol numbers by specified amount. Can be +ve or -ve",
- new OpFunc1< PoolBase, double >( &PoolBase::decrement )
- );
-
- static DestFinfo nIn( "nIn",
- "Assigns the number of molecules in Pool to specified value",
- new OpFunc1< PoolBase, double >( &PoolBase::nIn )
- );
//////////////////////////////////////////////////////////////
// SrcFinfo Definitions
//////////////////////////////////////////////////////////////
- static SrcFinfo1< double > nOut(
- "nOut",
+ static SrcFinfo1< double > nOut(
+ "nOut",
"Sends out # of molecules in pool on each timestep"
);
- static SrcFinfo0 requestMolWt(
- "requestMolWt",
+ static SrcFinfo0 requestMolWt(
+ "requestMolWt",
"Requests Species object for mol wt"
);
@@ -185,16 +155,12 @@ const Cinfo* PoolBase::initCinfo()
&concInit, // Value
&volume, // Readonly Value
&speciesId, // Value
- &isBuffered, // Value
- &increment, // DestFinfo
- &decrement, // DestFinfo
- &nIn, // DestFinfo
&reac, // SharedFinfo
&proc, // SharedFinfo
&species, // SharedFinfo
};
- static string doc[] =
+ static string doc[] =
{
"Name", "PoolBase",
"Author", "Upi Bhalla",
@@ -242,21 +208,6 @@ void PoolBase::reinit( const Eref& e, ProcPtr p )
vReinit( e, p );
}
-void PoolBase::increment( double val )
-{
- vIncrement(val);
-}
-
-void PoolBase::decrement( double val )
-{
- vDecrement( val );
-}
-
-void PoolBase::nIn( double val)
-{
- vnIn(val);
-}
-
void PoolBase::reac( double A, double B )
{
vReac( A, B );
@@ -283,15 +234,6 @@ void PoolBase::vReac( double A, double B )
void PoolBase::vHandleMolWt( const Eref& e, double v )
{;}
-void PoolBase::vIncrement( double val )
-{;}
-
-void PoolBase::vDecrement( double val )
-{;}
-
-void PoolBase::vnIn( double val)
-{;}
-
//////////////////////////////////////////////////////////////
// Field Definitions
//////////////////////////////////////////////////////////////
@@ -318,7 +260,7 @@ double PoolBase::getNinit( const Eref& e ) const
}
// Conc is given in millimolar. Volume is in m^3
-void PoolBase::setConc( const Eref& e, double c )
+void PoolBase::setConc( const Eref& e, double c )
{
vSetConc( e, c );
}
@@ -386,19 +328,6 @@ unsigned int PoolBase::getSpecies( const Eref& e ) const
return vGetSpecies( e );
}
-/**
- * setIsBuffered is active only for Pool and BufPool. Otherwise ignored.
- */
-void PoolBase::setIsBuffered( const Eref& e, bool v )
-{
- vSetIsBuffered( e, v );
-}
-
-bool PoolBase::getIsBuffered( const Eref& e ) const
-{
- return vGetIsBuffered( e );
-}
-
//////////////////////////////////////////////////////////////
// Virtual Field Definitions
//////////////////////////////////////////////////////////////
@@ -412,10 +341,6 @@ double PoolBase::vGetMotorConst(const Eref& e ) const
return 0.0;
}
-/// Dummy default function for most pool subclasses.
-void PoolBase::vSetIsBuffered( const Eref& e, bool v )
-{;}
-
//////////////////////////////////////////////////////////////
// Zombie conversion routine: Converts Pool subclasses. There
// will typically be a target specific follow-up function, for example,
@@ -423,7 +348,7 @@ void PoolBase::vSetIsBuffered( const Eref& e, bool v )
// There should also be a subsequent call to resched for the entire tree.
//////////////////////////////////////////////////////////////
// static func
-void PoolBase::zombify( Element* orig, const Cinfo* zClass,
+void PoolBase::zombify( Element* orig, const Cinfo* zClass,
Id ksolve, Id dsolve )
{
if ( orig->cinfo() == zClass )
@@ -438,7 +363,7 @@ void PoolBase::zombify( Element* orig, const Cinfo* zClass,
vector< double > motorConst( num, 0.0 );
for ( unsigned int i = 0; i < num; ++i ) {
Eref er( orig, i + start );
- const PoolBase* pb =
+ const PoolBase* pb =
reinterpret_cast< const PoolBase* >( er.data() );
species[ i ] = pb->getSpecies( er );
concInit[ i ] = pb->getConcInit( er );
diff --git a/kinetics/PoolBase.h b/kinetics/PoolBase.h
index 1bdf0a78..ace7ae86 100644
--- a/kinetics/PoolBase.h
+++ b/kinetics/PoolBase.h
@@ -68,11 +68,6 @@ class PoolBase
void setSpecies( const Eref& e, SpeciesId v );
SpeciesId getSpecies( const Eref& e ) const;
- /**
- * Functions to examine and change class between Pool and BufPool.
- */
- void setIsBuffered( const Eref& e, bool v );
- bool getIsBuffered( const Eref& e ) const;
//////////////////////////////////////////////////////////////////
// Here are the inner virtual funcs for fields.
@@ -96,9 +91,6 @@ class PoolBase
virtual void vSetVolume( const Eref& e, double v ) = 0;
virtual void vSetSpecies( const Eref& e, SpeciesId v ) = 0;
virtual SpeciesId vGetSpecies( const Eref& e ) const = 0;
- /// I put in a default empty function for vSetIsBuffered.
- virtual void vSetIsBuffered( const Eref& e, bool v );
- virtual bool vGetIsBuffered( const Eref& e) const = 0;
/**
* Assign whatever info is needed by the zombie based on the
* solver Element. Encapsulates some unpleasant field extraction,
@@ -134,9 +126,6 @@ class PoolBase
void reinit( const Eref& e, ProcPtr p );
void reac( double A, double B );
void handleMolWt( const Eref& e, double v );
- void increment( double val );
- void decrement( double val );
- void nIn( double val );
//////////////////////////////////////////////////////////////////
// Virtual Dest funcs. Most of these have a generic do-nothing
@@ -147,9 +136,6 @@ class PoolBase
virtual void vReinit( const Eref& e, ProcPtr p );
virtual void vReac( double A, double B );
virtual void vHandleMolWt( const Eref& e, double v);
- virtual void vIncrement( double val );
- virtual void vDecrement( double val );
- virtual void vnIn( double val );
//////////////////////////////////////////////////////////////////
static const Cinfo* initCinfo();
diff --git a/kinetics/Reac.cpp b/kinetics/Reac.cpp
index 2b094578..0f680cd5 100644
--- a/kinetics/Reac.cpp
+++ b/kinetics/Reac.cpp
@@ -14,6 +14,7 @@
#include "Reac.h"
#define EPSILON 1e-15
+
const Cinfo* Reac::initCinfo()
{
//////////////////////////////////////////////////////////////
diff --git a/kinetics/ReadCspace.cpp b/kinetics/ReadCspace.cpp
index de0cef3e..86b1f3f0 100644
--- a/kinetics/ReadCspace.cpp
+++ b/kinetics/ReadCspace.cpp
@@ -109,7 +109,7 @@ Id ReadCspace::readModelString( const string& model,
// SetGet2< double, unsigned int >::set( compt_, "buildDefaultMesh", 1e-18, 1 );
string temp = model.substr( pos + 1 );
pos = temp.find_first_of( " \n" );
-
+
for (unsigned long i = 0 ; i < temp.length() && i < pos; i += 5 ) {
build( temp.c_str() + i );
if ( temp[ i + 4 ] != '|' )
@@ -151,7 +151,7 @@ void ReadCspace::makePlots( double plotdt )
Id tab = shell->doCreate( "Table2", graphs, plotname, 1 );
assert( tab != Id() );
// cout << "ReadCspace made plot " << plotname << endl;
- ObjId mid = shell->doAddMsg( "Single",
+ ObjId mid = shell->doAddMsg( "Single",
tab, "requestOut", children[i], "getConc" );
assert( mid != ObjId() );
}
@@ -160,7 +160,7 @@ void ReadCspace::makePlots( double plotdt )
shell->doSetClock( 8, plotdt );
string plotpath = basepath + "/graphs/##[TYPE=Table2]";
- shell->doUseClock( plotpath, "process", 8 );
+ shell->doUseClock( plotpath, "process", 8 );
*/
}
@@ -181,33 +181,33 @@ void ReadCspace::makePlots( double plotdt )
// else if (line == "A --B--> B + C") type = 'L';
/////////////////////////////////////////////////////////////////////
-void ReadCspace::expandEnzyme(
+void ReadCspace::expandEnzyme(
const char* name, int e, int s, int p, int p2 )
{
static Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
Id enzMolId = mol_[ name[e] - 'a' ];
-
+
Id enzId = shell->doCreate( "Enz", enzMolId, name, 1 );
assert( enzId != Id() );
string cplxName = name;
cplxName += "_cplx";
Id cplxId = shell->doCreate( "Pool", enzId, cplxName, 1 );
assert( cplxId != Id() );
- ObjId ret = shell->doAddMsg( "OneToOne",
+ ObjId ret = shell->doAddMsg( "OneToOne",
enzId, "cplx", cplxId, "reac" );
- ret = shell->doAddMsg( "OneToOne",
+ ret = shell->doAddMsg( "OneToOne",
enzMolId, "reac", enzId, "enz" );
- ret = shell->doAddMsg( "OneToOne",
+ ret = shell->doAddMsg( "OneToOne",
mol_[ name[ s ] - 'a' ], "reac", enzId, "sub" );
- ret = shell->doAddMsg( "OneToOne",
+ ret = shell->doAddMsg( "OneToOne",
mol_[ name[ p ] - 'a' ], "reac", enzId, "prd" );
if ( p2 != 0 )
- ret = shell->doAddMsg( "OneToOne",
+ ret = shell->doAddMsg( "OneToOne",
mol_[ name[ p2 ] - 'a' ], "reac", enzId, "prd" );
assert( ret != ObjId() );
@@ -226,12 +226,12 @@ void ReadCspace::expandReaction( const char* name, int nm1 )
int i;
Id reacId = s->doCreate( "Reac", compt_, name, 1 );
-
+
// A is always a substrate
for (i = 0; i < nm1; i++ ) {
s->doAddMsg( "OneToOne", reacId, "sub", mol_[ name[1] - 'a' ], "reac" );
}
-
+
if ( name[0] < 'G' ) { // B is a product
s->doAddMsg( "OneToOne", reacId, "prd", mol_[ name[2] - 'a' ], "reac" );
} else { // B is a substrate
@@ -308,7 +308,7 @@ void ReadCspace::makeMolecule( char name )
unsigned int index = 1 + name - 'a';
// Put in molecule if it is a new one.
- if ( find( molseq_.begin(), molseq_.end(), index - 1 ) ==
+ if ( find( molseq_.begin(), molseq_.end(), index - 1 ) ==
molseq_.end() )
molseq_.push_back( index - 1 );
@@ -444,7 +444,7 @@ void ReadCspace::testReadModel( )
Id temp( path );
r1 = Field< double >::get( temp, "Kf");
r2 = Field< double >::get( temp, "Kb");
- assert( doubleEq( r1, i* 100 + 101 ) &&
+ assert( doubleEq( r1, i* 100 + 101 ) &&
doubleEq( r2, i * 100 + 102 ) );
}
diff --git a/kinetics/ReadKkit.cpp b/kinetics/ReadKkit.cpp
index 1c145e98..2529919a 100644
--- a/kinetics/ReadKkit.cpp
+++ b/kinetics/ReadKkit.cpp
@@ -130,7 +130,7 @@ Id makeStandardElements( Id pa, const string& modelname )
mgr = shell->doCreate( "Neutral", pa, modelname, 1, MooseGlobal );
Id kinetics( modelPath + "/kinetics" );
if ( kinetics == Id() ) {
- kinetics =
+ kinetics =
shell->doCreate( "CubeMesh", mgr, "kinetics", 1, MooseGlobal );
SetGet2< double, unsigned int >::set( kinetics, "buildDefaultMesh", 1e-15, 1 );
}
@@ -143,7 +143,7 @@ Id makeStandardElements( Id pa, const string& modelname )
Id geometry = shell->doCreate( "Neutral", mgr, "geometry", 1, MooseGlobal );
assert( geometry != Id() );
- Id groups =
+ Id groups =
shell->doCreate( "Neutral", mgr, "groups", 1, MooseGlobal );
assert( groups != Id() );
return mgr;
@@ -162,7 +162,7 @@ static void positionCompt( ObjId compt, double side, bool shiftUp )
}
}
-void makeSolverOnCompt( Shell* s, const vector< ObjId >& compts,
+void makeSolverOnCompt( Shell* s, const vector< ObjId >& compts,
bool isGsolve )
{
if ( compts.size() > 3 ) {
@@ -180,8 +180,8 @@ void makeSolverOnCompt( Shell* s, const vector< ObjId >& compts,
positionCompt( compts[0], side, true );
positionCompt( compts[2], side, false );
}
-
- for ( vector< ObjId >::const_iterator
+
+ for ( vector< ObjId >::const_iterator
i = compts.begin(); i != compts.end(); ++i ) {
string simpath = i->path() + "/##";
Id ksolve;
@@ -202,19 +202,19 @@ void makeSolverOnCompt( Shell* s, const vector< ObjId >& compts,
SetGet1< Id >::set( stoichVec[1], "buildXreacs", stoichVec[0] );
SetGet1< Id >::set( stoichVec[1], "buildXreacs", stoichVec[2] );
}
- for ( vector< Id >::iterator
+ for ( vector< Id >::iterator
i = stoichVec.begin(); i != stoichVec.end(); ++i ) {
SetGet0::set( *i, "filterXreacs" );
}
}
-void setMethod( Shell* s, Id mgr, double simdt, double plotdt,
+void setMethod( Shell* s, Id mgr, double simdt, double plotdt,
const string& method )
{
vector< ObjId > ret;
simpleWildcardFind( mgr.path() + "/#[ISA=ChemCompt]", ret );
assert( ret.size() > 0 );
-
+
Id compt( mgr.path() + "/kinetics" );
assert( compt != Id() );
string simpath2 = mgr.path() + "/##[ISA=StimulusTable]," +
@@ -224,11 +224,11 @@ void setMethod( Shell* s, Id mgr, double simdt, double plotdt,
if ( m == "rk4" ) {
cout << "Warning, not yet implemented. Using rk5 instead\n";
m = "rk5";
- }
- if ( m == "ksolve" || m == "gsl" ||
+ }
+ if ( m == "ksolve" || m == "gsl" ||
m == "rk5" || m == "rkf" || m == "rk" ) {
makeSolverOnCompt( s, ret, false );
- } else if ( m == "gssa" || m == "gsolve" ||
+ } else if ( m == "gssa" || m == "gsolve" ||
m == "gillespie" || m == "stochastic" ) {
makeSolverOnCompt( s, ret, true );
} else if ( m == "ee" || m == "neutral" ) {
@@ -257,10 +257,10 @@ void setMethod( Shell* s, Id mgr, double simdt, double plotdt,
* of parser and is likely to remain a legacy for a while.
*/
Id ReadKkit::read(
- const string& filename,
+ const string& filename,
const string& modelname,
Id pa, const string& methodArg )
-{
+{
string method = methodArg;
ifstream fin( filename.c_str() );
if (!fin){
@@ -298,7 +298,7 @@ Id ReadKkit::read(
convertParametersToConcUnits();
// s->doSetClock( 8, plotdt_ );
-
+
// string plotpath = basePath_ + "/graphs/##[TYPE=Table]," + basePath_ + "/moregraphs/##[TYPE=Table]";
// s->doUseClock( plotpath, "process", 8 );
@@ -335,7 +335,7 @@ void ReadKkit::run()
/*
string poolpath = basePath_ + "/kinetics/##[ISA=Pool]";
string reacpath = basePath_ + "/kinetics/##[ISA!=Pool]";
- string plotpath = basePath_ + "/graphs/##[TYPE=Table]," +
+ string plotpath = basePath_ + "/graphs/##[TYPE=Table]," +
basePath_ + "/moregraphs/##[TYPE=Table]";
shell_->doUseClock( reacpath, "process", 4 );
shell_->doUseClock( poolpath, "process", 5 );
@@ -362,10 +362,10 @@ void ReadKkit::dumpPlots( const string& filename )
{
// ofstream fout ( filename.c_str() );
vector< ObjId > plots;
- string plotpath = basePath_ + "/graphs/##[TYPE=Table2]," +
+ string plotpath = basePath_ + "/graphs/##[TYPE=Table2]," +
basePath_ + "/moregraphs/##[TYPE=Table2]";
wildcardFind( plotpath, plots );
- for ( vector< ObjId >::iterator
+ for ( vector< ObjId >::iterator
i = plots.begin(); i != plots.end(); ++i )
SetGet2< string, string >::set( *i, "xplot",
filename, i->element()->getName() );
@@ -388,8 +388,8 @@ void ReadKkit::innerRead( ifstream& fin )
if ( temp.length() == 0 )
continue;
pos = temp.find_last_not_of( "\t " );
- if ( pos == string::npos ) {
- // Nothing new in line, go with what was left earlier,
+ if ( pos == string::npos ) {
+ // Nothing new in line, go with what was left earlier,
// and clear out line for the next cycle.
temp = "";
clearLine = 1;
@@ -404,7 +404,7 @@ void ReadKkit::innerRead( ifstream& fin )
clearLine = 1;
}
}
-
+
pos = line.find_first_not_of( "\t " );
if ( pos == string::npos )
continue;
@@ -412,7 +412,7 @@ void ReadKkit::innerRead( ifstream& fin )
line = line.substr( pos );
if ( line.substr( 0, 2 ) == "//" )
continue;
- if ( (pos = line.find("//")) != string::npos )
+ if ( (pos = line.find("//")) != string::npos )
line = line.substr( 0, pos );
if ( line.substr( 0, 2 ) == "/*" ) {
parseMode = COMMENT;
@@ -434,15 +434,15 @@ void ReadKkit::innerRead( ifstream& fin )
parseMode = readInit( line );
}
}
-
+
/*
cout << " innerRead: " <<
- lineNum_ << " lines read, " <<
- numCompartments_ << " compartments, " <<
- numPools_ << " molecules, " <<
- numReacs_ << " reacs, " <<
- numEnz_ << " enzs, " <<
- numMMenz_ << " MM enzs, " <<
+ lineNum_ << " lines read, " <<
+ numCompartments_ << " compartments, " <<
+ numPools_ << " molecules, " <<
+ numReacs_ << " reacs, " <<
+ numEnz_ << " enzs, " <<
+ numMMenz_ << " MM enzs, " <<
numOthers_ << " others," <<
numPlot_ << " plots," <<
" PlotDt = " << plotdt_ <<
@@ -453,7 +453,7 @@ void ReadKkit::innerRead( ifstream& fin )
ReadKkit::ParseMode ReadKkit::readInit( const string& line )
{
vector< string > argv;
- chopLine( line, argv );
+ chopLine( line, argv );
if ( argv.size() < 3 )
return INIT;
@@ -505,8 +505,8 @@ ReadKkit::ParseMode ReadKkit::readInit( const string& line )
void ReadKkit::readData( const string& line )
{
vector< string > argv;
- chopLine( line, argv );
-
+ chopLine( line, argv );
+
if ( argv[0] == "simundump" )
undump( argv );
else if ( argv[0] == "addmsg" )
@@ -526,7 +526,7 @@ string ReadKkit::pathTail( const string& path, string& head ) const
string::size_type pos = path.find_last_of( "/" );
assert( pos != string::npos );
- head = basePath_ + path.substr( 0, pos );
+ head = basePath_ + path.substr( 0, pos );
return path.substr( pos + 1 );
}
@@ -535,11 +535,11 @@ string ReadKkit::cleanPath( const string& path ) const
// Could surely do this better with STL. But harder to understand.
// Harsha: Cleaned up this function
// minus was getting replaced with underscore, but in some genesis model
- // pool and reaction/Enzyme has same string name with
+ // pool and reaction/Enzyme has same string name with
// difference of minus and underscore like eIF4G_A-clx and eIF4G_A_clx,
// which later created a problem as the same name exist in moose when minus
// was replaced with underscore.
- //So replacing minus with _minus_ like I do in SBML
+ //So replacing minus with _minus_ like I do in SBML
string ret = path;
string cleanString;
for ( unsigned int i = 0; i < path.length(); ++i ) {
@@ -680,10 +680,10 @@ Id ReadKkit::buildReac( const vector< string >& args )
// the model has been created, once we know the order of each reac.
Id reac = shell_->doCreate( "Reac", pa, tail, 1 );
- reacIds_[ clean.substr( 10 ) ] = reac;
+ reacIds_[ clean.substr( 10 ) ] = reac;
// Here is another hack: The native values stored in the reac are
// Kf and Kb, in conc units. However the 'clean' values from kkit
- // are the number values numKf and numKb. In the
+ // are the number values numKf and numKb. In the
// function convertReacRatesToNumUnits we take the numKf and numKb and
// do proper conc scaling.
Field< double >::set( reac, "Kf", kf );
@@ -709,7 +709,7 @@ void ReadKkit::separateVols( Id pool, double vol )
volCategories_.push_back( temp );
}
-bool volCompare(
+bool volCompare(
const pair< unsigned int, double >& A,
const pair< unsigned int, double >& B )
{
@@ -717,7 +717,7 @@ bool volCompare(
}
// Returns the ranking of each volume. Largest is 0. This would be the
// suffix to attach to the compartment name.
-vector< unsigned int > findVolOrder( const vector< double >& vols )
+vector< unsigned int > findVolOrder( const vector< double >& vols )
{
vector< pair< unsigned int, double > > p( vols.size() );
for ( unsigned int i = 0; i < vols.size(); ++i ) {
@@ -758,7 +758,7 @@ void ReadKkit::assignPoolCompartments()
ss << "compartment_" << j;
name = ss.str();
comptId = Neutral::child( baseId_.eref(), name );
- if ( comptId == Id() )
+ if ( comptId == Id() )
comptId = shell_->doCreate( "CubeMesh", baseId_, name, 1 );
}
SetGet1< double >::set( comptId, "setVolumeNotRates",vols_[i]);
@@ -793,7 +793,7 @@ Id findParentComptOfReac( Id reac )
reac.element()->getNeighbors( subVec, subFinfo );
if ( subVec.size() == 0 ) // Dangling reaction
return Id();
- // For now just put the reac in the compt belonging to the
+ // For now just put the reac in the compt belonging to the
// first substrate
return getCompt( subVec[0] );
}
@@ -806,7 +806,7 @@ Id findParentComptOfReac( Id reac )
*/
void ReadKkit::assignReacCompartments()
{
- for ( map< string, Id >::iterator i = reacIds_.begin();
+ for ( map< string, Id >::iterator i = reacIds_.begin();
i != reacIds_.end(); ++i ) {
Id compt = findParentComptOfReac( i->second );
if ( compt != Id() ) {
@@ -845,7 +845,7 @@ void ReadKkit::assignEnzCompartments()
{
/*
Should not be needed, because the parent pool will move.
- for ( map< string, Id >::iterator i = enzIds_.begin();
+ for ( map< string, Id >::iterator i = enzIds_.begin();
i != enzIds_.end(); ++i ) {
Id compt = getCompt( Neutral::parent( i->second ).id );
if ( moveOntoCompartment_ ) {
@@ -866,7 +866,7 @@ void ReadKkit::assignMMenzCompartments()
{
/*
Should not be needed, because the parent pool will move.
- for ( map< string, Id >::iterator i = mmEnzIds_.begin();
+ for ( map< string, Id >::iterator i = mmEnzIds_.begin();
i != mmEnzIds_.end(); ++i ) {
Id compt = getCompt( Neutral::parent( i->second ).id );
if ( moveOntoCompartment_ ) {
@@ -889,13 +889,13 @@ Id ReadKkit::buildEnz( const vector< string >& args )
double k2 = atof( args[ enzMap_[ "k2" ] ].c_str() );
double k3 = atof( args[ enzMap_[ "k3" ] ].c_str() );
// double volscale = atof( args[ enzMap_[ "vol" ] ].c_str() );
- double nComplexInit =
+ double nComplexInit =
atof( args[ enzMap_[ "nComplexInit" ] ].c_str() );
// double vol = atof( args[ enzMap_[ "vol" ] ].c_str());
bool isMM = atoi( args[ enzMap_[ "usecomplex" ] ].c_str());
assert( poolVols_.find( pa ) != poolVols_.end() );
double vol = poolVols_[ pa ];
-
+
/**
* vsf is vol scale factor, which is what GENESIS stores in 'vol' field
* n = vsf * conc( uM )
@@ -907,7 +907,7 @@ Id ReadKkit::buildEnz( const vector< string >& args )
Id enz = shell_->doCreate( "MMenz", pa, tail, 1 );
assert( enz != Id () );
string mmEnzPath = clean.substr( 10 );
- mmEnzIds_[ mmEnzPath ] = enz;
+ mmEnzIds_[ mmEnzPath ] = enz;
assert( k1 > EPSILON );
double Km = ( k2 + k3 ) / k1;
@@ -922,7 +922,7 @@ Id ReadKkit::buildEnz( const vector< string >& args )
// double parentVol = Field< double >::get( pa, "volume" );
assert( enz != Id () );
string enzPath = clean.substr( 10 );
- enzIds_[ enzPath ] = enz;
+ enzIds_[ enzPath ] = enz;
// Need to figure out what to do about these. Perhaps it is OK
// to do this assignments in raw #/cell units.
@@ -939,7 +939,7 @@ Id ReadKkit::buildEnz( const vector< string >& args )
string cplxPath = enzPath + "/" + cplxName;
Id cplx = shell_->doCreate( "Pool", enz, cplxName, 1 );
assert( cplx != Id () );
- poolIds_[ cplxPath ] = cplx;
+ poolIds_[ cplxPath ] = cplx;
// Field< double >::set( cplx, "nInit", nComplexInit );
Field< double >::set( cplx, "nInit", nComplexInit );
@@ -947,9 +947,9 @@ Id ReadKkit::buildEnz( const vector< string >& args )
enzCplxMols_.push_back( pair< Id, Id >( pa, cplx ) );
separateVols( cplx, -1 ); // -1 vol is a flag to defer mesh assignment for the cplx pool.
- ObjId ret = shell_->doAddMsg( "OneToAll",
+ ObjId ret = shell_->doAddMsg( "OneToAll",
ObjId( enz, 0 ), "cplx",
- ObjId( cplx, 0 ), "reac" );
+ ObjId( cplx, 0 ), "reac" );
assert( ret != ObjId() );
@@ -969,7 +969,7 @@ Id ReadKkit::buildText( const vector< string >& args )
return text;
}
-Id ReadKkit::buildInfo( Id parent,
+Id ReadKkit::buildInfo( Id parent,
map< string, int >& m, const vector< string >& args )
{
Id info = shell_->doCreate( "Annotator", parent, "info", 1 );
@@ -982,7 +982,7 @@ Id ReadKkit::buildInfo( Id parent,
Field< double >::set( info, "x", x );
Field< double >::set( info, "y", y );
Field< string >::set( info, "color", args[ m[ "xtree_fg_req" ] ] );
- Field< string >::set( info, "textColor",
+ Field< string >::set( info, "textColor",
args[ m[ "xtree_textfg_req" ] ] );
return info;
}
@@ -1004,7 +1004,7 @@ Id ReadKkit::buildGroup( const vector< string >& args )
/**
* There is a problem with this conversion, because of the discrepancy of
- * the correct NA and the version (6e23) used in kkit. I take the
+ * the correct NA and the version (6e23) used in kkit. I take the
* concentration as authoritative, not the # of molecules. This is because
* I use conc units for the rates as well, and to use n for pools and
* conc for reactions will always introduce errors. This is still not
@@ -1020,7 +1020,7 @@ Id ReadKkit::buildPool( const vector< string >& args )
assert( pa != Id() );
double nInit = atof( args[ poolMap_[ "nInit" ] ].c_str() );
- double vsf = atof( args[ poolMap_[ "vol" ] ].c_str() );
+ double vsf = atof( args[ poolMap_[ "vol" ] ].c_str() );
/**
* vsf is vol scale factor, which is what GENESIS stores in 'vol' field
* n = vsf * conc( uM )
@@ -1031,9 +1031,9 @@ Id ReadKkit::buildPool( const vector< string >& args )
int slaveEnable = atoi( args[ poolMap_[ "slave_enable" ] ].c_str() );
double diffConst = atof( args[ poolMap_[ "DiffConst" ] ].c_str() );
- // I used -ve D as a flag to replace pool-specific D
+ // I used -ve D as a flag to replace pool-specific D
// with the global value of D. Here we just ignore it.
- if ( diffConst < 0 )
+ if ( diffConst < 0 )
diffConst = 0;
Id pool;
@@ -1044,14 +1044,14 @@ Id ReadKkit::buildPool( const vector< string >& args )
} else {
pool = shell_->doCreate( "Pool", pa, tail, 1 );
/*
- cout << "ReadKkit::buildPool: Unknown slave_enable flag '" <<
+ cout << "ReadKkit::buildPool: Unknown slave_enable flag '" <<
slaveEnable << "' on " << clean << "\n";
*/
poolFlags_[pool] = slaveEnable;
}
assert( pool != Id() );
// skip the 10 chars of "/kinetics/"
- poolIds_[ clean.substr( 10 ) ] = pool;
+ poolIds_[ clean.substr( 10 ) ] = pool;
Field< double >::set( pool, "nInit", nInit );
Field< double >::set( pool, "diffConst", diffConst );
@@ -1062,8 +1062,8 @@ Id ReadKkit::buildPool( const vector< string >& args )
Id info = buildInfo( pool, poolMap_, args );
/*
- cout << setw( 20 ) << head << setw( 15 ) << tail << " " <<
- setw( 12 ) << nInit << " " <<
+ cout << setw( 20 ) << head << setw( 15 ) << tail << " " <<
+ setw( 12 ) << nInit << " " <<
vol << " " << diffConst << " " <<
slaveEnable << endl;
*/
@@ -1072,13 +1072,13 @@ Id ReadKkit::buildPool( const vector< string >& args )
}
/**
- * Finds the source pool for a SumTot. It also deals with cases where
+ * Finds the source pool for a SumTot. It also deals with cases where
* the source is an enz-substrate complex
*/
Id ReadKkit::findSumTotSrc( const string& src )
{
map< string, Id >::iterator i = poolIds_.find( src );
- if ( i != poolIds_.end() ) {
+ if ( i != poolIds_.end() ) {
return i->second;
}
i = enzIds_.find( src );
@@ -1086,7 +1086,7 @@ Id ReadKkit::findSumTotSrc( const string& src )
string head;
string cplx = src + '/' + pathTail( src, head ) + "_cplx";
i = poolIds_.find( cplx );
- if ( i != poolIds_.end() ) {
+ if ( i != poolIds_.end() ) {
return i->second;
}
}
@@ -1100,7 +1100,7 @@ void ReadKkit::buildSumTotal( const string& src, const string& dest )
map< string, Id >::iterator i = poolIds_.find( dest );
assert( i != poolIds_.end() );
Id destId = i->second;
-
+
Id sumId;
// Check if the pool has not yet been converted to handle SumTots.
if ( destId.element()->cinfo()->name() == "Pool" ) {
@@ -1108,9 +1108,9 @@ void ReadKkit::buildSumTotal( const string& src, const string& dest )
// Turn dest into a FuncPool.
destId.element()->zombieSwap( BufPool::initCinfo() );
- ObjId ret = shell_->doAddMsg( "single",
+ ObjId ret = shell_->doAddMsg( "single",
ObjId( sumId, 0 ), "valueOut",
- ObjId( destId, 0 ), "setN" );
+ ObjId( destId, 0 ), "setN" );
assert( ret != ObjId() );
} else {
sumId = Neutral::child( destId.eref(), "func" );
@@ -1121,15 +1121,15 @@ void ReadKkit::buildSumTotal( const string& src, const string& dest )
<< dest << "'\n";
return;
}
-
+
Id srcId = findSumTotSrc( src );
unsigned int numVars = Field< unsigned int >::get( sumId, "numVars" );
ObjId xi( sumId.value() + 1, 0, numVars );
Field< unsigned int >::set( sumId, "numVars", numVars + 1 );
- ObjId ret = shell_->doAddMsg( "single",
+ ObjId ret = shell_->doAddMsg( "single",
ObjId( srcId, 0 ), "nOut",
- xi, "input" );
+ xi, "input" );
assert( ret != ObjId() );
@@ -1152,12 +1152,12 @@ Id ReadKkit::buildStim( const vector< string >& args )
Id pa = shell_->doFind( head ).id;
assert( pa != Id() );
- double level1 = atof( args[ stimMap_[ "firstLevel" ] ].c_str() );
- double width1 = atof( args[ stimMap_[ "firstWidth" ] ].c_str() );
- double delay1 = atof( args[ stimMap_[ "firstDelay" ] ].c_str() );
- double level2 = atof( args[ stimMap_[ "secondLevel" ] ].c_str() );
- double width2 = atof( args[ stimMap_[ "secondWidth" ] ].c_str() );
- double delay2 = atof( args[ stimMap_[ "secondLevel" ] ].c_str() );
+ double level1 = atof( args[ stimMap_[ "firstLevel" ] ].c_str() );
+ double width1 = atof( args[ stimMap_[ "firstWidth" ] ].c_str() );
+ double delay1 = atof( args[ stimMap_[ "firstDelay" ] ].c_str() );
+ double level2 = atof( args[ stimMap_[ "secondLevel" ] ].c_str() );
+ double width2 = atof( args[ stimMap_[ "secondWidth" ] ].c_str() );
+ double delay2 = atof( args[ stimMap_[ "secondLevel" ] ].c_str() );
double baselevel = atof( args[ stimMap_[ "baseLevel" ] ].c_str() );
Id stim = shell_->doCreate( "PulseGen", pa, tail, 1 );
@@ -1195,7 +1195,7 @@ Id ReadKkit::buildChan( const vector< string >& args )
chanIds_[ chanPath ] = chan;
return chan;
}
-
+
Id ReadKkit::buildGeometry( const vector< string >& args )
{
@@ -1231,7 +1231,7 @@ Id ReadKkit::buildPlot( const vector< string >& args )
assert( plot != Id() );
temp = graph + "/" + tail;
- plotIds_[ temp ] = plot;
+ plotIds_[ temp ] = plot;
numPlot_++;
return plot;
@@ -1267,7 +1267,7 @@ Id ReadKkit::buildTable( const vector< string >& args )
string temp = clean.substr( 10 );
- tabIds_[ temp ] = tab;
+ tabIds_[ temp ] = tab;
Id info = buildInfo( tab, tableMap_, args );
@@ -1306,14 +1306,14 @@ unsigned int ReadKkit::loadTab( const vector< string >& args )
Field< vector< double > >::set( tab, "vector", tabEntries_ );
// cout << "Loading table for " << args[0] << "," << args[1] << "," << clean << endl;
-
+
if ( args[1] == "-end" )
lastTab_ = Id();
return 0;
}
-void ReadKkit::innerAddMsg(
+void ReadKkit::innerAddMsg(
const string& src, const map< string, Id >& m1, const string& srcMsg,
const string& dest, const map< string, Id >& m2, const string& destMsg,
bool isBackward )
@@ -1328,14 +1328,14 @@ void ReadKkit::innerAddMsg(
// dest pool is substrate of src reac
if ( isBackward ) {
- ObjId ret = shell_->doAddMsg( "AllToOne",
+ ObjId ret = shell_->doAddMsg( "AllToOne",
ObjId( srcId, 0 ), srcMsg,
- ObjId( destId, 0 ), destMsg );
+ ObjId( destId, 0 ), destMsg );
assert( ret != ObjId() );
} else {
- ObjId ret = shell_->doAddMsg( "OneToAll",
+ ObjId ret = shell_->doAddMsg( "OneToAll",
ObjId( srcId, 0 ), srcMsg,
- ObjId( destId, 0 ), destMsg );
+ ObjId( destId, 0 ), destMsg );
assert( ret != ObjId() );
}
}
@@ -1345,7 +1345,7 @@ void ReadKkit::addmsg( const vector< string >& args)
{
string src = cleanPath( args[1] ).substr( 10 );
string dest = cleanPath( args[2] ).substr( 10 );
-
+
if ( args[3] == "REAC" ) {
if ( args[4] == "A" && args[5] == "B" ) {
// Ignore kchans
@@ -1353,7 +1353,7 @@ void ReadKkit::addmsg( const vector< string >& args)
; // found a kchan, do nothing
else
innerAddMsg( src, reacIds_, "sub", dest, poolIds_, "reac");
- }
+ }
else if ( args[4] == "B" && args[5] == "A" ) {
// Ignore kchans
if ( chanIds_.find( src ) != chanIds_.end() )
@@ -1410,7 +1410,7 @@ void ReadKkit::addmsg( const vector< string >& args)
return;
}
vector< Id > enzcplx;
- i->second.element()->getNeighbors( enzcplx,
+ i->second.element()->getNeighbors( enzcplx,
i->second.element()->cinfo()->findFinfo( "cplxOut" ) );
assert( enzcplx.size() == 1 );
pool = enzcplx[0];
@@ -1461,7 +1461,7 @@ void ReadKkit::setupSlaveMsg( const string& src, const string& dest )
nameMap = &stimIds_;
output = "output";
} else {
- cout << "Error: Unknown source for SLAVE msg: (" << src <<
+ cout << "Error: Unknown source for SLAVE msg: (" << src <<
", " << dest << ")\n";
return;
}
@@ -1469,7 +1469,7 @@ void ReadKkit::setupSlaveMsg( const string& src, const string& dest )
// NSLAVE is 1, CONCSLAVE is 2.
map< Id, int >::iterator i = poolFlags_.find( destId );
if ( i == poolFlags_.end() || !( i->second & 2 ) ) {
- innerAddMsg( src, *nameMap, output, dest, poolIds_,
+ innerAddMsg( src, *nameMap, output, dest, poolIds_,
"setNInit" );
} else {
innerAddMsg( src, *nameMap, output, dest, poolIds_,
@@ -1510,7 +1510,7 @@ void ReadKkit::convertParametersToConcUnits()
void ReadKkit::convertPoolAmountToConcUnits()
{
const double NA_RATIO = KKIT_NA / NA;
- for ( map< string, Id >::iterator i = poolIds_.begin();
+ for ( map< string, Id >::iterator i = poolIds_.begin();
i != poolIds_.end(); ++i ) {
Id pool = i->second;
double nInit = Field< double >::get( pool, "nInit" );
@@ -1526,7 +1526,7 @@ void ReadKkit::convertPoolAmountToConcUnits()
void ReadKkit::convertReacRatesToConcUnits()
{
const double NA_RATIO = KKIT_NA / NA;
- for ( map< string, Id >::iterator i = reacIds_.begin();
+ for ( map< string, Id >::iterator i = reacIds_.begin();
i != reacIds_.end(); ++i ) {
Id reac = i->second;
double kf = Field< double >::get( reac, "Kf" );
@@ -1537,9 +1537,9 @@ void ReadKkit::convertReacRatesToConcUnits()
// At this point the kf and kb are off because the
// NA for kkit is not accurate. So we correct for this.
- unsigned int numSub =
+ unsigned int numSub =
Field< unsigned int >::get( reac, "numSubstrates" );
- unsigned int numPrd =
+ unsigned int numPrd =
Field< unsigned int >::get( reac, "numProducts" );
if ( numSub > 1 )
@@ -1548,7 +1548,7 @@ void ReadKkit::convertReacRatesToConcUnits()
if ( numPrd > 1 )
kb *= pow( NA_RATIO, numPrd - 1.0 );
- // Now we have the correct numKf and numKb, plug them into the
+ // Now we have the correct numKf and numKb, plug them into the
// reac, and let it internally fix up the Kf and Kb.
Field< double >::set( reac, "numKf", kf );
Field< double >::set( reac, "numKb", kb );
@@ -1558,17 +1558,17 @@ void ReadKkit::convertReacRatesToConcUnits()
void ReadKkit::convertMMenzRatesToConcUnits()
{
const double NA_RATIO = KKIT_NA / NA;
- for ( map< string, Id >::iterator i = mmEnzIds_.begin();
+ for ( map< string, Id >::iterator i = mmEnzIds_.begin();
i != mmEnzIds_.end(); ++i ) {
Id enz = i->second;
// This was set in the original # units.
double numKm = Field< double >::get( enz, "Km" );
// At this point the numKm is inaaccurate because the
// NA for kkit is not accurate. So we correct for this.
- double numSub =
+ double numSub =
Field< unsigned int >::get( enz, "numSubstrates" );
// Note that we always have the enz itself as a substrate term.
- if ( numSub > 0 )
+ if ( numSub > 0 )
numKm *= pow( NA_RATIO, -numSub );
// Now we have the correct numKm, plug it into the MMenz, and
@@ -1584,16 +1584,16 @@ void ReadKkit::convertMMenzRatesToConcUnits()
void ReadKkit::convertEnzRatesToConcUnits()
{
const double NA_RATIO = KKIT_NA / NA;
- for ( map< string, Id >::iterator i = enzIds_.begin();
+ for ( map< string, Id >::iterator i = enzIds_.begin();
i != enzIds_.end(); ++i ) {
Id enz = i->second;
double k1 = Field< double >::get( enz, "k1" );
// At this point the k1 is inaaccurate because the
// NA for kkit is not accurate. So we correct for this.
- double numSub =
+ double numSub =
Field< unsigned int >::get( enz, "numSubstrates" );
// Note that we always have the enz itself as a substrate term.
- if ( numSub > 0 )
+ if ( numSub > 0 )
k1 *= pow( NA_RATIO, numSub );
Field< double >::set( enz, "k1", k1 );
}
diff --git a/kinetics/WriteKkit.cpp b/kinetics/WriteKkit.cpp
index 6546c9d4..0f8533c0 100644
--- a/kinetics/WriteKkit.cpp
+++ b/kinetics/WriteKkit.cpp
@@ -25,13 +25,13 @@
#include <set>
-void writeHeader( ofstream& fout,
+void writeHeader( ofstream& fout,
double simdt, double plotdt, double maxtime, double defaultVol)
{
time_t rawtime;
time( &rawtime );
- fout <<
+ fout <<
"//genesis\n"
"// kkit Version 11 flat dumpfile\n\n";
fout << "// Saved on " << ctime( &rawtime ) << endl;
@@ -48,7 +48,7 @@ void writeHeader( ofstream& fout,
"setfield /file/modpath value ~/scripts/modules\n"
"kparms\n\n";
- fout <<
+ fout <<
"initdump -version 3 -ignoreorphans 1\n"
"simobjdump table input output alloced step_mode stepsize x y z\n"
"simobjdump xtree path script namemode sizescale\n"
@@ -77,7 +77,7 @@ void writeHeader( ofstream& fout,
}
string trimPath(Id id, Id comptid)
-{
+{
string msgpath = Field <string> :: get(id,"path");
ObjId compartment(msgpath);
string path1;
@@ -95,7 +95,7 @@ string trimPath(Id id, Id comptid)
else
{
path1 = msgpath;
-
+
}
}
else
@@ -130,9 +130,9 @@ void writeEnz( ofstream& fout, Id id,
double x, double y, Id comptid )
{
string path = id.path();
- string comptname = Field < string > :: get(comptid,"name");
+ string comptname = Field < string > :: get(comptid,"name");
string poolpath = trimPath(id,comptid);
-
+
double k1 = 0;
double k2 = 0;
@@ -143,7 +143,7 @@ void writeEnz( ofstream& fout, Id id,
double conc = 0;
Id enzMol = getEnzMol( id );
assert( enzMol != Id() );
- double vol = Field< double >::get( enzMol, "volume" ) * NA * 1e-3;
+ double vol = Field< double >::get( enzMol, "volume" ) * NA * 1e-3;
unsigned int isMichaelisMenten = 0;
string enzClass = Field < string > :: get(id,"className");
if (enzClass == "ZombieMMenz" or enzClass == "MMenz")
@@ -164,9 +164,9 @@ void writeEnz( ofstream& fout, Id id,
concInit = Field< double >::get( cplx, "concInit" );
conc = Field< double >::get( cplx, "conc" );
}
- fout << "simundump kenz /kinetics" << poolpath << " 0 " <<
+ fout << "simundump kenz /kinetics" << poolpath << " 0 " <<
concInit << " " <<
- conc << " " <<
+ conc << " " <<
nInit << " " <<
n << " " <<
vol << " " <<
@@ -175,8 +175,8 @@ void writeEnz( ofstream& fout, Id id,
k3 << " " <<
0 << " " <<
isMichaelisMenten << " " <<
- "\"\"" << " " <<
- colour << " " << textcolour << " \"\"" <<
+ "\"\"" << " " <<
+ colour << " " << textcolour << " \"\"" <<
" " << x << " " << y << " 0\n";
}
@@ -188,21 +188,21 @@ void writeReac( ofstream& fout, Id id,
string reacname = Field<string> :: get(id, "name");
double kf = Field< double >::get( id, "numKf" );
double kb = Field< double >::get( id, "numKb" );
-
- unsigned int numSub =
+
+ unsigned int numSub =
Field< unsigned int >::get( id, "numSubstrates" );
- unsigned int numPrd =
+ unsigned int numPrd =
Field< unsigned int >::get( id, "numProducts" );
- fout << "simundump kreac /kinetics" << trimPath(id,comptid) << " 0 " <<
- kf << " " << kb << " \"\" " <<
+ fout << "simundump kreac /kinetics" << trimPath(id,comptid) << " 0 " <<
+ kf << " " << kb << " \"\" " <<
colour << " " << textcolour << " " << x << " " << y << " 0\n";
}
unsigned int getSlaveEnable( Id id )
{
- static const Finfo* setNinitFinfo =
+ static const Finfo* setNinitFinfo =
PoolBase::initCinfo()->findFinfo( "set_nInit" );
- static const Finfo* setConcInitFinfo =
+ static const Finfo* setConcInitFinfo =
PoolBase::initCinfo()->findFinfo( "set_concInit" );
unsigned int ret = 0;
vector< Id > src;
@@ -219,7 +219,7 @@ unsigned int getSlaveEnable( Id id )
return 4; // Just simple buffered molecule
if ( src[0].element()->cinfo()->isA( "StimulusTable" ) )
return ret; // Following a table, this is fine.
-
+
// Fallback: I have no idea what sent it the input, assume it is legit.
return ret;
}
@@ -243,7 +243,7 @@ void writePool( ofstream& fout, Id id,
{ vector< Id > children = Field< vector< Id > >::get( id, "children" );
if (children.size() == 0)
slave_enable = 4;
- for ( vector< Id >::iterator i = children.begin(); i != children.end(); ++i )
+ for ( vector< Id >::iterator i = children.begin(); i != children.end(); ++i )
{ string funcpath = Field <string> :: get(*i,"path");
string clsname = Field <string> :: get(*i,"className");
if (clsname == "Function" or clsname == "ZombieFunction")
@@ -252,13 +252,13 @@ void writePool( ofstream& fout, Id id,
slave_enable = 4;
}
- }
+ }
if (comptIndex > 0)
geometryTemp << "/geometry[" << comptIndex <<"]";
else
geometryTemp << "/geometry";
- // simobjdump kpool DiffConst CoInit Co n nInit mwt nMin vol slave_enable
+ // simobjdump kpool DiffConst CoInit Co n nInit mwt nMin vol slave_enable
fout << "simundump kpool /kinetics" << trimPath(id,comptid) << " 0 " <<
diffConst << " " <<
@@ -270,21 +270,21 @@ void writePool( ofstream& fout, Id id,
volume * NA * 1e-3 << " " << // volscale
slave_enable << //GENESIS FIELD HERE.
" /kinetics"<< geometryTemp.str() << " " <<
- colour << " " << textcolour << " " << x << " " << y << " 0\n";
+ colour << " " << textcolour << " " << x << " " << y << " 0\n";
}
void writePlot( ofstream& fout, Id id,
string colour, string textcolour,
double x, double y )
-{
+{
string path = id.path();
size_t pos = path.find( "/graphs" );
- if ( pos == string::npos )
+ if ( pos == string::npos )
pos = path.find( "/moregraphs" );
- if ( pos == string::npos )
+ if ( pos == string::npos )
return;
path = path.substr( pos );
- fout << "simundump xplot " << path << " 3 524288 \\\n" <<
- "\"delete_plot.w <s> <d>; edit_plot.D <w>\" " << textcolour << " 0 0 1\n";
+ fout << "simundump xplot " << path << " 3 524288 \\\n" <<
+ "\"delete_plot.w <s> <d>; edit_plot.D <w>\" " << textcolour << " 0 0 1\n";
}
void writeGui( ofstream& fout )
@@ -313,7 +313,7 @@ void storeMMenzMsgs( Id enz, vector< string >& msgs, Id comptid )
vector < Id > srct = LookupField <string,vector < Id> >::get(enz, "neighbors","sub");
for (vector <Id> :: iterator rsub = srct.begin();rsub != srct.end();rsub++)
- {
+ {
string s = "addmsg /kinetics" + trimPath(*rsub, comptid) + " /kinetics" + trimPath(enz, comptid) + " SUBSTRATE n";
msgs.push_back( s );
s = "addmsg /kinetics" + trimPath(enz, comptid) + " /kinetics" + trimPath( *rsub, comptid ) + " REAC sA B";
@@ -340,7 +340,7 @@ void storeCplxEnzMsgs( Id enz, vector< string >& msgs, Id comptid )
vector < Id > srct = LookupField <string,vector < Id> >::get(enz, "neighbors","sub");
for (vector <Id> :: iterator rsub = srct.begin();rsub != srct.end();rsub++)
- {
+ {
string s = "addmsg /kinetics" + trimPath(*rsub, comptid) + " /kinetics" + trimPath(enz, comptid) + " SUBSTRATE n";
msgs.push_back( s );
s = "addmsg /kinetics" + trimPath(enz, comptid) + " /kinetics" + trimPath( *rsub, comptid ) + " REAC sA B";
@@ -372,7 +372,7 @@ void storeEnzMsgs( Id enz, vector< string >& msgs, Id comptid )
}
void storeReacMsgs( Id reac, vector< string >& msgs, Id comptid )
-{
+{
vector < Id > srct = LookupField <string,vector < Id> >::get(reac, "neighbors","sub");
for (vector <Id> :: iterator rsub = srct.begin();rsub != srct.end();rsub++)
{ string s = "addmsg /kinetics" + trimPath(*rsub, comptid) + " /kinetics" + trimPath(reac, comptid) + " SUBSTRATE n";
@@ -401,7 +401,7 @@ void storeFunctionMsgs( Id func, vector< string >& msgs,map < double, pair<Id, i
string poolParent = Field <string> :: get(compt_vol[poolvol].first,"name");
Id xi(func.value()+1);
vector < Id > func_input = LookupField <string,vector < Id> >::get(xi, "neighbors","input");
-
+
for (vector <Id> :: iterator funcIp = func_input.begin();funcIp != func_input.end();funcIp++)
{ string funcIp_path = Field < string > :: get(*funcIp,"path");
double vol = Field < double > :: get(*funcIp,"Volume");
@@ -419,17 +419,17 @@ void storePlotMsgs( Id tab, vector< string >& msgs, Id pool, string bg, Id compt
string poolName = Field <string> :: get(pool,"name");
size_t pos = tabPath.find( "/graphs" );
- if ( pos == string::npos )
+ if ( pos == string::npos )
pos = tabPath.find( "/moregraphs" );
assert( pos != string::npos );
tabPath = tabPath.substr( pos );
- string s = "addmsg /kinetics" + trimPath( poolPath, comptid) + " " + tabPath +
+ string s = "addmsg /kinetics" + trimPath( poolPath, comptid) + " " + tabPath +
" PLOT Co *" + poolName + " *" + bg;
msgs.push_back( s );
}
/**
- * A bunch of heuristics to find good SimTimes to use for kkit.
+ * A bunch of heuristics to find good SimTimes to use for kkit.
* Returns runTime.
*/
double estimateSimTimes( double& simDt, double& plotDt )
@@ -437,9 +437,9 @@ double estimateSimTimes( double& simDt, double& plotDt )
double runTime = Field< double >::get( Id( 1 ), "runTime" );
if ( runTime <= 0 )
runTime = 100.0;
- vector< double > dts =
+ vector< double > dts =
Field< vector< double> >::get( Id( 1 ), "dts" );
-
+
simDt = dts[11];
plotDt = dts[18];
cout << "estimatesimtimes" << simDt << plotDt;
@@ -456,18 +456,18 @@ double estimateSimTimes( double& simDt, double& plotDt )
/// Returns an estimate of the default volume used in the model.
double estimateDefaultVol( Id model )
{
- vector< Id > children =
+ vector< Id > children =
Field< vector< Id > >::get( model, "children" );
vector< double > vols;
double maxVol = 0;
- for ( vector< Id >::iterator i = children.begin();
+ for ( vector< Id >::iterator i = children.begin();
i != children.end(); ++i ) {
if ( i->element()->cinfo()->isA( "ChemCompt" ) ) {
double v = Field< double >::get( *i, "volume" );
if ( i->element()->getName() == "kinetics" )
return v;
vols.push_back( v );
- if ( maxVol < v )
+ if ( maxVol < v )
maxVol = v;
}
}
@@ -482,19 +482,19 @@ void writeMsgs( ofstream& fout, const vector< string >& msgs )
fout << *i << endl;
}
void writeGroup(ofstream& fout,Id model)
-{
+{
vector < ObjId> group;
int x = 10;
int y = 20;
int num = wildcardFind( model.path() + "/##[TYPE=Neutral]", group );
for ( vector< ObjId >::iterator itr = group.begin(); itr != group.end();itr++)
- {
+ {
string path = Field<string>::get(*itr,"path");
size_t pos = path.find( "/kinetics" );
if (pos != std::string::npos)
{
path = path.substr( pos );
- fout << "simundump group " << path << " 0 " <<
+ fout << "simundump group " << path << " 0 " <<
"blue" << " " << "green" << " x 0 0 \"\" defaultfile \\\n";
fout << " defaultfile.g 0 0 0 " << x << " " << y << " 0\n";
}
@@ -514,17 +514,17 @@ void writeKkit( Id model, const string& fname )
string fg = "black";
double x = 0;
double y = 0;
-
+
map < double, pair<Id, int> > compt_vol;
-
+
unsigned int num = wildcardFind( model.path() + "/##[ISA=ChemCompt]", chemCompt );
if ( num == 0 ) {
- cout << "Warning: writeKkit:: No model found on " << model <<
+ cout << "Warning: writeKkit:: No model found on " << model <<
endl;
return;
}
for ( vector< ObjId >::iterator itr = chemCompt.begin(); itr != chemCompt.end();itr++)
- {
+ {
vector < unsigned int>dims;
unsigned int dims_size;
dims_size = 1;
@@ -533,7 +533,7 @@ void writeKkit( Id model, const string& fname )
string comptname = Field<string>::get(*itr,"name");
if (comptname != "kinetics")
{
- fout << "simundump group /kinetics/" << comptname << " 0 " <<
+ fout << "simundump group /kinetics/" << comptname << " 0 " <<
"blue" << " " << "green" << " x 0 0 \"\" defaultfile \\\n";
fout << " defaultfile.g 0 0 0 " << rand() % 10 + 1 << " " << rand() % 10 + 1 << " 0\n";
}
@@ -544,8 +544,8 @@ void writeKkit( Id model, const string& fname )
if (vecIndex > 0)
geometry << "simundump geometry /kinetics" << "/geometry[" << vecIndex <<"] 0 " << size << " " << ndim << " sphere " <<" \"\" white black 0 0 0\n";
else
- geometry << "simundump geometry /kinetics" << "/geometry 0 " << size << " " << ndim << " sphere " <<" \"\" white black 0 0 0\n";
- fout << geometry.str();
+ geometry << "simundump geometry /kinetics" << "/geometry 0 " << size << " " << ndim << " sphere " <<" \"\" white black 0 0 0\n";
+ fout << geometry.str();
compt_vol.insert(make_pair(size,make_pair(*itr,vecIndex)));
} // compartmentclose
writeGroup(fout, model);
@@ -553,7 +553,7 @@ void writeKkit( Id model, const string& fname )
for (compt = compt_vol.begin(); compt != compt_vol.end(); compt++)
{
string comptPath = Field<string>::get(compt->second.first,"path");
- // Species
+ // Species
vector< ObjId > Compt_spe;
wildcardFind(comptPath+"/##[ISA=PoolBase]",Compt_spe);
int species_size = 1;
@@ -578,11 +578,11 @@ void writeKkit( Id model, const string& fname )
for (vector <ObjId> :: iterator itrF= Compt_Func.begin();itrF != Compt_Func.end();itrF++)
{ storeFunctionMsgs( *itrF, msgs,compt_vol);
}
- // Reaction
+ // Reaction
vector< ObjId > Compt_Reac;
wildcardFind(comptPath+"/##[ISA=ReacBase]",Compt_Reac);
for (vector <ObjId> :: iterator itrR= Compt_Reac.begin();itrR != Compt_Reac.end();itrR++)
- {
+ {
string path = Field<string> :: get(*itrR,"path");
Id annotaId( path+"/info");
string noteClass = Field<string> :: get(annotaId,"className");
@@ -608,7 +608,7 @@ void writeKkit( Id model, const string& fname )
writeEnz( fout, *itrE, bg, fg, x, y, compt->second.first);
storeEnzMsgs( *itrE, msgs, compt->second.first);
}// reaction
-
+
} //compatment loop
writeGui ( fout);
@@ -623,7 +623,7 @@ void writeKkit( Id model, const string& fname )
{ string path = Field <string> :: get(*tabItem,"path");
double vol = Field < double> :: get (*tabItem,"Volume");
//Trying to find the compartment name via volume
- //otherwise if we go via parent, sometimes it might
+ //otherwise if we go via parent, sometimes it might
// get groupname so maped compartment Id and volume
Id parentId = compt_vol[vol].first;
diff --git a/kinetics/lookupVolumeFromMesh.cpp b/kinetics/lookupVolumeFromMesh.cpp
index 0b4e7ec3..84f9ebf9 100644
--- a/kinetics/lookupVolumeFromMesh.cpp
+++ b/kinetics/lookupVolumeFromMesh.cpp
@@ -46,21 +46,21 @@ double lookupVolumeFromMesh( const Eref& e )
* Figures out all the volumes of the substrates or products on the
* specified reaction 'reac'. The SrcFinfo is for the sub or prd msg.
* Returns the index of the smallest vol. Passes back a vector of volumes.
- * The meshIndex is zero. Reasoning is as follows: both in the case of
+ * The meshIndex is zero. Reasoning is as follows: both in the case of
* well-stirred (single mesh entry) models, and in the case of spatial
- * models with consistent mesh sizes and alignments, the mesh entry
+ * models with consistent mesh sizes and alignments, the mesh entry
* volumes are in the same ratio.
* Cases with more complex arrangements may also use the current vols as
* a starting point, but will need to add index-specific scaling factors
* to their reaction system.
*/
-unsigned int getReactantVols( const Eref& reac, const SrcFinfo* pools,
+unsigned int getReactantVols( const Eref& reac, const SrcFinfo* pools,
vector< double >& vols )
{
static const unsigned int meshIndex = 0;
- const vector< MsgFuncBinding >* mfb =
+ const vector< MsgFuncBinding >* mfb =
reac.element()->getMsgAndFunc( pools->getBindIndex() );
unsigned int smallIndex = 0;
@@ -88,22 +88,22 @@ unsigned int getReactantVols( const Eref& reac, const SrcFinfo* pools,
}
/**
- * Returns conversion factor to convert rates from concentration to
+ * Returns conversion factor to convert rates from concentration to
* mol# units.
* Handles arbitrary combinations of volumes.
- * Assumes that the reference volume for computing rates is the
+ * Assumes that the reference volume for computing rates is the
* smallest volume.
* 26 Feb 2013: This is now changed to use the volume of the first entry.
* Should only be used for substrates. For products need to find the
* first substrate, separately, and use that to scale down the conv factor.
* Assumes all calculations are in SI: cubic metres and millimolar.
- * 27 Feb 2013: This is changed to use the volume of a voxel of the
+ * 27 Feb 2013: This is changed to use the volume of a voxel of the
* the home compartment of the reac.
* Be warned: this can cause unexpected problems if the home compartment
- * isn't according to convention. For example, if there is a single
+ * isn't according to convention. For example, if there is a single
* substrate and the home compartment is elsewhere, you will get very odd
* Kf:kf values.
- * 9 Oct 2013: This is now changed to use the volume of the first
+ * 9 Oct 2013: This is now changed to use the volume of the first
* substrate. Note that if the conversion is for products, then the
* routine has to look up the substrate list to get the first substrate.
* Reason is that the home compartment was often wrong in ReadKkit.
@@ -111,7 +111,7 @@ unsigned int getReactantVols( const Eref& reac, const SrcFinfo* pools,
* conventions they use for cross-compartment reactions.
*/
-double convertConcToNumRateUsingMesh( const Eref& e, const SrcFinfo* pools,
+double convertConcToNumRateUsingMesh( const Eref& e, const SrcFinfo* pools,
bool doPartialConversion )
{
vector< double > vols;
@@ -157,10 +157,10 @@ double convertConcToNumRateUsingMesh( const Eref& e, const SrcFinfo* pools,
* This variant already knows the volume, but has to figure out # of
* reactants.
*/
-double convertConcToNumRateUsingVol( const Eref& e, const SrcFinfo* pools,
+double convertConcToNumRateUsingVol( const Eref& e, const SrcFinfo* pools,
double volume, double scale, bool doPartialConversion )
{
- const vector< MsgFuncBinding >* mfb =
+ const vector< MsgFuncBinding >* mfb =
e.element()->getMsgAndFunc( pools->getBindIndex() );
double conversion = 1.0;
if ( mfb && mfb->size() > 0 ) {
@@ -171,7 +171,7 @@ double convertConcToNumRateUsingVol( const Eref& e, const SrcFinfo* pools,
conversion = pow( conversion, power );
}
}
- if ( conversion <= 0 )
+ if ( conversion <= 0 )
conversion = 1.0;
}
@@ -184,7 +184,7 @@ double convertConcToNumRateUsingVol( const Eref& e, const SrcFinfo* pools,
* or mesh entries, and may therefore have different volumes.
* We already know the reactants and their affiliations.
*/
-double convertConcToNumRateInTwoCompts( double v1, unsigned int n1,
+double convertConcToNumRateInTwoCompts( double v1, unsigned int n1,
double v2, unsigned int n2, double scale )
{
double conversion = 1.0;
@@ -194,7 +194,7 @@ double convertConcToNumRateInTwoCompts( double v1, unsigned int n1,
for ( unsigned int i = 0; i < n2; ++i )
conversion *= scale * NA * v2;
- if ( conversion <= 0 )
+ if ( conversion <= 0 )
conversion = 1.0;
return conversion;
diff --git a/ksolve/Gsolve.cpp b/ksolve/Gsolve.cpp
index 736ca1f8..a1c576ac 100644
--- a/ksolve/Gsolve.cpp
+++ b/ksolve/Gsolve.cpp
@@ -30,199 +30,195 @@
const unsigned int OFFNODE = ~0;
// static function
-SrcFinfo2< Id, vector< double > >* Gsolve::xComptOut()
-{
- static SrcFinfo2< Id, vector< double > > xComptOut( "xComptOut",
- "Sends 'n' of all molecules participating in cross-compartment "
- "reactions between any juxtaposed voxels between current compt "
- "and another compartment. This includes molecules local to this "
- "compartment, as well as proxy molecules belonging elsewhere. "
- "A(t+1) = (Alocal(t+1) + AremoteProxy(t+1)) - Alocal(t) "
- "A(t+1) = (Aremote(t+1) + Aproxy(t+1)) - Aproxy(t) "
- "Then we update A on the respective solvers with: "
- "Alocal(t+1) = Aproxy(t+1) = A(t+1) "
- "This is equivalent to sending dA over on each timestep. "
- );
- return &xComptOut;
+SrcFinfo2< Id, vector< double > >* Gsolve::xComptOut() {
+ static SrcFinfo2< Id, vector< double > > xComptOut( "xComptOut",
+ "Sends 'n' of all molecules participating in cross-compartment "
+ "reactions between any juxtaposed voxels between current compt "
+ "and another compartment. This includes molecules local to this "
+ "compartment, as well as proxy molecules belonging elsewhere. "
+ "A(t+1) = (Alocal(t+1) + AremoteProxy(t+1)) - Alocal(t) "
+ "A(t+1) = (Aremote(t+1) + Aproxy(t+1)) - Aproxy(t) "
+ "Then we update A on the respective solvers with: "
+ "Alocal(t+1) = Aproxy(t+1) = A(t+1) "
+ "This is equivalent to sending dA over on each timestep. "
+ );
+ return &xComptOut;
}
const Cinfo* Gsolve::initCinfo()
{
- ///////////////////////////////////////////////////////
- // Field definitions
- ///////////////////////////////////////////////////////
-
- static ValueFinfo< Gsolve, Id > stoich (
- "stoich",
- "Stoichiometry object for handling this reaction system.",
- &Gsolve::setStoich,
- &Gsolve::getStoich
- );
-
- static ValueFinfo< Gsolve, Id > compartment (
- "compartment",
- "Compartment that contains this reaction system.",
- &Gsolve::setCompartment,
- &Gsolve::getCompartment
- );
-
- static ReadOnlyValueFinfo< Gsolve, unsigned int > numLocalVoxels(
- "numLocalVoxels",
- "Number of voxels in the core reac-diff system, on the "
- "current solver. ",
- &Gsolve::getNumLocalVoxels
- );
- static LookupValueFinfo<
- Gsolve, unsigned int, vector< double > > nVec(
- "nVec",
- "vector of pool counts",
- &Gsolve::setNvec,
- &Gsolve::getNvec
- );
- static ValueFinfo< Gsolve, unsigned int > numAllVoxels(
- "numAllVoxels",
- "Number of voxels in the entire reac-diff system, "
- "including proxy voxels to represent abutting compartments.",
- &Gsolve::setNumAllVoxels,
- &Gsolve::getNumAllVoxels
- );
-
- static ValueFinfo< Gsolve, unsigned int > numPools(
- "numPools",
- "Number of molecular pools in the entire reac-diff system, "
- "including variable, function and buffered.",
- &Gsolve::setNumPools,
- &Gsolve::getNumPools
- );
-
- static ValueFinfo< Gsolve, bool > useRandInit(
- "useRandInit",
- "Flag: True when using probabilistic (random) rounding.\n "
- "Default: True.\n "
- "When initializing the mol# from floating-point Sinit values, "
- "we have two options. One is to look at each Sinit, and round "
- "to the nearest integer. The other is to look at each Sinit, "
- "and probabilistically round up or down depending on the "
- "value. For example, if we had a Sinit value of 1.49, "
- "this would always be rounded to 1.0 if the flag is false, "
- "and would be rounded to 1.0 and 2.0 in the ratio 51:49 if "
- "the flag is true. ",
- &Gsolve::setRandInit,
- &Gsolve::getRandInit
- );
-
- static ValueFinfo< Gsolve, bool > useClockedUpdate(
- "useClockedUpdate",
- "Flag: True to cause all reaction propensities to be updated "
- "on every clock tick.\n"
- "Default: False.\n"
- "This flag should be set when the reaction system "
- "includes a function with a dependency on time or on external "
- "events. It has a significant speed penalty so the flag "
- "should not be set unless there are such functions. " ,
- &Gsolve::setClockedUpdate,
- &Gsolve::getClockedUpdate
- );
- static ReadOnlyLookupValueFinfo<
- Gsolve, unsigned int, vector< unsigned int > > numFire(
- "numFire",
- "Vector of the number of times each reaction has fired."
- "Indexed by the voxel number."
- "Zeroed out at reinit.",
- &Gsolve::getNumFire
- );
-
- ///////////////////////////////////////////////////////
- // DestFinfo definitions
- ///////////////////////////////////////////////////////
-
- static DestFinfo process( "process",
- "Handles process call",
- new ProcOpFunc< Gsolve >( &Gsolve::process ) );
- static DestFinfo reinit( "reinit",
- "Handles reinit call",
- new ProcOpFunc< Gsolve >( &Gsolve::reinit ) );
-
- static DestFinfo voxelVol( "voxelVol",
- "Handles updates to all voxels. Comes from parent "
- "ChemCompt object.",
- new OpFunc1< Gsolve, vector< double > >(
- &Gsolve::updateVoxelVol )
- );
-
- static DestFinfo initProc( "initProc",
- "Handles initProc call from Clock",
- new ProcOpFunc< Gsolve >( &Gsolve::initProc ) );
- static DestFinfo initReinit( "initReinit",
- "Handles initReinit call from Clock",
- new ProcOpFunc< Gsolve >( &Gsolve::initReinit ) );
-
- static DestFinfo xComptIn( "xComptIn",
- "Handles arriving pool 'n' values used in cross-compartment "
- "reactions.",
- new EpFunc2< Gsolve, Id, vector< double > >( &Gsolve::xComptIn )
- );
- ///////////////////////////////////////////////////////
- // Shared definitions
- ///////////////////////////////////////////////////////
- static Finfo* procShared[] =
- {
- &process, &reinit
- };
- static SharedFinfo proc( "proc",
- "Shared message for process and reinit",
- procShared, sizeof( procShared ) / sizeof( const Finfo* )
- );
-
- static Finfo* initShared[] =
- {
- &initProc, &initReinit
- };
- static SharedFinfo init( "init",
- "Shared message for initProc and initReinit. This is used"
- " when the system has cross-compartment reactions. ",
- initShared, sizeof( initShared ) / sizeof( const Finfo* )
- );
-
- static Finfo* xComptShared[] =
- {
- xComptOut(), &xComptIn
- };
- static SharedFinfo xCompt( "xCompt",
- "Shared message for pool exchange for cross-compartment "
- "reactions. Exchanges latest values of all pools that "
- "participate in such reactions.",
- xComptShared, sizeof( xComptShared ) / sizeof( const Finfo* )
- );
- ///////////////////////////////////////////////////////
-
- static Finfo* gsolveFinfos[] =
- {
- &stoich, // Value
- &numLocalVoxels, // ReadOnlyValue
- &nVec, // LookupValue
- &numAllVoxels, // ReadOnlyValue
- &numPools, // Value
- &voxelVol, // DestFinfo
- &proc, // SharedFinfo
- &init, // SharedFinfo
- &xCompt, // SharedFinfo
- // Here we put new fields that were not there in the Ksolve.
- &useRandInit, // Value
- &useClockedUpdate, // Value
- &numFire, // ReadOnlyLookupValue
- };
-
- static Dinfo< Gsolve > dinfo;
- static Cinfo gsolveCinfo(
- "Gsolve",
- Neutral::initCinfo(),
- gsolveFinfos,
- sizeof(gsolveFinfos)/sizeof(Finfo *),
- &dinfo
- );
-
- return &gsolveCinfo;
+ ///////////////////////////////////////////////////////
+ // Field definitions
+ ///////////////////////////////////////////////////////
+
+ static ValueFinfo< Gsolve, Id > stoich (
+ "stoich",
+ "Stoichiometry object for handling this reaction system.",
+ &Gsolve::setStoich,
+ &Gsolve::getStoich
+ );
+
+ static ValueFinfo< Gsolve, Id > compartment (
+ "compartment",
+ "Compartment that contains this reaction system.",
+ &Gsolve::setCompartment,
+ &Gsolve::getCompartment
+ );
+
+ static ReadOnlyValueFinfo< Gsolve, unsigned int > numLocalVoxels(
+ "numLocalVoxels",
+ "Number of voxels in the core reac-diff system, on the "
+ "current solver. ",
+ &Gsolve::getNumLocalVoxels
+ );
+ static LookupValueFinfo<
+ Gsolve, unsigned int, vector< double > > nVec(
+ "nVec",
+ "vector of pool counts",
+ &Gsolve::setNvec,
+ &Gsolve::getNvec
+ );
+ static ValueFinfo< Gsolve, unsigned int > numAllVoxels(
+ "numAllVoxels",
+ "Number of voxels in the entire reac-diff system, "
+ "including proxy voxels to represent abutting compartments.",
+ &Gsolve::setNumAllVoxels,
+ &Gsolve::getNumAllVoxels
+ );
+
+ static ValueFinfo< Gsolve, unsigned int > numPools(
+ "numPools",
+ "Number of molecular pools in the entire reac-diff system, "
+ "including variable, function and buffered.",
+ &Gsolve::setNumPools,
+ &Gsolve::getNumPools
+ );
+
+ static ValueFinfo< Gsolve, bool > useRandInit(
+ "useRandInit",
+ "Flag: True when using probabilistic (random) rounding.\n "
+ "Default: True.\n "
+ "When initializing the mol# from floating-point Sinit values, "
+ "we have two options. One is to look at each Sinit, and round "
+ "to the nearest integer. The other is to look at each Sinit, "
+ "and probabilistically round up or down depending on the "
+ "value. For example, if we had a Sinit value of 1.49, "
+ "this would always be rounded to 1.0 if the flag is false, "
+ "and would be rounded to 1.0 and 2.0 in the ratio 51:49 if "
+ "the flag is true. ",
+ &Gsolve::setRandInit,
+ &Gsolve::getRandInit
+ );
+
+ static ValueFinfo< Gsolve, bool > useClockedUpdate(
+ "useClockedUpdate",
+ "Flag: True to cause all reaction propensities to be updated "
+ "on every clock tick.\n"
+ "Default: False.\n"
+ "This flag should be set when the reaction system "
+ "includes a function with a dependency on time or on external "
+ "events. It has a significant speed penalty so the flag "
+ "should not be set unless there are such functions. " ,
+ &Gsolve::setClockedUpdate,
+ &Gsolve::getClockedUpdate
+ );
+ static ReadOnlyLookupValueFinfo<
+ Gsolve, unsigned int, vector< unsigned int > > numFire(
+ "numFire",
+ "Vector of the number of times each reaction has fired."
+ "Indexed by the voxel number."
+ "Zeroed out at reinit.",
+ &Gsolve::getNumFire
+ );
+
+ ///////////////////////////////////////////////////////
+ // DestFinfo definitions
+ ///////////////////////////////////////////////////////
+
+ static DestFinfo process( "process",
+ "Handles process call",
+ new ProcOpFunc< Gsolve >( &Gsolve::process ) );
+ static DestFinfo reinit( "reinit",
+ "Handles reinit call",
+ new ProcOpFunc< Gsolve >( &Gsolve::reinit ) );
+
+ static DestFinfo voxelVol( "voxelVol",
+ "Handles updates to all voxels. Comes from parent "
+ "ChemCompt object.",
+ new OpFunc1< Gsolve, vector< double > >(
+ &Gsolve::updateVoxelVol )
+ );
+
+ static DestFinfo initProc( "initProc",
+ "Handles initProc call from Clock",
+ new ProcOpFunc< Gsolve >( &Gsolve::initProc ) );
+ static DestFinfo initReinit( "initReinit",
+ "Handles initReinit call from Clock",
+ new ProcOpFunc< Gsolve >( &Gsolve::initReinit ) );
+
+ static DestFinfo xComptIn( "xComptIn",
+ "Handles arriving pool 'n' values used in cross-compartment "
+ "reactions.",
+ new EpFunc2< Gsolve, Id, vector< double > >( &Gsolve::xComptIn )
+ );
+ ///////////////////////////////////////////////////////
+ // Shared definitions
+ ///////////////////////////////////////////////////////
+ static Finfo* procShared[] = {
+ &process, &reinit
+ };
+ static SharedFinfo proc( "proc",
+ "Shared message for process and reinit",
+ procShared, sizeof( procShared ) / sizeof( const Finfo* )
+ );
+
+ static Finfo* initShared[] = {
+ &initProc, &initReinit
+ };
+ static SharedFinfo init( "init",
+ "Shared message for initProc and initReinit. This is used"
+ " when the system has cross-compartment reactions. ",
+ initShared, sizeof( initShared ) / sizeof( const Finfo* )
+ );
+
+ static Finfo* xComptShared[] = {
+ xComptOut(), &xComptIn
+ };
+ static SharedFinfo xCompt( "xCompt",
+ "Shared message for pool exchange for cross-compartment "
+ "reactions. Exchanges latest values of all pools that "
+ "participate in such reactions.",
+ xComptShared, sizeof( xComptShared ) / sizeof( const Finfo* )
+ );
+ ///////////////////////////////////////////////////////
+
+ static Finfo* gsolveFinfos[] =
+ {
+ &stoich, // Value
+ &numLocalVoxels, // ReadOnlyValue
+ &nVec, // LookupValue
+ &numAllVoxels, // ReadOnlyValue
+ &numPools, // Value
+ &voxelVol, // DestFinfo
+ &proc, // SharedFinfo
+ &init, // SharedFinfo
+ &xCompt, // SharedFinfo
+ // Here we put new fields that were not there in the Ksolve.
+ &useRandInit, // Value
+ &useClockedUpdate, // Value
+ &numFire, // ReadOnlyLookupValue
+ };
+
+ static Dinfo< Gsolve > dinfo;
+ static Cinfo gsolveCinfo(
+ "Gsolve",
+ Neutral::initCinfo(),
+ gsolveFinfos,
+ sizeof(gsolveFinfos)/sizeof(Finfo *),
+ &dinfo
+ );
+
+ return &gsolveCinfo;
}
static const Cinfo* gsolveCinfo = Gsolve::initCinfo();
@@ -232,20 +228,16 @@ static const Cinfo* gsolveCinfo = Gsolve::initCinfo();
//////////////////////////////////////////////////////////////
Gsolve::Gsolve()
- :
- pools_( 1 ),
- startVoxel_( 0 ),
- dsolve_(),
- dsolvePtr_( 0 ),
- useClockedUpdate_( false )
-{
- ;
-}
+ :
+ pools_( 1 ),
+ startVoxel_( 0 ),
+ dsolve_(),
+ dsolvePtr_( 0 ),
+ useClockedUpdate_( false )
+{;}
Gsolve::~Gsolve()
-{
- ;
-}
+{;}
//////////////////////////////////////////////////////////////
// Field Access functions
@@ -253,131 +245,121 @@ Gsolve::~Gsolve()
Id Gsolve::getStoich() const
{
- return stoich_;
+ return stoich_;
}
void Gsolve::setCompartment( Id compt )
{
- if ( ( compt.element()->cinfo()->isA( "ChemCompt" ) ) )
- {
- compartment_ = compt;
- vector< double > vols =
- Field< vector< double > >::get( compt, "voxelVolume" );
- if ( vols.size() > 0 )
- {
- pools_.resize( vols.size() );
- for ( unsigned int i = 0; i < vols.size(); ++i )
- {
- pools_[i].setVolume( vols[i] );
- }
- }
- }
+ if ( ( compt.element()->cinfo()->isA( "ChemCompt" ) ) ) {
+ compartment_ = compt;
+ vector< double > vols =
+ Field< vector< double > >::get( compt, "voxelVolume" );
+ if ( vols.size() > 0 ) {
+ pools_.resize( vols.size() );
+ for ( unsigned int i = 0; i < vols.size(); ++i ) {
+ pools_[i].setVolume( vols[i] );
+ }
+ }
+ }
}
Id Gsolve::getCompartment() const
{
- return compartment_;
+ return compartment_;
}
void Gsolve::setStoich( Id stoich )
{
- // This call is done _before_ setting the path on stoich
- assert( stoich.element()->cinfo()->isA( "Stoich" ) );
- stoich_ = stoich;
- stoichPtr_ = reinterpret_cast< Stoich* >( stoich.eref().data() );
- if ( stoichPtr_->getNumAllPools() == 0 )
- {
- stoichPtr_ = 0;
- return;
- }
- sys_.stoich = stoichPtr_;
- sys_.isReady = false;
- for ( unsigned int i = 0; i < pools_.size(); ++i )
- pools_[i].setStoich( stoichPtr_ );
+ // This call is done _before_ setting the path on stoich
+ assert( stoich.element()->cinfo()->isA( "Stoich" ) );
+ stoich_ = stoich;
+ stoichPtr_ = reinterpret_cast< Stoich* >( stoich.eref().data() );
+ if ( stoichPtr_->getNumAllPools() == 0 ) {
+ stoichPtr_ = 0;
+ return;
+ }
+ sys_.stoich = stoichPtr_;
+ sys_.isReady = false;
+ for ( unsigned int i = 0; i < pools_.size(); ++i )
+ pools_[i].setStoich( stoichPtr_ );
}
unsigned int Gsolve::getNumLocalVoxels() const
{
- return pools_.size();
+ return pools_.size();
}
unsigned int Gsolve::getNumAllVoxels() const
{
- return pools_.size(); // Need to redo.
+ return pools_.size(); // Need to redo.
}
// If we're going to do this, should be done before the zombification.
void Gsolve::setNumAllVoxels( unsigned int numVoxels )
{
- if ( numVoxels == 0 )
- {
- return;
- }
- pools_.resize( numVoxels );
- sys_.isReady = false;
+ if ( numVoxels == 0 ) {
+ return;
+ }
+ pools_.resize( numVoxels );
+ sys_.isReady = false;
}
vector< double > Gsolve::getNvec( unsigned int voxel) const
{
- static vector< double > dummy;
- if ( voxel < pools_.size() )
- {
- return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->Svec();
- }
- return dummy;
+ static vector< double > dummy;
+ if ( voxel < pools_.size() ) {
+ return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->Svec();
+ }
+ return dummy;
}
void Gsolve::setNvec( unsigned int voxel, vector< double > nVec )
{
- if ( voxel < pools_.size() )
- {
- if ( nVec.size() != pools_[voxel].size() )
- {
- cout << "Warning: Gsolve::setNvec: size mismatch ( " <<
- nVec.size() << ", " << pools_[voxel].size() << ")\n";
- return;
- }
- double* s = pools_[voxel].varS();
- for ( unsigned int i = 0; i < nVec.size(); ++i )
- {
- s[i] = round( nVec[i] );
- if ( s[i] < 0.0 )
- s[i] = 0.0;
- }
- if ( sys_.isReady )
- pools_[voxel].refreshAtot( &sys_ );
- }
+ if ( voxel < pools_.size() ) {
+ if ( nVec.size() != pools_[voxel].size() ) {
+ cout << "Warning: Gsolve::setNvec: size mismatch ( " <<
+ nVec.size() << ", " << pools_[voxel].size() << ")\n";
+ return;
+ }
+ double* s = pools_[voxel].varS();
+ for ( unsigned int i = 0; i < nVec.size(); ++i ) {
+ s[i] = round( nVec[i] );
+ if ( s[i] < 0.0 )
+ s[i] = 0.0;
+ }
+ if ( sys_.isReady )
+ pools_[voxel].refreshAtot( &sys_ );
+ }
}
vector< unsigned int > Gsolve::getNumFire( unsigned int voxel) const
{
- static vector< unsigned int > dummy;
- if ( voxel < pools_.size() )
- {
- return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->numFire();
- }
- return dummy;
+ static vector< unsigned int > dummy;
+ if ( voxel < pools_.size() ) {
+ return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->numFire();
+ }
+ return dummy;
}
bool Gsolve::getRandInit() const
{
- return sys_.useRandInit;
+ return sys_.useRandInit;
}
void Gsolve::setRandInit( bool val )
{
- sys_.useRandInit = val;
+ sys_.useRandInit = val;
}
bool Gsolve::getClockedUpdate() const
{
- return useClockedUpdate_;
+ return useClockedUpdate_;
}
void Gsolve::setClockedUpdate( bool val )
{
- useClockedUpdate_ = val;
+ useClockedUpdate_ = val;
}
//////////////////////////////////////////////////////////////
@@ -385,143 +367,122 @@ void Gsolve::setClockedUpdate( bool val )
//////////////////////////////////////////////////////////////
void Gsolve::process( const Eref& e, ProcPtr p )
{
- // cout << stoichPtr_ << " dsolve = " << dsolvePtr_ << endl;
- if ( !stoichPtr_ )
- return;
-
- // First, handle incoming diffusion values. Note potential for
- // issues with roundoff if diffusion is not integral.
- if ( dsolvePtr_ )
- {
- vector< double > dvalues( 4 );
- dvalues[0] = 0;
- dvalues[1] = getNumLocalVoxels();
- dvalues[2] = 0;
- dvalues[3] = stoichPtr_->getNumVarPools();
- dsolvePtr_->getBlock( dvalues );
-
- // Here we need to convert to integers, just in case. Normally
- // one would use a stochastic (integral) diffusion method with
- // the GSSA, but in mixed models it may be more complicated.
- vector< double >::iterator i = dvalues.begin() + 4;
-
- for ( ; i != dvalues.end(); ++i )
- {
- // cout << *i << " " << round( *i ) << " ";
+ // cout << stoichPtr_ << " dsolve = " << dsolvePtr_ << endl;
+ if ( !stoichPtr_ )
+ return;
+ // First, handle incoming diffusion values. Note potential for
+ // issues with roundoff if diffusion is not integral.
+ if ( dsolvePtr_ ) {
+ vector< double > dvalues( 4 );
+ dvalues[0] = 0;
+ dvalues[1] = getNumLocalVoxels();
+ dvalues[2] = 0;
+ dvalues[3] = stoichPtr_->getNumVarPools();
+ dsolvePtr_->getBlock( dvalues );
+ // Here we need to convert to integers, just in case. Normally
+ // one would use a stochastic (integral) diffusion method with
+ // the GSSA, but in mixed models it may be more complicated.
+ vector< double >::iterator i = dvalues.begin() + 4;
+ for ( ; i != dvalues.end(); ++i ) {
+ // cout << *i << " " << round( *i ) << " ";
#if SIMPLE_ROUNDING
- *i = round( *i );
+ *i = round( *i );
#else
- double base = floor( *i );
- if ( mtrand() >= (*i - base) )
- *i = base;
- else
- *i = base + 1.0;
+ double base = floor( *i );
+ if ( mtrand() > *i - base )
+ *i = base;
+ else
+ *i = base + 1.0;
#endif
- }
- setBlock( dvalues );
- }
- // Second, take the arrived xCompt reac values and update S with them.
- // Here the roundoff issues are handled by the GssaVoxelPools functions
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- XferInfo& xf = xfer_[i];
- // cout << xfer_.size() << " " << xf.xferVoxel.size() << endl;
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- pools_[xf.xferVoxel[j]].xferIn( xf, j, &sys_ );
- }
- }
- // Third, record the current value of pools as the reference for the
- // next cycle.
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- XferInfo& xf = xfer_[i];
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- pools_[xf.xferVoxel[j]].xferOut( j, xf.lastValues, xf.xferPoolIdx );
- }
- }
-
- // Fourth: Fix the rates if we have had any diffusion or xreacs
- // happening. This is very inefficient at this point, need to fix.
- if ( dsolvePtr_ || xfer_.size() > 0 )
- {
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->refreshAtot( &sys_ );
- }
- }
- // Fifth, update the mol #s.
- // First we advance the simulation.
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->advance( p, &sys_ );
- }
- if ( useClockedUpdate_ ) // Check if a clocked stim is to be updated
- {
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->recalcTime( &sys_, p->currTime );
- }
- }
-
- // Finally, assemble and send the integrated values off for the Dsolve.
- if ( dsolvePtr_ )
- {
- vector< double > kvalues( 4 );
- kvalues[0] = 0;
- kvalues[1] = getNumLocalVoxels();
- kvalues[2] = 0;
- kvalues[3] = stoichPtr_->getNumVarPools();
- getBlock( kvalues );
- dsolvePtr_->setBlock( kvalues );
- }
+ }
+ setBlock( dvalues );
+ }
+ // Second, take the arrived xCompt reac values and update S with them.
+ // Here the roundoff issues are handled by the GssaVoxelPools functions
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ XferInfo& xf = xfer_[i];
+ // cout << xfer_.size() << " " << xf.xferVoxel.size() << endl;
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ pools_[xf.xferVoxel[j]].xferIn( xf, j, &sys_ );
+ }
+ }
+ // Third, record the current value of pools as the reference for the
+ // next cycle.
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ XferInfo& xf = xfer_[i];
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ pools_[xf.xferVoxel[j]].xferOut( j, xf.lastValues, xf.xferPoolIdx );
+ }
+ }
+
+ // Fourth: Fix the rates if we have had any diffusion or xreacs
+ // happening. This is very inefficient at this point, need to fix.
+ if ( dsolvePtr_ || xfer_.size() > 0 ) {
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->refreshAtot( &sys_ );
+ }
+ }
+ // Fifth, update the mol #s.
+ // First we advance the simulation.
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->advance( p, &sys_ );
+ }
+ if ( useClockedUpdate_ ) { // Check if a clocked stim is to be updated
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->recalcTime( &sys_, p->currTime );
+ }
+ }
+
+ // Finally, assemble and send the integrated values off for the Dsolve.
+ if ( dsolvePtr_ ) {
+ vector< double > kvalues( 4 );
+ kvalues[0] = 0;
+ kvalues[1] = getNumLocalVoxels();
+ kvalues[2] = 0;
+ kvalues[3] = stoichPtr_->getNumVarPools();
+ getBlock( kvalues );
+ dsolvePtr_->setBlock( kvalues );
+ }
}
void Gsolve::reinit( const Eref& e, ProcPtr p )
{
- if ( !stoichPtr_ )
- return;
- if ( !sys_.isReady )
- rebuildGssaSystem();
- // First reinit concs.
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->reinit( &sys_ );
- }
-
- // Second, take the arrived xCompt reac values and update S with them.
- // Here the roundoff issues are handled by the GssaVoxelPools functions
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- const XferInfo& xf = xfer_[i];
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- pools_[xf.xferVoxel[j]].xferInOnlyProxies(
- xf.xferPoolIdx, xf.values,
- stoichPtr_->getNumProxyPools(), j );
- }
- }
- // Third, record the current value of pools as the reference for the
- // next cycle.
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- XferInfo& xf = xfer_[i];
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- pools_[xf.xferVoxel[j]].xferOut( j, xf.lastValues, xf.xferPoolIdx );
- }
- }
- // Fourth, update the atots.
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->refreshAtot( &sys_ );
- }
+ if ( !stoichPtr_ )
+ return;
+ if ( !sys_.isReady )
+ rebuildGssaSystem();
+ // First reinit concs.
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->reinit( &sys_ );
+ }
+
+ // Second, take the arrived xCompt reac values and update S with them.
+ // Here the roundoff issues are handled by the GssaVoxelPools functions
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ const XferInfo& xf = xfer_[i];
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ pools_[xf.xferVoxel[j]].xferInOnlyProxies(
+ xf.xferPoolIdx, xf.values,
+ stoichPtr_->getNumProxyPools(), j );
+ }
+ }
+ // Third, record the current value of pools as the reference for the
+ // next cycle.
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ XferInfo& xf = xfer_[i];
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ pools_[xf.xferVoxel[j]].xferOut( j, xf.lastValues, xf.xferPoolIdx );
+ }
+ }
+ // Fourth, update the atots.
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->refreshAtot( &sys_ );
+ }
}
//////////////////////////////////////////////////////////////
@@ -529,46 +490,41 @@ void Gsolve::reinit( const Eref& e, ProcPtr p )
//////////////////////////////////////////////////////////////
void Gsolve::initProc( const Eref& e, ProcPtr p )
{
- if ( !stoichPtr_ )
- return;
- // vector< vector< double > > values( xfer_.size() );
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- XferInfo& xf = xfer_[i];
- unsigned int size = xf.xferPoolIdx.size() * xf.xferVoxel.size();
- // values[i].resize( size, 0.0 );
- vector< double > values( size, 0.0 );
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- unsigned int vox = xf.xferVoxel[j];
- pools_[vox].xferOut( j, values, xf.xferPoolIdx );
- }
- xComptOut()->sendTo( e, xf.ksolve, e.id(), values );
- }
+ if ( !stoichPtr_ )
+ return;
+ // vector< vector< double > > values( xfer_.size() );
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ XferInfo& xf = xfer_[i];
+ unsigned int size = xf.xferPoolIdx.size() * xf.xferVoxel.size();
+ // values[i].resize( size, 0.0 );
+ vector< double > values( size, 0.0 );
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ unsigned int vox = xf.xferVoxel[j];
+ pools_[vox].xferOut( j, values, xf.xferPoolIdx );
+ }
+ xComptOut()->sendTo( e, xf.ksolve, e.id(), values );
+ }
}
void Gsolve::initReinit( const Eref& e, ProcPtr p )
{
- if ( !stoichPtr_ )
- return;
- for ( unsigned int i = 0 ; i < pools_.size(); ++i )
- {
- pools_[i].reinit( &sys_ );
- }
- // vector< vector< double > > values( xfer_.size() );
- for ( unsigned int i = 0; i < xfer_.size(); ++i )
- {
- XferInfo& xf = xfer_[i];
- unsigned int size = xf.xferPoolIdx.size() * xf.xferVoxel.size();
- xf.lastValues.assign( size, 0.0 );
- for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j )
- {
- unsigned int vox = xf.xferVoxel[j];
- pools_[ vox ].xferOut( j, xf.lastValues, xf.xferPoolIdx );
- // values[i] = xf.lastValues;
- }
- xComptOut()->sendTo( e, xf.ksolve, e.id(), xf.lastValues );
- }
+ if ( !stoichPtr_ )
+ return;
+ for ( unsigned int i = 0 ; i < pools_.size(); ++i ) {
+ pools_[i].reinit( &sys_ );
+ }
+ // vector< vector< double > > values( xfer_.size() );
+ for ( unsigned int i = 0; i < xfer_.size(); ++i ) {
+ XferInfo& xf = xfer_[i];
+ unsigned int size = xf.xferPoolIdx.size() * xf.xferVoxel.size();
+ xf.lastValues.assign( size, 0.0 );
+ for ( unsigned int j = 0; j < xf.xferVoxel.size(); ++j ) {
+ unsigned int vox = xf.xferVoxel[j];
+ pools_[ vox ].xferOut( j, xf.lastValues, xf.xferPoolIdx );
+ // values[i] = xf.lastValues;
+ }
+ xComptOut()->sendTo( e, xf.ksolve, e.id(), xf.lastValues );
+ }
}
//////////////////////////////////////////////////////////////
// Solver setup
@@ -576,28 +532,26 @@ void Gsolve::initReinit( const Eref& e, ProcPtr p )
void Gsolve::rebuildGssaSystem()
{
- stoichPtr_->convertRatesToStochasticForm();
- sys_.transposeN = stoichPtr_->getStoichiometryMatrix();
- sys_.transposeN.transpose();
- sys_.transposeN.truncateRow( stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() );
- vector< vector< unsigned int > > & dep = sys_.dependency;
- dep.resize( stoichPtr_->getNumRates() );
- for ( unsigned int i = 0; i < stoichPtr_->getNumRates(); ++i )
- {
- sys_.transposeN.getGillespieDependence( i, dep[i] );
- }
- fillMmEnzDep();
- fillPoolFuncDep();
- fillIncrementFuncDep();
- makeReacDepsUnique();
- for ( vector< GssaVoxelPools >::iterator
- i = pools_.begin(); i != pools_.end(); ++i )
- {
- i->setNumReac( stoichPtr_->getNumRates() );
- i->updateAllRateTerms( stoichPtr_->getRateTerms(),
- stoichPtr_->getNumCoreRates() );
- }
- sys_.isReady = true;
+ stoichPtr_->convertRatesToStochasticForm();
+ sys_.transposeN = stoichPtr_->getStoichiometryMatrix();
+ sys_.transposeN.transpose();
+ sys_.transposeN.truncateRow( stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() );
+ vector< vector< unsigned int > > & dep = sys_.dependency;
+ dep.resize( stoichPtr_->getNumRates() );
+ for ( unsigned int i = 0; i < stoichPtr_->getNumRates(); ++i ) {
+ sys_.transposeN.getGillespieDependence( i, dep[i] );
+ }
+ fillMmEnzDep();
+ fillPoolFuncDep();
+ fillIncrementFuncDep();
+ makeReacDepsUnique();
+ for ( vector< GssaVoxelPools >::iterator
+ i = pools_.begin(); i != pools_.end(); ++i ) {
+ i->setNumReac( stoichPtr_->getNumRates() );
+ i->updateAllRateTerms( stoichPtr_->getRateTerms(),
+ stoichPtr_->getNumCoreRates() );
+ }
+ sys_.isReady = true;
}
/**
@@ -608,48 +562,44 @@ void Gsolve::rebuildGssaSystem()
*/
void Gsolve::fillMmEnzDep()
{
- unsigned int numRates = stoichPtr_->getNumRates();
- vector< unsigned int > indices;
-
- // Make a map to look up enzyme RateTerm using
- // the key of the enzyme molecule.
- map< unsigned int, unsigned int > enzMolMap;
- for ( unsigned int i = 0; i < numRates; ++i )
- {
- const MMEnzymeBase* mme = dynamic_cast< const MMEnzymeBase* >(
- stoichPtr_->rates( i ) );
- if ( mme )
- {
- vector< unsigned int > reactants;
- mme->getReactants( reactants );
- if ( reactants.size() > 1 )
- enzMolMap[ reactants.front() ] = i; // front is enzyme.
- }
- }
-
- // Use the map to fill in deps.
- for ( unsigned int i = 0; i < numRates; ++i )
- {
- // Extract the row of all molecules that depend on the reac.
- const int* entry;
- const unsigned int* colIndex;
-
- unsigned int numInRow =
- sys_.transposeN.getRow( i, &entry, &colIndex );
- for( unsigned int j = 0; j < numInRow; ++j )
- {
- map< unsigned int, unsigned int >::iterator pos =
- enzMolMap.find( colIndex[j] );
- if ( pos != enzMolMap.end() )
- sys_.dependency[i].push_back( pos->second );
- }
- }
+ unsigned int numRates = stoichPtr_->getNumRates();
+ vector< unsigned int > indices;
+
+ // Make a map to look up enzyme RateTerm using
+ // the key of the enzyme molecule.
+ map< unsigned int, unsigned int > enzMolMap;
+ for ( unsigned int i = 0; i < numRates; ++i ) {
+ const MMEnzymeBase* mme = dynamic_cast< const MMEnzymeBase* >(
+ stoichPtr_->rates( i ) );
+ if ( mme ) {
+ vector< unsigned int > reactants;
+ mme->getReactants( reactants );
+ if ( reactants.size() > 1 )
+ enzMolMap[ reactants.front() ] = i; // front is enzyme.
+ }
+ }
+
+ // Use the map to fill in deps.
+ for ( unsigned int i = 0; i < numRates; ++i ) {
+ // Extract the row of all molecules that depend on the reac.
+ const int* entry;
+ const unsigned int* colIndex;
+
+ unsigned int numInRow =
+ sys_.transposeN.getRow( i, &entry, &colIndex );
+ for( unsigned int j = 0; j < numInRow; ++j ) {
+ map< unsigned int, unsigned int >::iterator pos =
+ enzMolMap.find( colIndex[j] );
+ if ( pos != enzMolMap.end() )
+ sys_.dependency[i].push_back( pos->second );
+ }
+ }
}
/**
* Here we fill in the dependencies involving poolFuncs. These are
* the functions that evaluate an expression and assign directly to the
- * # of a target molecule.
+ * # of a target molecule.
* There are two dependencies:
* 1. When a reaction fires, all the Functions that depend on the reactants
* must update their target molecule. This is in sys_.dependentMathExpn[].
@@ -659,59 +609,55 @@ void Gsolve::fillMmEnzDep()
*/
void Gsolve::fillPoolFuncDep()
{
- // create map of funcs that depend on specified molecule.
- vector< vector< unsigned int > > funcMap(
- stoichPtr_->getNumAllPools() );
- unsigned int numFuncs = stoichPtr_->getNumFuncs();
- for ( unsigned int i = 0; i < numFuncs; ++i )
- {
- const FuncTerm *f = stoichPtr_->funcs( i );
- vector< unsigned int > molIndex = f->getReactantIndex();
- for ( unsigned int j = 0; j < molIndex.size(); ++j )
- funcMap[ molIndex[j] ].push_back( i );
- }
- // The output of each func is a mol indexed as
- // numVarMols + numBufMols + i
- unsigned int numRates = stoichPtr_->getNumRates();
- sys_.dependentMathExpn.resize( numRates );
- vector< unsigned int > indices;
- for ( unsigned int i = 0; i < numRates; ++i )
- {
- vector< unsigned int >& dep = sys_.dependentMathExpn[ i ];
- dep.resize( 0 );
- // Extract the row of all molecules that depend on the reac.
- const int* entry;
- const unsigned int* colIndex;
- unsigned int numInRow =
- sys_.transposeN.getRow( i, &entry, &colIndex );
- for ( unsigned int j = 0; j < numInRow; ++j )
- {
- unsigned int molIndex = colIndex[j];
- vector< unsigned int >& funcs = funcMap[ molIndex ];
- dep.insert( dep.end(), funcs.begin(), funcs.end() );
- for ( unsigned int k = 0; k < funcs.size(); ++k )
- {
- // unsigned int outputMol = funcs[k] + funcOffset;
- unsigned int outputMol = stoichPtr_->funcs( funcs[k] )->getTarget();
- // Insert reac deps here. Columns are reactions.
- vector< int > e; // Entries: we don't need.
- vector< unsigned int > c; // Column index: the reactions.
- stoichPtr_->getStoichiometryMatrix().
- getRow( outputMol, e, c );
- // Each of the reacs (col entries) depend on this func.
- vector< unsigned int > rdep = sys_.dependency[i];
- rdep.insert( rdep.end(), c.begin(), c.end() );
- }
- }
- }
+ // create map of funcs that depend on specified molecule.
+ vector< vector< unsigned int > > funcMap(
+ stoichPtr_->getNumAllPools() );
+ unsigned int numFuncs = stoichPtr_->getNumFuncs();
+ for ( unsigned int i = 0; i < numFuncs; ++i ) {
+ const FuncTerm *f = stoichPtr_->funcs( i );
+ vector< unsigned int > molIndex = f->getReactantIndex();
+ for ( unsigned int j = 0; j < molIndex.size(); ++j )
+ funcMap[ molIndex[j] ].push_back( i );
+ }
+ // The output of each func is a mol indexed as
+ // numVarMols + numBufMols + i
+ unsigned int numRates = stoichPtr_->getNumRates();
+ sys_.dependentMathExpn.resize( numRates );
+ vector< unsigned int > indices;
+ for ( unsigned int i = 0; i < numRates; ++i ) {
+ vector< unsigned int >& dep = sys_.dependentMathExpn[ i ];
+ dep.resize( 0 );
+ // Extract the row of all molecules that depend on the reac.
+ const int* entry;
+ const unsigned int* colIndex;
+ unsigned int numInRow =
+ sys_.transposeN.getRow( i, &entry, &colIndex );
+ for ( unsigned int j = 0; j < numInRow; ++j ) {
+ unsigned int molIndex = colIndex[j];
+ vector< unsigned int >& funcs = funcMap[ molIndex ];
+ dep.insert( dep.end(), funcs.begin(), funcs.end() );
+ for ( unsigned int k = 0; k < funcs.size(); ++k ) {
+ // unsigned int outputMol = funcs[k] + funcOffset;
+ unsigned int outputMol = stoichPtr_->funcs( funcs[k] )->getTarget();
+ // Insert reac deps here. Columns are reactions.
+ vector< int > e; // Entries: we don't need.
+ vector< unsigned int > c; // Column index: the reactions.
+ stoichPtr_->getStoichiometryMatrix().
+ getRow( outputMol, e, c );
+ // Each of the reacs (col entries) depend on this func.
+ vector< unsigned int > rdep = sys_.dependency[i];
+ rdep.insert( rdep.end(), c.begin(), c.end() );
+ }
+ }
+ }
}
/**
* Here we fill in the dependencies involving incrementFuncs. These are
* the functions that evaluate an expression that specifies rate of change
- * of # of a target molecule.
+ * of # of a target molecule.
* There are two dependencies:
- * 1. When a reaction fires, all the incrementFuncs that depend on the
+ * 1. When a reaction fires, all the incrementFuncs that depend on the
* reactants must update their rates. This is added to sys_.dependency[]
* which is the usual handler for reac dependencies. Note that the inputs
* to the incrementFuncs are NOT present in the stoichiometry matrix, so
@@ -722,67 +668,62 @@ void Gsolve::fillPoolFuncDep()
*/
void Gsolve::fillIncrementFuncDep()
{
- // create map of funcs that depend on specified molecule.
- vector< vector< unsigned int > > funcMap(
- stoichPtr_->getNumAllPools() );
- const vector< RateTerm* >& rates = stoichPtr_->getRateTerms();
- vector< FuncRate* > incrementRates;
- vector< unsigned int > incrementRateIndex;
- const vector< RateTerm* >::const_iterator q;
- for ( unsigned int i = 0; i < rates.size(); ++i )
- {
- FuncRate *term =
- dynamic_cast< FuncRate* >( rates[i] );
- if (term)
- {
- incrementRates.push_back( term );
- incrementRateIndex.push_back( i );
- }
- }
-
- for ( unsigned int k = 0; k < incrementRates.size(); ++k )
- {
- const vector< unsigned int >& molIndex =
- incrementRates[k]->getFuncArgIndex();
- for ( unsigned int j = 0; j < molIndex.size(); ++j )
- funcMap[ molIndex[j] ].push_back( incrementRateIndex[k] );
- }
-
- unsigned int numRates = stoichPtr_->getNumRates();
- sys_.dependentMathExpn.resize( numRates );
- vector< unsigned int > indices;
- for ( unsigned int i = 0; i < numRates; ++i )
- {
- // Algorithm:
- // 1.Go through stoich matrix finding all the poolIndices affected
- // by each Rate Term.
- // 2.Use funcMap to look up FuncRateTerms affected by these indices
- // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.
-
- const int* entry;
- const unsigned int* colIndex;
- unsigned int numInRow =
- sys_.transposeN.getRow( i, &entry, &colIndex );
- // 1.Go through stoich matrix finding all the poolIndices affected
- // by each Rate Term.
- for ( unsigned int j = 0; j < numInRow; ++j )
- {
- unsigned int molIndex = colIndex[j]; // Affected poolIndex
-
- // 2.Use funcMap to look up FuncRateTerms affected by these indices
- vector< unsigned int >& funcs = funcMap[ molIndex ];
- // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.
- vector< unsigned int >& rdep = sys_.dependency[i];
- rdep.insert( rdep.end(), funcs.begin(), funcs.end() );
- }
- }
+ // create map of funcs that depend on specified molecule.
+ vector< vector< unsigned int > > funcMap(
+ stoichPtr_->getNumAllPools() );
+ const vector< RateTerm* >& rates = stoichPtr_->getRateTerms();
+ vector< FuncRate* > incrementRates;
+ vector< unsigned int > incrementRateIndex;
+ const vector< RateTerm* >::const_iterator q;
+ for ( unsigned int i = 0; i < rates.size(); ++i ) {
+ FuncRate *term =
+ dynamic_cast< FuncRate* >( rates[i] );
+ if (term) {
+ incrementRates.push_back( term );
+ incrementRateIndex.push_back( i );
+ }
+ }
+
+ for ( unsigned int k = 0; k < incrementRates.size(); ++k ) {
+ const vector< unsigned int >& molIndex =
+ incrementRates[k]->getFuncArgIndex();
+ for ( unsigned int j = 0; j < molIndex.size(); ++j )
+ funcMap[ molIndex[j] ].push_back( incrementRateIndex[k] );
+ }
+
+ unsigned int numRates = stoichPtr_->getNumRates();
+ sys_.dependentMathExpn.resize( numRates );
+ vector< unsigned int > indices;
+ for ( unsigned int i = 0; i < numRates; ++i ) {
+ // Algorithm:
+ // 1.Go through stoich matrix finding all the poolIndices affected
+ // by each Rate Term.
+ // 2.Use funcMap to look up FuncRateTerms affected by these indices
+ // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.
+
+ const int* entry;
+ const unsigned int* colIndex;
+ unsigned int numInRow =
+ sys_.transposeN.getRow( i, &entry, &colIndex );
+ // 1.Go through stoich matrix finding all the poolIndices affected
+ // by each Rate Term.
+ for ( unsigned int j = 0; j < numInRow; ++j ) {
+ unsigned int molIndex = colIndex[j]; // Affected poolIndex
+
+ // 2.Use funcMap to look up FuncRateTerms affected by these indices
+ vector< unsigned int >& funcs = funcMap[ molIndex ];
+ // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.
+ vector< unsigned int >& rdep = sys_.dependency[i];
+ rdep.insert( rdep.end(), funcs.begin(), funcs.end() );
+ }
+ }
}
/*
void Gsolve::fillMathDep()
{
// create map of funcs that depend on specified molecule.
- vector< vector< unsigned int > > funcMap(
+ vector< vector< unsigned int > > funcMap(
stoichPtr_->getNumAllPools() );
unsigned int numFuncs = stoichPtr_->getNumFuncs();
for ( unsigned int i = 0; i < numFuncs; ++i ) {
@@ -791,9 +732,9 @@ void Gsolve::fillMathDep()
for ( unsigned int j = 0; j < molIndex.size(); ++j )
funcMap[ molIndex[j] ].push_back( i );
}
- // The output of each func is a mol indexed as
+ // The output of each func is a mol indexed as
// numVarMols + numBufMols + i
- unsigned int funcOffset =
+ unsigned int funcOffset =
stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() + stoichPtr_->getNumBufPools();
unsigned int numRates = stoichPtr_->getNumRates();
sys_.dependentMathExpn.resize( numRates );
@@ -804,7 +745,7 @@ void Gsolve::fillMathDep()
// Extract the row of all molecules that depend on the reac.
const int* entry;
const unsigned int* colIndex;
- unsigned int numInRow =
+ unsigned int numInRow =
sys_.transposeN.getRow( i, &entry, &colIndex );
for ( unsigned int j = 0; j < numInRow; ++j ) {
unsigned int molIndex = colIndex[j];
@@ -832,39 +773,38 @@ void Gsolve::fillMathDep()
* Later.
*/
void Gsolve::insertMathDepReacs( unsigned int mathDepIndex,
- unsigned int firedReac )
+ unsigned int firedReac )
{
- /*
- unsigned int molIndex = sumTotals_[ mathDepIndex ].target( S_ );
- vector< unsigned int > reacIndices;
-
- // Extract the row of all reacs that depend on the target molecule
- if ( N_.getRowIndices( molIndex, reacIndices ) > 0 ) {
- vector< unsigned int >& dep = dependency_[ firedReac ];
- dep.insert( dep.end(), reacIndices.begin(), reacIndices.end() );
- }
- */
+ /*
+ unsigned int molIndex = sumTotals_[ mathDepIndex ].target( S_ );
+ vector< unsigned int > reacIndices;
+
+ // Extract the row of all reacs that depend on the target molecule
+ if ( N_.getRowIndices( molIndex, reacIndices ) > 0 ) {
+ vector< unsigned int >& dep = dependency_[ firedReac ];
+ dep.insert( dep.end(), reacIndices.begin(), reacIndices.end() );
+ }
+ */
}
// Clean up dependency lists: Ensure only unique entries.
// Also a reac cannot depend on itself.
void Gsolve::makeReacDepsUnique()
{
- unsigned int numRates = stoichPtr_->getNumRates();
- for ( unsigned int i = 0; i < numRates; ++i )
- {
- vector< unsigned int >& dep = sys_.dependency[ i ];
- // Here we want to remove self-entries as well as duplicates.
- sort( dep.begin(), dep.end() );
- vector< unsigned int >::iterator k = dep.begin();
-
- /// STL stuff follows, with the usual weirdness.
- vector< unsigned int >::iterator pos =
- unique( dep.begin(), dep.end() );
- dep.resize( pos - dep.begin() );
- /*
- */
- }
+ unsigned int numRates = stoichPtr_->getNumRates();
+ for ( unsigned int i = 0; i < numRates; ++i ) {
+ vector< unsigned int >& dep = sys_.dependency[ i ];
+ // Here we want to remove self-entries as well as duplicates.
+ sort( dep.begin(), dep.end() );
+ vector< unsigned int >::iterator k = dep.begin();
+
+ /// STL stuff follows, with the usual weirdness.
+ vector< unsigned int >::iterator pos =
+ unique( dep.begin(), dep.end() );
+ dep.resize( pos - dep.begin() );
+ /*
+ */
+ }
}
//////////////////////////////////////////////////////////////
@@ -872,36 +812,31 @@ void Gsolve::makeReacDepsUnique()
//////////////////////////////////////////////////////////////
unsigned int Gsolve::getPoolIndex( const Eref& e ) const
{
- return stoichPtr_->convertIdToPoolIndex( e.id() );
+ return stoichPtr_->convertIdToPoolIndex( e.id() );
}
unsigned int Gsolve::getVoxelIndex( const Eref& e ) const
{
- unsigned int ret = e.dataIndex();
- if ( ret < startVoxel_ || ret >= startVoxel_ + pools_.size() )
- return OFFNODE;
- return ret - startVoxel_;
+ unsigned int ret = e.dataIndex();
+ if ( ret < startVoxel_ || ret >= startVoxel_ + pools_.size() )
+ return OFFNODE;
+ return ret - startVoxel_;
}
void Gsolve::setDsolve( Id dsolve )
{
- if ( dsolve == Id () )
- {
- dsolvePtr_ = 0;
- dsolve_ = Id();
- }
- else if ( dsolve.element()->cinfo()->isA( "Dsolve" ) )
- {
- dsolve_ = dsolve;
- dsolvePtr_ = reinterpret_cast< ZombiePoolInterface* >(
- dsolve.eref().data() );
- }
- else
- {
- cout << "Warning: Gsolve::setDsolve: Object '" << dsolve.path() <<
- "' should be class Dsolve, is: " <<
- dsolve.element()->cinfo()->name() << endl;
- }
+ if ( dsolve == Id () ) {
+ dsolvePtr_ = 0;
+ dsolve_ = Id();
+ } else if ( dsolve.element()->cinfo()->isA( "Dsolve" ) ) {
+ dsolve_ = dsolve;
+ dsolvePtr_ = reinterpret_cast< ZombiePoolInterface* >(
+ dsolve.eref().data() );
+ } else {
+ cout << "Warning: Gsolve::setDsolve: Object '" << dsolve.path() <<
+ "' should be class Dsolve, is: " <<
+ dsolve.element()->cinfo()->name() << endl;
+ }
}
@@ -911,185 +846,166 @@ void Gsolve::setDsolve( Id dsolve )
void Gsolve::setN( const Eref& e, double v )
{
- unsigned int vox = getVoxelIndex( e );
- if ( vox != OFFNODE )
- {
- if ( e.element()->cinfo()->isA( "ZombieBufPool" ) )
- {
- // Do NOT round it here, it is folded into rate term.
- pools_[vox].setN( getPoolIndex( e ), v );
- // refresh rates because nInit controls ongoing value of n.
- if ( sys_.isReady )
- pools_[vox].refreshAtot( &sys_ );
- }
- else
- {
- pools_[vox].setN( getPoolIndex( e ), round( v ) );
- }
- }
+ unsigned int vox = getVoxelIndex( e );
+ if ( vox != OFFNODE ) {
+ if ( e.element()->cinfo()->isA( "ZombieBufPool" ) ) {
+ // Do NOT round it here, it is folded into rate term.
+ pools_[vox].setN( getPoolIndex( e ), v );
+ // refresh rates because nInit controls ongoing value of n.
+ if ( sys_.isReady )
+ pools_[vox].refreshAtot( &sys_ );
+ } else {
+ pools_[vox].setN( getPoolIndex( e ), round( v ) );
+ }
+ }
}
double Gsolve::getN( const Eref& e ) const
{
- unsigned int vox = getVoxelIndex( e );
- if ( vox != OFFNODE )
- return pools_[vox].getN( getPoolIndex( e ) );
- return 0.0;
+ unsigned int vox = getVoxelIndex( e );
+ if ( vox != OFFNODE )
+ return pools_[vox].getN( getPoolIndex( e ) );
+ return 0.0;
}
void Gsolve::setNinit( const Eref& e, double v )
{
- unsigned int vox = getVoxelIndex( e );
- if ( vox != OFFNODE )
- {
- if ( e.element()->cinfo()->isA( "ZombieBufPool" ) )
- {
- // Do NOT round it here, it is folded into rate term.
- pools_[vox].setNinit( getPoolIndex( e ), v );
- // refresh rates because nInit controls ongoing value of n.
- if ( sys_.isReady )
- pools_[vox].refreshAtot( &sys_ );
- }
- else
- {
- // I now do the rounding at reinit time. It is better there as
- // it can give a distinct value each cycle. It is also better
- // to keep the full resolution of Ninit for volume scaling.
- // pools_[vox].setNinit( getPoolIndex( e ), round( v ) );
- pools_[vox].setNinit( getPoolIndex( e ), v );
- }
- }
+ unsigned int vox = getVoxelIndex( e );
+ if ( vox != OFFNODE ) {
+ if ( e.element()->cinfo()->isA( "ZombieBufPool" ) ) {
+ // Do NOT round it here, it is folded into rate term.
+ pools_[vox].setNinit( getPoolIndex( e ), v );
+ // refresh rates because nInit controls ongoing value of n.
+ if ( sys_.isReady )
+ pools_[vox].refreshAtot( &sys_ );
+ } else {
+ // I now do the rounding at reinit time. It is better there as
+ // it can give a distinct value each cycle. It is also better
+ // to keep the full resolution of Ninit for volume scaling.
+ // pools_[vox].setNinit( getPoolIndex( e ), round( v ) );
+ pools_[vox].setNinit( getPoolIndex( e ), v );
+ }
+ }
}
double Gsolve::getNinit( const Eref& e ) const
{
- unsigned int vox = getVoxelIndex( e );
- if ( vox != OFFNODE )
- return pools_[vox].getNinit( getPoolIndex( e ) );
- return 0.0;
+ unsigned int vox = getVoxelIndex( e );
+ if ( vox != OFFNODE )
+ return pools_[vox].getNinit( getPoolIndex( e ) );
+ return 0.0;
}
void Gsolve::setDiffConst( const Eref& e, double v )
{
- ; // Do nothing.
+ ; // Do nothing.
}
double Gsolve::getDiffConst( const Eref& e ) const
{
- return 0;
+ return 0;
}
void Gsolve::setNumPools( unsigned int numPoolSpecies )
{
- sys_.isReady = false;
- unsigned int numVoxels = pools_.size();
- for ( unsigned int i = 0 ; i < numVoxels; ++i )
- {
- pools_[i].resizeArrays( numPoolSpecies );
- }
+ sys_.isReady = false;
+ unsigned int numVoxels = pools_.size();
+ for ( unsigned int i = 0 ; i < numVoxels; ++i ) {
+ pools_[i].resizeArrays( numPoolSpecies );
+ }
}
unsigned int Gsolve::getNumPools() const
{
- if ( pools_.size() > 0 )
- return pools_[0].size();
- return 0;
+ if ( pools_.size() > 0 )
+ return pools_[0].size();
+ return 0;
}
void Gsolve::getBlock( vector< double >& values ) const
{
- unsigned int startVoxel = values[0];
- unsigned int numVoxels = values[1];
- unsigned int startPool = values[2];
- unsigned int numPools = values[3];
-
- assert( startVoxel >= startVoxel_ );
- assert( numVoxels <= pools_.size() );
- assert( pools_.size() > 0 );
- assert( numPools + startPool <= pools_[0].size() );
- values.resize( 4 + numVoxels * numPools );
-
- for ( unsigned int i = 0; i < numVoxels; ++i )
- {
- const double* v = pools_[ startVoxel + i ].S();
- for ( unsigned int j = 0; j < numPools; ++j )
- {
- values[ 4 + j * numVoxels + i] = v[ j + startPool ];
- }
- }
+ unsigned int startVoxel = values[0];
+ unsigned int numVoxels = values[1];
+ unsigned int startPool = values[2];
+ unsigned int numPools = values[3];
+
+ assert( startVoxel >= startVoxel_ );
+ assert( numVoxels <= pools_.size() );
+ assert( pools_.size() > 0 );
+ assert( numPools + startPool <= pools_[0].size() );
+ values.resize( 4 + numVoxels * numPools );
+
+ for ( unsigned int i = 0; i < numVoxels; ++i ) {
+ const double* v = pools_[ startVoxel + i ].S();
+ for ( unsigned int j = 0; j < numPools; ++j ) {
+ values[ 4 + j * numVoxels + i] = v[ j + startPool ];
+ }
+ }
}
void Gsolve::setBlock( const vector< double >& values )
{
- unsigned int startVoxel = values[0];
- unsigned int numVoxels = values[1];
- unsigned int startPool = values[2];
- unsigned int numPools = values[3];
-
- assert( startVoxel >= startVoxel_ );
- assert( numVoxels <= pools_.size() );
- assert( pools_.size() > 0 );
- assert( numPools + startPool <= pools_[0].size() );
-
- for ( unsigned int i = 0; i < numVoxels; ++i )
- {
- double* v = pools_[ startVoxel + i ].varS();
- for ( unsigned int j = 0; j < numPools; ++j )
- {
- v[ j + startPool ] = values[ 4 + j * numVoxels + i ];
- }
- }
+ unsigned int startVoxel = values[0];
+ unsigned int numVoxels = values[1];
+ unsigned int startPool = values[2];
+ unsigned int numPools = values[3];
+
+ assert( startVoxel >= startVoxel_ );
+ assert( numVoxels <= pools_.size() );
+ assert( pools_.size() > 0 );
+ assert( numPools + startPool <= pools_[0].size() );
+
+ for ( unsigned int i = 0; i < numVoxels; ++i ) {
+ double* v = pools_[ startVoxel + i ].varS();
+ for ( unsigned int j = 0; j < numPools; ++j ) {
+ v[ j + startPool ] = values[ 4 + j * numVoxels + i ];
+ }
+ }
}
//////////////////////////////////////////////////////////////////////////
void Gsolve::updateVoxelVol( vector< double > vols )
{
- // For now we assume identical numbers of voxels. Also assume
- // identical voxel junctions. But it should not be too hard to
- // update those too.
- if ( vols.size() == pools_.size() )
- {
- for ( unsigned int i = 0; i < vols.size(); ++i )
- {
- pools_[i].setVolumeAndDependencies( vols[i] );
- }
- stoichPtr_->setupCrossSolverReacVols();
- updateRateTerms( ~0U );
- }
+ // For now we assume identical numbers of voxels. Also assume
+ // identical voxel junctions. But it should not be too hard to
+ // update those too.
+ if ( vols.size() == pools_.size() ) {
+ for ( unsigned int i = 0; i < vols.size(); ++i ) {
+ pools_[i].setVolumeAndDependencies( vols[i] );
+ }
+ stoichPtr_->setupCrossSolverReacVols();
+ updateRateTerms( ~0U );
+ }
}
void Gsolve::updateRateTerms( unsigned int index )
{
- if ( index == ~0U )
- {
- // unsigned int numCrossRates = stoichPtr_->getNumRates() - stoichPtr_->getNumCoreRates();
- for ( unsigned int i = 0 ; i < pools_.size(); ++i )
- {
- // pools_[i].resetXreacScale( numCrossRates );
- pools_[i].updateAllRateTerms( stoichPtr_->getRateTerms(),
- stoichPtr_->getNumCoreRates() );
- }
- }
- else if ( index < stoichPtr_->getNumRates() )
- {
- for ( unsigned int i = 0 ; i < pools_.size(); ++i )
- pools_[i].updateRateTerms( stoichPtr_->getRateTerms(),
- stoichPtr_->getNumCoreRates(), index );
- }
+ if ( index == ~0U ) {
+ // unsigned int numCrossRates = stoichPtr_->getNumRates() - stoichPtr_->getNumCoreRates();
+ for ( unsigned int i = 0 ; i < pools_.size(); ++i ) {
+ // pools_[i].resetXreacScale( numCrossRates );
+ pools_[i].updateAllRateTerms( stoichPtr_->getRateTerms(),
+ stoichPtr_->getNumCoreRates() );
+ }
+ } else if ( index < stoichPtr_->getNumRates() ) {
+ for ( unsigned int i = 0 ; i < pools_.size(); ++i )
+ pools_[i].updateRateTerms( stoichPtr_->getRateTerms(),
+ stoichPtr_->getNumCoreRates(), index );
+ }
}
//////////////////////////////////////////////////////////////////////////
VoxelPoolsBase* Gsolve::pools( unsigned int i )
{
- if ( pools_.size() > i )
- return &pools_[i];
- return 0;
+ if ( pools_.size() > i )
+ return &pools_[i];
+ return 0;
}
double Gsolve::volume( unsigned int i ) const
{
- if ( pools_.size() > i )
- return pools_[i].getVolume();
- return 0.0;
+ if ( pools_.size() > i )
+ return pools_[i].getVolume();
+ return 0.0;
}
diff --git a/ksolve/GssaVoxelPools.cpp b/ksolve/GssaVoxelPools.cpp
index 810c9481..b74900aa 100644
--- a/ksolve/GssaVoxelPools.cpp
+++ b/ksolve/GssaVoxelPools.cpp
@@ -205,10 +205,10 @@ void GssaVoxelPools::advance( const ProcInfo* p, const GssaSystem* g )
numFire_[rindex]++;
double r = rng_.uniform();
-
- while ( r == 0.0 )
+ while ( r <= 0.0 )
+ {
r = rng_.uniform();
-
+ }
t_ -= ( 1.0 / atot_ ) * log( r );
// g->stoich->updateFuncs( varS(), t_ ); // Handled next line.
updateDependentMathExpn( g, rindex, t_ );
@@ -234,7 +234,7 @@ void GssaVoxelPools::reinit( const GssaSystem* g )
double base = floor( n[i] );
assert( base >= 0.0 );
double frac = n[i] - base;
- if ( rng_.uniform() >= frac )
+ if ( rng_.uniform() > frac )
n[i] = base;
else
n[i] = base + 1.0;
@@ -369,9 +369,9 @@ void GssaVoxelPools::xferIn( XferInfo& xf,
{
double& x = s[*k];
// cout << x << " i = " << *i << *j << " m = " << *m << endl;
- double dx = *(i++) - *(j++);
+ double dx = *i++ - *j++;
double base = floor( dx );
- if ( rng_.uniform() >= (dx - base) )
+ if ( rng_.uniform() > dx - base )
x += base;
else
x += base + 1.0;
@@ -425,7 +425,7 @@ void GssaVoxelPools::xferInOnlyProxies(
if ( *k >= stoichPtr_->getNumVarPools() && *k < proxyEndIndex )
{
double base = floor( *i );
- if ( rng_.uniform() >= (*i - base) )
+ if ( rng_.uniform() > *i - base )
varSinit()[*k] = (varS()[*k] += base );
else
varSinit()[*k] = (varS()[*k] += base + 1.0 );
diff --git a/ksolve/KinSparseMatrix.cpp b/ksolve/KinSparseMatrix.cpp
index 431fb858..a83e12ae 100644
--- a/ksolve/KinSparseMatrix.cpp
+++ b/ksolve/KinSparseMatrix.cpp
@@ -164,6 +164,21 @@ void makeVecUnique( vector< unsigned int >& v )
v.resize( pos - v.begin() );
}
+vector< int > KinSparseMatrix::matrixEntry() const
+{
+ return N_;
+}
+
+vector< unsigned int > KinSparseMatrix::colIndex() const
+{
+ return colIndex_;
+}
+
+vector< unsigned int > KinSparseMatrix::rowStart() const
+{
+ return rowStart_;
+}
+
#ifdef DO_UNIT_TESTS
#include "header.h"
diff --git a/ksolve/KinSparseMatrix.h b/ksolve/KinSparseMatrix.h
index 3d316738..9d18c262 100644
--- a/ksolve/KinSparseMatrix.h
+++ b/ksolve/KinSparseMatrix.h
@@ -61,6 +61,10 @@ class KinSparseMatrix: public SparseMatrix< int >
*/
void truncateRow( unsigned int maxColumnIndex );
+ /// Here we expose the sparse matrix for MOOSE use.
+ vector< int > matrixEntry() const;
+ vector< unsigned int > colIndex() const;
+ vector< unsigned int > rowStart() const;
private:
/**
* End colIndex for rows (molecules in the transposed matrix)
diff --git a/ksolve/ZombieBufPool.cpp b/ksolve/ZombieBufPool.cpp
index 82665529..a00a6499 100644
--- a/ksolve/ZombieBufPool.cpp
+++ b/ksolve/ZombieBufPool.cpp
@@ -72,7 +72,3 @@ void ZombieBufPool::vSetConcInit( const Eref& e, double conc )
vSetConc( e, conc );
}
-bool ZombieBufPool::vGetIsBuffered( const Eref& e ) const
-{
- return true;
-}
diff --git a/ksolve/ZombieBufPool.h b/ksolve/ZombieBufPool.h
index 6ebdf8bc..72d0a200 100644
--- a/ksolve/ZombieBufPool.h
+++ b/ksolve/ZombieBufPool.h
@@ -21,7 +21,6 @@ class ZombieBufPool: public ZombiePool
void vSetNinit( const Eref& e, double v );
void vSetConc( const Eref& e, double v );
void vSetConcInit( const Eref& e, double v );
- bool vGetIsBuffered( const Eref& e ) const;
static const Cinfo* initCinfo();
private:
diff --git a/ksolve/ZombiePool.cpp b/ksolve/ZombiePool.cpp
index 4ab7e1f8..af4a2632 100644
--- a/ksolve/ZombiePool.cpp
+++ b/ksolve/ZombiePool.cpp
@@ -179,11 +179,6 @@ double ZombiePool::vGetVolume( const Eref& e ) const
return lookupVolumeFromMesh( e );
}
-bool ZombiePool::vGetIsBuffered( const Eref& e ) const
-{
- return false;
-}
-
//////////////////////////////////////////////////////////////
// Zombie conversion functions.
//////////////////////////////////////////////////////////////
diff --git a/ksolve/ZombiePool.h b/ksolve/ZombiePool.h
index 8e9b6ddb..6771b2ce 100644
--- a/ksolve/ZombiePool.h
+++ b/ksolve/ZombiePool.h
@@ -46,7 +46,6 @@ class ZombiePool: public PoolBase
void vSetMotorConst( const Eref& e, double v );
double vGetMotorConst( const Eref& e ) const;
- bool vGetIsBuffered( const Eref& e ) const;
//////////////////////////////////////////////////////////////////
// Dest funcs
//////////////////////////////////////////////////////////////////
diff --git a/msg/SparseMsg.cpp b/msg/SparseMsg.cpp
index 0be80c00..65051f64 100644
--- a/msg/SparseMsg.cpp
+++ b/msg/SparseMsg.cpp
@@ -42,40 +42,6 @@ const Cinfo* SparseMsg::initCinfo()
&SparseMsg::getNumEntries
);
- static ValueFinfo< SparseMsg, vector< unsigned int > > connectionList(
- "connectionList",
- "Pairwise specification of connection matrix where each x,y value "
- "represents a connection from src[x] to dest[y]. "
- "The (x,y) entries are ordered in a single vector as \n"
- "(x0, x1,... x_n-1, y0, y1,... y_n-1)\n",
- &SparseMsg::setEntryPairs,
- &SparseMsg::getEntryPairs
- );
-
- /// Connection matrix entries to manipulate in Python.
- static ReadOnlyValueFinfo< SparseMsg, vector< unsigned int > >
- matrixEntry(
- "matrixEntry",
- "The non-zero matrix entries in the sparse matrix. Their"
- "column indices are in a separate vector and the row"
- "informatino in a third",
- &SparseMsg::getMatrixEntry
- );
- /// connection matrix column indices to manipulate in Python.
- static ReadOnlyValueFinfo< SparseMsg, vector< unsigned int > >
- columnIndex(
- "columnIndex",
- "Column Index of each matrix entry",
- &SparseMsg::getColIndex
- );
- /// connection matrix rowStart to manipulate in Python.
- static ReadOnlyValueFinfo< SparseMsg, vector< unsigned int > >
- rowStart(
- "rowStart",
- "Row start for each block of entries and column indices",
- &SparseMsg::getRowStart
- );
-
static ValueFinfo< SparseMsg, double > probability(
"probability",
"connection probability for random connectivity.",
@@ -135,13 +101,6 @@ const Cinfo* SparseMsg::initCinfo()
vector< unsigned int > >(
&SparseMsg::tripletFill ) );
- static DestFinfo tripletFill1( "tripletFill1",
- "Single contiguous array to fill entire connection matrix using "
- "triplets of (x,y, fieldindex) ordered as \n"
- "(x0, x1,... xn-1, y0, y1,... yn-1, fi0, fi1,... fi_n-1)\n",
- new OpFunc1< SparseMsg, vector< unsigned int > >(
- &SparseMsg::tripletFill1 ) );
-
////////////////////////////////////////////////////////////////////////
// Assemble it all.
////////////////////////////////////////////////////////////////////////
@@ -150,10 +109,6 @@ const Cinfo* SparseMsg::initCinfo()
&numRows, // readonly value
&numColumns, // readonly value
&numEntries, // readonly value
- &connectionList, // value
- &matrixEntry, // ReadOnlyValue
- &columnIndex, // ReadOnlyValue
- &rowStart, // ReadOnlyValue
&probability, // value
&seed, // value
&setRandomConnectivity, // dest
@@ -163,7 +118,6 @@ const Cinfo* SparseMsg::initCinfo()
&transpose, //dest
&pairFill, //dest
&tripletFill, //dest
- &tripletFill1, //dest
};
static Dinfo< short > dinfo;
@@ -222,43 +176,6 @@ unsigned int SparseMsg::getNumEntries() const
return matrix_.nEntries();
}
-vector< unsigned int > SparseMsg::getMatrixEntry() const
-{
- return matrix_.matrixEntry();
-}
-
-vector< unsigned int > SparseMsg::getColIndex() const
-{
- return matrix_.colIndex();
-}
-
-vector< unsigned int > SparseMsg::getRowStart() const
-{
- return matrix_.rowStart();
-}
-
-void SparseMsg::setEntryPairs( vector< unsigned int > v )
-{
- vector< unsigned int > src( v.begin(), v.begin() + v.size()/2 );
- vector< unsigned int > dest( v.begin() + v.size()/2, v.end() );
- pairFill( src, dest );
-}
-
-vector< unsigned int > SparseMsg::getEntryPairs() const
-{
- vector< unsigned int > cols = matrix_.colIndex();
- vector< unsigned int > y;
- for ( unsigned int row = 0; row < matrix_.nRows(); ++row ) {
- unsigned int begin = matrix_.rowStart()[row];
- unsigned int end = matrix_.rowStart()[row+1];
- for ( unsigned int j = begin; j < end; ++j )
- y.push_back( row );
- }
- assert( cols.size() == y.size() );
- y.insert( y.end(), cols.begin(), cols.end() );
- return y;
-}
-
//////////////////////////////////////////////////////////////////
// DestFields
//////////////////////////////////////////////////////////////////
@@ -312,42 +229,10 @@ void SparseMsg::updateAfterFill()
e1()->markRewired();
e2()->markRewired();
}
-
void SparseMsg::pairFill( vector< unsigned int > src,
vector< unsigned int> dest )
{
- // Sanity check
- vector< unsigned int >::const_iterator i;
- for ( i = src.begin(); i != src.end(); ++i ) {
- if (*i >= e1()->numData() ) {
- cout << "Warning: SparseMsg::pairFill: Src index " << *i <<
- " exceeds Src array size " << e1()->numData() <<
- ". Aborting\n";
- return;
- }
- }
- for ( i = dest.begin(); i != dest.end(); ++i ) {
- if (*i >= e2()->numData() ) {
- cout << "Warning: SparseMsg::pairFill: Dest index " << *i <<
- " exceeds Dest array size " << e2()->numData() <<
- ". Aborting\n";
- return;
- }
- }
-
- vector< unsigned int > numAtDest( dest.size(), 0 );
- vector< unsigned int > fieldIndex( dest.size(), 0 );
- for ( unsigned int i = 0; i < dest.size(); ++i ) {
- fieldIndex[i] = numAtDest[ dest[i] ];
- // Could do on previous line, but clarity
- ++numAtDest[ dest[i] ];
- }
-
- /**
- * We set retainSize flag to true since the # of src/dest objects
- * doesn't change. We can explicitly assign it elsewhere if needed.
- */
- matrix_.tripletFill( src, dest, fieldIndex, true );
+ matrix_.pairFill( src, dest, 0 );
updateAfterFill();
}
@@ -355,20 +240,10 @@ void SparseMsg::tripletFill( vector< unsigned int > src,
vector< unsigned int> destDataIndex,
vector< unsigned int> destFieldIndex )
{
- // We set retainSize flag to true
- matrix_.tripletFill( src, destDataIndex, destFieldIndex, true );
+ matrix_.tripletFill( src, destDataIndex, destFieldIndex );
updateAfterFill();
}
-void SparseMsg::tripletFill1( vector< unsigned int > v )
-{
- unsigned int s3 = v.size() / 3;
- vector< unsigned int > src( v.begin(), v.begin() + s3 );
- vector< unsigned int > dest( v.begin() + s3, v.begin() + 2 * s3 );
- vector< unsigned int > fieldIndex( v.begin() + 2 * s3, v.end() );
- tripletFill( src, dest, fieldIndex );
-}
-
//////////////////////////////////////////////////////////////////
// Here are the actual class functions
//////////////////////////////////////////////////////////////////
@@ -376,10 +251,7 @@ void SparseMsg::tripletFill1( vector< unsigned int > v )
SparseMsg::SparseMsg( Element* e1, Element* e2, unsigned int msgIndex )
: Msg( ObjId( managerId_, (msgIndex != 0) ? msgIndex: msg_.size() ),
- e1, e2 ),
- numThreads_( 1 ),
- nrows_( 0 ),
- p_( 0.0 ), seed_( 0 )
+ e1, e2 )
{
unsigned int nrows = 0;
unsigned int ncolumns = 0;
diff --git a/msg/SparseMsg.h b/msg/SparseMsg.h
index d6fbf80b..2dffb9af 100644
--- a/msg/SparseMsg.h
+++ b/msg/SparseMsg.h
@@ -82,23 +82,16 @@ class SparseMsg: public Msg
long getSeed() const;
void setSeed( long value );
- vector< unsigned int > getEntryPairs() const;
- void setEntryPairs( vector< unsigned int > entries );
-
void setEntry( unsigned int row, unsigned int column,
unsigned int value );
void unsetEntry( unsigned int row, unsigned int column );
+ // Still need to implement array field gets.
+
unsigned int getNumRows() const;
unsigned int getNumColumns() const;
unsigned int getNumEntries() const;
- /// Return array entries in sparse matrix form
- vector< unsigned int > getMatrixEntry() const;
- /// Return column index for each array entry
- vector< unsigned int > getColIndex() const;
- /// row start number for each array entry
- vector< unsigned int > getRowStart() const;
void clear();
void transpose();
@@ -116,14 +109,6 @@ class SparseMsg: public Msg
void tripletFill( vector< unsigned int > src,
vector< unsigned int> dest,
vector< unsigned int > field );
-
- /**
- * Fills up the entire message based on triplets of
- * src,destDataIndex,destFieldIndex, but catenates them all into
- * a single long vector since PyMoose doesn't know how to handle
- * multiple vectors.
- */
- void tripletFill1( vector< unsigned int > entries );
/**
* Utility function to update all sorts of values after we've
diff --git a/pymoose/CMakeLists.txt b/pymoose/CMakeLists.txt
index cd7de488..b2887ee7 100644
--- a/pymoose/CMakeLists.txt
+++ b/pymoose/CMakeLists.txt
@@ -1,8 +1,6 @@
add_definitions(-DPYMOOSE)
include_directories(../basecode ../msg)
-find_package( PythonInterp REQUIRED )
-
set(PYMOOSE_SRCS
moosemodule.cpp
vec.cpp
@@ -20,18 +18,10 @@ EXEC_PROGRAM(${PYTHON_EXECUTABLE}
except Exception: pass'"
OUTPUT_VARIABLE PYTHON_SO_EXTENSION
)
-
-message( STATUS "Python path ${PYTHON_EXECUTABLE}" )
message( STATUS "Python so extension ${PYTHON_SO_EXTENSION}" )
find_package(NumPy REQUIRED)
-find_package(PythonLibs REQUIRED)
-
-include_directories( ${NUMPY_INCLUDE_DIRS} )
-include_directories( ${PYTHON_INCLUDE_DIRS} )
-
-message( STATUS "Python include dir : ${PYTHON_INCLUDE_DIRS} " )
-
+include_directories(${NUMPY_INCLUDE_DIRS})
add_definitions(-DUSE_NUMPY)
add_definitions(-DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION)
@@ -44,12 +34,7 @@ execute_process( COMMAND ${PYTHON_EXECUTABLE}-config --libs
OUTPUT_VARIABLE PYTHON_LIBRARIES
OUTPUT_STRIP_TRAILING_WHITESPACE
)
-
-if( NOT PYTHON_INCLUDE_FLAGS )
- set( PYTHON_INCLUDE_FLAGS "-I ${PYTHON_INCLUDE_DIRS} " )
-endif( )
message( STATUS "Python include flags: ${PYTHON_INCLUDE_FLAGS}" )
-
set_target_properties(_moose PROPERTIES
COMPILE_DEFINITIONS "PYMOOSE"
COMPILE_FLAGS "${PYTHON_INCLUDE_FLAGS}"
@@ -58,6 +43,11 @@ set_target_properties(_moose PROPERTIES
SUFFIX ".so"
)
+if(NOT(PYTHON_SO_EXTENSION STREQUAL ""))
+ set_target_properties(_moose PROPERTIES
+ SUFFIX ${PYTHON_SO_EXTENSION})
+endif()
+
# see issue #80
if(HDF5_LIBRARY_DIRS)
set_target_properties( _moose PROPERTIES LINK_FLAGS "-L${HDF5_LIBRARY_DIRS}" )
@@ -93,6 +83,8 @@ endif(MACOSX)
add_custom_target(copy_python_files ALL
COMMAND ${CMAKE_COMMAND} -E copy_directory
${CMAKE_SOURCE_DIR}/python ${CMAKE_BINARY_DIR}/python
+ COMMAND ${CMAKE_COMMAND} -E copy
+ ${CMAKE_SOURCE_DIR}/VERSION ${CMAKE_BINARY_DIR}/VERSION
COMMENT "Copying required python files and other files to build directory"
VERBATIM
)
diff --git a/pymoose/PyRun.cpp b/pymoose/PyRun.cpp
index 73d88c0c..5b3db0da 100644
--- a/pymoose/PyRun.cpp
+++ b/pymoose/PyRun.cpp
@@ -1,47 +1,47 @@
-// PyRun.cpp ---
-//
+// PyRun.cpp ---
+//
// Filename: PyRun.cpp
-// Description:
+// Description:
// Author: subha
-// Maintainer:
+// Maintainer:
// Created: Sat Oct 11 14:47:22 2014 (+0530)
-// Version:
+// Version:
// Last-Updated: Fri Jun 19 18:56:06 2015 (-0400)
// By: Subhasis Ray
// Update #: 15
-// URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
-//
-//
-//
+// URL:
+// Keywords:
+// Compatibility:
+//
+//
+
+// Commentary:
+//
+//
+//
+//
// Change log:
-//
-//
-//
-//
+//
+//
+//
+//
// 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, 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; see the file COPYING. If not, write to
// the Free Software Foundation, Inc., 51 Franklin Street, Fifth
// Floor, Boston, MA 02110-1301, USA.
-//
-//
+//
+//
// Code:
@@ -77,6 +77,7 @@ const Cinfo * PyRun::initCinfo()
"String to be executed at initialization (reinit).",
&PyRun::setInitString,
&PyRun::getInitString);
+
static ValueFinfo< PyRun, string > inputvar(
"inputVar",
"Name of local variable in which input balue is to be stored. Default"
@@ -87,13 +88,13 @@ const Cinfo * PyRun::initCinfo()
static ValueFinfo< PyRun, string > outputvar(
"outputVar",
- "Name of local variable for storing output. Default is `output`",
+ "Name of local variable for storing output. Default is `output`.",
&PyRun::setOutputVar,
&PyRun::getOutputVar);
static ValueFinfo< PyRun, int > mode(
"mode",
- "Flag to indicate whether runString should be executed for both trigger and process, or one of them",
+ "Flag to indicate whether runString should be executed for both trigger and process, or one of them.",
&PyRun::setMode,
&PyRun::getMode);
@@ -118,7 +119,7 @@ const Cinfo * PyRun::initCinfo()
" builtin function `input`). If debug is True, it prints the input"
" value.",
new EpFunc1< PyRun, double >(&PyRun::trigger));
-
+
static DestFinfo run(
"run",
"Runs a specified string. Does not modify existing run or init strings.",
@@ -133,7 +134,7 @@ const Cinfo * PyRun::initCinfo()
"reinit",
"Handles reinit call. Runs the current initString.",
new ProcOpFunc< PyRun >( &PyRun::reinit ));
-
+
static Finfo * processShared[] = { &process, &reinit };
static SharedFinfo proc(
"proc",
@@ -195,7 +196,7 @@ PyRun::PyRun():mode_(0), initstr_(""), runstr_(""),
}
if (PyDict_SetItemString(locals_, inputvar_.c_str(), value)){
PyErr_Print();
- }
+ }
}
PyRun::~PyRun()
@@ -264,7 +265,7 @@ void PyRun::trigger(const Eref& e, double input)
if (mode_ == 1){
return;
}
-
+
PyObject * value = PyDict_GetItemString(locals_, inputvar_.c_str());
if (value){
Py_DECREF(value);
@@ -335,12 +336,12 @@ void handleError(bool syntax)
{
PyObject *exc, *val, *trb;
char * msg;
-
- if (syntax && PyErr_ExceptionMatches (PyExc_SyntaxError)){
+
+ if (syntax && PyErr_ExceptionMatches (PyExc_SyntaxError)){
PyErr_Fetch (&exc, &val, &trb); /* clears exception! */
-
+
if (PyArg_ParseTuple (val, "sO", &msg, &trb) &&
- !strcmp (msg, "unexpected EOF while parsing")){ /* E_EOF */
+ !strcmp (msg, "unexpected EOF while parsing")){ /* E_EOF */
Py_XDECREF (exc);
Py_XDECREF (val);
Py_XDECREF (trb);
@@ -350,21 +351,21 @@ void handleError(bool syntax)
}
} else { /* some non-syntax error */
PyErr_Print ();
- }
+ }
}
void PyRun::reinit(const Eref& e, ProcPtr p)
{
PyObject * main_module;
if (globals_ == NULL){
- main_module = PyImport_AddModule("__main__");
+ main_module = PyImport_AddModule("__main__");
globals_ = PyModule_GetDict(main_module);
Py_XINCREF(globals_);
}
if (locals_ == NULL){
locals_ = PyDict_New();
if (!locals_){
- cerr << "Could not initialize locals dict" << endl;
+ cerr << "Could not initialize locals dict" << endl;
}
}
initcompiled_ = (PYCODEOBJECT*)Py_CompileString(
@@ -396,5 +397,5 @@ void PyRun::reinit(const Eref& e, ProcPtr p)
}
-//
+//
// PyRun.cpp ends here
diff --git a/pymoose/melement.cpp b/pymoose/melement.cpp
index 7cd4ee91..fdceba80 100644
--- a/pymoose/melement.cpp
+++ b/pymoose/melement.cpp
@@ -1,48 +1,48 @@
-// melement.cpp ---
-//
+// melement.cpp ---
+//
// Filename: melement.cpp
-// Description:
-// Author:
-// Maintainer:
+// Description:
+// Author:
+// Maintainer:
// Created: Mon Jul 22 16:50:41 2013 (+0530)
-// Version:
+// Version:
// Last-Updated: Fri Sep 25 23:02:53 2015 (-0400)
// By: subha
// Update #: 76
-// URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
+// URL:
+// Keywords:
+// Compatibility:
+//
+//
+
+// Commentary:
+//
// Mon Jul 22 16:50:47 IST 2013 - Taking out ObjId stuff from
// moosemodule.cpp
-//
-//
+//
+//
// Change log:
-//
-//
-//
-//
+//
+//
+//
+//
// 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, 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; see the file COPYING. If not, write to
// the Free Software Foundation, Inc., 51 Franklin Street, Fifth
// Floor, Boston, MA 02110-1301, USA.
-//
-//
+//
+//
// Code:
@@ -122,7 +122,7 @@ int moose_ObjId_init_from_id(_ObjId * self, PyObject * args, PyObject * kwargs)
if (Id_Check(obj)){
if (!Id::isValid(((_Id*)obj)->id_)){
RAISE_INVALID_ID(-1, "moose_ObjId_init_from_id");
- }
+ }
self->oid_ = ObjId(((_Id*)obj)->id_, data, field );
if (self->oid_.bad()){
PyErr_SetString(PyExc_ValueError, "Invalid dataIndex/fieldIndex.");
@@ -132,7 +132,7 @@ int moose_ObjId_init_from_id(_ObjId * self, PyObject * args, PyObject * kwargs)
} else if (PyObject_IsInstance(obj, (PyObject*)&ObjIdType)){
if (!Id::isValid(((_ObjId*)obj)->oid_.id)){
RAISE_INVALID_ID(-1, "moose_ObjId_init_from_id");
- }
+ }
self->oid_ = ((_ObjId*)obj)->oid_;
if (self->oid_.bad()){
PyErr_SetString(PyExc_ValueError, "Invalid ObjId");
@@ -156,7 +156,7 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
self->oid_ = ObjId( 0, BADINDEX );
PyTypeObject * mytype = Py_TYPE(self);
string mytypename(mytype->tp_name);
-
+
// First try to parse the arguments as (parsedPath, n, g, dtype)
bool parse_success = false;
if (PyArg_ParseTupleAndKeywords(args, kwargs,
@@ -167,14 +167,14 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
}
// we need to clear the parse error so that the callee can try
// other alternative: moose_ObjId_init_from_id
- PyErr_Clear();
+ PyErr_Clear();
if (!parse_success){
return -2;
}
string path(parsedPath);
// Remove one or more instances of '/' by a single '/' e.g. //a -> /a,
- // /a//b -> /a/b etc.
+ // /a//b -> /a/b etc.
path = moose::fix(path);
ostringstream err;
@@ -189,7 +189,7 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
}
basetype_str = string(basetype->tp_name).substr(6); // remove `moose.` prefix from type name
} else {
- basetype_str = string(type);
+ basetype_str = string(type);
}
@@ -211,7 +211,7 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
// If the current class is a subclass of some predefined
// moose class, do nothing.
string className = self->oid_.element()->cinfo()->name();
- map <string, PyTypeObject * >::iterator ii =
+ map <string, PyTypeObject * >::iterator ii =
get_moose_classes().find( className );
PyTypeObject * basetype = 0;
if ( ii != get_moose_classes().end() ) {
@@ -227,7 +227,7 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
// element exists at this path, but it does not inherit from any moose class.
// throw an error
err << "cannot convert "
- << className
+ << className
<< " to "
<< mytypename
<< ". To get the existing object use `moose.element(obj)` instead.";
@@ -245,7 +245,7 @@ int moose_ObjId_init_from_path(_ObjId * self, PyObject * args,
self->oid_ = ObjId(new_id);
return 0;
}
-
+
int moose_ObjId_init(_ObjId * self, PyObject * args,
PyObject * kwargs)
{
@@ -267,7 +267,7 @@ int moose_ObjId_init(_ObjId * self, PyObject * args,
PyErr_SetString(PyExc_ValueError,
"Could not parse arguments. "
" Call __init__(path, n, g, dtype) or"
- " __init__(id, dataIndex, fieldIndex)");
+ " __init__(id, dataIndex, fieldIndex)");
return -1;
}
@@ -327,14 +327,20 @@ PyObject * moose_ObjId_str(_ObjId * self)
PyDoc_STRVAR(moose_ObjId_getId_documentation,
"getId() -> vec\n"
"\n"
- "Get the vec of this object\n"
+ "Returns the information of the object's classtype, Id, and path \n"
+ "in form of a vector.\n"
+ "\nExample\n"
+ "-------\n"
+ " >>> com = moose.Compartment('/com')\n"
+ " >>> com.getId()\n"
+ " moose.vec: class=Compartment, id=481, path=/com>"
"\n");
PyObject* moose_ObjId_getId(_ObjId * self)
{
if (!Id::isValid(self->oid_.id)){
RAISE_INVALID_ID(NULL, "moose_ObjId_getId");
}
- extern PyTypeObject IdType;
+ extern PyTypeObject IdType;
_Id * ret = PyObject_New(_Id, &IdType);
ret->id_ = self->oid_.id;
return (PyObject*)ret;
@@ -343,12 +349,15 @@ PyObject* moose_ObjId_getId(_ObjId * self)
PyDoc_STRVAR(moose_ObjId_getFieldType_documentation,
"getFieldType(fieldname)\n"
"\n"
- "Get the string representation of the type of the field `fieldname`.\n"
+ "Returns the type of the field `fieldname` (as a string).\n"
"\n"
"Parameters\n"
"----------\n"
"fieldname : string\n"
" Name of the field to be queried.\n"
+ "\n"
+ " >>> comp.getFieldType('neighbors')\n"
+ " >>> 'string,vector<Id>' \n"
"\n");
PyObject * moose_ObjId_getFieldType(_ObjId * self, PyObject * args)
@@ -379,18 +388,21 @@ PyObject * moose_ObjId_getFieldType(_ObjId * self, PyObject * args)
PyDoc_STRVAR(moose_ObjId_getField_documentation,
"getField(fieldname)\n"
"\n"
- "Get the value of the field `fieldname`.\n"
+ "Returns the value of the field `fieldname`.\n"
"\n"
"Parameters\n"
"----------\n"
"fieldname : string\n"
- " Name of the field.");
+ " Name of the field.\n"
+ "\n"
+ " >>> comp.getField('x0')\n"
+ " >>> 0.0 \n");
PyObject * moose_ObjId_getField(_ObjId * self, PyObject * args)
{
if (!Id::isValid(self->oid_.id)){
RAISE_INVALID_ID(NULL, "moose_ObjId_getField");
}
- PyObject * attr;
+ PyObject * attr;
if (!PyArg_ParseTuple(args, "O:moose_ObjId_getField", &attr)){
return NULL;
}
@@ -399,7 +411,7 @@ PyObject * moose_ObjId_getField(_ObjId * self, PyObject * args)
/**
2011-03-28 13:59:41 (+0530)
-
+
Get a specified field. Re-done on: 2011-03-23 14:42:03 (+0530)
I wonder how to cleanly do this. The Id - ObjId dichotomy is
@@ -436,7 +448,7 @@ PyObject * moose_ObjId_getattro(_ObjId * self, PyObject * attr)
break;
}
}
-
+
string type = getFieldType(className, fieldName);
if (type.empty() || !isValueField ){
// Check if this field name is aliased and update fieldName and type if so.
@@ -520,12 +532,12 @@ PyObject * moose_ObjId_getattro(_ObjId * self, PyObject * attr)
_ret = to_py(&value, ftype);
break;
}
- case 'x': {
+ case 'x': {
Id value = Field<Id>::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
}
- case 'y': {
+ case 'y': {
ObjId value = Field<ObjId>::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
@@ -544,12 +556,12 @@ PyObject * moose_ObjId_getattro(_ObjId * self, PyObject * attr)
vector < Id > value = Field<vector <Id> >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
- }
+ }
case 'Y': { // vector<ObjId>
vector < ObjId > value = Field<vector <ObjId> >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
- }
+ }
case 'M': {
vector< long > value = Field< vector <long> >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
@@ -579,12 +591,12 @@ PyObject * moose_ObjId_getattro(_ObjId * self, PyObject * attr)
vector < vector < unsigned int > > value = Field<vector <vector < unsigned int > > >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
- }
+ }
case 'Q': { // vector< vector < int > >
vector < vector < int > > value = Field<vector < vector < int > > >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
break;
- }
+ }
case 'R': { // vector< vector < double > >
vector < vector < double > > value = Field<vector < vector < double > > >::get(self->oid_, fieldName);
_ret = to_py(&value, ftype);
@@ -635,12 +647,12 @@ PyObject * moose_ObjId_getattro(_ObjId * self, PyObject * attr)
default:
_ret = PyObject_GenericGetAttr((PyObject*)self, attr);
-
+
}
if (new_attr){
Py_DECREF(attr);
}
- return _ret;
+ return _ret;
}
/**
@@ -657,7 +669,12 @@ PyDoc_STRVAR(moose_ObjId_setField_documentation,
" Field to be assigned value to.\n"
"\n"
"value : python datatype compatible with the type of the field\n"
- " The value to be assigned to the field.");
+ " The value to be assigned to the field."
+ "\n"
+ "\n"
+ " >>> comp.setField('x0', 45.25) \n"
+ " >>> print comp.x0\n"
+ " 45.25\n");
PyObject * moose_ObjId_setField(_ObjId * self, PyObject * args)
{
@@ -694,7 +711,7 @@ int moose_ObjId_setattro(_ObjId * self, PyObject * attr, PyObject * value)
// typos). Otherwise, it must have been subclassed in
// Python. Then we allow normal Pythonic behaviour and
// consider such mistakes user's responsibility.
- string className = ((PyTypeObject*)PyObject_Type((PyObject*)self))->tp_name;
+ string className = ((PyTypeObject*)PyObject_Type((PyObject*)self))->tp_name;
if (get_moose_classes().find(className) == get_moose_classes().end()){
return PyObject_GenericSetAttr((PyObject*)self, PyString_FromString(field), value);
}
@@ -727,7 +744,7 @@ int moose_ObjId_setattro(_ObjId * self, PyObject * attr, PyObject * value)
unsigned long _value = PyInt_AsUnsignedLongMask(value);
ret = Field<unsigned long>::set(self->oid_, string(field), _value);
break;
- }
+ }
case 'f': {
float _value = PyFloat_AsDouble(value);
ret = Field<float>::set(self->oid_, string(field), _value);
@@ -899,7 +916,7 @@ int moose_ObjId_setattro(_ObjId * self, PyObject * attr, PyObject * value)
ret = Field< vector < float > >::set(self->oid_, string(field), _value);
}
break;
- }
+ }
case 'S': {
if (!PySequence_Check(value)){
PyErr_SetString(PyExc_TypeError, "For setting vector<string> field, specified value must be a sequence." );
@@ -955,7 +972,7 @@ int moose_ObjId_setattro(_ObjId * self, PyObject * attr, PyObject * value)
ret = Field< vector < Id > >::set(self->oid_, string(field), _value);
}
break;
- }
+ }
case 'Y': {//SET_VECFIELD(ObjId, f)
if (!PySequence_Check(value)){
PyErr_SetString(PyExc_TypeError, "For setting vector<ObjId> field, specified value must be a sequence." );
@@ -971,8 +988,8 @@ int moose_ObjId_setattro(_ObjId * self, PyObject * attr, PyObject * value)
ret = Field< vector < ObjId > >::set(self->oid_, string(field), _value);
}
break;
- }
- default:
+ }
+ default:
break;
}
// MOOSE Field::set returns 1 for success 0 for
@@ -1007,10 +1024,10 @@ PyObject * moose_ObjId_getItem(_ObjId * self, Py_ssize_t index)
// what is s0[1]? ObjId(X
// syn[0][1]->ObjId(X, 0, 1) =syn[0][0][0] - which is an ObjId.
// Now, what is syn[0][1][2] ?
-
+
// In PyMOOSE, user is allowed to directly put in the numbers
// for Id, dataIndex and fieldIndex directly and construct an
- // ObjId.
+ // ObjId.
_ObjId * ret = PyObject_New(_ObjId, &ObjIdType);
ret->oid_ = ObjId(self->oid_.id, self->oid_.dataIndex, index);
return (PyObject*)ret;
@@ -1031,8 +1048,8 @@ PyObject * moose_ObjId_getSlice(_ObjId * self, Py_ssize_t start, Py_ssize_t end)
return PyTuple_New(0);
}
PyObject * ret = PyTuple_New((Py_ssize_t)(end - start));
-
- // Py_XINCREF(ret);
+
+ // Py_XINCREF(ret);
for ( int ii = start; ii < end; ++ii){
_ObjId * value = PyObject_New(_ObjId, &ObjIdType);
value->oid_ = ObjId(self->oid_.id, self->oid_.dataIndex, ii);
@@ -1095,39 +1112,39 @@ PyObject * getLookupField(ObjId target, char * fieldName, PyObject * key)
case 'h': {
ret = lookup_value <short> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'H': {
ret = lookup_value <unsigned short> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'i': {
ret = lookup_value <int> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'I': {
ret = lookup_value <unsigned int> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'l': {
ret = lookup_value <long> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'k': {
ret = lookup_value <unsigned long> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'L': {
ret = lookup_value <long long> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'K': {
ret = lookup_value <unsigned long long> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'd': {
ret = lookup_value <double> (target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'f': {
ret = lookup_value <float> (target, string(fieldName), value_type_code, key_type_code, key);
break;
@@ -1147,7 +1164,7 @@ PyObject * getLookupField(ObjId target, char * fieldName, PyObject * key)
case 'D': {
ret = lookup_value < vector <double> >(target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'S': {
ret = lookup_value < vector <string> >(target, string(fieldName), value_type_code, key_type_code, key);
break;
@@ -1175,11 +1192,11 @@ PyObject * getLookupField(ObjId target, char * fieldName, PyObject * key)
case 'F': {
ret = lookup_value < vector <float> >(target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'w': {
ret = lookup_value < vector <short> >(target, string(fieldName), value_type_code, key_type_code, key);
break;
- }
+ }
case 'C': {
ret = lookup_value < vector <char> >(target, string(fieldName), value_type_code, key_type_code, key);
break;
@@ -1242,11 +1259,11 @@ int setLookupField(ObjId target, char * fieldName, PyObject * key, PyObject * va
case 'I': {
ret = set_lookup_value <unsigned int> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'k': {
ret = set_lookup_value <unsigned long> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 's': {
ret = set_lookup_value <string> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
@@ -1254,19 +1271,19 @@ int setLookupField(ObjId target, char * fieldName, PyObject * key, PyObject * va
case 'i': {
ret = set_lookup_value <int> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'l': {
ret = set_lookup_value <long> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'L': {
ret = set_lookup_value <long long> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'K': {
ret = set_lookup_value <unsigned long long> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'b': {
ret = set_lookup_value <bool> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
@@ -1278,15 +1295,15 @@ int setLookupField(ObjId target, char * fieldName, PyObject * key, PyObject * va
case 'h': {
ret = set_lookup_value <short> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'H': {
ret = set_lookup_value <unsigned short> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'd': {
ret = set_lookup_value <double> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
- }
+ }
case 'f': {
ret = set_lookup_value <float> (target, string(fieldName), value_type_code, key_type_code, key, value);
break;
@@ -1304,7 +1321,7 @@ int setLookupField(ObjId target, char * fieldName, PyObject * key, PyObject * va
error << "setLookupField: invalid key type " << type_vec[0];
PyErr_SetString(PyExc_TypeError, error.str().c_str());
}
- return ret;
+ return ret;
}// setLookupField
PyDoc_STRVAR(moose_ObjId_setLookupField_documentation,
@@ -1373,7 +1390,7 @@ PyObject * moose_ObjId_setDestField(_ObjId * self, PyObject * args)
PyErr_SetString(PyExc_ValueError, error.str().c_str());
return NULL;
}
-
+
// Get the destFinfo name
char * fieldName = PyString_AsString(arglist[0]);
if (!fieldName){ // not a string, raises TypeError
@@ -1381,7 +1398,7 @@ PyObject * moose_ObjId_setDestField(_ObjId * self, PyObject * args)
PyErr_SetString(PyExc_TypeError, error.str().c_str());
return NULL;
}
-
+
// Try to parse the arguments.
vector< string > argType;
if (parseFinfoType(Field<string>::get(oid, "className"),
@@ -1419,7 +1436,7 @@ PyObject * setDestFinfo(ObjId obj, string fieldName, PyObject *arg, string argTy
ostringstream error;
error << "moose.setDestFinfo: ";
-switch (typecode){
+switch (typecode){
case 'f': case 'd': {
double param = PyFloat_AsDouble(arg);
if (typecode == 'f'){
@@ -1464,7 +1481,7 @@ switch (typecode){
if (id == NULL){
error << "argument should be an vec or an melement";
PyErr_SetString(PyExc_TypeError, error.str().c_str());
- return NULL;
+ return NULL;
}
param = id->id_;
ret = SetGet1<Id>::set(obj, fieldName, param);
@@ -1476,7 +1493,7 @@ switch (typecode){
if (oid == NULL){
error << "argument should be vec or an melement";
PyErr_SetString(PyExc_TypeError, error.str().c_str());
- return NULL;
+ return NULL;
}
param = oid->oid_;
ret = SetGet1<ObjId>::set(obj, fieldName, param);
@@ -1508,7 +1525,7 @@ switch (typecode){
}
case 'L': {//SET_VECFIELD(long, l) {
return _set_vector_destFinfo<long>(obj, string(fieldName), arg, typecode);
- }
+ }
case 'N': { //SET_VECFIELD(unsigned int, I)
return _set_vector_destFinfo<unsigned int>(obj, string(fieldName), arg, typecode);
}
@@ -1520,7 +1537,7 @@ switch (typecode){
}
case 'D': {//SET_VECFIELD(double, d)
return _set_vector_destFinfo<double>(obj, string(fieldName), arg, typecode);
- }
+ }
case 'S': {
return _set_vector_destFinfo<string>(obj, string(fieldName), arg, typecode);
}
@@ -1594,7 +1611,7 @@ switch (type2){
if (id == NULL){
error << "argument should be an vec or an melement";
PyErr_SetString(PyExc_TypeError, error.str().c_str());
- return NULL;
+ return NULL;
}
param = id->id_;
// } else if (ObjId_SubtypeCheck(arg)){
@@ -1602,7 +1619,7 @@ switch (type2){
// if (oid == NULL){
// error << "argument should be an vec or an melement";
// PyErr_SetString(PyExc_TypeError, error.str().c_str());
- // return NULL;
+ // return NULL;
// }
// param = oid->oid_.id;
// }
@@ -1615,7 +1632,7 @@ switch (type2){
// if (id == NULL){
// error << "argument should be an vec or an melement";
// PyErr_SetString(PyExc_TypeError, error.str().c_str());
- // return NULL;
+ // return NULL;
// }
// param = ObjId(id->id_);
// } else if (ObjId_SubtypeCheck(arg)){
@@ -1623,7 +1640,7 @@ switch (type2){
if (oid == NULL){
error << "argument should be an vec or an melement";
PyErr_SetString(PyExc_TypeError, error.str().c_str());
- return NULL;
+ return NULL;
}
param = oid->oid_;
// }
@@ -1654,26 +1671,31 @@ switch (type2){
PyDoc_STRVAR(moose_ObjId_getFieldNames_documenation,
"getFieldNames(fieldType='') -> tuple of str\n"
"\n"
- "Get the names of fields on this element.\n"
+ "Returns the names of fields of this element of fieldType kind.\n"
"\n"
"Parameters\n"
"----------\n"
"fieldType : str\n"
- " Field type to retrieve. Can be `valueFinfo`, `srcFinfo`,\n"
- " `destFinfo`, `lookupFinfo`, etc. If an empty string is specified,\n"
- " names of all avaialable fields are returned.\n"
+ " Type of the fields you wish to retrieve. Can be\n"
+ " - `valueFinfo` - attributes of the object\n"
+ " - `srcFinfo` - fields of the object which can be used as source of information for connect\n"
+ " - `destFinfo` - fields of the object which can be used as destination of information for connect\n"
+ " - `lookupFinfo`- fields which can be looked at through this object"
+ ", etc. If an empty string is specified, names of all avaialable fields are returned.\n"
"\n"
"Returns\n"
"-------\n"
"names : tuple of strings.\n"
- " names of the fields of the specified type.\n"
+ " names of the fields of the specified type.\n"
"\n"
"Examples\n"
"--------\n"
"List names of all the source fields in PulseGen class:\n"
"\n"
- " >>> moose.getFieldNames('PulseGen', 'srcFinfo')\n"
- " ('childMsg', 'output')\n"
+ " >>> comp.getFieldNames('lookupFinfo') \n"
+ " ('neighbors', 'msgDests', 'msgDestFunctions', 'isA')\n"
+ " >>> moose.getFieldNames('PulseGen', 'srcFinfo')\n"
+ " ('childMsg', 'output')\n"
"\n");
// 2011-03-23 15:28:26 (+0530)
PyObject * moose_ObjId_getFieldNames(_ObjId * self, PyObject *args)
@@ -1692,13 +1714,13 @@ PyObject * moose_ObjId_getFieldNames(_ObjId * self, PyObject *args)
for (const char **a = getFinfoTypes(); *a; ++a){
vector<string> fields = getFieldNames(className, string(*a));
ret.insert(ret.end(), fields.begin(), fields.end());
- }
+ }
} else {
ret = getFieldNames(className, ftype_str);
}
-
+
PyObject * pyret = PyTuple_New((Py_ssize_t)ret.size());
-
+
for (unsigned int ii = 0; ii < ret.size(); ++ ii ){
PyObject * fname = Py_BuildValue("s", ret[ii].c_str());
if (!fname){
@@ -1713,7 +1735,7 @@ PyObject * moose_ObjId_getFieldNames(_ObjId * self, PyObject *args)
break;
}
}
- return pyret;
+ return pyret;
}
PyDoc_STRVAR(moose_ObjId_getNeighbors_documentation,
@@ -1731,7 +1753,7 @@ PyDoc_STRVAR(moose_ObjId_getNeighbors_documentation,
"neighbors: tuple of vecs.\n"
" tuple containing the ids of the neighbour vecs.\n"
"\n");
-
+
PyObject * moose_ObjId_getNeighbors(_ObjId * self, PyObject * args)
{
if (!Id::isValid(self->oid_.id)){
@@ -1744,14 +1766,14 @@ PyObject * moose_ObjId_getNeighbors(_ObjId * self, PyObject * args)
vector< Id > val = LookupField< string, vector< Id > >::get(self->oid_, "neighbors", string(field));
PyObject * ret = PyTuple_New((Py_ssize_t)val.size());
-
- for (unsigned int ii = 0; ii < val.size(); ++ ii ){
+
+ for (unsigned int ii = 0; ii < val.size(); ++ ii ){
_Id * entry = PyObject_New(_Id, &IdType);
if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, (PyObject*)entry)){
Py_DECREF(ret);
// Py_DECREF((PyObject*)entry);
- ret = NULL;
- break;
+ ret = NULL;
+ break;
}
entry->id_ = val[ii];
}
@@ -1764,21 +1786,33 @@ PyObject * moose_ObjId_getNeighbors(_ObjId * self, PyObject * args)
// 2011-03-28 10:51:52 (+0530)
PyDoc_STRVAR(moose_ObjId_connect_documentation,
- "connect(srcfield, destobj, destfield, msgtype) -> bool\n"
+ "connect(src, srcfield, destobj, destfield[,msgtype]) -> bool\n"
"\n"
- "Connect another object via a message.\n"
+ "Create a message between `src_field` on `src` object to `dest_field` on `dest` object.\n"
+ "This function is used mainly, to say, connect two entities, and to denote what kind of give-and-take relationship they share."
+ "It enables the 'destfield' (of the 'destobj') to acquire the data, from 'srcfield'(of the 'src')."
"\n"
"Parameters\n"
"----------\n"
+ "src : element/vec/string\n"
+ " the source object (or its path) \n"
+ " (the one that provides information)\n"
"srcfield : str\n"
- " source field on self.\n"
+ " source field on self.(type of the information)\n"
"destobj : element\n"
" Destination object to connect to.\n"
+ " (The one that need to get information)\n"
"destfield : str\n"
" field to connect to on `destobj`.\n"
"msgtype : str\n"
- " type of the message. Can be `Single`, `OneToAll`, `AllToOne`,\n"
- " `OneToOne`, `Reduce`, `Sparse`. Default: `Single`.\n"
+ " type of the message. Can be \n"
+ " `Single` - \n"
+ " `OneToAll` - \n"
+ " `AllToOne` - \n"
+ " `OneToOne` - \n"
+ " `Reduce` - \n"
+ " `Sparse` - \n"
+ " Default: `Single`.\n"
"\n"
"Returns\n"
"-------\n"
@@ -1804,7 +1838,7 @@ PyObject * moose_ObjId_connect(_ObjId * self, PyObject * args)
if (!Id::isValid(self->oid_.id)){
RAISE_INVALID_ID(NULL, "moose_ObjId_connect");
}
- extern PyTypeObject ObjIdType;
+ extern PyTypeObject ObjIdType;
PyObject * destPtr = NULL;
char * srcField = NULL, * destField = NULL, * msgType = NULL;
static char default_msg_type[] = "Single";
@@ -1830,7 +1864,7 @@ PyObject * moose_ObjId_connect(_ObjId * self, PyObject * args)
"connect failed: check field names and type compatibility.");
return NULL;
}
- _ObjId* msgMgrId = (_ObjId*)PyObject_New(_ObjId, &ObjIdType);
+ _ObjId* msgMgrId = (_ObjId*)PyObject_New(_ObjId, &ObjIdType);
msgMgrId->oid_ = mid;
return (PyObject*)msgMgrId;
}
@@ -1840,7 +1874,7 @@ PyDoc_STRVAR(moose_ObjId_richcompare_documentation,
"the paths of the element instances. This function exists only to\n"
"facilitate certain operations requiring sorting/comparison, like\n"
"using elements for dict keys. Conceptually only equality comparison is\n"
- "meaningful for elements.\n");
+ "meaningful for elements.\n");
PyObject* moose_ObjId_richcompare(_ObjId * self, PyObject * other, int op)
{
if (!Id::isValid(self->oid_.id)){
@@ -1892,13 +1926,19 @@ PyObject* moose_ObjId_richcompare(_ObjId * self, PyObject * other, int op)
PyDoc_STRVAR(moose_ObjId_getDataIndex_documentation,
"getDataIndex() -> int\n"
"\n"
- "Get the dataIndex of this object.\n"
+ "Returns the dataIndex (position of the object in vector) "
+ "of this object, if it belongs to a vector, otherwise returns 0.\n"
+ "\n"
+ " >>> comp = moose.Compartment('/comp')\n"
+ " >>> comp.getDataIndex()\n"
+ " >>> 0\n"
+ ""
);
PyObject * moose_ObjId_getDataIndex(_ObjId * self)
{
if (!Id::isValid(self->oid_.id)){
RAISE_INVALID_ID(NULL, "moose_ObjId_getDataIndex");
- }
+ }
PyObject * ret = Py_BuildValue("I", self->oid_.dataIndex);
return ret;
}
@@ -1921,7 +1961,7 @@ PyObject * moose_ObjId_getFieldIndex(_ObjId * self)
static PyMethodDef ObjIdMethods[] = {
{"getFieldType", (PyCFunction)moose_ObjId_getFieldType, METH_VARARGS,
- moose_ObjId_getFieldType_documentation},
+ moose_ObjId_getFieldType_documentation},
{"getField", (PyCFunction)moose_ObjId_getField, METH_VARARGS,
moose_ObjId_getField_documentation},
{"setField", (PyCFunction)moose_ObjId_setField, METH_VARARGS,
@@ -1947,7 +1987,7 @@ static PyMethodDef ObjIdMethods[] = {
"Get the index of this object as a field."},
{"setDestField", (PyCFunction)moose_ObjId_setDestField, METH_VARARGS,
moose_ObjId_setDestField_documentation},
- {NULL, NULL, 0, NULL}, /* Sentinel */
+ {NULL, NULL, 0, NULL}, /* Sentinel */
};
@@ -2011,7 +2051,7 @@ PyDoc_STRVAR(moose_ObjId_documentation,
">>> c = moose.melement(b)"
);
-PyTypeObject ObjIdType = {
+PyTypeObject ObjIdType = {
PyVarObject_HEAD_INIT(NULL, 0) /* tp_head */
"moose.melement", /* tp_name */
sizeof(_ObjId), /* tp_basicsize */
@@ -2055,5 +2095,5 @@ PyTypeObject ObjIdType = {
-//
+//
// melement.cpp ends here
diff --git a/pymoose/mfield.cpp b/pymoose/mfield.cpp
index 18bd3f73..7995427f 100644
--- a/pymoose/mfield.cpp
+++ b/pymoose/mfield.cpp
@@ -163,7 +163,6 @@ PyObject * moose_Field_repr(_Field * self)
return PyString_FromString(fieldPath.str().c_str());
}
-
PyDoc_STRVAR(moose_Field_documentation,
"Base class for MOOSE fields.\n"
"\n"
@@ -175,8 +174,6 @@ PyDoc_STRVAR(moose_Field_documentation,
"are putting fields as dictionary keys, you should do that after names\n"
"of all elements have been finalized.\n"
"\n");
-
-
static PyTypeObject moose_Field =
{
PyVarObject_HEAD_INIT(NULL, 0)
diff --git a/pymoose/moosemodule.cpp b/pymoose/moosemodule.cpp
index 1ac1d91f..70295a15 100644
--- a/pymoose/moosemodule.cpp
+++ b/pymoose/moosemodule.cpp
@@ -75,10 +75,10 @@ using namespace std;
extern void testSync();
extern void testAsync();
-extern void testSyncArray(
+extern void testSyncArray(
unsigned int size,
unsigned int numThreads,
- unsigned int method
+ unsigned int method
);
extern void testShell();
@@ -104,14 +104,14 @@ extern void test_moosemodule();
extern Id init(
int argc, char ** argv, bool& doUnitTests
- , bool& doRegressionTests, unsigned int& benchmark
+ , bool& doRegressionTests, unsigned int& benchmark
);
extern void initMsgManagers();
extern void destroyMsgManagers();
extern void speedTestMultiNodeIntFireNetwork(
- unsigned int size, unsigned int runsteps
+ unsigned int size, unsigned int runsteps
);
extern void mooseBenchmarks( unsigned int option );
@@ -1350,8 +1350,12 @@ PyDoc_STRVAR(moose_getFieldNames_documentation,
"className : string\n"
" Name of the class to look up.\n"
"finfoType : string\n"
- " The kind of field (`valueFinfo`, `srcFinfo`, `destFinfo`,\n"
- " `lookupFinfo`, `fieldElementFinfo`.).\n"
+ " The kind of field "
+ " `valueFinfo` - "
+ " `srcFinfo` - "
+ " `destFinfo` - "
+ " `lookupFinfo`- "
+ " `fieldElementFinfo` - \n"
"\n"
"Returns\n"
"-------\n"
@@ -1383,31 +1387,32 @@ PyObject * moose_getFieldNames(PyObject * dummy, PyObject * args)
}
PyDoc_STRVAR(moose_copy_documentation,
- "copy(src, dest, name, n, toGlobal, copyExtMsg) -> bool\n"
- "\n"
- "Make copies of a moose object.\n"
- "\n"
- "Parameters\n"
- "----------\n"
- "src : vec, element or str\n"
- " source object.\n"
- "dest : vec, element or str\n"
- " Destination object to copy into.\n"
- "name : str\n"
- " Name of the new object. If omitted, name of the original will be used.\n"
- "n : int\n"
- " Number of copies to make.\n"
- "toGlobal : int\n"
- " Relevant for parallel environments only. If false, the copies will\n"
- " reside on local node, otherwise all nodes get the copies.\n"
- "copyExtMsg : int\n"
- " If true, messages to/from external objects are also copied.\n"
- "\n"
- "Returns\n"
- "-------\n"
- "vec\n"
- " newly copied vec\n"
+ "copy(src, dest, name, n, toGlobal, copyExtMsg) -> bool\n"
+ "\n"
+ "Make copies of a moose object.\n"
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "src : vec, element or str\n"
+ " source object.\n"
+ "dest : vec, element or str\n"
+ " Destination object to copy into.\n"
+ "name : str\n"
+ " Name of the new object. If omitted, name of the original will be used.\n"
+ "n : int\n"
+ " Number of copies to make.\n"
+ "toGlobal : int\n"
+ " Relevant for parallel environments only. If false, the copies will\n"
+ " reside on local node, otherwise all nodes get the copies.\n"
+ "copyExtMsg : int\n"
+ " If true, messages to/from external objects are also copied.\n"
+ "\n"
+ "Returns\n"
+ "-------\n"
+ "vec\n"
+ " newly copied vec\n"
);
+
PyObject * moose_copy(PyObject * dummy, PyObject * args, PyObject * kwargs)
{
PyObject * src = NULL, * dest = NULL;
@@ -1643,8 +1648,8 @@ PyDoc_STRVAR(moose_useClock_documentation,
"Examples\n"
"--------\n"
"In multi-compartmental neuron model a compartment's membrane potential (Vm) is dependent on its neighbours' membrane potential. Thus it must get the neighbour's present Vm before computing its own Vm in next time step. This ordering is achieved by scheduling the `init` function, which communicates membrane potential, on tick 0 and `process` function on tick 1.\n\n"
- " >>> moose.useClock(0, '/model/compartment_1', 'init')\n"
- " >>> moose.useClock(1, '/model/compartment_1', 'process')\n");
+ " >>> moose.useClock(0, '/model/compartment_1', 'init')\n"
+ " >>> moose.useClock(1, '/model/compartment_1', 'process')\n");
PyObject * moose_useClock(PyObject * dummy, PyObject * args)
{
@@ -1952,42 +1957,52 @@ PyObject * moose_getCwe(PyObject * dummy, PyObject * args)
}
PyDoc_STRVAR(moose_connect_documentation,
- "connect(src, src_field, dest, dest_field, message_type) -> bool\n"
- "\n"
- "Create a message between `src_field` on `src` object to `dest_field`\n"
- "on `dest` object.\n"
- "\n"
- "Parameters\n"
- "----------\n"
- "src : element/vec/string\n"
- " the source object (or its path)\n"
- "src_field : str\n"
- " the source field name. Fields listed under `srcFinfo` and\n"
- " `sharedFinfo` qualify for this.\n"
- "dest : element/vec/string\n"
- " the destination object.\n"
- "dest_field : str\n"
- " the destination field name. Fields listed under `destFinfo`\n"
- " and `sharedFinfo` qualify for this.\n"
- "message_type : str (optional)\n"
- " Type of the message. Can be `Single`, `OneToOne`, `OneToAll`.\n"
- " If not specified, it defaults to `Single`.\n"
- "\n"
- "Returns\n"
- "-------\n"
- "msgmanager: melement\n"
- " message-manager for the newly created message.\n"
- "\n"
- "Examples\n"
- "--------\n"
- "Connect the output of a pulse generator to the input of a spike\n"
- "generator::\n"
- "\n"
- ">>> pulsegen = moose.PulseGen('pulsegen')\n"
- ">>> spikegen = moose.SpikeGen('spikegen')\n"
- ">>> moose.connect(pulsegen, 'output', spikegen, 'Vm')\n"
- "\n"
- );
+ "connect(src, srcfield, destobj, destfield[,msgtype]) -> bool\n"
+ "\n"
+ "Create a message between `src_field` on `src` object to `dest_field` on `dest` object.\n"
+ "This function is used mainly, to say, connect two entities, and to denote what kind of give-and-take relationship they share."
+ "It enables the 'destfield' (of the 'destobj') to acquire the data, from 'srcfield'(of the 'src')."
+ "\n"
+ "Parameters\n"
+ "----------\n"
+ "src : element/vec/string\n"
+ " the source object (or its path) \n"
+ " (the one that provides information)\n"
+ "srcfield : str\n"
+ " source field on self.(type of the information)\n"
+ "destobj : element\n"
+ " Destination object to connect to.\n"
+ " (The one that need to get information)\n"
+ "destfield : str\n"
+ " field to connect to on `destobj`.\n"
+ "msgtype : str\n"
+ " type of the message. Can be \n"
+ " `Single` - \n"
+ " `OneToAll` - \n"
+ " `AllToOne` - \n"
+ " `OneToOne` - \n"
+ " `Reduce` - \n"
+ " `Sparse` - \n"
+ " Default: `Single`.\n"
+ "\n"
+ "Returns\n"
+ "-------\n"
+ "msgmanager: melement\n"
+ " message-manager for the newly created message.\n"
+ "\n"
+ "Examples\n"
+ "--------\n"
+ "Connect the output of a pulse generator to the input of a spike\n"
+ "generator::\n"
+ "\n"
+ " >>> pulsegen = moose.PulseGen('pulsegen')\n"
+ " >>> spikegen = moose.SpikeGen('spikegen')\n"
+ " >>> pulsegen.connect('output', spikegen, 'Vm')\n"
+ "\n"
+ "See also\n"
+ "--------\n"
+ "moose.connect\n"
+ );
PyObject * moose_connect(PyObject * dummy, PyObject * args)
{
@@ -2085,7 +2100,7 @@ PyDoc_STRVAR(moose_getFieldDict_documentation,
"List all the source fields on class Neutral::\n"
"\n"
">>> moose.getFieldDict('Neutral', 'srcFinfo')\n"
- "{'childMsg': 'int'}\n"
+ " {'childMsg': 'int'}\n"
"\n"
"\n");
PyObject * moose_getFieldDict(PyObject * dummy, PyObject * args)
@@ -2499,16 +2514,114 @@ int defineAllClasses(PyObject * module_dict)
have to recursively call this function using the base class
string.
*/
+
PyDoc_STRVAR(moose_Class_documentation,
"*-----------------------------------------------------------------*\n"
"* This is Python generated documentation. *\n"
"* Use moose.doc('classname') to display builtin documentation for *\n"
"* class `classname`. *\n"
"* Use moose.doc('classname.fieldname') to display builtin *\n"
- "* documentationfor `field` in class `classname`. *\n"
+ "* documentation for `field` in class `classname`. *\n"
"*-----------------------------------------------------------------*\n"
);
+int defineLookupFinfos(const Cinfo * cinfo)
+{
+ const string & className = cinfo->name();
+#ifndef NDEBUG
+ if (verbosity > 1)
+ {
+ cout << "\tDefining lookupFields for " << className << endl;
+ }
+#endif
+ unsigned int num = cinfo->getNumLookupFinfo();
+ unsigned int currIndex = get_getsetdefs()[className].size();
+ for (unsigned int ii = 0; ii < num; ++ii)
+ {
+ const string& name = const_cast<Cinfo*>(cinfo)->getLookupFinfo(ii)->name();
+ PyGetSetDef getset;
+ get_getsetdefs()[className].push_back(getset);
+ get_getsetdefs()[className][currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
+ strncpy(const_cast<char*>(get_getsetdefs()[className][currIndex].name)
+ , const_cast<char*>(name.c_str()), name.size());
+ get_getsetdefs()[className][currIndex].doc = (char*) "Lookup field";
+ get_getsetdefs()[className][currIndex].get = (getter)moose_ObjId_get_lookupField_attr;
+ PyObject * args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
+ get_getsetdefs()[className][currIndex].closure = (void*)args;
+#ifndef NDEBUG
+ if (verbosity > 1)
+ {
+ cout << "\tDefined lookupField " << get_getsetdefs()[className][currIndex].name << endl;
+ }
+#endif
+
+ ++currIndex;
+ }
+ return 1;
+}
+
+int defineDestFinfos(const Cinfo * cinfo)
+{
+ const string& className = cinfo->name();
+#ifndef NDEBUG
+ if (verbosity > 1)
+ {
+ cout << "\tCreating destField attributes for " << className << endl;
+ }
+#endif
+ vector <PyGetSetDef>& vec = get_getsetdefs()[className];
+ /*
+ We do not know the final number of user-accessible
+ destFinfos as we have to ignore the destFinfos starting
+ with get/set. So use a vector instead of C array.
+ */
+ size_t currIndex = vec.size();
+ for (unsigned int ii = 0; ii < cinfo->getNumDestFinfo(); ++ii)
+ {
+ Finfo * destFinfo = const_cast<Cinfo*>(cinfo)->getDestFinfo(ii);
+ const string& name = destFinfo->name();
+ /*
+ get_{xyz} and set_{xyz} are internal destFinfos for
+ accessing valueFinfos. Ignore them.
+
+ With the '_' removed from internal get/set for value
+ fields, we cannot separate them out. - Subha Fri Jan 31
+ 16:43:51 IST 2014
+
+ The policy changed in the past and hence the following were commented out.
+ - Subha Tue May 26 00:25:28 EDT 2015
+ */
+ // if (name.find("get") == 0 || name.find("set") == 0){
+ // continue;
+ // }
+ PyGetSetDef destFieldGetSet;
+ vec.push_back(destFieldGetSet);
+
+ vec[currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
+ strncpy(vec[currIndex].name,
+ const_cast<char*>(name.c_str()),
+ name.size());
+
+ vec[currIndex].doc = (char*) "D_field";
+ vec[currIndex].get = (getter)moose_ObjId_get_destField_attr;
+ PyObject * args = PyTuple_New(1);
+ if (args == NULL)
+ {
+ cerr << "moosemodule.cpp: defineDestFinfos: Failed to allocate tuple" << endl;
+ return 0;
+ }
+ PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
+ vec[currIndex].closure = (void*)args;
+
+ //LOG( debug, "\tCreated destField " << vec[currIndex].name );
+
+ ++currIndex;
+ } // ! for
+
+ return 1;
+}
+
int defineClass(PyObject * module_dict, const Cinfo * cinfo)
{
const string& className = cinfo->name();
@@ -2577,7 +2690,7 @@ int defineClass(PyObject * module_dict, const Cinfo * cinfo)
new_class->tp_name = strdup(str.c_str());
new_class->tp_doc = moose_Class_documentation;
- // strncpy(new_class->tp_doc, moose_Class_documentation, strlen(moose_Class_documentation));
+ //strncpy(new_class->tp_doc, moose_Class_documentation, strlen(moose_Class_documentation));
map<string, PyTypeObject *>::iterator base_iter =
get_moose_classes().find(cinfo->getBaseClass());
if (base_iter == get_moose_classes().end())
@@ -2682,68 +2795,6 @@ PyObject * moose_ObjId_get_destField_attr(PyObject * self, void * closure)
return (PyObject*)ret;
}
-
-int defineDestFinfos(const Cinfo * cinfo)
-{
- const string& className = cinfo->name();
-#ifndef NDEBUG
- if (verbosity > 1)
- {
- cout << "\tCreating destField attributes for " << className << endl;
- }
-#endif
- vector <PyGetSetDef>& vec = get_getsetdefs()[className];
- /*
- We do not know the final number of user-accessible
- destFinfos as we have to ignore the destFinfos starting
- with get/set. So use a vector instead of C array.
- */
- size_t currIndex = vec.size();
- for (unsigned int ii = 0; ii < cinfo->getNumDestFinfo(); ++ii)
- {
- Finfo * destFinfo = const_cast<Cinfo*>(cinfo)->getDestFinfo(ii);
- const string& name = destFinfo->name();
- /*
- get_{xyz} and set_{xyz} are internal destFinfos for
- accessing valueFinfos. Ignore them.
-
- With the '_' removed from internal get/set for value
- fields, we cannot separate them out. - Subha Fri Jan 31
- 16:43:51 IST 2014
-
- The policy changed in the past and hence the following were commented out.
- - Subha Tue May 26 00:25:28 EDT 2015
- */
- // if (name.find("get") == 0 || name.find("set") == 0){
- // continue;
- // }
- PyGetSetDef destFieldGetSet;
- vec.push_back(destFieldGetSet);
-
- vec[currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
- strncpy(vec[currIndex].name,
- const_cast<char*>(name.c_str()),
- name.size());
-
- vec[currIndex].doc = (char*) "Destination field";
- vec[currIndex].get = (getter)moose_ObjId_get_destField_attr;
- PyObject * args = PyTuple_New(1);
- if (args == NULL)
- {
- cerr << "moosemodule.cpp: defineDestFinfos: Failed to allocate tuple" << endl;
- return 0;
- }
- PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
- vec[currIndex].closure = (void*)args;
-
- //LOG( debug, "\tCreated destField " << vec[currIndex].name );
-
- ++currIndex;
- } // ! for
-
- return 1;
-}
-
/**
Try to obtain a LookupField object for a specified
lookupFinfo. The first item in `closure` must be the name of
@@ -2796,42 +2847,6 @@ PyObject * moose_ObjId_get_lookupField_attr(PyObject * self,
return (PyObject*)ret;
}
-int defineLookupFinfos(const Cinfo * cinfo)
-{
- const string & className = cinfo->name();
-#ifndef NDEBUG
- if (verbosity > 1)
- {
- cout << "\tDefining lookupFields for " << className << endl;
- }
-#endif
- unsigned int num = cinfo->getNumLookupFinfo();
- unsigned int currIndex = get_getsetdefs()[className].size();
- for (unsigned int ii = 0; ii < num; ++ii)
- {
- const string& name = const_cast<Cinfo*>(cinfo)->getLookupFinfo(ii)->name();
- PyGetSetDef getset;
- get_getsetdefs()[className].push_back(getset);
- get_getsetdefs()[className][currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
- strncpy(const_cast<char*>(get_getsetdefs()[className][currIndex].name)
- , const_cast<char*>(name.c_str()), name.size());
- get_getsetdefs()[className][currIndex].doc = (char*) "Lookup field";
- get_getsetdefs()[className][currIndex].get = (getter)moose_ObjId_get_lookupField_attr;
- PyObject * args = PyTuple_New(1);
- PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
- get_getsetdefs()[className][currIndex].closure = (void*)args;
-#ifndef NDEBUG
- if (verbosity > 1)
- {
- cout << "\tDefined lookupField " << get_getsetdefs()[className][currIndex].name << endl;
- }
-#endif
-
- ++currIndex;
- }
- return 1;
-}
-
PyObject * moose_ObjId_get_elementField_attr(PyObject * self,
void * closure)
{
@@ -3230,15 +3245,15 @@ PyMODINIT_FUNC MODINIT(_moose)
clock_t defclasses_end = clock();
- LOG( moose::info, "`Time to define moose classes:"
+ LOG( moose::info, "`Time to define moose classes:"
<< (defclasses_end - defclasses_start) * 1.0 /CLOCKS_PER_SEC
);
PyGILState_Release(gstate);
clock_t modinit_end = clock();
- LOG( moose::info, "`Time to initialize module:"
- << (modinit_end - modinit_start) * 1.0 /CLOCKS_PER_SEC
+ LOG( moose::info, "`Time to initialize module:"
+ << (modinit_end - modinit_start) * 1.0 /CLOCKS_PER_SEC
);
if (doUnitTests)
diff --git a/pymoose/pymooseinit.cpp b/pymoose/pymooseinit.cpp
index d089447c..e5719af6 100644
--- a/pymoose/pymooseinit.cpp
+++ b/pymoose/pymooseinit.cpp
@@ -65,7 +65,7 @@ extern unsigned int initMsgManagers();
extern void destroyMsgManagers();
// void regressionTests();
#endif
-extern void speedTestMultiNodeIntFireNetwork(
+extern void speedTestMultiNodeIntFireNetwork(
unsigned int size, unsigned int runsteps );
#ifdef USE_SMOLDYN
@@ -95,7 +95,7 @@ unsigned int getNumCores()
#ifdef MACOSX
int mib[4];
- size_t len = sizeof(numCPU);
+ size_t len = sizeof(numCPU);
/* set the mib for hw.ncpu */
mib[0] = CTL_HW;
@@ -104,7 +104,7 @@ unsigned int getNumCores()
/* get the number of CPUs from the system */
sysctl(mib, 2, &numCPU, &len, NULL, 0);
- if( numCPU < 1 )
+ if( numCPU < 1 )
{
mib[1] = HW_NCPU;
sysctl( mib, 2, &numCPU, &len, NULL, 0 );
@@ -112,7 +112,7 @@ unsigned int getNumCores()
#endif
if ( numCPU < 1 )
{
-#ifndef QUIET_MODE
+#ifndef QUIET_MODE
cout << "No CPU information available. Assuming single core." << endl;
#else
#endif
@@ -129,7 +129,7 @@ void checkChildren( Id parent, const string& info )
{
vector< Id > ret;
Neutral::children( parent.eref(), ret );
- cout << info << " checkChildren of " <<
+ cout << info << " checkChildren of " <<
parent.element()->getName() << ": " <<
ret.size() << " children\n";
for ( vector< Id >::iterator i = ret.begin(); i != ret.end(); ++i )
@@ -199,16 +199,16 @@ Id init( int argc, char** argv, bool& doUnitTests, bool& doRegressionTests,
exit( 1 );
}
}
- if ( myNode == 0 )
+ if ( myNode == 0 )
{
#ifndef QUIET_MODE
- cout << "on node " << myNode << ", numNodes = "
+ cout << "on node " << myNode << ", numNodes = "
<< numNodes << ", numCores = " << numCores << endl;
#endif
}
Id shellId;
- Element* shelle =
+ Element* shelle =
new GlobalDataElement( shellId, Shell::initCinfo(), "root", 1 );
Id clockId = Id::nextId();
@@ -254,7 +254,7 @@ Id init( int argc, char** argv, bool& doUnitTests, bool& doRegressionTests,
// SetGet::setShell();
// Msg* m = new OneToOneMsg( shelle, shelle );
// assert ( m != 0 );
-
+
while ( isInfinite ) // busy loop for debugging under gdb and MPI.
;
diff --git a/pymoose/test_moosemodule.cpp b/pymoose/test_moosemodule.cpp
index 922ca59d..5eedaec2 100644
--- a/pymoose/test_moosemodule.cpp
+++ b/pymoose/test_moosemodule.cpp
@@ -1,47 +1,47 @@
// test_moosemodule.cpp ---
-//
+//
// Filename: test_moosemodule.cpp
-// Description:
-// Author:
-// Maintainer:
+// Description:
+// Author:
+// Maintainer:
// Created: Tue Jul 23 11:37:57 2013 (+0530)
-// Version:
+// Version:
// Last-Updated: Thu Jul 25 21:54:10 2013 (+0530)
// By: subha
// Update #: 85
-// URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
-//
-//
-//
+// URL:
+// Keywords:
+// Compatibility:
+//
+//
+
+// Commentary:
+//
+//
+//
+//
// Change log:
-//
-//
-//
-//
+//
+//
+//
+//
// 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, 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; see the file COPYING. If not, write to
// the Free Software Foundation, Inc., 51 Franklin Street, Fifth
// Floor, Boston, MA 02110-1301, USA.
-//
-//
+//
+//
// Code:
@@ -62,7 +62,7 @@ extern "C" {
void test_to_py()
{
#ifdef DO_UNIT_TESTS
- // conversion of double
+ // conversion of double
PyObject * pv;
double dv = 10.0;
pv = to_py((void*)&dv, 'd');
@@ -70,7 +70,7 @@ extern "C" {
assert(PyFloat_AsDouble(pv) == dv);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// conversion of long
long lv = 1000000000;
pv = to_py((void*)&lv, 'l');
@@ -78,7 +78,7 @@ extern "C" {
assert(PyLong_AsLong(pv) == lv);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// conversion of int
int iv = 10;
pv = to_py((void*)&iv, 'i');
@@ -86,7 +86,7 @@ extern "C" {
assert(PyInt_AsLong(pv) == iv);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// conversion of float
float fv = 7e-3;
pv = to_py((void*)&fv, 'f');
@@ -94,7 +94,7 @@ extern "C" {
assert(PyFloat_AsDouble(pv) == fv);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// string char-array
string sv = "hello world";
// C++ string
@@ -103,7 +103,7 @@ extern "C" {
assert(strcmp(PyString_AsString(pv), sv.c_str()) == 0);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// Id
Shell * shell = reinterpret_cast< Shell * >(ObjId( Id(), 0).data());
Id id = shell->doCreate("Neutral", Id(), "n", 1);
@@ -112,7 +112,7 @@ extern "C" {
assert(((_Id*)pv)->id_ == id);
Py_XDECREF(pv);
cout << "." << flush;
-
+
// ObjId
ObjId oid(id, 0);
pv = to_py((void*)&oid, 'y');
@@ -132,7 +132,7 @@ extern "C" {
#endif
}
-
+
} // extern "C"
void test_moosemodule()
@@ -140,5 +140,5 @@ void test_moosemodule()
test_to_py();
}
-//
+//
// test_moosemodule.cpp ends here
diff --git a/pymoose/vec.cpp b/pymoose/vec.cpp
index c178b4bf..733d2896 100644
--- a/pymoose/vec.cpp
+++ b/pymoose/vec.cpp
@@ -26,7 +26,7 @@
// Mon Jul 22 16:47:10 IST 2013 - Splitting contents of
// moosemodule.cpp into speparate files.
//
-//
+//c
// 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, or
@@ -85,6 +85,11 @@ PyDoc_STRVAR(moose_Id_delete_doc,
"\nDelete the underlying moose object. This will invalidate all"
"\nreferences to this object and any attempt to access it will raise a"
"\nValueError."
+ "\n Example"
+ "\n--------"
+ "\n >>>iaf.delete()"
+ "\n >>>print iaf.path"
+ "\n \\ "
"\n");
PyDoc_STRVAR(moose_Id_setField_doc,
@@ -97,13 +102,20 @@ PyDoc_STRVAR(moose_Id_setField_doc,
"fieldname: str\n"
" field to be set.\n"
"value: sequence of values\n"
- " sequence of values corresponding to individual elements under this\n"
- " vec.\n"
- "\n"
+ " sequence of values corresponding to individual elements"
+ " under this vec.\n"
+ "\n Example"
+ "\n--------"
+ "\n >>> iaf.setField('Vm', 20)"
+ "\n >>> print iaf.Vm"
+ "\n [ 20. 20. 20. 20. 20. 20. 20. 20. 20. 20.]"
+ "\n >>> iaf.setField('Vm', (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))"
+ "\n >>> print iaf.Vm"
+ "\n [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]"
"Notes\n"
"-----\n"
- " This is an interface to SetGet::setVec\n"
- );
+ " This is an interface to SetGet::setVec"
+ "\n");
static PyMethodDef IdMethods[] =
{
@@ -115,15 +127,15 @@ static PyMethodDef IdMethods[] =
},
{
"getValue", (PyCFunction)moose_Id_getValue, METH_NOARGS,
- "Return integer representation of the id of the element."
+ "Returns integer representation of the id of the element."
},
{
"getPath", (PyCFunction)moose_Id_getPath, METH_NOARGS,
- "Return the path of this vec object."
+ "Returns the path of this vec object."
},
{
"getShape", (PyCFunction)moose_Id_getShape, METH_NOARGS,
- "Get the shape of the vec object as a tuple."
+ "Returns the shape of the vec object as a tuple."
},
{
"setField", (PyCFunction)moose_Id_setField, METH_VARARGS,
@@ -166,46 +178,24 @@ PyDoc_STRVAR(moose_Id_doc,
"\n"
"array-elements are array-like objects which can have one or more"
" single-elements within them."
- " vec can be traversed like a Python sequence and is item is an"
+ " vec can be traversed like a Python sequence and its each item is an"
" element identifying single-objects contained in the array element.\n"
"\n"
- "you can create multiple references to the same MOOSE object in Python,"
- " but as long as they have the same path/id value, they all point to"
+ "you can create multiple references to the same MOOSE object in Python."
+ " As long as they have the same path/id value, they all point to"
" the same entity in MOOSE.\n"
"\n"
"Field access are vectorized. For example, if `comp` is a vec of"
- " Compartments, which has a field called `Vm` for membrane voltage, then"
+ " Compartments (of size 10), which has a field called `Vm` as membrane voltage, then"
" `comp.Vm` returns a"
- " tuple containing the `Vm` value of all the single-elements in this"
+ " tuple containing the `Vm` value of all 10 single-elements in this"
" vec. There are a few special fields that are unique for vec and are not"
" vectorized. These are `path`, `name`, `value`, `shape` and `className`."
- " There are two ways an vec can be initialized, (1) create a new array"
- " element or (2) create a reference to an existing object.\n"
- "\n Fields:"
- "\n -------"
- "\n path : str"
- "\n Path of the vec. In moose vecs are organized in a tree structure"
- " like unix file system and the paths follow the same convention."
- "\n"
- "\n name : str"
- "\n Name of the vec."
- "\n"
- "\n value : int/long"
- "\n Numeric identifier of the vec. This is unique within a single"
- " execution. vec comparison is based on this value and its hash is also"
- " this. So you can compare and sort vecs and use them as dict keys."
- "\n"
- "\n shape : tuple of ints"
- "\n Dimensions of the vec (as shape in numpy.ndarray). Currently only"
- " one-dimensional vecs are implemented."
- "\n"
- "\n className: str"
- "\n The class of the moose object this vec contains. MOOSE core"
- " implements its own class system independent of Python. pymoose creates"
- " thin wrappers around them. This field provides you the moose class"
- " name as defined in C++"
+ " There are two ways an vec can be initialized, \n"
+ "(1) create a new array element or \n"
+ "(2) create a reference to an existing object.\n"
"\n"
- "\n Constructor:"
+ "\n Constructor:"
"\n"
"\n vec(self, path=path, n=size, g=isGlobal, dtype=className)"
"\n "
@@ -214,20 +204,18 @@ PyDoc_STRVAR(moose_Id_doc,
"\n ----------"
"\n path : str/vec/int "
"\n Path of an existing array element or for creating a new one. This has"
- "\n the same format as unix file path: /{element1}/{element2} ... If there"
- "\n is no object with the specified path, moose attempts to create a new"
- "\n array element. For that to succeed everything until the last `/`"
+ "\n the same format as unix file path: /{element1}/{element2} ... "
+ "\n If there is no object with the specified path, moose attempts to create "
+ "\n a new array element. For that to succeed everything until the last `/`"
"\n character must exist or an error is raised"
"\n"
- "\n Alternatively, path can be vec or integer value of the id of an"
+ "\n Alternatively, path can be vec or integer value of the Id of an"
"\n existing vec object. The new object will be another reference to"
"\n the existing object."
"\n "
"\n n : positive int"
"\n This is a positive integers specifying the size of the array element"
- "\n to be created. Thus n=2 will create an"
- "\n vec with 2 elements."
- "\n "
+ "\n to be created. Thus n=2 will create an vec with 2 elements."
"\n "
"\n g : int"
"\n Specify if this is a global or local element. Global elements are"
@@ -236,15 +224,39 @@ PyDoc_STRVAR(moose_Id_doc,
"\n dtype: string"
"\n The vector will be of this moose-class."
"\n "
+ "\n Attributes:"
+ "\n -----------"
+ "\n path : str"
+ "\n Path of the vec. In moose vecs are organized in a tree structure"
+ " like unix file system and the paths follow the same convention."
+ "\n"
+ "\n name : str"
+ "\n Name of the vec."
+ "\n"
+ "\n value : int/long"
+ "\n Numeric identifier of the vec. This is unique within a single"
+ " execution. vec comparison is based on this value and its hash is also"
+ " this. So you can compare and sort vecs and use them as dict keys."
+ "\n"
+ "\n shape : tuple of ints"
+ "\n Dimensions of the vec (as shape in numpy.ndarray). Currently only"
+ " one-dimensional vecs are implemented."
+ "\n"
+ "\n className: str"
+ "\n The class of the moose object this vec contains. MOOSE core"
+ " implements its own class system independent of Python. pymoose creates"
+ " thin wrappers around them. This field provides you the moose class"
+ " name as defined in C++"
+ "\n"
"\n "
"\n Examples"
"\n ---------"
"\n >>> iaf = moose.vec('/iaf', n=10, dtype='IntFire')"
"\n >>> iaf.Vm = range(10)"
"\n >>> print iaf[5].Vm"
- "\n 5.0"
+ "\n 5.0"
"\n >>> print iaf.Vm"
- "\n array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
+ "\n array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
);
PyTypeObject IdType =
diff --git a/python/moose/SBML/readSBML.py b/python/moose/SBML/readSBML.py
index 4dcc89cc..7f3d8535 100644
--- a/python/moose/SBML/readSBML.py
+++ b/python/moose/SBML/readSBML.py
@@ -13,8 +13,7 @@
** copyright (C) 2003-2017 Upinder S. Bhalla. and NCBS
Created : Thu May 12 10:19:00 2016(+0530)
Version
-Last-Updated: Mon Apr 3 15:50:00 2017(+0530)
-
+Last-Updated: Wed Jan 11 2017
By:
**********************************************************************/
@@ -24,15 +23,15 @@ import sys
import os.path
import collections
import moose
+from .validation import validateModel
-from moose.SBML.validation import validateModel
-
-import re
'''
TODO in
-Compartment
+ --Need to add group
--Need to deal with compartment outside
-Molecule
+ -- Need to add group
-- mathML only AssisgmentRule is taken partly I have checked addition and multiplication,
--, need to do for other calculation.
-- In Assisgment rule one of the variable is a function, in moose since assignment is done using function,
@@ -63,15 +62,13 @@ def mooseReadSBML(filepath, loadpath, solver="ee"):
if not foundLibSBML_:
print('No python-libsbml found.'
'\nThis module can be installed by following command in terminal:'
- '\n\t easy_install python-libsbml'
- '\n\t apt-get install python-libsbml'
+ '\n\t easy_install python-libsbl'
)
- return moose.element('/')
+ return None
if not os.path.isfile(filepath):
print('%s is not found ' % filepath)
- return moose.element('/')
-
+ return None
with open(filepath, "r") as filep:
filep = open(filepath, "r")
@@ -119,10 +116,10 @@ def mooseReadSBML(filepath, loadpath, solver="ee"):
return moose.element('/')
else:
baseId = moose.Neutral(loadpath)
- basePath = baseId
# All the model will be created under model as
# a thumbrule
- basePath = moose.Neutral(baseId.path + '/model')
+ basePath = moose.Neutral(
+ baseId.path + '/model')
# Map Compartment's SBML id as key and value is
# list of[ Moose ID and SpatialDimensions ]
global comptSbmlidMooseIdMap
@@ -130,31 +127,26 @@ def mooseReadSBML(filepath, loadpath, solver="ee"):
warning = " "
global msg
msg = " "
- groupInfo = {}
- modelAnnotaInfo = {}
comptSbmlidMooseIdMap = {}
+ #print(("modelPath:" + basePath.path))
globparameterIdValue = {}
-
+ modelAnnotaInfo = {}
mapParameter(model, globparameterIdValue)
errorFlag = createCompartment(
basePath, model, comptSbmlidMooseIdMap)
-
- groupInfo = checkGroup(basePath,model)
if errorFlag:
specInfoMap = {}
errorFlag,warning = createSpecies(
- basePath, model, comptSbmlidMooseIdMap, specInfoMap, modelAnnotaInfo,groupInfo)
+ basePath, model, comptSbmlidMooseIdMap, specInfoMap, modelAnnotaInfo)
#print(errorFlag,warning)
-
if errorFlag:
errorFlag = createRules(
model, specInfoMap, globparameterIdValue)
if errorFlag:
errorFlag, msg = createReaction(
- model, specInfoMap, modelAnnotaInfo, globparameterIdValue,groupInfo)
+ model, specInfoMap, modelAnnotaInfo, globparameterIdValue)
getModelAnnotation(
model, baseId, basePath)
-
if not errorFlag:
print(msg)
# Any time in the middle if SBML does not read then I
@@ -169,37 +161,7 @@ def mooseReadSBML(filepath, loadpath, solver="ee"):
print("Validation failed while reading the model.")
return moose.element('/')
-def checkGroup(basePath,model):
- groupInfo = {}
- modelAnnotaInfo = {}
- if model.getPlugin("groups") != None:
- mplugin = model.getPlugin("groups")
- modelgn = mplugin.getNumGroups()
- for gindex in range(0, mplugin.getNumGroups()):
- p = mplugin.getGroup(gindex)
- groupAnnoInfo = {}
- groupAnnoInfo = getObjAnnotation(p, modelAnnotaInfo)
- if moose.exists(basePath.path+'/'+groupAnnoInfo["Compartment"]):
- if not moose.exists(basePath.path+'/'+groupAnnoInfo["Compartment"]+'/'+p.getId()):
- moosegrp = moose.Neutral(basePath.path+'/'+groupAnnoInfo["Compartment"]+'/'+p.getId())
- else:
- moosegrp = moose.element(basePath.path+'/'+groupAnnoInfo["Compartment"]+'/'+p.getId())
- moosegrpinfo = moose.Annotator(moosegrp.path+'/info')
- moosegrpinfo.color = groupAnnoInfo["bgColor"]
- else:
- print ("Compartment not found")
- if p.getKind() == 2:
- if p.getId() not in groupInfo:
- #groupInfo[p.getId()]
- for gmemIndex in range(0,p.getNumMembers()):
- mem = p.getMember(gmemIndex)
-
- if p.getId() in groupInfo:
- groupInfo[p.getId()].append(mem.getIdRef())
- else:
- groupInfo[p.getId()] =[mem.getIdRef()]
- return groupInfo
def setupEnzymaticReaction(enz, groupName, enzName,
specInfoMap, modelAnnotaInfo):
enzPool = (modelAnnotaInfo[groupName]["enzyme"])
@@ -208,6 +170,7 @@ def setupEnzymaticReaction(enz, groupName, enzName,
cplx = (modelAnnotaInfo[groupName]["complex"])
cplx = str(idBeginWith(cplx))
complx = moose.element(specInfoMap[cplx]["Mpath"].path)
+
enzyme_ = moose.Enz(enzParent.path + '/' + enzName)
moose.move(complx, enzyme_)
moose.connect(enzyme_, "cplx", complx, "reac")
@@ -323,7 +286,7 @@ def getModelAnnotation(obj, baseId, basepath):
for plots in plotlist:
plots = plots.replace(" ", "")
plotorg = plots
- if( moose.exists(basepath.path + plotorg) and isinstance(moose.element(basepath.path+plotorg),moose.PoolBase)) :
+ if moose.exists(basepath.path + plotorg):
plotSId = moose.element(
basepath.path + plotorg)
# plotorg = convertSpecialChar(plotorg)
@@ -338,7 +301,8 @@ def getModelAnnotation(obj, baseId, basepath):
if not fullPath in tablelistname:
tab = moose.Table2(fullPath)
tablelistname.append(fullPath)
- moose.connect(tab, "requestOut", plotSId, "getConc")
+ moose.connect(
+ tab, "requestOut", plotSId, "getConc")
def getObjAnnotation(obj, modelAnnotationInfo):
@@ -347,11 +311,11 @@ def getObjAnnotation(obj, modelAnnotationInfo):
# modelAnnotaInfo= {}
annotateMap = {}
if (obj.getAnnotation() is not None):
-
annoNode = obj.getAnnotation()
for ch in range(0, annoNode.getNumChildren()):
childNode = annoNode.getChild(ch)
- if (childNode.getPrefix() == "moose" and (childNode.getName() in["ModelAnnotation","EnzymaticReaction","GroupAnnotation"])):
+ if (childNode.getPrefix() == "moose" and (childNode.getName() ==
+ "ModelAnnotation" or childNode.getName() == "EnzymaticReaction")):
sublist = []
for gch in range(0, childNode.getNumChildren()):
grandChildNode = childNode.getChild(gch)
@@ -371,10 +335,6 @@ def getObjAnnotation(obj, modelAnnotationInfo):
annotateMap[nodeName] = nodeValue
if nodeName == "textColor":
annotateMap[nodeName] = nodeValue
- if nodeName == "Group":
- annotateMap[nodeName] = nodeValue
- if nodeName == "Compartment":
- annotateMap[nodeName] = nodeValue
return annotateMap
@@ -480,7 +440,7 @@ def getEnzAnnotation(obj, modelAnnotaInfo, rev,
return(groupName)
-def createReaction(model, specInfoMap, modelAnnotaInfo, globparameterIdValue,groupInfo):
+def createReaction(model, specInfoMap, modelAnnotaInfo, globparameterIdValue):
# print " reaction "
# Things done for reaction
# --Reaction is not created, if substrate and product is missing
@@ -502,17 +462,8 @@ def createReaction(model, specInfoMap, modelAnnotaInfo, globparameterIdValue,gro
rName = ""
rId = ""
reac = model.getReaction(ritem)
- group = ""
- reacAnnoInfo = {}
- reacAnnoInfo = getObjAnnotation(reac, modelAnnotaInfo)
- # if "Group" in reacAnnoInfo:
- # group = reacAnnoInfo["Group"]
-
if (reac.isSetId()):
rId = reac.getId()
- groups = [k for k, v in groupInfo.iteritems() if rId in v]
- if groups:
- group = groups[0]
if (reac.isSetName()):
rName = reac.getName()
rName = rName.replace(" ", "_space_")
@@ -580,11 +531,6 @@ def createReaction(model, specInfoMap, modelAnnotaInfo, globparameterIdValue,gro
sp = react.getSpecies()
sp = str(idBeginWith(sp))
speCompt = specInfoMap[sp]["comptId"].path
- if group:
- if moose.exists(speCompt+'/'+group):
- speCompt = speCompt+'/'+group
- else:
- speCompt = (moose.Neutral(speCompt+'/'+group)).path
reaction_ = moose.Reac(speCompt + '/' + rName)
reactionCreated = True
reactSBMLIdMooseId[rName] = {
@@ -814,12 +760,10 @@ def createRules(model, specInfoMap, globparameterIdValue):
exp = rule.getFormula()
for mem in ruleMemlist:
if (mem in specInfoMap):
- #exp1 = exp.replace(mem, str(speFunXterm[mem]))
- exp1 = re.sub(r'\b%s\b'% (mem), speFunXterm[mem], exp)
+ exp1 = exp.replace(mem, str(speFunXterm[mem]))
exp = exp1
elif(mem in globparameterIdValue):
- #exp1 = exp.replace(mem, str(globparameterIdValue[mem]))
- exp1 = re.sub(r'\b%s\b'% (mem), globparameterIdValue[mem], exp)
+ exp1 = exp.replace(mem, str(globparameterIdValue[mem]))
exp = exp1
else:
print("Math expression need to be checked")
@@ -858,7 +802,7 @@ def pullnotes(sbmlId, mooseId):
def createSpecies(basePath, model, comptSbmlidMooseIdMap,
- specInfoMap, modelAnnotaInfo,groupInfo):
+ specInfoMap, modelAnnotaInfo):
# ToDo:
# - Need to add group name if exist in pool
# - Notes
@@ -868,19 +812,8 @@ def createSpecies(basePath, model, comptSbmlidMooseIdMap,
else:
for sindex in range(0, model.getNumSpecies()):
spe = model.getSpecies(sindex)
- group = ""
- specAnnoInfo = {}
- specAnnoInfo = getObjAnnotation(spe, modelAnnotaInfo)
-
- # if "Group" in specAnnoInfo:
- # group = specAnnoInfo["Group"]
-
sName = None
sId = spe.getId()
-
- groups = [k for k, v in groupInfo.iteritems() if sId in v]
- if groups:
- group = groups[0]
if spe.isSetName():
sName = spe.getName()
sName = sName.replace(" ", "_space_")
@@ -897,11 +830,7 @@ def createSpecies(basePath, model, comptSbmlidMooseIdMap,
hasonlySubUnit = spe.getHasOnlySubstanceUnits()
# "false": is {unit of amount}/{unit of size} (i.e., concentration or density).
# "true": then the value is interpreted as having a unit of amount only.
- if group:
- if moose.exists(comptEl+'/'+group):
- comptEl = comptEl+'/'+group
- else:
- comptEl = (moose.Neutral(comptEl+'/'+group)).path
+
if (boundaryCondition):
poolId = moose.BufPool(comptEl + '/' + sName)
else:
@@ -909,13 +838,13 @@ def createSpecies(basePath, model, comptSbmlidMooseIdMap,
if (spe.isSetNotes):
pullnotes(spe, poolId)
-
+ specAnnoInfo = {}
+ specAnnoInfo = getObjAnnotation(spe, modelAnnotaInfo)
if specAnnoInfo:
if not moose.exists(poolId.path + '/info'):
poolInfo = moose.Annotator(poolId.path + '/info')
else:
poolInfo = moose.element(poolId.path + '/info')
-
for k, v in list(specAnnoInfo.items()):
if k == 'xCord':
poolInfo.x = float(v)
@@ -977,7 +906,6 @@ def createSpecies(basePath, model, comptSbmlidMooseIdMap,
if (rule_variable == sId):
found = True
break
-
if not (found):
print(
"Invalid SBML: Either initialConcentration or initialAmount must be set or it should be found in assignmentRule but non happening for ",
diff --git a/python/moose/SBML/writeSBML.py b/python/moose/SBML/writeSBML.py
index 5cdb25bc..3f39cc3b 100644
--- a/python/moose/SBML/writeSBML.py
+++ b/python/moose/SBML/writeSBML.py
@@ -12,7 +12,7 @@
** copyright (C) 2003-2017 Upinder S. Bhalla. and NCBS
Created : Friday May 27 12:19:00 2016(+0530)
Version
-Last-Updated: Tue Apr 4 14:20:00 2017(+0530)
+Last-Updated: Wed Jan 11 15:20:00 2017(+0530)
By:
**********************************************************************/
/****************************
@@ -22,13 +22,14 @@ import sys
import re
#from collections import Counter
import moose
-from moose.SBML.validation import validateModel
+from .validation import validateModel
from moose.chemUtil.chemConnectUtil import *
from moose.chemUtil.graphUtils import *
# ToDo:
# Table should be written
+# Group's should be added
# boundary condition for buffer pool having assignment statment constant
# shd be false
@@ -45,12 +46,11 @@ def mooseWriteSBML(modelpath, filename, sceneitems={}):
if not foundLibSBML_:
print('No python-libsbml found.'
'\nThis module can be installed by following command in terminal:'
- '\n\t easy_install python-libsbml or'
- '\n\t apt-get install python-libsbml'
+ '\n\t easy_install python-libsbml'
)
- return -2, "Could not save the model in to SBML file. \nThis module can be installed by following command in terminal: \n\t easy_install python-libsbml or \n\t apt-get install python-libsbml",''
+ return -1, msg
- #sbmlDoc = SBMLDocument(3, 1)
+ sbmlDoc = SBMLDocument(3, 1)
filepath, filenameExt = os.path.split(filename)
if filenameExt.find('.') != -1:
filename = filenameExt[:filenameExt.find('.')]
@@ -64,22 +64,16 @@ def mooseWriteSBML(modelpath, filename, sceneitems={}):
global nameList_
nameList_ = []
positionInfoexist = False
-
- xmlns = SBMLNamespaces(3, 1)
- xmlns.addNamespace("http://www.w3.org/1999/xhtml", "xhtml")
- xmlns.addNamespace("http://www.moose.ncbs.res.in", "moose")
- xmlns.addNamespace("http://www.sbml.org/sbml/level3/version1/groups/version1", "groups")
- sbmlDoc = SBMLDocument(xmlns)
- sbmlDoc.setPackageRequired("groups",bool(0))
-
+ xmlns = XMLNamespaces()
+ xmlns.add("http://www.sbml.org/sbml/level3/version1")
+ xmlns.add("http://www.moose.ncbs.res.in", "moose")
+ xmlns.add("http://www.w3.org/1999/xhtml", "xhtml")
+ sbmlDoc.setNamespaces(xmlns)
cremodel_ = sbmlDoc.createModel()
cremodel_.setId(filename)
- cremodel_.setTimeUnits("time")
+ cremodel_.setTimeUnits("second")
cremodel_.setExtentUnits("substance")
cremodel_.setSubstanceUnits("substance")
- cremodel_.setVolumeUnits("volume")
- cremodel_.setAreaUnits("area")
- cremodel_.setLengthUnits("length")
neutralNotes = ""
specieslist = moose.wildcardFind(modelpath + '/##[ISA=PoolBase]')
@@ -106,36 +100,14 @@ def mooseWriteSBML(modelpath, filename, sceneitems={}):
modelAnno = writeSimulationAnnotation(modelpath)
if modelAnno:
cremodel_.setAnnotation(modelAnno)
- groupInfo = {}
- compartexist, groupInfo = writeCompt(modelpath, cremodel_)
-
+
+ compartexist = writeCompt(modelpath, cremodel_)
if compartexist == True:
- species = writeSpecies( modelpath,cremodel_,sbmlDoc,sceneitems,groupInfo)
+ species = writeSpecies( modelpath,cremodel_,sbmlDoc,sceneitems)
if species:
writeFunc(modelpath, cremodel_)
- reacGroup = {}
- writeReac(modelpath, cremodel_, sceneitems,groupInfo)
- writeEnz(modelpath, cremodel_, sceneitems,groupInfo)
- if groupInfo:
- for key,value in groupInfo.items():
- mplugin = cremodel_.getPlugin("groups")
- group = mplugin.createGroup()
- name = moose.element(key).name
- group.setId(name)
- group.setKind("collection")
- ginfo = moose.element(key.path+'/info')
- groupCompartment = findCompartment(key)
- if ginfo.color != '':
- grpAnno = "<moose:GroupAnnotation>"
- grpAnno = grpAnno + "<moose:Compartment>" + groupCompartment.name + "</moose:Compartment>\n"
- if ginfo.color:
- grpAnno = grpAnno + "<moose:bgColor>" + ginfo.color + "</moose:bgColor>\n"
- grpAnno = grpAnno + "</moose:GroupAnnotation>"
- group.setAnnotation(grpAnno)
-
- for values in value:
- member = group.createMember()
- member.setIdRef(values)
+ writeReac(modelpath, cremodel_, sceneitems)
+ writeEnz(modelpath, cremodel_, sceneitems)
consistencyMessages = ""
SBMLok = validateModel(sbmlDoc)
if (SBMLok):
@@ -153,7 +125,7 @@ def calPrime(x):
prime = int((20 * (float(x - cmin) / float(cmax - cmin))) - 10)
return prime
-def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
+def writeEnz(modelpath, cremodel_, sceneitems):
for enz in moose.wildcardFind(modelpath + '/##[ISA=EnzBase]'):
enzannoexist = False
enzGpnCorCol = " "
@@ -161,25 +133,17 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
enzSubt = ()
compt = ""
notesE = ""
-
if moose.exists(enz.path + '/info'):
- groupName = moose.element("/")
Anno = moose.Annotator(enz.path + '/info')
notesE = Anno.notes
element = moose.element(enz)
ele = getGroupinfo(element)
- ele = findGroup_compt(element)
- if ele.className == "Neutral" or sceneitems or Anno.x or Anno.y:
+ if element.className == "Neutral" or sceneitems or Anno.x or Anno.y:
enzannoexist = True
if enzannoexist:
enzAnno = "<moose:ModelAnnotation>\n"
if ele.className == "Neutral":
- groupName = ele
- #enzGpnCorCol = "<moose:Group>" + ele.name + "</moose:Group>\n"
- # if ele.name not in groupInfo:
- # groupInfo[ele.name]=[setId]
- # else:
- # groupInfo[ele.name].append(setId)
+ enzGpnCorCol = "<moose:Group>" + ele.name + "</moose:Group>\n"
if sceneitems:
#Saved from GUI, then scene co-ordinates are passed
enzGpnCorCol = enzGpnCorCol + "<moose:xCord>" + \
@@ -199,6 +163,7 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
if Anno.textColor:
enzGpnCorCol = enzGpnCorCol + "<moose:textColor>" + \
Anno.textColor + "</moose:textColor>\n"
+
if (enz.className == "Enz" or enz.className == "ZombieEnz"):
enzyme = cremodel_.createReaction()
if notesE != "":
@@ -213,20 +178,14 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
compt = comptVec.name + "_" + \
str(comptVec.getId().value) + "_" + \
str(comptVec.getDataIndex()) + "_"
- enzsetId = str(idBeginWith(cleanEnzname +
+
+ enzyme.setId(str(idBeginWith(cleanEnzname +
"_" +
str(enz.getId().value) +
"_" +
str(enz.getDataIndex()) +
"_" +
- "Complex_formation_"))
- enzyme.setId(enzsetId)
-
- if groupName != moose.element('/'):
- if groupName not in groupInfo:
- groupInfo[groupName]=[enzsetId]
- else:
- groupInfo[groupName].append(enzsetId)
+ "Complex_formation_")))
enzyme.setName(cleanEnzname)
enzyme.setFast(False)
enzyme.setReversible(True)
@@ -267,7 +226,7 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
noofSub, sRateLaw = getSubprd(cremodel_, True, "sub", enzSubt)
#rec_order = rec_order + noofSub
rec_order = noofSub
- rate_law = compt + " * ( " + rate_law + " * " + sRateLaw
+ rate_law = compt + " * " + rate_law + "*" + sRateLaw
enzPrd = enz.neighbors["cplxDest"]
if not enzPrd:
@@ -277,7 +236,7 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
for i in range(0, len(nameList_)):
enzAnno = enzAnno + "<moose:product>" + \
nameList_[i] + "</moose:product>\n"
- rate_law = rate_law + " - " + " k2 " + ' * ' + sRateLaw +" )"
+ rate_law = rate_law + " - " + compt + "* k2" + '*' + sRateLaw
prd_order = noofPrd
enzAnno = enzAnno + "<moose:groupName>" + cleanEnzname + "_" + \
@@ -300,21 +259,14 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
unit = parmUnit(rec_order - 1, cremodel_)
printParameters(kl, "k1", k1, unit)
enzyme = cremodel_.createReaction()
- enzsetIdP = str(idBeginWith(cleanEnzname +
+ enzyme.setId(str(idBeginWith(cleanEnzname +
"_" +
str(enz.getId().value) +
"_" +
str(enz.getDataIndex()) +
"_" +
- "Product_formation_"))
- enzyme.setId(enzsetIdP)
+ "Product_formation_")))
enzyme.setName(cleanEnzname)
- if groupName != moose.element('/'):
- if groupName not in groupInfo:
- groupInfo[groupName]=[enzsetIdP]
- else:
- groupInfo[groupName].append(enzsetIdP)
-
enzyme.setFast(False)
enzyme.setReversible(False)
enzAnno2 = "<moose:EnzymaticReaction>"
@@ -364,7 +316,6 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
printParameters(kl, "k3", k3, unit)
elif(enz.className == "MMenz" or enz.className == "ZombieMMenz"):
-
enzSub = enz.neighbors["sub"]
enzPrd = enz.neighbors["prd"]
if (len(enzSub) != 0 and len(enzPrd) != 0):
@@ -382,18 +333,12 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
notesStringE = "<body xmlns=\"http://www.w3.org/1999/xhtml\">\n \t \t" + \
cleanNotesE + "\n\t </body>"
enzyme.setNotes(notesStringE)
- mmenzsetId = str(idBeginWith(cleanEnzname +
+ enzyme.setId(str(idBeginWith(cleanEnzname +
"_" +
str(enz.getId().value) +
"_" +
str(enz.getDataIndex()) +
- "_"))
- enzyme.setId(mmenzsetId)
- if groupName != moose.element('/'):
- if groupName not in groupInfo:
- groupInfo[groupName]=[mmenzsetId]
- else:
- groupInfo[groupName].append(mmenzsetId)
+ "_")))
enzyme.setName(cleanEnzname)
enzyme.setFast(False)
enzyme.setReversible(True)
@@ -413,15 +358,14 @@ def writeEnz(modelpath, cremodel_, sceneitems,groupInfo):
enzPrd = enz.neighbors["prd"]
noofPrd, sRateLawP = getSubprd(cremodel_, False, "prd", enzPrd)
kl = enzyme.createKineticLaw()
- fRate_law = compt + " * ( kcat * " + sRateLawS + " * " + sRateLawM + \
- " / ( Km" + " + " + sRateLawS + "))"
+ fRate_law = "kcat *" + sRateLawS + "*" + sRateLawM + \
+ "/(" + compt + " * (" + "Km" + "+" + sRateLawS + "))"
kl.setFormula(fRate_law)
kl.setNotes(
"<body xmlns=\"http://www.w3.org/1999/xhtml\">\n\t\t" +
fRate_law +
"\n \t </body>")
- KmUnit(cremodel_)
- printParameters(kl, "Km", Km, "mmole_per_litre")
+ printParameters(kl, "Km", Km, "substance")
kcatUnit = parmUnit(0, cremodel_)
printParameters(kl, "kcat", kcat, kcatUnit)
@@ -432,29 +376,6 @@ def printParameters(kl, k, kvalue, unit):
para.setValue(kvalue)
para.setUnits(unit)
-def KmUnit(cremodel_):
- unit_stream = "mmole_per_litre"
- lud = cremodel_.getListOfUnitDefinitions()
- flag = False
- for i in range(0, len(lud)):
- ud = lud.get(i)
- if (ud.getId() == unit_stream):
- flag = True
- break
- if (not flag):
- unitdef = cremodel_.createUnitDefinition()
- unitdef.setId(unit_stream)
- unit = unitdef.createUnit()
- unit.setKind(UNIT_KIND_LITRE)
- unit.setExponent(-1)
- unit.setMultiplier(1)
- unit.setScale(0)
- unit = unitdef.createUnit()
- unit.setKind(UNIT_KIND_MOLE)
- unit.setExponent(1)
- unit.setMultiplier(1)
- unit.setScale(-3)
- return unit_stream
def parmUnit(rct_order, cremodel_):
order = rct_order
@@ -463,7 +384,7 @@ def parmUnit(rct_order, cremodel_):
elif order == 1:
unit_stream = "litre_per_mmole_per_second"
elif order == 2:
- unit_stream = "sq_litre_per_mmole_sq_per_second"
+ unit_stream = "litre_per_mmole_sq_per_second"
else:
unit_stream = "litre_per_mmole_" + str(rct_order) + "_per_second"
@@ -482,7 +403,7 @@ def parmUnit(rct_order, cremodel_):
if order != 0:
unit = unitdef.createUnit()
unit.setKind(UNIT_KIND_LITRE)
- unit.setExponent(order)
+ unit.setExponent(1)
unit.setMultiplier(1)
unit.setScale(0)
unit = unitdef.createUnit()
@@ -586,7 +507,7 @@ def listofname(reacSub, mobjEnz):
nameList_.append(clean_name)
-def writeReac(modelpath, cremodel_, sceneitems,reacGroup):
+def writeReac(modelpath, cremodel_, sceneitems):
for reac in moose.wildcardFind(modelpath + '/##[ISA=ReacBase]'):
reacSub = reac.neighbors["sub"]
reacPrd = reac.neighbors["prd"]
@@ -596,13 +517,12 @@ def writeReac(modelpath, cremodel_, sceneitems,reacGroup):
reacannoexist = False
reacGpname = " "
cleanReacname = convertSpecialChar(reac.name)
- setId = str(idBeginWith(cleanReacname +
+ reaction.setId(str(idBeginWith(cleanReacname +
"_" +
str(reac.getId().value) +
"_" +
str(reac.getDataIndex()) +
- "_"))
- reaction.setId(setId)
+ "_")))
reaction.setName(cleanReacname)
#Kf = reac.numKf
#Kb = reac.numKb
@@ -628,11 +548,7 @@ def writeReac(modelpath, cremodel_, sceneitems,reacGroup):
if reacannoexist:
reacAnno = "<moose:ModelAnnotation>\n"
if ele.className == "Neutral":
- #reacAnno = reacAnno + "<moose:Group>" + ele.name + "</moose:Group>\n"
- if ele not in reacGroup:
- reacGroup[ele]=[setId]
- else:
- reacGroup[ele].append(setId)
+ reacAnno = reacAnno + "<moose:Group>" + ele.name + "</moose:Group>\n"
if sceneitems:
#Saved from GUI, then scene co-ordinates are passed
reacAnno = reacAnno + "<moose:xCord>" + \
@@ -713,7 +629,6 @@ def writeReac(modelpath, cremodel_, sceneitems,reacGroup):
kl_s +
"\n \t </body>")
kfl.setFormula(kl_s)
-
else:
print(" Reaction ", reac.name, "missing substrate and product")
@@ -752,6 +667,7 @@ def writeFunc(modelpath, cremodel_):
rule.setVariable(fName)
rule.setFormula(expr)
+
def convertNotesSpecialChar(str1):
d = {"&": "_and", "<": "_lessthan_", ">": "_greaterthan_", "BEL": "°"}
for i, j in d.items():
@@ -760,6 +676,7 @@ def convertNotesSpecialChar(str1):
str1 = str1.strip(' \t\n\r')
return str1
+
def getGroupinfo(element):
# Note: At this time I am assuming that if group exist (incase of Genesis)
# 1. for 'pool' its between compartment and pool, /modelpath/Compartment/Group/pool
@@ -768,7 +685,8 @@ def getGroupinfo(element):
# if /modelpath/Compartment/Group/Group1/Pool, then I check and get Group1
# And /modelpath is also a NeutralObject,I stop till I find Compartment
- while not mooseIsInstance(element, ["Neutral", "CubeMesh", "CyclMesh"]):
+ while not mooseIsInstance(element, ["Neutral"]) and not mooseIsInstance(
+ element, ["CubeMesh", "CyclMesh"]):
element = element.parent
return element
@@ -789,10 +707,6 @@ def idBeginWith(name):
changedName = "_" + name
return changedName
-def findGroup_compt(melement):
- while not (mooseIsInstance(melement, ["Neutral","CubeMesh", "CyclMesh"])):
- melement = melement.parent
- return melement
def convertSpecialChar(str1):
d = {"&": "_and", "<": "_lessthan_", ">": "_greaterthan_", "BEL": "°", "-": "_minus_", "'": "_prime_",
@@ -804,7 +718,7 @@ def convertSpecialChar(str1):
return str1
-def writeSpecies(modelpath, cremodel_, sbmlDoc, sceneitems,speGroup):
+def writeSpecies(modelpath, cremodel_, sbmlDoc, sceneitems):
# getting all the species
for spe in moose.wildcardFind(modelpath + '/##[ISA=PoolBase]'):
sName = convertSpecialChar(spe.name)
@@ -884,13 +798,7 @@ def writeSpecies(modelpath, cremodel_, sbmlDoc, sceneitems,speGroup):
if speciannoexist:
speciAnno = "<moose:ModelAnnotation>\n"
if ele.className == "Neutral":
- #speciAnno = speciAnno + "<moose:Group>" + ele.name + "</moose:Group>\n"
- if ele not in speGroup:
- speGroup[ele]=[spename]
- else:
- speGroup[ele].append(spename)
-
-
+ speciAnno = speciAnno + "<moose:Group>" + ele.name + "</moose:Group>\n"
if sceneitems:
#Saved from GUI, then scene co-ordinates are passed
speciAnno = speciAnno + "<moose:xCord>" + \
@@ -918,7 +826,6 @@ def writeSpecies(modelpath, cremodel_, sbmlDoc, sceneitems,speGroup):
def writeCompt(modelpath, cremodel_):
# getting all the compartments
compts = moose.wildcardFind(modelpath + '/##[ISA=ChemCompt]')
- groupInfo = {}
for compt in compts:
comptName = convertSpecialChar(compt.name)
# converting m3 to litre
@@ -936,20 +843,10 @@ def writeCompt(modelpath, cremodel_):
c1.setSize(size)
c1.setSpatialDimensions(ndim)
c1.setUnits('volume')
- #For each compartment get groups information along
- for grp in moose.wildcardFind(compt.path+'/##[TYPE=Neutral]'):
- grp_cmpt = findGroup_compt(grp.parent)
- try:
- value = groupInfo[moose.element(grp)]
- except KeyError:
- # Grp is not present
- groupInfo[moose.element(grp)] = []
-
-
if compts:
- return True,groupInfo
+ return True
else:
- return False,groupInfo
+ return False
# write Simulation runtime,simdt,plotdt
def writeSimulationAnnotation(modelpath):
modelAnno = ""
@@ -980,12 +877,12 @@ def writeSimulationAnnotation(modelpath):
graphSpefound = True
if graphSpefound:
if not plots:
- plots = ori[ori.find(q.name)-1:len(ori)]
- #plots = '/' + q.name + '/' + name
+ #plots = ori[ori.find(q.name)-1:len(ori)]
+ plots = '/' + q.name + '/' + name
else:
- plots = plots + "; "+ori[ori.find(q.name)-1:len(ori)]
- #plots = plots + "; /" + q.name + '/' + name
+ #plots = plots + "; "+ori[ori.find(q.name)-1:len(ori)]
+ plots = plots + "; /" + q.name + '/' + name
if plots != " ":
modelAnno = modelAnno + "<moose:plots> " + plots + "</moose:plots>\n"
modelAnno = modelAnno + "</moose:ModelAnnotation>"
@@ -1008,30 +905,6 @@ def writeUnits(cremodel_):
unit.setExponent(1.0)
unit.setScale(-3)
- unitLen = cremodel_.createUnitDefinition()
- unitLen.setId("length")
- unit = unitLen.createUnit()
- unit.setKind(UNIT_KIND_METRE)
- unit.setMultiplier(1.0)
- unit.setExponent(1.0)
- unit.setScale(0)
-
- unitArea = cremodel_.createUnitDefinition()
- unitArea.setId("area")
- unit = unitArea.createUnit()
- unit.setKind(UNIT_KIND_METRE)
- unit.setMultiplier(1.0)
- unit.setExponent(2.0)
- unit.setScale(0)
-
- unitTime = cremodel_.createUnitDefinition()
- unitTime.setId("time")
- unit = unitTime.createUnit()
- unit.setKind(UNIT_KIND_SECOND)
- unit.setExponent(1)
- unit.setMultiplier(1)
- unit.setScale(0)
-
if __name__ == "__main__":
try:
sys.argv[1]
diff --git a/python/moose/__init__.py b/python/moose/__init__.py
index b5447c6c..2e2f6772 100644
--- a/python/moose/__init__.py
+++ b/python/moose/__init__.py
@@ -1,616 +1,32 @@
-"""__init__.py:
-
"""
+How to use the documentation
+----------------------------
-from __future__ import print_function
-from __future__ import absolute_import
-
-
-from contextlib import closing
-import warnings
-import platform
-import pydoc
-import os
-from io import StringIO
-from collections import defaultdict
-import textwrap
-
-import moose
-from moose._moose import *
-import moose.SBML
-
-# Wrapper to get moose version information.
-__version__ = moose._moose.__version__
-VERSION = moose._moose.VERSION
-
-sequence_types = ['vector<double>',
- 'vector<int>',
- 'vector<long>',
- 'vector<unsigned int>',
- 'vector<float>',
- 'vector<unsigned long>',
- 'vector<short>',
- 'vector<Id>',
- 'vector<ObjId>']
-
-known_types = ['void',
- 'char',
- 'short',
- 'int',
- 'unsigned int',
- 'double',
- 'float',
- 'long',
- 'unsigned long',
- 'string',
- 'vec',
- 'melement'] + sequence_types
-
-# SBML related functions.
-
-def mooseReadSBML(filepath, loadpath, solver='ee'):
- """Load SBML model.
-
- keyword arguments: \n
-
- filepath -- filepath to be loaded \n
- loadpath -- Root path for this model e.g. /model/mymodel \n
- solver -- Solver to use (default 'ee' ) \n
-
- """
- return moose.SBML.readSBML.mooseReadSBML( filepath, loadpath, solver )
-
-
-def mooseWriteSBML(modelpath, filepath, sceneitems={}):
- """Writes loaded model under modelpath to a file in SBML format.
-
- keyword arguments:\n
-
- modelpath -- model path in moose e.g /model/mymodel \n
- filepath -- Path of output file. \n
- sceneitems -- dictlist (UserWarning: user need not worry about this) \n
- layout position is saved in Annotation field of all the moose Object (pool,Reaction,enzyme)\n
- If this function is called from \n
- -- GUI, the layout position of moose object is passed \n
- -- command line, \n
- ---if genesis/kkit model is loaded then layout position is taken from the file \n
- --- else, auto-coordinates is used for layout position and passed
-
- """
- return moose.SBML.writeSBML.mooseWriteSBML(modelpath, filepath, sceneitems)
-
-
-def mooseWriteKkit(modelpath, filepath,sceneitems={}):
- """Writes loded model under modelpath to a file in Kkit format.
-
- keyword arguments:\n
-
- modelpath -- model path in moose \n
- filepath -- Path of output file.
- """
- return moose.genesis.writeKkit.mooseWriteKkit(modelpath, filepath,sceneitems)
-
-
-def moosedeleteChemSolver(modelpath):
- """ deletes solver on all the compartment and its children.
- This is neccesary while created a new moose object on a pre-existing modelpath,\n
- this should be followed by mooseaddChemSolver for add solvers on to compartment to simulate else
- default is Exponential Euler (ee)
- """
- return chemUtil.add_Delete_ChemicalSolver.moosedeleteChemSolver(modelpath)
-
-
-def mooseaddChemSolver(modelpath, solver):
- """ Add solver on chemical compartment and its children for calculation
-
- keyword arguments:\n
-
- modelpath -- model path that is loaded into moose \n
- solver -- "Exponential Euler" (ee) (default), \n
- "Gillespie" ("gssa"), \n
- "Runge Kutta" ("gsl")
-
- """
- return chemUtil.add_Delete_ChemicalSolver.mooseaddChemSolver(modelpath, solver)
-
-################################################################
-# Wrappers for global functions
-################################################################
-
-
-def pwe():
- """Print present working element. Convenience function for GENESIS
- users. If you want to retrieve the element in stead of printing
- the path, use moose.getCwe()
-
- """
- pwe_ = _moose.getCwe()
- print(pwe_.getPath())
- return pwe_
-
-
-def le(el=None):
- """List elements under `el` or current element if no argument
- specified.
-
- Parameters
- ----------
- el : str/melement/vec/None
- The element or the path under which to look. If `None`, children
- of current working element are displayed.
-
- Returns
- -------
- List of path of child elements
-
- """
- if el is None:
- el = getCwe()
- elif isinstance(el, str):
- if not exists(el):
- raise ValueError('no such element')
- el = element(el)
- elif isinstance(el, vec):
- el = el[0]
- print('Elements under', el.path)
- for ch in el.children:
- print(ch.path)
- return [child.path for child in el.children]
-
-ce = setCwe # ce is a GENESIS shorthand for change element.
-
-
-def syncDataHandler(target):
- """Synchronize data handlers for target.
-
- Parameters
- ----------
- target : melement/vec/str
- Target element or vec or path string.
-
- Raises
- ------
- NotImplementedError
- The call to the underlying C++ function does not work.
-
- Notes
- -----
- This function is defined for completeness, but currently it does not work.
-
- """
- raise NotImplementedError('The implementation is not working for IntFire - goes to invalid objects. \
-First fix that issue with SynBase or something in that line.')
- if isinstance(target, str):
- if not _moose.exists(target):
- raise ValueError('%s: element does not exist.' % (target))
- target = vec(target)
- _moose.syncDataHandler(target)
+MOOSE documentation is split into Python documentation and builtin
+documentation. The functions and classes that are only part of the
+Python interface can be viewed via Python's builtin ``help``
+function::
+>>> help(moose.connect)
-def showfield(el, field='*', showtype=False):
- """Show the fields of the element `el`, their data types and
- values in human readable format. Convenience function for GENESIS
- users.
+The documentation built into main C++ code of MOOSE can be accessed
+via the module function ``doc``::
- Parameters
- ----------
- el : melement/str
- Element or path of an existing element.
+>>> moose.doc('Neutral')
- field : str
- Field to be displayed. If '*' (default), all fields are displayed.
+To get documentation about a particular field::
- showtype : bool
- If True show the data type of each field. False by default.
+>>> moose.doc('Neutral.childMsg')
- Returns
- -------
- None
+Builtin functions and classes in moose module (Python only)
+-----------------------------------------------------------
- """
- if isinstance(el, str):
- if not exists(el):
- raise ValueError('no such element')
- el = element(el)
- if field == '*':
- value_field_dict = getFieldDict(el.className, 'valueFinfo')
- max_type_len = max(len(dtype) for dtype in value_field_dict.values())
- max_field_len = max(len(dtype) for dtype in value_field_dict.keys())
- print('\n[', el.path, ']')
- for key, dtype in sorted(value_field_dict.items()):
- if dtype == 'bad' or key == 'this' or key == 'dummy' or key == 'me' or dtype.startswith(
- 'vector') or 'ObjId' in dtype:
- continue
- value = el.getField(key)
- if showtype:
- typestr = dtype.ljust(max_type_len + 4)
- # The following hack is for handling both Python 2 and
- # 3. Directly putting the print command in the if/else
- # clause causes syntax error in both systems.
- print(typestr, end=' ')
- print(key.ljust(max_field_len + 4), '=', value)
- else:
- try:
- print(field, '=', el.getField(field))
- except AttributeError:
- pass # Genesis silently ignores non existent fields
-
-
-def showfields(el, showtype=False):
- """Convenience function. Should be deprecated if nobody uses it.
-
- """
- warnings.warn(
- 'Deprecated. Use showfield(element, field="*", showtype=True) instead.',
- DeprecationWarning)
- showfield(el, field='*', showtype=showtype)
-
-# Predefined field types and their human readable names
-finfotypes = [('valueFinfo', 'value field'),
- ('srcFinfo', 'source message field'),
- ('destFinfo', 'destination message field'),
- ('sharedFinfo', 'shared message field'),
- ('lookupFinfo', 'lookup field')]
-
-
-def listmsg(el):
- """Return a list containing the incoming and outgoing messages of
- `el`.
-
- Parameters
- ----------
- el : melement/vec/str
- MOOSE object or path of the object to look into.
-
- Returns
- -------
- msg : list
- List of Msg objects corresponding to incoming and outgoing
- connections of `el`.
-
- """
- obj = element(el)
- ret = []
- for msg in obj.inMsg:
- ret.append(msg)
- for msg in obj.outMsg:
- ret.append(msg)
- return ret
-
-
-def showmsg(el):
- """Print the incoming and outgoing messages of `el`.
-
- Parameters
- ----------
- el : melement/vec/str
- Object whose messages are to be displayed.
-
- Returns
- -------
- None
-
- """
- obj = element(el)
- print('INCOMING:')
- for msg in obj.msgIn:
- print(
- msg.e2.path,
- msg.destFieldsOnE2,
- '<---',
- msg.e1.path,
- msg.srcFieldsOnE1)
- print('OUTGOING:')
- for msg in obj.msgOut:
- print(
- msg.e1.path,
- msg.srcFieldsOnE1,
- '--->',
- msg.e2.path,
- msg.destFieldsOnE2)
-
-def getfielddoc_(tokens, infoType=''):
- indent=''
- classname = tokens[0]
- # print( classname )
- while True:
- try:
- classelement = _moose.element('/classes/' + classname)
- # print( classelement )
- x = ''
- for finfo in classelement.children:
- # print (str(finfo)[33:-1])
- # trial = 'path=/classes[0]/' + classname + '[0]/' + infoType
- # print (trial)
- # print (str(finfo)[33:-1] == trial)
- for fieldelement in finfo:
- fieldname = fieldelement.fieldName
- if (str(fieldname).startswith('get')) or (str(fieldname).startswith('set')):
- continue
- baseinfo = ''
- finfotype = fieldelement.name
- if(infoType == 'destFinfo'):
- say = 'Destination Message Field'
- elif(infoType == 'valueFinfo'):
- say = 'Value Field'
- elif(infoType == 'srcFinfo'):
- say = 'Source Message Field'
- elif(infoType == 'lookupFinfo'):
- say = 'Lookup Field'
- elif(infoType == 'sharedFinfo'):
- say = 'Shared Message Field'
-
- # finfotype={finfotype}{baseinfo}
- if (str(finfotype) == infoType):
- x = x + '{indent}{classname}.{fieldname}: type= {type} finfotype= {say}{baseinfo}\n\t{docs}\n\n'.format(indent=indent, classname=tokens[0], fieldname = fieldname, type=fieldelement.type, say=say, baseinfo=baseinfo, docs=fieldelement.docs)
-
- return x
- # classname = classelement.baseClass
- except ValueError:
- raise NameError('`%s` has no field called `%s`'% (tokens[0], tokens[1]))
-
-def getfielddoc(tokens, indent=''):
- """Return the documentation for field specified by `tokens`.
-
- Parameters
- ----------
- tokens : (className, fieldName) str
- A sequence whose first element is a MOOSE class name and second
- is the field name.
-
- indent : str
- indentation (default: empty string) prepended to builtin
- documentation string.
-
- Returns
- -------
- docstring : str
- string of the form
- `{indent}{className}.{fieldName}: {datatype} - {finfoType}\n{Description}\n`
-
- Raises
- ------
- NameError
- If the specified fieldName is not present in the specified class.
- """
- assert(len(tokens) > 1)
- classname = tokens[0]
- fieldname = tokens[1]
- while True:
- try:
- classelement = _moose.element('/classes/' + classname)
- for finfo in classelement.children:
- x = ''
- for fieldelement in finfo:
- baseinfo = ''
- if classname != tokens[0]:
- baseinfo = ' (inherited from {})'.format(classname)
- if fieldelement.fieldName == fieldname:
- # The field elements are
- # /classes/{ParentClass}[0]/{fieldElementType}[N].
- finfotype = fieldelement.name
- x = x + '{indent}{classname}.{fieldname}: type={type}, finfotype={finfotype}{baseinfo}\n\t{docs}\n'.format(indent=indent, classname=tokens[0], fieldname=fieldname, type=fieldelement.type, finfotype=finfotype, baseinfo=baseinfo, docs=fieldelement.docs)
- return x
- classname = classelement.baseClass
- except ValueError:
- raise NameError('`%s` has no field called `%s`'% (tokens[0], tokens[1]))
-
-def toUnicode(v, encoding='utf8'):
- # if isinstance(v, str):
- # return v
- try:
- return v.decode(encoding)
- except (AttributeError, UnicodeEncodeError):
- return str(v)
-
-
-def getmoosedoc(tokens, inherited=False):
- """Return MOOSE builtin documentation.
-
- Parameters
- ----------
- tokens : (className, [fieldName])
- tuple containing one or two strings specifying class name
- and field name (optional) to get documentation for.
-
- inherited: bool (default: False)
- include inherited fields.
-
- Returns
- -------
- docstring : str
- Documentation string for class `className`.`fieldName` if both
- are specified, for the class `className` if fieldName is not
- specified. In the latter case, the fields and their data types
- and finfo types are listed.
-
- Raises
- ------
- NameError
- If class or field does not exist.
-
- """
- indent = ' '
- with closing(StringIO()) as docstring:
- if not tokens:
- return ""
- try:
- class_element = _moose.element('/classes/%s' % (tokens[0]))
- except ValueError:
- raise NameError('name \'%s\' not defined.' % (tokens[0]))
- if len(tokens) > 1:
- docstring.write(toUnicode(getfielddoc(tokens)))
- else:
- doc_text = class_element.docs
- textArray = textwrap.wrap(doc_text, width = 70, replace_whitespace = False, drop_whitespace = False)
- text = "\n".join(textArray)
- # print(text)
- docstring.write(toUnicode('%s\n' % (text)))
-
- info = '\t Functions and message destinations \n\t------------------------------------\n\t All \'destFinfo\' can be used as destination Field for moose.connect function.\n'
- docstring.write(toUnicode('%s\n') % (info))
- docstring.write(toUnicode(getfielddoc_(tokens, 'destFinfo')))
- # append_finfodocs(tokens[0], docstring, indent)
- if inherited:
- mro = eval('_moose.%s' % (tokens[0])).mro()
- for class_ in mro[1:]:
- if class_ == _moose.melement:
- break
- docstring.write(toUnicode('\n#Inherited from %s#\n' % (class_.__name__)))
- temp = []
- temp.append(str(class_.__name__))
- docstring.write(toUnicode(getfielddoc_(temp, 'destFinfo')))
- # append_finfodocs(class_.__name__, docstring, indent)
- if class_ == _moose.Neutral: # Neutral is the toplevel moose class
- break
-
- info = '\t Class attributes \n\t -------------------- \n\t All \'valueFinfo\' are attributes of the class, and can be read and written using \n\t standard get and set Functions (unless explicitely mentioned otherwise). \n\t for example, getVm() and setVm() for access to Vm.\n\t All \'sharedFinfo\'...'
- docstring.write(toUnicode('%s\n') % (info))
- docstring.write(toUnicode(getfielddoc_(tokens, 'valueFinfo')))
- # append_finfodocs(tokens[0], docstring, indent)
- if inherited:
- mro = eval('_moose.%s' % (tokens[0])).mro()
- for class_ in mro[1:]:
- if class_ == _moose.melement:
- break
- docstring.write(toUnicode('\n#Inherited from %s#\n' % (class_.__name__)))
- temp = []
- temp.append(str(class_.__name__))
- docstring.write(toUnicode(getfielddoc_(temp, 'valueFinfo')))
- # append_finfodocs(class_.__name__, docstring, indent)
- if class_ == _moose.Neutral: # Neutral is the toplevel moose class
- break
-
- info = '\t Source Messages \n\t ----------------------- \n\t All \'srcFinfo\' can be used as sourceField for moose.connect function.'
- docstring.write(toUnicode('%s\n') % (info))
- docstring.write(toUnicode(getfielddoc_(tokens, 'srcFinfo')))
- # append_finfodocs(tokens[0], docstring, indent)
- if inherited:
- mro = eval('_moose.%s' % (tokens[0])).mro()
- for class_ in mro[1:]:
- if class_ == _moose.melement:
- break
- docstring.write(toUnicode('\n#Inherited from %s#\n' % (class_.__name__)))
- temp = []
- temp.append(str(class_.__name__))
- docstring.write(toUnicode(getfielddoc_(temp, 'srcFinfo')))
- # append_finfodocs(class_.__name__, docstring, indent)
- if class_ == _moose.Neutral: # Neutral is the toplevel moose class
- break
-
- info = '\t LookUp Fields \n\t ---------------- \n\t All \'lookupFinfo\' are ..................................\n'
- docstring.write(toUnicode('%s\n') % (info))
- docstring.write(toUnicode(getfielddoc_(tokens, 'lookupFinfo')))
- # append_finfodocs(tokens[0], docstring, indent)
- if inherited:
- mro = eval('_moose.%s' % (tokens[0])).mro()
- for class_ in mro[1:]:
- if class_ == _moose.melement:
- break
- docstring.write(toUnicode('\n#Inherited from %s#\n' % (class_.__name__)))
- temp = []
- temp.append(str(class_.__name__))
- docstring.write(toUnicode(getfielddoc_(temp, 'lookupFinfo')))
- # append_finfodocs(class_.__name__, docstring, indent)
- if class_ == _moose.Neutral: # Neutral is the toplevel moose class
- break
-
- info = '\t shared fields \n\t ---------------- \n\t All \'sharedFinfo\' are ..................................\n'
- docstring.write(toUnicode('%s\n') % (info))
- docstring.write(toUnicode(getfielddoc_(tokens, 'sharedFinfo')))
- # append_finfodocs(tokens[0], docstring, indent)
- if inherited:
- mro = eval('_moose.%s' % (tokens[0])).mro()
- for class_ in mro[1:]:
- if class_ == _moose.melement:
- break
- docstring.write(toUnicode('\n#Inherited from %s#\n' % (class_.__name__)))
- temp = []
- temp.append(str(class_.__name__))
- docstring.write(toUnicode(getfielddoc_(temp, 'sharedFinfo')))
- # append_finfodocs(class_.__name__, docstring, indent)
- if class_ == _moose.Neutral: # Neutral is the toplevel moose class
- break
-
- return docstring.getvalue()
-
-def append_finfodocs(classname, docstring, indent):
- """Append list of finfos in class name to docstring"""
- try:
- class_element = _moose.element('/classes/%s' % (classname))
- except ValueError:
- raise NameError('class \'%s\' not defined.' % (classname))
- for ftype, rname in finfotypes:
- docstring.write(toUnicode('\n*%s*\n' % (rname.capitalize())))
- try:
- finfo = _moose.element('%s/%s' % (class_element.path, ftype))
- for field in finfo.vec:
- docstring.write(toUnicode(
- '%s%s: %s\n' % (indent, field.fieldName, field.type)))
- except ValueError:
- docstring.write(toUnicode('%sNone\n' % (indent)))
-
-# the global pager is set from pydoc even if the user asks for paged
-# help once. this is to strike a balance between GENESIS user's
-# expectation of control returning to command line after printing the
-# help and python user's expectation of seeing the help via more/less.
-pager = None
-
-
-def doc(arg, inherited=True, paged=True):
- """Display the documentation for class or field in a class.
-
- Parameters
- ----------
- arg : str/class/melement/vec
- A string specifying a moose class name and a field name
- separated by a dot. e.g., 'Neutral.name'. Prepending `moose.`
- is allowed. Thus moose.doc('moose.Neutral.name') is equivalent
- to the above.
- It can also be string specifying just a moose class name or a
- moose class or a moose object (instance of melement or vec
- or there subclasses). In that case, the builtin documentation
- for the corresponding moose class is displayed.
-
- paged: bool
- Whether to display the docs via builtin pager or print and
- exit. If not specified, it defaults to False and
- moose.doc(xyz) will print help on xyz and return control to
- command line.
+"""
+from .moose import *
- Returns
- -------
- None
+# Wrapper to get moose version information.
+__version__ = moose._moose.__version__
- Raises
- ------
- NameError
- If class or field does not exist.
+VERSION = moose._moose.VERSION
- """
- # There is no way to dynamically access the MOOSE docs using
- # pydoc. (using properties requires copying all the docs strings
- # from MOOSE increasing the loading time by ~3x). Hence we provide a
- # separate function.
- global pager
- if paged and pager is None:
- pager = pydoc.pager
- tokens = []
- text = ''
- if isinstance(arg, str):
- tokens = arg.split('.')
- if tokens[0] == 'moose':
- tokens = tokens[1:]
- elif isinstance(arg, type):
- tokens = [arg.__name__]
- elif isinstance(arg, melement) or isinstance(arg, vec):
- text = '%s: %s\n\n' % (arg.path, arg.className)
- tokens = [arg.className]
- if tokens:
- text += getmoosedoc(tokens, inherited=inherited)
- else:
- text += pydoc.getdoc(arg)
- if pager:
- pager(text)
- else:
- print(text, width=80)
+# NOTE: No module should be imported here. Use moose.py to write imports.
diff --git a/python/moose/genesis/writeKkit.py b/python/moose/genesis/writeKkit.py
index 1e549601..11b14c95 100644
--- a/python/moose/genesis/writeKkit.py
+++ b/python/moose/genesis/writeKkit.py
@@ -8,21 +8,15 @@ __version__ = "1.0.0"
__maintainer__ = "Harsha Rani"
__email__ = "hrani@ncbs.res.in"
__status__ = "Development"
-__updated__ = "Feb 13 2017"
+
import sys
import random
import re
+import matplotlib
import moose
from moose.chemUtil.chemConnectUtil import *
from moose.chemUtil.graphUtils import *
-foundmatplotlib_ = False
-try:
- import matplotlib
- foundmatplotlib_ = True
-except Exception as e:
- pass
-
GENESIS_COLOR_SEQUENCE = ((248, 0, 255), (240, 0, 255), (232, 0, 255), (224, 0, 255), (216, 0, 255), (208, 0, 255),
(200, 0, 255), (192, 0, 255), (184, 0, 255), (176, 0, 255), (168, 0, 255), (160, 0, 255), (152, 0, 255), (144, 0, 255),
(136, 0, 255), (128, 0, 255), (120, 0, 255), (112, 0, 255), (104, 0, 255), (96, 0, 255), (88, 0, 255), (80, 0, 255),
@@ -44,12 +38,8 @@ GENESIS_COLOR_SEQUENCE = ((248, 0, 255), (240, 0, 255), (232, 0, 255), (224, 0,
# --StimulusTable
def mooseWriteKkit( modelpath, filename, sceneitems={}):
- global foundmatplotlib_
- if not foundmatplotlib_:
- print('No maplotlib found.'
- '\nThis module can be installed by following command in terminal:'
- '\n\t sudo apt install python-maplotlib', "")
- return False
+ if filename.rfind('.') != -1:
+ filename = filename[:filename.rfind('.')]
else:
error = " "
ignoreColor= ["mistyrose","antiquewhite","aliceblue","azure","bisque","black","blanchedalmond","blue","cornsilk","darkolivegreen","darkslategray","dimgray","floralwhite","gainsboro","ghostwhite","honeydew","ivory","lavender","lavenderblush","lemonchiffon","lightcyan","lightgoldenrodyellow","lightgray","lightyellow","linen","mediumblue","mintcream","navy","oldlace","papayawhip","saddlebrown","seashell","snow","wheat","white","whitesmoke","aquamarine","lightsalmon","moccasin","limegreen","snow","sienna","beige","dimgrey","lightsage"]
@@ -535,6 +525,11 @@ def getColorCheck(color,GENESIS_COLOR_SEQUENCE):
else:
raise Exception("Invalid Color Value!")
+ignoreColor= ["mistyrose","antiquewhite","aliceblue","azure","bisque","black","blanchedalmond","blue","cornsilk","darkolivegreen","darkslategray","dimgray","floralwhite","gainsboro","ghostwhite","honeydew","ivory","lavender","lavenderblush","lemonchiffon","lightcyan","lightgoldenrodyellow","lightgray","lightyellow","linen","mediumblue","mintcream","navy","oldlace","papayawhip","saddlebrown","seashell","snow","wheat","white","whitesmoke","aquamarine","lightsalmon","moccasin","limegreen","snow","sienna","beige","dimgrey","lightsage"]
+matplotcolor = {}
+for name,hexno in matplotlib.colors.cnames.items():
+ matplotcolor[name]=hexno
+
def getRandColor():
k = random.choice(list(matplotcolor.keys()))
if k in ignoreColor:
@@ -663,19 +658,13 @@ def writeFooter2(f):
if __name__ == "__main__":
import sys
- import os
- filename = sys.argv[1]
- filepath, filenameWithext = os.path.split(filename)
- if filenameWithext.find('.') != -1:
- modelpath = filenameWithext[:filenameWithext.find('.')]
- else:
- modelpath = filenameWithext
+ filename = sys.argv[1]
+ modelpath = filename[0:filename.find('.')]
moose.loadModel(filename,'/'+modelpath,"gsl")
output = modelpath+"_.g"
- written = mooseWriteKkit('/'+modelpath,output)
-
+ written = write('/'+modelpath,output)
if written:
print((" file written to ",output))
else:
- print(" could be written to kkit format")
\ No newline at end of file
+ print(" could be written to kkit format")
diff --git a/python/moose/merge/merge.py b/python/moose/merge/merge.py
index a8507808..224431d4 100644
--- a/python/moose/merge/merge.py
+++ b/python/moose/merge/merge.py
@@ -11,31 +11,15 @@
#** copyright (C) 2003-2017 Upinder S. Bhalla. and NCBS
#Created : Friday Dec 16 23:19:00 2016(+0530)
#Version
-#Last-Updated: Tuesday Feb 28 15:05:33 2017(+0530)
+#Last-Updated: Thursday Jan 12 17:30:33 2017(+0530)
# By: Harsha
#**********************************************************************/
-# This program is used to merge models from src to destination
-#Rules are :
-# -- If Compartment from the src model doesn't exist in destination model,
-# then entire compartment and its children are copied over including groups
-# -- Models are mergered at group level (if exists)
-# (Group is Neutral object in moose, which may represent pathway in network model)
-# -- Pool's are copied from source to destination if it doesn't exist, if exist nothing is done
-# -- Reaction (Reac), Enzyme (Enz) are copied
-# --- if any danglling Reac or Enz exist then that is not copied
-#
-# --- if Reac Name's is different for a given path (group level)
-# then copy the entire Reac along with substrate/product
-# --- if same Reac Name and same sub and prd then nothing is copied
-# --- if same Reac Name but sub or prd is different then duplicated and copied
-#
-# --- if Enz Name's is different for a given parent pool path
-# then copy the entire Enz along with substrate/product
-# --- if same Enz Name and same sub and prd then nothing is copied
-# --- if same Enz Name but sub or prd is different then duplicated and copied
-# -- Function are copied only if destination pool to which its suppose to connect doesn't exist with function of its own
-#
+# This program is used to merge models
+# -- Model B is merged to modelA
+#Rules are
+#--In this models are mergered at group level (if exists)
+
import sys
@@ -48,8 +32,7 @@ from moose.chemUtil.chemConnectUtil import *
from moose.chemUtil.graphUtils import *
from moose.genesis import mooseWriteKkit
-def mergeChemModel(src,des):
-
+def mergeChemModel(A,B):
""" Merges two model or the path """
A = src
B = des
@@ -82,29 +65,39 @@ def mergeChemModel(src,des):
deleteSolver(modelA)
deleteSolver(modelB)
- global poolListina
+ modelA,loadedA = loadModels(A)
+ modelB,loadedB = loadModels(B)
+ if not loadedA or not loadedB:
+ if not loadedA:
+ modelB = moose.Shell('/')
+ if not loadedB:
+ modelA = moose.Shell('/')
+ else:
+ directory, bfname = os.path.split(B)
+ global grpNotcopiedyet,poolListina
poolListina = {}
grpNotcopiedyet = []
dictComptA = dict( [ (i.name,i) for i in moose.wildcardFind(modelA+'/##[ISA=ChemCompt]') ] )
dictComptB = dict( [ (i.name,i) for i in moose.wildcardFind(modelB+'/##[ISA=ChemCompt]') ] )
+
poolNotcopiedyet = []
- for key in list(dictComptA.keys()):
- if key not in dictComptB:
+ for key in list(dictComptB.keys()):
+ if key not in dictComptA:
# if compartmentname from modelB does not exist in modelA, then copy
- copy = moose.copy(dictComptA[key],moose.element(modelB))
+ copy = moose.copy(dictComptB[key],moose.element(modelA))
else:
#if compartmentname from modelB exist in modelA,
#volume is not same, then change volume of ModelB same as ModelA
- if abs(dictComptB[key].volume - dictComptA[key].volume):
+ if abs(dictComptA[key].volume - dictComptB[key].volume):
#hack for now
- while (abs(dictComptB[key].volume - dictComptA[key].volume) != 0.0):
- dictComptA[key].volume = float(dictComptB[key].volume)
- dictComptB = dict( [ (i.name,i) for i in moose.wildcardFind(modelB+'/##[ISA=ChemCompt]') ] )
+ while (abs(dictComptA[key].volume - dictComptB[key].volume) != 0.0):
+ dictComptB[key].volume = float(dictComptA[key].volume)
+ dictComptA = dict( [ (i.name,i) for i in moose.wildcardFind(modelA+'/##[ISA=ChemCompt]') ] )
#Mergering pool
- poolMerge(dictComptB[key],dictComptA[key],poolNotcopiedyet)
-
+ poolMerge(dictComptA[key],dictComptB[key],poolNotcopiedyet)
+
if grpNotcopiedyet:
# objA = moose.element(comptA).parent.name
# if not moose.exists(objA+'/'+comptB.name+'/'+bpath.name):
@@ -112,14 +105,15 @@ def mergeChemModel(src,des):
# moose.copy(bpath,moose.element(objA+'/'+comptB.name))
pass
- comptBdict = comptList(modelB)
- poolListinb = {}
- poolListinb = updatePoolList(comptBdict)
+ comptAdict = comptList(modelA)
+ poolListina = {}
+ poolListina = updatePoolList(comptAdict)
+ funcNotallowed = []
R_Duplicated, R_Notcopiedyet,R_Daggling = [], [], []
E_Duplicated, E_Notcopiedyet,E_Daggling = [], [], []
- for key in list(dictComptA.keys()):
- funcExist, funcNotallowed = [], []
- funcExist,funcNotallowed = functionMerge(dictComptB,dictComptA,key)
+ for key in list(dictComptB.keys()):
+ funcNotallowed = []
+ funcNotallowed = functionMerge(dictComptA,dictComptB,key)
poolListinb = updatePoolList(dictComptB)
R_Duplicated,R_Notcopiedyet,R_Daggling = reacMerge(dictComptB,dictComptA,key,poolListinb)
@@ -135,14 +129,15 @@ def mergeChemModel(src,des):
for fl in list(funcExist):
print("\t [Pool]: %s [Function]: %s \n" %(str(fl.parent.name), str(fl.path)))
if funcNotallowed:
- print( "\nThese functions is not to copied, since pool connected to function input are from different compartment:")
+ print( "\nPool already connected to a function, this function is not to connect to same pool, since no two function are allowed to connect to same pool:")
for fl in list(funcNotallowed):
print("\t [Pool]: %s [Function]: %s \n" %(str(fl.parent.name), str(fl.path)))
+
if R_Duplicated or E_Duplicated:
- print ("These Reaction / Enzyme are \"Duplicated\" into destination file \"%s\", due to "
- "\n 1. If substrate / product name's are different for a give reaction/Enzyme name "
- "\n 2. If product belongs to different compartment "
- "\n Models have to decide to keep or delete these reaction/enzyme in %s" %(dfile, dfile))
+ print ("Reaction / Enzyme are Duplicate"
+ "\n 1. The once whoes substrate / product names are different for a give reaction name "
+ "\n 2. its compartment to which it belongs to may be is different"
+ "\n Models have to decide to keep or delete these reaction/enzyme")
if E_Duplicated:
print("Reaction: ")
for rd in list(R_Duplicated):
@@ -166,7 +161,7 @@ def mergeChemModel(src,des):
print ("%s " %str(ed.name))
if R_Daggling or E_Daggling:
- print ("\n Daggling reaction/enzyme are not allowed in moose, these are not merged to %s from %s" %(dfile, sfile))
+ print ("\n Daggling reaction/enzyme are not not allowed in moose, these are not merged")
if R_Daggling:
print("Reaction: ")
for rd in list(R_Daggling):
@@ -203,48 +198,60 @@ def mergeChemModel(src,des):
print (' If you are in python terminal you could save \n >moose.mooseWriteKkit(\'%s\',\'filename.g\')' %(modelB))
def functionMerge(comptA,comptB,key):
- funcNotallowed, funcExist = [], []
+ funcNotallowed = []
comptApath = moose.element(comptA[key]).path
comptBpath = moose.element(comptB[key]).path
+ funcListina = moose.wildcardFind(comptApath+'/##[ISA=PoolBase]')
+ funcListinb = moose.wildcardFind(comptBpath+'/##[ISA=Function]')
objA = moose.element(comptApath).parent.name
objB = moose.element(comptBpath).parent.name
-
- #This will give us all the function which exist in modelB
- funcListinb = moose.wildcardFind(comptBpath+'/##[ISA=Function]')
+ #For function mergering pool name is taken as reference
+ funcNotcopiedyet = []
for fb in funcListinb:
- #This will give us all the pools that its connected to, for this function
- fvalueOut = moose.element(fb).neighbors['valueOut']
- for poolinB in fvalueOut:
- poolinBpath = poolinB.path
- poolinA = poolinBpath.replace(objB,objA)
- connectionexist = []
- if moose.exists(poolinA):
- #This is give us if pool which is to be connected already exist any connection
- connectionexist = moose.element(poolinA).neighbors['setN']+moose.element(poolinA).neighbors['setConc']+ moose.element(poolinA).neighbors['increment']
- if len(connectionexist) == 0:
- #This pool in model A doesnot exist with any function
- inputs = moose.element(fb.path+'/x').neighbors['input']
- volumes = []
- for ins in inputs:
- volumes.append((findCompartment(moose.element(ins))).volume)
- if len(set(volumes)) == 1:
- # If all the input connected belongs to one compartment then copy
- createFunction(fb,poolinA,objB,objA)
- else:
- # moose doesn't allow function's input to come from different compartment
- funcNotallowed.append(fb)
- else:
- #Pool in model 'A' already exist function "
- funcExist.append(fb)
- else:
- print(" Path in model A doesn't exists %s" %(poolinA))
-
- return funcExist,funcNotallowed
-def createFunction(fb,setpool,objB,objA):
+ if fb.parent.className in ['ZombiePool','Pool','ZombieBufPool','BufPool']:
+ objA = moose.element(comptApath).parent.name
+ fbpath = fb.path
+ #funcpath = fbpath[fbpath.find(findCompartment(fb).name)-1:len(fbpath)]
+ funcparentB = fb.parent.path
+ funcpath = fbpath.replace(objB,objA)
+ funcparentA = funcparentB.replace(objB,objA)
+ tt = moose.element(funcparentA).neighbors['setN']
+ if tt:
+ funcNotallowed.append(fb)
+ else:
+ if len(moose.element(fb.path+'/x').neighbors["input"]):
+ #inputB = moose.element(fb.path+'/x').neighbors["input"]
+ inputB = subprdList(moose.element(fb.path+'/x'),"input")
+ inputB_expr = fb.expr
+ if moose.exists(funcpath):
+ #inputA = moose.element(objA+funcpath+'/x').neighbors["input"]
+ inputA = subprdList(moose.element(funcpath+'/x'),"input")
+ inputA_expr = moose.element(funcpath).expr
+ hassameExpr = False
+ if inputA_expr == inputB_expr:
+ hassameExpr = True
+ hassameLen,hassameS,hassameVols = same_len_name_vol(inputA,inputB)
+ if not all((hassameLen,hassameS,hassameVols,hassameExpr)):
+ fb.name = fb.name+'_duplicatedF'
+ createFunction(fb,inputB,objB,objA)
+ else:
+ #function doesnot exist then copy
+ if len(inputB):
+ volinput = []
+ for inb in inputB:
+ volinput.append(findCompartment(moose.element(inb)).volume)
+ if len(set(volinput)) == 1:
+ # If all the input connected belongs to one compartment then copy
+ createFunction(fb,inputB,objB,objA)
+ else:
+ # moose doesn't allow function input to come from different compartment
+ funcNotallowed.append(fb)
+ return funcNotallowed
+
+def createFunction(fb,inputB,objB,objA):
fapath1 = fb.path.replace(objB,objA)
fapath = fapath1.replace('[0]','')
-
if not moose.exists(fapath):
# if fb.parent.className in ['CubeMesh','CyclMesh']:
# des = moose.Function('/'+objA+'/'+fb.parent.name+'/'+fb.name)
@@ -253,13 +260,7 @@ def createFunction(fb,setpool,objB,objA):
# if fb.parent.name == akey.name:
# des = moose.Function(akey.path+'/'+fb.name)
des = moose.Function(fapath)
- else:
- des = moose.element(fapath)
- inputB = moose.element(fb.path+'/x').neighbors["input"]
- moose.connect(des, 'valueOut', moose.element(setpool),'setN' )
- inputA = []
- inputA = moose.element(fapath+'/x').neighbors["input"]
- if not inputA:
+ moose.connect(des, 'valueOut', moose.element(fapath).parent,'setN' )
for src in inputB:
pool = ((src.path).replace(objB,objA)).replace('[0]','')
numVariables = des.numVars
@@ -270,30 +271,29 @@ def createFunction(fb,setpool,objB,objA):
des.expr = expr
moose.connect( pool, 'nOut', des.x[numVariables], 'input' )
+ #if fb.expr != des.expr:
+ # print "Function ",des, " which is duplicated from modelB, expression is different, this is tricky in moose to know what those constants are connected to "
+ # print "ModelB ", fb, fb.expr, "\nModelA ",des, des.expr
+
def comptList(modelpath):
comptdict = {}
for ca in moose.wildcardFind(modelpath+'/##[ISA=ChemCompt]'):
comptdict[ca.name] = ca
return comptdict
-def loadModels(filepath):
+def loadModels(filename):
""" load models into moose if file, if moosepath itself it passes back the path and
delete solver if exist """
modelpath = '/'
loaded = False
- if os.path.isfile(filepath) :
- fpath, filename = os.path.split(filepath)
- # print " head and tail ",head, " ",tail
- # modelpath = filename[filename.rfind('/'): filename.rfind('.')]
- # print "modelpath ",modelpath
- # ext = os.path.splitext(filename)[1]
- # filename = filename.strip()
- modelpath = '/'+filename[:filename.rfind('.')]
- modeltype = mtypes.getType(filepath)
- subtype = mtypes.getSubtype(filepath, modeltype)
-
+ if os.path.isfile(filename) :
+ modelpath = filename[filename.rfind('/'): filename.rfind('.')]
+ ext = os.path.splitext(filename)[1]
+ filename = filename.strip()
+ modeltype = mtypes.getType(filename)
+ subtype = mtypes.getSubtype(filename, modeltype)
if subtype == 'kkit' or modeltype == "cspace":
if moose.exists(modelpath):
moose.delete(modelpath)
@@ -301,16 +301,18 @@ def loadModels(filepath):
loaded = True
elif subtype == 'sbml':
- #moose.mooseReadSBML(filename,modelpath)
- #loaded = True
+ #moose.ReadSBML()
pass
else:
print("This file is not supported for mergering")
modelpath = moose.Shell('/')
-
- elif moose.exists(filepath):
- modelpath = filepath
+ elif moose.exists(filename):
+ modelpath = filename
loaded = True
+ ## default is 'ee' solver while loading the model using moose.loadModel,
+ ## yet deleteSolver is called just to be assured
+ if loaded:
+ deleteSolver(modelpath)
return modelpath,loaded
@@ -362,15 +364,15 @@ def copy_deleteUnlyingPoolObj(pool,path):
# which will automatically copie's the pool
copied = False
- if pool.parent.className not in ["Enz","ZombieEnz","MMenz","ZombieMMenz"]:
+ if pool.parent.className not in ["Enz","ZombieEnz"]:
poolcopied = moose.copy(pool,path)
copied = True
# deleting function and enzyme which gets copied if exist under pool
# This is done to ensure daggling function / enzyme not copied.
funclist = []
for types in ['setConc','setN','increment']:
- funclist.extend(moose.element(poolcopied).neighbors[types])
+ funclist.extend(moose.element(poolcopied).neighbors[types])
for fl in funclist:
moose.delete(fl)
enzlist = moose.element(poolcopied).neighbors['reac']
@@ -426,15 +428,20 @@ def enzymeMerge(comptA,comptB,key,poolListina):
allclean = True
else:
# didn't find sub or prd for this Enzyme
+ #print ("didn't find sub or prd for this reaction" )
RE_Notcopiedyet.append(eb)
else:
# -- it is dagging reaction
RE_Daggling.append(eb)
+ #print ("This reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied")
+ #war_msg = war_msg+"\nThis reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied"
else:
#Same Enzyme name
# -- Same substrate and product including same volume then don't copy
# -- different substrate/product or if sub/prd's volume is different then DUPLICATE the Enzyme
allclean = False
+ #ea = moose.element('/'+obj+'/'+enzcompartment.name+'/'+enzparent.name+'/'+eb.name)
+ #ea = moose.element(pA.path+'/'+eb.name)
ea = moose.element(eb.path.replace(objB,objA))
eAsubname = subprdList(ea,"sub")
eBsubname = subprdList(eb,"sub")
@@ -464,6 +471,7 @@ def enzymeMerge(comptA,comptB,key,poolListina):
moose.connect(moose.element(enz).parent,"nOut",moose.element(enz),"enzDest")
#moose.connect(moose.element(enz),"enz",moose.element(enz).parent,"reac")
+ #moose.connect( cplxItem, 'reac', enz, 'cplx' )
connectObj(enz,eBsubname,"sub",comptA,war_msg)
connectObj(enz,eBprdname,"prd",comptA,war_msg)
RE_Duplicated.append(enz)
@@ -478,9 +486,12 @@ def enzymeMerge(comptA,comptB,key,poolListina):
# -- it may be connected Enzyme cplx
if eBsubname and eBprdname:
RE_Notcopiedyet.append(eb)
+ #print ("This Enzyme \""+eb.path+"\" has no substrate/product must be connect to cplx")
+ #war_msg = war_msg+ "\nThis Enzyme \""+rb.path+"\" has no substrate/product must be connect to cplx"
else:
RE_Daggling.append(eb)
-
+ #print ("This enzyme \""+eb.path+"\" has no substrate/product daggling reaction are not copied")
+ #war_msg = war_msg+"\nThis reaction \""+eb.path+"\" has no substrate/product daggling reaction are not copied"
return RE_Duplicated,RE_Notcopiedyet,RE_Daggling
def reacMerge(comptA,comptB,key,poolListina):
@@ -564,12 +575,17 @@ def reacMerge(comptA,comptB,key,poolListina):
# -- it may be connected Enzyme cplx
if rBsubname and rBprdname:
RE_Notcopiedyet.append(rb)
+ #print ("This reaction \""+rb.path+"\" has no substrate/product must be connect to cplx")
+ #war_msg = war_msg+ "\nThis reaction \""+rb.path+"\" has no substrate/product must be connect to cplx"
else:
RE_Daggling.append(rb)
+ #print ("This reaction \""+rb.path+"\" has no substrate/product daggling reaction are not copied")
+ #war_msg = war_msg+"\nThis reaction \""+rb.path+"\" has no substrate/product daggling reaction are not copied"
return RE_Duplicated,RE_Notcopiedyet,RE_Daggling
def subprdList(reac,subprd):
+ #print "Reac ",reac
rtype = moose.element(reac).neighbors[subprd]
rname = []
for rs in rtype:
@@ -620,6 +636,8 @@ def connectObj(reac,spList,spType,comptA,war_msg):
allclean = True
else:
#It should not come here unless the sub/prd is connected to enzyme cplx pool
+ #print ("This pool \""+rsp.name+"\" doesnot exists in this "+comptName+" compartment to connect to this reaction \""+reac.name+"\"")
+ #war_msg = war_msg+ "This pool \""+rsp.name+"\" doesnot exists in this "+comptName+" compartment to connect to this reaction \""+reac.name+"\""
allclean = False
return allclean
@@ -685,4 +703,4 @@ if __name__ == "__main__":
mergeto = mergeto+'merge'
mergered = mergeChemModel(src,des,mergeto)
- '''
\ No newline at end of file
+ '''
diff --git a/python/moose/moose.py b/python/moose/moose.py
new file mode 100644
index 00000000..0957638d
--- /dev/null
+++ b/python/moose/moose.py
@@ -0,0 +1,507 @@
+# moose.py ---
+# This is the primary moose module. It wraps _moose.so and adds some
+# utility functions.
+
+# Filename: moose.py
+# Author: Subhasis Ray
+# Maintainer: Dilawar Singh, Harsha Rani, Upi Bhalla
+
+from __future__ import print_function
+from contextlib import closing
+import warnings
+import platform
+import pydoc
+import os
+from io import StringIO
+from collections import defaultdict
+from . import _moose
+from ._moose import *
+import __main__ as main
+from .genesis import writeKkit
+from . import SBML
+sequence_types = ['vector<double>',
+ 'vector<int>',
+ 'vector<long>',
+ 'vector<unsigned int>',
+ 'vector<float>',
+ 'vector<unsigned long>',
+ 'vector<short>',
+ 'vector<Id>',
+ 'vector<ObjId>']
+
+known_types = ['void',
+ 'char',
+ 'short',
+ 'int',
+ 'unsigned int',
+ 'double',
+ 'float',
+ 'long',
+ 'unsigned long',
+ 'string',
+ 'vec',
+ 'melement'] + sequence_types
+
+# SBML related functions.
+
+
+def mooseReadSBML(filepath, loadpath, solver='ee'):
+ """Load SBML model.
+
+ keyword arguments: \n
+
+ filepath -- filepath to be loaded \n
+ loadpath -- Root path for this model e.g. /model/mymodel \n
+ solver -- Solver to use (default 'ee' ) \n
+
+ """
+ return SBML.readSBML.mooseReadSBML( filepath, loadpath, solver )
+
+
+def mooseWriteSBML(modelpath, filepath, sceneitems={}):
+ """Writes loaded model under modelpath to a file in SBML format.
+
+ keyword arguments:\n
+
+ modelpath -- model path in moose e.g /model/mymodel \n
+ filepath -- Path of output file. \n
+ sceneitems -- dictlist (UserWarning: user need not worry about this) \n
+ layout position is saved in Annotation field of all the moose Object (pool,Reaction,enzyme)\n
+ If this function is called from \n
+ -- GUI, the layout position of moose object is passed \n
+ -- command line, \n
+ ---if genesis/kkit model is loaded then layout position is taken from the file \n
+ --- else, auto-coordinates is used for layout position and passed
+
+ """
+ return SBML.writeSBML.mooseWriteSBML(modelpath, filepath, sceneitems)
+
+
+def mooseWriteKkit(modelpath, filepath,sceneitems={}):
+ """Writes loded model under modelpath to a file in Kkit format.
+
+ keyword arguments:\n
+
+ modelpath -- model path in moose \n
+ filepath -- Path of output file.
+ """
+ return writeKkit.mooseWriteKkit(modelpath, filepath,sceneitems)
+
+
+def moosedeleteChemSolver(modelpath):
+ """ deletes solver on all the compartment and its children.
+ This is neccesary while created a new moose object on a pre-existing modelpath,\n
+ this should be followed by mooseaddChemSolver for add solvers on to compartment to simulate else
+ default is Exponential Euler (ee)
+ """
+ return chemUtil.add_Delete_ChemicalSolver.moosedeleteChemSolver(modelpath)
+
+
+def mooseaddChemSolver(modelpath, solver):
+ """ Add solver on chemical compartment and its children for calculation
+
+ keyword arguments:\n
+
+ modelpath -- model path that is loaded into moose \n
+ solver -- "Exponential Euler" (ee) (default), \n
+ "Gillespie" ("gssa"), \n
+ "Runge Kutta" ("gsl")
+
+ """
+ return chemUtil.add_Delete_ChemicalSolver.mooseaddChemSolver(modelpath, solver)
+
+################################################################
+# Wrappers for global functions
+################################################################
+
+
+def pwe():
+ """Print present working element. Convenience function for GENESIS
+ users. If you want to retrieve the element in stead of printing
+ the path, use moose.getCwe()
+
+ """
+ pwe_ = _moose.getCwe()
+ print(pwe_.getPath())
+ return pwe_
+
+
+def le(el=None):
+ """List elements under `el` or current element if no argument
+ specified.
+
+ Parameters
+ ----------
+ el : str/melement/vec/None
+ The element or the path under which to look. If `None`, children
+ of current working element are displayed.
+
+ Returns
+ -------
+ List of path of child elements
+
+ """
+ if el is None:
+ el = getCwe()
+ elif isinstance(el, str):
+ if not exists(el):
+ raise ValueError('no such element')
+ el = element(el)
+ elif isinstance(el, vec):
+ el = el[0]
+ print('Elements under', el.path)
+ for ch in el.children:
+ print(ch.path)
+ return [child.path for child in el.children]
+
+ce = setCwe # ce is a GENESIS shorthand for change element.
+
+
+def syncDataHandler(target):
+ """Synchronize data handlers for target.
+
+ Parameters
+ ----------
+ target : melement/vec/str
+ Target element or vec or path string.
+
+ Raises
+ ------
+ NotImplementedError
+ The call to the underlying C++ function does not work.
+
+ Notes
+ -----
+ This function is defined for completeness, but currently it does not work.
+
+ """
+ raise NotImplementedError('The implementation is not working for IntFire - goes to invalid objects. \
+First fix that issue with SynBase or something in that line.')
+ if isinstance(target, str):
+ if not _moose.exists(target):
+ raise ValueError('%s: element does not exist.' % (target))
+ target = vec(target)
+ _moose.syncDataHandler(target)
+
+
+def showfield(el, field='*', showtype=False):
+ """Show the fields of the element `el`, their data types and
+ values in human readable format. Convenience function for GENESIS
+ users.
+
+ Parameters
+ ----------
+ el : melement/str
+ Element or path of an existing element.
+
+ field : str
+ Field to be displayed. If '*' (default), all fields are displayed.
+
+ showtype : bool
+ If True show the data type of each field. False by default.
+
+ Returns
+ -------
+ None
+
+ """
+ if isinstance(el, str):
+ if not exists(el):
+ raise ValueError('no such element')
+ el = element(el)
+ if field == '*':
+ value_field_dict = getFieldDict(el.className, 'valueFinfo')
+ max_type_len = max(len(dtype) for dtype in value_field_dict.values())
+ max_field_len = max(len(dtype) for dtype in value_field_dict.keys())
+ print('\n[', el.path, ']')
+ for key, dtype in sorted(value_field_dict.items()):
+ if dtype == 'bad' or key == 'this' or key == 'dummy' or key == 'me' or dtype.startswith(
+ 'vector') or 'ObjId' in dtype:
+ continue
+ value = el.getField(key)
+ if showtype:
+ typestr = dtype.ljust(max_type_len + 4)
+ # The following hack is for handling both Python 2 and
+ # 3. Directly putting the print command in the if/else
+ # clause causes syntax error in both systems.
+ print(typestr, end=' ')
+ print(key.ljust(max_field_len + 4), '=', value)
+ else:
+ try:
+ print(field, '=', el.getField(field))
+ except AttributeError:
+ pass # Genesis silently ignores non existent fields
+
+
+def showfields(el, showtype=False):
+ """Convenience function. Should be deprecated if nobody uses it.
+
+ """
+ warnings.warn(
+ 'Deprecated. Use showfield(element, field="*", showtype=True) instead.',
+ DeprecationWarning)
+ showfield(el, field='*', showtype=showtype)
+
+# Predefined field types and their human readable names
+finfotypes = [('valueFinfo', 'value field'),
+ ('srcFinfo', 'source message field'),
+ ('destFinfo', 'destination message field'),
+ ('sharedFinfo', 'shared message field'),
+ ('lookupFinfo', 'lookup field')]
+
+
+def listmsg(el):
+ """Return a list containing the incoming and outgoing messages of
+ `el`.
+
+ Parameters
+ ----------
+ el : melement/vec/str
+ MOOSE object or path of the object to look into.
+
+ Returns
+ -------
+ msg : list
+ List of Msg objects corresponding to incoming and outgoing
+ connections of `el`.
+
+ """
+ obj = element(el)
+ ret = []
+ for msg in obj.inMsg:
+ ret.append(msg)
+ for msg in obj.outMsg:
+ ret.append(msg)
+ return ret
+
+
+def showmsg(el):
+ """Print the incoming and outgoing messages of `el`.
+
+ Parameters
+ ----------
+ el : melement/vec/str
+ Object whose messages are to be displayed.
+
+ Returns
+ -------
+ None
+
+ """
+ obj = element(el)
+ print('INCOMING:')
+ for msg in obj.msgIn:
+ print(
+ msg.e2.path,
+ msg.destFieldsOnE2,
+ '<---',
+ msg.e1.path,
+ msg.srcFieldsOnE1)
+ print('OUTGOING:')
+ for msg in obj.msgOut:
+ print(
+ msg.e1.path,
+ msg.srcFieldsOnE1,
+ '--->',
+ msg.e2.path,
+ msg.destFieldsOnE2)
+
+
+def getfielddoc(tokens, indent=''):
+ """Return the documentation for field specified by `tokens`.
+
+ Parameters
+ ----------
+ tokens : (className, fieldName) str
+ A sequence whose first element is a MOOSE class name and second
+ is the field name.
+
+ indent : str
+ indentation (default: empty string) prepended to builtin
+ documentation string.
+
+ Returns
+ -------
+ docstring : str
+ string of the form
+ `{indent}{className}.{fieldName}: {datatype} - {finfoType}\n{Description}\n`
+
+ Raises
+ ------
+ NameError
+ If the specified fieldName is not present in the specified class.
+ """
+ assert(len(tokens) > 1)
+ classname = tokens[0]
+ fieldname = tokens[1]
+ while True:
+ try:
+ classelement = _moose.element('/classes/' + classname)
+ for finfo in classelement.children:
+ for fieldelement in finfo:
+ baseinfo = ''
+ if classname != tokens[0]:
+ baseinfo = ' (inherited from {})'.format(classname)
+ if fieldelement.fieldName == fieldname:
+ # The field elements are
+ # /classes/{ParentClass}[0]/{fieldElementType}[N].
+ finfotype = fieldelement.name
+ return '{indent}{classname}.{fieldname}: type={type}, finfotype={finfotype}{baseinfo}\n\t{docs}\n'.format(
+ indent=indent, classname=tokens[0],
+ fieldname=fieldname,
+ type=fieldelement.type,
+ finfotype=finfotype,
+ baseinfo=baseinfo,
+ docs=fieldelement.docs)
+ classname = classelement.baseClass
+ except ValueError:
+ raise NameError('`%s` has no field called `%s`'
+ % (tokens[0], tokens[1]))
+
+
+def toUnicode(v, encoding='utf8'):
+ # if isinstance(v, str):
+ # return v
+ try:
+ return v.decode(encoding)
+ except (AttributeError, UnicodeEncodeError):
+ return str(v)
+
+
+def getmoosedoc(tokens, inherited=False):
+ """Return MOOSE builtin documentation.
+
+ Parameters
+ ----------
+ tokens : (className, [fieldName])
+ tuple containing one or two strings specifying class name
+ and field name (optional) to get documentation for.
+
+ inherited: bool (default: False)
+ include inherited fields.
+
+ Returns
+ -------
+ docstring : str
+ Documentation string for class `className`.`fieldName` if both
+ are specified, for the class `className` if fieldName is not
+ specified. In the latter case, the fields and their data types
+ and finfo types are listed.
+
+ Raises
+ ------
+ NameError
+ If class or field does not exist.
+
+ """
+ indent = ' '
+ with closing(StringIO()) as docstring:
+ if not tokens:
+ return ""
+ try:
+ class_element = _moose.element('/classes/%s' % (tokens[0]))
+ except ValueError:
+ raise NameError('name \'%s\' not defined.' % (tokens[0]))
+ if len(tokens) > 1:
+ docstring.write(toUnicode(getfielddoc(tokens)))
+ else:
+ docstring.write(toUnicode('%s\n' % (class_element.docs)))
+ append_finfodocs(tokens[0], docstring, indent)
+ if inherited:
+ mro = eval('_moose.%s' % (tokens[0])).mro()
+ for class_ in mro[1:]:
+ if class_ == _moose.melement:
+ break
+ docstring.write(toUnicode(
+ '\n\n#Inherited from %s#\n' % (class_.__name__)))
+ append_finfodocs(class_.__name__, docstring, indent)
+ if class_ == _moose.Neutral: # Neutral is the toplevel moose class
+ break
+ return docstring.getvalue()
+
+
+def append_finfodocs(classname, docstring, indent):
+ """Append list of finfos in class name to docstring"""
+ try:
+ class_element = _moose.element('/classes/%s' % (classname))
+ except ValueError:
+ raise NameError('class \'%s\' not defined.' % (classname))
+ for ftype, rname in finfotypes:
+ docstring.write(toUnicode('\n*%s*\n' % (rname.capitalize())))
+ try:
+ finfo = _moose.element('%s/%s' % (class_element.path, ftype))
+ for field in finfo.vec:
+ docstring.write(toUnicode(
+ '%s%s: %s\n' % (indent, field.fieldName, field.type)))
+ except ValueError:
+ docstring.write(toUnicode('%sNone\n' % (indent)))
+
+
+# the global pager is set from pydoc even if the user asks for paged
+# help once. this is to strike a balance between GENESIS user's
+# expectation of control returning to command line after printing the
+# help and python user's expectation of seeing the help via more/less.
+pager = None
+
+
+def doc(arg, inherited=True, paged=True):
+ """Display the documentation for class or field in a class.
+
+ Parameters
+ ----------
+ arg : str/class/melement/vec
+ A string specifying a moose class name and a field name
+ separated by a dot. e.g., 'Neutral.name'. Prepending `moose.`
+ is allowed. Thus moose.doc('moose.Neutral.name') is equivalent
+ to the above.
+ It can also be string specifying just a moose class name or a
+ moose class or a moose object (instance of melement or vec
+ or there subclasses). In that case, the builtin documentation
+ for the corresponding moose class is displayed.
+
+ paged: bool
+ Whether to display the docs via builtin pager or print and
+ exit. If not specified, it defaults to False and
+ moose.doc(xyz) will print help on xyz and return control to
+ command line.
+
+ Returns
+ -------
+ None
+
+ Raises
+ ------
+ NameError
+ If class or field does not exist.
+
+ """
+ # There is no way to dynamically access the MOOSE docs using
+ # pydoc. (using properties requires copying all the docs strings
+ # from MOOSE increasing the loading time by ~3x). Hence we provide a
+ # separate function.
+ global pager
+ if paged and pager is None:
+ pager = pydoc.pager
+ tokens = []
+ text = ''
+ if isinstance(arg, str):
+ tokens = arg.split('.')
+ if tokens[0] == 'moose':
+ tokens = tokens[1:]
+ elif isinstance(arg, type):
+ tokens = [arg.__name__]
+ elif isinstance(arg, melement) or isinstance(arg, vec):
+ text = '%s: %s\n\n' % (arg.path, arg.className)
+ tokens = [arg.className]
+ if tokens:
+ text += getmoosedoc(tokens, inherited=inherited)
+ else:
+ text += pydoc.getdoc(arg)
+ if pager:
+ pager(text)
+ else:
+ print(text)
+
+
+#
+# moose.py ends here
diff --git a/python/moose/plot_utils.py b/python/moose/plot_utils.py
index 25346524..c7c7a977 100644
--- a/python/moose/plot_utils.py
+++ b/python/moose/plot_utils.py
@@ -135,7 +135,7 @@ def plotTables(tables, outfile=None, **kwargs):
subplot = kwargs.get('subplot', True)
for i, tname in enumerate(tables):
if subplot:
- plt.subplot(len(tables), 1, i+1)
+ plt.subplot(len(tables), 1, i)
yvec = tables[tname].vector
xvec = np.linspace(0, moose.Clock('/clock').currentTime, len(yvec))
plt.plot(xvec, yvec, label=tname)
@@ -165,7 +165,7 @@ def plotVector(vec, xvec = None, **options):
:param vec: Given vector.
:param **kwargs: Optional to pass to maplotlib.
"""
- ax = options[ 'ax' ]
+
assert type(vec) == np.ndarray, "Expected type %s" % type(vec)
legend = options.get('legend', True)
@@ -176,29 +176,28 @@ def plotVector(vec, xvec = None, **options):
xx = xvec[:]
assert len(xx) == len(vec), "Expecting %s got %s" % (len(vec), len(xvec))
- ax.plot(xx, vec, label=options.get('label', ''))
+ plt.plot(xx, vec, label=options.get('label', ''))
if legend:
# This may not be available on older version of matplotlib.
try:
- ax.legend(loc='best', framealpha=0.4)
+ plt.legend(loc='best', framealpha=0.4)
except:
- ax.legend(loc='best')
+ plt.legend(loc='best')
if xvec is None:
- ax.set_xlabel('Time (sec)')
+ plt.xlabel('Time (sec)')
else:
- ax.set_xlabel(options.get('xlabel', ''))
+ plt.xlabel(options.get('xlabel', ''))
- ax.set_ylabel = options.get('ylabel', '')
- ax.set_title(options.get('title', ''))
+ plt.ylabel = options.get('ylabel', '')
+ plt.title(options.get('title', ''))
if(options.get('legend', True)):
try:
- ax.legend(loc='best', framealpha=0.4, prop={'size' : 9})
+ plt.legend(loc='best', framealpha=0.4, prop={'size' : 9})
except:
- ax.legend(loc='best', prop={'size' : 9})
- return ax
+ plt.legend(loc='best', prop={'size' : 9})
def saveRecords(records, xvec = None, **kwargs):
@@ -268,7 +267,7 @@ def plotRecords(records, xvec = None, **kwargs):
yvec = dataDict[k].vector
plotVector(yvec, xvec, label=k, **kwargs)
else:
- kwargs[ 'ax' ] = plt.subplot(len(dataDict), 1, i)
+ plt.subplot(len(dataDict), 1, i)
yvec = dataDict[k].vector
plotVector(yvec, xvec, label=k, **kwargs)
@@ -287,13 +286,9 @@ def plotRecords(records, xvec = None, **kwargs):
else:
plt.show()
-def plot_records( data_dict, xvec = None, **kwargs ):
- """Renamed (deprecated)
- """
- return plot_tables( data_dict, xvec, **kwargs )
-def plot_tables(data_dict, xvec = None, **kwargs):
- """plot_tables plots moose.Table stored in a dictionary.
+def plot_records(data_dict, xvec = None, **kwargs):
+ """plot_records Plot given dictionary.
:param data_dict:
:param xvec: If None, use moose.Clock to generate xvec.
@@ -323,7 +318,7 @@ def plot_tables(data_dict, xvec = None, **kwargs):
if plotThis:
if not subplot:
- yvec = data_dict[k].vector
+ yvec = data_dict[k]
plotVector(yvec, xvec, label=k, **kwargs)
else:
ax = plt.subplot(len(data_dict), 1, i+1)
diff --git a/python/rdesigneur/rdesigneur.py b/python/rdesigneur/rdesigneur.py
index 632e7ead..e267921c 100644
--- a/python/rdesigneur/rdesigneur.py
+++ b/python/rdesigneur/rdesigneur.py
@@ -80,7 +80,6 @@ class rdesigneur:
useGssa = True,
combineSegments = True,
stealCellFromLibrary = False,
- verbose = True,
diffusionLength= 2e-6,
meshLambda = -1.0, #This is a backward compatibility hack
temperature = 32,
@@ -112,7 +111,6 @@ class rdesigneur:
self.useGssa = useGssa
self.combineSegments = combineSegments
self.stealCellFromLibrary = stealCellFromLibrary
- self.verbose = verbose
self.diffusionLength= diffusionLength
if meshLambda > 0.0:
print("Warning: meshLambda argument is deprecated. Please use 'diffusionLength' instead.\nFor now rdesigneur will accept this argument.")
@@ -203,8 +201,7 @@ class rdesigneur:
self._buildMoogli()
self._buildStims()
self._configureClocks()
- if self.verbose:
- self._printModelStats()
+ self._printModelStats()
self._savePlots()
except BuildError as msg:
@@ -318,8 +315,7 @@ class rdesigneur:
return True
if moose.exists( '/library/' + protoVec[0] ):
#moose.copy('/library/' + protoVec[0], '/library/', protoVec[1])
- if self.verbose:
- print('renaming /library/' + protoVec[0] + ' to ' + protoVec[1])
+ print('renaming /library/' + protoVec[0] + ' to ' + protoVec[1])
moose.element( '/library/' + protoVec[0]).name = protoVec[1]
#moose.le( '/library' )
return True
@@ -458,7 +454,6 @@ class rdesigneur:
"buildChemDistrib: No elec compartments found in path: '" \
+ pair + "'" )
self.spineComptElist = self.elecid.spinesFromExpression[ pair ]
- #print( 'LEN SPINECOMPTELIST =' + str( pair ) + ", " str( len( self.spineComptElist ) ) )
'''
if len( self.spineComptElist ) == 0:
raise BuildError( \
@@ -600,7 +595,6 @@ class rdesigneur:
def _buildMoogli( self ):
knownFields = {
'Vm':('CompartmentBase', 'getVm', 1000, 'Memb. Potential (mV)', -80.0, 40.0 ),
- 'initVm':('CompartmentBase', 'getInitVm', 1000, 'Init. Memb. Potl (mV)', -80.0, 40.0 ),
'Im':('CompartmentBase', 'getIm', 1e9, 'Memb. current (nA)', -10.0, 10.0 ),
'inject':('CompartmentBase', 'getInject', 1e9, 'inject current (nA)', -10.0, 10.0 ),
'Gbar':('ChanBase', 'getGbar', 1e9, 'chan max conductance (nS)', 0.0, 1.0 ),
@@ -1282,8 +1276,8 @@ class rdesigneur:
else:
ePath = i[0].path + '/' + elecRelPath
if not( moose.exists( ePath ) ):
- continue
- #raise BuildError( "Error: buildAdaptor: no elec obj in " + ePath )
+ raise BuildError( \
+ "Error: buildAdaptor: no elec obj in " + ePath )
elObj = moose.element( i[0].path + '/' + elecRelPath )
if ( isElecToChem ):
elecFieldSrc = 'get' + capField
diff --git a/python/rdesigneur/rmoogli.py b/python/rdesigneur/rmoogli.py
index e1e34a78..8a475a09 100644
--- a/python/rdesigneur/rmoogli.py
+++ b/python/rdesigneur/rmoogli.py
@@ -17,7 +17,6 @@ import os
# Check if DISPLAY environment variable is properly set. If not, warn the user
# and continue.
hasDisplay = True
-hasMoogli = False
display = os.environ.get('DISPLAY', '' )
if not display:
hasDisplay = False
@@ -26,6 +25,7 @@ if not display:
"Anyway, MOOSE will continue without graphics.\n"
)
+hasMoogli = True
if hasDisplay:
try:
@@ -33,11 +33,11 @@ if hasDisplay:
import moogli
import moogli.extensions.moose
app = QtGui.QApplication(sys.argv)
- hasMoogli = True
except Exception as e:
print( 'Warning: Moogli not found. All moogli calls will use dummy functions' )
hasMoogli = False
+
runtime = 0.0
moogliDt = 1.0
rotation = math.pi / 500.0
diff --git a/python/setup.py b/python/setup.py
index 475826a5..a6c3852c 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -33,7 +33,7 @@ from distutils.core import setup
script_dir = os.path.dirname( os.path.abspath( __file__ ) )
-version = '3.2.git'
+version = '3.1'
try:
with open( os.path.join( script_dir, '..', 'VERSION'), 'r' ) as f:
version = f.read( )
diff --git a/scheduling/Clock.cpp b/scheduling/Clock.cpp
index 434d2f62..b5bac41b 100644
--- a/scheduling/Clock.cpp
+++ b/scheduling/Clock.cpp
@@ -327,7 +327,7 @@ const Cinfo* Clock::initCinfo()
"The clock also starts up with some default timesteps for each "
"of these ticks, and this can be overridden using the shell "
"command setClock, or by directly assigning tickStep values on the "
- "clock object. \n"
+ "clock object."
"Which objects use which tick? As a rule of thumb, try this: \n"
"Electrical/compartmental model calculations: Ticks 0-7 \n"
"Tables and output objects for electrical output: Tick 8 \n"
@@ -342,57 +342,57 @@ const Cinfo* Clock::initCinfo()
"clock ticks for the tables/fileIO objects handling output at "
"different time-resolutions. Typically one uses tick 8 and 18.\n"
"Here are the detailed mappings of class to tick.\n"
- " Class Tick dt \n"
- " DiffAmp 0 50e-6\n"
- " Interpol 0 50e-6\n"
- " PIDController 0 50e-6\n"
- " PulseGen 0 50e-6\n"
- " StimulusTable 0 50e-6\n"
- " testSched 0 50e-6\n"
- " VClamp 0 50e-6\n"
- " SynHandlerBase 1 50e-6\n"
- " SimpleSynHandler 1 50e-6\n"
- " STDPSynHandler 1 50e-6\n"
- " GraupnerBrunel2012CaPlasticitySynHandler 1 50e-6\n"
- " SeqSynHandler 1 50e-6\n"
+ " Class Tick dt \n"
+ " DiffAmp 0 50e-6\n"
+ " Interpol 0 50e-6\n"
+ " PIDController 0 50e-6\n"
+ " PulseGen 0 50e-6\n"
+ " StimulusTable 0 50e-6\n"
+ " testSched 0 50e-6\n"
+ " VClamp 0 50e-6\n"
+ " SynHandlerBase 1 50e-6\n"
+ " SimpleSynHandler 1 50e-6\n"
+ " STDPSynHandler 1 50e-6\n"
+ " GraupnerBrunel2012CaPlasticitySynHandler 1 50e-6\n"
+ " SeqSynHandler 1 50e-6\n"
" CaConc 1 50e-6\n"
" CaConcBase 1 50e-6\n"
" DifShell 1 50e-6\n"
- " DifShellBase 1 50e-6\n"
- " MMPump 1 50e-6\n"
- " DifBuffer 1 50e-6\n"
- " DifBufferBase 1 50e-6\n"
+ " DifShellBase 1 50e-6\n"
+ " MMPump 1 50e-6\n"
+ " DifBuffer 1 50e-6\n"
+ " DifBufferBase 1 50e-6\n"
" MgBlock 1 50e-6\n"
" Nernst 1 50e-6\n"
" RandSpike 1 50e-6\n"
" ChanBase 2 50e-6\n"
" IntFire 2 50e-6\n"
" IntFireBase 2 50e-6\n"
- " LIF 2 50e-6\n"
- " QIF 2 50e-6\n"
+ " LIF 2 50e-6\n"
+ " QIF 2 50e-6\n"
" ExIF 2 50e-6\n"
" AdExIF 2 50e-6\n"
- " AdThreshIF 2 50e-6\n"
+ " AdThreshIF 2 50e-6\n"
" IzhIF 2 50e-6\n"
- " IzhikevichNrn 2 50e-6\n"
+ " IzhikevichNrn 2 50e-6\n"
" SynChan 2 50e-6\n"
- " NMDAChan 2 50e-6\n"
+ " NMDAChan 2 50e-6\n"
" GapJunction 2 50e-6\n"
" HHChannel 2 50e-6\n"
" HHChannel2D 2 50e-6\n"
" Leakage 2 50e-6\n"
- " MarkovChannel 2 50e-6\n"
- " MarkovGslSolver 2 50e-6\n"
- " MarkovRateTable 2 50e-6\n"
- " MarkovSolver 2 50e-6\n"
- " MarkovSolverBase 2 50e-6\n"
- " RC 2 50e-6\n"
- " Compartment (init) 3 50e-6\n"
+ " MarkovChannel 2 50e-6\n"
+ " MarkovGslSolver 2 50e-6\n"
+ " MarkovRateTable 2 50e-6\n"
+ " MarkovSolver 2 50e-6\n"
+ " MarkovSolverBase 2 50e-6\n"
+ " RC 2 50e-6\n"
+ " Compartment (init) 3 50e-6\n"
" CompartmentBase (init ) 3 50e-6\n"
" SymCompartment (init) 3 50e-6\n"
- " Compartment 4 50e-6\n"
- " CompartmentBase 4 50e-6\n"
- " SymCompartment 4 50e-6\n"
+ " Compartment 4 50e-6\n"
+ " CompartmentBase 4 50e-6\n"
+ " SymCompartment 4 50e-6\n"
" SpikeGen 5 50e-6\n"
" HSolve 6 50e-6\n"
" SpikeStats 7 50e-6\n"
@@ -408,23 +408,23 @@ const Cinfo* Clock::initCinfo()
" Pool 13 0.1\n"
" PoolBase 13 0.1\n"
" CplxEnzBase 14 0.1\n"
- " Enz 14 0.1\n"
+ " Enz 14 0.1\n"
" EnzBase 14 0.1\n"
" MMenz 14 0.1\n"
" Reac 14 0.1\n"
" ReacBase 14 0.1\n"
- " Gsolve (init) 15 0.1\n"
- " Ksolve (init) 15 0.1\n"
+ " Gsolve (init) 15 0.1\n"
+ " Ksolve (init) 15 0.1\n"
" Gsolve 16 0.1\n"
" Ksolve 16 0.1\n"
" Stats 17 0.1\n"
" Table2 18 1\n"
" Streamer 19 10\n"
- " HDF5DataWriter 30 1\n"
- " HDF5WriterBase 30 1\n"
+ " HDF5DataWriter 30 1\n"
+ " HDF5WriterBase 30 1\n"
" NSDFWriter 30 1\n"
- " PyRun 30 1\n"
+ " PyRun 30 1\n"
" PostMaster 31 0.01\n"
" \n"
" Note that the other classes are not scheduled at all.",
@@ -746,7 +746,7 @@ void Clock::handleStep( const Eref& e, unsigned long numSteps )
time( &rawtime );
timeinfo = localtime( &rawtime );
strftime(now, 80, "%c", timeinfo);
- cout << "@ " << now << ": " << 100 * currentTime_ / runTime_
+ cout << "@ " << now << ": " << 100 * currentTime_ / runTime_
<< "% of total " << runTime_ << " seconds is over." << endl;
}
}
@@ -999,5 +999,3 @@ unsigned int Clock::lookupDefaultTick( const string& className )
}
return i->second;
}
-
-
diff --git a/synapse/CMakeLists.txt b/synapse/CMakeLists.txt
index 2b7d3622..bb47b977 100644
--- a/synapse/CMakeLists.txt
+++ b/synapse/CMakeLists.txt
@@ -1,18 +1,5 @@
cmake_minimum_required(VERSION 2.8)
-
include_directories( ../basecode ../utility ../kinetics)
include_directories( ../external/muparser/include/ )
-
-set( SYNAPSE_SRCS
- GraupnerBrunel2012CaPlasticitySynHandler.cpp
- RollingMatrix.cpp
- SeqSynHandler.cpp
- SimpleSynHandler.cpp
- STDPSynapse.cpp
- STDPSynHandler.cpp
- Synapse.cpp
- SynHandlerBase.cpp
- testSynapse.cpp
- )
-
+file(GLOB SYNAPSE_SRCS *.cpp)
add_library(synapse ${SYNAPSE_SRCS} )
diff --git a/synapse/RollingMatrix.cpp b/synapse/RollingMatrix.cpp
index 01818a83..5fd84a9b 100644
--- a/synapse/RollingMatrix.cpp
+++ b/synapse/RollingMatrix.cpp
@@ -11,7 +11,6 @@
using namespace std;
#include "RollingMatrix.h"
#include <cassert>
-// #include <iostream>
RollingMatrix::RollingMatrix()
: nrows_(0), ncolumns_(0), currentStartRow_(0)
@@ -68,21 +67,9 @@ void RollingMatrix::sumIntoRow( const vector< double >& input, unsigned int row
double RollingMatrix::dotProduct( const vector< double >& input,
unsigned int row, unsigned int startColumn ) const
{
- /// startColumn is the middle of the kernel.
unsigned int index = (row + currentStartRow_) % nrows_;
const SparseVector& sv = rows_[index];
- unsigned int i2 = input.size()/2;
- unsigned int istart = (startColumn >= i2) ? 0 : i2-startColumn;
- unsigned int colstart = (startColumn <= i2) ? 0 : startColumn - i2;
- unsigned int iend = (sv.size()-startColumn > i2 ) ? input.size() :
- i2 - startColumn + sv.size();
- // if ( iend >= istart ) cout << startColumn << i2 << istart << iend << colstart << "\n";
- double ret = 0;
- for (unsigned int i = istart, j = 0; i < iend; ++i, ++j )
- ret += sv[j + colstart] * input[i];
-
- /*
double ret = 0;
if ( input.size() + startColumn <= sv.size() ) {
for (unsigned int i = 0; i < input.size(); ++i )
@@ -92,7 +79,6 @@ double RollingMatrix::dotProduct( const vector< double >& input,
for (unsigned int i = 0; i < end; ++i )
ret += sv[i + startColumn] * input[i];
}
- */
return ret;
}
diff --git a/synapse/SeqSynHandler.cpp b/synapse/SeqSynHandler.cpp
index dc826cef..7cdf6bc9 100644
--- a/synapse/SeqSynHandler.cpp
+++ b/synapse/SeqSynHandler.cpp
@@ -8,7 +8,6 @@
**********************************************************************/
#include <queue>
-#include "global.h"
#include "header.h"
#include "Synapse.h"
#include "SynEvent.h"
@@ -43,22 +42,17 @@ const Cinfo* SeqSynHandler::initCinfo()
"kernel with the history[time][synapse#] matrix."
"\nThe local response can affect the synapse in three ways: "
"1. It can sum the entire response vector, scale by the "
- "*sequenceScale* term, and send to the synapse as a steady "
+ "*responseScale* term, and send to the synapse as a steady "
"activation. Consider this a cell-wide immediate response to "
"a sequence that it likes.\n"
"2. It do an instantaneous scaling of the weight of each "
"individual synapse by the corresponding entry in the response "
- "vector. It uses the *plasticityScale* term to do this. "
- "Consider "
+ "vector. It uses the *weightScale* term to do this. Consider "
"this a short-term plasticity effect on specific synapses. \n"
"3. It can do long-term plasticity of each individual synapse "
"using the matched local entries in the response vector and "
"individual synapse history as inputs to the learning rule. "
"This is not yet implemented.\n"
- "In addition to all these, the SeqSynHandler can act just like "
- "a regular synapse, where it responds to individual synaptic "
- "input according to the weight of the synapse. The size of "
- "this component of the output is scaled by *baseScale*\n"
};
static FieldElementFinfo< SynHandlerBase, Synapse > synFinfo(
@@ -94,51 +88,22 @@ const Cinfo* SeqSynHandler::initCinfo()
&SeqSynHandler::setHistoryTime,
&SeqSynHandler::getHistoryTime
);
- static ValueFinfo< SeqSynHandler, double > baseScale(
- "baseScale",
- "Basal scaling factor for regular synaptic activation.",
- &SeqSynHandler::setBaseScale,
- &SeqSynHandler::getBaseScale
- );
- static ValueFinfo< SeqSynHandler, double > sequenceScale(
- "sequenceScale",
+ static ValueFinfo< SeqSynHandler, double > responseScale(
+ "responseScale",
"Scaling factor for sustained activation of synapse by seq",
- &SeqSynHandler::setSequenceScale,
- &SeqSynHandler::getSequenceScale
- );
- static ValueFinfo< SeqSynHandler, vector< unsigned int > > synapseOrder(
- "synapseOrder",
- "Mapping of synapse input order to spatial order on syn array."
- "Entries in this vector are indices which must remain smaller "
- "than numSynapses. The system will fix up if you mess up. "
- "It does not insist on unique mappings, but these are "
- "desirable as outcome is undefined for repeated entries.",
- &SeqSynHandler::setSynapseOrder,
- &SeqSynHandler::getSynapseOrder
- );
- static ValueFinfo< SeqSynHandler, int > synapseOrderOption(
- "synapseOrderOption",
- "How to do the synapse order remapping. This rule stays in "
- "place and guarantees safe mappings even if the number of "
- "synapses is altered. Options:\n"
- "-2: User ordering.\n"
- "-1: Sequential ordering, 0 to numSynapses-1.\n"
- "0: Random ordering using existing system seed.\n"
- ">0: Random ordering using seed specified by this number\n"
- "Default is -1, sequential ordering.",
- &SeqSynHandler::setSynapseOrderOption,
- &SeqSynHandler::getSynapseOrderOption
+ &SeqSynHandler::setResponseScale,
+ &SeqSynHandler::getResponseScale
);
static ReadOnlyValueFinfo< SeqSynHandler, double > seqActivation(
"seqActivation",
"Reports summed activation of synaptic channel by sequence",
&SeqSynHandler::getSeqActivation
);
- static ValueFinfo< SeqSynHandler, double > plasticityScale(
- "plasticityScale",
- "Scaling factor for doing plasticity by scaling each synapse by response vector",
- &SeqSynHandler::setPlasticityScale,
- &SeqSynHandler::getPlasticityScale
+ static ValueFinfo< SeqSynHandler, double > weightScale(
+ "weightScale",
+ "Scaling factor for weight of each synapse by response vector",
+ &SeqSynHandler::setWeightScale,
+ &SeqSynHandler::getWeightScale
);
static ValueFinfo< SeqSynHandler, double > sequencePower(
@@ -219,7 +184,8 @@ SeqSynHandler::SeqSynHandler()
seqActivation_( 0.0 ),
synapseOrderOption_( -1 ) // sequential ordering
{
- history_.resize( numHistory(), 0 );
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
+ history_.resize( numHistory, 0 );
}
SeqSynHandler::~SeqSynHandler()
@@ -247,10 +213,10 @@ void SeqSynHandler::vSetNumSynapses( const unsigned int v )
for ( unsigned int i = prevSize; i < v; ++i )
synapses_[i].setHandler( this );
- history_.resize( numHistory(), v );
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
+ history_.resize( numHistory, v );
latestSpikes_.resize( v, 0.0 );
weightScaleVec_.resize( v, 0.0 );
- refillSynapseOrder( v );
updateKernel();
}
@@ -270,65 +236,6 @@ Synapse* SeqSynHandler::vGetSynapse( unsigned int i )
}
//////////////////////////////////////////////////////////////////////
-
-// Checks for numbers bigger than the size. Replaces with
-// values within the range that have not yet been used.
-void SeqSynHandler::fixSynapseOrder()
-{
- unsigned int sz = synapseOrder_.size();
- vector< unsigned int > availableEntries( sz );
- iota( availableEntries.begin(), availableEntries.end(), 0 );
- for( unsigned int i = 0; i < sz; ++i ) {
- if ( synapseOrder_[i] < sz )
- availableEntries[ synapseOrder_[i] ] = sz;
- }
- vector< unsigned int > ae;
- for( unsigned int i = 0; i < sz; ++i )
- if ( availableEntries[i] < sz )
- ae.push_back( availableEntries[i] );
-
- auto jj = ae.begin();
- for( unsigned int i = 0; i < sz; ++i ) {
- if ( synapseOrder_[i] >= sz )
- synapseOrder_[i] = *jj++;
- }
-}
-
-// Beautiful snippet from Lukasz Wiklendt on StackOverflow. Returns order
-// of entries in a vector.
-template <typename T> vector<size_t> sort_indexes(const vector<T> &v) {
- // initialize original index locations
- vector<size_t> idx(v.size());
- iota(idx.begin(), idx.end(), 0);
- // sort indexes based on comparing values in v
- sort(idx.begin(), idx.end(),
- [&v](size_t i1, size_t i2) {return v[i1] < v[i2];});
- return idx;
-}
-
-void SeqSynHandler::refillSynapseOrder( unsigned int newSize )
-{
- if ( synapseOrderOption_ <= -2 ) { // User order
- synapseOrder_.resize( newSize, newSize );
- fixSynapseOrder();
- } else if ( synapseOrderOption_ == -1 ) { // Ordered
- synapseOrder_.resize( newSize );
- for ( unsigned int i = 0 ; i < newSize; ++i )
- synapseOrder_[i] = i;
- } else {
- synapseOrder_.resize( newSize );
- if ( synapseOrderOption_ > 0 ) { // Specify seed explicitly
- moose::mtseed( synapseOrderOption_ );
- }
- vector< double > x;
- for ( unsigned int i = 0; i < newSize; ++i )
- x.push_back( moose::mtrand() );
- auto idx = sort_indexes< double >( x );
- for ( unsigned int i = 0; i < newSize; ++i )
- synapseOrder_[i] = idx[i];
- }
-}
-
void SeqSynHandler::updateKernel()
{
if ( kernelEquation_ == "" || seqDt_ < 1e-9 || historyTime_ < 1e-9 )
@@ -342,9 +249,9 @@ void SeqSynHandler::updateKernel()
p.DefineConst(_T("e"), (mu::value_type)M_E);
p.SetExpr( kernelEquation_ );
kernel_.clear();
- int nh = numHistory();
- kernel_.resize( nh );
- for ( int i = 0; i < nh; ++i ) {
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
+ kernel_.resize( numHistory );
+ for ( int i = 0; i < numHistory; ++i ) {
kernel_[i].resize( kernelWidth_ );
t = i * seqDt_;
for ( unsigned int j = 0; j < kernelWidth_; ++j ) {
@@ -381,7 +288,8 @@ void SeqSynHandler::setSeqDt( double v )
{
seqDt_ = v;
updateKernel();
- history_.resize( numHistory(), vGetNumSynapses() );
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
+ history_.resize( numHistory, vGetNumSynapses() );
}
double SeqSynHandler::getSeqDt() const
@@ -392,7 +300,8 @@ double SeqSynHandler::getSeqDt() const
void SeqSynHandler::setHistoryTime( double v )
{
historyTime_ = v;
- history_.resize( numHistory(), vGetNumSynapses() );
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
+ history_.resize( numHistory, vGetNumSynapses() );
updateKernel();
}
@@ -401,24 +310,14 @@ double SeqSynHandler::getHistoryTime() const
return historyTime_;
}
-void SeqSynHandler::setBaseScale( double v )
+void SeqSynHandler::setResponseScale( double v )
{
- baseScale_ = v;
+ responseScale_ = v;
}
-double SeqSynHandler::getBaseScale() const
+double SeqSynHandler::getResponseScale() const
{
- return baseScale_;
-}
-
-void SeqSynHandler::setSequenceScale( double v )
-{
- sequenceScale_ = v;
-}
-
-double SeqSynHandler::getSequenceScale() const
-{
- return sequenceScale_;
+ return responseScale_;
}
double SeqSynHandler::getSeqActivation() const
@@ -426,14 +325,14 @@ double SeqSynHandler::getSeqActivation() const
return seqActivation_;
}
-double SeqSynHandler::getPlasticityScale() const
+double SeqSynHandler::getWeightScale() const
{
- return plasticityScale_;
+ return weightScale_;
}
-void SeqSynHandler::setPlasticityScale( double v )
+vector< double >SeqSynHandler::getWeightScaleVec() const
{
- plasticityScale_ = v;
+ return weightScaleVec_;
}
double SeqSynHandler::getSequencePower() const
@@ -448,14 +347,14 @@ void SeqSynHandler::setSequencePower( double v )
vector< double >SeqSynHandler::getWeightScaleVec() const
{
- return weightScaleVec_;
+ weightScale_ = v;
}
vector< double > SeqSynHandler::getKernel() const
{
- int nh = numHistory();
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
vector< double > ret;
- for ( int i = 0; i < nh; ++i ) {
+ for ( int i = 0; i < numHistory; ++i ) {
ret.insert( ret.end(), kernel_[i].begin(), kernel_[i].end() );
}
return ret;
@@ -463,40 +362,17 @@ vector< double > SeqSynHandler::getKernel() const
vector< double > SeqSynHandler::getHistory() const
{
- int nh = numHistory();
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
int numX = vGetNumSynapses();
- vector< double > ret( numX * nh, 0.0 );
+ vector< double > ret( numX * numHistory, 0.0 );
vector< double >::iterator k = ret.begin();
- for ( int i = 0; i < nh; ++i ) {
+ for ( int i = 0; i < numHistory; ++i ) {
for ( int j = 0; j < numX; ++j )
*k++ = history_.get( i, j );
}
return ret;
}
-void SeqSynHandler::setSynapseOrder( vector< unsigned int > v )
-{
- synapseOrder_ = v;
- fixSynapseOrder();
- synapseOrderOption_ = -2; // Set the flag to say it is User defined.
-}
-
-vector< unsigned int > SeqSynHandler::getSynapseOrder() const
-{
- return synapseOrder_;
-}
-
-void SeqSynHandler::setSynapseOrderOption( int v )
-{
- synapseOrderOption_ = v;
- refillSynapseOrder( synapseOrder_.size() );
-}
-
-int SeqSynHandler::getSynapseOrderOption() const
-{
- return synapseOrderOption_;
-}
-
/////////////////////////////////////////////////////////////////////
void SeqSynHandler::addSpike(unsigned int index, double time, double weight)
@@ -508,9 +384,7 @@ void SeqSynHandler::addSpike(unsigned int index, double time, double weight)
// slice. For now, to get it going for LIF neurons, this will do.
// Even in the general case we will probably have a very wide window
// for the latestSpikes slice.
- //
- // Here we reorder the entries in latestSpikes by the synapse order.
- latestSpikes_[ synapseOrder_[index] ] += weight;
+ latestSpikes_[index] += weight;
}
unsigned int SeqSynHandler::addSynapse()
@@ -531,10 +405,10 @@ void SeqSynHandler::dropSynapse( unsigned int msgLookup )
void SeqSynHandler::vProcess( const Eref& e, ProcPtr p )
{
// Here we look at the correlations and do something with them.
- int nh = numHistory();
+ int numHistory = static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
// Check if we need to do correlations at all.
- if ( nh > 0 && kernel_.size() > 0 ) {
+ if ( numHistory > 0 && kernel_.size() > 0 ) {
// Check if timestep rolls over a seqDt boundary
if ( static_cast< int >( p->currTime / seqDt_ ) >
static_cast< int >( (p->currTime - p->dt) / seqDt_ ) ) {
@@ -544,22 +418,22 @@ void SeqSynHandler::vProcess( const Eref& e, ProcPtr p )
// Build up the sum of correlations over time
vector< double > correlVec( vGetNumSynapses(), 0.0 );
- for ( int i = 0; i < nh; ++i )
+ for ( int i = 0; i < numHistory; ++i )
history_.correl( correlVec, kernel_[i], i );
- if ( sequenceScale_ > 0.0 ) { // Sum all responses, send to chan
+ if ( responseScale_ > 0.0 ) { // Sum all responses, send to chan
seqActivation_ = 0.0;
for ( vector< double >::iterator y = correlVec.begin();
y != correlVec.end(); ++y )
seqActivation_ += pow( *y, sequencePower_ );
// We'll use the seqActivation_ to send a special msg.
- seqActivation_ *= sequenceScale_;
+ seqActivation_ *= responseScale_;
}
- if ( plasticityScale_ > 0.0 ) { // Short term changes in individual wts
+ if ( weightScale_ > 0.0 ) { // Short term changes in individual wts
weightScaleVec_ = correlVec;
for ( vector< double >::iterator y=weightScaleVec_.begin();
y != weightScaleVec_.end(); ++y )
- *y *= plasticityScale_;
+ *y *= weightScale_;
}
}
}
@@ -568,15 +442,15 @@ void SeqSynHandler::vProcess( const Eref& e, ProcPtr p )
// We can't leave it to the base class vProcess, because we need
// to scale the weights individually in some cases.
double activation = seqActivation_; // Start with seq activation
- if ( plasticityScale_ > 0.0 ) {
+ if ( weightScale_ > 0.0 ) {
while( !events_.empty() && events_.top().time <= p->currTime ) {
- activation += events_.top().weight * baseScale_ *
+ activation += events_.top().weight *
weightScaleVec_[ events_.top().synIndex ] / p->dt;
events_.pop();
}
} else {
while( !events_.empty() && events_.top().time <= p->currTime ) {
- activation += baseScale_ * events_.top().weight / p->dt;
+ activation += events_.top().weight / p->dt;
events_.pop();
}
}
@@ -590,8 +464,3 @@ void SeqSynHandler::vReinit( const Eref& e, ProcPtr p )
while( !events_.empty() )
events_.pop();
}
-
-int SeqSynHandler::numHistory() const
-{
- return static_cast< int >( 1.0 + floor( historyTime_ * (1.0 - 1e-6 ) / seqDt_ ) );
-}
diff --git a/synapse/SeqSynHandler.h b/synapse/SeqSynHandler.h
index 7489da86..15e1472f 100644
--- a/synapse/SeqSynHandler.h
+++ b/synapse/SeqSynHandler.h
@@ -55,14 +55,8 @@ class SeqSynHandler: public SynHandlerBase
double getSeqDt() const;
void setHistoryTime( double v );
double getHistoryTime() const;
- void setBaseScale( double v );
- double getBaseScale() const;
- void setSequenceScale( double v );
- double getSequenceScale() const;
- void setSynapseOrder( vector< unsigned int> v );
- vector< unsigned int> getSynapseOrder() const;
- void setSynapseOrderOption( int v );
- int getSynapseOrderOption() const;
+ void setResponseScale( double v );
+ double getResponseScale() const;
double getSeqActivation() const; // summed activation of syn chan
void setPlasticityScale( double v );
double getPlasticityScale() const;
@@ -72,11 +66,6 @@ class SeqSynHandler: public SynHandlerBase
vector< double > getKernel() const;
vector< double > getHistory() const;
- ////////////////////////////////////////////////////////////////
- // Utility func
- int numHistory() const;
- void refillSynapseOrder( unsigned int newSize );
- void fixSynapseOrder();
////////////////////////////////////////////////////////////////
static const Cinfo* initCinfo();
private:
@@ -97,19 +86,13 @@ class SeqSynHandler: public SynHandlerBase
string kernelEquation_;
unsigned int kernelWidth_; // Width in terms of number of synapses
- /// Time to store history. KernelDt defines num of rows
+ // Time to store history. KernelDt defines num of rows
double historyTime_;
double seqDt_; // Time step for successive entries in kernel
- /// Scaling factor for baseline synaptic responses.
- double baseScale_;
- /// Scaling factor for sequence recognition responses.
- double sequenceScale_;
-
- /**
- * Scaling factor for short-term plastic weight changes in each
- * synapse arising from sequential input.
- */
- double plasticityScale_;
+ // Scaling factor for sustained activation of synapse from response
+ double responseScale_;
+ // Scaling factor for weight changes in each synapse from response
+ double weightScale_;
/**
* Exponent to use for the outcome of the sequential calculations.
@@ -133,23 +116,8 @@ class SeqSynHandler: public SynHandlerBase
vector< double > latestSpikes_;
///////////////////////////////////////////
- vector< vector< double > > kernel_; ///Kernel for seq selectivity
- RollingMatrix history_; /// Rows = time; cols = synInputs
- /**
- * Remaps synapse order to avoid correlations based on presynaptic
- * object Id order, or on connection building order. This
- * undesirable ordering occurs even when random synaptic
- * projections are used. User can alter as preferred. This is
- * simply a look up table so that the incoming synapse index is
- * remapped: index_on_Handler = synapseOrder_[original_syn_index]
- * This must only have numbers from zero to numSynapses, and should
- * normally have all the numbers.
- */
- vector< unsigned int > synapseOrder_;
-
- /// Options: -2: User. -1: ordered. 0: random by system seed.
- /// > 0: Random by seed specified by this number
- int synapseOrderOption_;
+ vector< vector< double > > kernel_; //Kernel for seq selectivity
+ RollingMatrix history_; // Rows = time; cols = synInputs
vector< Synapse > synapses_;
priority_queue< PreSynEvent, vector< PreSynEvent >, CompareSynEvent > events_;
diff --git a/synapse/testSynapse.cpp b/synapse/testSynapse.cpp
index b39b87bd..2edd4165 100644
--- a/synapse/testSynapse.cpp
+++ b/synapse/testSynapse.cpp
@@ -20,48 +20,6 @@
#include "../shell/Shell.h"
#include "../randnum/randnum.h"
-double doCorrel( RollingMatrix& rm, vector< vector< double >> & kernel )
-{
- int nr = kernel.size();
- vector< double > correlVec( nr, 0.0 );
- for ( int i = 0; i < nr; ++i )
- rm.correl( correlVec, kernel[i], i );
- double seqActivation = 0.0;
- for ( int i = 0; i < nr; ++i )
- seqActivation += correlVec[i];
- return seqActivation;
-}
-
-void testRollingMatrix2()
-{
- int nr = 5;
- RollingMatrix rm;
- rm.resize( nr, nr );
- vector< vector< double > > kernel( nr );
- for ( int i = 0; i < nr; ++i ) {
- kernel[i].resize( nr, 0.0 );
- rm.zeroOutRow( i );
- for ( int j = 0; j < nr; ++j ) {
- kernel[i][j] = 16 - (i-j)*(i-j); // symmetric, forward
- rm.sumIntoEntry( (i==j), i, j );
- }
- }
- double ret1 = doCorrel( rm, kernel );
-
- for ( int i = 0; i < nr; ++i ) {
- kernel[i].clear();
- kernel[i].resize( nr, 0.0 );
- rm.zeroOutRow( i );
- for ( int j = 0; j < nr; ++j ) {
- int k = nr-i-1;
- kernel[i][j] = 16 - (k-j)*(k-j); // symmetric, backwards
- rm.sumIntoEntry( (k==j), i, j );
- }
- }
- double ret2 = doCorrel( rm, kernel );
- assert( doubleEq( ret1, ret2 ) );
-}
-
void testRollingMatrix()
{
int nr = 5;
@@ -99,59 +57,44 @@ void testRollingMatrix()
for ( int i = 0; i < nr; ++i )
input[i] = i + 1;
- assert( doubleEq( rm.dotProduct( input, 0, 5 ), 0.0 ) );
- assert( doubleEq( rm.dotProduct( input, 1, 5 ), 1.0 ) );
- assert( doubleEq( rm.dotProduct( input, 2, 5 ), 4.0 ) );
- assert( doubleEq( rm.dotProduct( input, 3, 5 ), 9.0 ) );
- assert( doubleEq( rm.dotProduct( input, 4, 5 ), 16.0 ) );
- assert( doubleEq( rm.dotProduct( input, 4, 6 ), 12.0 ) );
- assert( doubleEq( rm.dotProduct( input, 4, 7 ), 8.0 ) );
- assert( doubleEq( rm.dotProduct( input, 4, 8 ), 4.0 ) );
- assert( doubleEq( rm.dotProduct( input, 4, 9 ), 0.0 ) );
-
- // Note that the input and the row are aligned at col=5, the
- // middle of the input vector.
+ assert( doubleEq( rm.dotProduct( input, 0, 0 ), 0.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 1, 0 ), 1.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 2, 0 ), 4.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 3, 0 ), 9.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 4, 0 ), 16.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 4, 1 ), 12.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 4, 2 ), 8.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 4, 3 ), 4.0 ) );
+ assert( doubleEq( rm.dotProduct( input, 4, 4 ), 0.0 ) );
+
rm.sumIntoRow( input, 0 ); // input == [1234500000]
vector< double > corr;
rm.correl( corr, input, 4 ); // rm[4] == [00040000]
- assert( doubleEq( corr[0], 0.0 ) );
- assert( doubleEq( corr[1], 0.0 ) );
- assert( doubleEq( corr[2], 0.0 ) );
- assert( doubleEq( corr[3], 0.0 ) );
- assert( doubleEq( corr[4], 20.0 ) );
- assert( doubleEq( corr[5], 16.0 ) );
- assert( doubleEq( corr[6], 12.0 ) );
- assert( doubleEq( corr[7], 8.0 ) );
- assert( doubleEq( corr[8], 4.0 ) );
- assert( doubleEq( corr[9], 0.0 ) );
+ assert( doubleEq( corr[0], 16.0 ) );
+ assert( doubleEq( corr[1], 12.0 ) );
+ assert( doubleEq( corr[2], 8.0 ) );
+ assert( doubleEq( corr[3], 4.0 ) );
+ assert( doubleEq( corr[4], 0.0 ) );
corr.assign( corr.size(), 0 );
rm.correl( corr, input, 0 ); // rm[0] == [1234500000]
- assert( doubleEq( corr[0], 0.0 ) );
- assert( doubleEq( corr[1], 5.0 ) );
- assert( doubleEq( corr[2], 14.0 ) );
- assert( doubleEq( corr[3], 26.0 ) );
- assert( doubleEq( corr[4], 40.0 ) );
- assert( doubleEq( corr[5], 55.0 ) );
- assert( doubleEq( corr[6], 40.0 ) );
- assert( doubleEq( corr[7], 26.0 ) );
- assert( doubleEq( corr[8], 14.0 ) );
- assert( doubleEq( corr[9], 5.0 ) );
+ assert( doubleEq( corr[0], 55.0 ) );
+ assert( doubleEq( corr[1], 40.0 ) );
+ assert( doubleEq( corr[2], 26.0 ) );
+ assert( doubleEq( corr[3], 14.0 ) );
+ assert( doubleEq( corr[4], 5.0 ) );
cout << "." << flush;
}
-// FIXME: This test is failing on travis.
void testSeqSynapse()
{
int numSyn = 10;
int kernelWidth = 5;
SeqSynHandler ssh;
ssh.vSetNumSynapses( numSyn );
-
// for ( int i = 0; i < numSyn; ++i )
// ssh.addSynapse();
-
assert( static_cast< int >( ssh.vGetNumSynapses() ) == numSyn );
ssh.setSeqDt( 1.0 );
ssh.setHistoryTime( 5.0 );
@@ -170,12 +113,11 @@ void testSeqSynapse()
cout << "." << flush;
- ssh.setBaseScale( 1.0 );
- ssh.setSequenceScale( 1.0 );
+ ssh.setResponseScale( 1.0 );
for ( int i = 0; i < numSyn; ++i ) {
ssh.addSpike( i, 0.0, 1.0 );
}
- ssh.setPlasticityScale( 1.0 );
+ ssh.setWeightScale( 1.0 );
ProcInfo p;
Eref sheller( Id().eref() );
@@ -187,13 +129,14 @@ void testSeqSynapse()
// Here we correlate the vector [1,1,1,1,1,1,1,1,1,1,1] with
// the kernel [4,1,-1,-1,-1]
// Other lines are zeros.
- assert( doubleEq( ssh.getSeqActivation(), 14.0 ) );
+ // Should really make the kernel mapping symmetrical.
+ assert( doubleEq( ssh.getSeqActivation(), 28.0 ) );
vector< double > wts = ssh.getWeightScaleVec();
- for ( int i = 2; i < numSyn-2; ++i )
+ for ( int i = 0; i < numSyn-4; ++i )
assert( doubleEq( wts[i], 2.0 ) );
- assert( doubleEq( wts[0], -3 ) ); // Edge effects.
- assert( doubleEq( wts[1], -2 ) ); // Edge effects.
- assert( doubleEq( wts[8], 3 ) ); // Edge effects.
+ assert( doubleEq( wts[6], 3 ) ); // Edge effects. Last -1 vanishes.
+ assert( doubleEq( wts[7], 4 ) ); // Edge effects.
+ assert( doubleEq( wts[8], 5 ) ); // Edge effects.
assert( doubleEq( wts[9], 4 ) ); // Edge effects.
cout << "." << flush;
@@ -207,7 +150,6 @@ void testSynapse()
{
#ifdef DO_UNIT_TESTS
testRollingMatrix();
- testRollingMatrix2();
testSeqSynapse();
#endif // DO_UNIT_TESTS
}
diff --git a/tests/python/test_difshells.py b/tests/python/test_difshells.py
index 367b953a..669f46a8 100644
--- a/tests/python/test_difshells.py
+++ b/tests/python/test_difshells.py
@@ -115,6 +115,7 @@ if __name__ == '__main__':
dend.initVm = Vm_0
dend.diameter = dend_diameter
dend.length = dend_length
+
pulse.delay[0] = 8.
pulse.width[0] = 500e-3
pulse.level[0] = inject
--
GitLab