Athemis/pyKinetics
1
0
Fork 0
mirror of https://github.com/Athemis/pyKinetics.git synced 2025-04-05 06:56:02 +00:00
Code Issues Releases Wiki Activity

Split in library and cli

Browse source
This commit is contained in:
Alexander Minges 2015-08-18 23:58:57 +02:00
parent 7bbb368499
commit 7a943cb945
2 changed files with 141 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
analyze-cli.py Executable file
View file

@ -0,0 +1,65 @@
#!/usr/bin/python
import argparse
import logging
import csv
from pathlib import Path
import libkinetics
def parse_arguments():
parser = argparse.ArgumentParser()
parser.add_argument('-v',
'--verbose',
action='store_true',
help='increase output verbosity')
parser.add_argument('-wh',
'--with_hill',
action='store_true',
help='compute additional kinetics using Hill equation')
parser.add_argument('input',
type=str,
help='directory containing input files in csv format')
parser.add_argument('output',
type=str,
help='results will be written to this directory')
args = parser.parse_args()
return args
def main():
# parse command line arguments
args = parse_arguments()
if args.with_hill:
do_hill = args.with_hill
else:
do_hill = False
try:
input_path = Path(args.input).resolve()
except FileNotFoundError:
print('Path containing input data not found: {}'.format(args.input))
raise
try:
output_path = Path(args.output).resolve()
except FileNotFoundError:
print('Path for writing results not found: {}'.format(args.output))
raise
if output_path.is_dir():
if input_path.is_dir():
data_files = sorted(input_path.glob('**/*.csv'))
exp = libkinetics.Experiment(data_files, (10, 25), do_hill)
exp.plot_data(str(output_path))
exp.plot_kinetics(str(output_path))
exp.write_data(str(output_path))
else:
raise ValueError('{} is not a directory!'.format(input_path))
else:
raise ValueError('{} is not a directory!'.format(output_path))
if __name__ == "__main__":
main()

152
analyze.py → libkinetics/__init__.py Executable file → Normal file
View file

