def plotQuantity(self, identifier, param_values, n, bars=True): ''' Plot a simulated quantity vs its data points using Tellurium.''' i = self.measured_quantities.index(identifier) reference_quantity = self.reference_quantities[:, i] r = RoadRunner(self.sbml) if param_values is not None: self._setParameterVector(param_values, self.param_list, r) s = r.simulate(0, float(self.reference_time[-1]), n, ['time', identifier]) simulated_quantity = s[:, 1] residuals = simulated_quantity - reference_quantity # relative residuals # print('avg relative deviation for ', identifier, ': {:.1f}'.format(mean(abs(residuals/reference_quantity))*100.), '%') # residuals normalized to overall mean print( 'avg relative deviation for ', identifier, ': {:.1f}'.format( mean(abs(residuals)) / mean(abs(reference_quantity)) * 100.), '%') r.reset() s = r.simulate(0, float(self.reference_time[-1]), 1000, ['time', identifier]) import tellurium as te te.plot(self.reference_time, reference_quantity, scatter=True, name=identifier + ' data', show=False, error_y_pos=maximum(residuals, 0), error_y_neg=-minimum(residuals, 0)) te.plot(s[:, 0], s[:, 1], name=identifier + ' sim')
def plotQuantity(self, quantity, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import name_to_id_map, conc_indices quantity_id = name_to_id_map[quantity] iq = self.measured_quantities.index(quantity_id) reference_data = array(self.scaled_data[:, iq]) r = RoadRunner(self.sbml) self._setParameterVector(param_values, self.param_list, r) r.reset() t_now = 0. residuals = zeros((len(self.time_values), )) residuals[0] = r[quantity_id] - reference_data[0] for it_next in range(1, len(self.time_values)): self._setParameterVector(param_values, self.param_list, r) r.simulate(t_now, self.time_values[it_next], 100) t_now = self.time_values[it_next] residuals[it_next] = r[quantity_id] - reference_data[it_next] r.reset() s = r.simulate(0, float(self.time_values[-1]), 1000, ['time', quantity_id]) # print(quantity, sqrt(mean(residuals**2))/self.reference_value_means[iq]) import tellurium as te te.plot(self.time_values, reference_data, scatter=True, name=quantity + ' data', show=False, error_y_pos=maximum(residuals, 0), error_y_neg=-minimum(residuals, 0)) te.plot(s[:, 0], s[:, 1], name=quantity + ' sim')
def plotQuantity(self, quantity_id, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import measured_quantity_ids, measured_quantity_id_to_name_map from data import t1, t2, time_end, n1, n2, n3 quantity_name = measured_quantity_id_to_name_map.get(quantity_id,quantity_id) iq = measured_quantity_ids.index(quantity_id) reference_data = array(self.reference_values[:,iq]) r = RoadRunner(self.sbml) r.reset() r.resetAll() r.resetToOrigin() self._setParameterVector(param_values, self.param_list, r) # r.oneStep(0., 10) # print('plotQuantity OAA\' = {}'.format(r["OAA'"])) s1 = r.simulate(0., t1, n1, ['time', quantity_id]) s2 = r.simulate(t1, t2, n2, ['time', quantity_id]) # print(quantity_id) # if quantity_id == 'GLC': # print('BM before {}'.format(r['[BM]'])) # print(iq) # print(reference_data) s3 = r.simulate(t2, time_end, n3, ['time', quantity_id]) sim = vstack(( s1, s2, s3, )) assert sim.shape[0] == reference_data.shape[0] residuals = sim[:,1] - reference_data r.reset() r.resetAll() r.resetToOrigin() self._setParameterVector(param_values, self.param_list, r) # self._setParameterVector(param_values, self.param_list, r) s = r.simulate(0,time_end,1000,['time',quantity_id]) import tellurium as te te.plot(sim[:,0], reference_data, scatter=True, name=quantity_name+' data', show=False, title=quantity_name, error_y_pos=maximum(residuals,0), error_y_neg=-minimum(residuals,0)) te.plot(s[:,0], s[:,1], name=quantity_name+' sim')
def plotQuantity(self, quantity_id, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import time_values, measured_quantity_ids, measured_quantity_id_to_name_map quantity_name = measured_quantity_id_to_name_map[quantity_id] iq = measured_quantity_ids.index(quantity_id) reference_data = array(self.reference_values[:, iq]) r = RoadRunner(self.sbml) self._setParameterVector(param_values, self.param_list, r) r.reset() # r.resetAll() # r.resetToOrigin() # r.integrator = 'euler' # r.integrator = 'rk4' # r.integrator.subdivision_steps = 1000 # r.integrator.absolute_tolerance = 1e-10 # r.integrator.relative_tolerance = 1e-4 # r.integrator.initial_time_step = 0.001 # r.integrator.minimum_time_step = 0.0001 # r.integrator.maximum_time_step = 0.1 # print(r.integrator) sim = r.simulate(0., 119., 120, ['time', quantity_id]) assert sim.shape[0] == reference_data.shape[0] residuals = sim[:, 1] - reference_data r.reset() # r.resetAll() # r.resetToOrigin() s = r.simulate(0, float(time_values[-1]), 121, ['time', quantity_id]) # print('mse for {}: '.format(quantity_name), sqrt(mean((residuals**2)/(self.reference_norms[:,iq]**2)))) import tellurium as te te.plot(time_values, reference_data, scatter=True, name=quantity_name + ' data', show=False, title=quantity_name, error_y_pos=maximum(residuals, 0), error_y_neg=-minimum(residuals, 0)) te.plot(s[:, 0], s[:, 1], name=quantity_name + ' sim')
import numpy as np from roadrunner import RoadRunner from timeit import default_timer r = RoadRunner('WolfGlycolysis.xml') #orders = 5 #for multiplier in np.logspace(0,orders,orders+1): ##print('multiplier = {}'.format(multiplier)) #t1 = default_timer() #r.reset() #r.simulate(0,2*int(multiplier),1000*int(multiplier)) #t2 = default_timer() #print('{} simulation, duration = {}'.format(2*int(multiplier), t2-t1)) ##r.plot() # COPASI 4:20 t1 = default_timer() r.reset() r.simulate(0,20000,200000) t2 = default_timer()
class B3Problem(TimecourseSimBiopredyn): ''' Class that performs a timecourse simulation and evaluates the objective function for b1.''' def __init__(self, sbml): self.sbml = sbml self.r = RoadRunner(sbml) from data import measured_quantity_ids, exp_data self.measured_quantity_ids = measured_quantity_ids self.reference_values = exp_data self.reference_value_means_squared = mean(self.reference_values, axis=0)**2 from params import new_param_ids as param_ids self.param_list = param_ids self.penalty_scale = 1. def evaluate(self, x): # type: (array) -> SupportsFloat """ Evaluate and return the objective function. """ from interruptingcow import timeout # from data import time_end, n_points from data import t1, t2, time_end, n1, n2, n3 self.reset() self.r.resetAll() self.r.resetToOrigin() self.setParameterVector(x) self.r.reset() def worker(): # sim = array(self.r.simulate(0., time_end, n_points, self.measured_quantity_ids)) s1 = self.r.simulate(0., t1, n1, self.measured_quantity_ids) s2 = self.r.simulate(t1, t2, n2, self.measured_quantity_ids) s3 = self.r.simulate(t2, time_end, n3, self.measured_quantity_ids) sim = vstack(( s1, s2, s3, )) residuals = sim-self.reference_values normalized_mse_per_quantity = mean(residuals**2,axis=0)/self.reference_value_means_squared # from pprint import pprint # print('residuals:') # pprint({id: value for id,value in zip(self.measured_quantity_ids, sqrt(normalized_mse_per_quantity))}) return sqrt(mean(normalized_mse_per_quantity)) try: with timeout(10, StalledSimulation): return worker() except (RuntimeError, StalledSimulation): # if convergence fails, use a penalty score return 1e9*self.penalty_scale def plotQuantity(self, quantity_id, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import measured_quantity_ids, measured_quantity_id_to_name_map from data import t1, t2, time_end, n1, n2, n3 quantity_name = measured_quantity_id_to_name_map.get(quantity_id,quantity_id) iq = measured_quantity_ids.index(quantity_id) reference_data = array(self.reference_values[:,iq]) r = RoadRunner(self.sbml) r.reset() r.resetAll() r.resetToOrigin() self._setParameterVector(param_values, self.param_list, r) # r.oneStep(0., 10) # print('plotQuantity OAA\' = {}'.format(r["OAA'"])) s1 = r.simulate(0., t1, n1, ['time', quantity_id]) s2 = r.simulate(t1, t2, n2, ['time', quantity_id]) # print(quantity_id) # if quantity_id == 'GLC': # print('BM before {}'.format(r['[BM]'])) # print(iq) # print(reference_data) s3 = r.simulate(t2, time_end, n3, ['time', quantity_id]) sim = vstack(( s1, s2, s3, )) assert sim.shape[0] == reference_data.shape[0] residuals = sim[:,1] - reference_data r.reset() r.resetAll() r.resetToOrigin() self._setParameterVector(param_values, self.param_list, r) # self._setParameterVector(param_values, self.param_list, r) s = r.simulate(0,time_end,1000,['time',quantity_id]) import tellurium as te te.plot(sim[:,0], reference_data, scatter=True, name=quantity_name+' data', show=False, title=quantity_name, error_y_pos=maximum(residuals,0), error_y_neg=-minimum(residuals,0)) te.plot(s[:,0], s[:,1], name=quantity_name+' sim') # print('deviation for {}: {}/{} = {}'.format(quantity_id, sqrt(mean(residuals**2)), sqrt(self.reference_value_means_squared[iq]), sqrt(mean(residuals**2)/self.reference_value_means_squared[iq]))) def getParameterValue(self,param_index): from params import param_index_to_name_map try: return self.r[param_index_to_name_map[param_index]] except KeyError: raise KeyError('No such parameter for index {}, must be 0-1758 inclusive'.format(param_index))
class B4Problem(TimecourseSimBiopredyn): ''' Class that performs a timecourse simulation and calculates the residuals for b4.''' def __init__(self, sbml): ''' Constructor. :param measured_quantities: A list of the measured quantities. :param scaled_data: The scaled reference data. :param scaled_error: The scaled reference error. ''' from params import param_ids from data import time_values, conc_ids, scaled_data, scaled_error self.sbml = sbml self.r = RoadRunner(sbml) self.r.selections = ['time'] + conc_ids self.time_values = time_values assert self.time_values[0] == 0. self.measured_quantities = conc_ids self.param_list = param_ids self.reference_values = scaled_data self.reference_value_means = mean(self.reference_values, axis=0) self.scaled_data = scaled_data self.scaled_error = scaled_error self.penalty_scale = 1. def evaluate_original(self, x): # type: (array) -> SupportsFloat """ Evaluate the objective function and return the result. Identical to original biopredynbench evaluation, i.e. divides by scaled error. Difficult to compare across models. """ from interruptingcow import timeout self.reset() self.setParameterVector(x) self.r.reset() def worker(): t_now = 0. scaled_residuals = zeros( (len(self.time_values), len(self.measured_quantities))) for it_next in range(1, len(self.time_values)): t_now = self.r.simulate(t_now, self.time_values[it_next], 100) t_now = self.time_values[it_next] if self.divergent(): return 1e9 * self.penalty_scale for iq, q in enumerate(self.measured_quantities): scaled_residuals[ it_next - 1, iq] = (self.r[q] - self.scaled_data[it_next - 1, iq] ) / self.scaled_error[it_next - 1, iq] return sqrt(mean(scaled_residuals**2.)) try: with timeout(10, StalledSimulation): return worker() except (RuntimeError, StalledSimulation): # if convergence fails, use a penalty score return 1e9 * self.penalty_scale def evaluate(self, x): # type: (array) -> SupportsFloat """ Evaluate the objective function and return the result. """ from interruptingcow import timeout self.reset() self.setParameterVector(x) self.r.reset() def worker(): t_now = 0. scaled_residuals = zeros( (len(self.time_values), len(self.measured_quantities))) for it_next in range(0, len(self.time_values)): for iq, q in enumerate(self.measured_quantities): scaled_residuals[it_next, iq] = (self.r[q] - self.scaled_data[it_next, iq] ) / self.reference_value_means[iq] if it_next + 1 < len(self.time_values): self.r.simulate(t_now, self.time_values[it_next + 1], 100) t_now = self.time_values[it_next + 1] if self.divergent(): return 1e9 * self.penalty_scale # print('normalized errors: ', sqrt(mean(scaled_residuals**2, axis=0))) return sqrt(mean(scaled_residuals**2.)) try: with timeout(10, StalledSimulation): return worker() except (RuntimeError, StalledSimulation): # if convergence fails, use a penalty score return 1e9 * self.penalty_scale def plotQuantity(self, quantity, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import name_to_id_map, conc_indices quantity_id = name_to_id_map[quantity] iq = self.measured_quantities.index(quantity_id) reference_data = array(self.scaled_data[:, iq]) r = RoadRunner(self.sbml) self._setParameterVector(param_values, self.param_list, r) r.reset() t_now = 0. residuals = zeros((len(self.time_values), )) residuals[0] = r[quantity_id] - reference_data[0] for it_next in range(1, len(self.time_values)): self._setParameterVector(param_values, self.param_list, r) r.simulate(t_now, self.time_values[it_next], 100) t_now = self.time_values[it_next] residuals[it_next] = r[quantity_id] - reference_data[it_next] r.reset() s = r.simulate(0, float(self.time_values[-1]), 1000, ['time', quantity_id]) # print(quantity, sqrt(mean(residuals**2))/self.reference_value_means[iq]) import tellurium as te te.plot(self.time_values, reference_data, scatter=True, name=quantity + ' data', show=False, error_y_pos=maximum(residuals, 0), error_y_neg=-minimum(residuals, 0)) te.plot(s[:, 0], s[:, 1], name=quantity + ' sim')
def test_delayed_choice(self): inpil = """ length a = 5 length b = 15 length c = 15 length d = 15 length e = 15 length z = 15 RC1 = d( e( z ) ) b*( a* + ) c( + ) d @i 1e-8 M RC1b = d e( z ) d*( b*( a* + ) c( + ) ) @i 1e-8 M R0 = a b c @i 1e-7 M R21 = b c( + ) d @i 0 M R22 = d( e( z ) ) b*( a*( + ) ) c @i 0 M R31 = b c @i 0 M RC32b = d e( z ) d*( b*( a*( + ) ) c( + ) ) @i 0 M RC32 = d( e( z ) ) b*( a*( + ) ) c( + ) d @i 0 M TC1 = a( b c + b( c( + ) d + d( e( z ) ) ) ) @i 0 M TC2 = a( b c + b( c( + ) d( + d e( z ) ) ) ) @i 0 M TC3 = a( b( c + b c( + ) d( + d e( z ) ) ) ) @i 0 M """ enum, out = enumerate_pil(inpil, is_file=False, condensed=True) xml = write_sbml(enum, condensed=True) rr = RoadRunner() rr.load(xml) ExecutableModel = rr.model RC32 = 'RC32' if 'RC32' in rr.model.getFloatingSpeciesIds( ) else 'RC32b' RC1 = 'RC1' if 'RC1' in rr.model.getFloatingSpeciesIds() else 'RC1b' # Compartment assert ExecutableModel.getCompartmentVolumes() == 1. assert ExecutableModel.getNumCompartments() == 1 assert ExecutableModel.getCompartmentIds() == ['TestTube'] # Species speciesIDs = ['R0', RC32, 'R22', 'R31', 'R21', RC1] ini_spIDs = sorted('init({})'.format(x) for x in speciesIDs) concIDs = [ '[R0]', '[' + RC32 + ']', '[R22]', '[R31]', '[R21]', '[' + RC1 + ']' ] ini_coIDs = sorted('init({})'.format(x) for x in concIDs) assert ExecutableModel.getNumFloatingSpecies() == len(speciesIDs) assert sorted( ExecutableModel.getFloatingSpeciesIds()) == sorted(speciesIDs) assert sorted( ExecutableModel.getFloatingSpeciesInitAmountIds()) == sorted( ini_spIDs) assert sorted(ExecutableModel.getFloatingSpeciesInitConcentrationIds() ) == sorted(ini_coIDs) #print(sorted(ini_coIDs)) #print(ExecutableModel.getFloatingSpeciesInitAmounts()) #print(ExecutableModel.getFloatingSpeciesInitConcentrations()) # Reactions rxnIDs = [ 'R0_' + RC1 + '__' + RC32 + '_R31', 'R0_' + RC1 + '__R22_R21' ] assert ExecutableModel.getNumReactions() == len(rxnIDs) assert sorted(ExecutableModel.getReactionIds()) == sorted(rxnIDs) assert rr.model[RC32] == 0 assert rr.model[RC1] == 2e-8 # simulate deterministic rr.model['init([R0])'] = 1e-8 assert rr.model['init(R0)'] == 1e-8 Vol = 1.66e-15 rr.model.setCompartmentVolumes([Vol]) rr.model['init([R0])'] = 1e-8 * Vol rr.model[f'init({RC1})'] = 2e-8 * Vol rr.integrator.absolute_tolerance = 1e-12 * Vol rr.integrator.relative_tolerance = 1e-12 * Vol rr.integrator.initial_time_step = 0.00001 result = rr.simulate(0, 500, steps=100) #print(result) #rr.plot() # look at it if you like! # NOTE: something is off with the units with stochastic simulations, weird... #print(rr.model.getCompartmentVolumes()) #print(rr.model.getFloatingSpeciesInitConcentrations()) #print(rr.model.getFloatingSpeciesInitAmounts()) #print(rr.model.getFloatingSpeciesConcentrations()) #print(rr.model.getFloatingSpeciesAmounts()) rr.reset()
class B5Problem(TimecourseSimBiopredyn): ''' Class that performs a timecourse simulation and evaluates the objective function for b1.''' def __init__(self, sbml): self.sbml = sbml self.r = RoadRunner(sbml) self.r.integrator.absolute_tolerance = 1e-15 self.r.integrator.relative_tolerance = 1e-9 self.r.integrator.stiff = True from observables import observables self.measured_quantity_ids = observables from json import load with open(join(dirname(realpath(__file__)), 'exp_data.json')) as f: self.reference_value_collection = [array(a) for a in load(f)] self.reference_value_means_squared_collection = [] for a in self.reference_value_collection: self.reference_value_means_squared_collection.append( mean(a, axis=0)**2) with open(join(dirname(realpath(__file__)), 'exp_y0.json')) as f: self.exp_y0_collection = [array(a) for a in load(f)] with open(join(dirname(realpath(__file__)), 'stimuli.json')) as f: self.stimuli_collection = [d for d in load(f)] from parameters import param_ids self.param_list = param_ids self.penalty_scale = 1. def setExperimentNumber(self, n): ''' Villaverde et al. use a set of 10 different experiments with respective different stimuli combinations and expected results. This method initialized appropriate variables for the given experiment. ''' self.reference_values = self.reference_value_collection[n] self.reference_value_means_squared = self.reference_value_means_squared_collection[ n] self.exp_y0 = self.exp_y0_collection[n] from species import species for k, s in enumerate(species): self.r.setValue('init({})'.format(s), float(self.exp_y0[k])) self.stimuli = self.stimuli_collection[n] for s, b in self.stimuli.items(): print('{} = {}'.format(s, b * 1.)) self.r[s] = b * 1. def evaluate(self, x): # type: (array) -> SupportsFloat """ Evaluate and return the objective function. """ from interruptingcow import timeout for n in range(10): self.setExperimentNumber(n) self.reset() def worker(): self.r.reset() self.r.resetAll() self.setParameterVector(x, exponential=False) sim = self.r.simulate(0., 30., 16, self.measured_quantity_ids) residuals = sim - self.reference_values normalized_mse_per_quantity = mean( residuals**2, axis=0) / self.reference_value_means_squared return sqrt(mean(normalized_mse_per_quantity)) try: with timeout(10, StalledSimulation): return worker() except (RuntimeError, StalledSimulation): # if convergence fails, use a penalty score return 1e9 * self.penalty_scale def plotQuantity(self, quantity_id, param_values, exp_number): ''' Plot a simulated quantity vs its data points using Tellurium.''' self.setExperimentNumber(exp_number) iq = self.measured_quantity_ids.index(quantity_id) reference_data = array(self.reference_values[:, iq]) # self.r.reset() # self.r.resetAll() # # r.resetToOrigin() # self.setParameterVector(param_values, exponential=False) # sim = self.r.simulate(0., 30., 16, ['time', quantity_id]) # # print(self.r.getReactionRates()) # assert sim.shape[0] == reference_data.shape[0] # residuals = sim[:,1] - reference_data self.r.reset() self.r.resetAll() # r.resetToOrigin() self.setParameterVector(param_values, exponential=False) s = self.r.simulate(0, 25., 100, ['time', quantity_id]) import tellurium as te # te.plot(sim[:,0], reference_data, scatter=True, # name=quantity_id+' data', show=False, # title=quantity_id, # error_y_pos=maximum(residuals,0), # error_y_neg=-minimum(residuals,0)) print(quantity_id + ' sim') te.plot(s[:, 0], s[:, 1], name=quantity_id + ' sim') def getParameterValue(self, param_index): from params import param_index_to_name_map try: return self.r[param_index_to_name_map[param_index]] except KeyError: raise KeyError( 'No such parameter for index {}, must be 0-1758 inclusive'. format(param_index))
class B1Problem(TimecourseSimBiopredyn): ''' Class that performs a timecourse simulation and evaluates the objective function for b1.''' def __init__(self, sbml): self.sbml = sbml self.r = RoadRunner(sbml) # self.r.integrator = 'rk4' # print(self.r.integrator) # self.r.integrator.absolute_tolerance = 1e-10 # self.r.integrator.relative_tolerance = 1e-4 from data import measured_quantity_ids, exp_data, norm_data self.measured_quantity_ids = measured_quantity_ids self.reference_values = exp_data # self.reference_value_means_squared = mean(self.reference_values, axis=0)**2 self.reference_norms = maximum(norm_data, 0.0005) # self.reference_norms_squared = maximum(norm_data, 0.0005)**2 self.quantity_norms = array([ 0.0466906, 0.1666200, 0.1325631, 0.0757189, 0.1266561, 0.11634345, 0.1143341, 0.1104889, 0.2808254, 0.1275417, 0.1163108, 0.26822369, 0.1866278, 0.1555892, 0.4453806, 0.1598696, 0.1222940, 0.14366202, 0.1259413, 0.1473395, 0.1407897, 0.1246730, 0.1153060, 0.12375571, 0.1814630, 0.2199502, 0.1608888, 0.1903940, 0.1242392, 0.11704526, 0.1287076, 0.1319431, 0.1324937, 0.0690382, 0.1316586, 2.15109423, 0.1215476, 0.1414125, 0.1112873, 0.1297432, 0.1288462, 0.1155096, 0.1203922, 0.18807463 ])**2 # UDP-D-glucose excluded because it has buggy errors self.overall_norm = float( mean( array([ 0.0466906, 0.1666200, 0.1325631, 0.0757189, 0.1266561, 0.11634345, 0.1143341, 0.1104889, 0.2808254, 0.1275417, 0.1163108, 0.26822369, 0.1866278, 0.1555892, 0.4453806, 0.1598696, 0.1222940, 0.14366202, 0.1259413, 0.1473395, 0.1407897, 0.1246730, 0.1153060, 0.12375571, 0.1814630, 0.2199502, 0.1608888, 0.1903940, 0.1242392, 0.11704526, 0.1287076, 0.1319431, 0.1324937, 0.0690382, 0.1316586, 0.1215476, 0.1414125, 0.1112873, 0.1297432, 0.1288462, 0.1155096, 0.1203922, 0.18807463 ]))) from params import param_ids self.param_list = param_ids self.penalty_scale = 1. def evaluate(self, x): # type: (array) -> SupportsFloat """ Evaluate and return the objective function. """ from interruptingcow import timeout self.reset() self.setParameterVector(x) self.r.reset() def worker(): # skip the first timepoint # self.r.simulate(0., 1., 10, self.measured_quantity_ids) sim = self.r.simulate(0., 119., 120, self.measured_quantity_ids) # sim = array(sim[0:-1:10,:]) residuals = (sim - self.reference_values) / self.reference_norms normalized_mse_per_quantity = mean(residuals**2, axis=0) # print('sqrt(normalized_mse_per_quantity) = ', sqrt(normalized_mse_per_quantity)) # print('normed residuals', normalized_mse_per_quantity/self.quantity_norms) return float( sqrt(mean(normalized_mse_per_quantity / self.quantity_norms))) * self.overall_norm try: with timeout(10, StalledSimulation): return worker() except (RuntimeError, StalledSimulation): # if convergence fails, use a penalty score return 1e9 * self.penalty_scale def plotQuantity(self, quantity_id, param_values): ''' Plot a simulated quantity vs its data points using Tellurium.''' from data import time_values, measured_quantity_ids, measured_quantity_id_to_name_map quantity_name = measured_quantity_id_to_name_map[quantity_id] iq = measured_quantity_ids.index(quantity_id) reference_data = array(self.reference_values[:, iq]) r = RoadRunner(self.sbml) self._setParameterVector(param_values, self.param_list, r) r.reset() # r.resetAll() # r.resetToOrigin() # r.integrator = 'euler' # r.integrator = 'rk4' # r.integrator.subdivision_steps = 1000 # r.integrator.absolute_tolerance = 1e-10 # r.integrator.relative_tolerance = 1e-4 # r.integrator.initial_time_step = 0.001 # r.integrator.minimum_time_step = 0.0001 # r.integrator.maximum_time_step = 0.1 # print(r.integrator) sim = r.simulate(0., 119., 120, ['time', quantity_id]) assert sim.shape[0] == reference_data.shape[0] residuals = sim[:, 1] - reference_data r.reset() # r.resetAll() # r.resetToOrigin() s = r.simulate(0, float(time_values[-1]), 121, ['time', quantity_id]) # print('mse for {}: '.format(quantity_name), sqrt(mean((residuals**2)/(self.reference_norms[:,iq]**2)))) import tellurium as te te.plot(time_values, reference_data, scatter=True, name=quantity_name + ' data', show=False, title=quantity_name, error_y_pos=maximum(residuals, 0), error_y_neg=-minimum(residuals, 0)) te.plot(s[:, 0], s[:, 1], name=quantity_name + ' sim') def getParameterValue(self, param_index): from params import param_index_to_name_map try: return self.r[param_index_to_name_map[param_index]] except KeyError: raise KeyError( 'No such parameter for index {}, must be 0-1758 inclusive'. format(param_index)) def getCurrentValues_matlab(self): # identical to matlab version return array([ self.r.s_0075, self.r.s_0180, self.r.s_0188, self.r.s_0259, self.r.s_0260, self.r.s_0359, self.r.s_0362, self.r.s_0394, self.r.s_0409, self.r.s_0423, self.r.s_0434, self.r.s_0555, self.r.s_0557, self.r.s_0563, self.r.s_0567, self.r.s_0568, self.r.s_0586, self.r.s_0629, self.r.s_0680, self.r.s_0765, self.r.s_0764, self.r.s_0767, self.r.s_0785, self.r.s_0849, self.r.s_0955, self.r.s_0991, self.r.s_1003, self.r.s_1039, self.r.s_1045, self.r.s_1198, self.r.s_1203, self.r.s_1360, self.r.s_1399, self.r.s_1520, self.r.s_1538, self.r.s_1543, self.r.s_1559, self.r.s_1565, self.getParameterValue(1613) * (self.r.s_0565 - self.r.s_0563) / self.getParameterValue(1614) / (1 + self.r.s_0565 / self.getParameterValue(1614) + 1 + self.r.s_0563 / self.getParameterValue(1615) - 1), self.getParameterValue(1628) * self.r.s_0456 / self.getParameterValue(1629) / (1 + self.r.s_0456 / self.getParameterValue(1629)), self.getParameterValue(1642) * self.r.s_0680 / self.getParameterValue(1643) / (1 + self.r.s_0680 / self.getParameterValue(1643)), self.getParameterValue(1608) * self.r.s_0362 / self.getParameterValue(1609) / (1 + self.r.s_0362 / self.getParameterValue(1609)), self.getParameterValue(1616) * self.r.s_0765 / self.getParameterValue(1617) / (1 + self.r.s_0765 / self.getParameterValue(1617)), self.getParameterValue(1657) * self.r.s_1520 / self.getParameterValue(1658) / (1 + self.r.s_1520 / self.getParameterValue(1658)), ]) def getCurrentValues(self): return array([ self.r.s_0075, self.r.s_0180, self.r.s_0188, self.r.s_0259, self.r.s_0260, self.r.s_0359, self.r.s_0362, self.r.s_0394, self.r.s_0409, self.r.s_0423, self.r.s_0434, self.r.s_0555, self.r.s_0557, self.r.s_0563, self.r.s_0567, self.r.s_0568, self.r.s_0586, self.r.s_0629, self.r.s_0680, self.r.s_0765, self.r.s_0764, self.r.s_0767, self.r.s_0785, self.r.s_0849, self.r.s_0955, self.r.s_0991, self.r.s_1003, self.r.s_1039, self.r.s_1045, self.r.s_1198, self.r.s_1203, self.r.s_1360, self.r.s_1399, self.r.s_1520, self.r.s_1538, self.r.s_1543, self.r.s_1559, self.r.s_1565, # reactions self.r.r_1166, self.r.r_1697, self.r.r_1762, self.r.r_1106, self.r.r_1172, self.r.r_2079, ])