Merge development into master to do a release

.gitignore

@@ -62,3 +62,11 @@ simulations
 /sibernetic_NEURON/
 /CElegansNeuroML/
 /sib.env
+/configuration/worm_no_water_2017
+/test.sh
+/test2.sh
+/wcon/*.png
+/run_fw*.sh
+.vscode/*
+.settings/*
+.idea/*

.openworm.yml

@@ -3,23 +3,26 @@ shortDescription: "This is a C++/OpenCL implementation of the PCISPH algorithm s
 coordinator: [email protected]
 documentation: "https://openworm.github.io/sibernetic/"
 gitter: "http://gitter.im/openworm/sibernetic"
-inputs: 
-  - openworm/CElegansNeuroML
 keywords: 
   - simulation
   - physics
   - particles
   - worm body
 languages: 
+  - c++
   - python
 latest-release:
   - 0.0.3
 members: 
   - [email protected]
   - [email protected]
+inputs: 
+  - openworm/CElegansNeuroML
 outputs: 
   - openworm/CElegansNeuroML
+  - openworm/skeletonExtraction
 parent: 
   - openworm/OpenWorm
 children: 
   - openworm/sibernetic_NEURON
+  - openworm/sibernetic_config_gen

bin/win32/Release/main_sim.py → 20 cm long worm/main_sim.py

@@ -1,12 +1,14 @@
 import math
 import numpy as np
 
+"""
 import matplotlib.pyplot as plt
 from pylab import *
+"""
 
 muscle_row_count = 24
 
-time_per_step = 0.000005  #  s
+time_per_step = 0.000001  #  s
 
 quadrant0 = 'MDR'
 quadrant1 = 'MVR'
@@ -44,38 +46,70 @@ def parallel_waves(n=muscle_row_count, #26 for our first test?
                    step=0, 
                    phi=math.pi,
                    amplitude=1,
-                   velocity=0.0001):
-    """
-    Array of two travelling waves, second one starts
+				   #velocity=0.000008):
+                   velocity_s =0.000015*3.7*1.94/1.76, #swimming
+				   velocity_c =0.000015*0.72): #crawling // 0.9 // 0.65
+	"""
+	Array of two travelling waves, second one starts
     half way through the array
-    """
-
-    if n % 2 != 0:
-        raise NotImplementedError("Currently only supports even number of muscles!")
-
-    j = n/2
-
-    row_positions = np.linspace(0,1.5*2*math.pi,j)
-
-    wave_1 = (map(math.sin,(row_positions - velocity*step)))
-    wave_2 = (map(math.sin,(row_positions + (math.pi) - velocity*step)))
-
-    normalize_sine = lambda x : (x + 1)/2
-    wave_1 = map(normalize_sine, wave_1)
-    wave_2 = map(normalize_sine, wave_2)
-
-    double_wave_1 = []
-    double_wave_2 = []
-
-    for i in wave_1:
-        double_wave_1.append(i)
-        double_wave_1.append(i)
-
-    for i in wave_2:
-        double_wave_2.append(i)
-        double_wave_2.append(i)
-
-    return (double_wave_1,double_wave_2)
+	"""
+	j = n/2
+	max_muscle_force_coeff = 1.0
+
+	# "<" = first 6 seconds crawling, then swimming
+	# ">" = first 6 seconds swimming, then crawling
+	if (step>1200000): 
+		velocity = 14 * 0.000015*0.72#crawling
+		max_muscle_force_coeff = 1.0
+		row_positions = np.linspace(0,2.97*math.pi,j)		
+		wave_m = np.linspace(1,0.6,j) 		
+	else:
+		velocity = 14 * 0.000015*3.7#swimming
+		max_muscle_force_coeff = 0.575
+		row_positions = np.linspace(0,0.81*math.pi,j)
+		#wave_m = [0.8,0.7,0.8,0.93,1.0,1.0,1.0,1.0,0.93,0.8,0.6,0.4] 		
+		#wave_m = [0.8,0.7,0.8,0.93,1.0,1.0,1.0,1.0,0.93,0.8,0.65,0.5] 		
+		#wave_m = [0.8,0.7,0.8,0.93,1.0,1.0,1.0,0.93,0.8,0.6,0.4,0.2] 		
+		#wave_m = [0.81,0.90,0.97,1.00,0.99,0.95,0.88,0.78,0.65,0.50,0.33,0.15] 		
+		#wave_m = np.linspace(1,1,j) 		
+		wave_m = [0.81,0.90,0.97,1.00,0.99,0.95,0.88,0.78,0.65,0.53,0.40,0.25] #6
+		#wave_m = [0.81,0.90,0.97,1.00,0.99,0.95,0.90,0.83,0.75,0.65,0.55,0.45] 	#7	
+
+	if n % 2 != 0:
+		raise NotImplementedError("Currently only supports even number of muscles!")
+
+	wave_1 = (map(math.sin, (row_positions - velocity*step) ))
+	wave_2 = (map(math.sin, (row_positions - velocity*step + (math.pi)) ))
+
+	normalize_sine = lambda x : abs(x*(x>0))#(x + 1)/2
+	wave_1 = map(normalize_sine, wave_1)
+	wave_2 = map(normalize_sine, wave_2)
+
+	###### sinusoidal signal correction ##################################
+	#normalize_sine = lambda x : x*x
+	#wave_1 = map(normalize_sine, wave_1)
+	#wave_2 = map(normalize_sine, wave_2)
+
+	wave_1 = map(lambda x,y: max_muscle_force_coeff*x*y, wave_1, wave_m)
+	wave_2 = map(lambda x,y: max_muscle_force_coeff*x*y, wave_2, wave_m)
+	###### smooth start###################################################
+	if (step<(10000/14)):	
+		normalize_sine = lambda x : x*step/(10000/14)
+		wave_1 = map(normalize_sine, wave_1)
+		wave_2 = map(normalize_sine, wave_2)	
+	######################################################################
+
+	double_wave_1 = []
+	double_wave_2 = []
+
+	for i in wave_1:
+		double_wave_1.append(i)
+		double_wave_1.append(i)
+	for i in wave_2:
+		double_wave_2.append(i)
+		double_wave_2.append(i)
+
+	return (double_wave_1,double_wave_2)
 
 class MuscleSimulation():
 
@@ -86,6 +120,11 @@ def __init__(self,increment=1.0):
     def run(self,do_plot = True):
         self.contraction_array =  parallel_waves(step = self.step)
         self.step += self.increment
+        #if (self.step>1000000):
+        #    self.increment = -1.0
+        #else:
+		#    self.increment = self.increment
+
         return list(np.concatenate([self.contraction_array[0],
                                     self.contraction_array[1],
                                     self.contraction_array[1],