#28: More options for test case

Author: philippkraft

cmf/__init__.py

@@ -22,7 +22,7 @@
 from .stopwatch import StopWatch
 
 
-__version__ = '1.3.1b'
+__version__ = '1.3.1b.i28_numperf_reaches_tracer'
 
 from .cmf_core import connect_cells_with_flux as __ccwf
 

cmf/cmf_core.py

@@ -1509,7 +1509,6 @@ def __len__(self, *args, **kwargs):
         return _cmf_core.timeseries___len__(self, *args, **kwargs)
 
 
-
     def __repr__(self):
        return "cmf.timeseries(%s:%s:%s,count=%i)" % (self.begin,self.end,self.step,self.size())
 
@@ -1572,8 +1571,8 @@ def __rdiv__(self,other):
         return res
 
     def iter_time(self):
-        """Returns an iterator to iterate over each timestep
-        as_float if True, the timesteps will returned as floating point numbers representing the days after 1.1.0001 00:00
+        """
+        Returns an iterator to iterate over each timestep
         """
         for i in range(len(self)):
             yield self.begin + self.step * i
@@ -1607,7 +1606,6 @@ def __setstate__(self, data):
         self.__init__(begin, step, data['interpolationpower'])
         self.extend(data['values'])
 
-
     def to_pandas(self):
         """
         Returns the timeseries as a pandas Series object

cmf/cmf_core_src/cmf_wrap.cpp

@@ -3183,27 +3183,28 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
 #define SWIGTYPE_p_std__shared_ptrT_cmf__river__OpenWaterStorage_t swig_types[171]
 #define SWIGTYPE_p_std__shared_ptrT_cmf__river__Reach_t swig_types[172]
 #define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t swig_types[173]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__MacroPore_t swig_types[174]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__SoilLayer_t swig_types[175]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__SurfaceWater_t swig_types[176]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__aquifer_t swig_types[177]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__DirichletBoundary_t swig_types[178]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__NeumannBoundary_t swig_types[179]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__SoluteStorage_t swig_types[180]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__SystemBridge_t swig_types[181]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__WaterStorage_t swig_types[182]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_connection_t swig_types[183]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_integrator_t swig_types[184]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_node_t swig_types[185]
