In [15]:
import os, glob, numpy as np, csv, math
import numpy.ma as ma
import matplotlib.pyplot as plt
import matplotlib.colors as colors
import matplotlib.cm as cmx
from scipy import signal, fftpack
from matplotlib.legend_handler import HandlerLine2D
from scipy.optimize import minimize
%matplotlib inline
%config InlineBackend.figure_format = 'retina'


dir_path = os.path.dirname(os.path.realpath('plotter_notebook.ipynb'))
wrkdir = os.path.join(dir_path,'data')
csv_files = os.path.join(wrkdir,'*.csv')
meta_files = os.path.join(wrkdir,'*.txt')
trackdata = glob.glob(csv_files)
metadata = glob.glob(meta_files)
n_files = np.size(trackdata)

location = 'average'
volumes = [0.5,1.0,2.0,3.0,4.0,5.0,6.0,10.0]
angles= [2.0,3.5,4,5.0,7.7]

def basic_plot_format(subplot_label,x_label,y_label,major_grid,minor_grid,legend):
    # General plot formatting for relatively good plots. adjustments may be necessary
    # sub_plot_label, usually defined by 'ax' and a number
    # x_label and y_label must be type 'str'... Can use LaTeX for typsetting
    # major_grid, minor_grid, and legend are boolean
    
    plt.style.use('classic')
    font = {'family' : 'Times New Roman',
            'weight' : 0,
            'size'   : 18}
    plt.rc('font',**font)
    
    subplot_label.spines['right'].set_color('none')
    subplot_label.spines['top'].set_color('none')
    subplot_label.yaxis.set_ticks_position('left')
    subplot_label.xaxis.set_ticks_position('bottom')
    subplot_label.minorticks_on()
    subplot_label.set_xlabel(x_label,fontsize=24)
    subplot_label.set_ylabel(y_label,fontsize=24)

    subplot_label.grid(b=major_grid,which='major')
    subplot_label.grid(b=minor_grid,which='minor')
    
    if legend == False:
         0   
    else:
        legend =  subplot_label.legend(numpoints = 1,\
                                       bbox_to_anchor=(-0.5, 1),loc='upper left',frameon=False,fontsize=10)
        legend.get_frame().set_facecolor('white')
        return legend

def get_variables(metadata):
    f = open(metadata[0],"r")
    drop_vars = list(csv.reader(f))
    f.close()
    
    
    drop_meta = {}
    for i in range(n_files):
        drop_meta[drop_vars[i+1][0]] = {}
        n_meta = np.size(drop_vars[0][1:])
        for n in range(n_meta):
            drop_meta[drop_vars[i+1][0]][drop_vars[0][n+1].split('_')[0]] = float(drop_vars[i+1][n+1])

    meta = drop_meta
    return meta

meta = get_variables(metadata)


def get_data(wrkdir,csv_files,trackdata,n_files):
    
    total_drop_data = {}
    
    
    for i in range(n_files):
        (location, name) = os.path.split( trackdata[i] )
        
        f = open(trackdata[i],"r")
        drop_data = list(csv.reader(f))
        f.close()
        
        col_names = drop_data[0]
        n_col = np.size(drop_data[0])
        drop_data = np.asarray(drop_data[1:],dtype=float)
        total_drop_data[name[:-4]] = {}
        for j in range(n_col):
            total_drop_data[name[:-4]][col_names[j]] = drop_data[:,j]

    return total_drop_data

data = get_data(wrkdir,csv_files,trackdata,n_files)

In [18]:
def exit_times(data,meta):
    et_exp = {}
    et_theo = {}
    distance2exit = {}
    for key in data:
        
        R = ((3000*meta[key]['Volume'])/(4*math.pi))**(1/3)
        sin_angl = math.sin((meta[key]['Angle']/2)*(math.pi/180))
        x_max_theo = (R/sin_angl)
        
        if np.max(data[key]['average'])>x_max_theo:
            i = np.min(np.where(data[key]['average']>=x_max_theo))
            et_exp[key] = data[key]['time'][i]
            et_theo[key] = (R/1000)*(1000/(0.072*9.81))**(1/4)*(1/(-2*math.cos(155*math.pi/180)*sin_angl))
        else:
            distance2exit[key] = x_max_theo-np.max(data[key]['average'])

    return et_exp,et_theo

et_exp,et_theo = exit_times(data,meta)
global et_exp
global et_theo
def error_time(x):
    error = [abs(et_exp[key]-x*et_theo[key])/et_exp[key] for key in et_exp]
    ave_error = np.mean(error)
    return ave_error

res = minimize(error_time, 1, method='Nelder-Mead', tol=1e-6)
res


Out[18]:
 final_simplex: (array([[ 2.22989502],
       [ 2.22989578]]), array([ 0.15641177,  0.15641177]))
           fun: 0.15641176541006752
       message: 'Optimization terminated successfully.'
          nfev: 48
           nit: 24
        status: 0
       success: True
             x: array([ 2.22989502])

In [ ]: