diff --git a/.travis/travis_build_linux.sh b/.travis/travis_build_linux.sh
index a4499d303dc96fd07a21d527e37421d26ee048c7..3352c2f08c1e029257f95c0af3dc7c7aef95fad4 100755
--- a/.travis/travis_build_linux.sh
+++ b/.travis/travis_build_linux.sh
@@ -44,7 +44,7 @@ echo "Currently in `pwd`"
 (
     mkdir -p _GSL_BUILD && cd _GSL_BUILD
     cmake -DDEBUG=ON -DPYTHON_EXECUTABLE="$PYTHON2" ..
-    $MAKE && ctest --output-on-failure -j4
+    $MAKE && ctest --output-on-failure 
     sudo make install && cd  /tmp
     $PYTHON2 -c 'import moose;print(moose.__file__);print(moose.version())'
 )
@@ -53,7 +53,7 @@ echo "Currently in `pwd`"
     # Now with boost.
     mkdir -p _BOOST_BUILD && cd _BOOST_BUILD && \
         cmake -DWITH_BOOST_ODE=ON -DDEBUG=ON -DPYTHON_EXECUTABLE="$PYTHON2" ..
-    $MAKE && ctest --output-on-failure -j4
+    $MAKE && ctest --output-on-failure 
 )
 
 # This is only applicable on linux build.
@@ -63,13 +63,13 @@ if type $PYTHON3 > /dev/null; then
     sudo apt-get install -qq python3-networkx || echo "Error with apt"
     (
         mkdir -p _GSL_BUILD2 && cd _GSL_BUILD2 && \
-            cmake -DDEBUG=ON -DPYTHON_EXECUTABLE="$PYTHON3" ..
-        $MAKE && ctest --output-on-failure -j4
+            cmake -DPYTHON_EXECUTABLE="$PYTHON3" ..
+        $MAKE && ctest --output-on-failure 
     )
     (
         mkdir -p _BOOST_BUILD2 && cd _BOOST_BUILD2 && \
-            cmake -DWITH_BOOST_ODE=ON -DDEBUG=ON -DPYTHON_EXECUTABLE="$PYTHON3" ..
-        $MAKE && ctest --output-on-failure -j4
+            cmake -DWITH_BOOST_ODE=ON -DPYTHON_EXECUTABLE="$PYTHON3" ..
+        $MAKE && ctest --output-on-failure 
     )
     echo "All done"
 else
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 59977a0fa04ab1929aba24b7b7d8b56fbeb9f298..3bfb7fc880fb3247884fde732a3022f8e08bae08 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -80,11 +80,10 @@ option(DEBUG                "Build with debug support" OFF)
 option(GPROF                "Build for profiling using gprof" OFF)
 option(ENABLE_UNIT_TESTS    "Enable unit tests (DEBUG should also be ON)" OFF)
 option(WITH_MPI             "Enable Openmpi support" OFF)
+option(WITH_BOOST           "Enable boost. Prefer boost over stl" OFF)
 option(WITH_BOOST_ODE       "Use boost library ode2 library instead of GSL" OFF)
 option(WITH_GSL             "Use gsl-library. Alternative is WITH_BOOST" ON)
-option(PARALLELIZED_SOLVERS "Use parallel version of GSOLVE. (alpha)" OFF )
 option(PARALLELIZED_CLOCK   "High level parallelization of moose::Clock (alpha)" OFF )
-
 option(USE_PRIVATE_RNG      "Stochastic Objects use their private RNG" ON)
 
 
@@ -116,9 +115,7 @@ if(GPROF AND "${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
     set(CMAKE_EXE_LINKER_FLAGS_DEBUG "-pg")
 endif()
 
-if(PARALLELIZED_SOLVERS)
-    find_package(Threads)
-endif()
+find_package(Threads)
 
 
 ################################### TARGETS ####################################
@@ -131,6 +128,10 @@ add_executable(moose.bin basecode/main.cpp)
 # default include paths.
 include_directories( ${CMAKE_CURRENT_SOURCE_DIR} )
 
+if(WITH_BOOST)
+    set(WITH_BOOST_ODE ON)
+endif(WITH_BOOST)
+
 # If using BOOST ODE2 library to solve ODE system, then don't use GSL.
 if(WITH_BOOST_ODE)
     set(WITH_GSL OFF)
@@ -269,9 +270,7 @@ if(WITH_BOOST_ODE)
     list(APPEND SYSTEM_SHARED_LIBS ${Boost_LIBRARIES})
 endif(WITH_BOOST_ODE)
 
-if(PARALLELIZED_SOLVERS)
-    list(APPEND SYSTEM_SHARED_LIBS ${CMAKE_THREAD_LIBS_INIT})
-endif()
+list(APPEND SYSTEM_SHARED_LIBS ${CMAKE_THREAD_LIBS_INIT})
 
 # These libraries could be static of dynamic. We need to discrimate between
 # these two types because of --whole-archive option. See
diff --git a/CheckCXXCompiler.cmake b/CheckCXXCompiler.cmake
index f3fe24d921de0a6220fa427c91c02e9a37ac26dd..c6173acb709e6a64467a716f8c3039b838b9b129 100644
--- a/CheckCXXCompiler.cmake
+++ b/CheckCXXCompiler.cmake
@@ -11,9 +11,11 @@ add_definitions(-Wall
     #-Wno-return-type-c-linkage
     -Wno-unused-variable
     -Wno-unused-function
-    -Wno-unused-local-typedefs
     #-Wno-unused-private-field
     )
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    add_definitions( -Wno-unused-local-typedefs )
+endif()
 
 
 add_definitions(-fPIC)
@@ -34,9 +36,9 @@ if(COMPILER_SUPPORTS_CXX11)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     add_definitions( -DENABLE_CPP11 )
     if(APPLE)
-			  #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++" )
-				message(STATUS "NOTE: Making clang to inline more aggresively" )
-				add_definitions( -mllvm -inline-threshold=1000 )
+        #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++" )
+        message(STATUS "NOTE: Making clang to inline more aggresively" )
+        add_definitions( -mllvm -inline-threshold=1000 )
     endif(APPLE)
 else(COMPILER_SUPPORTS_CXX11)
     add_definitions( -DBOOST_NO_CXX11_SCOPED_ENUMS -DBOOST_NO_SCOPED_ENUMS )
diff --git a/basecode/FuncOrder.h b/basecode/FuncOrder.h
index 088b2f1fcd1dbcf676483cf924590362cf317728..03c4bfc17dc83579cb4e433b1d4ae09e58b2780c 100644
--- a/basecode/FuncOrder.h
+++ b/basecode/FuncOrder.h
@@ -13,28 +13,28 @@
 
 class FuncOrder
 {
-	public:
-			FuncOrder()
-				: func_( 0 ), index_( 0 )
-			{;}
+    public:
+            FuncOrder()
+                : func_( 0 ), index_( 0 )
+            {;}
 
-			const OpFunc* func() const {
-					return func_;
-			}
-			unsigned int index() const {
-					return index_;
-			}
+            const OpFunc* func() const {
+                    return func_;
+            }
+            unsigned int index() const {
+                    return index_;
+            }
 
-			void set( const OpFunc* func, unsigned int index ) {
-				func_ = func;
-			   	index_ = index;
-			}
+            void set( const OpFunc* func, unsigned int index ) {
+                func_ = func;
+                   index_ = index;
+            }
 
-			bool operator<( const FuncOrder& other ) const
-			{
-				return func_ < other.func_;
-			}
-	private:
-		const OpFunc* func_;
-		unsigned int index_;
+            bool operator<( const FuncOrder& other ) const
+            {
+                return func_ < other.func_;
+            }
+    private:
+        const OpFunc* func_;
+        unsigned int index_;
 };
diff --git a/basecode/global.cpp b/basecode/global.cpp
index 90f82b6ba10d09363c762824c22445af309a3bb1..fadf41ef88f76f8586120c6b5a79675bc128f16d 100644
--- a/basecode/global.cpp
+++ b/basecode/global.cpp
@@ -44,6 +44,11 @@ namespace moose {
 
     unsigned long __rng_seed__ = 0;
 
+    map<string, valarray<double>> solverProfMap = { 
+        { "Ksolve", {0.0, 0} }, 
+        { "HSolve", {0.0, 0} }
+    };
+
     moose::RNG<double> rng;
 
     /* Check if path is OK */
@@ -212,4 +217,16 @@ namespace moose {
     {
         __rng_seed__ = seed;
     }
+
+    void addSolverProf( const string& name, double time, size_t steps)
+    {
+        solverProfMap[ name ] = solverProfMap[name] + valarray<double>({ time, (double)steps });
+    }
+
+    void printSolverProfMap( )
+    {
+        for( auto &v : solverProfMap )
+            cout <<  '\t' << v.first << ": " << v.second[0] << " sec (" << v.second[1] << ")" << endl;
+    }
+
 }
diff --git a/basecode/global.h b/basecode/global.h
index 1735595d9a203fdcddb98f510f11ef107eaa8385..893c55762c7fe4f1bb51f2496c4346478a1a8de0 100644
--- a/basecode/global.h
+++ b/basecode/global.h
@@ -15,6 +15,7 @@
 #include <ctime>
 #include <map>
 #include <sstream>
+#include <valarray>
 
 #include "../randnum/RNG.h"                        /* Use inbuilt rng */
 #include "../utility/print_function.hpp"
@@ -57,6 +58,8 @@ namespace moose
 
     extern moose::RNG<double> rng;
 
+    extern map<string, valarray<double>> solverProfMap;
+
     /**
      * @brief A global seed for all RNGs in moose. When moose.seed( x ) is called,
      * this variable is set. Other's RNGs (except muparser) uses this seed to
@@ -194,6 +197,18 @@ namespace moose
      */
     /* ----------------------------------------------------------------------------*/
     void setGlobalSeed( int seed );
+
+    /* --------------------------------------------------------------------------*/
+    /**
+     * @Synopsis  Add solver performance into the global map.
+     *
+     * @Param name Name of the solver.
+     * @Param time Time taken by the solver.
+     * @Param steps Steps.
+     */
+    /* ----------------------------------------------------------------------------*/
+    void addSolverProf( const string& name, double time, size_t steps = 1);
+    void printSolverProfMap( );
 }
 
 #endif   /* ----- #ifndef __MOOSE_GLOBAL_INC_  ----- */
diff --git a/biophysics/ReadSwc.cpp b/biophysics/ReadSwc.cpp
index fe03adb14ee71fa13a8a3468a83e41c34c48bf57..22cc98c87e26dafbc94de8a2789e6a8fea43516f 100644
--- a/biophysics/ReadSwc.cpp
+++ b/biophysics/ReadSwc.cpp
@@ -16,6 +16,7 @@
 #include "Compartment.h"
 #include "SymCompartment.h"
 #include <fstream>
+#include <iomanip>
 
 // Minimum allowed radius of segment, in microns
 // Believe it or not, some otherwise reasonable files do have smaller radii
@@ -23,260 +24,290 @@ static const double MinRadius = 0.04;
 
 ReadSwc::ReadSwc( const string& fname )
 {
-	ifstream fin( fname.c_str() );
-	if ( !fin ) {
-		cerr << "ReadSwc:: could not open file " << fname << endl;
-		return;
-	}
+    ifstream fin( fname.c_str() );
+    if ( !fin )
+    {
+        cerr << "ReadSwc:: could not open file " << fname << endl;
+        return;
+    }
 
-	string temp;
-	int badSegs = 0;
-	while( getline( fin, temp ) ) {
-		if ( temp.length() == 0 )
-			continue;
-		string::size_type pos = temp.find_first_not_of( "\t " );
-		if ( pos == string::npos )
-			continue;
-		if ( temp[pos] == '#' )
-			continue;
+    string temp;
+    int badSegs = 0;
+    while( getline( fin, temp ) )
+    {
+        if ( temp.length() == 0 )
+            continue;
+        string::size_type pos = temp.find_first_not_of( "\t " );
+        if ( pos == string::npos )
+            continue;
+        if ( temp[pos] == '#' )
+            continue;
 
-		SwcSegment t( temp );
-		if ( t.OK() )
-			segs_.push_back( SwcSegment( temp ) );
-		else
-			badSegs++;
-	}
-	bool valid = validate();
-	if ( valid ) {
-		assignKids();
-		cleanZeroLength();
-		parseBranches();
-	}
-	cout << "ReadSwc: " << fname << "	: NumSegs = " << segs_.size() <<
-			", bad = " << badSegs <<
-			", Validated = " << valid <<
-			", numBranches = " << branches_.size() <<
-			endl;
-	diagnostics();
+        SwcSegment t( temp );
+        if ( t.OK() )
+            segs_.push_back( SwcSegment( temp ) );
+        else
+            badSegs++;
+    }
+    bool valid = validate();
+    if ( valid )
+    {
+        assignKids();
+        cleanZeroLength();
+        parseBranches();
+    }
+    cout << "ReadSwc: " << fname << "    : NumSegs = " << segs_.size() <<
+         ", bad = " << badSegs <<
+         ", Validated = " << valid <<
+         ", numBranches = " << branches_.size() <<
+         endl;
+    diagnostics();
 }
 
 bool ReadSwc::validate() const
 {
-	int numStart = 0;
-	int numOrphans = 0;
-	int badIndex = 0;
-	int badRadius = 0;
-	for ( unsigned int i = 0; i < segs_.size(); ++i ) {
-		const SwcSegment& s = segs_[i];
-		if ( s.myIndex() != i + 1 )
-			badIndex++;
-		if ( s.parent() == ~0U ) {
-			numStart++;
-		} else {
-			if ( s.parent() > i ) {
-				numOrphans++;
-			}
-		}
-		if ( s.radius() < MinRadius ) {
-			badRadius++;
-		}
-	}
-	bool valid = ( numStart == 1 && numOrphans == 0 && badRadius == 0 );
-	if ( !valid ) {
-		cout << "ReadSwc::validate() failed: \nNumSegs = " <<
-				segs_.size() <<
-				", numStart = " << numStart <<
-				", orphans = " << numOrphans <<
-				", badIndex = " << badIndex <<
-				", badRadius = " << badRadius <<
-				", numBranches = " << branches_.size() <<
-				endl;
-	}
-	return valid;
+    int numStart = 0;
+    int numOrphans = 0;
+    int badIndex = 0;
+    int badRadius = 0;
+    for ( unsigned int i = 0; i < segs_.size(); ++i )
+    {
+        const SwcSegment& s = segs_[i];
+        if ( s.myIndex() != i + 1 )
+            badIndex++;
+        if ( s.parent() == ~0U )
+        {
+            numStart++;
+        }
+        else
+        {
+            if ( s.parent() > i )
+            {
+                numOrphans++;
+            }
+        }
+        if ( s.radius() < MinRadius )
+        {
+            badRadius++;
+        }
+    }
+    bool valid = ( numStart == 1 && numOrphans == 0 && badRadius == 0 );
+    if ( !valid )
+    {
+        cout << "ReadSwc::validate() failed: \nNumSegs = " <<
+             segs_.size() <<
+             ", numStart = " << numStart <<
+             ", orphans = " << numOrphans <<
+             ", badIndex = " << badIndex <<
+             ", badRadius = " << badRadius <<
+             ", numBranches = " << branches_.size() <<
+             endl;
+    }
+    return valid;
 }
 
 void ReadSwc::assignKids()
 {
-	for ( unsigned int i = 0; i < segs_.size(); ++i ) {
-		const SwcSegment& s = segs_[i];
-		assert ( s.parent() != s.myIndex() );
-		if ( s.parent() != ~0U ) {
-			segs_[s.parent() - 1].addChild( i + 1 );
-		}
-	}
-	for ( unsigned int i = 0; i < segs_.size(); ++i ) {
-		segs_[i].figureOutType();
-	}
+    for ( unsigned int i = 0; i < segs_.size(); ++i )
+    {
+        const SwcSegment& s = segs_[i];
+        assert ( s.parent() != s.myIndex() );
+        if ( s.parent() != ~0U )
+        {
+            segs_[s.parent() - 1].addChild( i + 1 );
+        }
+    }
+    for ( unsigned int i = 0; i < segs_.size(); ++i )
+    {
+        segs_[i].figureOutType();
+    }
 }
 
 void ReadSwc::cleanZeroLength()
 {
-	static double EPSILON = 1e-2; // Assume units in microns.
-	for ( unsigned int i = 1; i < segs_.size(); ++i ) {
-		SwcSegment& s = segs_[i];
-		SwcSegment& pa = segs_[ s.parent() - 1 ];
-		if ( s.distance( pa ) < EPSILON ) {
-			// Remove the zero length child from pa.kids_
-			vector< int > temp;
-			for ( unsigned int j = 0; j < pa.kids().size(); ++j ) {
-				if ( static_cast< unsigned int >( pa.kids()[j] ) != s.myIndex() )
-					temp.push_back( pa.kids()[j] );
-			}
-			// Go through all kids of s and reparent them.
-			for ( unsigned int j = 0; j < s.kids().size(); ++j ) {
-				SwcSegment& kid = segs_[ s.kids()[j] - 1 ];
-				kid.setParent( pa.myIndex() );
-				temp.push_back( kid.myIndex() );
-			}
-			pa.replaceKids( temp );
-			s.setBad();
-			cout << "ReadSwc:: Cleaned zero length " << s.myIndex() << endl;
-		}
-	}
+    static double EPSILON = 1e-2; // Assume units in microns.
+    for ( unsigned int i = 1; i < segs_.size(); ++i )
+    {
+        SwcSegment& s = segs_[i];
+        SwcSegment& pa = segs_[ s.parent() - 1 ];
+        if ( s.distance( pa ) < EPSILON )
+        {
+            // Remove the zero length child from pa.kids_
+            vector< int > temp;
+            for ( unsigned int j = 0; j < pa.kids().size(); ++j )
+            {
+                if ( static_cast< unsigned int >( pa.kids()[j] ) != s.myIndex() )
+                    temp.push_back( pa.kids()[j] );
+            }
+            // Go through all kids of s and reparent them.
+            for ( unsigned int j = 0; j < s.kids().size(); ++j )
+            {
+                SwcSegment& kid = segs_[ s.kids()[j] - 1 ];
+                kid.setParent( pa.myIndex() );
+                temp.push_back( kid.myIndex() );
+            }
+            pa.replaceKids( temp );
+            s.setBad();
+            cout << "ReadSwc:: Cleaned zero length " << s.myIndex() << endl;
+        }
+    }
 }
 
 void ReadSwc::traverseBranch( const SwcSegment& s,
-		double& len, double& L, vector< int >& cable ) const
+                              double& len, double& L, vector< int >& cable ) const
 {
-	const SwcSegment* prev = &s;
-	cable.resize( 1, s.myIndex() ); // Always include the starting seg.
-	// Note that the cable is filled up with entries in reverse order.
+    const SwcSegment* prev = &s;
+    cable.resize( 1, s.myIndex() ); // Always include the starting seg.
+    // Note that the cable is filled up with entries in reverse order.
 
-	if ( s.parent() == ~0U ) {
-		len = s.radius();
-		L = sqrt( len );
-		return ;
-	}
+    if ( s.parent() == ~0U )
+    {
+        len = s.radius();
+        L = sqrt( len );
+        return ;
+    }
 
-	do {
-		// Beware the indexing!
-		const SwcSegment& pa = segs_[prev->parent() - 1];
-		len += pa.distance( *prev );
-		L += pa.L( );
-		cable.push_back( pa.myIndex() );
-		prev = &pa;
-	} while ( (prev->parent() != ~0U) && (prev->kids().size() == 1) );
-	cable.pop_back(); // Get rid of the last entry, it is on the parent.
+    do
+    {
+        // Beware the indexing!
+        const SwcSegment& pa = segs_[prev->parent() - 1];
+        len += pa.distance( *prev );
+        L += pa.L( );
+        cable.push_back( pa.myIndex() );
+        prev = &pa;
+    }
+    while ( (prev->parent() != ~0U) && (prev->kids().size() == 1) );
+    cable.pop_back(); // Get rid of the last entry, it is on the parent.
 }
 
 void ReadSwc::parseBranches()
 {
-	// Fill vector of all branches.
-	for ( unsigned int i = 0; i < segs_.size(); ++i ) {
-		const SwcSegment& s = segs_[i];
-		if ( s.OK() && s.kids().size() != 1 ) { // Either use a fork or an end.
-			vector< int > cable;
-			// int branchIndex = branches_.
-			// branches_.push_back( i + 1 );
-			double len = 0;
-			double L = 0;
-			traverseBranch( s, len, L, cable );
-			// branchGeomLength_.push_back( len );
-			// branchElectroLength_.push_back( L );
-			SwcBranch br( branches_.size(), s, len, L, cable );
-			branches_.push_back( br );
-		}
-	}
-	// Assign the parent of each branch. This is known because the
-	// parent of the first segment in the branch is the last segment
-	// in the parent branch. I construct a reverse lookup table to find
-	// the branch # from its last segment number.
-	vector< int > reverseSeg ( segs_.size() + 1, 0 );
-	for ( unsigned int i = 0; i < branches_.size(); ++i )
-		reverseSeg[ branches_[i].segs_.back() ] = i;
-	for ( unsigned int i = 0; i < branches_.size(); ++i ) {
-		int parentSeg = segs_[ branches_[i].segs_[0] - 1 ].parent();
-		assert( parentSeg != 0 ); // Note that segment indices start from 1
-		branches_[i].setParent( reverseSeg[ parentSeg ] );
-	}
+    // Fill vector of all branches.
+    for ( unsigned int i = 0; i < segs_.size(); ++i )
+    {
+        const SwcSegment& s = segs_[i];
+        if ( s.OK() && s.kids().size() != 1 )   // Either use a fork or an end.
+        {
+            vector< int > cable;
+            // int branchIndex = branches_.
+            // branches_.push_back( i + 1 );
+            double len = 0;
+            double L = 0;
+            traverseBranch( s, len, L, cable );
+            // branchGeomLength_.push_back( len );
+            // branchElectroLength_.push_back( L );
+            SwcBranch br( branches_.size(), s, len, L, cable );
+            branches_.push_back( br );
+        }
+    }
+    // Assign the parent of each branch. This is known because the
+    // parent of the first segment in the branch is the last segment
+    // in the parent branch. I construct a reverse lookup table to find
+    // the branch # from its last segment number.
+    vector< int > reverseSeg ( segs_.size() + 1, 0 );
+    for ( unsigned int i = 0; i < branches_.size(); ++i )
+        reverseSeg[ branches_[i].segs_.back() ] = i;
+    for ( unsigned int i = 0; i < branches_.size(); ++i )
+    {
+        int parentSeg = segs_[ branches_[i].segs_[0] - 1 ].parent();
+        assert( parentSeg != 0 ); // Note that segment indices start from 1
+        branches_[i].setParent( reverseSeg[ parentSeg ] );
+    }
 }
 
 void ReadSwc::diagnostics() const
 {
-	vector< int > diag( 14 );
-	for ( unsigned int i = 0; i < segs_.size(); ++i ) {
-		const SwcSegment& s = segs_[i];
-		if ( s.type() < 14 )
-			diag[s.type()]++;
-	}
-	for ( int i = 0; i < 14; ++i )
-		cout << "ReadSwc::diagnostics: " << SwcSegment::typeName[i] << " :	" << diag[i] << endl;
+    vector< int > diag( 14 );
+    for ( unsigned int i = 0; i < segs_.size(); ++i )
+    {
+        const SwcSegment& s = segs_[i];
+        if ( s.type() < 14 )
+            diag[s.type()]++;
+    }
+
+    for ( int i = 0; i < 14; ++i )
+        cout << "ReadSwc::diagnostics: " << setw(12) << SwcSegment::typeName[i] 
+            << ": " << setw(5) << diag[i] << endl;
 
-	/*
-	for ( unsigned int i = 0; i < branches_.size(); ++i )
-		branches_[i].printDiagnostics();
-		*/
 }
 
 static Id makeCompt( Id parent,
-		const SwcSegment& seg, const SwcSegment& pa,
-		double RM, double RA, double CM,
-		unsigned int i, unsigned int j	)
+                     const SwcSegment& seg, const SwcSegment& pa,
+                     double RM, double RA, double CM,
+                     unsigned int i, unsigned int j    )
 {
-	Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
-	double len = seg.radius() * 2.0;
-	string name = "soma";
-	Id compt;
-	double x0, y0, z0;
-	if ( seg.parent() != ~0U ) {
-		len = seg.distance( pa );
-		stringstream ss;
-		ss << SwcSegment::typeName[ seg.type() ] << "_" << i << "_" << j;
-		name = ss.str();
-		x0 = pa.vec().a0();
-		y0 = pa.vec().a1();
-		z0 = pa.vec().a2();
-	} else {
-		x0 = seg.vec().a0() - len;
-		y0 = seg.vec().a1();
-		z0 = seg.vec().a2();
-	}
-	assert( len > 0.0 );
-	compt = shell->doCreate( "Compartment", parent, name, 1 );
-	Eref er = compt.eref();
-	moose::CompartmentBase *cptr = reinterpret_cast< moose::CompartmentBase* >(
-					compt.eref().data() );
-	double xa = seg.radius() * seg.radius() * PI * 1e-12;
-	len *= 1e-6;
-	double dia = seg.radius() * 2.0e-6;
-	cptr->setRm( er, RM / ( len * dia * PI ) );
-	cptr->setRa( er, RA * len / xa );
-	cptr->setCm( er, CM * ( len * dia * PI ) );
-	cptr->setDiameter( dia );
-	cptr->setLength( len );
-	cptr->setX0( x0 * 1e-6 );
-	cptr->setY0( y0 * 1e-6 );
-	cptr->setZ0( z0 * 1e-6 );
-	cptr->setX( seg.vec().a0() * 1e-6 );
-	cptr->setY( seg.vec().a1() * 1e-6 );
-	cptr->setZ( seg.vec().a2() * 1e-6 );
-	return compt;
+    Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
+    double len = seg.radius() * 2.0;
+    string name = "soma";
+    Id compt;
+    double x0, y0, z0;
+    if ( seg.parent() != ~0U )
+    {
+        len = seg.distance( pa );
+        stringstream ss;
+        ss << SwcSegment::typeName[ seg.type() ] << "_" << i << "_" << j;
+        name = ss.str();
+        x0 = pa.vec().a0();
+        y0 = pa.vec().a1();
+        z0 = pa.vec().a2();
+    }
+    else
+    {
+        x0 = seg.vec().a0() - len;
+        y0 = seg.vec().a1();
+        z0 = seg.vec().a2();
+    }
+    assert( len > 0.0 );
+    compt = shell->doCreate( "Compartment", parent, name, 1 );
+    Eref er = compt.eref();
+    moose::CompartmentBase *cptr = reinterpret_cast< moose::CompartmentBase* >(
+                                       compt.eref().data() );
+    double xa = seg.radius() * seg.radius() * PI * 1e-12;
+    len *= 1e-6;
+    double dia = seg.radius() * 2.0e-6;
+    cptr->setRm( er, RM / ( len * dia * PI ) );
+    cptr->setRa( er, RA * len / xa );
+    cptr->setCm( er, CM * ( len * dia * PI ) );
+    cptr->setDiameter( dia );
+    cptr->setLength( len );
+    cptr->setX0( x0 * 1e-6 );
+    cptr->setY0( y0 * 1e-6 );
+    cptr->setZ0( z0 * 1e-6 );
+    cptr->setX( seg.vec().a0() * 1e-6 );
+    cptr->setY( seg.vec().a1() * 1e-6 );
+    cptr->setZ( seg.vec().a2() * 1e-6 );
+    return compt;
 }
 
 bool ReadSwc::build( Id parent,
-				double lambda, double RM, double RA, double CM )
+                     double lambda, double RM, double RA, double CM )
 {
-	Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
-	vector< Id > compts( segs_.size() );
-	for ( unsigned int i = 0; i < branches_.size(); ++i ) {
-		SwcBranch& br = branches_[i];
-		for ( unsigned int j = 0; j < br.segs_.size(); ++j ) {
-			Id compt;
-			SwcSegment& seg = segs_[ br.segs_[j] -1 ];
-			unsigned int paIndex = seg.parent();
-			if ( paIndex == ~0U ) { // soma
-				compt = makeCompt( parent, seg, seg, RM, RA, CM, i, j );
-			} else {
-				SwcSegment& pa = segs_[ paIndex - 1 ];
-				compt = makeCompt( parent, seg, pa, RM, RA, CM, i, j );
-				assert( compt != Id() );
-				assert( compts[ paIndex -1 ] != Id() );
-				shell->doAddMsg( "Single",
-					compts[paIndex-1], "axial", compt, "raxial" );
-			}
-			assert( compt != Id() );
-			compts[ seg.myIndex() -1 ] = compt;
-		}
-	}
-	return true;
+    Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
+    vector< Id > compts( segs_.size() );
+    for ( unsigned int i = 0; i < branches_.size(); ++i )
+    {
+        SwcBranch& br = branches_[i];
+        for ( unsigned int j = 0; j < br.segs_.size(); ++j )
+        {
+            Id compt;
+            SwcSegment& seg = segs_[ br.segs_[j] -1 ];
+            unsigned int paIndex = seg.parent();
+            if ( paIndex == ~0U )   // soma
+            {
+                compt = makeCompt( parent, seg, seg, RM, RA, CM, i, j );
+            }
+            else
+            {
+                SwcSegment& pa = segs_[ paIndex - 1 ];
+                compt = makeCompt( parent, seg, pa, RM, RA, CM, i, j );
+                assert( compt != Id() );
+                assert( compts[ paIndex -1 ] != Id() );
+                shell->doAddMsg( "Single",
+                                 compts[paIndex-1], "axial", compt, "raxial" );
+            }
+            assert( compt != Id() );
+            compts[ seg.myIndex() -1 ] = compt;
+        }
+    }
+    return true;
 }
diff --git a/builtins/Function.cpp b/builtins/Function.cpp
index ea0c8ae872cc043db64dd0abe7c9e905559316e8..8c82c64b0b8adca169b6d956971e7d12a0d683fe 100644
--- a/builtins/Function.cpp
+++ b/builtins/Function.cpp
@@ -345,18 +345,6 @@ Function::Function(): _t(0.0), _valid(false), _numVar(0), _lastValue(0.0),
     _valid = true;
 }
 
-#if 0
-void Function::extendMuParser( void )
-{
-    // Adding pi and e, the defaults are `_pi` and `_e`
-    _parser.DefineConst(_T("pi"), (mu::value_type)M_PI);
-    _parser.DefineConst(_T("e"), (mu::value_type)M_E);
-    // Add support
-    _parser.DefineVar( _T("t"),  &this->_t );
-    _parser.DefineOprt( _T("%"), &Function::muCallbackFMod, 7, mu::EOprtAssociativity::oaRIGHT, 0);
-}
-#endif
-
 Function::Function(const Function& rhs): _numVar(rhs._numVar),
     _lastValue(rhs._lastValue),
     _value(rhs._value), _rate(rhs._rate),
@@ -484,8 +472,10 @@ double * _functionAddVar(const char *name, void *data)
     Function* function = reinterpret_cast< Function * >(data);
     double * ret = NULL;
     string strname(name);
+
     // Names starting with x are variables, everything else is constant.
-    if (strname[0] == 'x'){
+    if (strname[0] == 'x')
+    {
         int index = atoi(strname.substr(1).c_str());
         if ((unsigned)index >= function->_varbuf.size()){
             function->_varbuf.resize(index+1, 0);
@@ -497,7 +487,9 @@ double * _functionAddVar(const char *name, void *data)
             function->_numVar = function->_varbuf.size();
         }
         ret = &(function->_varbuf[index]->value);
-    } else if (strname[0] == 'y'){
+    } 
+    else if (strname[0] == 'y')
+    {
         int index = atoi(strname.substr(1).c_str());
         if ((unsigned)index >= function->_pullbuf.size()){
             function->_pullbuf.resize(index+1, 0 );
@@ -508,9 +500,13 @@ double * _functionAddVar(const char *name, void *data)
             }
         }
         ret = function->_pullbuf[index];
-    } else if (strname == "t"){
+    }
+    else if (strname == "t")
+    {
         ret = &function->_t;
-    } else {
+    }
+    else 
+    {
         cerr << "Got an undefined symbol: " << name << endl
              << "Variables must be named xi, yi, where i is integer index."
 	     << " You must define the constants beforehand using LookupField c: c[name]"
@@ -538,24 +534,12 @@ double * _functionAddVar(const char *name, void *data)
  */
 unsigned int Function::addVar()
 {
-//     unsigned int newVarIndex = _numVar;
-//     ++_numVar;
-//     stringstream name;
-//     name << "x" << newVarIndex;
-//     _functionAddVar(name.str().c_str(), this);
-    //     return newVarIndex;
     return 0;
 }
 
-// void Function::dropVar(unsigned int msgLookup)
-// {
-//     // Don't know what this can possibly mean in the context of
-//     // evaluating a set expression.
-// }
-
 void Function::setExpr(const Eref& eref, string expr)
 {
-	this->innerSetExpr( eref, expr ); // Refer to the virtual function here.
+    this->innerSetExpr( eref, expr ); // Refer to the virtual function here.
 }
 
 // Virtual function, this does the work.
@@ -687,11 +671,8 @@ double Function::getDerivative() const
 void Function::setNumVar(const unsigned int num)
 {
     _clearBuffer();
-    for (unsigned int ii = 0; ii < num; ++ii){
-        stringstream name;
-        name << "x" << ii;
-        _functionAddVar(name.str().c_str(), this);
-    }
+    for (unsigned int ii = 0; ii < num; ++ii)
+        _functionAddVar( ("x"+std::to_string(ii)).c_str(), this);
 }
 
 unsigned int Function::getNumVar() const
diff --git a/builtins/Function.h b/builtins/Function.h
index 83f2b90381112ba44fc84603ba8da9af5baf69eb..8f50957bf7dcb335d96daac26364d246775a36ee 100644
--- a/builtins/Function.h
+++ b/builtins/Function.h
@@ -148,16 +148,22 @@ protected:
     unsigned int _mode;
     bool _useTrigger;
     bool _doEvalAtReinit;
-     // this stores variables received via incoming messages, identifiers of the form x{i} are included in this
+
+    // this stores variables received via incoming messages, identifiers of 
+    // the form x{i} are included in this
     vector<Variable *> _varbuf;
-    // this stores variable values pulled by sending request. identifiers of the form y{i} are included in this
+
+    // this stores variable values pulled by sending request. identifiers of 
+    // the form y{i} are included in this
     vector< double * > _pullbuf;
     map< string, double *> _constbuf;  // for constants
     string _independent; // index of independent variable
+
     mu::Parser _parser;
+
     void _clearBuffer();
     void _showError(mu::Parser::exception_type &e) const;
-	char* _stoich; // Used by kinetic solvers when this is zombified.
+    char* _stoich; // Used by kinetic solvers when this is zombified.
 };
 
 
diff --git a/diffusion/Dsolve.cpp b/diffusion/Dsolve.cpp
index ec72a97e737e06f9dc64a21f949c2047f5a49a3f..c1428146e640c75d4ad6fe57ecffbe39b412cd6b 100644
--- a/diffusion/Dsolve.cpp
+++ b/diffusion/Dsolve.cpp
@@ -33,151 +33,154 @@
 #include "../ksolve/ZombiePool.h"
 #include "../ksolve/ZombieBufPool.h"
 
+#include <thread>
+
 const Cinfo* Dsolve::initCinfo()
 {
-		///////////////////////////////////////////////////////
-		// Field definitions
-		///////////////////////////////////////////////////////
-
-		static ValueFinfo< Dsolve, Id > stoich (
-			"stoich",
-			"Stoichiometry object for handling this reaction system.",
-			&Dsolve::setStoich,
-			&Dsolve::getStoich
-		);
-
-		static ElementValueFinfo< Dsolve, string > path (
-			"path",
-			"Path of reaction system. Must include all the pools that "
-			"are to be handled by the Dsolve, can also include other "
-			"random objects, which will be ignored.",
-			&Dsolve::setPath,
-			&Dsolve::getPath
-		);
-
-		static ReadOnlyValueFinfo< Dsolve, unsigned int > numVoxels(
-			"numVoxels",
-			"Number of voxels in the core reac-diff system, on the "
-			"current diffusion solver. ",
-			&Dsolve::getNumVoxels
-		);
-		static ReadOnlyValueFinfo< Dsolve, unsigned int > numAllVoxels(
-			"numAllVoxels",
-			"Number of voxels in the core reac-diff system, on the "
-			"current diffusion solver. ",
-			&Dsolve::getNumVoxels
-		);
-		static LookupValueFinfo<
-				Dsolve, unsigned int, vector< double > > nVec(
-			"nVec",
-			"vector of # of molecules along diffusion length, "
-			"looked up by pool index",
-			&Dsolve::setNvec,
-			&Dsolve::getNvec
-		);
-
-		static ValueFinfo< Dsolve, unsigned int > numPools(
-			"numPools",
-			"Number of molecular pools in the entire reac-diff system, "
-			"including variable, function and buffered.",
-			&Dsolve::setNumPools,
-			&Dsolve::getNumPools
-		);
-
-		static ValueFinfo< Dsolve, Id > compartment (
-			"compartment",
-			"Reac-diff compartment in which this diffusion system is "
-			"embedded.",
-			&Dsolve::setCompartment,
-			&Dsolve::getCompartment
-		);
-
-		static LookupValueFinfo< Dsolve, unsigned int, double > diffVol1 (
-			"diffVol1",
-			"Volume used to set diffusion scaling: firstVol[ voxel# ] "
-			"Particularly relevant for diffusion between PSD and head.",
-			&Dsolve::setDiffVol1,
-			&Dsolve::getDiffVol1
-		);
-
-		static LookupValueFinfo< Dsolve, unsigned int, double > diffVol2 (
-			"diffVol2",
-			"Volume used to set diffusion scaling: secondVol[ voxel# ] "
-			"Particularly relevant for diffusion between spine and dend.",
-			&Dsolve::setDiffVol2,
-			&Dsolve::getDiffVol2
-		);
-
-		static LookupValueFinfo< Dsolve, unsigned int, double > diffScale (
-			"diffScale",
-			"Geometry term to set diffusion scaling: diffScale[ voxel# ] "
-			"Here the scaling term is given by cross-section area/length "
-			"Relevant for diffusion between spine head and dend, or PSD.",
-			&Dsolve::setDiffScale,
-			&Dsolve::getDiffScale
-		);
-
-
-		///////////////////////////////////////////////////////
-		// DestFinfo definitions
-		///////////////////////////////////////////////////////
-
-		static DestFinfo process( "process",
-			"Handles process call",
-			new ProcOpFunc< Dsolve >( &Dsolve::process ) );
-		static DestFinfo reinit( "reinit",
-			"Handles reinit call",
-			new ProcOpFunc< Dsolve >( &Dsolve::reinit ) );
-
-		static DestFinfo buildMeshJunctions( "buildMeshJunctions",
-			"Builds junctions between mesh on current Dsolve, and another"
-			" Dsolve. The meshes have to be compatible. ",
-			new EpFunc1< Dsolve, Id >(
-					&Dsolve::buildMeshJunctions ) );
-
-		static DestFinfo buildNeuroMeshJunctions( "buildNeuroMeshJunctions",
-			"Builds junctions between NeuroMesh, SpineMesh and PsdMesh",
-			new EpFunc2< Dsolve, Id, Id >(
-					&Dsolve::buildNeuroMeshJunctions ) );
-
-		///////////////////////////////////////////////////////
-		// 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* dsolveFinfos[] =
-	{
-		&stoich,			// ElementValue
-		&path,				// ElementValue
-		&compartment,		// Value
-		&numVoxels,			// ReadOnlyValue
-		&numAllVoxels,			// ReadOnlyValue
-		&nVec,				// LookupValue
-		&numPools,			// Value
-		&diffVol1,				// LookupValue
-		&diffVol2,				// LookupValue
-		&diffScale,				// LookupValue
-		&buildMeshJunctions, 	// DestFinfo
-		&buildNeuroMeshJunctions, 	// DestFinfo
-		&proc,				// SharedFinfo
-	};
-
-	static Dinfo< Dsolve > dinfo;
-	static  Cinfo dsolveCinfo(
-		"Dsolve",
-		Neutral::initCinfo(),
-		dsolveFinfos,
-		sizeof(dsolveFinfos)/sizeof(Finfo *),
-		&dinfo
-	);
-
-	return &dsolveCinfo;
+    ///////////////////////////////////////////////////////
+    // Field definitions
+    ///////////////////////////////////////////////////////
+
+    static ValueFinfo< Dsolve, Id > stoich (
+        "stoich",
+        "Stoichiometry object for handling this reaction system.",
+        &Dsolve::setStoich,
+        &Dsolve::getStoich
+    );
+
+    static ElementValueFinfo< Dsolve, string > path (
+        "path",
+        "Path of reaction system. Must include all the pools that "
+        "are to be handled by the Dsolve, can also include other "
+        "random objects, which will be ignored.",
+        &Dsolve::setPath,
+        &Dsolve::getPath
+    );
+
+    static ReadOnlyValueFinfo< Dsolve, unsigned int > numVoxels(
+        "numVoxels",
+        "Number of voxels in the core reac-diff system, on the "
+        "current diffusion solver. ",
+        &Dsolve::getNumVoxels
+    );
+    static ReadOnlyValueFinfo< Dsolve, unsigned int > numAllVoxels(
+        "numAllVoxels",
+        "Number of voxels in the core reac-diff system, on the "
+        "current diffusion solver. ",
+        &Dsolve::getNumVoxels
+    );
+    static LookupValueFinfo<
+    Dsolve, unsigned int, vector< double > > nVec(
+        "nVec",
+        "vector of # of molecules along diffusion length, "
+        "looked up by pool index",
+        &Dsolve::setNvec,
+        &Dsolve::getNvec
+    );
+
+    static ValueFinfo< Dsolve, unsigned int > numPools(
+        "numPools",
+        "Number of molecular pools in the entire reac-diff system, "
+        "including variable, function and buffered.",
+        &Dsolve::setNumPools,
+        &Dsolve::getNumPools
+    );
+
+    static ValueFinfo< Dsolve, Id > compartment (
+        "compartment",
+        "Reac-diff compartment in which this diffusion system is "
+        "embedded.",
+        &Dsolve::setCompartment,
+        &Dsolve::getCompartment
+    );
+
+    static LookupValueFinfo< Dsolve, unsigned int, double > diffVol1 (
+        "diffVol1",
+        "Volume used to set diffusion scaling: firstVol[ voxel# ] "
+        "Particularly relevant for diffusion between PSD and head.",
+        &Dsolve::setDiffVol1,
+        &Dsolve::getDiffVol1
+    );
+
+    static LookupValueFinfo< Dsolve, unsigned int, double > diffVol2 (
+        "diffVol2",
+        "Volume used to set diffusion scaling: secondVol[ voxel# ] "
+        "Particularly relevant for diffusion between spine and dend.",
+        &Dsolve::setDiffVol2,
+        &Dsolve::getDiffVol2
+    );
+
+    static LookupValueFinfo< Dsolve, unsigned int, double > diffScale (
+        "diffScale",
+        "Geometry term to set diffusion scaling: diffScale[ voxel# ] "
+        "Here the scaling term is given by cross-section area/length "
+        "Relevant for diffusion between spine head and dend, or PSD.",
+        &Dsolve::setDiffScale,
+        &Dsolve::getDiffScale
+    );
+
+
+    ///////////////////////////////////////////////////////
+    // DestFinfo definitions
+    ///////////////////////////////////////////////////////
+
+    static DestFinfo process( "process",
+                              "Handles process call",
+                              new ProcOpFunc< Dsolve >( &Dsolve::process ) );
+    static DestFinfo reinit( "reinit",
+                             "Handles reinit call",
+                             new ProcOpFunc< Dsolve >( &Dsolve::reinit ) );
+
+    static DestFinfo buildMeshJunctions( "buildMeshJunctions",
+                                         "Builds junctions between mesh on current Dsolve, and another"
+                                         " Dsolve. The meshes have to be compatible. ",
+                                         new EpFunc1< Dsolve, Id >(
+                                                 &Dsolve::buildMeshJunctions ) );
+
+    static DestFinfo buildNeuroMeshJunctions( "buildNeuroMeshJunctions",
+            "Builds junctions between NeuroMesh, SpineMesh and PsdMesh",
+            new EpFunc2< Dsolve, Id, Id >(
+                &Dsolve::buildNeuroMeshJunctions ) );
+
+    ///////////////////////////////////////////////////////
+    // 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* dsolveFinfos[] =
+    {
+        &stoich,			// ElementValue
+        &path,				// ElementValue
+        &compartment,		// Value
+        &numVoxels,			// ReadOnlyValue
+        &numAllVoxels,			// ReadOnlyValue
+        &nVec,				// LookupValue
+        &numPools,			// Value
+        &diffVol1,				// LookupValue
+        &diffVol2,				// LookupValue
+        &diffScale,				// LookupValue
+        &buildMeshJunctions, 	// DestFinfo
+        &buildNeuroMeshJunctions, 	// DestFinfo
+        &proc,				// SharedFinfo
+    };
+
+    static Dinfo< Dsolve > dinfo;
+    static  Cinfo dsolveCinfo(
+        "Dsolve",
+        Neutral::initCinfo(),
+        dsolveFinfos,
+        sizeof(dsolveFinfos)/sizeof(Finfo *),
+        &dinfo
+    );
+
+    return &dsolveCinfo;
 }
 
 static const Cinfo* dsolveCinfo = Dsolve::initCinfo();
@@ -186,12 +189,12 @@ static const Cinfo* dsolveCinfo = Dsolve::initCinfo();
 // Class definitions
 //////////////////////////////////////////////////////////////
 Dsolve::Dsolve()
-	:
-		dt_( -1.0 ),
-		numTotPools_( 0 ),
-		numLocalPools_( 0 ),
-		poolStartIndex_( 0 ),
-		numVoxels_( 0 )
+    :
+    dt_( -1.0 ),
+    numTotPools_( 0 ),
+    numLocalPools_( 0 ),
+    poolStartIndex_( 0 ),
+    numVoxels_( 0 )
 {;}
 
 Dsolve::~Dsolve()
@@ -203,89 +206,101 @@ Dsolve::~Dsolve()
 
 void Dsolve::setNvec( unsigned int pool, vector< double > vec )
 {
-	if ( pool < pools_.size() ) {
-		if ( vec.size() != pools_[pool].getNumVoxels() ) {
-			cout << "Warning: Dsolve::setNvec: pool index out of range\n";
-		} else {
-			pools_[ pool ].setNvec( vec );
-		}
-	}
+    if ( pool < pools_.size() )
+    {
+        if ( vec.size() != pools_[pool].getNumVoxels() )
+        {
+            cout << "Warning: Dsolve::setNvec: pool index out of range\n";
+        }
+        else
+        {
+            pools_[ pool ].setNvec( vec );
+        }
+    }
 }
 
 vector< double > Dsolve::getNvec( unsigned int pool ) const
 {
-	static vector< double > ret;
-	if ( pool <  pools_.size() )
-		return pools_[pool].getNvec();
+    static vector< double > ret;
+    if ( pool <  pools_.size() )
+        return pools_[pool].getNvec();
 
-	cout << "Warning: Dsolve::setNvec: pool index out of range\n";
-	return ret;
+    cout << "Warning: Dsolve::setNvec: pool index out of range\n";
+    return ret;
 }
 
 static bool checkJn( const vector< DiffJunction >& jn, unsigned int voxel,
-				const string& info )
+                     const string& info )
 {
-	if ( jn.size() < 1 ) {
-		cout << "Warning: Dsolve::" << info << ": junctions not defined.\n";
-		return false;
-	}
-	if ( jn[0].vj.size() < voxel + 1 ) {
-		cout << "Warning: Dsolve:: " << info << ": " << voxel <<
-				"out of range.\n";
-		return false;
-	}
-	return true;
+    if ( jn.size() < 1 )
+    {
+        cout << "Warning: Dsolve::" << info << ": junctions not defined.\n";
+        return false;
+    }
+    if ( jn[0].vj.size() < voxel + 1 )
+    {
+        cout << "Warning: Dsolve:: " << info << ": " << voxel <<
+             "out of range.\n";
+        return false;
+    }
+    return true;
 }
 
 void Dsolve::setDiffVol1( unsigned int voxel, double vol )
 {
- 	if ( checkJn( junctions_, voxel, "setDiffVol1" ) ) {
-		VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		vj.firstVol = vol;
-	}
+    if ( checkJn( junctions_, voxel, "setDiffVol1" ) )
+    {
+        VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        vj.firstVol = vol;
+    }
 }
 
 double Dsolve::getDiffVol1( unsigned int voxel ) const
 {
- 	if ( checkJn( junctions_, voxel, "getDiffVol1" ) ) {
-		const VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		return vj.firstVol;
-	}
-	return 0.0;
+    if ( checkJn( junctions_, voxel, "getDiffVol1" ) )
+    {
+        const VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        return vj.firstVol;
+    }
+    return 0.0;
 }
 
 void Dsolve::setDiffVol2( unsigned int voxel, double vol )
 {
- 	if ( checkJn( junctions_, voxel, "setDiffVol2" ) ) {
-		VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		vj.secondVol = vol;
-	}
+    if ( checkJn( junctions_, voxel, "setDiffVol2" ) )
+    {
+        VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        vj.secondVol = vol;
+    }
 }
 
 double Dsolve::getDiffVol2( unsigned int voxel ) const
 {
- 	if ( checkJn( junctions_, voxel, "getDiffVol2" ) ) {
-		const VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		return vj.secondVol;
-	}
-	return 0.0;
+    if ( checkJn( junctions_, voxel, "getDiffVol2" ) )
+    {
+        const VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        return vj.secondVol;
+    }
+    return 0.0;
 }
 
 void Dsolve::setDiffScale( unsigned int voxel, double adx )
 {
- 	if ( checkJn( junctions_, voxel, "setDiffScale" ) ) {
-		VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		vj.diffScale = adx;
-	}
+    if ( checkJn( junctions_, voxel, "setDiffScale" ) )
+    {
+        VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        vj.diffScale = adx;
+    }
 }
 
 double Dsolve::getDiffScale( unsigned int voxel ) const
 {
- 	if ( checkJn( junctions_, voxel, "getDiffScale" ) ) {
-		const VoxelJunction& vj = junctions_[0].vj[ voxel ];
-		return vj.diffScale;
-	}
-	return 0.0;
+    if ( checkJn( junctions_, voxel, "getDiffScale" ) )
+    {
+        const VoxelJunction& vj = junctions_[0].vj[ voxel ];
+        return vj.diffScale;
+    }
+    return 0.0;
 }
 
 //////////////////////////////////////////////////////////////
@@ -294,155 +309,169 @@ double Dsolve::getDiffScale( unsigned int voxel ) const
 
 static double integ( double myN, double rf, double rb, double dt )
 {
-	const double EPSILON = 1e-12;
-	if ( myN > EPSILON && rf > EPSILON ) {
-		double C = exp( -rf * dt / myN );
-		myN *= C + ( rb / rf ) * ( 1.0 - C );
-	} else {
-		myN += ( rb - rf ) * dt;
-	}
-	if ( myN < 0.0 )
-		return 0.0;
-	return myN;
+    const double EPSILON = 1e-12;
+    if ( myN > EPSILON && rf > EPSILON )
+    {
+        double C = exp( -rf * dt / myN );
+        myN *= C + ( rb / rf ) * ( 1.0 - C );
+    }
+    else
+    {
+        myN += ( rb - rf ) * dt;
+    }
+    if ( myN < 0.0 )
+        return 0.0;
+    return myN;
 }
 
 void Dsolve::calcJnDiff( const DiffJunction& jn, Dsolve* other, double dt)
 {
-	const double EPSILON = 1e-16;
-	assert( jn.otherPools.size() == jn.myPools.size() );
-	for ( unsigned int i = 0; i < jn.myPools.size(); ++i ) {
-		DiffPoolVec& myDv = pools_[ jn.myPools[i] ];
-		if ( myDv.getDiffConst() < EPSILON )
-			continue;
-		DiffPoolVec& otherDv = other->pools_[ jn.otherPools[i] ];
-		if ( otherDv.getDiffConst() < EPSILON )
-			continue;
-		// This geom mean is used in case we have the odd situation of
-		// different diffusion constants.
-		double effectiveDiffConst =
-			sqrt( myDv.getDiffConst() * otherDv.getDiffConst() );
-		for ( vector< VoxelJunction >::const_iterator
-			j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
-			double myN = myDv.getN( j->first );
-			double otherN = otherDv.getN( j->second );
-			// Here we do an exp Euler calculation
-			// rf is rate from self to other.
-			// double k = myDv.getDiffConst() * j->diffScale;
-			double k = effectiveDiffConst * j->diffScale;
-			double lastN = myN;
-			myN = integ( myN,
-				k * myN / j->firstVol,
-				k * otherN / j->secondVol,
-				dt
-			);
-			otherN += lastN - myN; // Simple mass conservation
-			if ( otherN < 0.0 ) { // Avoid negatives
-				myN += otherN;
-				otherN = 0.0;
-			}
-			myDv.setN( j->first, myN );
-			otherDv.setN( j->second, otherN );
-		}
-	}
+    const double EPSILON = 1e-16;
+    assert( jn.otherPools.size() == jn.myPools.size() );
+    for ( unsigned int i = 0; i < jn.myPools.size(); ++i )
+    {
+        DiffPoolVec& myDv = pools_[ jn.myPools[i] ];
+        if ( myDv.getDiffConst() < EPSILON )
+            continue;
+        DiffPoolVec& otherDv = other->pools_[ jn.otherPools[i] ];
+        if ( otherDv.getDiffConst() < EPSILON )
+            continue;
+        // This geom mean is used in case we have the odd situation of
+        // different diffusion constants.
+        double effectiveDiffConst =
+            sqrt( myDv.getDiffConst() * otherDv.getDiffConst() );
+        for ( vector< VoxelJunction >::const_iterator
+                j = jn.vj.begin(); j != jn.vj.end(); ++j )
+        {
+            double myN = myDv.getN( j->first );
+            double otherN = otherDv.getN( j->second );
+            // Here we do an exp Euler calculation
+            // rf is rate from self to other.
+            // double k = myDv.getDiffConst() * j->diffScale;
+            double k = effectiveDiffConst * j->diffScale;
+            double lastN = myN;
+            myN = integ( myN,
+                         k * myN / j->firstVol,
+                         k * otherN / j->secondVol,
+                         dt
+                       );
+            otherN += lastN - myN; // Simple mass conservation
+            if ( otherN < 0.0 )   // Avoid negatives
+            {
+                myN += otherN;
+                otherN = 0.0;
+            }
+            myDv.setN( j->first, myN );
+            otherDv.setN( j->second, otherN );
+        }
+    }
 }
 
-void Dsolve::calcJnXfer( const DiffJunction& jn, 
-				const vector< unsigned int >& srcXfer, 
-				const vector< unsigned int >& destXfer, 
-				Dsolve* srcDsolve, Dsolve* destDsolve )
+void Dsolve::calcJnXfer( const DiffJunction& jn,
+                         const vector< unsigned int >& srcXfer,
+                         const vector< unsigned int >& destXfer,
+                         Dsolve* srcDsolve, Dsolve* destDsolve )
 {
-	assert( destXfer.size() == srcXfer.size() );
-	for ( unsigned int i = 0; i < srcXfer.size(); ++i ) {
-		DiffPoolVec& srcDv = srcDsolve->pools_[ srcXfer[i] ];
-		DiffPoolVec& destDv = destDsolve->pools_[ destXfer[i] ];
-		for ( vector< VoxelJunction >::const_iterator
-			j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
-			double prevSrc = srcDv.getPrev( j->first );
-			double prevDest = destDv.getPrev( j->second );
-			double srcN = srcDv.getN( j->first );
-			double destN = destDv.getN( j->second );
-			// Consider delta as sum of local dN, and reference as prevDest
-			// newN = (srcN - prevSrc + destN - prevDest)  + prevDest
-			double newN = srcN + destN - prevSrc;
-			srcDv.setN( j->first, newN );
-			destDv.setN( j->second, newN );
-		}
-	}
+    assert( destXfer.size() == srcXfer.size() );
+    for ( unsigned int i = 0; i < srcXfer.size(); ++i )
+    {
+        DiffPoolVec& srcDv = srcDsolve->pools_[ srcXfer[i] ];
+        DiffPoolVec& destDv = destDsolve->pools_[ destXfer[i] ];
+        for ( vector< VoxelJunction >::const_iterator
+                j = jn.vj.begin(); j != jn.vj.end(); ++j )
+        {
+            double prevSrc = srcDv.getPrev( j->first );
+            double prevDest = destDv.getPrev( j->second );
+            double srcN = srcDv.getN( j->first );
+            double destN = destDv.getN( j->second );
+            // Consider delta as sum of local dN, and reference as prevDest
+            // newN = (srcN - prevSrc + destN - prevDest)  + prevDest
+            double newN = srcN + destN - prevSrc;
+            srcDv.setN( j->first, newN );
+            destDv.setN( j->second, newN );
+        }
+    }
 }
 
 void Dsolve::calcJnChan( const DiffJunction& jn, Dsolve* other, double dt )
 {
-	// Each jn has some channels
-	// Each channel has a chanPool, an intPool and an extPool.
-	// chanPool and intPool must be on self, extPool is on other. In
-	// cases where the intPool is on other, it attempts to swap the
-	// int and ext pools, but this too could fail
-	// because the chanPool could be a third compartment, such as the memb
-	//
-	// Don't have a solution for this case as yet.
-	// Other alternative is to have a message to update the N of the chan,
-	// so it isn't in the domain of the solver at all except for here.
-	// In which case we will want to point to the Moose object for it.
-	//
-	
-	for ( unsigned int i = 0; i < jn.myChannels.size(); ++i ) {
-		ConcChanInfo& myChan = channels_[ jn.myChannels[i] ];
-		DiffPoolVec& myDv = pools_[ myChan.myPool ];
-		DiffPoolVec& otherDv = other->pools_[ myChan.otherPool ];
-		DiffPoolVec& chanDv = pools_[ myChan.chanPool ];
-		for ( vector< VoxelJunction >::const_iterator
-			j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
-
-			double myN = myDv.getN( j->first );
-			double lastN = myN;
-			double otherN = otherDv.getN( j->second );
-			double chanN = chanDv.getN( j->first );
-			double perm = myChan.permeability * chanN / NA;
-			myN = integ( myN, perm * myN/j->firstVol, 
-							perm * otherN/j->secondVol, dt );
-			otherN += lastN - myN;	// Mass consv
-			if ( otherN < 0.0 ) { // Avoid negatives
-				myN += otherN;
-				otherN = 0.0;
-			}
-			myDv.setN( j->first, myN );
-			otherDv.setN( j->second, otherN );
-		}
-	}
+    // Each jn has some channels
+    // Each channel has a chanPool, an intPool and an extPool.
+    // chanPool and intPool must be on self, extPool is on other. In
+    // cases where the intPool is on other, it attempts to swap the
+    // int and ext pools, but this too could fail
+    // because the chanPool could be a third compartment, such as the memb
+    //
+    // Don't have a solution for this case as yet.
+    // Other alternative is to have a message to update the N of the chan,
+    // so it isn't in the domain of the solver at all except for here.
+    // In which case we will want to point to the Moose object for it.
+    //
+
+    for ( unsigned int i = 0; i < jn.myChannels.size(); ++i )
+    {
+        ConcChanInfo& myChan = channels_[ jn.myChannels[i] ];
+        DiffPoolVec& myDv = pools_[ myChan.myPool ];
+        DiffPoolVec& otherDv = other->pools_[ myChan.otherPool ];
+        DiffPoolVec& chanDv = pools_[ myChan.chanPool ];
+        for ( vector< VoxelJunction >::const_iterator
+                j = jn.vj.begin(); j != jn.vj.end(); ++j )
+        {
+
+            double myN = myDv.getN( j->first );
+            double lastN = myN;
+            double otherN = otherDv.getN( j->second );
+            double chanN = chanDv.getN( j->first );
+            double perm = myChan.permeability * chanN / NA;
+            myN = integ( myN, perm * myN/j->firstVol,
+                         perm * otherN/j->secondVol, dt );
+            otherN += lastN - myN;	// Mass consv
+            if ( otherN < 0.0 )   // Avoid negatives
+            {
+                myN += otherN;
+                otherN = 0.0;
+            }
+            myDv.setN( j->first, myN );
+            otherDv.setN( j->second, otherN );
+        }
+    }
 }
 
 // Same as above, but now go through channels on other Dsolve.
 void Dsolve::calcOtherJnChan( const DiffJunction& jn, Dsolve* other, double dt )
 {
-	for ( unsigned int i = 0; i < jn.otherChannels.size(); ++i ) {
-		ConcChanInfo& otherChan = other->channels_[ jn.otherChannels[i] ];
-		// This is the DiffPoolVec for the pools on the other Dsolve,
-		// the one with the channel.
-		// DiffPoolVec& otherDv = other->pools_[ jn.otherPools[otherChan.myPool] ];
-		DiffPoolVec& otherDv = other->pools_[ otherChan.myPool ];
-		// Local diffPoolVec.
-		// DiffPoolVec& myDv = pools_[ jn.myPools[otherChan.otherPool] ];
-		DiffPoolVec& myDv = pools_[ otherChan.otherPool ];
-		DiffPoolVec& chanDv = other->pools_[ otherChan.chanPool ];
-		for ( vector< VoxelJunction >::const_iterator
-			j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
-
-			double myN = myDv.getN( j->first );
-			double lastN = myN;
-			double otherN = otherDv.getN( j->second );
-			double chanN = chanDv.getN( j->second );
-			double perm = otherChan.permeability * chanN / NA;
-			myN = integ( myN, perm * myN/j->firstVol, 
-							perm * otherN/j->secondVol, dt );
-			otherN += lastN - myN;	// Mass consv
-			if ( otherN < 0.0 ) { // Avoid negatives
-				myN += otherN;
-				otherN = 0.0;
-			}
-			myDv.setN( j->first, myN );
-			otherDv.setN( j->second, otherN );
-		}
-	}
+    for ( unsigned int i = 0; i < jn.otherChannels.size(); ++i )
+    {
+        ConcChanInfo& otherChan = other->channels_[ jn.otherChannels[i] ];
+        // This is the DiffPoolVec for the pools on the other Dsolve,
+        // the one with the channel.
+        // DiffPoolVec& otherDv = other->pools_[ jn.otherPools[otherChan.myPool] ];
+        DiffPoolVec& otherDv = other->pools_[ otherChan.myPool ];
+        // Local diffPoolVec.
+        // DiffPoolVec& myDv = pools_[ jn.myPools[otherChan.otherPool] ];
+        DiffPoolVec& myDv = pools_[ otherChan.otherPool ];
+        DiffPoolVec& chanDv = other->pools_[ otherChan.chanPool ];
+        for ( vector< VoxelJunction >::const_iterator
+                j = jn.vj.begin(); j != jn.vj.end(); ++j )
+        {
+
+            double myN = myDv.getN( j->first );
+            double lastN = myN;
+            double otherN = otherDv.getN( j->second );
+            double chanN = chanDv.getN( j->second );
+            double perm = otherChan.permeability * chanN / NA;
+            myN = integ( myN, perm * myN/j->firstVol,
+                         perm * otherN/j->secondVol, dt );
+            otherN += lastN - myN;	// Mass consv
+            if ( otherN < 0.0 )   // Avoid negatives
+            {
+                myN += otherN;
+                otherN = 0.0;
+            }
+            myDv.setN( j->first, myN );
+            otherDv.setN( j->second, otherN );
+        }
+    }
 }
 
 /**
@@ -456,145 +485,159 @@ void Dsolve::calcOtherJnChan( const DiffJunction& jn, Dsolve* other, double dt )
  */
 void Dsolve::calcJunction( const DiffJunction& jn, double dt )
 {
-	Id oid( jn.otherDsolve );
-	assert ( oid != Id() );
-	assert ( oid.element()->cinfo()->isA( "Dsolve" ) );
+    Id oid( jn.otherDsolve );
+    assert ( oid != Id() );
+    assert ( oid.element()->cinfo()->isA( "Dsolve" ) );
 
-	Dsolve* other = reinterpret_cast< Dsolve* >( oid.eref().data() );
-	calcJnDiff( jn, other, dt/2.0 );
+    Dsolve* other = reinterpret_cast< Dsolve* >( oid.eref().data() );
+    calcJnDiff( jn, other, dt/2.0 );
 
-	calcJnChan( jn, other, dt/2.0 );
-	calcOtherJnChan( jn, other, dt/2.0 );
+    calcJnChan( jn, other, dt/2.0 );
+    calcOtherJnChan( jn, other, dt/2.0 );
 
-	calcJnXfer( jn, jn.myXferSrc, jn.otherXferDest, this, other );
-	calcJnXfer( jn, jn.otherXferSrc, jn.myXferDest, other, this );
+    calcJnXfer( jn, jn.myXferSrc, jn.otherXferDest, this, other );
+    calcJnXfer( jn, jn.otherXferSrc, jn.myXferDest, other, this );
 
-	calcJnDiff( jn, other, dt/2.0 );
+    calcJnDiff( jn, other, dt/2.0 );
 
-	calcJnChan( jn, other, dt/2.0 );
-	calcOtherJnChan( jn, other, dt/2.0 );
+    calcJnChan( jn, other, dt/2.0 );
+    calcOtherJnChan( jn, other, dt/2.0 );
 }
 
 void Dsolve::process( const Eref& e, ProcPtr p )
 {
-	for ( vector< DiffPoolVec >::iterator
-					i = pools_.begin(); i != pools_.end(); ++i ) {
-		i->advance( p->dt );
-	}
+    for ( auto i = pools_.begin(); i != pools_.end(); ++i )
+        i->advance( p->dt );
 }
 
 void Dsolve::reinit( const Eref& e, ProcPtr p )
 {
-	build( p->dt );
-	for ( vector< DiffPoolVec >::iterator
-					i = pools_.begin(); i != pools_.end(); ++i ) {
-		i->reinit();
-	}
+    build( p->dt );
+    for ( vector< DiffPoolVec >::iterator
+            i = pools_.begin(); i != pools_.end(); ++i )
+    {
+        i->reinit();
+    }
 }
 
 void Dsolve::updateJunctions( double dt )
 {
-	for ( vector< DiffJunction >::const_iterator
-			i = junctions_.begin(); i != junctions_.end(); ++i ) {
-		calcJunction( *i, dt );
-	}
+    for (auto i = junctions_.begin(); i != junctions_.end(); ++i )
+        calcJunction( *i, dt );
 }
+
+
+void Dsolve::calcJunction_chunk( const size_t begin, const size_t end, double dt )
+{
+    for (size_t i = begin; i < min(end, junctions_.size()); i++) 
+        calcJunction( junctions_[i], dt );
+
+}
+
+
 //////////////////////////////////////////////////////////////
 // Solver coordination and setup functions
 //////////////////////////////////////////////////////////////
 
 void Dsolve::setStoich( Id id )
 {
-	if ( !id.element()->cinfo()->isA( "Stoich" ) ) {
-		cout << "Dsolve::setStoich::( " << id << " ): Error: provided Id is not a Stoich\n";
-		return;
-	}
-
-	stoich_ = id;
-	poolMap_ = Field< vector< unsigned int > >::get( stoich_, "poolIdMap" );
-	poolMapStart_ = poolMap_.back();
-	poolMap_.pop_back();
-
-	path_ = Field< string >::get( stoich_, "path" );
-	// cout << "Pool Info for stoich " << id.path() << endl;
-
-	for ( unsigned int i = 0; i < poolMap_.size(); ++i ) {
-		unsigned int poolIndex = poolMap_[i];
-		if ( poolIndex != ~0U && poolIndex < pools_.size() ) {
-			// assert( poolIndex < pools_.size() );
-			Id pid( i + poolMapStart_ );
-			assert( pid.element()->cinfo()->isA( "PoolBase" ) );
-			PoolBase* pb =
-					reinterpret_cast< PoolBase* >( pid.eref().data());
-			double diffConst = pb->getDiffConst( pid.eref() );
-			double motorConst = pb->getMotorConst( pid.eref() );
-			pools_[ poolIndex ].setId( pid.value() );
-			pools_[ poolIndex ].setDiffConst( diffConst );
-			pools_[ poolIndex ].setMotorConst( motorConst );
-			/*
-			cout << i << " poolIndex=" <<  poolIndex <<
-					", id=" << pid.value() <<
-					", name=" << pid.element()->getName() << endl;
-					*/
-		}
-	}
-	string chanpath = path_ + "[ISA=ConcChan]";
-	vector< ObjId > chans;
-	wildcardFind( chanpath, chans );
-	fillConcChans( chans );
+    if ( !id.element()->cinfo()->isA( "Stoich" ) )
+    {
+        cout << "Dsolve::setStoich::( " << id << " ): Error: provided Id is not a Stoich\n";
+        return;
+    }
+
+    stoich_ = id;
+    poolMap_ = Field< vector< unsigned int > >::get( stoich_, "poolIdMap" );
+    poolMapStart_ = poolMap_.back();
+    poolMap_.pop_back();
+
+    path_ = Field< string >::get( stoich_, "path" );
+    // cout << "Pool Info for stoich " << id.path() << endl;
+
+    for ( unsigned int i = 0; i < poolMap_.size(); ++i )
+    {
+        unsigned int poolIndex = poolMap_[i];
+        if ( poolIndex != ~0U && poolIndex < pools_.size() )
+        {
+            // assert( poolIndex < pools_.size() );
+            Id pid( i + poolMapStart_ );
+            assert( pid.element()->cinfo()->isA( "PoolBase" ) );
+            PoolBase* pb =
+                reinterpret_cast< PoolBase* >( pid.eref().data());
+            double diffConst = pb->getDiffConst( pid.eref() );
+            double motorConst = pb->getMotorConst( pid.eref() );
+            pools_[ poolIndex ].setId( pid.value() );
+            pools_[ poolIndex ].setDiffConst( diffConst );
+            pools_[ poolIndex ].setMotorConst( motorConst );
+            /*
+            cout << i << " poolIndex=" <<  poolIndex <<
+            		", id=" << pid.value() <<
+            		", name=" << pid.element()->getName() << endl;
+            		*/
+        }
+    }
+    string chanpath = path_ + "[ISA=ConcChan]";
+    vector< ObjId > chans;
+    wildcardFind( chanpath, chans );
+    fillConcChans( chans );
 }
 
 void Dsolve::fillConcChans( const vector< ObjId >& chans )
 {
-	static const Cinfo* ccc = Cinfo::find( "ConcChan" );
-	static const Finfo* inPoolFinfo = ccc->findFinfo( "inPool" );
-	static const Finfo* outPoolFinfo = ccc->findFinfo( "outPool" );
-	static const Finfo* chanPoolFinfo = ccc->findFinfo( "setNumChan" );
-	FuncId fin = static_cast< const DestFinfo* >( inPoolFinfo )->getFid();
-	FuncId fout = static_cast< const DestFinfo* >(outPoolFinfo )->getFid();
-	FuncId fchan = 
-			static_cast< const DestFinfo* >(chanPoolFinfo )->getFid();
-
-	// Find the in pools and the chan pools on the current compt.
-	// Save the Id of the outPool as an integer.
-	// Use these and the permeability to create the ConcChanInfo.
-	for ( auto i = chans.begin(); i != chans.end(); ++i ) {
-		vector< Id > ret;
-		if (i->element()->getNeighbors( ret, inPoolFinfo ) == 0 ) return;
-		ObjId inPool( ret[0] );
-		ret.clear();
-		if (i->element()->getNeighbors( ret, outPoolFinfo ) == 0 ) return;
-		ObjId outPool( ret[0] );
-		ret.clear();
-		if (i->element()->getNeighbors( ret, chanPoolFinfo ) == 0 ) return;
-		ObjId chanPool( ret[0] );
-		ret.clear();
-		unsigned int outPoolValue = outPool.id.value();
-		bool swapped = false;
-		if ( !( inPool.bad() or chanPool.bad() ) ) {
-			unsigned int inPoolIndex = convertIdToPoolIndex( inPool.id );
-			unsigned int chanPoolIndex = convertIdToPoolIndex(chanPool.id);
-			if ( inPoolIndex == ~0U ) { // Swap in and out as chan is symm
-				inPoolIndex = convertIdToPoolIndex( outPool.id );
-				outPoolValue = inPool.id.value();
-				swapped = true;
-			}
-			if ( ( inPoolIndex != ~0U) && (chanPoolIndex != ~0U ) ) {
-				ConcChanInfo cci( 
-					inPoolIndex, outPoolValue, chanPoolIndex, 
-					Field< double >::get( *i, "permeability" ), 
-					////// Fix it below ////////
-					swapped
-				);
-				channels_.push_back( cci );
-			}
-		}
-	}
+    static const Cinfo* ccc = Cinfo::find( "ConcChan" );
+    static const Finfo* inPoolFinfo = ccc->findFinfo( "inPool" );
+    static const Finfo* outPoolFinfo = ccc->findFinfo( "outPool" );
+    static const Finfo* chanPoolFinfo = ccc->findFinfo( "setNumChan" );
+    FuncId fin = static_cast< const DestFinfo* >( inPoolFinfo )->getFid();
+    FuncId fout = static_cast< const DestFinfo* >(outPoolFinfo )->getFid();
+    FuncId fchan =
+        static_cast< const DestFinfo* >(chanPoolFinfo )->getFid();
+
+    // Find the in pools and the chan pools on the current compt.
+    // Save the Id of the outPool as an integer.
+    // Use these and the permeability to create the ConcChanInfo.
+    for ( auto i = chans.begin(); i != chans.end(); ++i )
+    {
+        vector< Id > ret;
+        if (i->element()->getNeighbors( ret, inPoolFinfo ) == 0 ) return;
+        ObjId inPool( ret[0] );
+        ret.clear();
+        if (i->element()->getNeighbors( ret, outPoolFinfo ) == 0 ) return;
+        ObjId outPool( ret[0] );
+        ret.clear();
+        if (i->element()->getNeighbors( ret, chanPoolFinfo ) == 0 ) return;
+        ObjId chanPool( ret[0] );
+        ret.clear();
+        unsigned int outPoolValue = outPool.id.value();
+        bool swapped = false;
+        if ( !( inPool.bad() or chanPool.bad() ) )
+        {
+            unsigned int inPoolIndex = convertIdToPoolIndex( inPool.id );
+            unsigned int chanPoolIndex = convertIdToPoolIndex(chanPool.id);
+            if ( inPoolIndex == ~0U )   // Swap in and out as chan is symm
+            {
+                inPoolIndex = convertIdToPoolIndex( outPool.id );
+                outPoolValue = inPool.id.value();
+                swapped = true;
+            }
+            if ( ( inPoolIndex != ~0U) && (chanPoolIndex != ~0U ) )
+            {
+                ConcChanInfo cci(
+                    inPoolIndex, outPoolValue, chanPoolIndex,
+                    Field< double >::get( *i, "permeability" ),
+                    ////// Fix it below ////////
+                    swapped
+                );
+                channels_.push_back( cci );
+            }
+        }
+    }
 }
 
 Id Dsolve::getStoich() const
 {
-	return stoich_;
+    return stoich_;
 }
 
 /// Inherited, defining dummy function here.
@@ -603,100 +646,113 @@ void Dsolve::setDsolve( Id dsolve )
 
 void Dsolve::setCompartment( Id id )
 {
-	const Cinfo* c = id.element()->cinfo();
-	compartment_ = id;
-	numVoxels_ = Field< unsigned int >::get( id, "numMesh" );
-	if ( c->isA( "CubeMesh" ) ) { // we do only linear diffusion for now
-		unsigned int nx = Field< unsigned int >::get( id, "nx" );
-		unsigned int ny = Field< unsigned int >::get( id, "nx" );
-		unsigned int nz = Field< unsigned int >::get( id, "nx" );
-		if ( !( nx*ny == 1 || nx*nz == 1 || ny*nz == 1 ) ) {
-			cout << "Warning: Dsolve::setCompartment:: Cube mesh: " <<
-			c->name() << " found with >1 dimension of voxels. " <<
-			"Only 1-D diffusion supported for now.\n";
-			return;
-		}
-	}
+    const Cinfo* c = id.element()->cinfo();
+    compartment_ = id;
+    numVoxels_ = Field< unsigned int >::get( id, "numMesh" );
+    if ( c->isA( "CubeMesh" ) )   // we do only linear diffusion for now
+    {
+        unsigned int nx = Field< unsigned int >::get( id, "nx" );
+        unsigned int ny = Field< unsigned int >::get( id, "nx" );
+        unsigned int nz = Field< unsigned int >::get( id, "nx" );
+        if ( !( nx*ny == 1 || nx*nz == 1 || ny*nz == 1 ) )
+        {
+            cout << "Warning: Dsolve::setCompartment:: Cube mesh: " <<
+                 c->name() << " found with >1 dimension of voxels. " <<
+                 "Only 1-D diffusion supported for now.\n";
+            return;
+        }
+    }
 }
 
 void Dsolve::makePoolMapFromElist( const vector< ObjId >& elist,
-				vector< Id >& temp )
+                                   vector< Id >& temp )
 {
-	unsigned int minId = 0;
-	unsigned int maxId = 0;
-	temp.resize( 0 );
-	for ( vector< ObjId >::const_iterator
-			i = elist.begin(); i != elist.end(); ++i ) {
-		if ( i->element()->cinfo()->isA( "PoolBase" ) ) {
-			temp.push_back( i->id );
-			if ( minId == 0 )
-				maxId = minId = i->id.value();
-			else if ( i->id.value() < minId )
-				minId = i->id.value();
-			else if ( i->id.value() > maxId )
-				maxId = i->id.value();
-		}
-	}
-
-	if ( temp.size() == 0 ) {
-		cout << "Dsolve::makePoolMapFromElist::( " << path_ <<
-				" ): Error: path is has no pools\n";
-		return;
-	}
-
-	stoich_ = Id();
-	poolMapStart_ = minId;
-	poolMap_.resize( 1 + maxId - minId );
-	for ( auto i = poolMap_.begin(); i != poolMap_.end(); ++i )
-		*i = ~0U;
-	for ( unsigned int i = 0; i < temp.size(); ++i ) {
-		unsigned int idValue = temp[i].value();
-		assert( idValue >= minId );
-		assert( idValue - minId < poolMap_.size() );
-		poolMap_[ idValue - minId ] = i;
-	}
+    unsigned int minId = 0;
+    unsigned int maxId = 0;
+    temp.resize( 0 );
+    for ( vector< ObjId >::const_iterator
+            i = elist.begin(); i != elist.end(); ++i )
+    {
+        if ( i->element()->cinfo()->isA( "PoolBase" ) )
+        {
+            temp.push_back( i->id );
+            if ( minId == 0 )
+                maxId = minId = i->id.value();
+            else if ( i->id.value() < minId )
+                minId = i->id.value();
+            else if ( i->id.value() > maxId )
+                maxId = i->id.value();
+        }
+    }
+
+    if ( temp.size() == 0 )
+    {
+        cout << "Dsolve::makePoolMapFromElist::( " << path_ <<
+             " ): Error: path is has no pools\n";
+        return;
+    }
+
+    stoich_ = Id();
+    poolMapStart_ = minId;
+    poolMap_.resize( 1 + maxId - minId );
+    for ( auto i = poolMap_.begin(); i != poolMap_.end(); ++i )
+        *i = ~0U;
+    for ( unsigned int i = 0; i < temp.size(); ++i )
+    {
+        unsigned int idValue = temp[i].value();
+        assert( idValue >= minId );
+        assert( idValue - minId < poolMap_.size() );
+        poolMap_[ idValue - minId ] = i;
+    }
 }
 
 void Dsolve::setPath( const Eref& e, string path )
 {
-	vector< ObjId > elist;
-	simpleWildcardFind( path, elist );
-	if ( elist.size() == 0 ) {
-		cout << "Dsolve::setPath::( " << path << " ): Error: path is empty\n";
-		return;
-	}
-	vector< Id > temp;
-	makePoolMapFromElist( elist, temp );
-
-	setNumPools( temp.size() );
-	for ( unsigned int i = 0; i < temp.size(); ++i ) {
-	 	Id id = temp[i];
-		double diffConst = Field< double >::get( id, "diffConst" );
-		double motorConst = Field< double >::get( id, "motorConst" );
-		const Cinfo* c = id.element()->cinfo();
-		if ( c == Pool::initCinfo() ) {
-			PoolBase::zombify( id.element(), ZombiePool::initCinfo(), Id(), e.id() );
-		} else if ( c == BufPool::initCinfo() ) {
-			PoolBase::zombify( id.element(), ZombieBufPool::initCinfo(), Id(), e.id() );
-			// Any Functions will have to continue to manage the BufPools.
-			// This needs them to be replicated, and for their messages
-			// to be copied over. Not really set up here.
-		} else {
-			cout << "Error: Dsolve::setPath( " << path << " ): unknown pool class:" << c->name() << endl;
-		}
-		id.element()->resize( numVoxels_ );
-
-		unsigned int j = temp[i].value() - poolMapStart_;
-		assert( j < poolMap_.size() );
-		pools_[ poolMap_[i] ].setId( id.value() );
-		pools_[ poolMap_[j] ].setDiffConst( diffConst );
-		pools_[ poolMap_[j] ].setMotorConst( motorConst );
-	}
+    vector< ObjId > elist;
+    simpleWildcardFind( path, elist );
+    if ( elist.size() == 0 )
+    {
+        cout << "Dsolve::setPath::( " << path << " ): Error: path is empty\n";
+        return;
+    }
+    vector< Id > temp;
+    makePoolMapFromElist( elist, temp );
+
+    setNumPools( temp.size() );
+    for ( unsigned int i = 0; i < temp.size(); ++i )
+    {
+        Id id = temp[i];
+        double diffConst = Field< double >::get( id, "diffConst" );
+        double motorConst = Field< double >::get( id, "motorConst" );
+        const Cinfo* c = id.element()->cinfo();
+        if ( c == Pool::initCinfo() )
+        {
+            PoolBase::zombify( id.element(), ZombiePool::initCinfo(), Id(), e.id() );
+        }
+        else if ( c == BufPool::initCinfo() )
+        {
+            PoolBase::zombify( id.element(), ZombieBufPool::initCinfo(), Id(), e.id() );
+            // Any Functions will have to continue to manage the BufPools.
+            // This needs them to be replicated, and for their messages
+            // to be copied over. Not really set up here.
+        }
+        else
+        {
+            cout << "Error: Dsolve::setPath( " << path << " ): unknown pool class:" << c->name() << endl;
+        }
+        id.element()->resize( numVoxels_ );
+
+        unsigned int j = temp[i].value() - poolMapStart_;
+        assert( j < poolMap_.size() );
+        pools_[ poolMap_[i] ].setId( id.value() );
+        pools_[ poolMap_[j] ].setDiffConst( diffConst );
+        pools_[ poolMap_[j] ].setMotorConst( motorConst );
+    }
 }
 
 string Dsolve::getPath( const Eref& e ) const
 {
-	return path_;
+    return path_;
 }
 
 /////////////////////////////////////////////////////////////
@@ -722,43 +778,45 @@ string Dsolve::getPath( const Eref& e ) const
 
 void Dsolve::build( double dt )
 {
-	if ( doubleEq( dt, dt_ ) )
-		return;
-	if ( compartment_ == Id() ) {
-		cout << "Dsolve::build: Warning: No compartment defined. \n"
-				"Did you forget to assign 'stoich.dsolve = this' ?\n";
-		return;
-	}
-	dt_ = dt;
-	const MeshCompt* m = reinterpret_cast< const MeshCompt* >(
-						compartment_.eref().data() );
-	unsigned int numVoxels = m->getNumEntries();
-
-	for ( unsigned int i = 0; i < numLocalPools_; ++i ) {
-		bool debugFlag = false;
-		vector< unsigned int > diagIndex;
-		vector< double > diagVal;
-		vector< Triplet< double > > fops;
-		FastMatrixElim elim( numVoxels, numVoxels );
-		if ( elim.buildForDiffusion(
-			m->getParentVoxel(), m->getVoxelVolume(),
-			m->getVoxelArea(), m->getVoxelLength(),
-		    pools_[i].getDiffConst(), pools_[i].getMotorConst(), dt ) )
-		{
-			vector< unsigned int > parentVoxel = m->getParentVoxel();
-			assert( elim.checkSymmetricShape() );
-			vector< unsigned int > lookupOldRowsFromNew;
-			elim.hinesReorder( parentVoxel, lookupOldRowsFromNew );
-			assert( elim.checkSymmetricShape() );
-			pools_[i].setNumVoxels( numVoxels_ );
-			elim.buildForwardElim( diagIndex, fops );
-			elim.buildBackwardSub( diagIndex, fops, diagVal );
-			elim.opsReorder( lookupOldRowsFromNew, fops, diagVal );
-			if (debugFlag )
-				elim.print();
-		}
-		pools_[i].setOps( fops, diagVal );
-	}
+    if ( doubleEq( dt, dt_ ) )
+        return;
+    if ( compartment_ == Id() )
+    {
+        cout << "Dsolve::build: Warning: No compartment defined. \n"
+             "Did you forget to assign 'stoich.dsolve = this' ?\n";
+        return;
+    }
+    dt_ = dt;
+    const MeshCompt* m = reinterpret_cast< const MeshCompt* >(
+                             compartment_.eref().data() );
+    unsigned int numVoxels = m->getNumEntries();
+
+    for ( unsigned int i = 0; i < numLocalPools_; ++i )
+    {
+        bool debugFlag = false;
+        vector< unsigned int > diagIndex;
+        vector< double > diagVal;
+        vector< Triplet< double > > fops;
+        FastMatrixElim elim( numVoxels, numVoxels );
+        if ( elim.buildForDiffusion(
+                    m->getParentVoxel(), m->getVoxelVolume(),
+                    m->getVoxelArea(), m->getVoxelLength(),
+                    pools_[i].getDiffConst(), pools_[i].getMotorConst(), dt ) )
+        {
+            vector< unsigned int > parentVoxel = m->getParentVoxel();
+            assert( elim.checkSymmetricShape() );
+            vector< unsigned int > lookupOldRowsFromNew;
+            elim.hinesReorder( parentVoxel, lookupOldRowsFromNew );
+            assert( elim.checkSymmetricShape() );
+            pools_[i].setNumVoxels( numVoxels_ );
+            elim.buildForwardElim( diagIndex, fops );
+            elim.buildBackwardSub( diagIndex, fops, diagVal );
+            elim.opsReorder( lookupOldRowsFromNew, fops, diagVal );
+            if (debugFlag )
+                elim.print();
+        }
+        pools_[i].setOps( fops, diagVal );
+    }
 }
 
 /**
@@ -767,195 +825,216 @@ void Dsolve::build( double dt )
 // Would like to permit vectors of spines and psd compartments.
 void Dsolve::buildNeuroMeshJunctions( const Eref& e, Id spineD, Id psdD )
 {
-	if ( !compartment_.element()->cinfo()->isA( "NeuroMesh" ) ) {
-		cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
-				compartment_.path() << "' is not a NeuroMesh\n";
-		return;
-	}
-	Id spineMesh = Field< Id >::get( spineD, "compartment" );
-	if ( !spineMesh.element()->cinfo()->isA( "SpineMesh" ) ) {
-		cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
-				spineMesh.path() << "' is not a SpineMesh\n";
-		return;
-	}
-	Id psdMesh = Field< Id >::get( psdD, "compartment" );
-	if ( !psdMesh.element()->cinfo()->isA( "PsdMesh" ) ) {
-		cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
-				psdMesh.path() << "' is not a PsdMesh\n";
-		return;
-	}
-
-	innerBuildMeshJunctions( spineD, e.id(), false );
-	innerBuildMeshJunctions( psdD, spineD, false );
+    if ( !compartment_.element()->cinfo()->isA( "NeuroMesh" ) )
+    {
+        cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
+             compartment_.path() << "' is not a NeuroMesh\n";
+        return;
+    }
+    Id spineMesh = Field< Id >::get( spineD, "compartment" );
+    if ( !spineMesh.element()->cinfo()->isA( "SpineMesh" ) )
+    {
+        cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
+             spineMesh.path() << "' is not a SpineMesh\n";
+        return;
+    }
+    Id psdMesh = Field< Id >::get( psdD, "compartment" );
+    if ( !psdMesh.element()->cinfo()->isA( "PsdMesh" ) )
+    {
+        cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
+             psdMesh.path() << "' is not a PsdMesh\n";
+        return;
+    }
+
+    innerBuildMeshJunctions( spineD, e.id(), false );
+    innerBuildMeshJunctions( psdD, spineD, false );
 }
 
 void Dsolve::buildMeshJunctions( const Eref& e, Id other )
 {
-	Id otherMesh;
-	if ( other.element()->cinfo()->isA( "Dsolve" ) ) {
-		otherMesh = Field< Id >::get( other, "compartment" );
-		if ( compartment_.element()->cinfo()->isA( "ChemCompt" ) &&
-			otherMesh.element()->cinfo()->isA( "ChemCompt" ) ) {
-				bool isMembraneBound = 
-					Field< bool >::get( compartment_, "isMembraneBound" );
-				innerBuildMeshJunctions( e.id(), other, isMembraneBound );
-				return;
-		}
-	}
-	cout << "Warning: Dsolve::buildMeshJunctions: one of '" <<
-		compartment_.path() << ", " << otherMesh.path() <<
-		"' is not a Mesh\n";
+    Id otherMesh;
+    if ( other.element()->cinfo()->isA( "Dsolve" ) )
+    {
+        otherMesh = Field< Id >::get( other, "compartment" );
+        if ( compartment_.element()->cinfo()->isA( "ChemCompt" ) &&
+                otherMesh.element()->cinfo()->isA( "ChemCompt" ) )
+        {
+            bool isMembraneBound =
+                Field< bool >::get( compartment_, "isMembraneBound" );
+            innerBuildMeshJunctions( e.id(), other, isMembraneBound );
+            return;
+        }
+    }
+    cout << "Warning: Dsolve::buildMeshJunctions: one of '" <<
+         compartment_.path() << ", " << otherMesh.path() <<
+         "' is not a Mesh\n";
 }
 
 void printJunction( Id self, Id other, const DiffJunction& jn )
 {
-	cout << "Junction between " << self.path() << ", " << other.path() << endl;
-	cout << "Pool indices: myPools, otherPools\n";
-	for ( unsigned int i = 0; i < jn.myPools.size(); ++i )
-		cout << i << "	" << jn.myPools[i] << "	" << jn.otherPools[i] << endl;
-	cout << "Voxel junctions: first	second	firstVol	secondVol	diffScale\n";
-	for ( unsigned int i = 0; i < jn.vj.size(); ++i ) {
-		cout << i << "	" << jn.vj[i].first << "	" << jn.vj[i].second <<
-		"	" << jn.vj[i].firstVol << "	" << jn.vj[i].secondVol <<
-			   "	" << jn.vj[i].diffScale <<	endl;
-	}
+    cout << "Junction between " << self.path() << ", " << other.path() << endl;
+    cout << "Pool indices: myPools, otherPools\n";
+    for ( unsigned int i = 0; i < jn.myPools.size(); ++i )
+        cout << i << "	" << jn.myPools[i] << "	" << jn.otherPools[i] << endl;
+    cout << "Voxel junctions: first	second	firstVol	secondVol	diffScale\n";
+    for ( unsigned int i = 0; i < jn.vj.size(); ++i )
+    {
+        cout << i << "	" << jn.vj[i].first << "	" << jn.vj[i].second <<
+             "	" << jn.vj[i].firstVol << "	" << jn.vj[i].secondVol <<
+             "	" << jn.vj[i].diffScale <<	endl;
+    }
 }
 
-void Dsolve::mapDiffPoolsBetweenDsolves( DiffJunction& jn, 
-				Id self, Id other)
+void Dsolve::mapDiffPoolsBetweenDsolves( DiffJunction& jn,
+        Id self, Id other)
 {
-	Dsolve* mySolve = reinterpret_cast< Dsolve* >( self.eref().data() );
-	unordered_map< string, unsigned int > myPools;
-	for ( unsigned int i = 0; i < mySolve->pools_.size(); ++i ) {
-			Id pool( mySolve->pools_[i].getId() );
-			assert( pool != Id() );
-			myPools[ pool.element()->getName() ] = i;
-	}
-
-	const Dsolve* otherSolve = reinterpret_cast< const Dsolve* >(
-					other.eref().data() );
-	for ( unsigned int i = 0; i < otherSolve->pools_.size(); ++i ) {
-		Id otherPool( otherSolve->pools_[i].getId() );
-		unordered_map< string, unsigned int >::iterator p =
-			myPools.find( otherPool.element()->getName() );
-		if ( p != myPools.end() ) {
-			jn.otherPools.push_back( i );
-			jn.myPools.push_back( p->second );
-		}
-	}
+    Dsolve* mySolve = reinterpret_cast< Dsolve* >( self.eref().data() );
+    unordered_map< string, unsigned int > myPools;
+    for ( unsigned int i = 0; i < mySolve->pools_.size(); ++i )
+    {
+        Id pool( mySolve->pools_[i].getId() );
+        assert( pool != Id() );
+        myPools[ pool.element()->getName() ] = i;
+    }
+
+    const Dsolve* otherSolve = reinterpret_cast< const Dsolve* >(
+                                   other.eref().data() );
+    for ( unsigned int i = 0; i < otherSolve->pools_.size(); ++i )
+    {
+        Id otherPool( otherSolve->pools_[i].getId() );
+        unordered_map< string, unsigned int >::iterator p =
+            myPools.find( otherPool.element()->getName() );
+        if ( p != myPools.end() )
+        {
+            jn.otherPools.push_back( i );
+            jn.myPools.push_back( p->second );
+        }
+    }
 }
 
-/** 
+/**
  * static void mapXfersBetweenDsolves(...)
  * Build a list of all the molecules that should transfer instantaneously
  * to another compartment, for cross-compartment reactions.
  * Here we look for src names of the form <name>_xfer_<destComptName>
- * For example, if we had an enzyme in compartment 'src', whose product 
- * should go to pool 'bar' in compartment 'dest', 
- * the name of the enzyme product in compartment src would be 
+ * For example, if we had an enzyme in compartment 'src', whose product
+ * should go to pool 'bar' in compartment 'dest',
+ * the name of the enzyme product in compartment src would be
  * 		bar_xfer_dest
  */
 void Dsolve::mapXfersBetweenDsolves(
-	vector< unsigned int >& srcPools, vector< unsigned int >& destPools, 
-	Id src, Id dest )
+    vector< unsigned int >& srcPools, vector< unsigned int >& destPools,
+    Id src, Id dest )
 {
-	Id destMesh = Field< Id >::get( dest, "compartment" );
-	string xferPost( string( "_xfer_" ) + destMesh.element()->getName() );
-	size_t xlen = xferPost.length();
-
-	Dsolve* srcSolve = reinterpret_cast< Dsolve* >( src.eref().data() );
-	unordered_map< string, unsigned int > srcMap;
-	for ( unsigned int i = 0; i < srcSolve->pools_.size(); ++i ) {
-			Id pool( srcSolve->pools_[i].getId() );
-			assert( pool != Id() );
-			string poolName = pool.element()->getName();
-			if ( poolName.length() > xlen ) {
-				size_t prefixLen = poolName.length() - xlen;
-				if ( poolName.rfind( xferPost ) == prefixLen )
-					srcMap[ poolName.substr( 0, prefixLen) ] = i;
-			}
-	}
-
-	const Dsolve* destSolve = reinterpret_cast< const Dsolve* >(
-					dest.eref().data() );
-	for ( unsigned int i = 0; i < destSolve->pools_.size(); ++i ) {
-		Id destPool( destSolve->pools_[i].getId() );
-		unordered_map< string, unsigned int >::iterator p =
-			srcMap.find( destPool.element()->getName() );
-		if ( p != srcMap.end() ) {
-			destPools.push_back( i );
-			srcPools.push_back( p->second );
-		}
-	}
+    Id destMesh = Field< Id >::get( dest, "compartment" );
+    string xferPost( string( "_xfer_" ) + destMesh.element()->getName() );
+    size_t xlen = xferPost.length();
+
+    Dsolve* srcSolve = reinterpret_cast< Dsolve* >( src.eref().data() );
+    unordered_map< string, unsigned int > srcMap;
+    for ( unsigned int i = 0; i < srcSolve->pools_.size(); ++i )
+    {
+        Id pool( srcSolve->pools_[i].getId() );
+        assert( pool != Id() );
+        string poolName = pool.element()->getName();
+        if ( poolName.length() > xlen )
+        {
+            size_t prefixLen = poolName.length() - xlen;
+            if ( poolName.rfind( xferPost ) == prefixLen )
+                srcMap[ poolName.substr( 0, prefixLen) ] = i;
+        }
+    }
+
+    const Dsolve* destSolve = reinterpret_cast< const Dsolve* >(
+                                  dest.eref().data() );
+    for ( unsigned int i = 0; i < destSolve->pools_.size(); ++i )
+    {
+        Id destPool( destSolve->pools_[i].getId() );
+        unordered_map< string, unsigned int >::iterator p =
+            srcMap.find( destPool.element()->getName() );
+        if ( p != srcMap.end() )
+        {
+            destPools.push_back( i );
+            srcPools.push_back( p->second );
+        }
+    }
 }
 
 void Dsolve::mapChansBetweenDsolves( DiffJunction& jn, Id self, Id other)
 {
-	Dsolve* otherSolve = reinterpret_cast< Dsolve* >(
-					other.eref().data() );
-	Dsolve* selfSolve = reinterpret_cast< Dsolve* >( self.eref().data() );
-	vector< ConcChanInfo >& ch = selfSolve->channels_;
-	unsigned int outIndex;
-	for ( unsigned int i = 0; i < ch.size(); ++i ) {
-		unsigned int chanIndex = ch[i].chanPool;
-		outIndex = otherSolve->convertIdToPoolIndex( ch[i].otherPool );
-		if ( (outIndex != ~0U) && (chanIndex != ~0U ) ) {
-			jn.myChannels.push_back(i);
-			ch[i].otherPool = outIndex;	// replace the Id with the index.
-			ch[i].chanPool = chanIndex; //chanIndex may be on either Dsolve
-		}
-	}
-	// Now set up the other Dsolve.
-	vector< ConcChanInfo >& ch2 = otherSolve->channels_;
-	for ( unsigned int i = 0; i < ch2.size(); ++i ) {
-		unsigned int chanIndex = ch2[i].chanPool;
-		outIndex = selfSolve->convertIdToPoolIndex( ch2[i].otherPool );
-		if ( (outIndex != ~0U) && (chanIndex != ~0U) ) {
-			jn.otherChannels.push_back(i);
-			ch2[i].otherPool = outIndex;  // replace the Id with the index
-			ch2[i].chanPool = chanIndex;  //chanIndex may be on either Dsolve
-		}
-	}
+    Dsolve* otherSolve = reinterpret_cast< Dsolve* >(
+                             other.eref().data() );
+    Dsolve* selfSolve = reinterpret_cast< Dsolve* >( self.eref().data() );
+    vector< ConcChanInfo >& ch = selfSolve->channels_;
+    unsigned int outIndex;
+    for ( unsigned int i = 0; i < ch.size(); ++i )
+    {
+        unsigned int chanIndex = ch[i].chanPool;
+        outIndex = otherSolve->convertIdToPoolIndex( ch[i].otherPool );
+        if ( (outIndex != ~0U) && (chanIndex != ~0U ) )
+        {
+            jn.myChannels.push_back(i);
+            ch[i].otherPool = outIndex;	// replace the Id with the index.
+            ch[i].chanPool = chanIndex; //chanIndex may be on either Dsolve
+        }
+    }
+    // Now set up the other Dsolve.
+    vector< ConcChanInfo >& ch2 = otherSolve->channels_;
+    for ( unsigned int i = 0; i < ch2.size(); ++i )
+    {
+        unsigned int chanIndex = ch2[i].chanPool;
+        outIndex = selfSolve->convertIdToPoolIndex( ch2[i].otherPool );
+        if ( (outIndex != ~0U) && (chanIndex != ~0U) )
+        {
+            jn.otherChannels.push_back(i);
+            ch2[i].otherPool = outIndex;  // replace the Id with the index
+            ch2[i].chanPool = chanIndex;  //chanIndex may be on either Dsolve
+        }
+    }
 }
 
 static void mapVoxelsBetweenMeshes( DiffJunction& jn, Id self, Id other)
 {
-	Id myMesh = Field< Id >::get( self, "compartment" );
-	Id otherMesh = Field< Id >::get( other, "compartment" );
-
-	const ChemCompt* myCompt = reinterpret_cast< const ChemCompt* >(
-					myMesh.eref().data() );
-	const ChemCompt* otherCompt = reinterpret_cast< const ChemCompt* >(
-					otherMesh.eref().data() );
-	myCompt->matchMeshEntries( otherCompt, jn.vj );
-	vector< double > myVols = myCompt->getVoxelVolume();
-	vector< double > otherVols = otherCompt->getVoxelVolume();
-	for ( vector< VoxelJunction >::iterator
-		i = jn.vj.begin(); i != jn.vj.end(); ++i ) {
-		i->firstVol = myVols[i->first];
-		i->secondVol = otherVols[i->second];
-	}
+    Id myMesh = Field< Id >::get( self, "compartment" );
+    Id otherMesh = Field< Id >::get( other, "compartment" );
+
+    const ChemCompt* myCompt = reinterpret_cast< const ChemCompt* >(
+                                   myMesh.eref().data() );
+    const ChemCompt* otherCompt = reinterpret_cast< const ChemCompt* >(
+                                      otherMesh.eref().data() );
+    myCompt->matchMeshEntries( otherCompt, jn.vj );
+    vector< double > myVols = myCompt->getVoxelVolume();
+    vector< double > otherVols = otherCompt->getVoxelVolume();
+    for ( vector< VoxelJunction >::iterator
+            i = jn.vj.begin(); i != jn.vj.end(); ++i )
+    {
+        i->firstVol = myVols[i->first];
+        i->secondVol = otherVols[i->second];
+    }
 }
 
 // Static utility func for building junctions
 void Dsolve::innerBuildMeshJunctions( Id self, Id other, bool selfIsMembraneBound )
 {
-	DiffJunction jn; // This is based on the Spine Dsolver.
-	jn.otherDsolve = other.value();
-	Dsolve* dself = reinterpret_cast< Dsolve* >( self.eref().data() );
-	if ( selfIsMembraneBound ) {
-		mapChansBetweenDsolves( jn, self, other );
-	} else {
-		mapDiffPoolsBetweenDsolves( jn, self, other );
-	}
-	mapXfersBetweenDsolves( jn.myXferSrc, jn.otherXferDest, self, other );
-	mapXfersBetweenDsolves( jn.otherXferSrc, jn.myXferDest, other, self );
-
-	mapVoxelsBetweenMeshes( jn, self, other );
-
-
-	// printJunction( self, other, jn );
-	dself->junctions_.push_back( jn );
+    DiffJunction jn; // This is based on the Spine Dsolver.
+    jn.otherDsolve = other.value();
+    Dsolve* dself = reinterpret_cast< Dsolve* >( self.eref().data() );
+    if ( selfIsMembraneBound )
+    {
+        mapChansBetweenDsolves( jn, self, other );
+    }
+    else
+    {
+        mapDiffPoolsBetweenDsolves( jn, self, other );
+    }
+    mapXfersBetweenDsolves( jn.myXferSrc, jn.otherXferDest, self, other );
+    mapXfersBetweenDsolves( jn.otherXferSrc, jn.myXferDest, other, self );
+
+    mapVoxelsBetweenMeshes( jn, self, other );
+
+
+    // printJunction( self, other, jn );
+    dself->junctions_.push_back( jn );
 }
 
 /////////////////////////////////////////////////////////////
@@ -964,191 +1043,202 @@ void Dsolve::innerBuildMeshJunctions( Id self, Id other, bool selfIsMembraneBoun
 //
 unsigned int Dsolve::getNumVarPools() const
 {
-	return 0;
+    return 0;
 }
 
 unsigned int Dsolve::getNumVoxels() const
 {
-	return numVoxels_;
+    return numVoxels_;
 }
 
 void Dsolve::setNumAllVoxels( unsigned int num )
 {
-	numVoxels_ = num;
-	for ( unsigned int i = 0 ; i < numLocalPools_; ++i )
-		pools_[i].setNumVoxels( numVoxels_ );
+    numVoxels_ = num;
+    for ( unsigned int i = 0 ; i < numLocalPools_; ++i )
+        pools_[i].setNumVoxels( numVoxels_ );
 }
 
 unsigned int Dsolve::convertIdToPoolIndex( const Id id ) const
 {
-	unsigned int i  = id.value() - poolMapStart_;
-	if ( i < poolMap_.size() ) {
-		return poolMap_[i];
-	}
-	cout << "Warning: Dsolve::convertIdToPoollndex: Id out of range, (" <<
-		poolMapStart_ << ", " << id << ", " << id.path() << ", " <<
-		poolMap_.size() + poolMapStart_ << "\n";
-	return 0;
+    unsigned int i  = id.value() - poolMapStart_;
+    if ( i < poolMap_.size() )
+    {
+        return poolMap_[i];
+    }
+    cout << "Warning: Dsolve::convertIdToPoollndex: Id out of range, (" <<
+         poolMapStart_ << ", " << id << ", " << id.path() << ", " <<
+         poolMap_.size() + poolMapStart_ << "\n";
+    return 0;
 }
 
 unsigned int Dsolve::convertIdToPoolIndex( const Eref& e ) const
 {
-	return convertIdToPoolIndex( e.id() );
+    return convertIdToPoolIndex( e.id() );
 }
 
 void Dsolve::setN( const Eref& e, double v )
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	// Ignore silently, as this may be a valid pid for the ksolve to use.
-	if ( pid >= pools_.size() )
-		return;
-	unsigned int vox = e.dataIndex();
-	if ( vox < numVoxels_ ) {
-		pools_[ pid ].setN( vox, v );
-		return;
-	}
-	cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
-			pools_.size() << ", " << numVoxels_ << "\n";
+    unsigned int pid = convertIdToPoolIndex( e );
+    // Ignore silently, as this may be a valid pid for the ksolve to use.
+    if ( pid >= pools_.size() )
+        return;
+    unsigned int vox = e.dataIndex();
+    if ( vox < numVoxels_ )
+    {
+        pools_[ pid ].setN( vox, v );
+        return;
+    }
+    cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
+         pools_.size() << ", " << numVoxels_ << "\n";
 }
 
 double Dsolve::getN( const Eref& e ) const
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() ) return 0.0; // ignore silently
-	unsigned int vox = e.dataIndex();
-	if ( vox <  numVoxels_ ) {
-		return pools_[ pid ].getN( vox );
-	}
-	cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
-			pools_.size() << ", " << numVoxels_ << "\n";
-	return 0.0;
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() ) return 0.0; // ignore silently
+    unsigned int vox = e.dataIndex();
+    if ( vox <  numVoxels_ )
+    {
+        return pools_[ pid ].getN( vox );
+    }
+    cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
+         pools_.size() << ", " << numVoxels_ << "\n";
+    return 0.0;
 }
 
 void Dsolve::setNinit( const Eref& e, double v )
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() )  // Ignore silently
-		return;
-	unsigned int vox = e.dataIndex();
-	if ( vox < numVoxels_ ) {
-		pools_[ pid ].setNinit( vox, v );
-		return;
-	}
-	cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
-			pools_.size() << ", " << numVoxels_ << "\n";
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() )  // Ignore silently
+        return;
+    unsigned int vox = e.dataIndex();
+    if ( vox < numVoxels_ )
+    {
+        pools_[ pid ].setNinit( vox, v );
+        return;
+    }
+    cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
+         pools_.size() << ", " << numVoxels_ << "\n";
 }
 
 double Dsolve::getNinit( const Eref& e ) const
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() ) return 0.0; // ignore silently
-	unsigned int vox = e.dataIndex();
-	if ( vox < numVoxels_ ) {
-		return pools_[ pid ].getNinit( vox );
-	}
-	cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
-			pools_.size() << ", " << numVoxels_ << "\n";
-	return 0.0;
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() ) return 0.0; // ignore silently
+    unsigned int vox = e.dataIndex();
+    if ( vox < numVoxels_ )
+    {
+        return pools_[ pid ].getNinit( vox );
+    }
+    cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
+         pools_.size() << ", " << numVoxels_ << "\n";
+    return 0.0;
 }
 
 void Dsolve::setDiffConst( const Eref& e, double v )
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() )   // Ignore silently, out of range.
-		return;
-	pools_[ convertIdToPoolIndex( e ) ].setDiffConst( v );
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() )   // Ignore silently, out of range.
+        return;
+    pools_[ convertIdToPoolIndex( e ) ].setDiffConst( v );
 }
 
 double Dsolve::getDiffConst( const Eref& e ) const
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() )   // Ignore silently, out of range.
-		return 0.0;
-	return pools_[ convertIdToPoolIndex( e ) ].getDiffConst();
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() )   // Ignore silently, out of range.
+        return 0.0;
+    return pools_[ convertIdToPoolIndex( e ) ].getDiffConst();
 }
 
 void Dsolve::setMotorConst( const Eref& e, double v )
 {
-	unsigned int pid = convertIdToPoolIndex( e );
-	if ( pid >= pools_.size() )   // Ignore silently, out of range.
-		return;
-	pools_[ convertIdToPoolIndex( e ) ].setMotorConst( v );
+    unsigned int pid = convertIdToPoolIndex( e );
+    if ( pid >= pools_.size() )   // Ignore silently, out of range.
+        return;
+    pools_[ convertIdToPoolIndex( e ) ].setMotorConst( v );
 }
 
 void Dsolve::setNumPools( unsigned int numPoolSpecies )
 {
-	// Decompose numPoolSpecies here, assigning some to each node.
-	numTotPools_ = numPoolSpecies;
-	numLocalPools_ = numPoolSpecies;
-	poolStartIndex_ = 0;
-
-	pools_.resize( numLocalPools_ );
-	for ( unsigned int i = 0 ; i < numLocalPools_; ++i ) {
-		pools_[i].setNumVoxels( numVoxels_ );
-		// pools_[i].setId( reversePoolMap_[i] );
-		// pools_[i].setParent( me );
-	}
+    // Decompose numPoolSpecies here, assigning some to each node.
+    numTotPools_ = numPoolSpecies;
+    numLocalPools_ = numPoolSpecies;
+    poolStartIndex_ = 0;
+
+    pools_.resize( numLocalPools_ );
+    for ( unsigned int i = 0 ; i < numLocalPools_; ++i )
+    {
+        pools_[i].setNumVoxels( numVoxels_ );
+        // pools_[i].setId( reversePoolMap_[i] );
+        // pools_[i].setParent( me );
+    }
 }
 
 unsigned int Dsolve::getNumPools() const
 {
-	return numTotPools_;
+    return numTotPools_;
 }
 
 // July 2014: This is half-baked wrt the startPool.
 void Dsolve::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 + numVoxels <= numVoxels_ );
-	assert( startPool >= poolStartIndex_ );
-	assert( numPools + startPool <= numLocalPools_ );
-	values.resize( 4 );
-
-	for ( unsigned int i = 0; i < numPools; ++i ) {
-		unsigned int j = i + startPool;
-		if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ ){
-			vector< double >::const_iterator q =
-				pools_[ j - poolStartIndex_ ].getNvec().begin();
-
-			values.insert( values.end(),
-				q + startVoxel, q + startVoxel + numVoxels );
-		}
-	}
+    unsigned int startVoxel = values[0];
+    unsigned int numVoxels = values[1];
+    unsigned int startPool = values[2];
+    unsigned int numPools = values[3];
+
+    assert( startVoxel + numVoxels <= numVoxels_ );
+    assert( startPool >= poolStartIndex_ );
+    assert( numPools + startPool <= numLocalPools_ );
+    values.resize( 4 );
+
+    for ( unsigned int i = 0; i < numPools; ++i )
+    {
+        unsigned int j = i + startPool;
+        if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ )
+        {
+            vector< double >::const_iterator q =
+                pools_[ j - poolStartIndex_ ].getNvec().begin();
+
+            values.insert( values.end(),
+                           q + startVoxel, q + startVoxel + numVoxels );
+        }
+    }
 }
 
 // Inefficient but easy to set up. Optimize later.
 void Dsolve::setPrev()
 {
-	for ( auto i = pools_.begin(); i != pools_.end(); ++i ) {
-		// if (i->getDiffConst() > 0.0 )
-			i->setPrevVec();
-	}
+    for ( auto i = pools_.begin(); i != pools_.end(); ++i )
+    {
+        // if (i->getDiffConst() > 0.0 )
+        i->setPrevVec();
+    }
 }
 
 void Dsolve::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 + numVoxels <= numVoxels_ );
-	assert( startPool >= poolStartIndex_ );
-	assert( numPools + startPool <= numLocalPools_ );
-	assert( values.size() == 4 + numVoxels * numPools );
-
-	for ( unsigned int i = 0; i < numPools; ++i ) {
-		unsigned int j = i + startPool;
-		if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ ){
-			vector< double >::const_iterator
-				q = values.begin() + 4 + i * numVoxels;
-			pools_[ j - poolStartIndex_ ].setNvec( startVoxel, numVoxels, q );
-		}
-	}
+    unsigned int startVoxel = values[0];
+    unsigned int numVoxels = values[1];
+    unsigned int startPool = values[2];
+    unsigned int numPools = values[3];
+
+    assert( startVoxel + numVoxels <= numVoxels_ );
+    assert( startPool >= poolStartIndex_ );
+    assert( numPools + startPool <= numLocalPools_ );
+    assert( values.size() == 4 + numVoxels * numPools );
+
+    for ( unsigned int i = 0; i < numPools; ++i )
+    {
+        unsigned int j = i + startPool;
+        if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ )
+        {
+            vector< double >::const_iterator
+            q = values.begin() + 4 + i * numVoxels;
+            pools_[ j - poolStartIndex_ ].setNvec( startVoxel, numVoxels, q );
+        }
+    }
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -1156,25 +1246,25 @@ void Dsolve::setBlock( const vector< double >& values )
 
 void Dsolve::updateRateTerms( unsigned int index )
 {
-	;
+    ;
 }
 
 unsigned int Dsolve::getPoolIndex( const Eref& e ) const
 {
-	return convertIdToPoolIndex( e );
+    return convertIdToPoolIndex( e );
 }
 
 unsigned int Dsolve::getNumLocalVoxels() const
 {
-	return numVoxels_;
+    return numVoxels_;
 }
 
 VoxelPoolsBase* Dsolve::pools( unsigned int i )
 {
-	return 0;
+    return 0;
 }
 
 double Dsolve::volume( unsigned int i ) const
 {
-	return 1.0;
+    return 1.0;
 }
diff --git a/diffusion/Dsolve.h b/diffusion/Dsolve.h
index b8197ef4bb300255584c63346db7db02fb1591e6..dc013d3ceae42928bce6636da7a5c4826e9325c3 100644
--- a/diffusion/Dsolve.h
+++ b/diffusion/Dsolve.h
@@ -28,198 +28,202 @@
  */
 class Dsolve: public ZombiePoolInterface
 {
-	public:
-		Dsolve();
-		~Dsolve();
-
-		//////////////////////////////////////////////////////////////////
-		// Field assignment stuff
-		//////////////////////////////////////////////////////////////////
-		unsigned int getNumVarPools() const;
-
-		void setStoich( Id id );
-		Id getStoich() const;
-		void setCompartment( Id id );
-		// Defined in base class. Id getCompartment() const;
-		void setDsolve( Id id ); /// Dummy, inherited but not used.
-
-		void setPath( const Eref& e, string path );
-		string getPath( const Eref& e ) const;
-
-		unsigned int getNumVoxels() const;
-		/// Inherited virtual.
-		void setNumAllVoxels( unsigned int numVoxels );
-
-		vector< double > getNvec( unsigned int pool ) const;
-		void setNvec( unsigned int pool, vector< double > vec );
-
-		/// LookupFied for examining cross-solver diffusion terms.
-		double getDiffVol1( unsigned int voxel ) const;
-		void setDiffVol1( unsigned int voxel, double vol );
-		double getDiffVol2( unsigned int voxel ) const;
-		void setDiffVol2( unsigned int voxel, double vol );
-		double getDiffScale( unsigned int voxel ) const;
-		void setDiffScale( unsigned int voxel, double scale );
-
-		//////////////////////////////////////////////////////////////////
-		// Dest Finfos
-		//////////////////////////////////////////////////////////////////
-		void process( const Eref& e, ProcPtr p );
-		void reinit( const Eref& e, ProcPtr p );
-
-		//////////////////////////////////////////////////////////////////
-		void updateJunctions( double dt );
-
-		/**
-		 * Builds junctions between Dsolves handling NeuroMesh, SpineMesh,
-		 * and PsdMesh. Must only be called from the one handling the
-		 * NeuroMesh.
-		 * These junctions handle diffusion between different meshes.
-		 * Note that a single NeuroMesh may contact many spines which are
-		 * all in a single SpineMesh. Likewise each spine has a single
-		 * PSD, but there are many spines in the SpineMesh and matching
-		 * psds in the PsdMesh. Finally, note that
-		 * there may be many molecules which diffuse across each diffusion
-		 * junction.
-		 */
-		void buildNeuroMeshJunctions( const Eref& e, Id spineD, Id psdD );
-
-		/**
-		 * Builds junctions between current Dsolve and another. For this
-		 * to work the respective meshes must be compatible.
-		 * These junctions handle diffusion between different meshes.
-		 */
-		void buildMeshJunctions( const Eref& e, Id other );
-
-		/**
-		 * buildMeshJunctions is the inner utility function for building
-		 * the junction between any specified pair of Dsolves.
-		 * Note that it builds the junction on the 'self' Dsolve.
-		 */
-		static void innerBuildMeshJunctions( Id self, Id other, 
-						bool isMembraneBound );
-
-		/// Sets up map of matching pools for diffusion.
-		static void mapDiffPoolsBetweenDsolves( DiffJunction& jn, 
-						Id self, Id other);
-
-		static void mapXfersBetweenDsolves(
-						vector< unsigned int >& srcPools, 
-						vector< unsigned int >& destPools,
-						Id src, Id dest );
-		static void mapChansBetweenDsolves( DiffJunction& jn, 
-						Id self, Id other);
-
-		/**
-		 * Computes flux through a junction between diffusion solvers.
-		 * Most used at junctions on spines and PSDs, but can also be used
-		 * when a given diff solver is decomposed. At present the lookups
-		 * on the other diffusion solver assume that the data is on the
-		 * local node. Once this works well I can figure out how to do
-		 * across nodes.
-		 */
-		void calcJunction( const DiffJunction& jn, double dt );
-		//////////////////////////////////////////////////////////////////
-		// Inherited virtual funcs from ZombiePoolInterface
-		//////////////////////////////////////////////////////////////////
-		double getNinit( const Eref& e ) const;
-		void setNinit( const Eref& e, double value );
-		double getN( const Eref& e ) const;
-		void setN( const Eref& e, double value );
-		double getDiffConst( const Eref& e ) const;
-		void setDiffConst( const Eref& e, double value );
-		void setMotorConst( const Eref& e, double value );
-
-		void setNumPools( unsigned int num );
-		unsigned int getNumPools() const;
-		unsigned int getNumLocalVoxels() const;
-		VoxelPoolsBase* pools( unsigned int i );
-		double volume( unsigned int i ) const;
-
-		void getBlock( vector< double >& values ) const;
-		void setBlock( const vector< double >& values );
-		void setPrev();
-
-		// This one isn't used in Dsolve, but is defined as a dummy.
-		void setupCrossSolverReacs(
-					const map< Id, vector< Id > >& xr, Id otherStoich );
-		void setupCrossSolverReacVols(
-			const vector< vector< Id > >& subCompts,
-			const vector< vector< Id > >& prdCompts );
-		void filterCrossRateTerms( const vector< pair< Id, Id > >& xrt );
-
-		// Do any updates following a volume or rate constant change.
-		void updateRateTerms( unsigned int index );
-		//////////////////////////////////////////////////////////////////
-		// Model traversal and building functions
-		//////////////////////////////////////////////////////////////////
-		unsigned int convertIdToPoolIndex( Id id ) const;
-		unsigned int convertIdToPoolIndex( const Eref& e ) const;
-		unsigned int getPoolIndex( const Eref& e ) const;
-
-		/**
-		 * Fills in poolMap_ using elist of objects found when the
-		 * 'setPath' function is executed. temp is returned with the
-		 * list of PoolBase objects that exist on the path.
-		 */
-		void makePoolMapFromElist( const vector< ObjId >& elist,
-						vector< Id >& temp );
-
-		/**
-		 * This key function does the work of setting up the Dsolve.
-		 * Should be called after the compartment has been attached to
-		 * the Dsolve, and the stoich is assigned.
-		 * Called during the setStoich function.
-		 */
-		void build( double dt );
-		void rebuildPools();
-		void calcJnDiff( const DiffJunction& jn, Dsolve* other, double dt );
-		void calcJnXfer( const DiffJunction& jn, 
-						const vector< unsigned int >& srcXfer, 
-						const vector< unsigned int >& destXfer, 
-						Dsolve* srcDsolve, Dsolve* destDsolve );
-		void calcJnChan( const DiffJunction& jn, Dsolve* other, double dt );
-		void calcOtherJnChan( const DiffJunction& jn, Dsolve* other, 
-						double dt );
-		void fillConcChans( const vector< ObjId >& chans );
-
-		/**
-		 * Utility func for debugging: Prints N_ matrix
-		 */
-		void print() const;
-
-		//////////////////////////////////////////////////////////////////
-		static const Cinfo* initCinfo();
-	private:
-
-		/// Path of pools managed by Dsolve, may include other classes too.
-		string path_;
-
-		/// Timestep used by diffusion calculations.
-		double dt_;
-
-		unsigned int numTotPools_;
-		unsigned int numLocalPools_;
-		unsigned int poolStartIndex_;
-		unsigned int numVoxels_;
-
-		/// Internal vector, one for each pool species managed by Dsolve.
-		vector< DiffPoolVec > pools_;
-		/// Internal vector, one for each ConcChan managed by Dsolve.
-		vector< ConcChanInfo > channels_;
-
-		/// smallest Id value for poolMap_
-		unsigned int poolMapStart_;
-
-		/// Looks up pool# from pool Id, using poolMapStart_ as offset.
-		vector< unsigned int > poolMap_;
-
-		/**
-		 * Lists all the diffusion junctions managed by this Dsolve.
-		 * Each junction entry provides the info needed to do the
-		 * numerical integration for flux between the Dsolves.
-		 */
-		vector< DiffJunction > junctions_;
+public:
+    Dsolve();
+    ~Dsolve();
+
+    //////////////////////////////////////////////////////////////////
+    // Field assignment stuff
+    //////////////////////////////////////////////////////////////////
+    unsigned int getNumVarPools() const;
+
+    void setStoich( Id id );
+    Id getStoich() const;
+    void setCompartment( Id id );
+    // Defined in base class. Id getCompartment() const;
+    void setDsolve( Id id ); /// Dummy, inherited but not used.
+
+    void setPath( const Eref& e, string path );
+    string getPath( const Eref& e ) const;
+
+    unsigned int getNumVoxels() const;
+    /// Inherited virtual.
+    void setNumAllVoxels( unsigned int numVoxels );
+
+    vector< double > getNvec( unsigned int pool ) const;
+    void setNvec( unsigned int pool, vector< double > vec );
+
+    /// LookupFied for examining cross-solver diffusion terms.
+    double getDiffVol1( unsigned int voxel ) const;
+    void setDiffVol1( unsigned int voxel, double vol );
+    double getDiffVol2( unsigned int voxel ) const;
+    void setDiffVol2( unsigned int voxel, double vol );
+    double getDiffScale( unsigned int voxel ) const;
+    void setDiffScale( unsigned int voxel, double scale );
+
+    //////////////////////////////////////////////////////////////////
+    // Dest Finfos
+    //////////////////////////////////////////////////////////////////
+    void process( const Eref& e, ProcPtr p );
+    void reinit( const Eref& e, ProcPtr p );
+
+    //////////////////////////////////////////////////////////////////
+    void updateJunctions( double dt );
+
+    /**
+     * Builds junctions between Dsolves handling NeuroMesh, SpineMesh,
+     * and PsdMesh. Must only be called from the one handling the
+     * NeuroMesh.
+     * These junctions handle diffusion between different meshes.
+     * Note that a single NeuroMesh may contact many spines which are
+     * all in a single SpineMesh. Likewise each spine has a single
+     * PSD, but there are many spines in the SpineMesh and matching
+     * psds in the PsdMesh. Finally, note that
+     * there may be many molecules which diffuse across each diffusion
+     * junction.
+     */
+    void buildNeuroMeshJunctions( const Eref& e, Id spineD, Id psdD );
+
+    /**
+     * Builds junctions between current Dsolve and another. For this
+     * to work the respective meshes must be compatible.
+     * These junctions handle diffusion between different meshes.
+     */
+    void buildMeshJunctions( const Eref& e, Id other );
+
+    /**
+     * buildMeshJunctions is the inner utility function for building
+     * the junction between any specified pair of Dsolves.
+     * Note that it builds the junction on the 'self' Dsolve.
+     */
+    static void innerBuildMeshJunctions( Id self, Id other,
+                                         bool isMembraneBound );
+
+    /// Sets up map of matching pools for diffusion.
+    static void mapDiffPoolsBetweenDsolves( DiffJunction& jn,
+                                            Id self, Id other);
+
+    static void mapXfersBetweenDsolves(
+        vector< unsigned int >& srcPools,
+        vector< unsigned int >& destPools,
+        Id src, Id dest );
+    static void mapChansBetweenDsolves( DiffJunction& jn,
+                                        Id self, Id other);
+
+    /**
+     * Computes flux through a junction between diffusion solvers.
+     * Most used at junctions on spines and PSDs, but can also be used
+     * when a given diff solver is decomposed. At present the lookups
+     * on the other diffusion solver assume that the data is on the
+     * local node. Once this works well I can figure out how to do
+     * across nodes.
+     */
+    void calcJunction( const DiffJunction& jn, double dt );
+    
+    /* Multithreaded version */
+    void calcJunction_chunk( const size_t begin, const size_t end, double dt );
+
+    //////////////////////////////////////////////////////////////////
+    // Inherited virtual funcs from ZombiePoolInterface
+    //////////////////////////////////////////////////////////////////
+    double getNinit( const Eref& e ) const;
+    void setNinit( const Eref& e, double value );
+    double getN( const Eref& e ) const;
+    void setN( const Eref& e, double value );
+    double getDiffConst( const Eref& e ) const;
+    void setDiffConst( const Eref& e, double value );
+    void setMotorConst( const Eref& e, double value );
+
+    void setNumPools( unsigned int num );
+    unsigned int getNumPools() const;
+    unsigned int getNumLocalVoxels() const;
+    VoxelPoolsBase* pools( unsigned int i );
+    double volume( unsigned int i ) const;
+
+    void getBlock( vector< double >& values ) const;
+    void setBlock( const vector< double >& values );
+    void setPrev();
+
+    // This one isn't used in Dsolve, but is defined as a dummy.
+    void setupCrossSolverReacs(
+        const map< Id, vector< Id > >& xr, Id otherStoich );
+    void setupCrossSolverReacVols(
+        const vector< vector< Id > >& subCompts,
+        const vector< vector< Id > >& prdCompts );
+    void filterCrossRateTerms( const vector< pair< Id, Id > >& xrt );
+
+    // Do any updates following a volume or rate constant change.
+    void updateRateTerms( unsigned int index );
+    //////////////////////////////////////////////////////////////////
+    // Model traversal and building functions
+    //////////////////////////////////////////////////////////////////
+    unsigned int convertIdToPoolIndex( Id id ) const;
+    unsigned int convertIdToPoolIndex( const Eref& e ) const;
+    unsigned int getPoolIndex( const Eref& e ) const;
+
+    /**
+     * Fills in poolMap_ using elist of objects found when the
+     * 'setPath' function is executed. temp is returned with the
+     * list of PoolBase objects that exist on the path.
+     */
+    void makePoolMapFromElist( const vector< ObjId >& elist,
+                               vector< Id >& temp );
+
+    /**
+     * This key function does the work of setting up the Dsolve.
+     * Should be called after the compartment has been attached to
+     * the Dsolve, and the stoich is assigned.
+     * Called during the setStoich function.
+     */
+    void build( double dt );
+    void rebuildPools();
+    void calcJnDiff( const DiffJunction& jn, Dsolve* other, double dt );
+    void calcJnXfer( const DiffJunction& jn,
+                     const vector< unsigned int >& srcXfer,
+                     const vector< unsigned int >& destXfer,
+                     Dsolve* srcDsolve, Dsolve* destDsolve );
+    void calcJnChan( const DiffJunction& jn, Dsolve* other, double dt );
+    void calcOtherJnChan( const DiffJunction& jn, Dsolve* other,
+                          double dt );
+    void fillConcChans( const vector< ObjId >& chans );
+
+    /**
+     * Utility func for debugging: Prints N_ matrix
+     */
+    void print() const;
+
+    //////////////////////////////////////////////////////////////////
+    static const Cinfo* initCinfo();
+private:
+
+    /// Path of pools managed by Dsolve, may include other classes too.
+    string path_;
+
+    /// Timestep used by diffusion calculations.
+    double dt_;
+
+    unsigned int numTotPools_;
+    unsigned int numLocalPools_;
+    unsigned int poolStartIndex_;
+    unsigned int numVoxels_;
+
+    /// Internal vector, one for each pool species managed by Dsolve.
+    vector< DiffPoolVec > pools_;
+    /// Internal vector, one for each ConcChan managed by Dsolve.
+    vector< ConcChanInfo > channels_;
+
+    /// smallest Id value for poolMap_
+    unsigned int poolMapStart_;
+
+    /// Looks up pool# from pool Id, using poolMapStart_ as offset.
+    vector< unsigned int > poolMap_;
+
+    /**
+     * Lists all the diffusion junctions managed by this Dsolve.
+     * Each junction entry provides the info needed to do the
+     * numerical integration for flux between the Dsolves.
+     */
+    vector< DiffJunction > junctions_;
 };
 
 
diff --git a/external/muparser/include/muParserBase.h b/external/muparser/include/muParserBase.h
index 774330cce8fc914920b754846fb141d574e7858a..e7cfa6ae5bd341d703267908dff27ce17e8ae746 100644
--- a/external/muparser/include/muParserBase.h
+++ b/external/muparser/include/muParserBase.h
@@ -288,7 +288,7 @@ private:
     mutable stringbuf_type  m_vStringBuf; ///< String buffer, used for storing string function arguments
     stringbuf_type  m_vStringVarBuf;
 
-    std::unique_ptr<token_reader_type> m_pTokenReader; ///< Managed pointer to the token reader object.
+    std::shared_ptr<token_reader_type> m_pTokenReader; ///< Managed pointer to the token reader object.
 
     funmap_type  m_FunDef;         ///< Map of function names and pointers.
     funmap_type  m_PostOprtDef;    ///< Postfix operator callbacks
diff --git a/hsolve/HSolve.cpp b/hsolve/HSolve.cpp
index e4b9b0e74091ae27a2763d93dc604edecd682100..7f3cc36b0481effeef6071917d0b22e21f69e97f 100644
--- a/hsolve/HSolve.cpp
+++ b/hsolve/HSolve.cpp
@@ -7,7 +7,8 @@
 ** See the file COPYING.LIB for the full notice.
 **********************************************************************/
 
-#include "header.h"
+#include "../basecode/header.h"
+#include "../basecode/global.h"
 #include "ElementValueFinfo.h"
 #include "HSolveStruct.h"
 #include "HinesMatrix.h"
@@ -27,6 +28,12 @@
 #include "ZombieHHChannel.h"
 #include "../shell/Shell.h"
 
+#include <chrono>
+using namespace std::chrono;
+
+// defined in global.h 
+extern map<string, double> solverProfMap;
+
 const Cinfo* HSolve::initCinfo()
 {
     static DestFinfo process(
@@ -190,12 +197,20 @@ static const Cinfo* hsolveCinfo = HSolve::initCinfo();
 HSolve::HSolve()
     : dt_( 50e-6 )
 {
-    ;
 }
 
 HSolve::~HSolve()
 {
     unzombify();
+#if 0
+    char* p = getenv( "MOOSE_SHOW_SOLVER_PERF" );
+    if( p != NULL )
+    {
+        cout << "Info: HSolve took " << totalTime_ << " seconds and took " << numSteps_
+             << " steps." << endl;
+
+    }
+#endif
 }
 
 
@@ -205,7 +220,10 @@ HSolve::~HSolve()
 
 void HSolve::process( const Eref& hsolve, ProcPtr p )
 {
+    t0_ = high_resolution_clock::now();
     this->HSolveActive::step( p );
+    t1_ = high_resolution_clock::now();
+    addSolverProf( "HSolve", duration_cast<duration<double>>(t1_ - t0_).count(), 1 );
 }
 
 void HSolve::reinit( const Eref& hsolve, ProcPtr p )
diff --git a/hsolve/HSolve.h b/hsolve/HSolve.h
index 56c15d2dc712371a5f0ac3003a9b0cc0ff3a1bcb..48317cee7b33eaeb24507d4f47170205f61422af 100644
--- a/hsolve/HSolve.h
+++ b/hsolve/HSolve.h
@@ -9,166 +9,173 @@
 
 #ifndef _HSOLVE_H
 #define _HSOLVE_H
+
 #include <set>
+#include <chrono>
+using namespace std::chrono;
+
 /**
  * HSolve adapts the integrator HSolveActive into a MOOSE class.
  */
 class HSolve: public HSolveActive
 {
 public:
-	HSolve();
-	~HSolve();
+    HSolve();
+    ~HSolve();
 
-	void process( const Eref& hsolve, ProcPtr p );
-	void reinit( const Eref& hsolve, ProcPtr p );
+    void process( const Eref& hsolve, ProcPtr p );
+    void reinit( const Eref& hsolve, ProcPtr p );
 
-	void setSeed( Id seed );
-	Id getSeed() const; 		/**< For searching for compartments:
+    void setSeed( Id seed );
+    Id getSeed() const; 		/**< For searching for compartments:
 								 *   seed is the starting compt.     */
 
-	void setPath( const Eref& e, string path );
-	string getPath( const Eref& e ) const;
-								/**< Path to the compartments */
+    void setPath( const Eref& e, string path );
+    string getPath( const Eref& e ) const;
+    /**< Path to the compartments */
 
-	void setDt( double dt );
-	double getDt() const;
+    void setDt( double dt );
+    double getDt() const;
 
-	void setCaAdvance( int caAdvance );
-	int getCaAdvance() const;
+    void setCaAdvance( int caAdvance );
+    int getCaAdvance() const;
 
-	void setVDiv( int vDiv );
-	int getVDiv() const;
+    void setVDiv( int vDiv );
+    int getVDiv() const;
 
-	void setVMin( double vMin );
-	double getVMin() const;
+    void setVMin( double vMin );
+    double getVMin() const;
 
-	void setVMax( double vMax );
-	double getVMax() const;
+    void setVMax( double vMax );
+    double getVMax() const;
 
-	void setCaDiv( int caDiv );
-	int getCaDiv() const;
+    void setCaDiv( int caDiv );
+    int getCaDiv() const;
 
-	void setCaMin( double caMin );
-	double getCaMin() const;
+    void setCaMin( double caMin );
+    double getCaMin() const;
 
-	void setCaMax( double caMax );
-	double getCaMax() const;
+    void setCaMax( double caMax );
+    double getCaMax() const;
 
-	// Interface functions defined in HSolveInterface.cpp
-	double getInitVm( Id id ) const;
-	void setInitVm( Id id, double value );
+    // Interface functions defined in HSolveInterface.cpp
+    double getInitVm( Id id ) const;
+    void setInitVm( Id id, double value );
 
-	double getVm( Id id ) const;
-	void setVm( Id id, double value );
+    double getVm( Id id ) const;
+    void setVm( Id id, double value );
 
-	double getCm( Id id ) const;
-	void setCm( Id id, double value );
+    double getCm( Id id ) const;
+    void setCm( Id id, double value );
 
-	double getEm( Id id ) const;
-	void setEm( Id id, double value );
+    double getEm( Id id ) const;
+    void setEm( Id id, double value );
 
-	double getRm( Id id ) const;
-	void setRm( Id id, double value );
+    double getRm( Id id ) const;
+    void setRm( Id id, double value );
 
-	double getRa( Id id ) const;
-	void setRa( Id id, double value );
+    double getRa( Id id ) const;
+    void setRa( Id id, double value );
 
-	// Im is read-only
-	double getIm( Id id ) const;
+    // Im is read-only
+    double getIm( Id id ) const;
 
-	// Ia is read-only
-	double getIa( Id id ) const;
+    // Ia is read-only
+    double getIa( Id id ) const;
 
-	double getInject( Id id ) const;
-	void setInject( Id id, double value );
+    double getInject( Id id ) const;
+    void setInject( Id id, double value );
 
-	void addInject( Id id, double value );
+    void addInject( Id id, double value );
 
-	/// Interface to compartments
-	//~ const vector< Id >& getCompartments() const;
+    /// Interface to compartments
+    //~ const vector< Id >& getCompartments() const;
 
-	void addGkEk( Id id, double v1, double v2 );
-	void addConc( Id id, double conc );
-	/// Interface to channels
-	//~ const vector< Id >& getHHChannels() const;
-	void setPowers(
-		Id id,
-		double Xpower,
-		double Ypower,
-		double Zpower );
+    void addGkEk( Id id, double v1, double v2 );
+    void addConc( Id id, double conc );
+    /// Interface to channels
+    //~ const vector< Id >& getHHChannels() const;
+    void setPowers(
+        Id id,
+        double Xpower,
+        double Ypower,
+        double Zpower );
 
-	int getInstant( Id id ) const;
-	void setInstant( Id id, int instant );
+    int getInstant( Id id ) const;
+    void setInstant( Id id, int instant );
 
-	double getHHChannelGbar( Id id ) const;
-	void setHHChannelGbar( Id id, double value );
+    double getHHChannelGbar( Id id ) const;
+    void setHHChannelGbar( Id id, double value );
 
-	double getEk( Id id ) const;
-	void setEk( Id id, double value );
+    double getEk( Id id ) const;
+    void setEk( Id id, double value );
 
-	double getGk( Id id ) const;
-	void setGk( Id id, double value );
+    double getGk( Id id ) const;
+    void setGk( Id id, double value );
 
-	// Ik is read-only
-	double getIk( Id id ) const;
+    // Ik is read-only
+    double getIk( Id id ) const;
 
-	double getX( Id id ) const;
-	void setX( Id id, double value );
+    double getX( Id id ) const;
+    void setX( Id id, double value );
 
-	double getY( Id id ) const;
-	void setY( Id id, double value );
+    double getY( Id id ) const;
+    void setY( Id id, double value );
 
-	double getZ( Id id ) const;
-	void setZ( Id id, double value );
+    double getZ( Id id ) const;
+    void setZ( Id id, double value );
 
-	/// Assign scale factor for HH channel conductance.
-	void setHHmodulation( Id id, double value );
+    /// Assign scale factor for HH channel conductance.
+    void setHHmodulation( Id id, double value );
 
-	/// Interface to CaConc
-	//~ const vector< Id >& getCaConcs() const;
-	double getCa( Id id ) const;
-	void setCa( Id id, double Ca );
-	void iCa( Id id, double iCa ); // Add incoming calcium current.
+    /// Interface to CaConc
+    //~ const vector< Id >& getCaConcs() const;
+    double getCa( Id id ) const;
+    void setCa( Id id, double Ca );
+    void iCa( Id id, double iCa ); // Add incoming calcium current.
 
-	double getCaBasal( Id id ) const;
-	void setCaBasal( Id id, double CaBasal );
+    double getCaBasal( Id id ) const;
+    void setCaBasal( Id id, double CaBasal );
 
-	void setTauB( Id id, double tau, double B );
+    void setTauB( Id id, double tau, double B );
 
-	double getCaCeiling( Id id ) const;
-	void setCaCeiling( Id id, double floor );
+    double getCaCeiling( Id id ) const;
+    void setCaCeiling( Id id, double floor );
 
-	double getCaFloor( Id id ) const;
-	void setCaFloor( Id id, double floor );
+    double getCaFloor( Id id ) const;
+    void setCaFloor( Id id, double floor );
 
-	/// Interface to external channels
-	//~ const vector< vector< Id > >& getExternalChannels() const;
+    /// Interface to external channels
+    //~ const vector< vector< Id > >& getExternalChannels() const;
 
-	static const Cinfo* initCinfo();
+    static const Cinfo* initCinfo();
 
     static const std::set<string>& handledClasses();
-						/**< Returns the set of classes "handled" by HSolve */
+    /**< Returns the set of classes "handled" by HSolve */
     static void deleteIncomingMessages( Element * orig, const string finfo);
-						/**< Delete messages coming into this particular
-						 *   element if its class that is handled by HSolve */
+    /**< Delete messages coming into this particular
+     *   element if its class that is handled by HSolve */
 
 private:
-	static vector< Id > children( Id obj );
-	static Id deepSearchForCompartment( Id base );
-
-	void setup( Eref hsolve );
-	void zombify( Eref hsolve ) const;
-	void unzombify() const;
-
-	// Mapping global Id to local index. Defined in HSolveInterface.cpp.
-	void mapIds();
-	void mapIds( vector< Id > id );
-	unsigned int localIndex( Id id ) const;
-	map< Id, unsigned int > localIndex_;
-
-	double dt_;
-	string path_;
-	Id seed_;
+    static vector< Id > children( Id obj );
+    static Id deepSearchForCompartment( Id base );
+
+    void setup( Eref hsolve );
+    void zombify( Eref hsolve ) const;
+    void unzombify() const;
+
+    // Mapping global Id to local index. Defined in HSolveInterface.cpp.
+    void mapIds();
+    void mapIds( vector< Id > id );
+    unsigned int localIndex( Id id ) const;
+    map< Id, unsigned int > localIndex_;
+
+    double dt_;
+    string path_;
+    Id seed_;
+
+    double totalTime_ = 0.0;
+    high_resolution_clock::time_point t0_, t1_;
 };
 
 #endif // _HSOLVE_H
diff --git a/ksolve/BoostSys.h b/ksolve/BoostSys.h
index ae97723a52ddf24e6cc10ac97f0da573b93ffceb..89fcc817ae8f943b524e88941000f115aea47d2a 100644
--- a/ksolve/BoostSys.h
+++ b/ksolve/BoostSys.h
@@ -21,34 +21,6 @@ typedef boost::numeric::odeint::modified_midpoint< vector_type_ > rk_midpoint_st
 typedef boost::numeric::odeint::runge_kutta_cash_karp54< vector_type_ > rk_karp_stepper_type_;
 typedef boost::numeric::odeint::runge_kutta_fehlberg78< vector_type_ > rk_felhberg_stepper_type_;
 
-
-class VoxelPools;
-
-/*
- * =====================================================================================
- *        Class:  BoostSys
- *  Description:  The ode system of ksolve. It uses boost library to solve it.
- *  It is intended to be gsl replacement.
- * =====================================================================================
- */
-class BoostSys
-{
-public:
-    BoostSys( );
-    ~BoostSys( );
-
-    /* Operator is called by boost ode-solver */
-    void operator()( const vector_type_ y , vector_type_& dydt, const double t );
-
-    /* Pointer to the arbitrary parameters of the system */
-    VoxelPools* vp;
-    void* params;
-
-    double epsAbs;
-    double epsRel;
-    std::string method;
-};
-
 #endif // USE_BOOST_ODE
 
 #endif /* end of include guard: BOOSTSYSTEM_H */
diff --git a/ksolve/CMakeLists.txt b/ksolve/CMakeLists.txt
index f35588de2c69225086b36e306e023d546c88ae68..f86c69c08d82ae568b283bacb5f2afde6baa2a93 100644
--- a/ksolve/CMakeLists.txt
+++ b/ksolve/CMakeLists.txt
@@ -18,11 +18,11 @@ elseif(WITH_GSL)
     include_directories( ${GSL_INCLUDE_DIRS} )
 endif(WITH_BOOST_ODE)
 
-if(PARALLELIZED_SOLVERS)
-    message( STATUS "Parallel version of KSolve and Gsolve" )
-    add_definitions( -DPARALLELIZE_KSOLVE_WITH_CPP11_ASYNC )
-    add_definitions( -DPARALLELIZE_GSOLVE_WITH_CPP11_ASYNC )
-endif(PARALLELIZED_SOLVERS)
+if(WITH_BOOST)
+    find_package(Boost REQUIRED COMPONENTS thread)
+    add_definitions( -DUSE_BOOST_ASYNC )
+    include_directories( ${Boost_INCLUDE_DIRS} )
+endif()
 
 set(KSOLVE_SRCS
 	KinSparseMatrix.cpp
@@ -48,7 +48,7 @@ if(WITH_GSL)
     list(APPEND KSOLVE_SRCS SteadyStateGsl.cpp )
 elseif(WITH_BOOST_ODE)
     list(APPEND KSOLVE_SRCS SteadyStateBoost.cpp )
-    list(APPEND KSOLVE_SRCS BoostSys.cpp)
 endif(WITH_GSL)
 
 add_library( ksolve ${KSOLVE_SRCS} )
+target_link_libraries( ksolve ${Boost_LIBRARIES} )
diff --git a/ksolve/FuncRateTerm.h b/ksolve/FuncRateTerm.h
index 9dad58098ca5a32d161e3c0c4cb38f3e91114006..b04d7d0ab24fe60897a38e1509c21cb2ee737fb2 100644
--- a/ksolve/FuncRateTerm.h
+++ b/ksolve/FuncRateTerm.h
@@ -4,8 +4,7 @@
 ** also known as GENESIS 3 base code.
 **           copyright (C) 2003-2010 Upinder S. Bhalla. and NCBS
 ** It is made available under the terms of the
-** GNU Lesser General Public License version 2.1
-** See the file COPYING.LIB for the full notice.
+** GNU Lesser General Public License version 3 or later.
 **********************************************************************/
 
 /**
@@ -21,63 +20,63 @@
  */
 class FuncRate: public ExternReac
 {
-	public:
-		FuncRate( double k, unsigned int targetPoolIndex )
-			: k_( k ), funcVolPower_( 0.0 )
-		{
-			func_.setTarget( targetPoolIndex );
-		}
-
-		double operator() ( const double* S ) const {
-			double t = Field< double >::get( Id(1), "currentTime" );
-			return func_( S, t ); // get rate from func calculation.
-		}
-
-		unsigned int getReactants( vector< unsigned int >& molIndex ) const{
-			molIndex.resize( 1 );
-			molIndex[0] = func_.getTarget();
-
-			// This is the number of substrates to the reac. It is zero.
-			return 0;
-			// The target molecule is handled as a product.
-		}
-
-		void setReactants( const vector< unsigned int >& molIndex ) {
-			assert( molIndex.size() > 0 );
-			func_.setTarget( molIndex[0] );
-		}
-
-		const vector< unsigned int >& getFuncArgIndex()
-		{
-			return func_.getReactantIndex();
-		}
-
-		void setFuncArgIndex( const vector< unsigned int >& mol ) {
-			func_.setReactantIndex( mol );
-		}
-
-		void setExpr( const string& s ) {
-			func_.setExpr( s );
-		}
-		const string& getExpr() const {
-			return func_.getExpr();
-		}
-
-		RateTerm* copyWithVolScaling(
-				double vol, double sub, double prd ) const
-		{
-			double ratio = sub * pow( NA * vol, funcVolPower_ );
-			FuncRate* ret = new FuncRate( k_ / ratio, func_.getTarget() );
-			ret->funcVolPower_ = funcVolPower_;
-			ret->func_ = func_;
-			// return new FuncRate( k_ / ratio );
-			return ret;
-		}
-
-	protected:
-		FuncTerm func_;
-		double k_;
-		double funcVolPower_;
+    public:
+        FuncRate( double k, unsigned int targetPoolIndex )
+            : k_( k ), funcVolPower_( 0.0 )
+        {
+            func_.setTarget( targetPoolIndex );
+        }
+
+        double operator() ( const double* S ) const {
+            double t = Field< double >::get( Id(1), "currentTime" );
+            return func_( S, t ); // get rate from func calculation.
+        }
+
+        unsigned int getReactants( vector< unsigned int >& molIndex ) const{
+            molIndex.resize( 1 );
+            molIndex[0] = func_.getTarget();
+
+            // This is the number of substrates to the reac. It is zero.
+            return 0;
+            // The target molecule is handled as a product.
+        }
+
+        void setReactants( const vector< unsigned int >& molIndex ) {
+            assert( molIndex.size() > 0 );
+            func_.setTarget( molIndex[0] );
+        }
+
+        const vector< unsigned int >& getFuncArgIndex()
+        {
+            return func_.getReactantIndex();
+        }
+
+        void setFuncArgIndex( const vector< unsigned int >& mol ) {
+            func_.setReactantIndex( mol );
+        }
+
+        void setExpr( const string& s ) {
+            func_.setExpr( s );
+        }
+        const string& getExpr() const {
+            return func_.getExpr();
+        }
+
+        RateTerm* copyWithVolScaling(
+                double vol, double sub, double prd ) const
+        {
+            double ratio = sub * pow( NA * vol, funcVolPower_ );
+            FuncRate* ret = new FuncRate( k_ / ratio, func_.getTarget() );
+            ret->funcVolPower_ = funcVolPower_;
+            ret->func_ = func_;
+            // return new FuncRate( k_ / ratio );
+            return ret;
+        }
+
+    protected:
+        FuncTerm func_;
+        double k_;
+        double funcVolPower_;
 
 };
 
@@ -98,57 +97,57 @@ class FuncRate: public ExternReac
  */
 class FuncReac: public FuncRate
 {
-	public:
-		FuncReac( double k, vector< unsigned int > v )
-			: FuncRate( k, 0 ),
-			v_( v )
-		{;}
-
-		double operator() ( const double* S ) const {
-			// double ret = k_ * func_( S, 0.0 ); // get rate from func calculation.
-			double ret = func_( S, 0.0 ); // get rate from func calculation.
-			vector< unsigned int >::const_iterator i;
-			for ( i = v_.begin(); i != v_.end(); i++) {
-				assert( !std::isnan( S[ *i ] ) );
-				ret *= S[ *i ];
-			}
-			return ret;
-		}
-
-		unsigned int getReactants( vector< unsigned int >& molIndex ) const{
-			molIndex = v_;
-			return numSubstrates_;
-		}
-
-		void setReactants( const vector< unsigned int >& molIndex ) {
-			v_ = molIndex;
-		}
-
-		void rescaleVolume( short comptIndex,
-			const vector< short >& compartmentLookup, double ratio )
-		{
-			for ( unsigned int i = 1; i < v_.size(); ++i ) {
-				if ( comptIndex == compartmentLookup[ v_[i] ] )
-					k_ /= ratio;
-			}
-		}
-
-
-		RateTerm* copyWithVolScaling(
-				double vol, double sub, double prd ) const
-		{
-			assert( v_.size() > 0 );
-			double ratio = sub * pow( NA * vol,
-							funcVolPower_ + (int)( v_.size() ) - 1 );
-			FuncReac* ret = new FuncReac( k_ / ratio, v_ );
-			ret->func_ = func_;
-			ret->funcVolPower_ = funcVolPower_;
-			return ret;
-			// return new FuncReac( k_ / ratio, v_ );
-		}
-
-	private:
-		vector< unsigned int > v_;
-		unsigned int numSubstrates_;
+    public:
+        FuncReac( double k, vector< unsigned int > v )
+            : FuncRate( k, 0 ),
+            v_( v )
+        {;}
+
+        double operator() ( const double* S ) const {
+            // double ret = k_ * func_( S, 0.0 ); // get rate from func calculation.
+            double ret = func_( S, 0.0 ); // get rate from func calculation.
+            vector< unsigned int >::const_iterator i;
+            for ( i = v_.begin(); i != v_.end(); i++) {
+                assert( !std::isnan( S[ *i ] ) );
+                ret *= S[ *i ];
+            }
+            return ret;
+        }
+
+        unsigned int getReactants( vector< unsigned int >& molIndex ) const{
+            molIndex = v_;
+            return numSubstrates_;
+        }
+
+        void setReactants( const vector< unsigned int >& molIndex ) {
+            v_ = molIndex;
+        }
+
+        void rescaleVolume( short comptIndex,
+            const vector< short >& compartmentLookup, double ratio )
+        {
+            for ( unsigned int i = 1; i < v_.size(); ++i ) {
+                if ( comptIndex == compartmentLookup[ v_[i] ] )
+                    k_ /= ratio;
+            }
+        }
+
+
+        RateTerm* copyWithVolScaling(
+                double vol, double sub, double prd ) const
+        {
+            assert( v_.size() > 0 );
+            double ratio = sub * pow( NA * vol,
+                            funcVolPower_ + (int)( v_.size() ) - 1 );
+            FuncReac* ret = new FuncReac( k_ / ratio, v_ );
+            ret->func_ = func_;
+            ret->funcVolPower_ = funcVolPower_;
+            return ret;
+            // return new FuncReac( k_ / ratio, v_ );
+        }
+
+    private:
+        vector< unsigned int > v_;
+        unsigned int numSubstrates_;
 };
 
diff --git a/ksolve/FuncTerm.cpp b/ksolve/FuncTerm.cpp
index b7a8ec1cfa4496fe7aa6a8e7342430ac2265b3ca..1ca12021d767234f94dc4e280ef65fd1e2068bf3 100644
--- a/ksolve/FuncTerm.cpp
+++ b/ksolve/FuncTerm.cpp
@@ -28,45 +28,45 @@ using namespace std;
 #include "../utility/numutil.h"
 
 FuncTerm::FuncTerm()
-	: reactantIndex_( 1, 0 ),
-		volScale_( 1.0 ),
-		target_( ~0U)
+    : reactantIndex_( 1, 0 ),
+        volScale_( 1.0 ),
+        target_( ~0U)
 {
-	args_ = 0;
-	parser_.DefineConst(_T("pi"), (mu::value_type)M_PI);
-	parser_.DefineConst(_T("e"), (mu::value_type)M_E);
+    args_ = 0;
+    parser_.DefineConst(_T("pi"), (mu::value_type)M_PI);
+    parser_.DefineConst(_T("e"), (mu::value_type)M_E);
 }
 
 FuncTerm::~FuncTerm()
 {
-	if (args_) {
-		delete[] args_;
-	}
+    if (args_) {
+        delete[] args_;
+    }
 }
 
 void FuncTerm::setReactantIndex( const vector< unsigned int >& mol )
 {
-	reactantIndex_ = mol;
-	if ( args_ ) {
-		delete[] args_;
-		args_ = 0;
-	}
-	args_ = new double[ mol.size() + 1 ];
-	// args_.resize( mol.size() + 1, 0.0 );
-	for ( unsigned int i = 0; i < mol.size(); ++i ) {
-		stringstream ss;
-		args_[i] = 0.0;
-		ss << "x" << i;
-		parser_.DefineVar( ss.str(), &args_[i] );
-	}
-	// Define a 't' variable even if we don't always use it.
-	args_[mol.size()] = 0.0;
-	parser_.DefineVar( "t", &args_[mol.size()] );
+    reactantIndex_ = mol;
+    if ( args_ ) {
+        delete[] args_;
+        args_ = 0;
+    }
+    args_ = new double[ mol.size() + 1 ];
+    // args_.resize( mol.size() + 1, 0.0 );
+    for ( unsigned int i = 0; i < mol.size(); ++i ) {
+        stringstream ss;
+        args_[i] = 0.0;
+        ss << "x" << i;
+        parser_.DefineVar( ss.str(), &args_[i] );
+    }
+    // Define a 't' variable even if we don't always use it.
+    args_[mol.size()] = 0.0;
+    parser_.DefineVar( "t", &args_[mol.size()] );
 }
 
 const vector< unsigned int >& FuncTerm::getReactantIndex() const
 {
-	return reactantIndex_;
+    return reactantIndex_;
 }
 
 
@@ -82,50 +82,50 @@ void showError(mu::Parser::exception_type &e)
 
 void FuncTerm::setExpr( const string& expr )
 {
-	try {
-		parser_.SetExpr( expr );
-		expr_ = expr;
-	} catch(mu::Parser::exception_type &e) {
-		showError(e);
-		//return;
+    try {
+        parser_.SetExpr( expr );
+        expr_ = expr;
+    } catch(mu::Parser::exception_type &e) {
+        showError(e);
+        //return;
                 throw(e);
-	}
+    }
 }
 
 const string& FuncTerm::getExpr() const
 {
-	return expr_;
+    return expr_;
 }
 
 void FuncTerm::setTarget( unsigned int t )
 {
-	target_ = t;
+    target_ = t;
 }
 
 const unsigned int FuncTerm::getTarget() const
 {
-	return target_;
+    return target_;
 }
 
 void FuncTerm::setVolScale( double vs )
 {
-	volScale_ = vs;
+    volScale_ = vs;
 }
 
 double FuncTerm::getVolScale() const
 {
-	return volScale_;
+    return volScale_;
 }
 
 const FuncTerm& FuncTerm::operator=( const FuncTerm& other )
 {
-	args_ = 0; // Don't delete it, the original one is still using it.
-	parser_ = other.parser_;
-	expr_ = other.expr_;
-	volScale_ = other.volScale_;
-	target_ = other.target_;
-	setReactantIndex( other.reactantIndex_ );
-	return *this;
+    args_ = 0; // Don't delete it, the original one is still using it.
+    parser_ = other.parser_;
+    expr_ = other.expr_;
+    volScale_ = other.volScale_;
+    target_ = other.target_;
+    setReactantIndex( other.reactantIndex_ );
+    return *this;
 }
 
 /**
@@ -134,12 +134,12 @@ const FuncTerm& FuncTerm::operator=( const FuncTerm& other )
  */
 double FuncTerm::operator() ( const double* S, double t ) const
 {
-	if ( !args_ )
-		return 0.0;
-	unsigned int i;
-	for ( i = 0; i < reactantIndex_.size(); ++i )
-		args_[i] = S[reactantIndex_[i]];
-	args_[i] = t;
+    if ( !args_ )
+        return 0.0;
+    unsigned int i;
+    for ( i = 0; i < reactantIndex_.size(); ++i )
+        args_[i] = S[reactantIndex_[i]];
+    args_[i] = t;
         try
         {
             double result = parser_.Eval() * volScale_;
@@ -155,12 +155,12 @@ double FuncTerm::operator() ( const double* S, double t ) const
 
 void FuncTerm::evalPool( double* S, double t ) const
 {
-	if ( !args_ || target_ == ~0U )
-		return;
-	unsigned int i;
-	for ( i = 0; i < reactantIndex_.size(); ++i )
-		args_[i] = S[reactantIndex_[i]];
-	args_[i] = t;
+    if ( !args_ || target_ == ~0U )
+        return;
+    unsigned int i;
+    for ( i = 0; i < reactantIndex_.size(); ++i )
+        args_[i] = S[reactantIndex_[i]];
+    args_[i] = t;
         try
         {
             S[ target_] = parser_.Eval() * volScale_;
diff --git a/ksolve/FuncTerm.h b/ksolve/FuncTerm.h
index 05779b7919559a7012684b4de2763456726ead8e..ccf2dcd1884d6c655549d7a047f508c8cc0c4ba1 100644
--- a/ksolve/FuncTerm.h
+++ b/ksolve/FuncTerm.h
@@ -14,44 +14,45 @@
 
 class FuncTerm
 {
-	public:
-		FuncTerm();
-		~FuncTerm();
-		/**
-		 * This computes the value. The time t is an argument needed by
-		 * some functions.
-		 */
-		double operator() ( const double* S, double t ) const;
-		const FuncTerm& operator=( const FuncTerm& other );
+    public:
+        FuncTerm();
+        ~FuncTerm();
+        /**
+         * This computes the value. The time t is an argument needed by
+         * some functions.
+         */
+        double operator() ( const double* S, double t ) const;
+        const FuncTerm& operator=( const FuncTerm& other );
 
-		void evalPool( double* s, double t ) const;
+        void evalPool( double* s, double t ) const;
 
-		/**
-		 * This function finds the reactant indices in the vector
-		 * S. It returns the number of indices found, which are the
-		 * entries in molIndex.
-		 */
-		void setReactantIndex( const vector< unsigned int >& mol );
-		const vector< unsigned int >& getReactantIndex() const;
-		const string& getExpr() const;
-		void setExpr( const string& e );
-		const unsigned int getTarget() const;
-		void setTarget( unsigned int tgt );
-		void setVolScale( double vs );
-		double getVolScale() const;
-	private:
-		double* args_;
-		// Look up reactants in the S vec.
-		vector< unsigned int > reactantIndex_;
-		mu::Parser parser_;
-		string expr_;
-		/**
-		 * Scale factor to account for pool volume if we are assigning conc
-		 * rather than N. Note that this conc will not be further updated
-		 * so this is an undesirable option.
-		 */
-		double volScale_;
-		unsigned int target_; /// Index of the entity to be updated by Func
+        /**
+         * This function finds the reactant indices in the vector
+         * S. It returns the number of indices found, which are the
+         * entries in molIndex.
+         */
+        void setReactantIndex( const vector< unsigned int >& mol );
+        const vector< unsigned int >& getReactantIndex() const;
+        const string& getExpr() const;
+        void setExpr( const string& e );
+        const unsigned int getTarget() const;
+        void setTarget( unsigned int tgt );
+        void setVolScale( double vs );
+        double getVolScale() const;
+
+    private:
+        double* args_;
+        // Look up reactants in the S vec.
+        vector< unsigned int > reactantIndex_;
+        mu::Parser parser_;
+        string expr_;
+        /**
+         * Scale factor to account for pool volume if we are assigning conc
+         * rather than N. Note that this conc will not be further updated
+         * so this is an undesirable option.
+         */
+        double volScale_;
+        unsigned int target_; /// Index of the entity to be updated by Func
 };
 
 #endif // _FUNC_TERM_H
diff --git a/ksolve/Gsolve.cpp b/ksolve/Gsolve.cpp
index c7f5cb8ac00bcc159ee2fc54c3260c0c2dd61630..d99dd12a322b88b4129d544a491bc36c08586ae4 100644
--- a/ksolve/Gsolve.cpp
+++ b/ksolve/Gsolve.cpp
@@ -23,12 +23,22 @@
 #include "GssaSystem.h"
 #include "Stoich.h"
 #include "GssaVoxelPools.h"
+#include "Gsolve.h"
+
+#include <chrono>
+#include <algorithm>
+
+#ifdef USE_BOOST_ASYNC
+#define BOOST_THREAD_PROVIDES_FUTURE
+#include <boost/thread.hpp>
+#include <boost/thread/future.hpp>
+#endif
 
 #include <future>
 #include <atomic>
 #include <thread>
+#include <functional>
 
-#include "Gsolve.h"
 
 #define SIMPLE_ROUNDING 0
 
@@ -60,13 +70,14 @@ const Cinfo* Gsolve::initCinfo()
         "current solver. ",
         &Gsolve::getNumLocalVoxels
     );
-    static LookupValueFinfo<
-    Gsolve, unsigned int, vector< double > > nVec(
+
+    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, "
@@ -83,6 +94,13 @@ const Cinfo* Gsolve::initCinfo()
         &Gsolve::getNumPools
     );
 
+    static ValueFinfo< Gsolve, unsigned int > numThreads(
+        "numThreads",
+        "Number of threads to use in GSolve",
+        &Gsolve::setNumThreads,
+        &Gsolve::getNumThreads
+    );
+
     static ValueFinfo< Gsolve, bool > useRandInit(
         "useRandInit",
         "Flag: True when using probabilistic (random) rounding.\n "
@@ -107,7 +125,7 @@ const Cinfo* Gsolve::initCinfo()
         "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. " ,
+        "should not be set unless there are such functions. ",
         &Gsolve::setClockedUpdate,
         &Gsolve::getClockedUpdate
     );
@@ -171,28 +189,29 @@ const Cinfo* Gsolve::initCinfo()
 
     static Finfo* gsolveFinfos[] =
     {
-        &stoich,			// Value
-        &numLocalVoxels,	// ReadOnlyValue
-        &nVec,				// LookupValue
-        &numAllVoxels,		// ReadOnlyValue
-        &numPools,			// Value
-        &voxelVol,			// DestFinfo
-        &proc,				// SharedFinfo
-        &init,				// SharedFinfo
+        &stoich,           // Value
+        &numLocalVoxels,   // ReadOnlyValue
+        &nVec,             // LookupValue
+        &numAllVoxels,     // ReadOnlyValue
+        &numPools,         // Value
+        &numThreads,       // Value
+        &voxelVol,         // DestFinfo
+        &proc,             // SharedFinfo
+        &init,             // SharedFinfo
         // Here we put new fields that were not there in the Ksolve.
-        &useRandInit,		// Value
-        &useClockedUpdate,	// Value
-        &numFire,			// ReadOnlyLookupValue
+        &useRandInit,      // Value
+        &useClockedUpdate, // Value
+        &numFire,          // ReadOnlyLookupValue
     };
 
     static Dinfo< Gsolve > dinfo;
-    static  Cinfo gsolveCinfo(
-        "Gsolve",
-        Neutral::initCinfo(),
-        gsolveFinfos,
-        sizeof(gsolveFinfos)/sizeof(Finfo *),
-        &dinfo
-    );
+
+    static  Cinfo gsolveCinfo( "Gsolve",
+            Neutral::initCinfo(),
+            gsolveFinfos,
+            sizeof(gsolveFinfos)/sizeof(Finfo *),
+            &dinfo
+            );
 
     return &gsolveCinfo;
 }
@@ -204,9 +223,7 @@ static const Cinfo* gsolveCinfo = Gsolve::initCinfo();
 //////////////////////////////////////////////////////////////
 
 Gsolve::Gsolve() :
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
-    numThreads_ ( 2 ),
-#endif
+    numThreads_ ( 1 ),
     pools_( 1 ),
     startVoxel_( 0 ),
     dsolve_(),
@@ -360,44 +377,12 @@ void Gsolve::setClockedUpdate( bool val )
 }
 
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
-/**
- * @brief Advance voxels pools but concurrently.
- *
- * @param begin
- * @param end
- * @param p
- */
-void Gsolve::parallel_advance(int begin, int end, size_t nWorkers, const ProcPtr p
-                              , const GssaSystem* sys
-                             )
-{
-    std::atomic<int> idx( begin );
-    for (size_t cpu = 0; cpu != nWorkers; ++cpu)
-    {
-        std::async( std::launch::async,
-                [this, &idx, end, p, sys]()
-                {
-                    for (;;)
-                    {
-                        int i = idx++;
-                        if (i >= end)
-                            break;
-                        pools_[i].advance( p, sys);
-                    }
-                }
-            );
-    }
-}
-
-#endif
-
 //////////////////////////////////////////////////////////////
 // Process operations.
 //////////////////////////////////////////////////////////////
 void Gsolve::process( const Eref& e, ProcPtr p )
 {
-    // cout << stoichPtr_ << "	dsolve = " <<	dsolvePtr_ << endl;
+    // cout << stoichPtr_ << "    dsolve = " <<    dsolvePtr_ << endl;
     if ( !stoichPtr_ )
         return;
 
@@ -420,7 +405,7 @@ void Gsolve::process( const Eref& e, ProcPtr p )
 
         for ( ; i != dvalues.end(); ++i )
         {
-            //	cout << *i << "	" << round( *i ) << "		";
+            //    cout << *i << "    " << round( *i ) << "        ";
 #if SIMPLE_ROUNDING
             *i = round( *i );
 #else
@@ -440,21 +425,29 @@ void Gsolve::process( const Eref& e, ProcPtr p )
     // happening. This is very inefficient at this point, need to fix.
     if ( dsolvePtr_ )
     {
-        for ( vector< GssaVoxelPools >::iterator
-                i = pools_.begin(); i != pools_.end(); ++i )
-        {
+        for ( auto i = pools_.begin(); i != pools_.end(); ++i )
             i->refreshAtot( &sys_ );
-        }
     }
+
     // Fourth, update the mol #s.
     // First we advance the simulation.
     size_t nvPools = pools_.size( );
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
-    // If there is only one voxel-pool or one thread is specified by user then
-    // there is no point in using std::async there.
-    if( 1 == getNumThreads( ) || 1 == nvPools )
+    // Third, do the numerical integration for all reactions.
+    size_t grainSize = max( (size_t)1, min( nvPools, nvPools / numThreads_));
+
+    // Make sure that we cover all the pools.
+    while( (numThreads_ * grainSize) < nvPools )
+        grainSize += 1;
+
+    if( 1 == numThreads_ || 1 == nvPools )
     {
+        if( numThreads_ > 1 )
+        {
+            cerr << "Warn: Not enough voxels or threads. Reverting to serial mode. " << endl;
+            numThreads_ = 1;
+        }
+
         for ( size_t i = 0; i < nvPools; i++ )
             pools_[i].advance( p, &sys_ );
     }
@@ -464,22 +457,47 @@ void Gsolve::process( const Eref& e, ProcPtr p )
          *  Somewhat complicated computation to compute the number of threads. 1
          *  thread per (at least) voxel pool is ideal situation.
          *-----------------------------------------------------------------------------*/
-        size_t grainSize = min( nvPools, 1 + (nvPools / numThreads_ ) );
-        size_t nWorkers = nvPools / grainSize;
+        vector<std::thread> vecThreads;
+
+        for (size_t i = 0; i < numThreads_; i++)
+        {
+            // Use lambda. It is roughly 10% faster than std::bind and does not
+            // involve copying data.
+            std::thread  t( 
+                    [this, i, grainSize, p](){ this->advance_chunk(i*grainSize, (i+1)*grainSize, p); }
+                    );
+            vecThreads.push_back( std::move(t) );
+        }
 
-        for (size_t i = 0; i < nWorkers; i++)
-            parallel_advance( i * grainSize, (i+1) * grainSize, nWorkers, p, &sys_ );
+        for( auto &v : vecThreads )
+            v.join();
 
     }
-#else
-    for ( size_t i = 0; i < nvPools; i++ )
-        pools_[i].advance( p, &sys_ );
-#endif
 
     if ( useClockedUpdate_ )   // Check if a clocked stim is to be updated
     {
-        for ( auto &v : pools_ )
-            v.recalcTime( &sys_, p->currTime );
+        if(numThreads_ == 1)
+        {
+            for ( auto &v : pools_ )
+                v.recalcTime( &sys_, p->currTime );
+        }
+        else
+        {
+            vector<std::thread> vecThreads;
+
+            for (size_t i = 0; i < numThreads_; i++)
+            {
+                // Use lambda. It is roughly 10% faster than std::bind and does not
+                // involve copying data.
+                std::thread  t( 
+                        [this, i, grainSize, p](){ this->recalcTimeChunk(i*grainSize, (i+1)*grainSize, p); }
+                        );
+                vecThreads.push_back( std::move(t) );
+            }
+
+            for( auto &v : vecThreads )
+                v.join();
+        }
     }
 
     // Finally, assemble and send the integrated values off for the Dsolve.
@@ -493,13 +511,25 @@ void Gsolve::process( const Eref& e, ProcPtr p )
         getBlock( kvalues );
         dsolvePtr_->setBlock( kvalues );
 
-		// Now use the values in the Dsolve to update junction fluxes
-		// for diffusion, channels, and xreacs
-		dsolvePtr_->updateJunctions( p->dt );
-		// Here the Gsolve may need to do something to convert to integers
+        // Now use the values in the Dsolve to update junction fluxes
+        // for diffusion, channels, and xreacs
+        dsolvePtr_->updateJunctions( p->dt );
+        // Here the Gsolve may need to do something to convert to integers
     }
 }
 
+void Gsolve::recalcTimeChunk( const size_t begin, const size_t end, ProcPtr p)
+{
+    for (size_t i = begin; i < std::min(pools_.size(), end); i++) 
+        pools_[i].recalcTime( &sys_, p->currTime );
+}
+
+void Gsolve::advance_chunk( const size_t begin, const size_t end, ProcPtr p )
+{
+    for (size_t i = begin; i < std::min(end, pools_.size() ); i++)
+        pools_[i].advance( p, &sys_ );
+}
+
 void Gsolve::reinit( const Eref& e, ProcPtr p )
 {
     if ( !stoichPtr_ )
@@ -519,11 +549,9 @@ void Gsolve::reinit( const Eref& e, ProcPtr p )
         i->refreshAtot( &sys_ );
     }
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
     if( 1 < getNumThreads( ) )
-        cout << "Info: Using threaded gsolve: " << getNumThreads( )
-            << " threads. " << endl;
-#endif
+        cout << "Info: Setting up threaded gsolve with " << getNumThreads( )
+             << " threads. " << endl;
 }
 
 //////////////////////////////////////////////////////////////
@@ -752,48 +780,48 @@ void Gsolve::fillIncrementFuncDep()
 /*
 void Gsolve::fillMathDep()
 {
-	// 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 funcOffset =
-			stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() + stoichPtr_->getNumBufPools();
-	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;
-				// 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 funcOffset =
+            stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() + stoichPtr_->getNumBufPools();
+    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;
+                // 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() );
+            }
+        }
+    }
 }
 */
 
@@ -811,8 +839,8 @@ void Gsolve::insertMathDepReacs( unsigned int mathDepIndex,
 
     // 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() );
+        vector< unsigned int >& dep = dependency_[ firedReac ];
+        dep.insert( dep.end(), reacIndices.begin(), reacIndices.end() );
     }
     */
 }
@@ -1063,7 +1091,6 @@ double Gsolve::volume( unsigned int i ) const
     return 0.0;
 }
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
 unsigned int Gsolve::getNumThreads( ) const
 {
     return numThreads_;
@@ -1073,4 +1100,3 @@ void Gsolve::setNumThreads( unsigned int x )
 {
     numThreads_ = x;
 }
-#endif
diff --git a/ksolve/Gsolve.h b/ksolve/Gsolve.h
index cb51181468c1a30966a0f53593538eb1658bca82..4b09049ccc4e4542da904020f06dfa035251aae6 100644
--- a/ksolve/Gsolve.h
+++ b/ksolve/Gsolve.h
@@ -108,12 +108,9 @@ public:
      */
     void updateRateTerms( unsigned int index );
 
-
-    // A wrapper to call advance function of GssaVoxelPool
-    // concurrently.
-    void parallel_advance(int begin, int end, size_t nWorkers
-                          , ProcPtr p , const GssaSystem* sys
-                         );
+    // Function for multithreading.
+    void advance_chunk( const size_t begin, const size_t end, ProcPtr p );
+    void recalcTimeChunk( const size_t begin, const size_t end, ProcPtr p);
 
     //////////////////////////////////////////////////////////////////
     /// Flag: returns true if randomized round to integers is done.
@@ -126,22 +123,18 @@ public:
     /// Flag: set true if randomized round to integers is to be done.
     void setClockedUpdate( bool val );
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
     unsigned int getNumThreads( ) const;
     void setNumThreads( unsigned int x );
-#endif
 
     //////////////////////////////////////////////////////////////////
     static const Cinfo* initCinfo();
 private:
 
-#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
     /**
      * @brief Number of threads to use when parallel version of Gsolve is
      * used.
      */
     unsigned int numThreads_;
-#endif
 
     GssaSystem sys_;
     /**
@@ -169,6 +162,8 @@ private:
 
     /// Flag: True if atot should be updated every clock tick
     bool useClockedUpdate_;
+
+    double t1_;
 };
 
 #endif	// _GSOLVE_H
diff --git a/ksolve/GssaVoxelPools.cpp b/ksolve/GssaVoxelPools.cpp
index 4128d0a6dcd65010cbe263fdcb178f83cdee3ef3..ae725120a3e8608dc495d0663356753632c6d463 100644
--- a/ksolve/GssaVoxelPools.cpp
+++ b/ksolve/GssaVoxelPools.cpp
@@ -208,11 +208,7 @@ void GssaVoxelPools::advance( const ProcInfo* p, const GssaSystem* g )
             assert( rindex < v_.size() );
         }
 
-#if ENABLE_CPP11
         double sign = std::copysign( 1, v_[rindex] );
-#else
-        double sign = double(v_[rindex] >= 0) - double(0 > v_[rindex] );
-#endif
 
         g->transposeN.fireReac( rindex, Svec(), sign );
         numFire_[rindex]++;
@@ -238,6 +234,7 @@ void GssaVoxelPools::reinit( const GssaSystem* g )
 
     double* n = varS();
 
+    double totalN = 0;
     if( g->useRandInit )
     {
         vector<double> error(numVarPools, 0.0);
@@ -248,6 +245,7 @@ void GssaVoxelPools::reinit( const GssaSystem* g )
             error[i] = n[i];
             double base = std::floor( n[i] );
             assert( base >= 0.0 );
+            totalN += n[i];
             double frac = n[i] - base;
             if ( rng_.uniform() >= frac )
                 n[i] = base;
@@ -255,38 +253,28 @@ void GssaVoxelPools::reinit( const GssaSystem* g )
                 n[i] = base + 1.0;
 
             error[i] -= n[i];
-
-            //if( true )
-            //{
-            //    //NOTE: Thats how I get the name of the pool at this index.
-            //    Eref e = g->stoich->getPoolByIndex( i ).eref();
-            //    groupByVal[n[i]].push_back( e );
-
-            //    // Guess the fix the error.
-            //}
-
-
         }
 
         double extra = std::accumulate( error.begin(), error.end(), 0.0 );
-        if( std::abs(extra) > 0.1 )
+
+        // Show warning to user if extra molecules in the system after
+        // converting flots to integer is larger 1%.
+        if( std::abs(extra) / totalN > 0.01 )
         {
-            cout << "WARNING: Extra " << extra
-                << " molecules in system after converting fractional to integer e.g. 1.1 = 1 (~90% of times) or 2 (~10% of times)." << endl;
+            cout << "Warn: Extra " << extra
+                << " molecules in system after converting fractional to integer e.g. 1.1 becomes  "
+                " 1 roughly 90% of times or 2 roughly 10% of times." 
+                << endl;
         }
     }
     else     // Just round to the nearest int.
     {
         for ( unsigned int i = 0; i < numVarPools; ++i )
         {
-#if ENABLE_CPP11
             // Just like rint but does not raise exception.
             // See http://en.cppreference.com/w/cpp/numeric/math/nearbyint for
             // details.
             n[i] = std::nearbyint(n[i]);
-#else
-            n[i] = round( n[i] );
-#endif
         }
     }
 
diff --git a/ksolve/Ksolve.cpp b/ksolve/Ksolve.cpp
index b55d0d1212d43744be7a3232f7a8cb53cdcac03f..2277e5ffb37d5041eb56487cfa09766568b9e980 100644
--- a/ksolve/Ksolve.cpp
+++ b/ksolve/Ksolve.cpp
@@ -7,6 +7,7 @@
 ** See the file COPYING.LIB for the full notice.
 **********************************************************************/
 #include "../basecode/header.h"
+#include "../basecode/global.h"
 #ifdef USE_GSL
 #include <gsl/gsl_errno.h>
 #include <gsl/gsl_matrix.h>
@@ -31,10 +32,22 @@
 #include "../mesh/ChemCompt.h"
 #include "Ksolve.h"
 
+#include <chrono>
+#include <algorithm>
+
+#ifdef USE_BOOST_ASYNC
+#define BOOST_THREAD_PROVIDES_FUTURE
+#include <boost/thread.hpp>
+#include <boost/thread/future.hpp>
+#endif
+
 #include <future>
+#include <functional>
 #include <atomic>
 #include <thread>
 
+using namespace std::chrono;
+
 const unsigned int OFFNODE = ~0;
 
 const Cinfo* Ksolve::initCinfo()
@@ -42,7 +55,6 @@ const Cinfo* Ksolve::initCinfo()
     ///////////////////////////////////////////////////////
     // Field definitions
     ///////////////////////////////////////////////////////
-
     static ValueFinfo< Ksolve, string > method (
         "method",
         "Integration method, using GSL. So far only explict. Options are:"
@@ -84,13 +96,14 @@ const Cinfo* Ksolve::initCinfo()
         "current solver. ",
         &Ksolve::getNumLocalVoxels
     );
-    static LookupValueFinfo<
-    Ksolve, unsigned int, vector< double > > nVec(
+
+    static LookupValueFinfo< Ksolve, unsigned int, vector< double > > nVec(
         "nVec",
         "vector of pool counts. Index specifies which voxel.",
         &Ksolve::setNvec,
         &Ksolve::getNvec
     );
+
     static ValueFinfo< Ksolve, unsigned int > numAllVoxels(
         "numAllVoxels",
         "Number of voxels in the entire reac-diff system, "
@@ -99,14 +112,12 @@ const Cinfo* Ksolve::initCinfo()
         &Ksolve::getNumAllVoxels
     );
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
     static ValueFinfo< Ksolve, unsigned int > numThreads (
         "numThreads",
         "Number of threads to use (applicable in deterministic case)",
         &Ksolve::setNumThreads,
         &Ksolve::getNumThreads
     );
-#endif
 
     static ValueFinfo< Ksolve, unsigned int > numPools(
         "numPools",
@@ -121,6 +132,7 @@ const Cinfo* Ksolve::initCinfo()
         "Estimated timestep for reac system based on Euler error",
         &Ksolve::getEstimatedDt
     );
+
     static ReadOnlyValueFinfo< Ksolve, Id > stoich(
         "stoich",
         "Id for stoichiometry object tied to this Ksolve",
@@ -134,17 +146,23 @@ const Cinfo* Ksolve::initCinfo()
 
     static DestFinfo process( "process",
                               "Handles process call from Clock",
-                              new ProcOpFunc< Ksolve >( &Ksolve::process ) );
+                              new ProcOpFunc< Ksolve >( &Ksolve::process )
+                            );
+
     static DestFinfo reinit( "reinit",
                              "Handles reinit call from Clock",
-                             new ProcOpFunc< Ksolve >( &Ksolve::reinit ) );
+                             new ProcOpFunc< Ksolve >( &Ksolve::reinit )
+                           );
 
     static DestFinfo initProc( "initProc",
                                "Handles initProc call from Clock",
-                               new ProcOpFunc< Ksolve >( &Ksolve::initProc ) );
+                               new ProcOpFunc< Ksolve >( &Ksolve::initProc )
+                             );
+
     static DestFinfo initReinit( "initReinit",
                                  "Handles initReinit call from Clock",
-                                 new ProcOpFunc< Ksolve >( &Ksolve::initReinit ) );
+                                 new ProcOpFunc< Ksolve >( &Ksolve::initReinit )
+                               );
 
     static DestFinfo voxelVol( "voxelVol",
                                "Handles updates to all voxels. Comes from parent "
@@ -152,6 +170,7 @@ const Cinfo* Ksolve::initCinfo()
                                new OpFunc1< Ksolve, vector< double > >(
                                    &Ksolve::updateVoxelVol )
                              );
+
     ///////////////////////////////////////////////////////
     // Shared definitions
     ///////////////////////////////////////////////////////
@@ -159,16 +178,19 @@ const Cinfo* Ksolve::initCinfo()
     {
         &process, &reinit
     };
+
     static SharedFinfo proc( "proc",
                              "Shared message for process and reinit. These are used for "
                              "all regular Ksolve calculations including interfacing with "
                              "the diffusion calculations by a Dsolve.",
                              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. ",
@@ -177,22 +199,20 @@ const Cinfo* Ksolve::initCinfo()
 
     static Finfo* ksolveFinfos[] =
     {
-        &method,			// Value
-        &epsAbs,			// Value
-        &epsRel ,			// Value
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
-        &numThreads,                    // Value
-#endif
-        &compartment,		// Value
-        &numLocalVoxels,	// ReadOnlyValue
-        &nVec,				// LookupValue
-        &numAllVoxels,		// ReadOnlyValue
-        &numPools,			// Value
-        &estimatedDt,		// ReadOnlyValue
-        &stoich,			// ReadOnlyValue
-        &voxelVol,			// DestFinfo
-        &proc,				// SharedFinfo
-        &init,				// SharedFinfo
+        &method,                         // Value
+        &epsAbs,                         // Value
+        &epsRel ,                         // Value
+        &numThreads,                            // Value
+        &compartment,                           // Value
+        &numLocalVoxels,                 // ReadOnlyValue
+        &nVec,                                 // LookupValue
+        &numAllVoxels,                         // ReadOnlyValue
+        &numPools,                         // Value
+        &estimatedDt,                         // ReadOnlyValue
+        &stoich,                         // ReadOnlyValue
+        &voxelVol,                         // DestFinfo
+        &proc,                                 // SharedFinfo
+        &init,                                 // SharedFinfo
     };
 
     static Dinfo< Ksolve > dinfo;
@@ -222,20 +242,25 @@ Ksolve::Ksolve()
 #endif
     epsAbs_( 1e-7 ),
     epsRel_( 1e-7 ),
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
-    numThreads_( 3 ),
-#endif
+    numThreads_( 1 ),
     pools_( 1 ),
     startVoxel_( 0 ),
     dsolve_(),
     dsolvePtr_( 0 )
 {
-    ;
 }
 
 Ksolve::~Ksolve()
 {
-    ;
+#if 0
+    char* p = getenv( "MOOSE_SHOW_SOLVER_PERF" );
+    if( p != NULL )
+    {
+        cout << "Info: Ksolve (+Dsolve) took " << totalTime_ << " seconds and took " << numSteps_
+             << " steps." << endl;
+
+    }
+#endif
 }
 
 //////////////////////////////////////////////////////////////
@@ -302,7 +327,6 @@ void Ksolve::setEpsRel( double epsRel )
     }
 }
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
 void Ksolve::setNumThreads( unsigned int x )
 {
     numThreads_ = x;
@@ -312,7 +336,6 @@ unsigned int Ksolve::getNumThreads(  ) const
 {
     return numThreads_;
 }
-#endif
 
 Id Ksolve::getStoich() const
 {
@@ -365,10 +388,11 @@ void Ksolve::setStoich( Id stoich )
         ode.method = method_;
 #ifdef USE_GSL
         ode.gslSys.dimension = stoichPtr_->getNumAllPools();
-        if ( ode.gslSys.dimension == 0 ) {
-			stoichPtr_ = 0;
+        if ( ode.gslSys.dimension == 0 )
+        {
+            stoichPtr_ = 0;
             return; // No pools, so don't bother.
-		}
+        }
         innerSetMethod( ode, method_ );
         ode.gslSys.function = &VoxelPools::gslFunc;
         ode.gslSys.jacobian = 0;
@@ -382,15 +406,11 @@ void Ksolve::setStoich( Id stoich )
         }
 #elif USE_BOOST_ODE
         ode.dimension = stoichPtr_->getNumAllPools();
-        ode.boostSys.epsAbs = epsAbs_;
-        ode.boostSys.epsRel = epsRel_;
-        ode.boostSys.method = method_;
         if ( ode.dimension == 0 )
             return; // No pools, so don't bother.
         unsigned int numVoxels = pools_.size();
         for ( unsigned int i = 0 ; i < numVoxels; ++i )
         {
-            ode.boostSys.params = &pools_[i];
             pools_[i].setStoich( stoichPtr_, &ode );
         }
 #endif
@@ -496,9 +516,13 @@ double Ksolve::getEstimatedDt() const
 //////////////////////////////////////////////////////////////
 void Ksolve::process( const Eref& e, ProcPtr p )
 {
+
+
     if ( isBuilt_ == false )
         return;
 
+    t0_ = high_resolution_clock::now();
+
     // First, handle incoming diffusion values, update S with those.
     if ( dsolvePtr_ )
     {
@@ -509,29 +533,30 @@ void Ksolve::process( const Eref& e, ProcPtr p )
         dvalues[3] = stoichPtr_->getNumVarPools();
 
         dsolvePtr_->getBlock( dvalues );
-		// Second, set the prev_ value in DiffPoolVec
-		dsolvePtr_->setPrev();
+        // Second, set the prev_ value in DiffPoolVec
+        dsolvePtr_->setPrev();
         setBlock( dvalues );
     }
 
     size_t nvPools = pools_.size( );
 
-#ifdef PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
     // Third, do the numerical integration for all reactions.
-    size_t grainSize = min( nvPools, 1 + (nvPools / numThreads_ ) );
-    size_t nWorkers = nvPools / grainSize;
+    size_t grainSize = max( (size_t)1, min( nvPools, nvPools / numThreads_));
+    size_t nWorkers = std::max(1, (int)(nvPools/grainSize) );
+
+    // Just to be sure. Its not very costly computation.
+    while( nWorkers * grainSize < nvPools )
+        grainSize += 1;
 
     if( 1 == nWorkers || 1 == nvPools )
     {
         if( numThreads_ > 1 )
         {
-#ifndef NDEBUG
-            cout << "Debug: Reset to 1 threads " << endl;
-#endif
+            cerr << "Warn: Not enough voxels or threads. Reverting to serial mode. " << endl;
             numThreads_ = 1;
         }
 
-        for ( size_t i = 0; i < nvPools; i++ )
+        for ( unsigned int i = 0; i < nvPools; i++ )
             pools_[i].advance( p );
     }
     else
@@ -540,15 +565,19 @@ void Ksolve::process( const Eref& e, ProcPtr p )
          *  Somewhat complicated computation to compute the number of threads. 1
          *  thread per (at least) voxel pool is ideal situation.
          *-----------------------------------------------------------------------------*/
-        //cout << "Grain size " << grainSize <<  " Workers : " << nWorkers << endl;
+        vector<std::thread> vecThreads;
+        // cout << nWorkers << " grain size " << grainSize << endl;
+
+        // lambdas are faster than std::bind
         for (size_t i = 0; i < nWorkers; i++)
-            parallel_advance( i * grainSize, (i+1) * grainSize, nWorkers, p );
-    }
-#else
-    for ( size_t i = 0; i < nvPools; i++ )
-        pools_[i].advance( p );
-#endif
+        {
+            std::thread t( &Ksolve::advance_chunk, this, i*grainSize, (i+1)*grainSize, p );
+            vecThreads.push_back( std::move(t) );
+        }
 
+        for (auto &v : vecThreads )
+            v.join();
+    }
 
     // Assemble and send the integrated values off for the Dsolve.
     if ( dsolvePtr_ )
@@ -561,40 +590,24 @@ void Ksolve::process( const Eref& e, ProcPtr p )
         getBlock( kvalues );
         dsolvePtr_->setBlock( kvalues );
 
-		// Now use the values in the Dsolve to update junction fluxes
-		// for diffusion, channels, and xreacs
-        dsolvePtr_->updateJunctions( p->dt );
+        // Now use the values in the Dsolve to update junction fluxes
+        // for diffusion, channels, and xreacs
+        dsolvePtr_->updateJunctions( p->dt ); 
     }
+    t1_ = high_resolution_clock::now();
+    moose::addSolverProf( "Ksolve", duration_cast<duration<double>> (t1_ - t0_ ).count(), 1 );
 }
 
+void Ksolve::advance_pool( const size_t i, ProcPtr p )
+{
+    pools_[i].advance(p);
+}
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
-/**
- * @brief Advance voxels pools using parallel Ksolve.
- *
- * @param begin
- * @param end
- * @param p
- */
-void Ksolve::parallel_advance(int begin, int end, size_t nWorkers, ProcPtr p)
+void Ksolve::advance_chunk( const size_t begin, const size_t end, ProcPtr p )
 {
-    std::atomic<int> idx( begin );
-    for (size_t cpu = 0; cpu != nWorkers; ++cpu)
-    {
-        std::async( std::launch::async
-                , [this, &idx, end, p]() {
-                    for (;;)
-                    {
-                        int i = idx++;
-                        if (i >= end)
-                            break;
-                        pools_[i].advance( p );
-                    }
-                }
-            );
-    }
+    for (size_t i = begin; i < std::min(end, pools_.size() ); i++)
+        pools_[i].advance( p );
 }
-#endif
 
 
 void Ksolve::reinit( const Eref& e, ProcPtr p )
@@ -613,10 +626,8 @@ void Ksolve::reinit( const Eref& e, ProcPtr p )
         return;
     }
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
     if( 1 < getNumThreads( ) )
-        cout << "Debug: User wants Ksolve with " << numThreads_ << " threads" << endl;
-#endif
+        cout << "Info: Setting up ksolve with " << numThreads_ << " threads" << endl;
 
 }
 
diff --git a/ksolve/Ksolve.h b/ksolve/Ksolve.h
index c7f4af8a378b0764fa17a26b9d731c9e12fb2daa..f4b9327ae9ba7e5e271065c88e543139234eada4 100644
--- a/ksolve/Ksolve.h
+++ b/ksolve/Ksolve.h
@@ -10,6 +10,10 @@
 #ifndef _KSOLVE_H
 #define _KSOLVE_H
 
+#include <chrono>
+
+using namespace std::chrono;
+
 class Stoich;
 
 class Ksolve: public ZombiePoolInterface
@@ -54,14 +58,13 @@ public:
     vector< double > getNvec( unsigned int voxel) const;
     void setNvec( unsigned int voxel, vector< double > vec );
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
     // Set number of threads to use (for deterministic case only).
     unsigned int getNumThreads( ) const;
     void setNumThreads( unsigned int x );
 
-    // Parallel advance().
-    void parallel_advance(int begin, int end, size_t nWorkers, ProcPtr p);
-#endif
+    void advance_chunk( const size_t begin, const size_t end, ProcPtr p );
+
+    void advance_pool( const size_t i, ProcPtr p );
 
     /**
      * This does a quick and dirty estimate of the timestep suitable
@@ -139,12 +142,10 @@ private:
     double epsAbs_;
     double epsRel_;
 
-#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
     /**
      * @brief Number of threads to use. Only applicable for deterministic case.
      */
     unsigned int numThreads_;
-#endif
 
     /**
      * Each VoxelPools entry handles all the pools in a single voxel.
@@ -169,6 +170,14 @@ private:
     /// Pointer to diffusion solver
     ZombiePoolInterface* dsolvePtr_;
 
+    // Timing and benchmarking related variables.
+    size_t numSteps_  = 0;
+
+    // Time taken in all process function in us.
+    double totalTime_ = 0.0;
+
+    high_resolution_clock::time_point t0_, t1_;
+
 };
 
 #endif	// _KSOLVE_H
diff --git a/ksolve/OdeSystem.h b/ksolve/OdeSystem.h
index 84e2c72fa8ca9bc2b5245a255cdd9bb072df03eb..6a3ede6dcf26d589ada9b4ffd0dfa15a16cfb557 100644
--- a/ksolve/OdeSystem.h
+++ b/ksolve/OdeSystem.h
@@ -37,8 +37,6 @@ class OdeSystem {
         double epsRel; // Relative error
 
 #if  USE_BOOST_ODE
-        //BoostSys* pBoostSys;
-        BoostSys boostSys;
         size_t dimension;
 #endif     /* -----  USE_BOOST_ODE  ----- */
 };
diff --git a/ksolve/VoxelPools.cpp b/ksolve/VoxelPools.cpp
index 38c5e2e76e3fdba4668df119db07ce2a80127b5a..ea575304362e063afda23ec222e09c227a93019f 100644
--- a/ksolve/VoxelPools.cpp
+++ b/ksolve/VoxelPools.cpp
@@ -31,7 +31,6 @@ using namespace boost::numeric;
 
 //////////////////////////////////////////////////////////////
 // Class definitions
-//////////////////////////////////////////////////////////////
 
 VoxelPools::VoxelPools()
 {
@@ -67,6 +66,10 @@ void VoxelPools::reinit( double dt )
 void VoxelPools::setStoich( Stoich* s, const OdeSystem* ode )
 {
     stoichPtr_ = s;
+    absTol_ = ode->epsAbs;
+    relTol_ = ode->epsRel;
+    method_ = ode->method;
+
 #ifdef USE_GSL
     if ( ode )
     {
@@ -76,12 +79,9 @@ void VoxelPools::setStoich( Stoich* s, const OdeSystem* ode )
 
         driver_ = gsl_odeiv2_driver_alloc_y_new(
                       &sys_, ode->gslStep, ode->initStepSize,
-                      ode->epsAbs, ode->epsRel 
-                );
+                      ode->epsAbs, ode->epsRel
+                  );
     }
-#elif USE_BOOST_ODE
-    if( ode )
-        sys_ = ode->boostSys;
 #endif
     VoxelPoolsBase::reinit();
 }
@@ -108,11 +108,6 @@ void VoxelPools::advance( const ProcInfo* p )
 
 #elif USE_BOOST_ODE
 
-
-    // NOTE: Make sure to assing vp to BoostSys vp. In next call, it will be used by
-    // updateRates func. Unlike gsl call, we can't pass extra void*  to gslFunc.
-    VoxelPools* vp = reinterpret_cast< VoxelPools* >( sys_.params );
-    sys_.vp = vp;
     /*-----------------------------------------------------------------------------
     NOTE: 04/21/2016 11:31:42 AM
 
@@ -122,7 +117,7 @@ void VoxelPools::advance( const ProcInfo* p )
     take away the constantness of double*. This probably makes the call bit
     cleaner.
      *-----------------------------------------------------------------------------*/
-    vp->stoichPtr_->updateFuncs( &Svec()[0], p->currTime );
+    stoichPtr_->updateFuncs( &Svec()[0], p->currTime );
 
     /*-----------------------------------------------------------------------------
      * Using integrate function works with with default stepper type.
@@ -134,10 +129,6 @@ void VoxelPools::advance( const ProcInfo* p )
      *-----------------------------------------------------------------------------
      */
 
-    double absTol = sys_.epsAbs;
-    double relTol = sys_.epsRel;
-
-
     /**
      * @brief Default step size for fixed size iterator.
      * FIXME/TODO: I am not sure if this is a right value to pick by default. May be
@@ -146,78 +137,113 @@ void VoxelPools::advance( const ProcInfo* p )
      */
     const double fixedDt = 0.1;
 
-    if( sys_.method == "rk2" )
+    if( method_ == "rk2" )
         odeint::integrate_const( rk_midpoint_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if( sys_.method == "rk4" )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) {
+                        VoxelPools::evalRates(this, dy, dydt ); 
+                    }
+                , Svec()
+                , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
+                );
+    else if( method_ == "rk4" )
         odeint::integrate_const( rk4_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if( sys_.method == "rk5")
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
+                );
+    else if( method_ == "rk5")
         odeint::integrate_const( rk_karp_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if( sys_.method == "rk5a")
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
+                );
+    else if( method_ == "rk5a")
         odeint::integrate_adaptive(
-            odeint::make_controlled<rk_karp_stepper_type_>( absTol, relTol)
-            , sys_
-            , Svec()
-            , p->currTime - p->dt
-            , p->currTime
-            , p->dt
-        );
-    else if ("rk54" == sys_.method )
+                odeint::make_controlled<rk_karp_stepper_type_>( absTol_, relTol_ )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , p->dt
+                );
+    else if ("rk54" == method_ )
         odeint::integrate_const( rk_karp_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if ("rk54a" == sys_.method )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
+                );
+    else if ("rk54a" == method_ )
         odeint::integrate_adaptive(
-            odeint::make_controlled<rk_karp_stepper_type_>( absTol, relTol )
-            , sys_, Svec()
-            , p->currTime - p->dt
-            , p->currTime
-            , p->dt
-        );
-    else if ("rk5" == sys_.method )
+                odeint::make_controlled<rk_karp_stepper_type_>( absTol_, relTol_ )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , p->dt
+                );
+    else if ("rk5" == method_ )
         odeint::integrate_const( rk_dopri_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if ("rk5a" == sys_.method )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , std::min( p->dt, fixedDt )
+                );
+    else if ("rk5a" == method_ )
         odeint::integrate_adaptive(
-            odeint::make_controlled<rk_dopri_stepper_type_>( absTol, relTol )
-            , sys_, Svec()
-            , p->currTime - p->dt
-            , p->currTime
-            , p->dt
-        );
-    else if( sys_.method == "rk8" )
+                odeint::make_controlled<rk_dopri_stepper_type_>( absTol_, relTol_ )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , p->dt
+                );
+    else if( method_ == "rk8" )
         odeint::integrate_const( rk_felhberg_stepper_type_()
-                                 , sys_ , Svec()
-                                 , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
-                               );
-    else if( sys_.method == "rk8a" )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt, p->currTime, std::min( p->dt, fixedDt )
+                );
+    else if( method_ == "rk8a" )
         odeint::integrate_adaptive(
-            odeint::make_controlled<rk_felhberg_stepper_type_>( absTol, relTol )
-            , sys_, Svec()
-            , p->currTime - p->dt
-            , p->currTime
-            , p->dt
-        );
+                odeint::make_controlled<rk_felhberg_stepper_type_>( absTol_, relTol_ )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , p->dt
+                );
 
     else
         odeint::integrate_adaptive(
-            odeint::make_controlled<rk_karp_stepper_type_>( absTol, relTol )
-            , sys_, Svec()
-            , p->currTime - p->dt
-            , p->currTime
-            , p->dt
-        );
+                odeint::make_controlled<rk_karp_stepper_type_>( absTol_, relTol_ )
+                , [this](const vector_type_& dy, vector_type_& dydt, const double t) { 
+                        VoxelPools::evalRates(this, dy, dydt );
+                    }
+                , Svec()
+                , p->currTime - p->dt
+                , p->currTime
+                , p->dt
+                );
+
 #endif
     if ( !stoichPtr_->getAllowNegative() )   // clean out negatives
     {
@@ -266,13 +292,13 @@ int VoxelPools::gslFunc( double t, const double* y, double *dydt,
 #endif
 }
 
-#elif USE_BOOST_ODE
-void VoxelPools::evalRates(
-    const vector_type_& y,  vector_type_& dydt,  const double t, VoxelPools* vp
-)
+#elif USE_BOOST_ODE   // NOT GSL
+
+void VoxelPools::evalRates( VoxelPools* vp, const vector_type_& y,  vector_type_& dydt )
 {
     vp->updateRates( &y[0], &dydt[0] );
 }
+
 #endif
 
 ///////////////////////////////////////////////////////////////////////
@@ -287,8 +313,10 @@ void VoxelPools::updateAllRateTerms( const vector< RateTerm* >& rates,
         delete( rates_[i] );
 
     rates_.resize( rates.size() );
+
     for ( unsigned int i = 0; i < numCoreRates; ++i )
         rates_[i] = rates[i]->copyWithVolScaling( getVolume(), 1, 1 );
+
     for ( unsigned int i = numCoreRates; i < rates.size(); ++i )
     {
         rates_[i] = rates[i]->copyWithVolScaling(  getVolume(),
@@ -337,7 +365,7 @@ void VoxelPools::updateRates( const double* s, double* yprime ) const
     }
 
     for (unsigned int i = 0; i < totVar; ++i)
-        *yprime++ = N.computeRowRate( i , v );
+        *yprime++ = N.computeRowRate( i, v );
     for (unsigned int i = 0; i < totInvar ; ++i)
         *yprime++ = 0.0;
 }
diff --git a/ksolve/VoxelPools.h b/ksolve/VoxelPools.h
index a8f0b4aef36a8fe7290eec8418d2716ef684878e..a39b151c4ed8185c29829c980a38bc5782169da9 100644
--- a/ksolve/VoxelPools.h
+++ b/ksolve/VoxelPools.h
@@ -1,6 +1,5 @@
 /**********************************************************************
 ** This program is part of 'MOOSE', the
-#include <boost/numeric/odeint.hpp>
 ** Messaging Object Oriented Simulation Environment.
 **           Copyright (C) 2003-2014 Upinder S. Bhalla. and NCBS
 ** It is made available under the terms of the
@@ -55,11 +54,7 @@ public:
 #ifdef USE_GSL      /* -----  not USE_BOOST_ODE  ----- */
     static int gslFunc( double t, const double* y, double *dydt, void* params);
 #elif  USE_BOOST_ODE
-    static void evalRates( const vector_type_& y
-                ,  vector_type_& dydt
-                ,  const double t
-                , VoxelPools* vp
-                );
+    static void evalRates( VoxelPools* vp, const vector_type_& y, vector_type_& dydt );
 #endif     /* -----  not USE_BOOST_ODE  ----- */
 
     //////////////////////////////////////////////////////////////////
@@ -102,10 +97,12 @@ private:
 #ifdef USE_GSL
     gsl_odeiv2_driver* driver_;
     gsl_odeiv2_system sys_;
-#elif USE_BOOST_ODE
-    BoostSys sys_;
 #endif
 
+    double absTol_;
+    double relTol_;
+    string method_;
+
 };
 
 #endif	// _VOXEL_POOLS_H
diff --git a/ksolve/ZombiePoolInterface.cpp b/ksolve/ZombiePoolInterface.cpp
index b75254d23441f59160fc54e4ca62993adcf8bd95..1df99ae25d9cfeacedc93bec5d2e27cc7a4e1571 100644
--- a/ksolve/ZombiePoolInterface.cpp
+++ b/ksolve/ZombiePoolInterface.cpp
@@ -30,8 +30,8 @@
 #include "../mesh/ChemCompt.h"
 
 ZombiePoolInterface::ZombiePoolInterface()
-		: stoich_(), compartment_(),
-		isBuilt_( false )
+    : stoich_(), compartment_(),
+      isBuilt_( false )
 {;}
 
 void ZombiePoolInterface::updateJunctions( double dt )
@@ -43,21 +43,24 @@ void ZombiePoolInterface::setPrev()
 
 Id ZombiePoolInterface::getCompartment() const
 {
-	return compartment_;
+    return compartment_;
 }
 
 void ZombiePoolInterface::setCompartment( Id compt )
 {
-	isBuilt_ = false; // We will have to now rebuild the whole thing.
-	if ( compt.element()->cinfo()->isA( "ChemCompt" ) ) {
-		compartment_ = compt;
-		vector< double > vols =
-			Field< vector < double > >::get( compt, "voxelVolume" );
-		if ( vols.size() > 0 ) {
-			setNumAllVoxels( vols.size() );
-			for ( unsigned int i = 0; i < vols.size(); ++i ) {
-				pools(i)->setVolume( vols[i] );
-			}
-		}
-	}
+    isBuilt_ = false; // We will have to now rebuild the whole thing.
+    if ( compt.element()->cinfo()->isA( "ChemCompt" ) )
+    {
+        compartment_ = compt;
+        vector< double > vols =
+            Field< vector < double > >::get( compt, "voxelVolume" );
+        if ( vols.size() > 0 )
+        {
+            setNumAllVoxels( vols.size() );
+            for ( unsigned int i = 0; i < vols.size(); ++i )
+            {
+                pools(i)->setVolume( vols[i] );
+            }
+        }
+    }
 }
diff --git a/ksolve/ZombiePoolInterface.h b/ksolve/ZombiePoolInterface.h
index fe5bb1d8d98e6b0dd93d8d1b888a4b6bf2c11b13..70d49954752f667fe02b51d507cb93f0968f7f78 100644
--- a/ksolve/ZombiePoolInterface.h
+++ b/ksolve/ZombiePoolInterface.h
@@ -18,112 +18,113 @@
  */
 class ZombiePoolInterface
 {
-	public:
-		ZombiePoolInterface();
-
-		/// Set initial # of molecules in given pool and voxel. Bdry cond.
-		virtual void setNinit( const Eref& e, double val ) = 0;
-		/// get initial # of molecules in given pool and voxel. Bdry cond.
-		virtual double getNinit( const Eref& e ) const = 0;
-
-		/// Set # of molecules in given pool and voxel. Varies with time.
-		virtual void setN( const Eref& e, double val ) = 0;
-		/// Get # of molecules in given pool and voxel. Varies with time.
-		virtual double getN( const Eref& e ) const = 0;
-
-		/// Diffusion constant: Only one per pool, voxel number is ignored.
-		virtual void setDiffConst( const Eref& e, double val ) = 0;
-		/// Diffusion constant: Only one per pool, voxel number is ignored.
-		virtual double getDiffConst( const Eref& e ) const = 0;
-
-		/// Motor constant: Only one per pool, voxel number is ignored.
-		/// Used only in Dsolves, so here I put in a dummy.
-		virtual void setMotorConst( const Eref& e, double val )
-		{;}
-
-		/// Specifies number of pools (species) handled by system.
-		virtual void setNumPools( unsigned int num ) = 0;
-		/// gets number of pools (species) handled by system.
-		virtual unsigned int getNumPools() const = 0;
-
-		/// Assign number of voxels (size of pools_ vector )
-		virtual void setNumAllVoxels( unsigned int numVoxels ) = 0;
-		/// Number of voxels here. pools_.size() == getNumLocalVoxels
-		virtual unsigned int getNumLocalVoxels() const = 0;
-		/// Return a pointer to the specified VoxelPool.
-		virtual VoxelPoolsBase* pools( unsigned int i ) = 0;
-
-		/// Return volume of voxel i.
-		virtual double volume( unsigned int i ) const = 0;
-
-		/**
-		 * Gets block of data. The first 4 entries are passed in
-		 * on the 'values' vector: the start voxel, numVoxels,
-		 * start pool#, numPools.
-		 * These are followed by numVoxels * numPools of data values
-		 * which are filled in by the function.
-		 * We assert that the entire requested block is present in
-		 * this ZombiePoolInterface.
-		 * The block is organized as an array of arrays of voxels;
-		 * values[pool#][voxel#]
-		 *
-		 * Note that numVoxels and numPools are the number in the current
-		 * block, not the upper limit of the block. So
-		 * values.size() == 4 + numPools * numVoxels.
-		 */
-		virtual void getBlock( vector< double >& values ) const = 0;
-
-		/**
-		 * Sets block of data. The first 4 entries
-		 * on the 'values' vector are the start voxel, numVoxels,
-		 * start pool#, numPools. These are
-		 * followed by numVoxels * numPools of data values.
-		 */
-		virtual void setBlock( const vector< double >& values ) = 0;
-
-		/**
-		 * Informs the ZPI about the stoich, used during subsequent
-		 * computations.
-		 * Called to wrap up the model building. The Stoich
-		 * does this call after it has set up its own path.
-		 */
-		virtual void setStoich( Id stoich ) = 0;
-
-		/// Assigns the diffusion solver. Used by the reac solvers
-		virtual void setDsolve( Id dsolve ) = 0;
-
-		/// Assigns compartment.
-		virtual void setCompartment( Id compartment );
-		Id getCompartment() const;
-
-		/// Used for telling Dsolver to handle all ops across Junctions
-		virtual void updateJunctions( double dt );
-		/// Used to tell Dsolver to assign 'prev' values.
-		virtual void setPrev();
-		/**
-		 * Informs the solver that the rate terms or volumes have changed
-		 * and that the parameters must be updated.
-		 * The index specifies which rateTerm to change, and if it is
-		 * ~0U it means update all of them.
-		 */
-		virtual void updateRateTerms( unsigned int index = ~0U ) = 0;
-
-		/// Return pool index, using Stoich ptr to do lookup.
-		virtual unsigned int getPoolIndex( const Eref& er ) const = 0;
-
-		//////////////////////////////////////////////////////////////
-	protected:
-		/**
-		 * Stoich is the class that sets up the reaction system and
-		 * manages the stoichiometry matrix
-		 */
-		Id stoich_;
-
-		/// Id of Chem compartment used to figure out volumes of voxels.
-		Id compartment_;
-
-		/// Flag: True when solver setup has been completed.
-		bool isBuilt_;
+public:
+    ZombiePoolInterface();
+
+    /// Set initial # of molecules in given pool and voxel. Bdry cond.
+    virtual void setNinit( const Eref& e, double val ) = 0;
+    /// get initial # of molecules in given pool and voxel. Bdry cond.
+    virtual double getNinit( const Eref& e ) const = 0;
+
+    /// Set # of molecules in given pool and voxel. Varies with time.
+    virtual void setN( const Eref& e, double val ) = 0;
+    /// Get # of molecules in given pool and voxel. Varies with time.
+    virtual double getN( const Eref& e ) const = 0;
+
+    /// Diffusion constant: Only one per pool, voxel number is ignored.
+    virtual void setDiffConst( const Eref& e, double val ) = 0;
+    /// Diffusion constant: Only one per pool, voxel number is ignored.
+    virtual double getDiffConst( const Eref& e ) const = 0;
+
+    /// Motor constant: Only one per pool, voxel number is ignored.
+    /// Used only in Dsolves, so here I put in a dummy.
+    virtual void setMotorConst( const Eref& e, double val )
+    {;}
+
+    /// Specifies number of pools (species) handled by system.
+    virtual void setNumPools( unsigned int num ) = 0;
+    /// gets number of pools (species) handled by system.
+    virtual unsigned int getNumPools() const = 0;
+
+    /// Assign number of voxels (size of pools_ vector )
+    virtual void setNumAllVoxels( unsigned int numVoxels ) = 0;
+    /// Number of voxels here. pools_.size() == getNumLocalVoxels
+    virtual unsigned int getNumLocalVoxels() const = 0;
+    /// Return a pointer to the specified VoxelPool.
+    virtual VoxelPoolsBase* pools( unsigned int i ) = 0;
+
+    /// Return volume of voxel i.
+    virtual double volume( unsigned int i ) const = 0;
+
+    /**
+     * Gets block of data. The first 4 entries are passed in
+     * on the 'values' vector: the start voxel, numVoxels,
+     * start pool#, numPools.
+     * These are followed by numVoxels * numPools of data values
+     * which are filled in by the function.
+     * We assert that the entire requested block is present in
+     * this ZombiePoolInterface.
+     * The block is organized as an array of arrays of voxels;
+     * values[pool#][voxel#]
+     *
+     * Note that numVoxels and numPools are the number in the current
+     * block, not the upper limit of the block. So
+     * values.size() == 4 + numPools * numVoxels.
+     */
+    virtual void getBlock( vector< double >& values ) const = 0;
+
+    /**
+     * Sets block of data. The first 4 entries
+     * on the 'values' vector are the start voxel, numVoxels,
+     * start pool#, numPools. These are
+     * followed by numVoxels * numPools of data values.
+     */
+    virtual void setBlock( const vector< double >& values ) = 0;
+
+    /**
+     * Informs the ZPI about the stoich, used during subsequent
+     * computations.
+     * Called to wrap up the model building. The Stoich
+     * does this call after it has set up its own path.
+     */
+    virtual void setStoich( Id stoich ) = 0;
+
+    /// Assigns the diffusion solver. Used by the reac solvers
+    virtual void setDsolve( Id dsolve ) = 0;
+
+    /// Assigns compartment.
+    virtual void setCompartment( Id compartment );
+    Id getCompartment() const;
+
+    /// Used for telling Dsolver to handle all ops across Junctions
+    virtual void updateJunctions( double dt );
+
+    /// Used to tell Dsolver to assign 'prev' values.
+    virtual void setPrev();
+    /**
+     * Informs the solver that the rate terms or volumes have changed
+     * and that the parameters must be updated.
+     * The index specifies which rateTerm to change, and if it is
+     * ~0U it means update all of them.
+     */
+    virtual void updateRateTerms( unsigned int index = ~0U ) = 0;
+
+    /// Return pool index, using Stoich ptr to do lookup.
+    virtual unsigned int getPoolIndex( const Eref& er ) const = 0;
+
+    //////////////////////////////////////////////////////////////
+protected:
+    /**
+     * Stoich is the class that sets up the reaction system and
+     * manages the stoichiometry matrix
+     */
+    Id stoich_;
+
+    /// Id of Chem compartment used to figure out volumes of voxels.
+    Id compartment_;
+
+    /// Flag: True when solver setup has been completed.
+    bool isBuilt_;
 };
 
-#endif	// _ZOMBIE_POOL_INTERFACE_H
+#endif    // _ZOMBIE_POOL_INTERFACE_H
diff --git a/mesh/CylMesh.cpp b/mesh/CylMesh.cpp
index 82cd895ffa2fcfdad6bc5aaee9318981c3c9e57b..9fc8352efc126290cf597757b79297428acaa39c 100644
--- a/mesh/CylMesh.cpp
+++ b/mesh/CylMesh.cpp
@@ -26,135 +26,135 @@
 #include "../utility/numutil.h"
 const Cinfo* CylMesh::initCinfo()
 {
-		//////////////////////////////////////////////////////////////
-		// Field Definitions
-		//////////////////////////////////////////////////////////////
-		static ElementValueFinfo< CylMesh, double > x0(
-			"x0",
-			"x coord of one end",
-			&CylMesh::setX0,
-			&CylMesh::getX0
-		);
-		static ElementValueFinfo< CylMesh, double > y0(
-			"y0",
-			"y coord of one end",
-			&CylMesh::setY0,
-			&CylMesh::getY0
-		);
-		static ElementValueFinfo< CylMesh, double > z0(
-			"z0",
-			"z coord of one end",
-			&CylMesh::setZ0,
-			&CylMesh::getZ0
-		);
-		static ElementValueFinfo< CylMesh, double > r0(
-			"r0",
-			"Radius of one end",
-			&CylMesh::setR0,
-			&CylMesh::getR0
-		);
-		static ElementValueFinfo< CylMesh, double > x1(
-			"x1",
-			"x coord of other end",
-			&CylMesh::setX1,
-			&CylMesh::getX1
-		);
-		static ElementValueFinfo< CylMesh, double > y1(
-			"y1",
-			"y coord of other end",
-			&CylMesh::setY1,
-			&CylMesh::getY1
-		);
-		static ElementValueFinfo< CylMesh, double > z1(
-			"z1",
-			"z coord of other end",
-			&CylMesh::setZ1,
-			&CylMesh::getZ1
-		);
-		static ElementValueFinfo< CylMesh, double > r1(
-			"r1",
-			"Radius of other end",
-			&CylMesh::setR1,
-			&CylMesh::getR1
-		);
-		static ElementValueFinfo< CylMesh, vector< double > > coords(
-			"coords",
-			"All the coords as a single vector: x0 y0 z0  x1 y1 z1  r0 r1 diffLength",
-			&CylMesh::setCoords,
-			&CylMesh::getCoords
-		);
-
-		static ElementValueFinfo< CylMesh, double > diffLength(
-			"diffLength",
-			"Length constant to use for subdivisions"
-			"The system will attempt to subdivide using compartments of"
-			"length diffLength on average. If the cylinder has different end"
-			"diameters r0 and r1, it will scale to smaller lengths"
-			"for the smaller diameter end and vice versa."
-			"Once the value is set it will recompute diffLength as "
-			"totLength/numEntries",
-			&CylMesh::setDiffLength,
-			&CylMesh::getDiffLength
-		);
-
-		static ReadOnlyValueFinfo< CylMesh, unsigned int > numDiffCompts(
-			"numDiffCompts",
-			"Number of diffusive compartments in model",
-			&CylMesh::innerGetNumEntries
-		);
-
-		static ReadOnlyValueFinfo< CylMesh, double > totLength(
-			"totLength",
-			"Total length of cylinder",
-			&CylMesh::getTotLength
-		);
-
-		//////////////////////////////////////////////////////////////
-		// MsgDest Definitions
-		//////////////////////////////////////////////////////////////
-
-		//////////////////////////////////////////////////////////////
-		// Field Elements
-		//////////////////////////////////////////////////////////////
-
-	static Finfo* cylMeshFinfos[] = {
-		&x0,			// Value
-		&y0,			// Value
-		&z0,			// Value
-		&r0,			// Value
-		&x1,			// Value
-		&y1,			// Value
-		&z1,			// Value
-		&r1,			// Value
-		&diffLength,			// Value
-		&coords,		// Value
-		&numDiffCompts,		// ReadOnlyValue
-		&totLength,		// ReadOnlyValue
-	};
-
-	static string doc[] =
-	{
-		"Name", "CylMesh",
-		"Author", "Upi Bhalla",
-		"Description", "Chemical compartment with cylindrical geometry. "
-				"Defaults to a uniform cylinder of radius 1 micron, "
-				"length 100 microns, and voxel length 1 micron so there "
-				"are 100 voxels in the cylinder. "
-				"The cylinder can be given a linear taper, by assigning "
-				"different radii r0 and r1 to the two ends. ",
-	};
-	static Dinfo< CylMesh > dinfo;
-	static Cinfo cylMeshCinfo (
-		"CylMesh",
-		ChemCompt::initCinfo(),
-		cylMeshFinfos,
-		sizeof( cylMeshFinfos ) / sizeof ( Finfo* ),
-		&dinfo,
-		doc,
+        //////////////////////////////////////////////////////////////
+        // Field Definitions
+        //////////////////////////////////////////////////////////////
+        static ElementValueFinfo< CylMesh, double > x0(
+            "x0",
+            "x coord of one end",
+            &CylMesh::setX0,
+            &CylMesh::getX0
+        );
+        static ElementValueFinfo< CylMesh, double > y0(
+            "y0",
+            "y coord of one end",
+            &CylMesh::setY0,
+            &CylMesh::getY0
+        );
+        static ElementValueFinfo< CylMesh, double > z0(
+            "z0",
+            "z coord of one end",
+            &CylMesh::setZ0,
+            &CylMesh::getZ0
+        );
+        static ElementValueFinfo< CylMesh, double > r0(
+            "r0",
+            "Radius of one end",
+            &CylMesh::setR0,
+            &CylMesh::getR0
+        );
+        static ElementValueFinfo< CylMesh, double > x1(
+            "x1",
+            "x coord of other end",
+            &CylMesh::setX1,
+            &CylMesh::getX1
+        );
+        static ElementValueFinfo< CylMesh, double > y1(
+            "y1",
+            "y coord of other end",
+            &CylMesh::setY1,
+            &CylMesh::getY1
+        );
+        static ElementValueFinfo< CylMesh, double > z1(
+            "z1",
+            "z coord of other end",
+            &CylMesh::setZ1,
+            &CylMesh::getZ1
+        );
+        static ElementValueFinfo< CylMesh, double > r1(
+            "r1",
+            "Radius of other end",
+            &CylMesh::setR1,
+            &CylMesh::getR1
+        );
+        static ElementValueFinfo< CylMesh, vector< double > > coords(
+            "coords",
+            "All the coords as a single vector: x0 y0 z0  x1 y1 z1  r0 r1 diffLength",
+            &CylMesh::setCoords,
+            &CylMesh::getCoords
+        );
+
+        static ElementValueFinfo< CylMesh, double > diffLength(
+            "diffLength",
+            "Length constant to use for subdivisions"
+            "The system will attempt to subdivide using compartments of"
+            "length diffLength on average. If the cylinder has different end"
+            "diameters r0 and r1, it will scale to smaller lengths"
+            "for the smaller diameter end and vice versa."
+            "Once the value is set it will recompute diffLength as "
+            "totLength/numEntries",
+            &CylMesh::setDiffLength,
+            &CylMesh::getDiffLength
+        );
+
+        static ReadOnlyValueFinfo< CylMesh, unsigned int > numDiffCompts(
+            "numDiffCompts",
+            "Number of diffusive compartments in model",
+            &CylMesh::innerGetNumEntries
+        );
+
+        static ReadOnlyValueFinfo< CylMesh, double > totLength(
+            "totLength",
+            "Total length of cylinder",
+            &CylMesh::getTotLength
+        );
+
+        //////////////////////////////////////////////////////////////
+        // MsgDest Definitions
+        //////////////////////////////////////////////////////////////
+
+        //////////////////////////////////////////////////////////////
+        // Field Elements
+        //////////////////////////////////////////////////////////////
+
+    static Finfo* cylMeshFinfos[] = {
+        &x0,            // Value
+        &y0,            // Value
+        &z0,            // Value
+        &r0,            // Value
+        &x1,            // Value
+        &y1,            // Value
+        &z1,            // Value
+        &r1,            // Value
+        &diffLength,            // Value
+        &coords,        // Value
+        &numDiffCompts,        // ReadOnlyValue
+        &totLength,        // ReadOnlyValue
+    };
+
+    static string doc[] =
+    {
+        "Name", "CylMesh",
+        "Author", "Upi Bhalla",
+        "Description", "Chemical compartment with cylindrical geometry. "
+                "Defaults to a uniform cylinder of radius 1 micron, "
+                "length 100 microns, and voxel length 1 micron so there "
+                "are 100 voxels in the cylinder. "
+                "The cylinder can be given a linear taper, by assigning "
+                "different radii r0 and r1 to the two ends. ",
+    };
+    static Dinfo< CylMesh > dinfo;
+    static Cinfo cylMeshCinfo (
+        "CylMesh",
+        ChemCompt::initCinfo(),
+        cylMeshFinfos,
+        sizeof( cylMeshFinfos ) / sizeof ( Finfo* ),
+        &dinfo,
+        doc,
         sizeof(doc)/sizeof(string)
-	);
+    );
 
-	return &cylMeshCinfo;
+    return &cylMeshCinfo;
 }
 
 //////////////////////////////////////////////////////////////
@@ -167,30 +167,30 @@ static const Cinfo* cylMeshCinfo = CylMesh::initCinfo();
 // Class stuff.
 //////////////////////////////////////////////////////////////////
 CylMesh::CylMesh()
-	:
-		numEntries_( 100 ),
-		useCaps_( 0 ),
-		isToroid_( false ),
-		x0_( 0.0 ),
-		y0_( 0.0 ),
-		z0_( 0.0 ),
-		x1_( 100.0e-6 ),
-		y1_( 0.0 ),
-		z1_( 0.0 ),
-		r0_( 1.0e-6 ),
-		r1_( 1.0e-6 ),
-		diffLength_( 1.0e-6 ),
-		surfaceGranularity_( 0.1 ),
-		totLen_( 100.0e-6 ),
-		rSlope_( 0.0 ),
-		lenSlope_( 0.0 )
+    :
+        numEntries_( 100 ),
+        useCaps_( 0 ),
+        isToroid_( false ),
+        x0_( 0.0 ),
+        y0_( 0.0 ),
+        z0_( 0.0 ),
+        x1_( 100.0e-6 ),
+        y1_( 0.0 ),
+        z1_( 0.0 ),
+        r0_( 1.0e-6 ),
+        r1_( 1.0e-6 ),
+        diffLength_( 1.0e-6 ),
+        surfaceGranularity_( 0.1 ),
+        totLen_( 100.0e-6 ),
+        rSlope_( 0.0 ),
+        lenSlope_( 0.0 )
 {
-	;
+    ;
 }
 
 CylMesh::~CylMesh()
 {
-	;
+    ;
 }
 
 //////////////////////////////////////////////////////////////////
@@ -204,213 +204,222 @@ CylMesh::~CylMesh()
  */
 void CylMesh::updateCoords( const Eref& e, const vector< double >& concs )
 {
-	double temp = sqrt(
-		( x1_ - x0_ ) * ( x1_ - x0_ ) +
-		( y1_ - y0_ ) * ( y1_ - y0_ ) +
-		( z1_ - z0_ ) * ( z1_ - z0_ )
-	);
-
-	if ( doubleEq( temp, 0.0 ) ) {
-		cout << "Error: CylMesh::updateCoords:\n"
-		"total length of compartment = 0 with these parameters\n";
-		return;
-	}
-	totLen_ = temp;
-
-
-	temp = totLen_ / diffLength_;
-	if ( temp < 1.0 ) {
-		diffLength_ = totLen_;
-		numEntries_ = 1;
-	} else {
-		numEntries_ = static_cast< unsigned int >( round ( temp ) );
-		diffLength_ = totLen_ / numEntries_;
-	}
-	rSlope_ = ( r1_ - r0_ ) / numEntries_;
-	lenSlope_ = diffLength_ * rSlope_ * 2 / ( r0_ + r1_ );
-
-	// dx2_[0] = diffLength_;
-	// dx2_[1] = diffLength_;
-	buildStencil();
-	setChildConcs( e, concs, 0 );
+    double temp = sqrt(
+        ( x1_ - x0_ ) * ( x1_ - x0_ ) +
+        ( y1_ - y0_ ) * ( y1_ - y0_ ) +
+        ( z1_ - z0_ ) * ( z1_ - z0_ )
+    );
+
+    if ( doubleEq( temp, 0.0 ) ) {
+        cout << "Error: CylMesh::updateCoords:\n"
+        "total length of compartment = 0 with these parameters\n";
+        return;
+    }
+    totLen_ = temp;
+
+    temp = totLen_ / diffLength_;
+    if ( temp < 1.0 ) {
+        diffLength_ = totLen_;
+        numEntries_ = 1;
+    } else {
+        numEntries_ = static_cast< unsigned int >( round ( temp ) );
+        diffLength_ = totLen_ / numEntries_;
+    }
+    rSlope_ = ( r1_ - r0_ ) / numEntries_;
+    lenSlope_ = diffLength_ * rSlope_ * 2 / ( r0_ + r1_ );
+
+    // dx2_[0] = diffLength_;
+    // dx2_[1] = diffLength_;
+    buildStencil();
+    setChildConcs( e, concs, 0 );
 }
 
 void CylMesh::setX0( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	x0_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    x0_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getX0( const Eref& e ) const
 {
-	return x0_;
+    return x0_;
 }
 
 void CylMesh::setY0( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	y0_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    y0_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getY0( const Eref& e ) const
 {
-	return y0_;
+    return y0_;
 }
 
 void CylMesh::setZ0( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	z0_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    z0_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getZ0( const Eref& e ) const
 {
-	return z0_;
+    return z0_;
 }
 
 void CylMesh::setR0( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	r0_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    r0_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getR0( const Eref& e ) const
 {
-	return r0_;
+    return r0_;
 }
 
 
 void CylMesh::setX1( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	x1_ = v;
-	updateCoords( e, childConcs );
+
+    size_t numVoxels = (v - x0_) / diffLength_;
+    if( numVoxels > SM_MAX_COLUMNS )
+    {
+        cout << "Warn: Compartment is too big. With diffusion-length of " << diffLength_ 
+            << " total " << numVoxels << " would be generated which is larger than maximum "
+            <<  SM_MAX_COLUMNS << " allowed. Ignoring .." << endl;
+        return;
+    }
+
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    x1_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getX1( const Eref& e ) const
 {
-	return x1_;
+    return x1_;
 }
 
 void CylMesh::setY1( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	y1_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    y1_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getY1( const Eref& e ) const
 {
-	return y1_;
+    return y1_;
 }
 
 void CylMesh::setZ1( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	z1_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    z1_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getZ1( const Eref& e ) const
 {
-	return z1_;
+    return z1_;
 }
 
 void CylMesh::setR1( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	r1_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    r1_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getR1( const Eref& e ) const
 {
-	return r1_;
+    return r1_;
 }
 
 void CylMesh::innerSetCoords( const Eref& e, const vector< double >& v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	x0_ = v[0];
-	y0_ = v[1];
-	z0_ = v[2];
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    x0_ = v[0];
+    y0_ = v[1];
+    z0_ = v[2];
 
-	x1_ = v[3];
-	y1_ = v[4];
-	z1_ = v[5];
+    x1_ = v[3];
+    y1_ = v[4];
+    z1_ = v[5];
 
-	r0_ = v[6];
-	r1_ = v[7];
+    r0_ = v[6];
+    r1_ = v[7];
 
-	diffLength_ = v[8];
+    diffLength_ = v[8];
 
-	updateCoords( e, childConcs );
+    updateCoords( e, childConcs );
 }
 
 void CylMesh::setCoords( const Eref& e, vector< double > v )
 {
-	if ( v.size() < 9 ) {
-		cout << "CylMesh::setCoords: Warning: size of argument vec should be >= 9, was " << v.size() << endl;
-	}
-	innerSetCoords( e, v );
-	transmitChange( e );
+    if ( v.size() < 9 ) {
+        cout << "CylMesh::setCoords: Warning: size of argument vec should be >= 9, was " << v.size() << endl;
+    }
+    innerSetCoords( e, v );
+    transmitChange( e );
 }
 
 vector< double > CylMesh::getCoords( const Eref& e ) const
 {
-	vector< double > ret( 9 );
+    vector< double > ret( 9 );
 
-	ret[0] = x0_;
-	ret[1] = y0_;
-	ret[2] = z0_;
+    ret[0] = x0_;
+    ret[1] = y0_;
+    ret[2] = z0_;
 
-	ret[3] = x1_;
-	ret[4] = y1_;
-	ret[5] = z1_;
+    ret[3] = x1_;
+    ret[4] = y1_;
+    ret[5] = z1_;
 
-	ret[6] = r0_;
-	ret[7] = r1_;
+    ret[6] = r0_;
+    ret[7] = r1_;
 
-	ret[8] = diffLength_;
-	return ret;
+    ret[8] = diffLength_;
+    return ret;
 }
 
 
 void CylMesh::setDiffLength( const Eref& e, double v )
 {
-	vector< double > childConcs;
-	getChildConcs( e, childConcs );
-	diffLength_ = v;
-	updateCoords( e, childConcs );
+    vector< double > childConcs;
+    getChildConcs( e, childConcs );
+    diffLength_ = v;
+    updateCoords( e, childConcs );
 }
 
 double CylMesh::getDiffLength( const Eref& e ) const
 {
-	return diffLength_;
+    return diffLength_;
 }
 
 
 double CylMesh::getTotLength() const
 {
-	return totLen_;
+    return totLen_;
 }
 
 unsigned int CylMesh::innerGetDimensions() const
 {
-	return 3;
+    return 3;
 }
 
 //////////////////////////////////////////////////////////////////
@@ -420,16 +429,16 @@ unsigned int CylMesh::innerGetDimensions() const
 /// Virtual function to return MeshType of specified entry.
 unsigned int CylMesh::getMeshType( unsigned int fid ) const
 {
-	if ( !isToroid_ && useCaps_ && ( fid == 0 || fid == numEntries_ - 1 ) )
-		return SPHERE_SHELL_SEG;
+    if ( !isToroid_ && useCaps_ && ( fid == 0 || fid == numEntries_ - 1 ) )
+        return SPHERE_SHELL_SEG;
 
-	return CYL;
+    return CYL;
 }
 
 /// Virtual function to return dimensions of specified entry.
 unsigned int CylMesh::getMeshDimensions( unsigned int fid ) const
 {
-	return 3;
+    return 3;
 }
 
 /**
@@ -476,103 +485,103 @@ unsigned int CylMesh::getMeshDimensions( unsigned int fid ) const
 /// Virtual function to return volume of mesh Entry.
 double CylMesh::getMeshEntryVolume( unsigned int fid ) const
 {
- 	double len0 = diffLength_ * 2 * r0_ / ( r0_ + r1_ );
+     double len0 = diffLength_ * 2 * r0_ / ( r0_ + r1_ );
 
-	double ri = r0_ + (fid + 0.5) * rSlope_;
-	double leni = len0 + ( fid + 0.5 ) * lenSlope_;
+    double ri = r0_ + (fid + 0.5) * rSlope_;
+    double leni = len0 + ( fid + 0.5 ) * lenSlope_;
 
-	return leni * ri * ri * PI;
+    return leni * ri * ri * PI;
 }
 
 /// Virtual function to return coords of mesh Entry.
 /// For Cylindrical mesh, coords are x1y1z1 x2y2z2 r0 r1 phi0 phi1
 vector< double > CylMesh::getCoordinates( unsigned int fid ) const
 {
-	vector< double > ret(10, 0.0);
- 	double len0 = diffLength_ * 2 * r0_ / ( r0_ + r1_ );
- 	// double len0 = diffLength_ * 2 * ( r0_ + rSlope_ / 0.5) / ( r0_ + r1_ );
-	double lenStart = len0 + lenSlope_ * 0.5;
+    vector< double > ret(10, 0.0);
+     double len0 = diffLength_ * 2 * r0_ / ( r0_ + r1_ );
+     // double len0 = diffLength_ * 2 * ( r0_ + rSlope_ / 0.5) / ( r0_ + r1_ );
+    double lenStart = len0 + lenSlope_ * 0.5;
 
-	double axialStart = fid * lenStart + ( ( fid * (fid - 1 ) )/2 ) * lenSlope_;
-		// fid * totLen_/numEntries_ + (fid - frac ) * lenSlope_;
-	double axialEnd =
-		(fid + 1) * lenStart + ( ( fid * (fid + 1 ) )/2 ) * lenSlope_;
-		// (fid + 1) * totLen_/numEntries_ + (fid - frac + 1.0) * lenSlope_;
+    double axialStart = fid * lenStart + ( ( fid * (fid - 1 ) )/2 ) * lenSlope_;
+        // fid * totLen_/numEntries_ + (fid - frac ) * lenSlope_;
+    double axialEnd =
+        (fid + 1) * lenStart + ( ( fid * (fid + 1 ) )/2 ) * lenSlope_;
+        // (fid + 1) * totLen_/numEntries_ + (fid - frac + 1.0) * lenSlope_;
 
-	ret[0] = x0_ + (x1_ - x0_ ) * axialStart/totLen_;
-	ret[1] = y0_ + (y1_ - y0_ ) * axialStart/totLen_;
-	ret[2] = z0_ + (z1_ - z0_ ) * axialStart/totLen_;
+    ret[0] = x0_ + (x1_ - x0_ ) * axialStart/totLen_;
+    ret[1] = y0_ + (y1_ - y0_ ) * axialStart/totLen_;
+    ret[2] = z0_ + (z1_ - z0_ ) * axialStart/totLen_;
 
-	ret[3] = x0_ + (x1_ - x0_ ) * axialEnd/totLen_;
-	ret[4] = y0_ + (y1_ - y0_ ) * axialEnd/totLen_;
-	ret[5] = z0_ + (z1_ - z0_ ) * axialEnd/totLen_;
+    ret[3] = x0_ + (x1_ - x0_ ) * axialEnd/totLen_;
+    ret[4] = y0_ + (y1_ - y0_ ) * axialEnd/totLen_;
+    ret[5] = z0_ + (z1_ - z0_ ) * axialEnd/totLen_;
 
-	ret[6] = r0_ + fid * rSlope_;
-	ret[7] = r0_ + (fid + 1.0) * rSlope_;
+    ret[6] = r0_ + fid * rSlope_;
+    ret[7] = r0_ + (fid + 1.0) * rSlope_;
 
-	ret[8] = 0;
-	ret[9] = 0;
+    ret[8] = 0;
+    ret[9] = 0;
 
-	return ret;
+    return ret;
 }
 
 /// Virtual function to return diffusion X-section area for each neighbor
 vector< double > CylMesh::getDiffusionArea( unsigned int fid ) const
 {
-	if ( numEntries_ <= 1 )
-		return vector< double >( 0 );
-
-	double rlow = r0_ + fid * rSlope_;
-	double rhigh = r0_ + (fid + 1.0) * rSlope_;
-
-	if ( fid == 0 ) {
-		if ( isToroid_ ) {
-			vector < double > ret( 2 );
-			ret[0] = rlow * rlow * PI;
-			ret[1] = rhigh * rhigh * PI;
-			return ret;
-		} else {
-			return vector < double >( 1, rhigh * rhigh * PI );
-		}
-	}
-
-	if ( fid == (numEntries_ - 1 ) ) {
-		if ( isToroid_ ) {
-			vector < double > ret( 2 );
-			ret[0] = rlow * rlow * PI;
-			ret[1] = r0_ * r0_ * PI; // Wrapping around
-			return ret;
-		} else {
-			return vector < double >( 1, rlow * rlow * PI );
-		}
-	}
-	vector< double > ret( 2 );
-	ret[0] = rlow * rlow * PI;
-	ret[1] = rhigh * rhigh * PI;
-	return ret;
+    if ( numEntries_ <= 1 )
+        return vector< double >( 0 );
+
+    double rlow = r0_ + fid * rSlope_;
+    double rhigh = r0_ + (fid + 1.0) * rSlope_;
+
+    if ( fid == 0 ) {
+        if ( isToroid_ ) {
+            vector < double > ret( 2 );
+            ret[0] = rlow * rlow * PI;
+            ret[1] = rhigh * rhigh * PI;
+            return ret;
+        } else {
+            return vector < double >( 1, rhigh * rhigh * PI );
+        }
+    }
+
+    if ( fid == (numEntries_ - 1 ) ) {
+        if ( isToroid_ ) {
+            vector < double > ret( 2 );
+            ret[0] = rlow * rlow * PI;
+            ret[1] = r0_ * r0_ * PI; // Wrapping around
+            return ret;
+        } else {
+            return vector < double >( 1, rlow * rlow * PI );
+        }
+    }
+    vector< double > ret( 2 );
+    ret[0] = rlow * rlow * PI;
+    ret[1] = rhigh * rhigh * PI;
+    return ret;
 }
 
 /// Virtual function to return scale factor for diffusion. 1 here.
 vector< double > CylMesh::getDiffusionScaling( unsigned int fid ) const
 {
-	if ( numEntries_ <= 1 )
-		return vector< double >( 0 );
+    if ( numEntries_ <= 1 )
+        return vector< double >( 0 );
 
-	if ( !isToroid_ && ( fid == 0 || fid == (numEntries_ - 1) ) )
-		return vector< double >( 1, 1.0 );
+    if ( !isToroid_ && ( fid == 0 || fid == (numEntries_ - 1) ) )
+        return vector< double >( 1, 1.0 );
 
-	return vector< double >( 2, 1.0 );
+    return vector< double >( 2, 1.0 );
 }
 
 /// Virtual function to return volume of mesh Entry, including
 /// for diffusively coupled voxels from other solvers.
 double CylMesh::extendedMeshEntryVolume( unsigned int fid ) const
 {
-	if ( fid < numEntries_ ) {
-		return getMeshEntryVolume( fid );
-	} else {
-		return MeshCompt::extendedMeshEntryVolume( fid - numEntries_ );
-	}
+    if ( fid < numEntries_ ) {
+        return getMeshEntryVolume( fid );
+    } else {
+        return MeshCompt::extendedMeshEntryVolume( fid - numEntries_ );
+    }
 }
 
 //////////////////////////////////////////////////////////////////
@@ -581,31 +590,31 @@ double CylMesh::extendedMeshEntryVolume( unsigned int fid ) const
 
 /// More inherited virtual funcs: request comes in for mesh stats
 void CylMesh::innerHandleRequestMeshStats( const Eref& e,
-		const SrcFinfo2< unsigned int, vector< double > >* meshStatsFinfo
-	)
+        const SrcFinfo2< unsigned int, vector< double > >* meshStatsFinfo
+    )
 {
-	vector< double > ret( vGetEntireVolume() / numEntries_ ,1 );
-	meshStatsFinfo->send( e, 1, ret );
+    vector< double > ret( vGetEntireVolume() / numEntries_ ,1 );
+    meshStatsFinfo->send( e, 1, ret );
 }
 
 void CylMesh::innerHandleNodeInfo(
-			const Eref& e,
-			unsigned int numNodes, unsigned int numThreads )
+            const Eref& e,
+            unsigned int numNodes, unsigned int numThreads )
 {
-		/*
-	unsigned int numEntries = numEntries_;
-	vector< double > vols( numEntries, volume_ / numEntries );
-	vector< unsigned int > localEntries( numEntries );
-	vector< vector< unsigned int > > outgoingEntries;
-	vector< vector< unsigned int > > incomingEntries;
-	*/
-	/*
-	double oldvol = getMeshEntryVolume( 0 );
-	meshSplit()->send( e,
-		oldvol,
-		vols, localEntries,
-		outgoingEntries, incomingEntries );
-		*/
+        /*
+    unsigned int numEntries = numEntries_;
+    vector< double > vols( numEntries, volume_ / numEntries );
+    vector< unsigned int > localEntries( numEntries );
+    vector< vector< unsigned int > > outgoingEntries;
+    vector< vector< unsigned int > > incomingEntries;
+    */
+    /*
+    double oldvol = getMeshEntryVolume( 0 );
+    meshSplit()->send( e,
+        oldvol,
+        vols, localEntries,
+        outgoingEntries, incomingEntries );
+        */
 }
 //////////////////////////////////////////////////////////////////
 
@@ -614,7 +623,7 @@ void CylMesh::innerHandleNodeInfo(
  */
 unsigned int CylMesh::innerGetNumEntries() const
 {
-	return numEntries_;
+    return numEntries_;
 }
 
 /**
@@ -622,116 +631,116 @@ unsigned int CylMesh::innerGetNumEntries() const
  */
 void CylMesh::innerSetNumEntries( unsigned int n )
 {
-	static const unsigned int WayTooLarge = 1000000;
-	if ( n == 0 || n > WayTooLarge ) {
-		cout << "Warning: CylMesh::innerSetNumEntries( " << n <<
-		" ): out of range\n";
-		return;
-	}
-	assert( n > 0 );
-	numEntries_ = n;
-	diffLength_ = totLen_ / n;
-	rSlope_ = ( r1_ - r0_ ) / numEntries_;
-	lenSlope_ = diffLength_ * rSlope_ * 2 / ( r0_ + r1_ );
-
-	buildStencil();
+    static const unsigned int WayTooLarge = 1000000;
+    if ( n == 0 || n > WayTooLarge ) {
+        cout << "Warning: CylMesh::innerSetNumEntries( " << n <<
+        " ): out of range\n";
+        return;
+    }
+    assert( n > 0 );
+    numEntries_ = n;
+    diffLength_ = totLen_ / n;
+    rSlope_ = ( r1_ - r0_ ) / numEntries_;
+    lenSlope_ = diffLength_ * rSlope_ * 2 / ( r0_ + r1_ );
+
+    buildStencil();
 }
 
 
 void CylMesh::innerBuildDefaultMesh( const Eref& e,
-	double volume, unsigned int numEntries )
+    double volume, unsigned int numEntries )
 {
-	/// Single voxel cylinder with diameter = length.
-	/// vol = volume = pi.r^2.len.
-	/// So len = 2r, volume = pi*r^2*2r = 2pi*r^3 so r = (volume/2pi)^(1/3)
-	double r = pow( ( volume / ( PI * 2 ) ), 1.0 / 3 );
-	vector< double > coords( 9, 0 );
-	coords[3] = 2 * r;
-	coords[6] = r;
-	coords[7] = r;
-	coords[8] = 2 * r / numEntries;
-	setCoords( e, coords );
+    /// Single voxel cylinder with diameter = length.
+    /// vol = volume = pi.r^2.len.
+    /// So len = 2r, volume = pi*r^2*2r = 2pi*r^3 so r = (volume/2pi)^(1/3)
+    double r = pow( ( volume / ( PI * 2 ) ), 1.0 / 3 );
+    vector< double > coords( 9, 0 );
+    coords[3] = 2 * r;
+    coords[6] = r;
+    coords[7] = r;
+    coords[8] = 2 * r / numEntries;
+    setCoords( e, coords );
 }
 
 vector< unsigned int > CylMesh::getParentVoxel() const
 {
-	vector< unsigned int > ret( numEntries_ );
-	if ( numEntries_ > 0 )
-		ret[0] = static_cast< unsigned int >( -1 );
-	for (unsigned int i = 1; i < numEntries_; ++i )
-		ret[i] = i-1;
+    vector< unsigned int > ret( numEntries_ );
+    if ( numEntries_ > 0 )
+        ret[0] = static_cast< unsigned int >( -1 );
+    for (unsigned int i = 1; i < numEntries_; ++i )
+        ret[i] = i-1;
 
-	return ret;
+    return ret;
 }
 
 const vector< double >& CylMesh::vGetVoxelVolume() const
 {
-	static vector< double > vol;
-	vol.resize( numEntries_ );
-	for ( unsigned int i = 0; i < numEntries_; ++i )
-		vol[i] = getMeshEntryVolume( i );
-	return vol;
+    static vector< double > vol;
+    vol.resize( numEntries_ );
+    for ( unsigned int i = 0; i < numEntries_; ++i )
+        vol[i] = getMeshEntryVolume( i );
+    return vol;
 }
 
 const vector< double >& CylMesh::vGetVoxelMidpoint() const
 {
-	static vector< double > midpoint( numEntries_ * 3, 0.0 );
-	midpoint.resize( numEntries_ * 3 );
-	double dx = ( x1_ - x0_ ) / numEntries_;
-	double dy = ( y1_ - y0_ ) / numEntries_;
-	double dz = ( z1_ - z0_ ) / numEntries_;
-	vector< double >::iterator j = midpoint.begin();
-	for ( unsigned int i = 0; i < numEntries_; ++i )
-		*j++ = x0_ + dx * i;
-	for ( unsigned int i = 0; i < numEntries_; ++i )
-		*j++ = y0_ + dy * i;
-	for ( unsigned int i = 0; i < numEntries_; ++i )
-		*j++ = z0_ + dz * i;
-
-	return midpoint;
+    static vector< double > midpoint( numEntries_ * 3, 0.0 );
+    midpoint.resize( numEntries_ * 3 );
+    double dx = ( x1_ - x0_ ) / numEntries_;
+    double dy = ( y1_ - y0_ ) / numEntries_;
+    double dz = ( z1_ - z0_ ) / numEntries_;
+    vector< double >::iterator j = midpoint.begin();
+    for ( unsigned int i = 0; i < numEntries_; ++i )
+        *j++ = x0_ + dx * i;
+    for ( unsigned int i = 0; i < numEntries_; ++i )
+        *j++ = y0_ + dy * i;
+    for ( unsigned int i = 0; i < numEntries_; ++i )
+        *j++ = z0_ + dz * i;
+
+    return midpoint;
 }
 
 const vector< double >& CylMesh::getVoxelArea() const
 {
-	static vector< double > area;
-	area.resize( numEntries_ );
-	for ( unsigned int i = 0; i < numEntries_; ++i ) {
-		double frac = ( 0.5 + static_cast< double >( i ) ) /
-			static_cast< double >( numEntries_ );
-		double r = r0_ * ( 1.0 - frac ) + r1_ * frac;
-		area[i] = r * r * PI;
-	}
-	return area;
+    static vector< double > area;
+    area.resize( numEntries_ );
+    for ( unsigned int i = 0; i < numEntries_; ++i ) {
+        double frac = ( 0.5 + static_cast< double >( i ) ) /
+            static_cast< double >( numEntries_ );
+        double r = r0_ * ( 1.0 - frac ) + r1_ * frac;
+        area[i] = r * r * PI;
+    }
+    return area;
 }
 
 const vector< double >& CylMesh::getVoxelLength() const
 {
-	static vector< double > length;
-	length.assign( numEntries_, totLen_ / numEntries_ );
-	return length;
+    static vector< double > length;
+    length.assign( numEntries_, totLen_ / numEntries_ );
+    return length;
 }
 
 double CylMesh::vGetEntireVolume() const
 {
-	double vol = 0.0;
-	for ( unsigned int i = 0; i < numEntries_; ++i )
-		vol += getMeshEntryVolume( i );
-	return vol;
+    double vol = 0.0;
+    for ( unsigned int i = 0; i < numEntries_; ++i )
+        vol += getMeshEntryVolume( i );
+    return vol;
 }
 
 bool CylMesh::vSetVolumeNotRates( double volume )
 {
-	double oldVol = vGetEntireVolume();
-	double linScale = pow( volume/oldVol, 1.0 / 3.0 );
-	x1_ *= linScale;
-	y1_ *= linScale;
-	z1_ *= linScale;
-	r0_ *= linScale;
-	r1_ *= linScale;
-	totLen_ *= linScale;
-	// Have to scale this so numEntries remains the same.
-	diffLength_ = totLen_ / numEntries_;
-	return true;
+    double oldVol = vGetEntireVolume();
+    double linScale = pow( volume/oldVol, 1.0 / 3.0 );
+    x1_ *= linScale;
+    y1_ *= linScale;
+    z1_ *= linScale;
+    r0_ *= linScale;
+    r1_ *= linScale;
+    totLen_ *= linScale;
+    // Have to scale this so numEntries remains the same.
+    diffLength_ = totLen_ / numEntries_;
+    return true;
 }
 
 //////////////////////////////////////////////////////////////////
@@ -740,43 +749,43 @@ bool CylMesh::vSetVolumeNotRates( double volume )
 
 void CylMesh::transmitChange( const Eref& e )
 {
-		/*
-	Id meshEntry( e.id().value() + 1 );
-	assert(
-		meshEntry.eref().data() == reinterpret_cast< char* >( lookupEntry( 0 ) )
-	);
-	double oldvol = getMeshEntryVolume( 0 );
-	unsigned int totalNumEntries = numEntries_;
-	unsigned int localNumEntries = totalNumEntries;
-	unsigned int startEntry = 0;
-	vector< unsigned int > localIndices( localNumEntries ); // empty
-	for ( unsigned int i = 0; i < localNumEntries; ++i )
-		localIndices[i] = i;
-	vector< double > vols( localNumEntries, volume_ / numEntries_ );
-	vector< vector< unsigned int > > outgoingEntries; // [node#][Entry#]
-	vector< vector< unsigned int > > incomingEntries; // [node#][Entry#]
-
-	// This function updates the size of the FieldDataHandler for the
-	// MeshEntries.
-	DataHandler* dh = meshEntry.element()->dataHandler();
-	FieldDataHandlerBase* fdh = dynamic_cast< FieldDataHandlerBase* >( dh );
-	assert( fdh );
-	if ( totalNumEntries > fdh->getMaxFieldEntries() ) {
-		fdh->setMaxFieldEntries( localNumEntries );
-	}
-
-	// This message tells the Stoich about the new mesh, and also about
-	// how it communicates with other nodes.
-	meshSplit()->fastSend( e,
-		oldvol,
-		vols, localIndices,
-		outgoingEntries, incomingEntries );
-
-	// This func goes down to the MeshEntry to tell all the pools and
-	// Reacs to deal with the new mesh. They then update the stoich.
-	lookupEntry( 0 )->triggerRemesh( meshEntry.eref(),
-		oldvol, startEntry, localIndices, vols );
-		*/
+        /*
+    Id meshEntry( e.id().value() + 1 );
+    assert(
+        meshEntry.eref().data() == reinterpret_cast< char* >( lookupEntry( 0 ) )
+    );
+    double oldvol = getMeshEntryVolume( 0 );
+    unsigned int totalNumEntries = numEntries_;
+    unsigned int localNumEntries = totalNumEntries;
+    unsigned int startEntry = 0;
+    vector< unsigned int > localIndices( localNumEntries ); // empty
+    for ( unsigned int i = 0; i < localNumEntries; ++i )
+        localIndices[i] = i;
+    vector< double > vols( localNumEntries, volume_ / numEntries_ );
+    vector< vector< unsigned int > > outgoingEntries; // [node#][Entry#]
+    vector< vector< unsigned int > > incomingEntries; // [node#][Entry#]
+
+    // This function updates the size of the FieldDataHandler for the
+    // MeshEntries.
+    DataHandler* dh = meshEntry.element()->dataHandler();
+    FieldDataHandlerBase* fdh = dynamic_cast< FieldDataHandlerBase* >( dh );
+    assert( fdh );
+    if ( totalNumEntries > fdh->getMaxFieldEntries() ) {
+        fdh->setMaxFieldEntries( localNumEntries );
+    }
+
+    // This message tells the Stoich about the new mesh, and also about
+    // how it communicates with other nodes.
+    meshSplit()->fastSend( e,
+        oldvol,
+        vols, localIndices,
+        outgoingEntries, incomingEntries );
+
+    // This func goes down to the MeshEntry to tell all the pools and
+    // Reacs to deal with the new mesh. They then update the stoich.
+    lookupEntry( 0 )->triggerRemesh( meshEntry.eref(),
+        oldvol, startEntry, localIndices, vols );
+        */
 }
 
 //////////////////////////////////////////////////////////////////
@@ -784,40 +793,40 @@ void CylMesh::transmitChange( const Eref& e )
 //////////////////////////////////////////////////////////////////
 void CylMesh::buildStencil()
 {
-	setStencilSize( numEntries_, numEntries_ );
-	for ( unsigned int i = 0; i < numEntries_; ++i ) {
-		double rLow = r0_ + i * rSlope_;
-		double rHigh = r0_ + (i + 1.0) * rSlope_;
-		double aLow = rLow * rLow * PI;
-		double aHigh = rHigh * rHigh * PI;
-		vector< double > entry;
-		vector< unsigned int > colIndex;
-		if ( i == 0 ) {
-			colIndex.push_back( 1 );
-			entry.push_back( aHigh / diffLength_ );
-			if ( isToroid_ ) {
-				colIndex.push_back( numEntries_ - 1 );
-				entry.push_back( aLow / diffLength_ );
-			}
-		} else if ( i == numEntries_ - 1 ) {
-			if ( isToroid_ ) {
-				colIndex.push_back( 0 );
-				if ( r0_ < r1_ )
-					entry.push_back( r0_ * r0_ * PI / diffLength_ );
-				else
-					entry.push_back( r1_ * r1_ * PI / diffLength_ );
-			}
-			colIndex.push_back( numEntries_ - 2 );
-			entry.push_back( aLow / diffLength_ );
-		} else { // Mostly it is in the middle.
-			colIndex.push_back( i - 1 );
-			entry.push_back( aLow / diffLength_ );
-			colIndex.push_back( i + 1 );
-			entry.push_back( aHigh / diffLength_ );
-		}
-		addRow( i, entry, colIndex );
-	}
-	innerResetStencil();
+    setStencilSize( numEntries_, numEntries_ );
+    for ( unsigned int i = 0; i < numEntries_; ++i ) {
+        double rLow = r0_ + i * rSlope_;
+        double rHigh = r0_ + (i + 1.0) * rSlope_;
+        double aLow = rLow * rLow * PI;
+        double aHigh = rHigh * rHigh * PI;
+        vector< double > entry;
+        vector< unsigned int > colIndex;
+        if ( i == 0 ) {
+            colIndex.push_back( 1 );
+            entry.push_back( aHigh / diffLength_ );
+            if ( isToroid_ ) {
+                colIndex.push_back( numEntries_ - 1 );
+                entry.push_back( aLow / diffLength_ );
+            }
+        } else if ( i == numEntries_ - 1 ) {
+            if ( isToroid_ ) {
+                colIndex.push_back( 0 );
+                if ( r0_ < r1_ )
+                    entry.push_back( r0_ * r0_ * PI / diffLength_ );
+                else
+                    entry.push_back( r1_ * r1_ * PI / diffLength_ );
+            }
+            colIndex.push_back( numEntries_ - 2 );
+            entry.push_back( aLow / diffLength_ );
+        } else { // Mostly it is in the middle.
+            colIndex.push_back( i - 1 );
+            entry.push_back( aLow / diffLength_ );
+            colIndex.push_back( i + 1 );
+            entry.push_back( aHigh / diffLength_ );
+        }
+        addRow( i, entry, colIndex );
+    }
+    innerResetStencil();
 }
 
 //////////////////////////////////////////////////////////////////
@@ -825,15 +834,15 @@ void CylMesh::buildStencil()
 //////////////////////////////////////////////////////////////////
 
 void CylMesh::matchMeshEntries( const ChemCompt* other,
-	   vector< VoxelJunction >& ret ) const
+       vector< VoxelJunction >& ret ) const
 {
-	// This is seriously ugly, and what virtual funcs were meant to handle.
-	// Dirty hack for now.
-	const CylMesh* cyl = dynamic_cast< const CylMesh* >( other );
-	if ( cyl ) {
-		matchCylMeshEntries( cyl, ret );
-		return;
-	}
+    // This is seriously ugly, and what virtual funcs were meant to handle.
+    // Dirty hack for now.
+    const CylMesh* cyl = dynamic_cast< const CylMesh* >( other );
+    if ( cyl ) {
+        matchCylMeshEntries( cyl, ret );
+        return;
+    }
     const EndoMesh* em = dynamic_cast< const EndoMesh* >( other );
     if ( em )
     {
@@ -841,18 +850,18 @@ void CylMesh::matchMeshEntries( const ChemCompt* other,
         flipRet( ret );
         return;
     }
-	const CubeMesh* cube = dynamic_cast< const CubeMesh* >( other );
-	if ( cube ) {
-		matchCubeMeshEntries( cube, ret );
-		return;
-	}
-	const NeuroMesh* nm = dynamic_cast< const NeuroMesh* >( other );
-	if ( nm ) {
-		matchNeuroMeshEntries( nm, ret );
-		return;
-	}
-	cout << "Warning:CylMesh::matchMeshEntries: "  << 
-			" unknown mesh type\n";
+    const CubeMesh* cube = dynamic_cast< const CubeMesh* >( other );
+    if ( cube ) {
+        matchCubeMeshEntries( cube, ret );
+        return;
+    }
+    const NeuroMesh* nm = dynamic_cast< const NeuroMesh* >( other );
+    if ( nm ) {
+        matchNeuroMeshEntries( nm, ret );
+        return;
+    }
+    cout << "Warning:CylMesh::matchMeshEntries: "  << 
+            " unknown mesh type\n";
 }
 
 // Look for end-to-end diffusion, not sideways for now.
@@ -861,161 +870,161 @@ void CylMesh::matchMeshEntries( const ChemCompt* other,
 void CylMesh::matchCylMeshEntries( const CylMesh* other,
 vector< VoxelJunction >& ret ) const
 {
-	const double EPSILON = 1e-3;
-	ret.clear();
-	// Should really estimate the distance from the centre of the smaller
-	// cylinder cap disk to the plane of the larger disk, provided it is
-	// within the radius of the disk. The subsequent calculations are the
-	// same though.
-	double dr1 = 	// startOfSelf-to-startOfOther
-			distance(x0_ - other->x0_, y0_ - other->y0_, z0_ - other->z0_ );
-	double dr2 =  // endOfSelf-to-endOfOther
-			distance(x1_ - other->x1_, y1_ - other->y1_, z1_ - other->z1_ );
-	double dr3 = // endOfSelf-to-startOfOther
-			distance(x1_ - other->x0_, y1_ - other->y0_, z1_ - other->z0_ );
-	double dr4 =  // startOfSelf-to-endOfOther
-			distance(x0_ - other->x1_, y0_ - other->y1_, z0_ - other->z1_ );
-
-	if ( dr1 <= dr2 && dr1 <= dr3 && dr1 <= dr4 ) {
-		if ( ( dr1/totLen_ < EPSILON && dr1/other->totLen_ < EPSILON ) ) {
-			double xda;
-			if ( r0_ < other->r0_ )
-				xda = 2 * r0_ * r0_ * PI / ( diffLength_ + other->diffLength_ );
-			else
-				xda = 2 * other->r0_ * other->r0_ * PI /
-						( diffLength_ + other->diffLength_ );
-			ret.push_back( VoxelJunction( 0, 0, xda ) );
-			ret.back().first = 0;
-			ret.back().second = 0;
-			ret.back().firstVol = getMeshEntryVolume( 0 );
-			ret.back().secondVol = other->getMeshEntryVolume( 0 );
-		}
-	} else if ( dr2 <= dr3 && dr2 <= dr4 ) {
-		if ( ( dr2/totLen_ < EPSILON && dr2/other->totLen_ < EPSILON ) ) {
-			double xda;
-			if ( r1_ < other->r1_ )
-				xda = 2 * r1_ * r1_ * PI / ( diffLength_ + other->diffLength_ );
-			else
-				xda = 2 * other->r1_ * other->r1_ * PI /
-						( diffLength_ + other->diffLength_ );
-			ret.push_back( VoxelJunction( numEntries_ - 1,
-						other->numEntries_ - 1, xda ) );
-			ret.back().first = numEntries_;
-			ret.back().second = other->numEntries_ - 1;
-			ret.back().firstVol = getMeshEntryVolume( numEntries_ - 1 );
-			ret.back().secondVol = other->getMeshEntryVolume( other->numEntries_ - 1 );
-		}
-	} else if ( dr3 <= dr4 ) {
-		if ( ( dr3/totLen_ < EPSILON && dr3/other->totLen_ < EPSILON ) ) {
-			double xda;
-			if ( r1_ < other->r0_ )
-				xda = 2 * r1_ * r1_ * PI / ( diffLength_ + other->diffLength_ );
-			else
-				xda = 2 * other->r0_ * other->r0_ * PI /
-						( diffLength_ + other->diffLength_ );
-			ret.push_back( VoxelJunction( numEntries_ - 1, 0, xda ) );
-			ret.back().first = numEntries_ - 1;
-			ret.back().second = 0;
-			ret.back().firstVol = getMeshEntryVolume( numEntries_ - 1 );
-			ret.back().secondVol = other->getMeshEntryVolume( 0 );
-		}
-	} else {
-		if ( ( dr4/totLen_ < EPSILON && dr4/other->totLen_ < EPSILON ) ) {
-			double xda;
-			if ( r0_ < other->r1_ )
-				xda = 2 * r0_ * r0_ * PI / ( diffLength_ + other->diffLength_ );
-			else
-				xda = 2 * other->r1_ * other->r1_ * PI /
-						( diffLength_ + other->diffLength_ );
-			ret.push_back( VoxelJunction( 0, other->numEntries_ - 1, xda ));
-			ret.back().first = 0;
-			ret.back().second = other->numEntries_ - 1;
-			ret.back().firstVol = getMeshEntryVolume( 0 );
-			ret.back().secondVol = other->getMeshEntryVolume( other->numEntries_ - 1 );
-		}
-	}
+    const double EPSILON = 1e-3;
+    ret.clear();
+    // Should really estimate the distance from the centre of the smaller
+    // cylinder cap disk to the plane of the larger disk, provided it is
+    // within the radius of the disk. The subsequent calculations are the
+    // same though.
+    double dr1 =     // startOfSelf-to-startOfOther
+            distance(x0_ - other->x0_, y0_ - other->y0_, z0_ - other->z0_ );
+    double dr2 =  // endOfSelf-to-endOfOther
+            distance(x1_ - other->x1_, y1_ - other->y1_, z1_ - other->z1_ );
+    double dr3 = // endOfSelf-to-startOfOther
+            distance(x1_ - other->x0_, y1_ - other->y0_, z1_ - other->z0_ );
+    double dr4 =  // startOfSelf-to-endOfOther
+            distance(x0_ - other->x1_, y0_ - other->y1_, z0_ - other->z1_ );
+
+    if ( dr1 <= dr2 && dr1 <= dr3 && dr1 <= dr4 ) {
+        if ( ( dr1/totLen_ < EPSILON && dr1/other->totLen_ < EPSILON ) ) {
+            double xda;
+            if ( r0_ < other->r0_ )
+                xda = 2 * r0_ * r0_ * PI / ( diffLength_ + other->diffLength_ );
+            else
+                xda = 2 * other->r0_ * other->r0_ * PI /
+                        ( diffLength_ + other->diffLength_ );
+            ret.push_back( VoxelJunction( 0, 0, xda ) );
+            ret.back().first = 0;
+            ret.back().second = 0;
+            ret.back().firstVol = getMeshEntryVolume( 0 );
+            ret.back().secondVol = other->getMeshEntryVolume( 0 );
+        }
+    } else if ( dr2 <= dr3 && dr2 <= dr4 ) {
+        if ( ( dr2/totLen_ < EPSILON && dr2/other->totLen_ < EPSILON ) ) {
+            double xda;
+            if ( r1_ < other->r1_ )
+                xda = 2 * r1_ * r1_ * PI / ( diffLength_ + other->diffLength_ );
+            else
+                xda = 2 * other->r1_ * other->r1_ * PI /
+                        ( diffLength_ + other->diffLength_ );
+            ret.push_back( VoxelJunction( numEntries_ - 1,
+                        other->numEntries_ - 1, xda ) );
+            ret.back().first = numEntries_;
+            ret.back().second = other->numEntries_ - 1;
+            ret.back().firstVol = getMeshEntryVolume( numEntries_ - 1 );
+            ret.back().secondVol = other->getMeshEntryVolume( other->numEntries_ - 1 );
+        }
+    } else if ( dr3 <= dr4 ) {
+        if ( ( dr3/totLen_ < EPSILON && dr3/other->totLen_ < EPSILON ) ) {
+            double xda;
+            if ( r1_ < other->r0_ )
+                xda = 2 * r1_ * r1_ * PI / ( diffLength_ + other->diffLength_ );
+            else
+                xda = 2 * other->r0_ * other->r0_ * PI /
+                        ( diffLength_ + other->diffLength_ );
+            ret.push_back( VoxelJunction( numEntries_ - 1, 0, xda ) );
+            ret.back().first = numEntries_ - 1;
+            ret.back().second = 0;
+            ret.back().firstVol = getMeshEntryVolume( numEntries_ - 1 );
+            ret.back().secondVol = other->getMeshEntryVolume( 0 );
+        }
+    } else {
+        if ( ( dr4/totLen_ < EPSILON && dr4/other->totLen_ < EPSILON ) ) {
+            double xda;
+            if ( r0_ < other->r1_ )
+                xda = 2 * r0_ * r0_ * PI / ( diffLength_ + other->diffLength_ );
+            else
+                xda = 2 * other->r1_ * other->r1_ * PI /
+                        ( diffLength_ + other->diffLength_ );
+            ret.push_back( VoxelJunction( 0, other->numEntries_ - 1, xda ));
+            ret.back().first = 0;
+            ret.back().second = other->numEntries_ - 1;
+            ret.back().firstVol = getMeshEntryVolume( 0 );
+            ret.back().secondVol = other->getMeshEntryVolume( other->numEntries_ - 1 );
+        }
+    }
 }
 
 // Select grid volume. Ideally the meshes should be comparable.
 double CylMesh::selectGridVolume( double h ) const
 {
-	if ( h > diffLength_ )
-		h = diffLength_;
-	if ( h > r0_ )
-		h = r0_;
-	if ( h > r1_ )
-		h = r1_;
-	h *= surfaceGranularity_;
-	unsigned int num = ceil( diffLength_ / h );
-	h = diffLength_ / num;
-
-	return h;
+    if ( h > diffLength_ )
+        h = diffLength_;
+    if ( h > r0_ )
+        h = r0_;
+    if ( h > r1_ )
+        h = r1_;
+    h *= surfaceGranularity_;
+    unsigned int num = ceil( diffLength_ / h );
+    h = diffLength_ / num;
+
+    return h;
 }
 
 void fillPointsOnCircle(
-				const Vec& u, const Vec& v, const Vec& q,
-				double h, double r, vector< double >& area,
-				const CubeMesh* other
-				)
+                const Vec& u, const Vec& v, const Vec& q,
+                double h, double r, vector< double >& area,
+                const CubeMesh* other
+                )
 {
-	// fine-tune the h spacing so it is integral around circle.
-	// This will cause small errors in area estimate but they will
-	// be anisotropic. The alternative will have large errors toward
-	// 360 degrees, but not elsewhere.
-	unsigned int numAngle = floor( 2.0 * PI * r / h + 0.5 );
-	assert( numAngle > 0 );
-	double dtheta = 2.0 * PI / numAngle;
-	double dArea = h * dtheta * r;
-	// March along points on surface of circle centred at q.
-	for ( unsigned int j = 0; j < numAngle; ++j ) {
-		double theta = j * dtheta;
-		double c = cos( theta );
-		double s = sin( theta );
-		double p0 = q.a0() + r * ( u.a0() * c + v.a0() * s );
-		double p1 = q.a1() + r * ( u.a1() * c + v.a1() * s );
-		double p2 = q.a2() + r * ( u.a2() * c + v.a2() * s );
-		unsigned int index = other->spaceToIndex( p0, p1, p2 );
-		if ( index != CubeMesh::EMPTY )
-			area[index] += dArea;
-	}
+    // fine-tune the h spacing so it is integral around circle.
+    // This will cause small errors in area estimate but they will
+    // be anisotropic. The alternative will have large errors toward
+    // 360 degrees, but not elsewhere.
+    unsigned int numAngle = floor( 2.0 * PI * r / h + 0.5 );
+    assert( numAngle > 0 );
+    double dtheta = 2.0 * PI / numAngle;
+    double dArea = h * dtheta * r;
+    // March along points on surface of circle centred at q.
+    for ( unsigned int j = 0; j < numAngle; ++j ) {
+        double theta = j * dtheta;
+        double c = cos( theta );
+        double s = sin( theta );
+        double p0 = q.a0() + r * ( u.a0() * c + v.a0() * s );
+        double p1 = q.a1() + r * ( u.a1() * c + v.a1() * s );
+        double p2 = q.a2() + r * ( u.a2() * c + v.a2() * s );
+        unsigned int index = other->spaceToIndex( p0, p1, p2 );
+        if ( index != CubeMesh::EMPTY )
+            area[index] += dArea;
+    }
 }
 
 void CylMesh::matchCubeMeshEntries( const CubeMesh* other,
 vector< VoxelJunction >& ret ) const
 {
-	const double EPSILON = 1e-18;
-	Vec a( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
-	Vec u;
-	Vec v;
-	a.orthogonalAxes( u, v );
-
-	double h = selectGridVolume( other->getDx() );
-
-	unsigned int num = floor( 0.1 + diffLength_ / h );
-	// March along axis of cylinder.
-	// q is the location of the point along axis.
-	for ( unsigned int i = 0; i < numEntries_; ++i ) {
-		vector< double >area( other->getNumEntries(), 0.0 );
-		for ( unsigned int j = 0; j < num; ++j ) {
-			unsigned int m = i * num + j;
-			double frac = ( m * h + h/2.0 ) / totLen_;
-			double q0 = x0_ + a.a0() * frac;
-			double q1 = y0_ + a.a1() * frac;
-			double q2 = z0_ + a.a2() * frac;
-			// get radius of cylinder at this point.
-			double r = r0_ + ( m * h + h / 2.0 ) * rSlope_;
-			fillPointsOnCircle( u, v, Vec( q0, q1, q2 ),
-						h, r, area, other );
-			}
-		// Go through all cubeMesh entries and compute diffusion
-		// cross-section. Assume this is through a membrane, so the
-		// only factor relevant is area. Not the distance.
-		for ( unsigned int k = 0; k < area.size(); ++k ) {
-			if ( area[k] > EPSILON ) {
-				ret.push_back( VoxelJunction( i, k, area[k] ) );
-			}
-		}
-	}
+    const double EPSILON = 1e-18;
+    Vec a( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
+    Vec u;
+    Vec v;
+    a.orthogonalAxes( u, v );
+
+    double h = selectGridVolume( other->getDx() );
+
+    unsigned int num = floor( 0.1 + diffLength_ / h );
+    // March along axis of cylinder.
+    // q is the location of the point along axis.
+    for ( unsigned int i = 0; i < numEntries_; ++i ) {
+        vector< double >area( other->getNumEntries(), 0.0 );
+        for ( unsigned int j = 0; j < num; ++j ) {
+            unsigned int m = i * num + j;
+            double frac = ( m * h + h/2.0 ) / totLen_;
+            double q0 = x0_ + a.a0() * frac;
+            double q1 = y0_ + a.a1() * frac;
+            double q2 = z0_ + a.a2() * frac;
+            // get radius of cylinder at this point.
+            double r = r0_ + ( m * h + h / 2.0 ) * rSlope_;
+            fillPointsOnCircle( u, v, Vec( q0, q1, q2 ),
+                        h, r, area, other );
+            }
+        // Go through all cubeMesh entries and compute diffusion
+        // cross-section. Assume this is through a membrane, so the
+        // only factor relevant is area. Not the distance.
+        for ( unsigned int k = 0; k < area.size(); ++k ) {
+            if ( area[k] > EPSILON ) {
+                ret.push_back( VoxelJunction( i, k, area[k] ) );
+            }
+        }
+    }
 }
 
 void CylMesh::matchNeuroMeshEntries( const NeuroMesh* other,
@@ -1024,111 +1033,111 @@ vector< VoxelJunction >& ret ) const
 }
 
 void CylMesh::indexToSpace( unsigned int index,
-			double& x, double& y, double& z ) const
+            double& x, double& y, double& z ) const
 {
-	if ( index < numEntries_ ) {
-		double k = ( index + 0.5 ) / static_cast< double >( numEntries_ );
-		x = ( x1_ - x0_ ) * k + x0_;
-		y = ( y1_ - y0_ ) * k + y0_;
-		z = ( z1_ - z0_ ) * k + z0_;
-	}
+    if ( index < numEntries_ ) {
+        double k = ( index + 0.5 ) / static_cast< double >( numEntries_ );
+        x = ( x1_ - x0_ ) * k + x0_;
+        y = ( y1_ - y0_ ) * k + y0_;
+        z = ( z1_ - z0_ ) * k + z0_;
+    }
 }
 
 static double dotprd ( double x0, double y0, double z0,
-				double x1, double y1, double z1 )
+                double x1, double y1, double z1 )
 {
-		return x0 * x1 + y0 * y1 + z0 * z1;
+        return x0 * x1 + y0 * y1 + z0 * z1;
 }
 
 
 // this is the function that does the actual calculation.
 double CylMesh::nearest( double x, double y, double z,
-				double& linePos, double& r ) const
+                double& linePos, double& r ) const
 {
-	// Consider r0 = x0,y0,z0 and r1 = x1, y1, z1, and r = x,y,z.
-	// Fraction along cylinder = k
-	//
-	// Then, point p along line from r0 to r1 is
-	// p = k( r0-r1) + r1.
-	//
-	// Solving,
-	// k = (r0 - r1).(r - r1) / (|r0-r1|^2)
-	//
-
-	double dist = distance( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
-	double k = dotprd(
-		x1_ - x0_, y1_ - y0_, z1_ - z0_,
-		x - x0_, y - y0_, z - z0_ ) / ( dist * dist );
-
-	// x2, y2, z2 are the coords of the nearest point.
-	double x2 = k * (x1_ - x0_) + x0_;
-	double y2 = k * (y1_ - y0_) + y0_;
-	double z2 = k * (z1_ - z0_) + z0_;
-
-	double ret = distance( x - x2, y - y2, z - z2 );
-	linePos = k;
-	r = r0_ + k * numEntries_ * rSlope_;
-	return ret;
+    // Consider r0 = x0,y0,z0 and r1 = x1, y1, z1, and r = x,y,z.
+    // Fraction along cylinder = k
+    //
+    // Then, point p along line from r0 to r1 is
+    // p = k( r0-r1) + r1.
+    //
+    // Solving,
+    // k = (r0 - r1).(r - r1) / (|r0-r1|^2)
+    //
+
+    double dist = distance( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
+    double k = dotprd(
+        x1_ - x0_, y1_ - y0_, z1_ - z0_,
+        x - x0_, y - y0_, z - z0_ ) / ( dist * dist );
+
+    // x2, y2, z2 are the coords of the nearest point.
+    double x2 = k * (x1_ - x0_) + x0_;
+    double y2 = k * (y1_ - y0_) + y0_;
+    double z2 = k * (z1_ - z0_) + z0_;
+
+    double ret = distance( x - x2, y - y2, z - z2 );
+    linePos = k;
+    r = r0_ + k * numEntries_ * rSlope_;
+    return ret;
 }
 
 // This function returns the index.
 double CylMesh::nearest( double x, double y, double z,
-				unsigned int& index ) const
+                unsigned int& index ) const
 {
-	double k = 0.0;
-	double r;
-	double ret = nearest( x, y, z, k, r );
-	if ( k < 0.0 ) {
-		ret = -ret;
-		index = 0;
-	} else if ( k > 1.0 ) {
-		ret = -ret;
-		index = numEntries_ - 1;
-	} else { // Inside length of cylinder, now is it inside radius?
-		index = k * numEntries_;
-		double ri = r0_ + (index + 0.5) * rSlope_;
-		if ( ret > ri )
-			ret = -ret;
-	}
-	return ret;
+    double k = 0.0;
+    double r;
+    double ret = nearest( x, y, z, k, r );
+    if ( k < 0.0 ) {
+        ret = -ret;
+        index = 0;
+    } else if ( k > 1.0 ) {
+        ret = -ret;
+        index = numEntries_ - 1;
+    } else { // Inside length of cylinder, now is it inside radius?
+        index = k * numEntries_;
+        double ri = r0_ + (index + 0.5) * rSlope_;
+        if ( ret > ri )
+            ret = -ret;
+    }
+    return ret;
 }
 
 
 /*
 bool isOnSurface( double x, double y, double z,
-					double dx, double dy, double dz,
-					unsigned int &index, double& adx )
+                    double dx, double dy, double dz,
+                    unsigned int &index, double& adx )
 {
-	double len = distance( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
-	double k = dotprd(
-		x1_ - x0_, y1_ - y0_, z1_ - z0_,
-		x - x0_, y - y0_, z - z0_ ) / len;
+    double len = distance( x1_ - x0_, y1_ - y0_, z1_ - z0_ );
+    double k = dotprd(
+        x1_ - x0_, y1_ - y0_, z1_ - z0_,
+        x - x0_, y - y0_, z - z0_ ) / len;
 
-	// x2, y2, z2 are the coords of the nearest point.
-	double x2 = k * (x1_ - x0_) + x0_;
-	double y2 = k * (y1_ - y0_) + y0_;
-	double z2 = k * (z1_ - z0_) + z0_;
+    // x2, y2, z2 are the coords of the nearest point.
+    double x2 = k * (x1_ - x0_) + x0_;
+    double y2 = k * (y1_ - y0_) + y0_;
+    double z2 = k * (z1_ - z0_) + z0_;
 
-	double ret = distance( x - x2, y - y2, z - z2 );
+    double ret = distance( x - x2, y - y2, z - z2 );
 
-	double cubeRange = sqrt(dx*dx + dy*dy + dz*dz);
+    double cubeRange = sqrt(dx*dx + dy*dy + dz*dz);
 
-	// Now we check if the distance is definitely too far off for the
-	// passed in point
-	if ( k < -dx/2 || k > len + dx/2 ) // past the end.
-		return false;
+    // Now we check if the distance is definitely too far off for the
+    // passed in point
+    if ( k < -dx/2 || k > len + dx/2 ) // past the end.
+        return false;
 
-	double ri = k * rSlope_; // local cylinder radius.
+    double ri = k * rSlope_; // local cylinder radius.
 
-	if ( ret > ri + cubeRange || ret < ri - cubeRange )
-		return false;
+    if ( ret > ri + cubeRange || ret < ri - cubeRange )
+        return false;
 
-	// OK, now we need to find the plane of intersection of the cylinder
-	// with the cuboid. To make it easier, assume it is flat. We already
-	// know the vector from the middle of the cuboid to the nearest
-	// cylinder point. Treat it as the normal to the intersection plane.
-	// We need: : is the plane inside the cube?
-	// What is the area of the plane till its intersection with the cube?
+    // OK, now we need to find the plane of intersection of the cylinder
+    // with the cuboid. To make it easier, assume it is flat. We already
+    // know the vector from the middle of the cuboid to the nearest
+    // cylinder point. Treat it as the normal to the intersection plane.
+    // We need: : is the plane inside the cube?
+    // What is the area of the plane till its intersection with the cube?
 
 }
 
diff --git a/pymoose/PyRun.cpp b/pymoose/PyRun.cpp
index 5b3db0daec6cfb73d78516a2ee6acf404788ba6a..53e33c6bd8734d43341fe861585f8e37ffc5fb78 100644
--- a/pymoose/PyRun.cpp
+++ b/pymoose/PyRun.cpp
@@ -3,47 +3,7 @@
 // Filename: PyRun.cpp
 // Description:
 // Author: subha
-// Maintainer:
 // Created: Sat Oct 11 14:47:22 2014 (+0530)
-// Version:
-// Last-Updated: Fri Jun 19 18:56:06 2015 (-0400)
-//           By: Subhasis Ray
-//     Update #: 15
-// 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:
 
 #include "Python.h"
 #include "../basecode/header.h"
@@ -147,7 +107,8 @@ const Cinfo * PyRun::initCinfo()
         "for the Reinit operation. It also uses ProcInfo. ",
         processShared, sizeof( processShared ) / sizeof( Finfo* ));
 
-    static Finfo * pyRunFinfos[] = {
+    static Finfo * pyRunFinfos[] =
+    {
         &runstring,
         &initstring,
         &mode,
@@ -161,10 +122,12 @@ const Cinfo * PyRun::initCinfo()
         &proc,
     };
 
-    static string doc[] = {
+    static string doc[] =
+    {
         "Name", "PyRun",
         "Author", "Subhasis Ray",
-        "Description", "Runs Python statements from inside MOOSE."};
+        "Description", "Runs Python statements from inside MOOSE."
+    };
     static Dinfo< PyRun > dinfo;
     static Cinfo pyRunCinfo(
         "PyRun",
@@ -180,21 +143,24 @@ const Cinfo * PyRun::initCinfo()
 static const Cinfo * pyRunCinfo = PyRun::initCinfo();
 
 PyRun::PyRun():mode_(0), initstr_(""), runstr_(""),
-               globals_(0), locals_(0),
-               runcompiled_(0), initcompiled_(0),
-               inputvar_("input_"), outputvar_("output")
+    globals_(0), locals_(0),
+    runcompiled_(0), initcompiled_(0),
+    inputvar_("input_"), outputvar_("output")
 {
     locals_ = PyDict_New();
-    if (!locals_){
+    if (!locals_)
+    {
         cerr << "Could not initialize locals dict" << endl;
         return;
     }
     PyObject * value = PyFloat_FromDouble(0.0);
-    if (!value && PyErr_Occurred()){
+    if (!value && PyErr_Occurred())
+    {
         PyErr_Print();
         return;
     }
-    if (PyDict_SetItemString(locals_, inputvar_.c_str(), value)){
+    if (PyDict_SetItemString(locals_, inputvar_.c_str(), value))
+    {
         PyErr_Print();
     }
 }
@@ -259,34 +225,44 @@ int PyRun::getMode() const
 
 void PyRun::trigger(const Eref& e, double input)
 {
-    if (!runcompiled_){
+    if (!runcompiled_)
+    {
         return;
     }
-    if (mode_ == 1){
+    if (mode_ == 1)
+    {
         return;
     }
 
     PyObject * value = PyDict_GetItemString(locals_, inputvar_.c_str());
-    if (value){
+    if (value)
+    {
         Py_DECREF(value);
     }
     value = PyFloat_FromDouble(input);
-    if (!value && PyErr_Occurred()){
+    if (!value && PyErr_Occurred())
+    {
         PyErr_Print();
     }
-    if (PyDict_SetItemString(locals_, inputvar_.c_str(), value)){
+    if (PyDict_SetItemString(locals_, inputvar_.c_str(), value))
+    {
         PyErr_Print();
     }
     PyEval_EvalCode(runcompiled_, globals_, locals_);
-    if (PyErr_Occurred()){
+    if (PyErr_Occurred())
+    {
         PyErr_Print ();
     }
     value = PyDict_GetItemString(locals_, outputvar_.c_str());
-    if (value){
+    if (value)
+    {
         double output = PyFloat_AsDouble(value);
-        if (PyErr_Occurred()){
+        if (PyErr_Occurred())
+        {
             PyErr_Print ();
-        } else {
+        }
+        else
+        {
             outputOut()->send(e, output);
         }
     }
@@ -296,36 +272,49 @@ void PyRun::run(const Eref&e, string statement)
 {
     PyRun_SimpleString(statement.c_str());
     PyObject * value = PyDict_GetItemString(locals_, outputvar_.c_str());
-    if (value){
+    if (value)
+    {
         double output = PyFloat_AsDouble(value);
-        if (PyErr_Occurred()){
+        if (PyErr_Occurred())
             PyErr_Print ();
-        } else {
+        else
             outputOut()->send(e, output);
-        }
     }
 }
 
 void PyRun::process(const Eref & e, ProcPtr p)
 {
+    // Make sure the get the GIL. Ksolve/Gsolve can be multithreaded.
+    PyGILState_STATE gstate = PyGILState_Ensure();
+
     // PyRun_String(runstr_.c_str(), 0, globals_, locals_);
     // PyRun_SimpleString(runstr_.c_str());
-    if (!runcompiled_ || mode_ == 2){
+    if (! runcompiled_ || mode_ == 2)
+    {
         return;
     }
+
     PyEval_EvalCode(runcompiled_, globals_, locals_);
-    if (PyErr_Occurred()){
+    if (PyErr_Occurred())
+    {
         PyErr_Print ();
+        return;
     }
+
     PyObject * value = PyDict_GetItemString(locals_, outputvar_.c_str());
-    if (value){
+    if (value)
+    {
         double output = PyFloat_AsDouble(value);
-        if (PyErr_Occurred()){
+        if (PyErr_Occurred())
+        {
             PyErr_Print ();
-        } else {
-            outputOut()->send(e, output);
+            return;
         }
+        else
+            outputOut()->send(e, output);
     }
+
+    PyGILState_Release( gstate );
 }
 
 /**
@@ -337,19 +326,25 @@ 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);
-        } else {                                  /* some other syntax error */
+        }
+        else                                      /* some other syntax error */
+        {
             PyErr_Restore (exc, val, trb);
             PyErr_Print ();
         }
-    } else {                                     /* some non-syntax error */
+    }
+    else                                         /* some non-syntax error */
+    {
         PyErr_Print ();
     }
 }
@@ -357,45 +352,55 @@ void handleError(bool syntax)
 void PyRun::reinit(const Eref& e, ProcPtr p)
 {
     PyObject * main_module;
-    if (globals_ == NULL){
+    if (globals_ == NULL)
+    {
         main_module = PyImport_AddModule("__main__");
         globals_ = PyModule_GetDict(main_module);
         Py_XINCREF(globals_);
     }
-    if (locals_ == NULL){
+    if (locals_ == NULL)
+    {
         locals_ = PyDict_New();
-        if (!locals_){
+        if (!locals_)
+        {
             cerr << "Could not initialize locals dict" << endl;
         }
     }
     initcompiled_ = (PYCODEOBJECT*)Py_CompileString(
-        initstr_.c_str(),
-        get_program_name().c_str(),
-        Py_file_input);
-    if (!initcompiled_){
+                        initstr_.c_str(),
+                        get_program_name().c_str(),
+                        Py_file_input);
+    if (!initcompiled_)
+    {
         cerr << "Error compiling initString" << endl;
         handleError(true);
-    } else {
+    }
+    else
+    {
         PyEval_EvalCode(initcompiled_, globals_, locals_);
-        if (PyErr_Occurred()){
+        if (PyErr_Occurred())
+        {
             PyErr_Print ();
         }
     }
+
+    assert( runstr_.size() > 0 );
+
     runcompiled_ = (PYCODEOBJECT*)Py_CompileString(
-        runstr_.c_str(),
-        get_program_name().c_str(),
-        Py_file_input);
-    if (!runcompiled_){
+                       runstr_.c_str(),
+                       get_program_name().c_str(),
+                       Py_file_input);
+    if (!runcompiled_)
+    {
         cerr << "Error compiling runString" << endl;
         handleError(true);
-    } else {
+    }
+    else
+    {
         PyEval_EvalCode(runcompiled_, globals_, locals_);
-        if (PyErr_Occurred()){
+        if (PyErr_Occurred())
+        {
             PyErr_Print ();
         }
     }
 }
-
-
-//
-// PyRun.cpp ends here
diff --git a/pymoose/PyRun.h b/pymoose/PyRun.h
index 8f8d061236b84cb7d788be5dd71f966420b6264e..ab0d1bdd09f943e7f553e9229c409f49dd449bb6 100644
--- a/pymoose/PyRun.h
+++ b/pymoose/PyRun.h
@@ -1,49 +1,7 @@
-// PyRun.h ---
-//
 // Filename: PyRun.h
 // Description:
 // Author: subha
-// Maintainer:
 // Created: Sat Oct 11 14:40:45 2014 (+0530)
-// Version:
-// Last-Updated: Fri Jun 19 18:54:49 2015 (-0400)
-//           By: Subhasis Ray
-//     Update #: 31
-// URL:
-// Keywords:
-// Compatibility:
-//
-//
-
-// Commentary:
-//
-// Class to call Python functions from MOOSE
-//
-//
-
-// 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:
 
 #ifndef _PYCALL_H
 #define _PYCALL_H
@@ -55,19 +13,19 @@
 
 string get_program_name()
 {
-  wchar_t * progname = Py_GetProgramName();
-  char buffer[PATH_MAX+1];
-  size_t ret = wcstombs(buffer, progname, PATH_MAX);
-  buffer[ret] = '\0';
-  return string(buffer);
+    wchar_t * progname = Py_GetProgramName();
+    char buffer[PATH_MAX+1];
+    size_t ret = wcstombs(buffer, progname, PATH_MAX);
+    buffer[ret] = '\0';
+    return string(buffer);
 }
 #else
 #define PYCODEOBJECT PyCodeObject
 
 string get_program_name()
 {
-  char * progname = Py_GetProgramName();
-  return string(progname);
+    char * progname = Py_GetProgramName();
+    return string(progname);
 }
 #endif
 
@@ -107,7 +65,8 @@ public:
 
     void run(const Eref& e, string statement);
 
-    void trigger(const Eref& e, double input); // this is a way to trigger execution via incoming message - can be useful for debugging
+     // this is a way to trigger execution via incoming message - can be useful for debugging
+    void trigger(const Eref& e, double input);
 
     void process(const Eref& e, ProcPtr p);
     void reinit(const Eref& e, ProcPtr p);
@@ -115,20 +74,15 @@ public:
     static const Cinfo * initCinfo();
 
 protected:
-    int mode_; // flag to decide when to run the Python string
-    string initstr_; // statement str for running at reinit
-    string runstr_; // statement str for running in each process call
-    PyObject * globals_; // global env dict
-    PyObject * locals_; // local env dict
-    PYCODEOBJECT * runcompiled_; // compiled form of procstr_
+    int mode_;                    // flag to decide when to run the Python string
+    string initstr_;              // statement str for running at reinit
+    string runstr_;               // statement str for running in each process call
+    PyObject * globals_;          // global env dict
+    PyObject * locals_;           // local env dict
+    PYCODEOBJECT * runcompiled_;  // compiled form of procstr_
     PYCODEOBJECT * initcompiled_; // coimpiled form of initstr_
-    string inputvar_; // identifier for input variable.
-    string outputvar_; // identifier for output variable
+    string inputvar_;             // identifier for input variable.
+    string outputvar_;            // identifier for output variable
 };
 
 #endif
-
-
-
-//
-// PyRun.h ends here
diff --git a/pymoose/moosemodule.cpp b/pymoose/moosemodule.cpp
index acf86f0235bb32feff830f6d6de8b6fd2c3eb859..fe70212514086d6d56ae44f1ba813169cb03c184 100644
--- a/pymoose/moosemodule.cpp
+++ b/pymoose/moosemodule.cpp
@@ -164,8 +164,8 @@ int verbosity = 1;
 // static int isSingleThreaded = 0;
 static int isInfinite = 0;
 static unsigned int numNodes = 1;
-static unsigned int numCores = 1;
-static unsigned int myNode = 0;
+// static unsigned int numCores = 1;
+// static unsigned int myNode = 0;
 // static unsigned int numProcessThreads = 0;
 static int doUnitTests = 0;
 static int doRegressionTests = 0;
@@ -899,6 +899,7 @@ vector <string> setup_runtime_env()
             args.push_back("-i");
         }
     }
+#if 0
     it = argmap.find("NUMNODES");
     if (it != argmap.end())
     {
@@ -917,6 +918,7 @@ vector <string> setup_runtime_env()
     //     args.push_back("-t");
     //     args.push_back(it->second);
     // }
+#endif
     it = argmap.find("QUIT");
     if (it != argmap.end())
     {
@@ -1720,14 +1722,6 @@ PyObject * moose_start(PyObject * dummy, PyObject * args )
     sigHandler.sa_flags = 0;
     sigaction(SIGINT, &sigHandler, NULL);
 
-#if 0
-    // NOTE: (dilawar) Does not know if Py_BEGIN_ALLOW_THREADS is
-    // neccessary.
-    // Py_BEGIN_ALLOW_THREADS
-    SHELLPTR->doStart(runtime);
-    // Py_END_ALLOW_THREADS
-    Py_RETURN_NONE;
-#endif
     SHELLPTR->doStart( runtime, notify );
     Py_RETURN_NONE;
 
@@ -3199,10 +3193,10 @@ PyMODINIT_FUNC MODINIT(_moose)
     PyModule_AddObject(moose_module, "DestField", (PyObject*)&moose_DestField);
 
     // PyModule_AddIntConstant(moose_module, "SINGLETHREADED", isSingleThreaded);
-    PyModule_AddIntConstant(moose_module, "NUMCORES", numCores);
-    PyModule_AddIntConstant(moose_module, "NUMNODES", numNodes);
+    // PyModule_AddIntConstant(moose_module, "NUMCORES", numCores);
+    // PyModule_AddIntConstant(moose_module, "NUMNODES", numNodes);
     // PyModule_AddIntConstant(moose_module, "NUMPTHREADS", numProcessThreads);
-    PyModule_AddIntConstant(moose_module, "MYNODE", myNode);
+    // PyModule_AddIntConstant(moose_module, "MYNODE", myNode);
     PyModule_AddIntConstant(moose_module, "INFINITE", isInfinite);
     PyModule_AddStringConstant(moose_module, "__version__", SHELLPTR->doVersion().c_str());
     PyModule_AddStringConstant(moose_module, "VERSION", SHELLPTR->doVersion().c_str());
@@ -3233,13 +3227,11 @@ PyMODINIT_FUNC MODINIT(_moose)
        );
 
     if (doUnitTests)
-    {
         test_moosemodule();
-    }
 #ifdef PY3K
     return moose_module;
 #endif
-} //! init_moose
+} 
 
 
 //////////////////////////////////////////////
diff --git a/pymoose/pymooseinit.cpp b/pymoose/pymooseinit.cpp
index e5719af645d9544a99985a6478bf8374e0a077a0..29200a673cea316f2590e004f259beb4cbc161a7 100644
--- a/pymoose/pymooseinit.cpp
+++ b/pymoose/pymooseinit.cpp
@@ -9,9 +9,9 @@
 
 #include "header.h"
 #ifndef WIN32
-	#include <sys/time.h>
+#include <sys/time.h>
 #else
-	#include <time.h>
+#include <time.h>
 #endif
 #include <math.h>
 #include <queue>
@@ -66,10 +66,10 @@ extern void destroyMsgManagers();
 // void regressionTests();
 #endif
 extern void speedTestMultiNodeIntFireNetwork(
-	unsigned int size, unsigned int runsteps );
+    unsigned int size, unsigned int runsteps );
 
 #ifdef USE_SMOLDYN
-	extern void testSmoldyn();
+extern void testSmoldyn();
 #endif
 // bool benchmarkTests( int argc, char** argv );
 
@@ -81,44 +81,44 @@ extern void mooseBenchmarks( unsigned int option );
 
 unsigned int getNumCores()
 {
-	unsigned int numCPU = 0;
+    unsigned int numCPU = 0;
 #ifdef WIN_32
-	SYSTEM_INFO sysinfo;
-	GetSystemInfo( &sysinfo );
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo( &sysinfo );
 
-	numCPU = sysinfo.dwNumberOfProcessors;
+    numCPU = sysinfo.dwNumberOfProcessors;
 #endif
 
 #ifdef LINUX
-	numCPU = sysconf( _SC_NPROCESSORS_ONLN );
+    numCPU = sysconf( _SC_NPROCESSORS_ONLN );
 #endif
 
 #ifdef MACOSX
-	int mib[4];
-	size_t len = sizeof(numCPU);
+    int mib[4];
+    size_t len = sizeof(numCPU);
 
-	/* set the mib for hw.ncpu */
-	mib[0] = CTL_HW;
-	mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
+    /* set the mib for hw.ncpu */
+    mib[0] = CTL_HW;
+    mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
 
-	/* get the number of CPUs from the system */
-	sysctl(mib, 2, &numCPU, &len, NULL, 0);
+    /* get the number of CPUs from the system */
+    sysctl(mib, 2, &numCPU, &len, NULL, 0);
 
-	if( numCPU < 1 )
-	{
-		mib[1] = HW_NCPU;
-		sysctl( mib, 2, &numCPU, &len, NULL, 0 );
-	}
+    if( numCPU < 1 )
+    {
+        mib[1] = HW_NCPU;
+        sysctl( mib, 2, &numCPU, &len, NULL, 0 );
+    }
 #endif
-	if ( numCPU < 1 )
-	{
-#ifndef QUIET_MODE
-		cout << "No CPU information available. Assuming single core." << endl;
-#else
+
+#if 0
+    if ( numCPU < 1 )
+    {
+        cout << "No CPU information available. Assuming single core." << endl;
+        numCPU = 1;
+    }
 #endif
-		numCPU = 1;
-	}
-	return numCPU;
+    return numCPU;
 }
 
 bool quitFlag = 0;
@@ -127,138 +127,141 @@ bool quitFlag = 0;
 
 void checkChildren( Id parent, const string& info )
 {
-	vector< Id > ret;
-	Neutral::children( parent.eref(), ret );
-	cout << info << " checkChildren of " <<
-			parent.element()->getName() << ": " <<
-		ret.size() << " children\n";
-	for ( vector< Id >::iterator i = ret.begin(); i != ret.end(); ++i )
-	{
-		cout << i->element()->getName() << endl;
-	}
+    vector< Id > ret;
+    Neutral::children( parent.eref(), ret );
+    cout << info << " checkChildren of " <<
+         parent.element()->getName() << ": " <<
+         ret.size() << " children\n";
+    for ( vector< Id >::iterator i = ret.begin(); i != ret.end(); ++i )
+    {
+        cout << i->element()->getName() << endl;
+    }
 }
 
 Id init( int argc, char** argv, bool& doUnitTests, bool& doRegressionTests,
-	  unsigned int& benchmark )
+         unsigned int& benchmark )
 {
-	unsigned int numCores = getNumCores();
-	int numNodes = 1;
-	int myNode = 0;
-	bool isInfinite = 0;
-	int opt;
-	benchmark = 0; // Default, means don't do any benchmarks.
-	Cinfo::rebuildOpIndex();
+    unsigned int numCores = getNumCores();
+    int numNodes = 1;
+    int myNode = 0;
+    bool isInfinite = 0;
+    int opt;
+    benchmark = 0; // Default, means don't do any benchmarks.
+    Cinfo::rebuildOpIndex();
 #ifdef USE_MPI
-	/*
-	// OpenMPI does not use argc or argv.
-	// unsigned int temp_argc = 1;
-	int provided;
-	MPI_Init_thread( &argc, &argv, MPI_THREAD_SERIALIZED, &provided );
-	*/
-	MPI_Init( &argc, &argv );
-
-	MPI_Comm_size( MPI_COMM_WORLD, &numNodes );
-	MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
-	/*
-	if ( provided < MPI_THREAD_SERIALIZED && myNode == 0 ) {
-		cout << "Warning: This MPI implementation does not like multithreading: " << provided << "\n";
-	}
-	*/
-	// myNode = MPI::COMM_WORLD.Get_rank();
+    /*
+    // OpenMPI does not use argc or argv.
+    // unsigned int temp_argc = 1;
+    int provided;
+    MPI_Init_thread( &argc, &argv, MPI_THREAD_SERIALIZED, &provided );
+    */
+    MPI_Init( &argc, &argv );
+
+    MPI_Comm_size( MPI_COMM_WORLD, &numNodes );
+    MPI_Comm_rank( MPI_COMM_WORLD, &myNode );
+    /*
+    if ( provided < MPI_THREAD_SERIALIZED && myNode == 0 ) {
+    	cout << "Warning: This MPI implementation does not like multithreading: " << provided << "\n";
+    }
+    */
+    // myNode = MPI::COMM_WORLD.Get_rank();
 #endif
-	/**
-	 * Here we allow the user to override the automatic identification
-	 * of processor configuration
-	 */
-	while ( ( opt = getopt( argc, argv, "hiqurn:b:B:" ) ) != -1 ) {
-		switch ( opt ) {
-			case 'i' : // infinite loop, used for multinode debugging, to give gdb something to attach to.
-				isInfinite = 1;
-				break;
-			case 'n': // Multiple nodes
-			  numNodes = (unsigned int)atoi( optarg );
-				break;
-			case 'b': // Benchmark:
-				benchmark = atoi( optarg );
-				break;
-			case 'B': // Benchmark plus dump data: handle later.
-				break;
-			case 'u': // Do unit tests, pass back.
-				doUnitTests = 1;
-				break;
-			case 'r': // Do regression tests: pass back
-				doRegressionTests = 1;
-				break;
-			case 'q': // quit immediately after completion.
-				quitFlag = 1;
-				break;
-			case 'h': // help
-			default:
-				cout << "Usage: moose -help -infiniteLoop -unit_tests -regression_tests -quit -n numNodes -benchmark [ksolve intFire hhNet msg_<msgType>_<size>]\n";
-
-				exit( 1 );
-		}
-	}
-	if ( myNode == 0 )
+    /**
+     * Here we allow the user to override the automatic identification
+     * of processor configuration
+     */
+    while ( ( opt = getopt( argc, argv, "hiqurn:b:B:" ) ) != -1 )
+    {
+        switch ( opt )
         {
-#ifndef QUIET_MODE
-		cout << "on node " << myNode << ", numNodes = "
-                    << numNodes << ", numCores = " << numCores << endl;
-#endif
+        case 'i' : // infinite loop, used for multinode debugging, to give gdb something to attach to.
+            isInfinite = 1;
+            break;
+        case 'n': // Multiple nodes
+            numNodes = (unsigned int)atoi( optarg );
+            break;
+        case 'b': // Benchmark:
+            benchmark = atoi( optarg );
+            break;
+        case 'B': // Benchmark plus dump data: handle later.
+            break;
+        case 'u': // Do unit tests, pass back.
+            doUnitTests = 1;
+            break;
+        case 'r': // Do regression tests: pass back
+            doRegressionTests = 1;
+            break;
+        case 'q': // quit immediately after completion.
+            quitFlag = 1;
+            break;
+        case 'h': // help
+        default:
+            cout << "Usage: moose -help -infiniteLoop -unit_tests -regression_tests -quit -n numNodes -benchmark [ksolve intFire hhNet msg_<msgType>_<size>]\n";
+
+            exit( 1 );
         }
+    }
+    if ( myNode == 0 )
+    {
+
+#if 0
+        cout << "on node " << myNode << ", numNodes = "
+             << numNodes << ", numCores = " << numCores << endl;
+#endif
+    }
 
-	Id shellId;
-	Element* shelle =
-		new GlobalDataElement( shellId, Shell::initCinfo(), "root", 1 );
+    Id shellId;
+    Element* shelle =
+        new GlobalDataElement( shellId, Shell::initCinfo(), "root", 1 );
 
-	Id clockId = Id::nextId();
-	assert( clockId.value() == 1 );
-	Id classMasterId = Id::nextId();
-	Id postMasterId = Id::nextId();
+    Id clockId = Id::nextId();
+    assert( clockId.value() == 1 );
+    Id classMasterId = Id::nextId();
+    Id postMasterId = Id::nextId();
 
-	Shell* s = reinterpret_cast< Shell* >( shellId.eref().data() );
-	s->setShellElement( shelle );
-	s->setHardware( numCores, numNodes, myNode );
-	s->loadBalance();
+    Shell* s = reinterpret_cast< Shell* >( shellId.eref().data() );
+    s->setShellElement( shelle );
+    s->setHardware( numCores, numNodes, myNode );
+    s->loadBalance();
 
-	/// Sets up the Elements that represent each class of Msg.
-	unsigned int numMsg = Msg::initMsgManagers();
+    /// Sets up the Elements that represent each class of Msg.
+    unsigned int numMsg = Msg::initMsgManagers();
 
-	new GlobalDataElement( clockId, Clock::initCinfo(), "clock", 1 );
-	new GlobalDataElement( classMasterId, Neutral::initCinfo(), "classes", 1);
-	new GlobalDataElement( postMasterId, PostMaster::initCinfo(), "postmaster", 1 );
+    new GlobalDataElement( clockId, Clock::initCinfo(), "clock", 1 );
+    new GlobalDataElement( classMasterId, Neutral::initCinfo(), "classes", 1);
+    new GlobalDataElement( postMasterId, PostMaster::initCinfo(), "postmaster", 1 );
 
-	assert ( shellId == Id() );
-	assert( clockId == Id( 1 ) );
-	assert( classMasterId == Id( 2 ) );
-	assert( postMasterId == Id( 3 ) );
+    assert ( shellId == Id() );
+    assert( clockId == Id( 1 ) );
+    assert( classMasterId == Id( 2 ) );
+    assert( postMasterId == Id( 3 ) );
 
 
 
-	// s->connectMasterMsg();
+    // s->connectMasterMsg();
 
-	Shell::adopt( shellId, clockId, numMsg++ );
-	Shell::adopt( shellId, classMasterId, numMsg++ );
-	Shell::adopt( shellId, postMasterId, numMsg++ );
+    Shell::adopt( shellId, clockId, numMsg++ );
+    Shell::adopt( shellId, classMasterId, numMsg++ );
+    Shell::adopt( shellId, postMasterId, numMsg++ );
 
-	assert( numMsg == 10 ); // Must be the same on all nodes.
+    assert( numMsg == 10 ); // Must be the same on all nodes.
 
-	Cinfo::makeCinfoElements( classMasterId );
+    Cinfo::makeCinfoElements( classMasterId );
 
 
-	// This will be initialized within the Process loop, and better there
-	// as it flags attempts to call the Reduce operations before ProcessLoop
-	// Qinfo::clearReduceQ( numCores ); // Initialize the ReduceQ entry.
+    // This will be initialized within the Process loop, and better there
+    // as it flags attempts to call the Reduce operations before ProcessLoop
+    // Qinfo::clearReduceQ( numCores ); // Initialize the ReduceQ entry.
 
 
-	// SetGet::setShell();
-	// Msg* m = new OneToOneMsg( shelle, shelle );
-	// assert ( m != 0 );
+    // SetGet::setShell();
+    // Msg* m = new OneToOneMsg( shelle, shelle );
+    // assert ( m != 0 );
 
-	while ( isInfinite ) // busy loop for debugging under gdb and MPI.
-		;
+    while ( isInfinite ) // busy loop for debugging under gdb and MPI.
+        ;
 
-	return shellId;
+    return shellId;
 }
 
 /**
@@ -270,28 +273,29 @@ Id init( int argc, char** argv, bool& doUnitTests, bool& doRegressionTests,
 void nonMpiTests( Shell* s )
 {
 #ifdef DO_UNIT_TESTS
-	if ( Shell::myNode() == 0 ) {
-		unsigned int numNodes = s->numNodes();
-		unsigned int numCores = s->numCores();
-		if ( numCores > 0 )
-		s->setHardware( 1, 1, 0 );
-		testAsync();
-		testMsg();
-		testShell();
-		testScheduling();
-		testBuiltins();
-		// testKinetics();
-		// testKineticSolvers();
-		testBiophysics();
-		// testHSolve();
-		// testGeom();
-		// testMesh();
-		// testSigNeur();
+    if ( Shell::myNode() == 0 )
+    {
+        unsigned int numNodes = s->numNodes();
+        unsigned int numCores = s->numCores();
+        if ( numCores > 0 )
+            s->setHardware( 1, 1, 0 );
+        testAsync();
+        testMsg();
+        testShell();
+        testScheduling();
+        testBuiltins();
+        // testKinetics();
+        // testKineticSolvers();
+        testBiophysics();
+        // testHSolve();
+        // testGeom();
+        // testMesh();
+        // testSigNeur();
 #ifdef USE_SMOLDYN
-		// testSmoldyn();
+        // testSmoldyn();
 #endif
-		s->setHardware( numCores, numNodes, 0 );
-	}
+        s->setHardware( numCores, numNodes, 0 );
+    }
 #endif
 }
 
@@ -302,13 +306,13 @@ void nonMpiTests( Shell* s )
 void processTests( Shell* s )
 {
 #ifdef DO_UNIT_TESTS
-	testSchedulingProcess();
-	testBuiltinsProcess();
-	// testKineticsProcess();
-	testBiophysicsProcess();
-	// testKineticSolversProcess();
-	// testSimManager();
-	// testSigNeurProcess();
+    testSchedulingProcess();
+    testBuiltinsProcess();
+    // testKineticsProcess();
+    testBiophysicsProcess();
+    // testKineticSolversProcess();
+    // testSimManager();
+    // testSigNeurProcess();
 #endif
 }
 
@@ -319,13 +323,13 @@ void processTests( Shell* s )
 void mpiTests()
 {
 #ifdef DO_UNIT_TESTS
-		testMpiMsg();
-		cout << "." << flush;
-		testMpiShell();
-		cout << "." << flush;
-		testMpiBuiltins();
-		cout << "." << flush;
-		testMpiScheduling();
-		cout << "." << flush;
+    testMpiMsg();
+    cout << "." << flush;
+    testMpiShell();
+    cout << "." << flush;
+    testMpiBuiltins();
+    cout << "." << flush;
+    testMpiScheduling();
+    cout << "." << flush;
 #endif
 }
diff --git a/python/moose/utils.py b/python/moose/utils.py
index 9abf7ae5d2636cbccfc80cb0c19535233c4f6def..8dbec98ab95916431cafe3e5efd3b0fc9630dd01 100644
--- a/python/moose/utils.py
+++ b/python/moose/utils.py
@@ -1,12 +1,7 @@
-# -*- coding: utf-8 -*-
-# utils.py:
-#
+# -* coding: utf-8 -*-
 # Utility functions for moose.
-#
-# NOTE: Some function might break because unicode is default string in python3.
 
 from __future__ import print_function, division, absolute_import
-
 from __future__ import print_function, division
 from __future__ import absolute_import
 
@@ -27,9 +22,7 @@ from moose.print_utils import *
 try:
     from moose.plot_utils import *
 except Exception as e:
-    info( "Plot utilities are not loaded due to '%s'" )
-    pass
-
+    info( "Plot utilities are not loaded due to '%s'" % e )
 
 def create_table_path(model, graph, element, field):
 
@@ -849,7 +842,6 @@ def get_child_Mstring(mooseobject,mstring):
             return child
     return None
 
-# Note: This function is also moved to helper.moose_methods
 def connect_CaConc(compartment_list, temperature=None):
     """ Connect the Ca pools and channels within each of the compartments in compartment_list
      Ca channels should have a child Mstring named 'ion' with value set in MOOSE.
@@ -917,112 +909,3 @@ def connect_CaConc(compartment_list, temperature=None):
                                     #print 'Connected concOut of',caconc.path,'to concen of',channel.path
                         except TypeError:
                             pass
-
-############# added by Aditya Gilra -- end ################
-import uuid
-import unittest
-import sys
-from io import StringIO as _sio
-
-class _TestMooseUtils(unittest.TestCase):
-    def test_printtree(self):
-        s = moose.Neutral('/cell')
-        soma = moose.Neutral('%s/soma'% (s.path))
-        d1 = moose.Neutral('%s/d1'% (soma.path))
-        d2 = moose.Neutral('%s/d2'% (soma.path))
-        d3 = moose.Neutral('%s/d3'% (d1.path))
-        d4 = moose.Neutral('%s/d4'% (d1.path))
-        d5 = moose.Neutral('%s/d5'% (s.path))
-        orig_stdout = sys.stdout
-        sys.stdout = _sio()
-        printtree(s)
-        expected = """
-cell
-|
-|__ soma
-|  |
-|  |__ d1
-|  |  |
-|  |  |__ d3
-|  |  |
-|  |  |__ d4
-|  |
-|  |__ d2
-|
-|__ d5
-"""
-        self.assertEqual(sys.stdout.getvalue(), expected)
-        sys.stdout = _sio()
-        s1 = moose.Neutral('cell1')
-        c1 = moose.Neutral('%s/c1' % (s1.path))
-        c2 = moose.Neutral('%s/c2' % (c1.path))
-        c3 = moose.Neutral('%s/c3' % (c1.path))
-        c4 = moose.Neutral('%s/c4' % (c2.path))
-        c5 = moose.Neutral('%s/c5' % (c3.path))
-        c6 = moose.Neutral('%s/c6' % (c3.path))
-        c7 = moose.Neutral('%s/c7' % (c4.path))
-        c8 = moose.Neutral('%s/c8' % (c5.path))
-        printtree(s1)
-        expected1 = """
-cell1
-|
-|__ c1
-   |
-   |__ c2
-   |  |
-   |  |__ c4
-   |     |
-   |     |__ c7
-   |
-   |__ c3
-      |
-      |__ c5
-      |  |
-      |  |__ c8
-      |
-      |__ c6
-"""
-        self.assertEqual(sys.stdout.getvalue(), expected1)
-
-    def test_autoposition(self):
-        """Simple check for automatic generation of positions.
-
-        A spherical soma is created with 20 um diameter. A 100
-        compartment cable is created attached to it with each
-        compartment of length 100 um.
-
-        """
-        testid = 'test%s' % (uuid.uuid4())
-        container = moose.Neutral('/test')
-        model = moose.Neuron('/test/%s' % (testid))
-        soma = moose.Compartment('%s/soma' % (model.path))
-        soma.diameter = 20e-6
-        soma.length = 0.0
-        parent = soma
-        comps = []
-        for ii in range(100):
-            comp = moose.Compartment('%s/comp_%d' % (model.path, ii))
-            comp.diameter = 10e-6
-            comp.length = 100e-6
-            moose.connect(parent, 'raxial', comp, 'axial')
-            comps.append(comp)
-            parent = comp
-        soma = autoposition(model)
-        sigfig = 8
-        self.assertAlmostEqual(soma.x0, 0.0, sigfig)
-        self.assertAlmostEqual(soma.y0, 0.0, sigfig)
-        self.assertAlmostEqual(soma.z0, 0.0, sigfig)
-        self.assertAlmostEqual(soma.x, 0.0, sigfig)
-        self.assertAlmostEqual(soma.y, 0.0, sigfig)
-        self.assertAlmostEqual(soma.z, soma.diameter/2.0, sigfig)
-        for ii, comp in enumerate(comps):
-            print(comp.path, ii)
-            self.assertAlmostEqual(comp.x0, 0, sigfig)
-            self.assertAlmostEqual(comp.y0, 0.0, sigfig)
-            self.assertAlmostEqual(comp.z0, soma.diameter/2.0 + ii * 100e-6, sigfig)
-            self.assertAlmostEqual(comp.x, 0.0, sigfig)
-            self.assertAlmostEqual(comp.y, 0.0, sigfig)
-            self.assertAlmostEqual(comp.z, soma.diameter/2.0 + (ii + 1) * 100e-6, sigfig)
-
-if __name__ == "__main__": # test printtree
-    unittest.main()
diff --git a/python/rdesigneur/rdesigneur.py b/python/rdesigneur/rdesigneur.py
index aa5b3fce4b5513a3579fae9e365687e7f24c6ce3..568bac944455073b43e71ad2cf2dbaa3faf69e9c 100644
--- a/python/rdesigneur/rdesigneur.py
+++ b/python/rdesigneur/rdesigneur.py
@@ -29,12 +29,7 @@ import matplotlib.pyplot as plt
 
 import rdesigneur.rmoogli as rmoogli
 from rdesigneur.rdesigneurProtos import *
-from moose.fixXreacs import fixXreacs
-#import fixXreacs
-#from . import fixXreacs
-#from rdesigneur.rmoogli import *
-#import rmoogli
-#from rdesigneurProtos import *
+import moose.fixXreacs as fixXreacs
 
 from moose.neuroml.NeuroML import NeuroML
 from moose.neuroml.ChannelML import ChannelML
@@ -101,8 +96,8 @@ class rdesigneur:
             chemDistrib = [],
             adaptorList= [],
             stimList = [],
-            plotList = [],  # elecpath, geom_expr, object, field, title ['wave' [min max]]
-            moogList = [], 
+            plotList = [],
+            moogList = [],
             params = None
         ):
         """ Constructor of the rdesigner. This just sets up internal fields
@@ -143,16 +138,11 @@ class rdesigneur:
         self.params = params
 
         self.adaptorList = adaptorList
-        try:
-            self.stimList = [ rstim.convertArg(i) for i in stimList ]
-            self.plotList = [ rplot.convertArg(i) for i in plotList ]
-            self.moogList = [ rmoog.convertArg(i) for i in moogList ]
-        except BuildError as msg:
-            print("Error: rdesigneur: " + msg)
-            quit()
-
-        #self.saveList = plotList                    #ADDED BY Sarthak
+        self.stimList = stimList
+        self.plotList = plotList
+        self.saveList = plotList                    #ADDED BY Sarthak
         self.saveAs = []
+        self.moogList = moogList
         self.plotNames = []
         self.wavePlotNames = []
         self.saveNames = []
@@ -174,19 +164,18 @@ class rdesigneur:
             quit()
 
 
-
     ################################################################
     def _printModelStats( self ):
-        print("Rdesigneur: Elec model has",
+        print("\n\tRdesigneur: Elec model has",
             self.elecid.numCompartments, "compartments and",
             self.elecid.numSpines, "spines on",
             len( self.cellPortionElist ), "compartments.")
         if hasattr( self , 'chemid' ):
             dmstoich = moose.element( self.dendCompt.path + '/stoich' )
-            print("Chem part of model has the following compartments: ")
+            print("\tChem part of model has the following compartments: ")
             for j in moose.wildcardFind( '/model/chem/##[ISA=ChemCompt]'):
                 s = moose.element( j.path + '/stoich' )
-                print( "In {}, {} voxels X {} pools".format( j.name, j.mesh.num, s.numAllPools ) )
+                print( "\t | In {}, {} voxels X {} pools".format( j.name, j.mesh.num, s.numAllPools ) )
 
     def buildModel( self, modelPath = '/model' ):
         if moose.exists( modelPath ):
@@ -195,28 +184,30 @@ class rdesigneur:
             return
         self.model = moose.Neutral( modelPath )
         self.modelPath = modelPath
-        try:
-            # Protos made in the init phase. Now install the elec and
-            # chem protos on model.
-            self.installCellFromProtos()
-            # Now assign all the distributions
-            self.buildPassiveDistrib()
-            self.buildChanDistrib()
-            self.buildSpineDistrib()
-            self.buildChemDistrib()
-            self._configureSolvers()
-            self.buildAdaptors()
-            self._buildStims()
-            self._buildPlots()
-            self._buildMoogli()
-            self._configureHSolve()
-            self._configureClocks()
+        print( "[INFO ] rdesigneur: Building model. " )
+        funcs = [ self.installCellFromProtos, self.buildPassiveDistrib
+            , self.buildChanDistrib, self.buildSpineDistrib, self.buildChemDistrib
+            , self._configureSolvers, self.buildAdaptors, self._buildStims
+            , self._buildPlots, self._buildMoogli, self._configureHSolve
+            , self._configureClocks, self._printModelStats, self._savePlots 
+            ]
+        for i, _func in enumerate( funcs ):
             if self.verbose:
-                self._printModelStats()
-
-        except BuildError as msg:
-            print("Error: rdesigneur: model build failed:", msg)
-            moose.delete( self.model )
+                print( " + (%d/%d) executing %25s"%(i, len(funcs), _func.__name__), end=' ' )
+                sys.stdout.flush()
+            t0 = time.time()
+            try:
+                _func( )
+            except BuildError as msg:
+                print("Error: rdesigneur: model build failed:", msg)
+                moose.delete( self.model )
+                return
+            t = time.time() - t0
+            if self.verbose:
+                msg = r'    ... DONE'
+                if t > 1:
+                    msg += ' %.3f sec' % t
+                print( msg )
 
     def installCellFromProtos( self ):
         if self.stealCellFromLibrary:
@@ -257,11 +248,14 @@ class rdesigneur:
         if bracePos == -1:
             return False
 
-        modPos = func.find( "." )
+        # . can be in path name as well. Find the last dot which is most likely
+        # to be the function name.
+        modPos = func.rfind( "." )
         if ( modPos != -1 ): # Function is in a file, load and check
-            pathTokens = func[0:modPos].split('/')
+            resolvedPath = os.path.realpath( func[0:modPos] )
+            pathTokens = resolvedPath.split('/')
             pathTokens = ['/'] + pathTokens
-            modulePath = os.path.join(*pathTokens[:-1])
+            modulePath = os.path.realpath(os.path.join(*pathTokens[:-1]))
             moduleName = pathTokens[-1]
             funcName = func[modPos+1:bracePos]
             moduleFile, pathName, description = imp.find_module(moduleName, [modulePath])
@@ -469,10 +463,10 @@ class rdesigneur:
         # Here we hack geomExpr to use it for the syn weight. We assume it
         # is just a number. In due course
         # it should be possible to actually evaluate it according to geom.
-        synWeight = float( stimInfo.geom_expr )
+        synWeight = float( stimInfo[1] )
         stimObj = []
         for i in dendCompts + spineCompts:
-            path = i.path + '/' + stimInfo.relpath + '/sh/synapse[0]'
+            path = i.path + '/' + stimInfo[2] + '/sh/synapse[0]'
             if moose.exists( path ):
                 synInput = make_synInput( name='synInput', parent=path )
                 synInput.doPeriodic = doPeriodic
@@ -492,10 +486,6 @@ class rdesigneur:
 	# Expression can use p, g, L, len, dia, maxP, maxG, maxL.
         temp = []
         for i in self.passiveDistrib:
-            if (len( i ) < 3) or (len(i) %2 != 1):
-                raise BuildError( "buildPassiveDistrib: Need 3 + N*2 arguments, have {}".format( len(i) ) )
-
-            temp.append( '.' )
             temp.extend( i )
             temp.extend( [""] )
         self.elecid.passiveDistribution = temp
@@ -609,24 +599,27 @@ class rdesigneur:
 
     # Utility function for doing lookups for objects.
     def _makeUniqueNameStr( self, obj ):
-        return obj.name + " " + str( obj.index )
+        # second one is faster than the former. 140 ns v/s 180 ns.
+        #  return obj.name + " " + str( obj.index )
+        return "%s %s" % (obj.name, obj.index)
 
     # Returns vector of source objects, and the field to use.
     # plotSpec is of the form
     #   [ region_wildcard, region_expr, path, field, title]
     def _parseComptField( self, comptList, plotSpec, knownFields ):
         # Put in stuff to go through fields if the target is a chem object
-        field = plotSpec.field
+        field = plotSpec[3]
         if not field in knownFields:
             print("Warning: Rdesigneur::_parseComptField: Unknown field '{}'".format( field ) )
             return (), ""
 
         kf = knownFields[field] # Find the field to decide type.
-        if ( kf[0] == 'CaConcBase' or kf[0] == 'ChanBase' or kf[0] == 'NMDAChan' or kf[0] == 'VClamp' ):
-            objList = self._collapseElistToPathAndClass( comptList, plotSpec.relpath, kf[0] )
+        if kf[0] in ['CaConcBase', 'ChanBase', 'NMDAChan', 'VClamp']:
+            objList = self._collapseElistToPathAndClass( comptList, plotSpec[2], kf[0] )
             return objList, kf[1]
-        elif (field == 'n' or field == 'conc' or field == 'volume'  ):
-            path = plotSpec.relpath
+
+        elif field in [ 'n', 'conc', 'volume']:
+            path = plotSpec[2]
             pos = path.find( '/' )
             if pos == -1:   # Assume it is in the dend compartment.
                 path  = 'dend/' + path
@@ -647,13 +640,13 @@ class rdesigneur:
 
             voxelVec = [i for i in range(len( em ) ) if em[i] in comptSet ]
             # Here we collapse the voxelVec into objects to plot.
-            allObj = moose.vec( self.modelPath + '/chem/' + plotSpec.relpath )
+            allObj = moose.vec( self.modelPath + '/chem/' + plotSpec[2] )
             #print "####### allObj=", self.modelPath + '/chem/' + plotSpec[2]
             if len( allObj ) >= len( voxelVec ):
                 objList = [ allObj[int(j)] for j in voxelVec]
             else:
                 objList = []
-                print( "Warning: Rdesigneur::_parseComptField: unknown Object: '", plotSpec.relpath, "'" )
+                print( "Warn: Rdesigneur::_parseComptField: unknown Object: '%s'" % plotSpec[2] )
             #print "############", chemCompt, len(objList), kf[1]
             return objList, kf[1]
 
@@ -685,7 +678,7 @@ class rdesigneur:
         dummy = moose.element( '/' )
         k = 0
         for i in self.plotList:
-            pair = i.elecpath + ' ' + i.geom_expr
+            pair = i[0] + " " + i[1]
             dendCompts = self.elecid.compartmentsFromExpression[ pair ]
             spineCompts = self.elecid.spinesFromExpression[ pair ]
             plotObj, plotField = self._parseComptField( dendCompts, i, knownFields )
@@ -693,32 +686,32 @@ class rdesigneur:
             assert( plotField == plotField2 )
             plotObj3 = plotObj + plotObj2
             numPlots = sum( q != dummy for q in plotObj3 )
-            #print( "PlotList: {0}: numobj={1}, field ={2}, nd={3}, ns={4}".format( pair, numPlots, plotField, len( dendCompts ), len( spineCompts ) ) )
-            if numPlots > 0:
-                tabname = graphs.path + '/plot' + str(k)
-                scale = knownFields[i.field][2]
-                units = knownFields[i.field][3]
-                if i.mode == 'wave':
-                    self.wavePlotNames.append( [ tabname, i.title, k, scale, units, i.field, i.ymin, i.ymax ] )
-                else:
-                    self.plotNames.append( [ tabname, i.title, k, scale, units, i.field, i.ymin, i.ymax ] )
-                if len( i.saveFile ) > 4 and i.saveFile[-4] == '.xml' or i.saveFile:
-                    self.saveNames.append( [ tabname, len(self.saveNames), scale, units, i ] )
+            if numPlots == 0:
+                return 
+
+            tabname = graphs.path + '/plot' + str(k)
+            scale = knownFields[i[3]][2]
+            units = knownFields[i[3]][3]
+            ymin = i[6] if len(i) > 7 else 0
+            ymax = i[7] if len(i) > 7 else 0
+            if len( i ) > 5 and i[5] == 'wave':
+                self.wavePlotNames.append( [ tabname, i[4], k, scale, units, i[3], ymin, ymax ] )
+            else:
+                self.plotNames.append( [ tabname, i[4], k, scale, units, i[3], ymin, ymax ] )
+            k += 1
+            if i[3] in [ 'n', 'conc', 'volume', 'Gbar' ]:
+                tabs = moose.Table2( tabname, numPlots )
+            else:
+                tabs = moose.Table( tabname, numPlots )
+                if i[3] == 'spikeTime':
+                    tabs.vec.threshold = -0.02 # Threshold for classifying Vm as a spike.
+                    tabs.vec.useSpikeMode = True # spike detect mode on
 
-                k += 1
-                if i.field == 'n' or i.field == 'conc' or i.field == 'volume' or i.field == 'Gbar':
-                    tabs = moose.Table2( tabname, numPlots )
-                else:
-                    tabs = moose.Table( tabname, numPlots )
-                    if i.field == 'spikeTime':
-                        tabs.vec.threshold = -0.02 # Threshold for classifying Vm as a spike.
-                        tabs.vec.useSpikeMode = True # spike detect mode on
-
-                vtabs = moose.vec( tabs )
-                q = 0
-                for p in [ x for x in plotObj3 if x != dummy ]:
-                    moose.connect( vtabs[q], 'requestOut', p, plotField )
-                    q += 1
+            vtabs = moose.vec( tabs )
+            q = 0
+            for p in [ x for x in plotObj3 if x != dummy ]:
+                moose.connect( vtabs[q], 'requestOut', p, plotField )
+                q += 1
 
     def _buildMoogli( self ):
         knownFields = {
@@ -738,8 +731,8 @@ class rdesigneur:
         moogliBase = moose.Neutral( self.modelPath + '/moogli' )
         k = 0
         for i in self.moogList:
-            kf = knownFields[i.field]
-            pair = i.elecpath + " " + i.geom_expr
+            kf = knownFields[i[3]]
+            pair = i[0] + " " + i[1]
             dendCompts = self.elecid.compartmentsFromExpression[ pair ]
             spineCompts = self.elecid.spinesFromExpression[ pair ]
             dendObj, mooField = self._parseComptField( dendCompts, i, knownFields )
@@ -747,6 +740,13 @@ class rdesigneur:
             assert( mooField == mooField2 )
             mooObj3 = dendObj + spineObj
             numMoogli = len( mooObj3 )
+            #dendComptMap = self.dendCompt.elecComptMap
+            #self.moogliViewer = rmoogli.makeMoogli( self, mooObj3, mooField )
+            if len( i ) == 5:
+                i.extend( kf[4:6] )
+            elif len( i ) == 6:
+                i.extend( [kf[5]] )
+            #self.moogliViewer = rmoogli.makeMoogli( self, mooObj3, i, kf )
             self.moogNames.append( rmoogli.makeMoogli( self, mooObj3, i, kf ) )
 
 
@@ -770,7 +770,6 @@ rdesigneur.rmoogli.updateMoogliViewer()
 
     def display( self, startIndex = 0 ):
         for i in self.plotNames:
-            # ?, title, fignum, scale, ylabel, wave/spikeTime, ymin, ymax
             plt.figure( i[2] + startIndex )
             plt.title( i[1] )
             plt.xlabel( "Time (s)" )
@@ -788,8 +787,6 @@ rdesigneur.rmoogli.updateMoogliViewer()
                 t = np.arange( 0, vtab[0].vector.size, 1 ) * vtab[0].dt
                 for j in vtab:
                     plt.plot( t, j.vector * i[3] )
-                    if i[6] != i[7]:
-                        plt.ylim( i[6], i[7] )
         if len( self.moogList ) or len( self.wavePlotNames ) > 0:
             plt.ion()
         # Here we build the plots and lines for the waveplots
@@ -818,14 +815,10 @@ rdesigneur.rmoogli.updateMoogliViewer()
             plt.title( i[1] )
             plt.xlabel( "position (voxels)" )
             plt.ylabel( i[4] )
-            if i[6] != i[7]:
-                mn = i[6]
-                mx = i[7]
-            else:
-                mn = np.min(vpts)
-                mx = np.max(vpts)
-                if mn/mx < 0.3:
-                    mn = 0
+            mn = np.min(vpts)
+            mx = np.max(vpts)
+            if mn/mx < 0.3:
+                mn = 0
             ax.set_ylim( mn, mx )
             line, = plt.plot( range( len( vtab ) ), vpts[0] )
             timeLabel = plt.text( len(vtab ) * 0.05, mn + 0.9*(mx-mn), 'time = 0' )
@@ -835,7 +828,7 @@ rdesigneur.rmoogli.updateMoogliViewer()
     def displayWavePlots( self ):
         for f in range( self.numWaveFrames ):
             for i in self.wavePlotNames:
-                wp = i[-1]
+                wp = i[6]
                 if len( wp[2] ) > f:
                     wp[1].set_ydata( wp[2][f] )
                     wp[3].set_text( "time = {:.1f}".format(f*self.frameDt) )
@@ -854,13 +847,134 @@ rdesigneur.rmoogli.updateMoogliViewer()
     Email address: sarthaks442@gmail.com
     Heavily modified by U.S. Bhalla
     '''
-    def _writeXML( self, plotData, time, vtab ): 
-        tabname = plotData[0]
-        idx = plotData[1]
-        scale = plotData[2]
-        units = plotData[3]
-        rp = plotData[4]
-        filename = rp.saveFile[:-4] + str(idx) + '.xml'
+
+    def _savePlots( self ):
+        if self.verbose:
+            print( 'rdesigneur: Saving plots ...', end = ' ' )
+            sys.stdout.flush()
+
+        knownFields = {
+            'Vm':('CompartmentBase', 'getVm', 1000, 'Memb. Potential (mV)' ),
+            'Cm':('CompartmentBase', 'getCm', 1e12, 'Memb. capacitance (pF)' ),
+            'Rm':('CompartmentBase', 'getRm', 1e-9, 'Memb. Res (GOhm)' ),
+            'Ra':('CompartmentBase', 'getRa', 1e-6, 'Axial Res (MOhm)' ),
+            'spikeTime':('CompartmentBase', 'getVm', 1, 'Spike Times (s)'),
+            'Im':('CompartmentBase', 'getIm', 1e9, 'Memb. current (nA)' ),
+            'inject':('CompartmentBase', 'getInject', 1e9, 'inject current (nA)' ),
+            'Gbar':('ChanBase', 'getGbar', 1e9, 'chan max conductance (nS)' ),
+            'modulation':('ChanBase', 'getModulation', 1, 'chan modulation (unitless)' ),
+            'Gk':('ChanBase', 'getGk', 1e9, 'chan conductance (nS)' ),
+            'Ik':('ChanBase', 'getIk', 1e9, 'chan current (nA)' ),
+            'ICa':('NMDAChan', 'getICa', 1e9, 'Ca current (nA)' ),
+            'Ca':('CaConcBase', 'getCa', 1e3, 'Ca conc (uM)' ),
+            'n':('PoolBase', 'getN', 1, '# of molecules'),
+            'conc':('PoolBase', 'getConc', 1000, 'Concentration (uM)' ),
+            'volume':('PoolBase', 'getVolume', 1e18, 'Volume (um^3)' ),
+            'current':('VClamp', 'getCurrent', 1e9, 'Holding Current (nA)')
+        }
+
+        save_graphs = moose.Neutral( self.modelPath + '/save_graphs' )
+        dummy = moose.element( '/' )
+        k = 0
+
+        for i in self.saveList:
+            pair = i[0] + " " + i[1]
+            dendCompts = self.elecid.compartmentsFromExpression[ pair ]
+            spineCompts = self.elecid.spinesFromExpression[ pair ]
+            plotObj, plotField = self._parseComptField( dendCompts, i, knownFields )
+            plotObj2, plotField2 = self._parseComptField( spineCompts, i, knownFields )
+            assert( plotField == plotField2 )
+            plotObj3 = plotObj + plotObj2
+            numPlots = sum( i != dummy for i in plotObj3 )
+            if numPlots > 0:
+                save_tabname = save_graphs.path + '/save_plot' + str(k)
+                scale = knownFields[i[3]][2]
+                units = knownFields[i[3]][3]
+                self.saveNames.append( ( save_tabname, i[4], k, scale, units ) )
+                k += 1
+                if i[3] in [ 'n', 'conc', 'volume', 'Gbar' ]:
+                    save_tabs = moose.Table2( save_tabname, numPlots )
+                    save_vtabs = moose.vec( save_tabs )
+                else:
+                    save_tabs = moose.Table( save_tabname, numPlots )
+                    save_vtabs = moose.vec( save_tabs )
+                    if i[3] == 'spikeTime':
+                        save_vtabs.threshold = -0.02 # Threshold for classifying Vm as a spike.
+                        save_vtabs.useSpikeMode = True # spike detect mode on
+                q = 0
+                for p in [ x for x in plotObj3 if x != dummy ]:
+                    moose.connect( save_vtabs[q], 'requestOut', p, plotField )
+                    q += 1
+
+        if self.verbose:
+            print( ' ... DONE.' )
+
+    def _getTimeSeriesTable( self ):
+
+        '''
+        This function gets the list with all the details of the simulation
+        required for plotting.
+        This function adds flexibility in terms of the details
+        we wish to store.
+        '''
+
+        knownFields = {
+            'Vm':('CompartmentBase', 'getVm', 1000, 'Memb. Potential (mV)' ),
+            'spikeTime':('CompartmentBase', 'getVm', 1, 'Spike Times (s)'),
+            'Im':('CompartmentBase', 'getIm', 1e9, 'Memb. current (nA)' ),
+            'inject':('CompartmentBase', 'getInject', 1e9, 'inject current (nA)' ),
+            'Gbar':('ChanBase', 'getGbar', 1e9, 'chan max conductance (nS)' ),
+            'Gk':('ChanBase', 'getGk', 1e9, 'chan conductance (nS)' ),
+            'Ik':('ChanBase', 'getIk', 1e9, 'chan current (nA)' ),
+            'ICa':('NMDAChan', 'getICa', 1e9, 'Ca current (nA)' ),
+            'Ca':('CaConcBase', 'getCa', 1e3, 'Ca conc (uM)' ),
+            'n':('PoolBase', 'getN', 1, '# of molecules'),
+            'conc':('PoolBase', 'getConc', 1000, 'Concentration (uM)' ),
+            'volume':('PoolBase', 'getVolume', 1e18, 'Volume (um^3)' )
+        }
+
+        '''
+        This takes data from plotList
+        saveList is exactly like plotList but with a few additional arguments:
+        ->It will have a resolution option, i.e., the number of decimal figures to which the value should be rounded
+        ->There is a list of "saveAs" formats
+        With saveList, the user will able to set what all details he wishes to be saved.
+        '''
+
+        for i,ind in enumerate(self.saveNames):
+            pair = self.saveList[i][0] + " " + self.saveList[i][1]
+            dendCompts = self.elecid.compartmentsFromExpression[ pair ]
+            spineCompts = self.elecid.spinesFromExpression[ pair ]
+            # Here we get the object details from plotList
+            savePlotObj, plotField = self._parseComptField( dendCompts, self.saveList[i], knownFields )
+            savePlotObj2, plotField2 = self._parseComptField( spineCompts, self.saveList[i], knownFields )
+            savePlotObj3 = savePlotObj + savePlotObj2
+
+            rowList = list(ind)
+            save_vtab = moose.vec( ind[0] )
+            t = np.arange( 0, save_vtab[0].vector.size, 1 ) * save_vtab[0].dt
+
+            rowList.append(save_vtab[0].dt)
+            rowList.append(t)
+            rowList.append([jvec.vector * ind[3] for jvec in save_vtab])             #get values
+            rowList.append(self.saveList[i][3])
+            rowList.append(filter(lambda obj: obj.path != '/', savePlotObj3))        #this filters out dummy elements
+
+            if (type(self.saveList[i][-1])==int):
+                rowList.append(self.saveList[i][-1])
+            else:
+                rowList.append(12)
+
+            self.tabForXML.append(rowList)
+            rowList = []
+
+        timeSeriesTable = self.tabForXML                                            # the list with all the details of plot
+        return timeSeriesTable
+
+    def _writeXML( self, filename, timeSeriesData ):                                #to write to XML file
+
+        plotData = timeSeriesData
+        print("[CAUTION] The '%s' file might be very large if all the compartments are to be saved." % filename)
         root = etree.Element("TimeSeriesPlot")
         parameters = etree.SubElement( root, "parameters" )
         if self.params == None:
@@ -873,33 +987,36 @@ rdesigneur.rmoogli.updateMoogliViewer()
 
         #plotData contains all the details of a single plot
         title = etree.SubElement( root, "timeSeries" )
-        title.set( 'title', rp.title)
-        title.set( 'field', rp.field)
-        title.set( 'scale', str(scale) )
-        title.set( 'units', units)
-        title.set( 'dt', str(vtab[0].dt) )
-        res = rp.saveResolution
+        title.set( 'title', str(plotData[1]))
+        title.set( 'field', str(plotData[8]))
+        title.set( 'scale', str(plotData[3]))
+        title.set( 'units', str(plotData[4]))
+        title.set( 'dt', str(plotData[5]))
         p = []
-        for t, v in zip( time, vtab ):
+        assert(len(plotData[7]) == len(plotData[9]))
+
+        res = plotData[10]
+        for ind, jvec in enumerate(plotData[7]):
             p.append( etree.SubElement( title, "data"))
-            p[-1].set( 'path', v.path )
-            p[-1].text = ''.join( str(round(y,res)) + ' ' for y in v.vector )
+            p[-1].set( 'path', str(plotData[9][ind].path))
+            p[-1].text = ''.join( str(round(value,res)) + ' ' for value in jvec )
         tree = etree.ElementTree(root)
         tree.write(filename)
 
-    def _writeCSV( self, plotData, time, vtab ): 
-        tabname = plotData[0]
-        idx = plotData[1]
-        scale = plotData[2]
-        units = plotData[3]
-        rp = plotData[4]
-        filename = rp.saveFile[:-4] + str(idx) + '.csv'
-
-        header = ["time",]
-        valMatrix = [time,]
-        header.extend( [ v.path for v in vtab ] )
-        valMatrix.extend( [ v.vector for v in vtab ] )
-        nv = np.array( valMatrix ).T
+    def _writeCSV(self, filename, timeSeriesData):
+
+        plotData = timeSeriesData
+        dataList = []
+        header = []
+        time = plotData[6]
+        res = plotData[10]
+
+        for ind, jvec in enumerate(plotData[7]):
+            header.append(plotData[9][ind].path)
+            dataList.append([round(value,res) for value in jvec.tolist()])
+        dl = [tuple(lst) for lst in dataList]
+        rows = zip(tuple(time), *dl)
+        header.insert(0, "time")
         with open(filename, 'wb') as f:
             writer = csv.writer(f, quoting=csv.QUOTE_MINIMAL)
             writer.writerow(header)
@@ -907,25 +1024,42 @@ rdesigneur.rmoogli.updateMoogliViewer()
                 writer.writerow(row)
 
     ##########****SAVING*****###############
+    def _saveFormats(self, timeSeriesData, k, *filenames):
+        "This takes in the filenames and writes to corresponding format."
+        if filenames:
+            for filename in filenames:
+                for name in filename:
+                    print (name)
+                    if name[-4:] == '.xml':
+                        self._writeXML(name, timeSeriesData)
+                        print(name, " written")
+                    elif name[-4:] == '.csv':
+                        self._writeCSV(name, timeSeriesData)
+                        print(name, " written")
+                    else:
+                        print("Save format not known")
+                        pass
+        else:
+            pass
 
 
     def _save( self ):
-        for i in self.saveNames:
-            tabname = i[0]
-            idx = i[1]
-            scale = i[2]
-            units = i[3]
-            rp = i[4] # The rplot data structure, it has the setup info.
-
-            vtab = moose.vec( tabname )
-            t = np.arange( 0, vtab[0].vector.size, 1 ) * vtab[0].dt
-            ftype = rp.filename[-4:]
-            if ftype == '.xml':
-                self._writeXML( i, t, vtab )
-            elif ftype == '.csv':
-                self._writeCSV( i, t, vtab )
+        timeSeriesTable = self._getTimeSeriesTable()
+        for i,sList in enumerate(self.saveList):
+
+            if (len(sList) >= 6) and (type(sList[5]) != int):
+                    self.saveAs.extend(filter(lambda fmt: type(fmt)!=int, sList[5:]))
+                    try:
+                        timeSeriesData = timeSeriesTable[i]
+                    except IndexError:
+                        print("The object to be plotted has all dummy elements.")
+                        pass
+                    self._saveFormats(timeSeriesData, i, self.saveAs)
+                    self.saveAs=[]
             else:
-                print("Save format '{}' not known, please use .csv or .xml".format( ftype ) )
+                pass
+        else:
+            pass
 
     ################################################################
     # Here we set up the stims
@@ -946,17 +1080,17 @@ rdesigneur.rmoogli.updateMoogliViewer()
         k = 0
         # Stimlist = [path, geomExpr, relPath, field, expr_string]
         for i in self.stimList:
-            pair = i.elecpath + " " + i.geom_expr
+            pair = i[0] + " " + i[1]
             dendCompts = self.elecid.compartmentsFromExpression[ pair ]
             spineCompts = self.elecid.spinesFromExpression[ pair ]
             #print( "pair = {}, numcompts = {},{} ".format( pair, len( dendCompts), len( spineCompts ) ) )
-            if i.field == 'vclamp':
+            if i[3] == 'vclamp':
                 stimObj3 = self._buildVclampOnCompt( dendCompts, spineCompts, i )
                 stimField = 'commandIn'
-            elif i.field == 'randsyn':
+            elif i[3] == 'randsyn':
                 stimObj3 = self._buildSynInputOnCompt( dendCompts, spineCompts, i )
                 stimField = 'setRate'
-            elif i.field == 'periodicsyn':
+            elif i[3] == 'periodicsyn':
                 stimObj3 = self._buildSynInputOnCompt( dendCompts, spineCompts, i, doPeriodic = True )
                 stimField = 'setRate'
             else:
@@ -969,7 +1103,7 @@ rdesigneur.rmoogli.updateMoogliViewer()
                 funcname = stims.path + '/stim' + str(k)
                 k += 1
                 func = moose.Function( funcname )
-                func.expr = i.expr
+                func.expr = i[4]
                 #if i[3] == 'vclamp': # Hack to clean up initial condition
                 func.doEvalAtReinit = 1
                 for q in stimObj3:
@@ -1324,7 +1458,7 @@ rdesigneur.rmoogli.updateMoogliViewer()
             return
         if not hasattr( self, 'dendCompt' ):
             raise BuildError( "configureSolvers: no chem meshes defined." )
-        fixXreacs( self.chemid.path )
+        fixXreacs.fixXreacs( self.chemid.path )
         dmksolve = moose.Ksolve( self.dendCompt.path + '/ksolve' )
         dmdsolve = moose.Dsolve( self.dendCompt.path + '/dsolve' )
         dmstoich = moose.Stoich( self.dendCompt.path + '/stoich' )
@@ -1485,95 +1619,3 @@ rdesigneur.rmoogli.updateMoogliViewer()
                 for j in range( i[1], i[2] ):
                     moose.connect( i[3], 'requestOut', chemVec[j], chemFieldSrc)
                 msg = moose.connect( i[3], 'output', elObj, elecFieldDest )
-
-
-#######################################################################
-# Some helper classes, used to define argument lists.
-#######################################################################
-
-class baseplot:
-    def __init__( self,
-            elecpath='soma', geom_expr='1', relpath='.', field='Vm' ):
-        self.elecpath = elecpath
-        self.geom_expr = geom_expr
-        self.relpath = relpath
-        self.field = field
-
-class rplot( baseplot ):
-    def __init__( self,
-        elecpath = 'soma', geom_expr = '1', relpath = '.', field = 'Vm', 
-        title = 'Membrane potential', 
-        mode = 'time', 
-        ymin = 0.0, ymax = 0.0, 
-        saveFile = "", saveResolution = 3, show = True ):
-        baseplot.__init__( self, elecpath, geom_expr, relpath, field )
-        self.title = title
-        self.mode = mode # Options: time, wave, wave_still, raster
-        self.ymin = ymin # If ymin == ymax, it autoscales.
-        self.ymax = ymax
-        if len( saveFile ) < 5:
-            self.saveFile = ""
-        else:
-            f = saveFile.split('.')
-            if len(f) < 2 or ( f[-1] != 'xml' and f[-1] != 'csv' ):
-                raise BuildError( "rplot: Filetype is '{}', must be of type .xml or .csv.".format( f[-1] ) )
-        self.saveFile = saveFile
-        self.show = show
-
-    def printme( self ):
-        print( "{}, {}, {}, {}, {}, {}, {}, {}, {}, {}".format( 
-            self.elecpath,
-            self.geom_expr, self.relpath, self.field, self.title,
-            self.mode, self.ymin, self.ymax, self.saveFile, self.show ) )
-
-    @staticmethod
-    def convertArg( arg ):
-        if isinstance( arg, rplot ):
-            return arg
-        elif isinstance( arg, list ):
-            return rplot( *arg )
-        else:
-            raise BuildError( "rplot initialization failed" )
-
-class rmoog( baseplot ):
-    def __init__( self,
-        elecpath = 'soma', geom_expr = '1', relpath = '.', field = 'Vm', 
-        title = 'Membrane potential', 
-        ymin = 0.0, ymax = 0.0, 
-        show = True ): # Could put in other display options.
-        baseplot.__init__( self, elecpath, geom_expr, relpath, field )
-        self.title = title
-        self.ymin = ymin # If ymin == ymax, it autoscales.
-        self.ymax = ymax
-        self.show = show
-
-    @staticmethod
-    def convertArg( arg ):
-        if isinstance( arg, rmoog ):
-            return arg
-        elif isinstance( arg, list ):
-            return rmoog( *arg )
-        else:
-            raise BuildError( "rmoog initialization failed" )
-
-        # Stimlist = [path, geomExpr, relPath, field, expr_string]
-class rstim( baseplot ):
-    def __init__( self,
-            elecpath = 'soma', geom_expr = '1', relpath = '.', field = 'inject', expr = '0'):
-        baseplot.__init__( self, elecpath, geom_expr, relpath, field )
-        self.expr = expr
-
-    def printme( self ):
-        print( "{}, {}, {}, {}, {}, {}, {}, {}, {}, {}".format( 
-            self.elecpath,
-            self.geom_expr, self.relpath, self.field, self.expr ) )
-
-    @staticmethod
-    def convertArg( arg ):
-        if isinstance( arg, rstim ):
-            return arg
-        elif isinstance( arg, list ):
-            return rstim( *arg )
-        else:
-            raise BuildError( "rstim initialization failed" )
-
diff --git a/shell/Shell.cpp b/shell/Shell.cpp
index 775092c634f768c95caa2021c11a878338491720..e4b2946350516eaa7dd4cc2ea8e6e7244062d820 100644
--- a/shell/Shell.cpp
+++ b/shell/Shell.cpp
@@ -348,6 +348,11 @@ void Shell::doStart( double runtime, bool notify )
         Streamer* pStreamer = reinterpret_cast<Streamer*>( itr->data( ) );
         pStreamer->cleanUp( );
     }
+
+    // Print the stats collected by profiling map.
+    char* p = getenv( "MOOSE_SHOW_SOLVER_PERF" );
+    if( p != NULL )
+        moose::printSolverProfMap( );
 }
 
 bool isDoingReinit()
diff --git a/shell/Wildcard.cpp b/shell/Wildcard.cpp
index 17e69dc23e1ef1cf3c7019ea27b0879bfb739a55..0ce0567a4896e94c438810c26a0fc10d16bc998b 100644
--- a/shell/Wildcard.cpp
+++ b/shell/Wildcard.cpp
@@ -103,18 +103,6 @@ static int innerFind( const string& path, vector< ObjId >& ret)
         Shell* s = reinterpret_cast< Shell* >( ObjId().data() );
         start = s->getCwe();
     }
-
-    /*
-    if ( path[0] == '/' ) {
-    // separateString puts in a blank first entry if the first char
-    // is a separator.
-    separateString( path.substr( 1 ) , names, "/" );
-    } else {
-    Shell* s = reinterpret_cast< Shell* >( Id.eref().data() );
-    separateString( path, names, "/" );
-    start = s->getCwe();
-    }
-    */
     return wildcardRelativeFind( start, names, 0, ret );
 }
 
@@ -141,7 +129,6 @@ int simpleWildcardFind( const string& path, vector< ObjId >& ret)
     unsigned int n = ret.size();
     vector< string > wildcards;
     Shell::chopString( path, wildcards, ',' );
-    // separateString( path, wildcards, "," );
     vector< string >::iterator i;
     for ( i = wildcards.begin(); i != wildcards.end(); ++i )
         innerFind( *i, ret );
diff --git a/synapse/GraupnerBrunel2012CaPlasticitySynHandler.cpp b/synapse/GraupnerBrunel2012CaPlasticitySynHandler.cpp
index 7f78996d341b5d9a800efb90e23b0f0443deed0c..fe8a52a7326a9df5bc4a4e69caa5c1a1c232c2cc 100644
--- a/synapse/GraupnerBrunel2012CaPlasticitySynHandler.cpp
+++ b/synapse/GraupnerBrunel2012CaPlasticitySynHandler.cpp
@@ -269,8 +269,6 @@ void GraupnerBrunel2012CaPlasticitySynHandler::reinitSeed( void )
 
     if( 0 == seed_ )
         seed_ = rd_();
-
-    MOOSE_DEBUG( "Seed is set to " << seed_ );
     rng_.seed( seed_ );
 }
 
diff --git a/tests/python/fixXreacs.py b/tests/python/fixXreacs.py
deleted file mode 100644
index 7a68ed9b6c89a0bccf7e95e9b4108270c115b294..0000000000000000000000000000000000000000
--- a/tests/python/fixXreacs.py
+++ /dev/null
@@ -1,194 +0,0 @@
-# -*- coding: utf-8 -*-
-####################################################################
-# fixXreacs.py
-# The program is meant to take a model and reconfigure any cross-compartment
-# reactions so that they are split into portions on either side coupled
-# either by diffusion, or by a reaction-driven translocation process.
-#
-# Copyright (C) Upinder S. Bhalla       2018
-# This program is free software. It is licensed under the terms of
-# GPL version 3 or later at your discretion.
-# This program carries no warranty whatsoever.
-####################################################################
-
-
-import sys
-import moose
-
-msgSeparator = "_xMsg_"
-
-def findCompt( elm ):
-    elm = moose.element( elm )
-    pa = elm.parent
-    while pa.path != '/':
-        if moose.Neutral(pa).isA[ 'ChemCompt' ]:
-            return pa.path
-        pa = pa.parent
-    print( 'Error: No compartment parent found for ' + elm.path )
-    return '/'
-
-# http://stackoverflow.com/q/3844948/
-def checkEqual(lst):
-    return not lst or lst.count(lst[0]) == len(lst)
-
-def findXreacs( basepath, reacType ):
-    reacs = moose.wildcardFind( basepath + '/##[ISA=' + reacType + 'Base]' )
-    ret = []
-    for i in reacs:
-        reacc = findCompt( i )
-        subs = i.neighbors['subOut']
-        prds = i.neighbors['prdOut']
-        subc = [findCompt(j) for j in subs]
-        prdc = [findCompt(j) for j in prds]
-
-        enzc = []
-        if reacType == 'Enz':
-            enzc = [reacc]
-        if not checkEqual( subc + prdc + enzc ):
-            ret.append( [i, reacc, subs, subc, prds, prdc ])
-    return ret
-
-def removeEnzFromPool( pool ):
-    kids = moose.wildcardFind( pool.path + "/#" )
-    for i in kids:
-        if i.isA[ 'EnzBase' ]:
-            moose.delete( i )
-        elif i.isA[ 'Function' ]:
-            moose.delete( i )
-
-# If a pool is not in the same compt as reac, make a proxy in the reac
-# compt, connect it up, and disconnect the one in the old compt.
-def proxify( reac, reacc, direction, pool, poolc ):
-    reacc_elm = moose.element( reacc )
-    reac_elm = moose.element( reac )
-    # Preserve the rates which were set up for the x-compt reacn
-    #moose.showfield( reac )
-    dupname = pool.name + '_xfer_' + moose.element(poolc).name
-    #print "#############", pool, dupname, poolc
-    if moose.exists( reacc + '/' + dupname ):
-        duppool = moose.element( reacc + '/' + dupname )
-    else:
-        # This also deals with cases where the duppool is buffered.
-        duppool = moose.copy(pool, reacc_elm, dupname )
-    duppool.diffConst = 0   # diffusion only happens in original compt
-    removeEnzFromPool( duppool )
-    disconnectReactant( reac, pool, duppool )
-    moose.connect( reac, direction, duppool, 'reac' )
-    #moose.showfield( reac )
-    #moose.showmsg( reac )
-
-def enzProxify( enz, enzc, direction, pool, poolc ):
-    if enzc == poolc:
-        return
-    enze = moose.element( enz )
-    # kcat and k2 are indept of volume, just time^-1
-    km = enze.numKm
-    proxify( enz, enzc, direction, pool, poolc )
-    enze.numKm = km
-
-def reacProxify( reac, reacc, direction, pool, poolc ):
-    if reacc == poolc:
-        return
-    reac_elm = moose.element( reac )
-    kf = reac_elm.numKf
-    kb = reac_elm.numKb
-    proxify( reac, reacc, direction, pool, poolc )
-    reac_elm.numKf = kf
-    reac_elm.numKb = kb
-
-def identifyMsg( src, srcOut, dest ):
-    if src.isA[ 'ReacBase' ] or src.isA[ 'EnzBase' ]:
-        if srcOut == 'subOut':
-            return msgSeparator + src.path + ' sub ' + dest.path + ' reac'
-        if srcOut == 'prdOut':
-            return msgSeparator + src.path + ' prd ' + dest.path + ' reac'
-    return ''
-
-def disconnectReactant( reacOrEnz, reactant, duppool ):
-    outMsgs = reacOrEnz.msgOut
-    infoPath = duppool.path + '/info'
-    if moose.exists( infoPath ):
-        info = moose.element( infoPath )
-    else:
-        info = moose.Annotator( infoPath )
-
-    #moose.le( reactant )
-    notes = ""
-    #moose.showmsg( reacOrEnz )
-    for i in outMsgs:
-        #print "killing msg from {} to {}\nfor {} and {}".format( reacOrEnz.path, reactant.path, i.srcFieldsOnE1[0], i.srcFieldsOnE2[0] )
-        if i.e1 == reactant:
-            msgStr = identifyMsg( i.e2, i.e2.srcFieldsOnE2[0], i.e1 )
-            if len( msgStr ) > 0:
-                notes += msgStr
-                moose.delete( i )
-        elif i.e2 == reactant:
-            msgStr = identifyMsg( i.e1[0], i.srcFieldsOnE1[0], i.e2[0] )
-            if len( msgStr ) > 0:
-                notes += msgStr
-                moose.delete( i )
-    #print "MSGS to rebuild:", notes
-    info.notes += notes
-
-def fixXreacs( basepath ):
-    xr = findXreacs( basepath, 'Reac' )
-    xe = findXreacs( basepath, 'Enz' )
-
-    for i in (xr):
-        reac, reacc, subs, subc, prds, prdc = i
-        for j in range( len( subs )):
-            reacProxify( reac, reacc, 'sub', subs[j], subc[j] )
-        for j in range( len( prds )):
-            reacProxify( reac, reacc, 'prd', prds[j], prdc[j] )
-
-    for i in (xe):
-        reac, reacc, subs, subc, prds, prdc = i
-        for j in range( len( subs )):
-            enzProxify( reac, reacc, 'sub', subs[j], subc[j] )
-        for j in range( len( prds )):
-            enzProxify( reac, reacc, 'prd', prds[j], prdc[j] )
-
-#####################################################################
-
-def getOldRates( msgs ):
-    if len( msgs ) > 1 :
-        m1 = msgs[1].split( msgSeparator )[0]
-        elm = moose.element( m1.split( ' ' )[0] )
-        if elm.isA[ 'ReacBase' ]:
-            return [elm.numKf, elm.numKb]
-        elif elm.isA[ 'EnzBase' ]:
-            return [elm.numKm,]
-    print( "Warning: getOldRates did not have any messages" )
-    return [0,]
-
-def restoreOldRates( oldRates, msgs ):
-    #print oldRates, msgs
-    if len( msgs ) > 1 :
-        m1 = msgs[1].split( msgSeparator )[0]
-        elm = moose.element( m1.split( ' ' )[0] )
-        if elm.isA[ 'ReacBase' ]:
-            elm.numKf = oldRates[0]
-            elm.numKb = oldRates[1]
-        elif elm.isA[ 'enzBase' ]:
-            elm.numKm = oldRates[0]
-
-
-
-def restoreXreacs( basepath ):
-    proxyInfo = moose.wildcardFind( basepath + "/##/#_xfer_#/info" )
-    for i in proxyInfo:
-        msgs = i.notes.split( msgSeparator )
-        oldRates = getOldRates( msgs )
-        #print( "Deleting {}".format( i.parent.path ) )
-        #print msgs
-        moose.delete( i.parent )
-        for j in msgs:
-            if len( j ) > 0:
-                args = j.split( ' ' )
-                assert( len( args ) == 4 )
-                #moose.showfield( args[0] )
-                moose.connect( args[0], args[1], args[2], args[3] )
-                #print( "Reconnecting {}".format( args ) )
-                #moose.showfield( args[0] )
-        restoreOldRates( oldRates, msgs )
-
diff --git a/tests/python/testXchan1.py b/tests/python/testXchan1.py
index 1bcc130b6e694a3823ad9be4cef4b88630e81379..c62f1427307b54c771830e8b889a971cf9edf2da 100644
--- a/tests/python/testXchan1.py
+++ b/tests/python/testXchan1.py
@@ -31,7 +31,7 @@ import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
 print( '[INFO ] Using moose from %s, %s' % (moose.__file__, moose.version()) )
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXdiff1.py b/tests/python/testXdiff1.py
index bbf73e8715f99c14b74d6dc4b638a61798370213..71b309930cec00eb0430f3ef5d15d3890f221758 100644
--- a/tests/python/testXdiff1.py
+++ b/tests/python/testXdiff1.py
@@ -30,7 +30,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 diffConst = 1e-16
 
diff --git a/tests/python/testXenz1.py b/tests/python/testXenz1.py
index b359d44ebfc17abf0928ccff18e1e01964671ebf..80071aa53c89a6c37b3215f58dc2ed9458a103a5 100644
--- a/tests/python/testXenz1.py
+++ b/tests/python/testXenz1.py
@@ -20,7 +20,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 subInit = 0.002
 eInit = 0.001
diff --git a/tests/python/testXreacs2.py b/tests/python/testXreacs2.py
index 289c2b24670437c9197d05d7fdcf9a8b3f87264a..1d5bed338b9c3f5e18583eea84612207f4ea3907 100644
--- a/tests/python/testXreacs2.py
+++ b/tests/python/testXreacs2.py
@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
 mpl.rcParams['text.usetex'] = False
 import moose
 import numpy as np
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def countCrossings( plot, thresh ):
     vec = moose.element( plot ).vector
diff --git a/tests/python/testXreacs3.py b/tests/python/testXreacs3.py
index 4e5ef170d23a2acf315fff969eab69f63bc1f999..fa99656f10af9b8f7347bc3e3b21ff36d2f6aed8 100644
--- a/tests/python/testXreacs3.py
+++ b/tests/python/testXreacs3.py
@@ -25,7 +25,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs4.py b/tests/python/testXreacs4.py
index 4fd440076aede4ec9f14e60f8f7dbb8b8e0c8ee2..d618e05c252ec5e08d4c4ba89799172d3b0a76ef 100644
--- a/tests/python/testXreacs4.py
+++ b/tests/python/testXreacs4.py
@@ -14,7 +14,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs4a.py b/tests/python/testXreacs4a.py
index 2fe009e9e67759f3cebb95152b2da48052ebed8e..482c0dba721eb22b940c28adc7ce5753300a9a6b 100644
--- a/tests/python/testXreacs4a.py
+++ b/tests/python/testXreacs4a.py
@@ -14,7 +14,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs5.py b/tests/python/testXreacs5.py
index e46bc45906757f85b060b427a84856a57ed24244..7012dd96b4f9ba4dd7d6cc285c69c65ec0130e42 100644
--- a/tests/python/testXreacs5.py
+++ b/tests/python/testXreacs5.py
@@ -14,7 +14,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs5a.py b/tests/python/testXreacs5a.py
index 330419ea1cae499105e168c6324b2f9b318e2053..3d552f345c8763eef8297026f7622445740f58d9 100644
--- a/tests/python/testXreacs5a.py
+++ b/tests/python/testXreacs5a.py
@@ -14,7 +14,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs6.py b/tests/python/testXreacs6.py
index 7edb514d9185d6cf3aeba3f8d8280362801950da..75bd905bfe984ff4f8ce3f666075a8f78e948fd2 100644
--- a/tests/python/testXreacs6.py
+++ b/tests/python/testXreacs6.py
@@ -14,7 +14,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs7.py b/tests/python/testXreacs7.py
index b55de2686be921c2deb174c4149ba2091d545f56..73008321b1c7f3b98614df5b3cf241896ae75e2e 100644
--- a/tests/python/testXreacs7.py
+++ b/tests/python/testXreacs7.py
@@ -16,7 +16,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/testXreacs8.py b/tests/python/testXreacs8.py
index 58dc5cf418b5e170628e89dfec83af672398efe2..0ae0dba9dd9c6da23a6b9d241310a1e7e214de8b 100644
--- a/tests/python/testXreacs8.py
+++ b/tests/python/testXreacs8.py
@@ -25,7 +25,7 @@ import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.image as mpimg
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xchan1.py b/tests/python/test_Xchan1.py
index 35fc56f647a36ebebe6c33841eca6c9371bbd4cb..af555663817579d728465bb256055821fa1567a0 100644
--- a/tests/python/test_Xchan1.py
+++ b/tests/python/test_Xchan1.py
@@ -28,7 +28,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xdiff1.py b/tests/python/test_Xdiff1.py
index fc9df5d8879755578e9e69588681731a470408e4..6a7545c92a4cf97f1f90b5ffeafc94684b1fbf1f 100644
--- a/tests/python/test_Xdiff1.py
+++ b/tests/python/test_Xdiff1.py
@@ -29,7 +29,7 @@ import math
 import numpy as np
 import moose
 print( '[INFO] Using moose from %s, %s' % (moose.__file__, moose.version()) )
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 diffConst = 1e-16
 
diff --git a/tests/python/test_Xenz1.py b/tests/python/test_Xenz1.py
index c7463ad47aa9f6d77484af09bdd7f46fbea5fd29..13b7d4b85f36b9bb53121c25df11e99430724e3f 100644
--- a/tests/python/test_Xenz1.py
+++ b/tests/python/test_Xenz1.py
@@ -18,7 +18,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 subInit = 0.002
 eInit = 0.001
diff --git a/tests/python/test_Xreacs2.py b/tests/python/test_Xreacs2.py
index 1b1e73026b1c48c5049ac2bd54187c5d423ab1ee..4089501cc4b8fcfbc27a8484ae5b2d9e7f6be87a 100644
--- a/tests/python/test_Xreacs2.py
+++ b/tests/python/test_Xreacs2.py
@@ -3,7 +3,7 @@ import os
 import sys
 import moose
 import numpy as np
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def countCrossings( plot, thresh ):
     vec = moose.element( plot ).vector
diff --git a/tests/python/test_Xreacs3.py b/tests/python/test_Xreacs3.py
index 53cd7600b05a55a31d60321fed6891baf3b9e3bf..889e0b1cfbe9b21a3ed40d25f55a07b2123a931d 100644
--- a/tests/python/test_Xreacs3.py
+++ b/tests/python/test_Xreacs3.py
@@ -23,7 +23,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs4.py b/tests/python/test_Xreacs4.py
index c655e4e5fe9727ed9e055887c006768924e27e47..d96497b9e89eb86b47f4623c333c7d2b50f77f16 100644
--- a/tests/python/test_Xreacs4.py
+++ b/tests/python/test_Xreacs4.py
@@ -12,7 +12,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs4a.py b/tests/python/test_Xreacs4a.py
index 73c6d54746c88d36238904116547f73969eed6b5..ffad55b395a8a8516ea7618c00b43ab00a8ade44 100644
--- a/tests/python/test_Xreacs4a.py
+++ b/tests/python/test_Xreacs4a.py
@@ -12,7 +12,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs5.py b/tests/python/test_Xreacs5.py
index 4dde2a47f1b673fbe9065d0f81fff2493e08a195..60acd3cfe05416668c7570a7fd51c579b9779f89 100644
--- a/tests/python/test_Xreacs5.py
+++ b/tests/python/test_Xreacs5.py
@@ -12,7 +12,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
@@ -91,8 +91,10 @@ def main( standalone = False ):
     moose.reinit()
     moose.start( runtime )
 
-    assert( almostEq( 2.0 * moose.element( 'model/compartment/s' ).conc,
-        moose.element( '/model/endo/s' ).conc ) )
+    e1 = moose.element( 'model/compartment/s' )
+    e2 = moose.element( 'model/endo/s' )
+    assert almostEq(2.0 * e1.conc, e2.conc), \
+            "Expected %g, Got %g" % (e1.conc, e2.conc )
 
     moose.delete( '/model' )
 
diff --git a/tests/python/test_Xreacs5a.py b/tests/python/test_Xreacs5a.py
index 126f918238b6019a65ca0f4052aadb8f1b258be3..09a2c17e530d99369a83a5ddbe579e3d4bc6879b 100644
--- a/tests/python/test_Xreacs5a.py
+++ b/tests/python/test_Xreacs5a.py
@@ -12,7 +12,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs6.py b/tests/python/test_Xreacs6.py
index 35f21c5be50c28cc7593795b9a0645020c9ff1ed..06695267bf2af890c2088921fec97bf8739a6cc4 100644
--- a/tests/python/test_Xreacs6.py
+++ b/tests/python/test_Xreacs6.py
@@ -12,7 +12,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs7.py b/tests/python/test_Xreacs7.py
index 913a7a1cc791ac674967bc9360f5f5cdd083afe7..5df168bcc617dfc983070aa3c008559c15a1084c 100644
--- a/tests/python/test_Xreacs7.py
+++ b/tests/python/test_Xreacs7.py
@@ -14,7 +14,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_Xreacs8.py b/tests/python/test_Xreacs8.py
index 15bb0f01a4a95687085d7eb3f39729d4207b3b3a..d2ef6de35646f3888f7f598f3aa321adc553ff8c 100644
--- a/tests/python/test_Xreacs8.py
+++ b/tests/python/test_Xreacs8.py
@@ -23,7 +23,7 @@
 import math
 import numpy as np
 import moose
-import fixXreacs
+import moose.fixXreacs as fixXreacs
 
 def makeModel():
     # create container for model
diff --git a/tests/python/test_cylinder_diffusion_gsolve+dsolve.py b/tests/python/test_cylinder_diffusion_gsolve+dsolve.py
new file mode 100644
index 0000000000000000000000000000000000000000..db3dd773440c1b4d28a15a7047c19de5ab273009
--- /dev/null
+++ b/tests/python/test_cylinder_diffusion_gsolve+dsolve.py
@@ -0,0 +1,146 @@
+#########################################################################
+## This program is part of 'MOOSE', the
+## Messaging Object Oriented Simulation Environment.
+##           Copyright (C) 2014 Upinder S. Bhalla. and NCBS
+## It is made available under the terms of the
+## GNU Lesser General Public License version 2.1
+## See the file COPYING.LIB for the full notice.
+#########################################################################
+
+
+import sys
+import math
+import numpy as np
+import moose
+print('[INFO] Using moose from %s' % moose.__file__ )
+import os
+
+moose.seed( 1 )
+
+concA = 0.005 # millimolar
+def makeModel():
+    # create container for model
+    r0 = 2e-6        # m
+    r1 = 1e-6        # m
+    num = 100
+    diffLength = 1e-6 # m
+    L = num * diffLength        # m
+    diffConst = 10e-12
+    #motorRate = 1e-6
+    #diffConst = 0
+    motorRate = 0
+
+    model = moose.Neutral( 'model' )
+    compartment = moose.CylMesh( '/model/compartment' )
+    compartment.r0 = r0
+    compartment.r1 = r1
+    compartment.x0 = 0
+    compartment.x1 = L
+    compartment.diffLength = diffLength
+    assert( compartment.numDiffCompts == num )
+
+    # create molecules and reactions
+    a = moose.Pool( '/model/compartment/a' )
+    b = moose.Pool( '/model/compartment/b' )
+    c = moose.Pool( '/model/compartment/c' )
+    d = moose.Pool( '/model/compartment/d' )
+    r1 = moose.Reac( '/model/compartment/r1' )
+    moose.connect( r1, 'sub', b, 'reac' )
+    moose.connect( r1, 'sub', d, 'reac' )
+    moose.connect( r1, 'prd', c, 'reac' )
+    r1.Kf = 1000.0 # 1/(mM.sec)
+    r1.Kb = 1 # 1/sec
+
+    # Assign parameters
+    a.diffConst = diffConst
+    b.diffConst = diffConst / 2.0
+    b.motorConst = motorRate
+    c.diffConst = diffConst
+    d.diffConst = diffConst
+
+    # Make solvers
+    ksolve = moose.Gsolve( '/model/compartment/ksolve' )
+    dsolve = moose.Dsolve( '/model/compartment/dsolve' )
+    stoich = moose.Stoich( '/model/compartment/stoich' )
+    stoich.compartment = compartment
+    stoich.ksolve = ksolve
+    stoich.dsolve = dsolve
+    stoich.path = "/model/compartment/##"
+    assert( dsolve.numPools == 4 )
+    a.vec.concInit = concA
+    b.vec.concInit = concA / 5.0
+    c.vec.concInit = concA
+    d.vec.concInit = concA / 5.0
+    for i in range( num ):
+        d.vec[i].concInit = concA * 2 * i / num
+
+def main():
+    """
+    This example illustrates how to set up a diffusion/transport model with
+    a simple reaction-diffusion system in a tapering cylinder:
+
+    | Molecule **a** diffuses with diffConst of 10e-12 m^2/s.
+    | Molecule **b** diffuses with diffConst of 5e-12 m^2/s.
+    | Molecule **b** also undergoes motor transport with a rate of 10e-6 m/s
+    |   Thus it 'piles up' at the end of the cylinder.
+    | Molecule **c** does not move: diffConst = 0.0
+    | Molecule **d** does not move: diffConst = 10.0e-12 but it is buffered.
+    |   Because it is buffered, it is treated as non-diffusing.
+
+    All molecules other than **d** start out only in the leftmost (first)
+    voxel, with a concentration of 1 mM. **d** is present throughout
+    at 0.2 mM, except in the last voxel, where it is at 1.0 mM.
+
+    The cylinder has a starting radius of 2 microns, and end radius of
+    1 micron. So when the molecule undergoing motor transport gets to the
+    narrower end, its concentration goes up.
+
+    There is a little reaction in all compartments: ``b + d <===> c``
+
+    As there is a high concentration of **d** in the last compartment,
+    when the molecule **b** reaches the end of the cylinder, the reaction
+    produces lots of **c**.
+
+    Note that molecule **a** does not participate in this reaction.
+
+    The concentrations of all molecules are displayed in an animation.
+    """
+    runtime = 20.0
+    diffdt = 0.005
+    plotdt = 0.1
+    makeModel()
+    # Set up clocks. The dsolver to know before assigning stoich
+    moose.setClock( 10, diffdt ) # 10 is the standard clock for Dsolve.
+    moose.setClock( 16, plotdt ) # 16 is the standard clock for Ksolve.
+
+    a = moose.element( '/model/compartment/a' )
+    b = moose.element( '/model/compartment/b' )
+    c = moose.element( '/model/compartment/c' )
+    d = moose.element( '/model/compartment/d' )
+
+    moose.reinit()
+    atot = sum( a.vec.n )
+    btot = sum( b.vec.n )
+    ctot = sum( c.vec.n )
+    dtot = sum( d.vec.n )
+    for t in np.arange( 0, runtime, plotdt ):
+        moose.start( plotdt )
+
+    atot2 = sum( a.vec.n )
+    btot2 = sum( b.vec.n )
+    ctot2 = sum( c.vec.n )
+    dtot2 = sum( d.vec.n )
+
+    msg = 'Ratio of initial to final total numbers of '
+    got = np.array((atot2/atot, btot2/btot, ctot2/ctot, dtot2/dtot))
+    msg += 'a=%f b=%f, c=%f, d=%f' % (tuple(got))
+    print(msg)
+    print('Initial to final (b+c)=%f' % (float(btot2 + ctot2) / (btot + ctot )))
+    expected = np.array((1.00003087, 1.39036644, 0.92191184, 1.11427514))
+    error = got - expected
+    rerror = np.abs( error ) / expected
+    assert np.allclose(got, expected, atol=1e-3), "Got %s, expected %s" % (got, expected)
+
+# Run the 'main' if this script is executed standalone.
+if __name__ == '__main__':
+    main()
diff --git a/tests/python/test_gsolve_parallel.py b/tests/python/test_gsolve_parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7887ce853fa66ef033565d9f46272bedb1189fd
--- /dev/null
+++ b/tests/python/test_gsolve_parallel.py
@@ -0,0 +1,83 @@
+import numpy as np
+import moose
+print( '[INFO] Using moose from %s' % moose.__file__ )
+import time
+moose.seed( 10 )
+
+def main( nT ):
+    """
+    This example implements a reaction-diffusion like system which is
+    bistable and propagates losslessly. It is based on the NEURON example 
+    rxdrun.py, but incorporates more compartments and runs for a longer time.
+    The system is implemented in a function rather than as a proper system
+    of chemical reactions. Please see rxdReacDiffusion.py for a variant that 
+    uses a reaction plus a function object to control its rates.
+    """
+    print( 'Using %d threads' % nT )
+
+    dt = 0.1
+
+    # define the geometry
+    compt = moose.CylMesh( '/cylinder' )
+    compt.r0 = compt.r1 = 100e-9
+    compt.x1 = 200e-9
+    compt.diffLength = 0.2e-9
+    assert( compt.numDiffCompts == compt.x1/compt.diffLength )
+
+    #define the molecule. Its geometry is defined by its parent volume, cylinder
+    c = moose.Pool( '/cylinder/pool' )
+    c.diffConst = 1e-13 # define diffusion constant
+
+
+    # Here we set up a function calculation
+    func = moose.Function( '/cylinder/pool/func' )
+    func.expr = "(-x0 * (30e-9 - x0) * (100e-9 - x0))*0.0001"
+    func.x.num = 1 #specify number of input variables.
+
+    #Connect the molecules to the func
+    moose.connect( c, 'nOut', func.x[0], 'input' )
+    #Connect the function to the pool
+    moose.connect( func, 'valueOut', c, 'increment' )
+
+    #Set up solvers
+    ksolve = moose.Gsolve( '/cylinder/Gsolve' )
+    try:
+        ksolve.numThreads = nT
+    except Exception as e:
+        print( 'OLD MOOSE. Does not support multithreading' )
+    dsolve = moose.Dsolve( '/cylinder/dsolve' )
+    stoich = moose.Stoich( '/cylinder/stoich' )
+    stoich.compartment = compt
+    stoich.ksolve = ksolve
+    stoich.dsolve = dsolve
+    stoich.path = '/cylinder/##'
+
+    #initialize
+    x = np.arange( 0, compt.x1, compt.diffLength )
+    c.vec.nInit = [ 1000.0 for q in x ]
+
+    # Run and plot it.
+    moose.reinit()
+    updateDt = 50
+    runtime = updateDt * 10
+    t1 = time.time()
+    res = []
+    for t in range( 0, runtime-1, updateDt ):
+        moose.start( updateDt )
+        y = c.vec.n
+        res.append( (np.mean(y), np.std(y)) )
+
+    expected = [(9.0, 0.0), (6.0, 0.0), (5.0, 0.0), (3.0, 0.0), (2.0, 0.0),
+        (2.0, 0.0), (2.0, 0.0), (1.0, 0.0), (1.0, 0.0), (1.0, 0.0)]
+    print(("Time = ", time.time() - t1))
+    print( res )
+    assert res == expected
+
+if __name__ == '__main__':
+    import sys
+    import multiprocessing
+    nT = int(multiprocessing.cpu_count() / 2)
+    if len(sys.argv) > 1:
+        nT = int(sys.argv[1])
+    main( nT )
+
diff --git a/tests/python/test_ksolve.py b/tests/python/test_ksolve.py
index f70d889d8a4c606d35583b3c53165d9239cca620..4edabc933e1395e9ec26ecb1643b8244df322597 100644
--- a/tests/python/test_ksolve.py
+++ b/tests/python/test_ksolve.py
@@ -32,6 +32,7 @@ ksolve = moose.Ksolve( '/compt/ksolve' )
 stoich = moose.Stoich( '/compt/stoich' )
 stoich.compartment = compt
 stoich.ksolve = ksolve
+ksolve.numThreads = 2
 stoich.path = '/compt/##'
 moose.reinit()
 print( '[INFO] Using method = %s' % ksolve.method )
diff --git a/tests/python/test_ksolve_parallel.py b/tests/python/test_ksolve_parallel.py
new file mode 100644
index 0000000000000000000000000000000000000000..72da77d78190533627fe7a142e94d817259aa9c9
--- /dev/null
+++ b/tests/python/test_ksolve_parallel.py
@@ -0,0 +1,105 @@
+import os
+import numpy as np
+import moose
+print( 'Using moose from %s' % moose.__file__ )
+import time
+os.environ['MOOSE_SHOW_PROFILING_INFO'] = '1'
+
+def main( nthreads = 1 ):
+    """
+    This example implements a reaction-diffusion like system which is
+    bistable and propagates losslessly. It is based on the NEURON example 
+    rxdrun.py, but incorporates more compartments and runs for a longer time.
+    The system is implemented as a hybrid of a reaction and a function which
+    sets its rates. Please see rxdFuncDiffusion.py for a variant that uses
+    just a function object to set up the system.
+    """
+
+    dt = 0.1
+
+    # define the geometry
+    compt = moose.CylMesh( '/cylinder' )
+    compt.r0 = compt.r1 = 1
+    #  compt.diffLength = 1e-6
+    compt.x1 = 1e-2
+    assert compt.numDiffCompts == int(compt.x1/compt.diffLength), ( 
+            compt.numDiffCompts, compt.x1 / compt.diffLength )
+    print( 'No of compartment %d' % compt.numDiffCompts )
+
+    #define the molecule. Its geometry is defined by its parent volume, cylinder
+    c = moose.Pool( '/cylinder/pool' )
+    c.diffConst = 1 # define diffusion constant
+    # There is an implicit reaction substrate/product. MOOSE makes it explicit.
+    buf = moose.BufPool( '/cylinder/buf' )
+    buf.nInit = 1
+
+    # The reaction is something entirely peculiar, not a chemical thing.
+    reaction = moose.Reac( '/cylinder/reac' )
+    reaction.Kb = 0
+
+    # so here we set up a function calculation to do the same thing.
+    func = moose.Function( '/cylinder/reac/func' )
+    func.expr = "(1 - x0) * (0.3 - x0)"
+    func.x.num = 1 #specify number of input variables.
+
+    #Connect the reaction to the pools
+    moose.connect( reaction, 'sub', c, 'reac' )
+    moose.connect( reaction, 'prd', buf, 'reac' )
+
+    #Connect the function to the reaction
+    moose.connect( func, 'valueOut', reaction, 'setNumKf' )
+
+    #Connect the molecules to the func
+    moose.connect( c, 'nOut', func.x[0], 'input' )
+
+    #Set up solvers
+    ksolve = moose.Ksolve( '/cylinder/ksolve' )
+    ksolve.numThreads = nthreads
+    dsolve = moose.Dsolve( '/cylinder/dsolve' )
+    stoich = moose.Stoich( '/cylinder/stoich' )
+    stoich.compartment = compt
+    stoich.ksolve = ksolve
+    stoich.dsolve = dsolve
+    stoich.path = '/cylinder/##'
+    for i in range( 10, 18 ):
+        moose.setClock( i, dt )
+
+    #initialize
+    x = np.arange( 0, compt.x1, compt.diffLength )
+    c.vec.nInit = [ (q < 0.2 * compt.x1) for q in x ]
+
+    expected = [ (0.2, 0.40000000000000013)
+            , (2.6704795776286974e-07, 1.2678976830753021e-17)
+            , (8.167639617309419e-14, 3.8777269301457245e-24)
+            , (2.498062905267963e-20, 1.1860363878961374e-30)
+            , (7.64029581501609e-27, 3.6273808003690943e-37)
+            ]
+
+    # Run and plot it.
+    moose.reinit()
+    updateDt = 50
+    runtime = updateDt * 4
+    #  plt = pylab.plot( x, c.vec.n, label='t = 0 ')
+    yvec = c.vec.n
+    u1, m1 = np.mean( yvec ), np.std( yvec )
+    print( u1, m1 )
+    assert np.isclose( (u1, m1), expected[0], atol=1e-5).all(), expected[0]
+    t1 = time.time()
+    for i, t in enumerate(range( 0, runtime-1, updateDt)):
+        moose.start( updateDt )
+        #  plt = pylab.plot( x, c.vec.n, label='t = '+str(t + updateDt) )
+        yvec = c.vec.n
+        u1, m1 = np.mean( yvec ), np.std( yvec )
+        print( u1, m1 )
+        np.isclose( (u1,m1), expected[i+1], atol=1e-5 ).all(), expected[i+1]
+    return time.time() - t1
+
+
+if __name__ == '__main__':
+    import multiprocessing
+    import sys
+    nT = int(multiprocessing.cpu_count()/2)
+    if len(sys.argv) > 1:
+        nT = int(sys.argv[1])
+    t2 = main( nT )
+    print( 'With threads=%d, Time=%g' % (nT, t2))
diff --git a/utility/print_function.hpp b/utility/print_function.hpp
index d3a9e8882e1b367fa00ca04d8d7922e73158e20c..4b984d7cd69a9aa88eae57ef99d32c67b60bb9fe 100644
--- a/utility/print_function.hpp
+++ b/utility/print_function.hpp
@@ -59,7 +59,7 @@ using namespace std;
  */
 /* ----------------------------------------------------------------------------*/
 #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-#ifdef NDEBUG
+#ifndef NDEBUG
 #define MOOSE_DEBUG( a ) { \
     stringstream ss; ss << a; \
     cout << "DEBUG: " << __FILENAME__ << ":" << __LINE__ << "| " << ss.str(); \