-#define SWIGTYPE_p_std__shared_ptrT_cmf__water__waterbalance_integrator_t swig_types[186]
-#define SWIGTYPE_p_std__shared_ptrT_std__shared_ptrT_cmf__atmosphere__ConstantRainSource_t_t swig_types[187]
-#define SWIGTYPE_p_std__shared_ptrT_std__shared_ptrT_cmf__atmosphere__RainfallStationReference_t_t swig_types[188]
-#define SWIGTYPE_p_std__string swig_types[189]
-#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__WaterStorage_t_t swig_types[190]
-#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__flux_connection_t_t__const_iterator swig_types[191]
-#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__flux_connection_t_t__iterator swig_types[192]
-static swig_type_info *swig_types[194];
-static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0};
+#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t swig_types[174]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__MacroPore_t swig_types[175]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__SoilLayer_t swig_types[176]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__SurfaceWater_t swig_types[177]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__upslope__aquifer_t swig_types[178]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__DirichletBoundary_t swig_types[179]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__NeumannBoundary_t swig_types[180]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__SoluteStorage_t swig_types[181]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__SystemBridge_t swig_types[182]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__WaterStorage_t swig_types[183]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_connection_t swig_types[184]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_integrator_t swig_types[185]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__flux_node_t swig_types[186]
+#define SWIGTYPE_p_std__shared_ptrT_cmf__water__waterbalance_integrator_t swig_types[187]
+#define SWIGTYPE_p_std__shared_ptrT_std__shared_ptrT_cmf__atmosphere__ConstantRainSource_t_t swig_types[188]
+#define SWIGTYPE_p_std__shared_ptrT_std__shared_ptrT_cmf__atmosphere__RainfallStationReference_t_t swig_types[189]
+#define SWIGTYPE_p_std__string swig_types[190]
+#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__WaterStorage_t_t swig_types[191]
+#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__flux_connection_t_t__const_iterator swig_types[192]
+#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_cmf__water__flux_connection_t_t__iterator swig_types[193]
+static swig_type_info *swig_types[195];
+static swig_module_info swig_module = {swig_types, 194, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -83069,6 +83070,7 @@ static swig_type_info _swigt__p_std__shared_ptrT_cmf__math__integratable_t = {"_
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__river__OpenWaterStorage_t = {"_p_std__shared_ptrT_cmf__river__OpenWaterStorage_t", "std::shared_ptr< cmf::river::OpenWaterStorage > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__river__Reach_t = {"_p_std__shared_ptrT_cmf__river__Reach_t", "std::shared_ptr< cmf::river::Reach > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t = {"_p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t", "std::shared_ptr< cmf::upslope::ET::ShuttleworthWallace > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t = {"_p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t", "std::shared_ptr< cmf::upslope::ET::aerodynamic_resistance > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__upslope__MacroPore_t = {"_p_std__shared_ptrT_cmf__upslope__MacroPore_t", "std::shared_ptr< cmf::upslope::MacroPore > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__upslope__SoilLayer_t = {"_p_std__shared_ptrT_cmf__upslope__SoilLayer_t", "cmf::upslope::SoilLayer::ptr *|std::shared_ptr< cmf::upslope::SoilLayer > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t = {"_p_std__shared_ptrT_cmf__upslope__SurfaceWater_t", "std::shared_ptr< cmf::upslope::SurfaceWater > *|cmf::upslope::surfacewater_ptr *", 0, 0, (void*)0, 0};
@@ -83264,6 +83266,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_std__shared_ptrT_cmf__river__OpenWaterStorage_t,
   &_swigt__p_std__shared_ptrT_cmf__river__Reach_t,
   &_swigt__p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t,
+  &_swigt__p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t,
   &_swigt__p_std__shared_ptrT_cmf__upslope__MacroPore_t,
   &_swigt__p_std__shared_ptrT_cmf__upslope__SoilLayer_t,
   &_swigt__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t,
@@ -83459,6 +83462,7 @@ static swig_cast_info _swigc__p_std__shared_ptrT_cmf__math__integratable_t[] = {
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__river__OpenWaterStorage_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__river__OpenWaterStorage_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t, _p_std__shared_ptrT_cmf__upslope__SurfaceWater_tTo_p_std__shared_ptrT_cmf__river__OpenWaterStorage_t, 0, 0},  {&_swigt__p_std__shared_ptrT_cmf__river__Reach_t, _p_std__shared_ptrT_cmf__river__Reach_tTo_p_std__shared_ptrT_cmf__river__OpenWaterStorage_t, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__river__Reach_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__river__Reach_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__upslope__MacroPore_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__upslope__MacroPore_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__upslope__SoilLayer_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__upslope__SoilLayer_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t[] = {  {&_swigt__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t, 0, 0, 0},{0, 0, 0, 0}};
@@ -83654,6 +83658,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_std__shared_ptrT_cmf__river__OpenWaterStorage_t,
   _swigc__p_std__shared_ptrT_cmf__river__Reach_t,
   _swigc__p_std__shared_ptrT_cmf__upslope__ET__ShuttleworthWallace_t,
+  _swigc__p_std__shared_ptrT_cmf__upslope__ET__aerodynamic_resistance_t,
   _swigc__p_std__shared_ptrT_cmf__upslope__MacroPore_t,
   _swigc__p_std__shared_ptrT_cmf__upslope__SoilLayer_t,
   _swigc__p_std__shared_ptrT_cmf__upslope__SurfaceWater_t,

demo/runtime_river_substance.py

@@ -7,15 +7,15 @@
 import timeit
 import argparse
 
-def test(d, withsubstance=False, threads=1):
+def test(args):
     """
     creates a set of river segments with and without substance. the solver
     can be set up with a varying nu,ber of threads as well as separated for
     water and substance fluxes.
     """
-    cmf.set_parallel_threads(threads)
-    
-    if withsubstance:
+    cmf.set_parallel_threads(args.threads)
+    d = args.segment_length
+    if args.tracer:
         p = cmf.project("X")
         X, = p.solutes
     else:
@@ -24,24 +24,41 @@ def test(d, withsubstance=False, threads=1):
     # Create a triangular reach crosssection for 10 m long reaches with a bankslope of 2
     shape = cmf.TriangularReach(10.,2.)
     # Create a 1km river with 100 reaches along the x axis and a constant slope of 1%
-    reaches = [p.NewReach(i,0,i*.01,shape,False) for i in range(0,1000,d)]
-    for r_lower, r_upper in zip(reaches[:-1],reaches[1:]):
+    reaches = [p.NewReach(i, 0, i*.01, shape, False) for i in range(0, 1000, d)]
+    if args.adsorption:
+        for r in reaches:
+            r[X].set_adsorption(cmf.LinearAdsorption(1e-2, 1e-2))
+    for r_lower, r_upper in zip(reaches[:-1], reaches[1:]):
         r_upper.set_downstream(r_lower)
     for i, r in enumerate(reaches):
         r.Name = 'R{}'.format(i+1)
 
     # Initial condition: 10 cmf of water in the most upper reach
     for r in reaches:
         r.depth=0.1
-        if withsubstance:
+        if args.tracer:
             r.conc(X, 1.0)
-
-            # Template for the water solver
-    wsolver = cmf.CVodeIntegrator(1e-9)
-    # Template for the solute solver
-    ssolver = cmf.HeunIntegrator()
-    # Creating the SWI, the storage objects of the project are internally assigned to the correct solver
-    solver = cmf.SoluteWaterIntegrator(p.solutes, wsolver, ssolver, p)
+    if args.solver and args.solver != 'c':
+        # Template for the water solver
+        wsolver = cmf.CVodeIntegrator(1e-9)
+        # Template for the solute solver
+        if args.solver == 'ch':
+            ssolver = cmf.HeunIntegrator()
+            print('Heun')
+        elif args.solver == 'ce':
+            ssolver = cmf.ExplicitEuler_fixed()
+            print('Explicit Euler')
+        elif args.solver == 'ci':
+            ssolver = cmf.ImplicitEuler(1e-9)
+            print('Implicit Euler')
+        else:
+            ssolver = cmf.CVodeIntegrator(1e-9)
+            print('CVode')
+        # Creating the SWI, the storage objects of the project are internally assigned to the correct solver
+        solver = cmf.SoluteWaterIntegrator(p.solutes, wsolver, ssolver, p)
+    else:
+        solver = cmf.CVodeIntegrator(p, 1e-9)
+        print('Joint CVode solver')
     # solver = cmf.CVodeIntegrator(p,1e-6)
     assert solver.size() == len(reaches) * (len(p.solutes) + 1)
 
@@ -50,13 +67,11 @@ def test(d, withsubstance=False, threads=1):
 
     start = time.time()
     c = Counter()
-    for t in solver.run(datetime(2012,1,1),datetime(2012,1,2), cmf.min * 10):
+    for t in solver.run(datetime(2012, 1, 1),datetime(2012, 1, 2), cmf.min):
         # c.update([solver.get_error().argmax()])
-        print('{:10.3} sec, {}, {}, {}, {:0.4g}'
-              .format(time.time()-start, t,
-              solver.dt,0,0 #solver.get_rhsevals(),
-              #np.abs(solver.get_error()).max()
-              ))
+        print('{:10.3} sec, {}, {}, {:0.4g}'
+              .format(time.time()-start, t, solver.dt,
+                      reaches[1][X].conc if X else 0))
         depth.append([r.depth for r in reaches])
 
     time_elapsed = time.time() - start 
@@ -79,12 +94,17 @@ def test(d, withsubstance=False, threads=1):
 
     parser = argparse.ArgumentParser()
     parser.add_argument('segment_length', type=int, help='Length of river segments in m')
-    parser.add_argument('-X','--tracer', action='store_true', help='Use -x to create a tracer')
-    parser.add_argument('-t','--threads', action='store', default=1, type=int, help='Number of threads')
+    parser.add_argument('-X', '--tracer', action='store_true', help='Use -x to create a tracer')
+    parser.add_argument('-t', '--threads', action='store', default=1, type=int, help='Number of threads')
+    parser.add_argument('-s', '--solver', choices=['c', 'cc', 'ch', 'ci', 'ce'],
+                        help='Sets the solver:  c: Joint CVode, cc: CVode for water and solute, ' + ' ' * 18 +
+                             'ch: CVode / Heun, ci: CVode/Implicit, ce: CVode/Explicit')
+    parser.add_argument('-e', '--errortolerance', type=float, default=1e-9)
+    parser.add_argument('-a', '--adsorption', action='store_true', help='Use -a to use linear adsorption')
     args = parser.parse_args()
-    
+    print('cmf', cmf.__version__)
     def run():
-        return test(args.segment_length, args.tracer, args.threads)
+        return test(args)
 
     t = timeit.Timer(run)