@ -3,11 +3,11 @@
from scipy import stats, optimize from scipy import stats, optimize
import numpy as np import numpy as np
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
import glob
import csv import csv
class Replicate(): class Replicate():
def __init__(self, x, y, owner): def __init__(self, x, y, owner):
self.x = x self.x = x
self.y = y self.y = y
@ -59,7 +59,7 @@ class Measurement():
self.avg_slope = np.average(self.slopes) self.avg_slope = np.average(self.slopes)
self.avg_slope_err = np.std(self.slopes) self.avg_slope_err = np.std(self.slopes)
def plot(self): def plot(self, outpath):
fig, ax = plt.subplots() fig, ax = plt.subplots()
ax.set_xlabel('Time [s]') ax.set_xlabel('Time [s]')
ax.set_ylabel('Absorption (340 nm) [Au]') ax.set_ylabel('Absorption (340 nm) [Au]')
@ -73,8 +73,9 @@ class Measurement():
'k-') 'k-')
ax.axvspan(self.xlim[0], self.xlim[1], facecolor='0.8', alpha=0.5) ax.axvspan(self.xlim[0], self.xlim[1], facecolor='0.8', alpha=0.5)
plt.savefig('out/fit_{}_{}.png'.format(self.concentration, plt.savefig('{}/fit_{}_{}.png'.format(outpath,
self.concentration_unit), self.concentration,
self.concentration_unit),
bbox_inches='tight') bbox_inches='tight')
plt.close(fig) plt.close(fig)
@ -88,7 +89,7 @@ class Measurement():
class Experiment(): class Experiment():
def __init__(self, data_files, xlim): def __init__(self, data_files, xlim, do_hill=False):
# collction of indepentend measurements # collction of indepentend measurements
self.measurements = [] self.measurements = []
@ -97,15 +98,11 @@ class Experiment():
'y': [], 'y': [],
'yerr': []} 'yerr': []}
self.xlim = xlim self.xlim = xlim
# variables to store calculated Michaelis-Menten and Hill kinetics
self.mm = None
self.hill = None
# parse data files and generate measurements # parse data files and generate measurements
for csvfile in data_files: for csvfile in data_files:
tmp = np.genfromtxt(csvfile, comments='#') tmp = np.genfromtxt(str(csvfile), comments='#')
with open(csvfile) as datafile: with open(str(csvfile)) as datafile:
head = [next(datafile) for x in range(2)] head = [next(datafile) for x in range(2)]
# extract concentration and unit from header # extract concentration and unit from header
# TODO: move unit to parameter # TODO: move unit to parameter
@ -113,25 +110,34 @@ class Experiment():
conc = head[0].strip('#').strip() conc = head[0].strip('#').strip()
unit = head[1].strip('#').strip() unit = head[1].strip('#').strip()
# split x and y data apart # split x and y data apart
# first column is x data (time); following columns contain # first column is x data (time); following columns contain
# replicates of y data (absorption, etc.) # replicates of y data (absorption, etc.)
x = tmp[:, 0] x = tmp[:, 0]
y = tmp[:, 1:] y = tmp[:, 1:]
# create new measurement and append to list # create new measurement and append to list
measurement = Measurement(x, y, conc, unit, self) measurement = Measurement(x, y, conc, unit, self)
self.measurements.append(measurement) self.measurements.append(measurement)
# iterate over all measurements # iterate over all measurements
for m in self.measurements: for m in self.measurements:
# extract relevant data for kinetics calculation (concentration, # extract relevant data for kinetics calculation (concentration,
# average slope and error) # average slope and error)
self.raw_kinetic_data['x'].append(m.concentration) self.raw_kinetic_data['x'].append(m.concentration)
self.raw_kinetic_data['y'].append(np.absolute(m.avg_slope)) self.raw_kinetic_data['y'].append(np.absolute(m.avg_slope))
self.raw_kinetic_data['yerr'].append(m.avg_slope_err) self.raw_kinetic_data['yerr'].append(m.avg_slope_err)
def plot_data(self): # calculate kinetics
self.mm = self.do_mm_kinetics()
if do_hill:
self.hill = self.do_hill_kinetics()
else:
self.hill = None
def plot_data(self, outpath):
# iterate over all measurements
for m in self.measurements: for m in self.measurements:
m.plot() # plot each measurement
m.plot(outpath)
def mm_kinetics_function(self, x, vmax, Km): def mm_kinetics_function(self, x, vmax, Km):
v = (vmax*x)/(Km+x) v = (vmax*x)/(Km+x)
@ -142,39 +148,47 @@ class Experiment():
return v return v
def do_mm_kinetics(self): def do_mm_kinetics(self):
popt, pconv = optimize.curve_fit(self.mm_kinetics_function, try:
self.raw_kinetic_data['x'], popt, pconv = optimize.curve_fit(self.mm_kinetics_function,
self.raw_kinetic_data['y']) self.raw_kinetic_data['x'],
self.raw_kinetic_data['y'])
perr = np.sqrt(np.diag(pconv)) perr = np.sqrt(np.diag(pconv))
vmax = popt[0] vmax = popt[0]
Km = popt[1] Km = popt[1]
x = np.arange(0, max(self.raw_kinetic_data['x']), 0.0001) x = np.arange(0, max(self.raw_kinetic_data['x']), 0.0001)
return {'vmax': float(vmax), return {'vmax': float(vmax),
'Km': float(Km), 'Km': float(Km),
'perr': perr, 'perr': perr,
'x': x} 'x': x}
except:
print('Calculation of Hill kinetics failed!')
return None
def do_hill_kinetics(self): def do_hill_kinetics(self):
popt, pconv = optimize.curve_fit(self.hill_kinetics_function, try:
self.raw_kinetic_data['x'], popt, pconv = optimize.curve_fit(self.hill_kinetics_function,
self.raw_kinetic_data['y']) self.raw_kinetic_data['x'],
self.raw_kinetic_data['y'])
perr = np.sqrt(np.diag(pconv)) perr = np.sqrt(np.diag(pconv))
vmax = popt[0] vmax = popt[0]
Kprime = popt[1] Kprime = popt[1]
h = popt[2] h = popt[2]
x = np.arange(0, max(self.raw_kinetic_data['x']), 0.0001) x = np.arange(0, max(self.raw_kinetic_data['x']), 0.0001)
return {'vmax': float(vmax), return {'vmax': float(vmax),
'Kprime': float(Kprime), 'Kprime': float(Kprime),
'perr': perr, 'perr': perr,
'h': h, 'h': h,
'x': x} 'x': x}
except:
print('Calculation of Hill kinetics failed!')
return None
def plot_kinetics(self): def plot_kinetics(self, outpath):
fig, ax = plt.subplots() fig, ax = plt.subplots()
ax.set_xlabel('c [mM]') ax.set_xlabel('c [mM]')
ax.set_ylabel('dA/dt [Au/s]') ax.set_ylabel('dA/dt [Au/s]')
@ -184,28 +198,24 @@ class Experiment():
self.raw_kinetic_data['y'], self.raw_kinetic_data['y'],
yerr=self.raw_kinetic_data['yerr'], yerr=self.raw_kinetic_data['yerr'],
fmt='ok', ms=3, fillstyle='none', label="Data with error") fmt='ok', ms=3, fillstyle='none', label="Data with error")
# linestyle='None', marker='o', ms=3, fillstyle='none'
self.mm = self.do_mm_kinetics()
self.hill = self.do_hill_kinetics()
print(self.mm) if self.mm:
print(self.hill) ax.plot(self.mm['x'],
(self.mm['vmax']*self.mm['x'])/(self.mm['Km']+self.mm['x']), 'b-', label="Michaelis-Menten")
ax.plot(self.mm['x'], if self.hill:
(self.mm['vmax']*self.mm['x'])/(self.mm['Km']+self.mm['x']), ax.plot(self.hill['x'],
'b-', label="Michaelis-Menten") ((self.hill['vmax']*(self.hill['x']**self.hill['h'])) /
ax.plot(self.hill['x'], (self.hill['Kprime'] + (self.hill['x']**self.hill['h']))), 'g-', label="Hill")
((self.hill['vmax']*(self.hill['x']**self.hill['h'])) /
(self.hill['Kprime'] + (self.hill['x']**self.hill['h']))),
'g-', label="Hill")
ax.legend(loc='best', fancybox=True) ax.legend(loc='best', fancybox=True)
plt.savefig('out/kinetics.png', bbox_inches='tight') plt.savefig('{}/kinetics.png'.format(outpath), bbox_inches='tight')
plt.close(fig) plt.close(fig)
def write_data(self): def write_data(self, outpath):
with open('out/results.csv', 'w', newline='\n') as csvfile: with open('{}/results.csv'.format(outpath),
'w',
newline='\n') as csvfile:
writer = csv.writer(csvfile, dialect='excel-tab') writer = csv.writer(csvfile, dialect='excel-tab')
writer.writerow(['# LINEAR FITS']) writer.writerow(['# LINEAR FITS'])
@ -223,22 +233,12 @@ class Experiment():
writer.writerow(row) writer.writerow(row)
writer.writerow([]) writer.writerow([])
writer.writerow(['# MICHAELIS-MENTEN KINETICS']) if self.mm:
writer.writerow(['# vmax', 'Km']) writer.writerow(['# MICHAELIS-MENTEN KINETICS'])
writer.writerow([self.mm['vmax'], self.mm['Km']]) writer.writerow(['# vmax', 'Km'])
writer.writerow([self.mm['vmax'], self.mm['Km']])
writer.writerow(['# HILL KINETICS']) if self.hill:
writer.writerow(['# vmax', 'Kprime', 'h']) writer.writerow(['# HILL KINETICS'])
writer.writerow([self.hill['vmax'], self.hill['Kprime'], writer.writerow(['# vmax', 'Kprime', 'h'])
self.hill['h']]) writer.writerow([self.hill['vmax'], self.hill['Kprime'],
self.hill['h']])
def main():
data_files = glob.glob('csv/*.csv')
exp = Experiment(data_files, (10, 25))
exp.plot_data()
exp.plot_kinetics()
exp.write_data()
if __name__ == "__main__":
main()