def load(self, filename, variables_names, outputs_names, header=None):
""" Load data from text file with results of DOE.
TODO: NEED TO INCLUDE POSSIBILITY FOR TWO LEVEL VARIABLE
- input:
- header: If not specified, the first line in the file
will be considered to be the header.
"""
if self.variables_names == []:
if header == None:
Data = xf.output_reader(filename=filename)
else:
Data = xf.output_reader(filename=filename, header=header)
if True==True:
self.output_names = outputs_names
self.variables_names = variables_names
self.n_var = len(variables_names)
self.n_var_2 = 0
self.output = {key:Data[key] for key in self.output_names}
self.domain = {key:Data[key] for key in self.variables_names}
# except:
# raise Exception('Something wrong with variables_names and '+
# 'outputs_names.')
else:
raise Exception('Cannot atribute variables and load data at the' +
'same object.')
from scipy import polyfit, polyval
import matplotlib.pyplot as plt
from xfoil_module import output_reader
# Wire properties
rho = 3.55041728247e-06
A = math.pi*(0.000381/2.)**2
L = math.sqrt((0.168 + 0.018)**2 + (0.06 + 0.01)**2)
# Number of point to ignore at each voltage
N = 20
# Import data from IR camera
filename = "voltage_angle_run4.txt"
Data = output_reader(filename, separator='\t', output=None, rows_to_skip=1,
header=['Date', 'Time', 'Voltage', 'X', 'Z'], column_types = [str, str, float,
float, float])
deflection = Data['Z']
voltage = np.array(Data['Voltage'])
delta_t = 0.05 # seconds
time = delta_t * np.array(range(len(Data['Z'])))
#Filter drift
#(drift, drift_0) = polyfit(time[0:7000], deflection[0:7000],1)
#
#deflection = deflection - drift*time
plt.figure()
plt.scatter(voltage, deflection)
plt.xlabel("Voltage (mV)")
import matplotlib.pyplot as plt
from airfoil_module import CST
from xfoil_module import output_reader
data = pickle.load(open('shape_study.p', 'rb'))
n = 5
print 'For n=', n, ': '
print '\t error: ', data['error'][n - 1]
print '\t deltaz: ', data['deltaz'][n - 1]
print '\t Au: ', data['Au'][n - 1]
print '\t Al: ', data['Al'][n - 1]
filename = 'sampled_airfoil_data.csv'
raw_data = output_reader(filename, separator=', ', header=['x', 'y'])
# Rotating airfoil
x_TE = (raw_data['x'][0] + raw_data['x'][-1]) / 2.
y_TE = (raw_data['y'][0] + raw_data['y'][-1]) / 2.
theta_TE = math.atan(-y_TE / x_TE)
# position trailing edge at the x-axis
processed_data = {'x': [], 'y': []}
for i in range(len(raw_data['x'])):
x = raw_data['x'][i]
y = raw_data['y'][i]
c_theta = math.cos(theta_TE)
s_theta = math.sin(theta_TE)
x_rotated = c_theta * x - s_theta * y
E_A = 18.46e3
# Martensite thermal expansion (1/C)
alpha_M = 0.0 # 6.6e-6
# Austenite thermal expansion (1/C)
alpha_A = 0.0 # 11e-6
# Initial tem (T0)
Ti = 30.0
# Final tem (Tf)
Tf = 140.0
eps_t = []
delta_eps_list = []
plt.figure()
for stress_i in stress:
stress_i_string = str(stress_i) + "MPa"
raw_data = output_reader(
"filtered_data_" + stress_i_string + ".txt", separator=" ", header=["Temperature", "Strain", "Stress"]
)
delta_eps = max(raw_data["Strain"]) - min(raw_data["Strain"])
delta_eps_list.append(delta_eps)
eps_t_i = delta_eps + alpha_A * (Tf - Ti) + stress_i * (E_M - E_A) / (E_M * E_A)
print delta_eps, alpha_A * (Tf - Ti), stress_i * (E_M - E_A) / (E_M * E_A), eps_t_i
eps_t.append(eps_t_i)
eps = np.array(raw_data["Strain"]) - min(raw_data["Strain"])
temperature = np.array(raw_data["Temperature"])
plt.plot(temperature, eps, label=stress_i_string)
plt.legend()
plt.grid()
plt.xlabel("Temperature (C)")
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 08 15:06:17 2016
@author: Pedro Leal
"""
import matplotlib.pyplot as plt
from scipy import polyfit, polyval
import numpy as np
from xfoil_module import output_reader
raw_data = output_reader("flexinol_monotonic_loading_martensite.csv", separator=",",
rows_to_skip=4, header = ['Time', 'Extension',
'Load',
"Strain", "Stress"],)
# 'Load',
# "Strain", "Temperature", "Stress"],)
#==============================================================================
# CORRECTION FACTOR BECAUSE OF INCORRENT SAMPLE LENGTH AT INSTRON
#==============================================================================
raw_data["Strain"] = np.array(raw_data["Strain"])*( 0.045/0.10769)
#Ignore initial data
for i in range(len(raw_data['Time'])):
if raw_data['Stress'][i] > 100. :
break
young_data = {}
for key in raw_data:
L = 0.19
# Wire radius
r = 0.000381/2.
# Wire cross section area
A = np.pi*r**2
# Start austenite temperature
A_s = 66.87
# Finish austenite temperature
A_f = 89.68
strain_correction = True
# Import data from IR camera
filename = "untrained_wire_temperature_run5.txt"
Data_temperature = output_reader(filename, separator='\t', output=None, rows_to_skip=13,
header=['Date', 'Time', 'Miliseconds', 'Relative time',
'Temperature'], column_types = [str, str, int, float,
float, float])
# Convert time to total seconds
for i in range(len(Data_temperature['Time'])):
time_i = time.strptime(Data_temperature['Time'][i].split(',')[0],
'%H:%M:%S')
Data_temperature['Time'][i] = datetime.timedelta(hours=time_i.tm_hour,
minutes=time_i.tm_min,
seconds=time_i.tm_sec).total_seconds()
# Import data from Arduino
filename = "untrained_wire_voltage_current_run5.txt"
Data_eletric = output_reader(filename, separator='\t', output=None, rows_to_skip=1,
header=['Date', 'Time', 'Voltage',
'Current'], column_types = [str, str, float,
def flap_multiobjective(airfoil, chord, J, sma, linear, sigma_o, W, r_w, V,
altitude, alpha, T_0, T_final, MVF_init, n, R, all_outputs = False,
import_matlab = True, eng = None, aero_loads = True,
cycling = 'False', n_cycles = 0):
"""
solve actuation problem for flap driven by an antagonistic mechanism
using SMA and linear actuators
:param J: dictionary with coordinates of Joint
:param sigma_o: pre-stress, if not defined, it calculates the biggest
one respecting the constraints (max is H_max)
:param T_0: initial temperature
:param T_final: final temperature
:param MVF_init: initial martensitic volume fraction
:param n: number of steps in simulation"""
from scipy.interpolate import interp1d
import pickle
import os.path
if import_matlab and eng == None:
import matlab.engine
#Start Matlab engine
eng = matlab.engine.start_matlab()
#Go to directory where matlab file is
if import_matlab:
eng.cd(' ..')
eng.cd('SMA_temperature_strain_driven')
else:
eng.cd('SMA_temperature_strain_driven')
def constitutive_model(T, MVF_init, i, n, eps, eps_t_0, sigma_0 = 0,
eps_0 = 0, plot = 'True'):
"""Run SMA model
- all inputs are scalars"""
k = i+1
if k == n:
data = eng.OneD_SMA_Model(k, eps, T, MVF_init,
eps_t_0, sigma_0, eps_0, n, plot,
nargout=6)
else:
data = eng.OneD_SMA_Model(k, eps, T, MVF_init,
eps_t_0, sigma_0, eps_0, n, 'False',
nargout=6)
return data
def equilibrium(eps_s, s, l, T, MVF_init, sigma_0,
i, n, r_w, W, x = None, y = None, alpha = 0.,
q = 1., chord = 1., x_hinge = 0.25, aero_loads = aero_loads,
return_abs = False):
"""Calculates the moment equilibrium. Function used for the
secant method.
"""
#calculate new theta for eps_s and update all the parameter
#of the actuator class
s.eps = eps_s
# print s.eps, s.eps_0, s.r_1, s.r_2, s.r_1_0, s.r_2_0, s.max_eps, s.min_eps
# print s.min_theta, s.max_theta
# try:
# print eps_s
s.calculate_theta(theta_0 = s.theta)
# except:
# s.theta = max(s.max_theta, l.max_theta)
# s.update()
# l.theta = max_theta
# l.update()
# plot_flap(x, y, J['x'], -s.theta)
# raise Exception("Inverse solution for theta did not converge")
s.update()
l.theta = s.theta
l.update()
#SMA (Constitutive equation: coupling via sigma)
data = constitutive_model(T, MVF_init, i, n, eps_s,
eps_t_0, sigma_0, s.eps_0, plot = 'False')
s.sigma = data[0][i][0]
s.calculate_force(source = 'sigma')
tau_s = s.calculate_torque()
#Linear (Geometric equation: coupling via theta)
l.calculate_force()
tau_l = l.calculate_torque()
#weight (Geometric equation: coupling via theta)
tau_w = - r_w*W*math.cos(l.theta)
#aerodynamic (Panel method: coupling via theta)
if aero_loads:
# The deflection considered for the flap is positivite in
# the clockwise, contrary to the dynamic system. Hence we need
# to multiply it by -1.
# print alpha, x_hinge, l.theta
if abs(l.theta) > math.pi/2.:
tau_a = - np.sign(l.theta)*4
else:
Cm = Cm_function(l.theta)
tau_a = Cm*q*chord**2
# Cm = calculate_flap_moment(x, y, alpha, x_hinge, - l.theta,
# unit_deflection = 'rad')
else:
tau_a = 0.
# print 'tau', tau_s, tau_l, tau_w, tau_a, tau_s + tau_l + tau_w + tau_a
f = open('data', 'a')
f.write('\t Inner loop 1\t'+ str(T[i]) + '\t' + str( eps_s) + '\t' + \
str( tau_s + tau_l + tau_w + tau_a) + '\t' + str( tau_s) + '\t' + str(tau_l) + '\t' + str(tau_w) + '\t' + str(tau_a) + '\t' + \
str(l.theta) + '\n')
f.write('\t ' + str(i) + '\t' + str(n) +'\n')
f.write('\t ' + str(l.F) + '\t' + str(s.F) + '\n')
f.close()
if return_abs:
return abs(tau_s + tau_l + tau_w + tau_a)
else:
return tau_s + tau_l + tau_w + tau_a
def eps_s_fixed_point(eps_s, s, l, T, MVF_init, sigma_0,
i, n, r_w, W, x = None, y = None, alpha = 0.,
q = 1., chord = 1., x_hinge = 0.25, aero_loads = aero_loads,
return_abs = False):
"""Calculates the SMA strain. Function used for the
fixed position iteration method. Restriction d epsilon_s / dt < 1.
"""
#calculate new theta for eps_s and update all the parameter
#of the actuator class
s.eps = eps_s
# print 'eps_s: ', eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
l.theta = s.theta
l.update()
#SMA (Constitutive equation: coupling via sigma)
data = constitutive_model(T, MVF_init, i, n, eps_s,
eps_t_0, sigma_0, s.eps_0, plot = 'False')
s.sigma = data[0][i][0]
s.calculate_force(source = 'sigma')
tau_s = s.calculate_torque()
#Linear (Geometric equation: coupling via theta)
l.calculate_force()
tau_l = l.calculate_torque()
#weight (Geometric equation: coupling via theta)
tau_w = - r_w*W*math.cos(l.theta)
#aerodynamic (Panel method: coupling via theta)
if aero_loads:
# The deflection considered for the flap is positivite in
# the clockwise, contrary to the dynamic system. Hence we need
# to multiply it by -1.
if abs(l.theta) > math.pi/2.:
tau_a = - np.sign(l.theta)*4
else:
Cm = Cm_function(l.theta)
tau_a = Cm*q*chord**2
else:
tau_a = 0.
B = tau_s/s.sigma
eps_t = data[3][i][0]
E = data[5][i][0]
eps_s = eps_t - (tau_l + tau_w + tau_a)/(B*E)
# print 'tau', tau_s, tau_l, tau_w, tau_a, tau_s + tau_l + tau_w + tau_a
f = open('data', 'a')
f.write('\t Inner loop 2\t'+ str(T[i]) + '\t' + str( eps_s) + '\t' + \
str( tau_s + tau_l + tau_w + tau_a) + '\t' + str( tau_s) + '\t' + str(tau_l) + '\t' + str(tau_w) + '\t' + str(tau_a) + '\t' + \
str(l.theta) + '\n')
f.close()
return eps_s
def deformation_theta(theta = -math.pi/2., plot = False):
"""Return lists of deformation os SMA actuator per theta"""
theta_list = np.linspace(-theta, theta)
eps_s_list = []
eps_l_list = []
for theta in theta_list:
s.theta = theta
l.theta = theta
s.update()
l.update()
l.calculate_force()
eps_s_list.append(s.eps)
eps_l_list.append(l.eps)
if plot:
import matplotlib.pyplot as plt
plt.figure()
plt.plot(np.degrees(theta_list), eps_s_list, 'r', np.degrees(theta_list), eps_l_list, 'b')
plt.xlabel('$\\theta (degrees)$')
plt.ylabel('$\epsilon$')
return eps_s_list, theta_list
def plot_flap(x, y, x_J, y_J = None, theta = 0):
"""
Plot flap with actuators. theta is clockwise positive.
@Author: Endryws (modified by Pedro Leal)
Created on Fri Mar 18 14:26:54 2016
"""
import matplotlib.pyplot as plt
plt.figure()
x_dict, y_dict = af.separate_upper_lower(x, y)
# Below I create the dictionarys used to pass to the function find_hinge
upper = {'x': x_dict['upper'], 'y': y_dict['upper']} # x and y upper points
lower = {'x': x_dict['lower'], 'y': y_dict['lower']} # x and y lower points
hinge = af.find_hinge(x_J, upper, lower)
#=======================================================================
# With the Joint (hinge) point, i can use the find flap function to
# found the points of the flap in the airfoil.
#=======================================================================
data = {'x': x, 'y': y}
static_data, flap_data = af.find_flap(data, hinge)
R = hinge['y_upper']
theta_list = np.linspace(3*math.pi/2, math.pi/2, 50)
x_circle_list = hinge['x'] + R*np.cos(theta_list)
y_circle_list = hinge['y'] + R*np.sin(theta_list)
n_upper = len(flap_data['x'])/2
# Ploting the flap in the original position
plt.plot(flap_data['x'][:n_upper],flap_data['y'][:n_upper],'k--')
plt.plot(flap_data['x'][n_upper:],flap_data['y'][n_upper:],'k--')
# Rotate and plot
upper = {'x': np.concatenate((flap_data['x'][:n_upper], x_circle_list)),
'y': np.concatenate((flap_data['y'][:n_upper], y_circle_list))}
lower = {'x':(flap_data['x'][n_upper:]),
'y':(flap_data['y'][n_upper:])}
rotated_upper, rotated_lower = af.rotate(upper, lower, hinge, theta,
unit_theta = 'rad')
plt.plot(static_data['x'], static_data['y'],'k')
plt.plot(rotated_upper['x'], rotated_upper['y'],'k')
plt.plot(rotated_lower['x'], rotated_lower['y'],'k')
plt.axes().set_aspect('equal')
s.plot_actuator()
l.plot_actuator()
if y_J != None:
for i in range(y_J):
plt.scatter(x_J , y_J[i])
plt.grid()
plt.locator_params(axis = 'y', nbins=6)
plt.xlabel('${}_{I}x + x_J$')
plt.ylabel('${}_{I}y$')
border = 0.05
plt.xlim(-border, 1+border)
plt.savefig( str(np.floor(100*abs(theta))) + "_configuration.png")
plt.close()
#==============================================================================
# Material and flow properties
#==============================================================================
#SMA properties
E_M = 8.8888e+10
E_A = 3.7427e+10
sigma_crit = 0
H_max = 0.0550
H_min = 0.0387
k = 4.6849e-09
Air_props= air_properties(altitude, unit='feet')
rho = Air_props['Density']
q = 0.5*rho*V**2
#Spring properties(Squared or closed)
C = 10. #Spring index
Nt = 17. #Total number of springs
safety_factor = 5.
A = 2211e6*10**(0.435) #Mpa.mm**0.125
#===========================================================================
# Generate Temperature arrays
#===========================================================================
if n_cycles == 0:
T = np.linspace(T_0, T_final, n)
else:
T = np.append(np.linspace(T_0, T_final, n),
np.linspace(T_final, T_0, n))
for i in range(n_cycles-1):
T = np.append(T,T)
T = list(T)
#===========================================================================
# Generate airfoil (NACA0012)
#===========================================================================
xf.call(airfoil, output='Coordinates')
filename = xf.file_name(airfoil, output='Coordinates')
Data = xf.output_reader(filename, output='Coordinates',
header = ['x','y'])
#The coordinates from Xfoil are normalized, hence we have to multiply
#by the chord
x = []
y = []
for i in range(len(Data['x'])):
x.append( Data['x'][i]*chord )
y.append( Data['y'][i]*chord )
filename = airfoil + '_' + str(int(100*J['x'])) + '_' + \
str(int(100*chord)) + '.p'
#Generate aerodynamic moment data. If already exists, load it
if os.path.isfile(filename):
with open(filename, "rb") as f:
Cm_list = pickle.load( f )
theta_list = pickle.load( f )
else:
theta_list = np.linspace(-math.pi/2., math.pi/2., 100)
Cm_list = []
for theta in theta_list:
Cm = calculate_flap_moment(x, y, alpha, J['x'], - theta,
unit_deflection = 'rad')
Cm_list.append(Cm)
with open(filename, "wb") as f:
pickle.dump( Cm_list, f )
pickle.dump( theta_list, f )
Cm_function = interp1d(theta_list, Cm_list)
#===========================================================================
# SMA actuator
#===========================================================================
#Initial transformation strain
eps_t_0 = H_min + (H_max - H_min)*(1. - math.exp(-k*(abs(sigma_o) - \
sigma_crit)))
#Define initial strain
eps_0 = eps_t_0 + sigma_o/E_M
#Sma actuator (s)
s = actuator(sma, J, eps_0 = eps_0, material = 'SMA', design = 'B',
R = R)
#Check if crossing joint. If True do nothing
if s.check_crossing_joint(tol = 0.0009):
print '1'
if all_outputs:
return [s.eps_0], [0], [s.theta], [sigma_o], [1.], [T[0]], [eps_t_0], [s.theta], [0], [0], [s.length_r]
else:
return s.theta, 9999.
else:
#Input initial stress
s.sigma = sigma_o
s.calculate_force(source = 'sigma')
s.eps_t_0 = eps_t_0
if alpha != 0.:
raise Exception('The initial equilibirum equation only ' + \
'makes sense for alpha equal to zero!!')
s.update()
#Calculate initial torques
s.calculate_torque()
tau_w = - r_w*W
if aero_loads:
# The deflection considered for the flap is positivite in
# the clockwise, contrary to the dynamic system. Hence we need
# to multiply it by -1.
Cm = Cm_function(s.theta)
tau_a = Cm*q*chord**2
else:
tau_a = 0.
#===========================================================================
# Linear actuator
#===========================================================================
#Linear actuator (l)
l = actuator(linear, J, material = 'linear', design = 'B', R=R)
l.theta = s.theta
#Check if crossing joint. If True do nothing
if l.check_crossing_joint(tol = 0.001):
if all_outputs:
return [s.eps_0], [0], [s.theta], [sigma_o], [1.], [T[0]], [eps_t_0], [s.theta], [0], [0], [s.length_r]
else:
return s.theta, 9999.
else:
#l.k = - (s.torque + tau_w + tau_a)/(l.eps*(l.y_p*l.r_1 - l.x_p*l.r_2))
l.F = (s.torque + tau_w + tau_a)/l.R
# print 'force: ', l.F, s.torque, s.torque + tau_w + tau_a
#Spring components
if l.F < 0:
l.d = (safety_factor*(2*C+1)*abs(1.5*l.F)/(0.1125*A*math.pi))**(1./1.855)
else:
l.d = (safety_factor*(C*(4*C+2)/(4*C-3))*abs(1.5*l.F)/(0.05625*A*math.pi))**(1./1.855)
l.D = C*l.d
if l.d < 0.000838:
G = 82.7e9
E = 203.4e9
elif l.d < 0.0016:
G = 81.7e9
E = 200.0e9
elif l.d < 0.00318:
G = 81.0e9
E = 196.6e9
else:
G = 80.0e9
E = 193.0e9
if l.F < 0:
Na = Nt - 2 #Active number of springs
else:
Nt = (E*G*l.d*l.length_r_0 + (1.-2.*C)*E*G*l.d**2 - \
8.*l.F*G*C**3)/(E*G*l.d**2 + 8.*E*l.F*C**3)
Na = Nt + G/E #Equivalent active number of springs
# print "Ns", Nt, Na
l.N = Nt
l.k = l.d**4*G/(8*l.D**3*Na)
if l.F < 0.:
l.zero_stress_length = -l.F/l.k + l.length_r_0
l.solid = (Nt + 1)*l.d
else:
l.zero_stress_length = (2*C - 1 + Nt)*l.d
l.solid = l.zero_stress_length
l.update()
l.eps_0 = l.eps
l.calculate_force(source = 'strain')
l.calculate_torque()
# print "torque: ", l.torque
l.calculate_theta()
# print s.torque, s.eps_0, s.eps, l.eps, l.torque, s.torque + tau_w + \
# tau_a + l.torque
t = 0.12
y_J = af.Naca00XX(chord, t, [J['x']], return_dict = 'y')
l.find_limits(y_J, theta_0 = 0)
# print 's: limits', s.max_theta, s.min_theta
# print s.max_theta_A, s.max_theta_B
# print 'l: limits', l.max_theta, l.min_theta
# print l.max_theta_A, l.max_theta_B
# plot_flap(x, y, J['x'], theta= 0.)
if l.pulley_position == "down":
max_theta = min(l.max_theta, math.pi/2)
elif l.pulley_position == "up":
max_theta = max(l.max_theta, -math.pi/2)
##==============================================================================
# Matlab simulation
##==============================================================================
eps_s = eps_0
eps_s_list = [eps_s]
eps_l_list = [l.eps]
theta_list = [s.theta]
F_l_list =[l.calculate_force()]
L_s_list = [s.length_r]
#Because of the constraint of the maximum deflection, it is possible that
#the number of steps is smaller than n
n_real = 1
# plot_flap(x, y, J['x'], theta= -s.theta)
#Create new data file and erase everything inside
f = open('data', 'w')
f.close()
if n_cycles == 0:
iterations = n
else:
iterations = 2*n*n_cycles
#original number of steps without any restrictions
n_o = n
eps_s_prev = [eps_0, eps_0]
for i in range(1, iterations):
#because n_real can be different of n, it is posssible that
#i is greater than the actual number of iterations. Need
#to break
if i == iterations:
break
#Linear prediction
delta_eps = eps_s_prev[1] - eps_s_prev[0]
#Correction with fixed point iteration
try:
eps_s = fixed_point(eps_s_fixed_point, eps_s + delta_eps, args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
except:
# eps_s = fixed_point(eps_s_fixed_point, eps_s, args=((s, l, T,
# MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
# q, chord, J['x'], True)), xtol = 1e-8)
eps_s_start = eps_s + delta_eps
for j in range(10):
try:
eps_s = fixed_point(eps_s_fixed_point, eps_s_start, args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
break
except:
eps_s_start = eps_s_start*float(j)/10.
eps_s_prev[0] = eps_s_prev[1]
eps_s_prev[1] = eps_s
s.eps = eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
f = open('data', 'a')
f.write('Outer loop \t'+ str(i) + '\t'+ str(eps_s) + '\t'+ str(s.theta)+ '\n')
f.close()
# print 'new theta: ', s.theta
#stop if actuator crosses joints, exceds maximum theta and theta is positively increasing
# print l.r_1, l.r_2
# print s.check_crossing_joint(tol = 0.001), l.check_crossing_joint(tol = 0.001), s.theta, l.length_r, l.solid
if s.check_crossing_joint(tol = 0.001) or l.check_crossing_joint(tol = 0.001) or l.length_r <= l.solid:
if n_cycles == 0:
iterations = n_real
T = T[:n_real]
break
else:
n = n_real #+ 10
iterations = 2*n_real*n_cycles
T_cycle = T[:n_real] + T[:n_real][::-1] #+ 10*[T[n_real-1]]
T = T_cycle
for k in range(n_cycles-1):
T += T_cycle
#Correction with fixed point iteration
eps_s = fixed_point(eps_s_fixed_point, eps_s_prev[1], args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
eps_s_prev[0] = eps_s_prev[1]
eps_s_prev[1] = eps_s
s.eps = eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
else:
if n != n_real:
n_real +=1
if n_o == n_real:
n = n_real #+ 10
if n_cycles == 0:
iterations = n_real
else:
iterations = 2*n_real*n_cycles
T_cycle = T[:n_real] + T[:n_real][::-1] #+ 10*[T[n_real-1]]
T = T_cycle
for k in range(n_cycles-1):
T += T_cycle
l.theta = s.theta
l.update()
eps_s_list.append(eps_s)
eps_l_list.append(l.eps)
theta_list.append(s.theta)
F_l_list.append(l.calculate_force())
L_s_list.append(s.length_r)
# print 'final theta: ', s.theta
if all_outputs:
# print "Nt: %.4f , Na: %.4f, d: %.5f, D: %.4f, L: %.4f, solid length: %.4f, final_L: %.4f" % (Nt, Na, l.d , l.D, l.zero_stress_length, l.solid, l.length_r)
# s.theta = theta_list[-1]
# l.theta = s.theta
# s.update()
# l.update()
# plot_flap(x, y, J['x'], theta= -s.theta)
#
# s.theta = 0.
# l.theta = s.theta
# s.update()
# l.update()
# plot_flap(x, y, J['x'], theta= -s.theta)
if n_real == 1:
return [s.eps_0], [l.eps], [s.theta], [sigma_o], [1.], [T[0]], [eps_t_0], [s.theta], [0], [0], [s.length_r]
else:
#Extra run with prescribed deformation (which has already been calculated)
# to get all the properties]
#TODO: include back n_real
for i in range(1, iterations):
data = constitutive_model(T, MVF_init, i, iterations,
eps_s_list[i], eps_t_0,
sigma_0 = sigma_o,
eps_0 = eps_0,
plot = 'False')
delta_xi = 1. - data[1][-1][0]
sigma_list = []
for i in range(len(data[0])):
sigma_list.append(data[0][i][0])
MVF_list = []
for i in range(len(data[1])):
MVF_list.append(data[1][i][0])
eps_t_list = []
for i in range(len(data[3])):
eps_t_list.append(data[3][i][0])
return eps_s_list, eps_l_list, theta_list, sigma_list, MVF_list, T, eps_t_list, theta_list, F_l_list, l.k, L_s_list
else:
# print theta_list
return theta_list[-1], l.k
def find_deflection(x_hinge,
upper_cruise,
lower_cruise,
type='Match trailing edge',
alpha=0,
Reynolds=0,
**kwargs):
"""
Function to calculate the flap deflection.
Required inputs:
:param x_hinge
:param upper_cruise
:param lower_cruise
:param type: can be:
- 'Match trailing edge': will find the deflection where the
baseline's trailing edge matches that of the objective, i.e.
match the the trailing edge of a traditional flap with a
morphing conitunous flap.
- 'Same Cl': will find deflection where Cl of flapped airfoil
is equal to the the objective airfoil.
- 'Range of deflection'
kwrgs arguments for 'Match trailing edge':
:param x_TE_objective
:param y_TE_objective
:param x_TE_baseline
:param y_TE_baseline
kwrgs arguments for 'Same Cl':
:param Cl_objective
kwrgs arguments for 'Same Cd':
:param Cd_objective
kwrgs arguments for 'Range of deflection'
:param max_deflection
Optional arguments:
:param alpha
:param Reynolds
"""
import xfoil_module as xf
airfoil = 'flapped_airfoil'
if type == 'Match trailing edge':
x_TE_objective = kwargs['x_TE_objective']
y_TE_objective = kwargs['y_TE_objective']
x_TE_baseline = kwargs['x_TE_baseline']
y_TE_baseline = kwargs['y_TE_baseline']
elif type == 'Same Cl':
Cl_objective = kwargs['Cl_objective']
elif type == 'Same Cd':
Cd_objective = kwargs['Cd_objective']
elif type == 'Range of deflection':
max_deflection = kwargs['max_deflection']
init_deflection = kwargs['init_deflection']
step = kwargs['step']
hinge = find_hinge(x_hinge, upper_cruise, lower_cruise)
upper_static, upper_flap = find_flap(upper_cruise, hinge)
lower_static, lower_flap = find_flap(lower_cruise, hinge)
#==============================================================================
# Find Deflection
#==============================================================================
if type == 'Match trailing edge':
#Calculate deflection angle in radians
deflection = np.arctan2(hinge['y'] - y_TE_objective,
x_TE_objective - hinge['x']) - np.arctan2(
hinge['y'] - y_TE_baseline,
x_TE_baseline - hinge['x'])
# Convet to degrees
deflection = deflection * 180. / np.pi
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge,
deflection)
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=100,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
Cd = Data['CD']
Cl = Data['CL']
elif type == 'Same Cl':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = 2.
history = []
# Rough search
step = 2.
while current_Cl < Cl_objective and deflection < 90.: # Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap,
hinge, deflection)
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=100,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
for i in range(1, 6):
# Fine search
step = 0.5**i
current_Cl = previous_Cl
while current_Cl < Cl_objective and deflection < 90.: # Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap,
hinge, deflection)
previous_flapped_airfoil = flapped_airfoil
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=100,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
print current_Cl, deflection
elif type == 'Same Cd':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = 2.
history = []
# Rough search
step = 2.
while current_Cd < Cd_objective and deflection < 90.: # Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap,
hinge, deflection)
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=100,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
for i in range(1, 6):
# Fine search
step = 0.5**i
current_Cd = previous_Cd
while current_Cd < Cd_objective or deflection < 90.: # Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap,
hinge, deflection)
previous_flapped_airfoil = flapped_airfoil
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=1000,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
print deflection
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
print current_Cd, deflection
print history
print Cd_objective
deflection = previous_deflection
Cd = previous_Cd
Cl = previous_Cl
flapped_airfoil = previous_flapped_airfoil
elif type == 'Range of deflection':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = init_deflection
history = {'CD': [], 'CL': [], 'deflection': []}
# Rough search
while deflection < max_deflection: # Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap,
hinge, deflection)
flapped_airfoil = clean(upper_static,
upper_rotated,
lower_static,
lower_rotated,
hinge,
deflection,
N=5)
xf.create_input(airfoil, 'Type 3', airfoil=flapped_airfoil)
xf.call(airfoil,
alfas=alpha,
Reynolds=Reynolds,
iteration=300,
GDES=True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
print deflection
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
if deflection <= max_deflection:
history['CD'].append(current_Cd)
history['CL'].append(current_Cl)
history['deflection'].append(deflection)
return history
return deflection, Cd, Cl, flapped_airfoil
# 'F_l': F_l, 'k': k, 'L_s':L_s}
Data = pickle.load( open( "data.p", "rb" ) )
T_num = np.array(Data['T']) - 273.15
theta_num = np.rad2deg(np.array(Data['theta']))
# Wire properties
rho = 3.55041728247e-06
A = math.pi*(0.000381/2.)**2
L = math.sqrt((0.168 + 0.018)**2 + (0.06 + 0.01)**2)
# Number of point to ignore at each voltage
N = 2
# Import data from IR camera
filename = "voltage_angle_run4.txt"
Data_arduino = output_reader(filename, separator='\t', output=None, rows_to_skip=1,
header=['Date', 'Time', 'Voltage', 'delta t', 'Z'], column_types = [str, str, float,
float, float])
# Convert time to total seconds
for i in range(len(Data_arduino['Time'])):
time_i = time.strptime(Data_arduino['Time'][i].split(',')[0],
'%H:%M:%S')
Data_arduino['Time'][i] = datetime.timedelta(hours=time_i.tm_hour,
minutes=time_i.tm_min,
seconds=time_i.tm_sec).total_seconds()
# Import data from IR camera
filename = "temperature_run4.txt"
Data_temperature = output_reader(filename, separator='\t', output=None, rows_to_skip=13,
header=['Date', 'Time', 'Miliseconds', 'Relative time',
'Temperature'], column_types = [str, str, int, float,
def fitting_shape_coefficients(filename,
bounds='Default',
n=5,
return_data=False,
return_error=False,
optimize_deltaz=False):
"""Fit shape parameters to given data points
Inputs:
- filename: name of the file where the original data is
- bounds: bounds for the shape parameters. If not defined,
Default values are used.
- n: order of the Bernstein polynomial. If bounds is default
this input will define the order of the polynomial.
Otherwise the length of bounds (minus one) is taken into
consideration"""
from hausdorff_distance import hausdorff_distance_2D
def shape_difference(inputs, optimize_deltaz=False):
if optimize_deltaz == True or optimize_deltaz == [True]:
y_u = CST(upper['x'],
1,
deltasz=inputs[-1] / 2.,
Au=list(inputs[:n + 1]))
y_l = CST(lower['x'],
1,
deltasz=inputs[-1] / 2.,
Al=list(inputs[n + 1:-1]))
else:
y_u = CST(upper['x'],
1,
deltasz=deltaz / 2.,
Au=list(inputs[:n + 1]))
y_l = CST(lower['x'],
1,
deltasz=deltaz / 2.,
Al=list(inputs[n + 1:]))
# Vector to be compared with
a_u = {'x': upper['x'], 'y': y_u}
a_l = {'x': lower['x'], 'y': y_l}
b_u = upper
b_l = lower
return hausdorff_distance_2D(a_u, b_u) + hausdorff_distance_2D(
a_l, b_l)
# def shape_difference_upper(inputs, optimize_deltaz = False):
# if optimize_deltaz == True:
# y = CST(x, 1, deltasz = inputs[-1]/2., Au = list(inputs[:-1]))
# else:
# y = CST(x, 1, deltasz = inputs[-1]/2., Au = list(inputs))
# # Vector to be compared with
# b = {'x': x, 'y': y}
# return hausdorff_distance_2D(a, b)
# def shape_difference_lower(inputs, optimize_deltaz = False):
# if optimize_deltaz == True:
# y = CST(x, 1, deltasz = inputs[-1]/2., Al = list(inputs[:-1]))
# else:
# y = CST(x, 1, deltasz = deltaz/2., Al = list(inputs))
# # Vector to be compared with
# b = {'x': x, 'y': y}
# return hausdorff_distance_2D(a, b)
def separate_upper_lower(data):
for i in range(len(data['x'])):
if data['y'][i] < 0:
break
upper = {'x': data['x'][0:i], 'y': data['y'][0:i]}
lower = {'x': data['x'][i:], 'y': data['y'][i:]}
return upper, lower
# Order of Bernstein polynomial
if bounds != 'Default':
n = len(bounds) - 1
# Obtaining data
data = output_reader(filename, separator=', ', header=['x', 'y'])
# Rotating airfoil
x_TE = (data['x'][0] + data['x'][-1]) / 2.
y_TE = (data['y'][0] + data['y'][-1]) / 2.
theta_TE = math.atan(-y_TE / x_TE)
# position trailing edge at the x-axis
processed_data = {'x': [], 'y': []}
for i in range(len(data['x'])):
x = data['x'][i]
y = data['y'][i]
c_theta = math.cos(theta_TE)
s_theta = math.sin(theta_TE)
x_rotated = c_theta * x - s_theta * y
y_rotated = s_theta * x + c_theta * y
processed_data['x'].append(x_rotated)
processed_data['y'].append(y_rotated)
data = processed_data
# determine what is the leading edge and the rotation angle beta
processed_data = {'x': [], 'y': []}
min_x_list = []
min_y_list = []
min_x = min(data['x'])
min_index = data['x'].index(min_x)
min_y = data['y'][min_index]
chord = max(data['x']) - min(data['x'])
beta = math.atan((y_TE - min_y) / (x_TE - min_x))
for i in range(len(data['x'])):
processed_data['x'].append((data['x'][i] - min_x) / chord)
processed_data['y'].append(data['y'][i] / chord)
data = processed_data
#==============================================================================
# Optimizing shape
#==============================================================================
# Determining default bounds
if bounds == 'Default':
upper_bounds = [[0, 1.]] * (n + 1)
lower_bounds = [[0, 1]] + [[-1., 1.]] * n
if optimize_deltaz:
bounds = upper_bounds + lower_bounds + [[0, 0.1]]
else:
bounds = upper_bounds + lower_bounds
deltaz = (data['y'][0] - data['y'][-1])
print bounds
upper, lower = separate_upper_lower(data)
# a = data
# x = data['x']
result = differential_evolution(shape_difference,
bounds,
disp=True,
popsize=10,
args=[optimize_deltaz])
print 'order %i upper done' % n
# x = lower['x']
# a = lower
# result_lower = differential_evolution(shape_difference_lower, lower_bounds,
# disp=True, popsize = 10,
# args = (optimize_deltaz))
# print 'order %i lower done' % n
if optimize_deltaz:
Au = list(result.x[:n + 1])
Al = list(result.x[n + 1:-1])
deltaz = result.x[-1]
else:
Au = list(result.x[:n + 1])
Al = list(result.x[n + 1:])
# Return Al, Au, and others
if return_data:
return data, deltaz, Al, Au
elif return_error:
return result.fun, deltaz, Al, Au
else:
return deltaz, Al, Au
rmse = np.sqrt(np.sum((f - strain_np) ** 2) / len(strain))
return rmse
def tangent_lines(T, T_1, T_2, T_3, T_4, strain_1, strain_2, strain_3, strain_4):
if T < T_2:
return (strain_2 - strain_1) / (T_2 - T_1) * (T - T_1) + strain_1
elif T < T_3:
return (strain_3 - strain_2) / (T_3 - T_2) * (T - T_2) + strain_2
else:
return (strain_4 - strain_3) / (T_4 - T_3) * (T - T_4) + strain_4
raw_data = output_reader("filtered_data_50MPa.txt", header=["Temperature", "Strain", "Stress"])
temperature = raw_data["Temperature"]
strain = raw_data["Strain"]
stress = raw_data["Stress"]
# for i in range(len(temperature)):
# if stress[i] >= 172.:
# break
#
# temperature = temperature[i:]
# strain = strain[i:]
i = temperature.index(max(temperature))
n_b = len(b[keys[0]])
min_values = 1e10 * np.ones(n_a)
for i in range(n_a):
a_x = a['x'][i]
a_y = a['y'][i]
for j in range(n_b):
v = [a_x - b['x'][j], a_y - b['y'][j]]
norm = euclidian_norm(v)
if norm < min_values[i]:
min_values[i] = norm
d = max(min_values)
return d
def euclidian_norm(v):
"""Calculate the Euclidina norm of avector with size n"""
squared_sum = 0
for i in range(len(v)):
squared_sum += v[i]**2
return math.sqrt(squared_sum)
if __name__ == '__main__':
from xfoil_module import output_reader
filename = 'sampled_airfoil_data.csv'
data = output_reader(filename, separator=', ', header=['x', 'y'])
print(hausdorff_distance_2D(data, data))
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 08 15:06:17 2016
@author: Pedro Leal
"""
import matplotlib.pyplot as plt
import scipy.signal as signal
import scipy.interpolate as interpolate
import numpy as np
from xfoil_module import output_reader
stress = "50MPa"
raw_data = output_reader("flexinol_isobaric_trained_" + stress + ".csv", separator=",",
rows_to_skip=4, header = ['Time', 'Extension',
'Load', "Temperature",
"Strain", "Stress"],)
#first_data = output_reader("flexinol_untrained_cyclic_temperature_0p.csv", separator=",",
# rows_to_skip=4, header = ['Time', 'Extension',
# 'Load', "Strain",
# "Stress", "Temperature"],)
##Ignore final data
#for i in range(len(first_data['Time'])):
# if first_data['Time'][i] == 2908.75300: #120745.90000: 5958.89500
# print 'ho'
# break
#
#old_data = first_data
#data = {}
#for key in first_data:
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 14 17:53:47 2016
@author: Pedro Leal
"""
import numpy as np
from xfoil_module import output_reader
stress = "50MPa"
filename = "filtered_data_" + stress + ".txt"
max_172 = 0.10769
Data = output_reader(filename, separator="\t", output=None, rows_to_skip=1, header=["Temperature", "Strain", "Stress"])
T = np.array(Data["Temperature"])
eps = np.array(Data["Strain"]) * (0.045 / max_172)
sigma = Data["Stress"]
data = np.array([T, eps, sigma])
np.savetxt("filtered_data_" + stress + ".txt", data.T, fmt="%.18f")
print max(Data["Strain"])
def plot_generations(filename, cost = None, g = None, p = None,
output_constrained = ['EigenValue', ['Weight','Lift']],
outputs_plotted = ['Weight', 'Velocity'], source = 'raw',
units = ['N','m/s'], n_generation = 20,
last_best = True, color_scheme = 'individual',
optimizers = ['NSGA2','SNOPT'], plot_type = 'all',
output_labels = None):
"""
:param filename: name of file to read
:param cost: function that calculates the cost, if not defined and
'best' used, it is the minimum value in outputs_plotted
:param g: constraint function
:param p: processing function(eg. convert units after constraints)
:param output_constrained: Outputs that will be constrained by g
:param outputs_plotted: The two outputs in the axis of the scatter
plot. If only one is defined, the x axis is considered the
generation
:param source: 'raw' or 'processed'
:param units: units to be on the scatter plots
:param n_generation: number of generations
:param last_best: if Trye, the last individual is the best and plot it.
:param color_scheme: if 'individual', each point in the scatter plot
has a unique color. If 'generation', each individual in the
same generation have the same color.
:optimizers: list of optimizers (works for plot_type = 'best')
:param plot_type: 'all' plots all individuals and 'best' plots only the
best individuals (still does not work for multiobjective). 'all and best'
plots both together.
:param output_labels: if defined, defines the labels on the plot.
Otherwise the outputs_plotted are used
"""
#h = # Equality Constraint
if g==None or output_constrained == None:
process = False
else:
process = True
if source == 'processed':
pullData = open(filename).read()
dataArray = pullData.split('\n')
Drag=[]
Weight=[]
Generation=[]
n_generation=max(Generation)
for eachLine in dataArray:
# Avoids extra lines
if len(eachLine)>1:
x,y,z = eachLine.split('\t')
Generation.append(x)
Weight.append(y)
Drag.append(z)
elif source == 'raw':
pullData = output_reader(filename)
# Creating Generation counter
pullData['Generation'] = []
RandomKey = pullData.keys()[0] # Assumes all keys have item of same len
population_size = len(pullData[RandomKey]) / n_generation
for i in range(population_size, len(pullData[RandomKey])+population_size):
pullData['Generation'].append( i/ population_size )
# If process is True, the values that violate the constrain will be
# deleted in all of the dictionaries of pullData
if process:
for i in range(len(pullData[RandomKey])):
for j in range(len(g)):
if type(output_constrained[j]) != list:
if pullData[output_constrained[j]][i] != None:
if not g[j](pullData[output_constrained[j]][i]):
for key in pullData:
# try:
pullData[key][i] = None
# except:
# print key
elif len(output_constrained[j]) == 2:
# Need to verify if values was already annuled
if pullData[output_constrained[j][0]][i] !=None and pullData[output_constrained[j][1]][i] !=None:
if not g[j](pullData[output_constrained[j][0]][i],
pullData[output_constrained[j][1]][i]):
for key in pullData:
# try:
pullData[key][i] = None
# except:
# print key
while None in pullData[RandomKey]:
for key in pullData:
pullData[key].remove(None)
# Processing
if p != None:
for k in range(len(outputs_plotted)):
for i in range(len(pullData[outputs_plotted[k]])):
pullData[outputs_plotted[k]][i] = p[k](pullData[outputs_plotted[k]][i])
plt.colors()
generation = pullData['Generation']
x = pullData[outputs_plotted[0]]
if len(outputs_plotted) == 2:
x = pullData[outputs_plotted[0]]
y = pullData[outputs_plotted[1]]
space = 0.02*(max(x) - min(x))
plt.xlim(min(x) - space ,max(x) + space)
else:
x = pullData['Generation']
y = pullData[outputs_plotted[0]]
plt.xlim(0.5, n_generation + 0.5)
if plot_type == 'best' or plot_type == 'all and best':
global_min = 9999.
cost_list = []
generation_list = []
if cost == None:
for j in range(1,n_generation+1):
current_min = 9999.
for i in range(len(generation)):
if generation[i] == j and y[i] < current_min:
current_min = y[i]
if current_min < global_min:
global_min = current_min
cost_list.append(global_min)
generation_list.append(j)
plt.plot(generation_list, cost_list, '-o')
plt.xlim(0.5, n_generation + 0.5)
if plot_type == 'all' or plot_type == 'all and best':
for i in range(len(x)):
if color_scheme == 'generation':
plt.scatter(x[i], y[i], color=((1.-float(generation[i])/n_generation,
float(generation[i])/n_generation,
0, 1.)))
elif color_scheme == 'individual':
plt.scatter(x[i], y[i], color=((1.-float(i)/len(x),
float(i)/len(x),
0, 1.)))
plt.plot()
if last_best:
plt.scatter(x[-1], y[-1], marker = 's')
plt.plot()
plt.grid()
if len(outputs_plotted) == 2:
if output_labels == None:
if units != None:
plt.xlabel(outputs_plotted[0] + ' (' + units[0] + ')')
plt.ylabel(outputs_plotted[1] + ' (' + units[1] + ')')
else:
plt.xlabel(outputs_plotted[0])
plt.ylabel(outputs_plotted[1])
else:
if units != None:
plt.xlabel(output_labels[0] + ' (' + units[0] + ')')
plt.ylabel(output_labels[1] + ' (' + units[1] + ')')
else:
plt.xlabel(output_labels[0])
plt.ylabel(output_labels[1])
else:
plt.xlabel('Iteration number')
if output_labels == None:
if units != None:
plt.ylabel(outputs_plotted[0] + ' (' + units[0] + ')')
else:
plt.ylabel(outputs_plotted[0])
else:
if units != None:
plt.ylabel(output_labels[0] + ' (' + units[0] + ')')
else:
plt.ylabel(output_labels[0])
if output_format == 'separate':
return x_offset, y_offset
if __name__ == '__main__':
import xfoil_module as xf
import aero_module as ar
alpha = 0.
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# First step: generate original airfoil
airfoil = "naca0012"
xf.call(airfoil, output='Coordinates')
filename = xf.file_name(airfoil, output='Coordinates')
Data = xf.output_reader(filename, output='Coordinates', header=['x', 'y'])
#Second step: generate flapped airfoil
x, y = separate_upper_lower(Data['x'], Data['y'])
upper = {'x': x['upper'], 'y': y['upper']}
lower = {'x': x['lower'], 'y': y['lower']}
x_hinge = 0.75
hinge = find_hinge(x_hinge, upper, lower)
upper_static, upper_flap = find_flap(upper, hinge)
lower_static, lower_flap = find_flap(lower, hinge, extra_points='lower')
deflection = -90.
Created on Mon Apr 04 15:30:04 2016
@author: Pedro Leal
"""
import numpy as np
import matplotlib.pyplot as plt
import scipy.interpolate
from xfoil_module import output_reader
from airfoil_module import Naca00XX, create_x
filename = 'opt_data.txt'
safety = 0.05
x_J = 0.75
Data = output_reader(filename)
x = Data['xl-'] + Data['xl+'] + Data['xs-'] + Data['xs+']
y = Data['yl-'] + Data['yl+'] + Data['ys-'] + Data['ys+']
theta = Data['theta'] + Data['theta'] + Data['theta'] + Data['theta']
#Need to denormalize y:
for i in range(len(x)):
y_airfoil = Naca00XX(1., 0.12, [x[i]], return_dict = 'y')
thickness = y_airfoil['u'] - y_airfoil['l']
y[i] = y[i]*thickness/2.
x_data = x[::]
y_data = y[::]
#==============================================================================
# Adding point with nothing
upper_rotated, lower_rotated = af.rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil, i_separator = af.clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5,
return_flap_i = True)
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Third step: get new values of pressure coefficient
xf.create_input(x = flapped_airfoil['x'], y_u = flapped_airfoil['y'],
filename = 'flapped', different_x_upper_lower = True)
Data = xf.find_pressure_coefficients('flapped', alpha, NACA = False)
x, y, Cp = separate_upper_lower(x = Data['x'], y = Data['y'],
Cp = Data['Cp'], i_separator = i_separator)
Cm = ar.calculate_moment_coefficient(x, y, Cp, alpha = alpha, c = 1.,
x_ref = x_hinge, y_ref = 0.)
print Cm
if __name__ == '__main__':
# print find_3D_coefficients(airfoil='naca0012', alpha=1.)
alpha = 0.
x_hinge = 0.75
deflection = 5.
# generate original airfoil
airfoil = "naca0012"
xf.call(airfoil, output='Coordinates')
filename = xf.file_name(airfoil, output='Coordinates')
Data = xf.output_reader(filename, output='Coordinates', header = ['x','y'])
Cm = calculate_flap_moment(Data['x'], Data['y'], alpha, x_hinge, deflection)
def find_deflection(x_hinge, upper_cruise, lower_cruise,
type = 'Match trailing edge', alpha=0, Reynolds = 0,
**kwargs):
"""
Function to calculate the flap deflection.
Required inputs:
:param x_hinge
:param upper_cruise
:param lower_cruise
:param type: can be:
- 'Match trailing edge': will find the deflection where the
baseline's trailing edge matches that of the objective, i.e.
match the the trailing edge of a traditional flap with a
morphing conitunous flap.
- 'Same Cl': will find deflection where Cl of flapped airfoil
is equal to the the objective airfoil.
- 'Range of deflection'
kwrgs arguments for 'Match trailing edge':
:param x_TE_objective
:param y_TE_objective
:param x_TE_baseline
:param y_TE_baseline
kwrgs arguments for 'Same Cl':
:param Cl_objective
kwrgs arguments for 'Same Cd':
:param Cd_objective
kwrgs arguments for 'Range of deflection'
:param max_deflection
Optional arguments:
:param alpha
:param Reynolds
"""
import xfoil_module as xf
airfoil = 'flapped_airfoil'
if type == 'Match trailing edge':
x_TE_objective = kwargs['x_TE_objective']
y_TE_objective = kwargs['y_TE_objective']
x_TE_baseline = kwargs['x_TE_baseline']
y_TE_baseline = kwargs['y_TE_baseline']
elif type == 'Same Cl':
Cl_objective = kwargs['Cl_objective']
elif type == 'Same Cd':
Cd_objective = kwargs['Cd_objective']
elif type == 'Range of deflection':
max_deflection = kwargs['max_deflection']
init_deflection = kwargs['init_deflection']
step = kwargs['step']
hinge = find_hinge(x_hinge, upper_cruise, lower_cruise)
upper_static, upper_flap = find_flap(upper_cruise, hinge)
lower_static, lower_flap = find_flap(lower_cruise, hinge)
#==============================================================================
# Find Deflection
#==============================================================================
if type == 'Match trailing edge':
#Calculate deflection angle in radians
deflection = np.arctan2(hinge['y'] - y_TE_objective, x_TE_objective - hinge['x']) - np.arctan2(hinge['y'] - y_TE_baseline, x_TE_baseline - hinge['x'])
# Convet to degrees
deflection = deflection*180./np.pi
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=100, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
Cd = Data['CD']
Cl = Data['CL']
elif type == 'Same Cl':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = 2.
history = []
# Rough search
step = 2.
while current_Cl < Cl_objective and deflection < 90.:# Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=100, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
for i in range(1,6):
# Fine search
step = 0.5**i
current_Cl = previous_Cl
while current_Cl < Cl_objective and deflection < 90.:# Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
previous_flapped_airfoil = flapped_airfoil
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=100, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
print current_Cl, deflection
elif type == 'Same Cd':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = 2.
history = []
# Rough search
step = 2.
while current_Cd < Cd_objective and deflection < 90.:# Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=100, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
for i in range(1,6):
# Fine search
step = 0.5**i
current_Cd = previous_Cd
while current_Cd < Cd_objective or deflection < 90.:# Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
history.append([previous_deflection, previous_Cl, previous_Cd])
deflection = deflection + step
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
previous_flapped_airfoil = flapped_airfoil
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=1000, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
print deflection
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
print current_Cd, deflection
print history
print Cd_objective
deflection = previous_deflection
Cd = previous_Cd
Cl = previous_Cl
flapped_airfoil = previous_flapped_airfoil
elif type == 'Range of deflection':
current_Cl = 0
current_Cd = 0
previous_Cl = 0
deflection = init_deflection
history = {'CD':[], 'CL':[], 'deflection':[]}
# Rough search
while deflection < max_deflection:# Convet to degrees
previous_Cl = current_Cl
previous_Cd = current_Cd
previous_deflection = deflection
deflection = deflection + step
print deflection
upper_rotated, lower_rotated = rotate(upper_flap, lower_flap, hinge, deflection)
flapped_airfoil = clean(upper_static, upper_rotated, lower_static,
lower_rotated, hinge, deflection, N = 5)
xf.create_input(airfoil, 'Type 3', airfoil = flapped_airfoil)
xf.call(airfoil, alfas = alpha, Reynolds = Reynolds, iteration=300, GDES = True,
output='Polar')
filename = xf.file_name(airfoil, alpha, output='Polar')
Data = xf.output_reader(filename, output='Polar')
#Rename to make more convenient
print deflection
current_Cd = Data['CD'][0]
current_Cl = Data['CL'][0]
if deflection <= max_deflection:
history['CD'].append(current_Cd)
history['CL'].append(current_Cl)
history['deflection'].append(deflection)
return history
return deflection, Cd, Cl, flapped_airfoil
def flap(airfoil, chord, J, sma, linear, spring, W, r_w, V,
altitude, alpha, T_0, T_final, MVF_init, n, all_outputs = False,
import_matlab = True, eng = None, aero_loads = True,
cycling = 'False', n_cycles = 0):
"""
solve actuation problem for flap driven by an antagonistic mechanism
using SMA and linear actuators
:param J: dictionary with coordinates of Joint
:param sigma_o: pre-stress, if not defined, it calculates the biggest
one respecting the constraints (max is H_max)
:param T_0: initial temperature
:param T_final: final temperature
:param MVF_init: initial martensitic volume fraction
:param n: number of steps in simulation"""
from scipy.interpolate import interp1d
import pickle
import os.path
if import_matlab and eng == None:
import matlab.engine
#Start Matlab engine
eng = matlab.engine.start_matlab()
#Go to directory where matlab file is
if import_matlab:
eng.cd(' ..')
eng.cd('SMA_temperature_strain_driven')
else:
eng.cd('SMA_temperature_strain_driven')
def constitutive_model(T, MVF_init, i, n, eps, eps_t_0, sigma_0 = 0,
eps_0 = 0, plot = 'True'):
"""Run SMA model
- all inputs are scalars"""
k = i+1
if k == n:
data = eng.OneD_SMA_Model(k, eps, T, MVF_init,
eps_t_0, sigma_0, eps_0, n, plot,
nargout=6)
else:
data = eng.OneD_SMA_Model(k, eps, T, MVF_init,
eps_t_0, sigma_0, eps_0, n, 'False',
nargout=6)
return data
def equilibrium(eps_s, s, l, T, MVF_init, sigma_0,
i, n, r_w, W, x = None, y = None, alpha = 0.,
q = 1., chord = 1., x_hinge = 0.25, aero_loads = aero_loads,
return_abs = False):
"""Calculates the moment equilibrium. Function used for the
secant method.
"""
#calculate new theta for eps_s and update all the parameter
#of the actuator class
s.eps = eps_s
# print s.eps, s.eps_0, s.r_1, s.r_2, s.r_1_0, s.r_2_0, s.max_eps, s.min_eps
# print s.min_theta, s.max_theta
# try:
# print eps_s
s.calculate_theta(theta_0 = s.theta)
# except:
# s.theta = max(s.max_theta, l.max_theta)
# s.update()
# l.theta = max_theta
# l.update()
# plot_flap(x, y, J['x'], -s.theta)
# raise Exception("Inverse solution for theta did not converge")
s.update()
l.theta = s.theta
l.update()
#SMA (Constitutive equation: coupling via sigma)
data = constitutive_model(T, MVF_init, i, n, eps_s,
eps_t_0, sigma_0, s.eps_0, plot = 'False')
s.sigma = data[0][i][0]
s.calculate_force(source = 'sigma')
tau_s = s.calculate_torque()
#Linear (Geometric equation: coupling via theta)
l.calculate_force()
tau_l = l.calculate_torque()
#weight (Geometric equation: coupling via theta)
tau_w = - r_w*W*math.cos(l.theta)
#aerodynamic (Panel method: coupling via theta)
tau_a = 0.
# print 'tau', tau_s, tau_l, tau_w, tau_a, tau_s + tau_l + tau_w + tau_a
f = open('data', 'a')
f.write('\t Inner loop \t'+ str(T[i]) + '\t' + str( eps_s) + '\t' + \
str( tau_s + tau_l + tau_w + tau_a) + '\t' + str( tau_s) + '\t' + str(tau_l) + '\t' + str(tau_w) + '\t' + str(tau_a) + '\t' + \
str(l.theta) + '\n')
f.write('\t ' + str(i) + '\t' + str(n) +'\n')
f.write('\t ' + str(l.F) + '\t' + str(s.F) + '\n')
f.close()
if return_abs:
return abs(tau_s + tau_l + tau_w + tau_a)
else:
return tau_s + tau_l + tau_w + tau_a
def eps_s_fixed_point(eps_s, s, l, T, MVF_init, sigma_0,
i, n, r_w, W, x = None, y = None, alpha = 0.,
q = 1., chord = 1., x_hinge = 0.25, aero_loads = aero_loads,
return_abs = False):
"""Calculates the SMA strain. Function used for the
fixed position iteration method. Restriction d epsilon_s / dt < 1.
"""
#calculate new theta for eps_s and update all the parameter
#of the actuator class
s.eps = eps_s
# print 'eps_s: ', eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
l.theta = s.theta
l.update()
#SMA (Constitutive equation: coupling via sigma)
data = constitutive_model(T, MVF_init, i, n, eps_s,
eps_t_0, sigma_0, s.eps_0, plot = 'False')
s.sigma = data[0][i][0]
s.calculate_force(source = 'sigma')
tau_s = s.calculate_torque()
#Linear (Geometric equation: coupling via theta)
l.calculate_force()
tau_l = l.calculate_torque()
#weight (Geometric equation: coupling via theta)
tau_w = - r_w*W*math.cos(l.theta)
#aerodynamic (Panel method: coupling via theta)
tau_a = 0.
B = tau_s/s.sigma
eps_t = data[3][i][0]
E = data[5][i][0]
eps_s = eps_t - (tau_l + tau_w + tau_a)/(B*E)
# print 'tau', tau_s, tau_l, tau_w, tau_a, tau_s + tau_l + tau_w + tau_a
f = open('data', 'a')
f.write('\t Inner loop 2\t'+ str(T[i]) + '\t' + str( eps_s) + '\t' + \
str( tau_s + tau_l + tau_w + tau_a) + '\t' + str( tau_s) + '\t' + str(tau_l) + '\t' + str(tau_w) + '\t' + str(tau_a) + '\t' + \
str(l.theta) + '\n')
f.close()
return eps_s
def deformation_theta(theta = -math.pi/2., plot = False):
"""Return lists of deformation os SMA actuator per theta"""
theta_list = np.linspace(-theta, theta)
eps_s_list = []
eps_l_list = []
for theta in theta_list:
s.theta = theta
l.theta = theta
s.update()
l.update()
l.calculate_force()
eps_s_list.append(s.eps)
eps_l_list.append(l.eps)
if plot:
import matplotlib.pyplot as plt
plt.figure()
plt.plot(np.degrees(theta_list), eps_s_list, 'r', np.degrees(theta_list), eps_l_list, 'b')
plt.xlabel('$\\theta (degrees)$')
plt.ylabel('$\epsilon$')
return eps_s_list, theta_list
def plot_flap(x, y, x_J, y_J = None, theta = 0):
"""
Plot flap with actuators. theta is clockwise positive.
@Author: Endryws (modified by Pedro Leal)
Created on Fri Mar 18 14:26:54 2016
"""
import matplotlib.pyplot as plt
plt.figure()
x_dict, y_dict = af.separate_upper_lower(x, y)
# Below I create the dictionarys used to pass to the function find_hinge
upper = {'x': x_dict['upper'], 'y': y_dict['upper']} # x and y upper points
lower = {'x': x_dict['lower'], 'y': y_dict['lower']} # x and y lower points
hinge = af.find_hinge(x_J, upper, lower)
#=======================================================================
# With the Joint (hinge) point, i can use the find flap function to
# found the points of the flap in the airfoil.
#=======================================================================
data = {'x': x, 'y': y}
static_data, flap_data = af.find_flap(data, hinge)
R = hinge['y_upper']
theta_list = np.linspace(3*math.pi/2, math.pi/2, 50)
x_circle_list = hinge['x'] + R*np.cos(theta_list)
y_circle_list = hinge['y'] + R*np.sin(theta_list)
n_upper = len(flap_data['x'])/2
# Ploting the flap in the original position
plt.plot(flap_data['x'][:n_upper],flap_data['y'][:n_upper],'k--')
plt.plot(flap_data['x'][n_upper:],flap_data['y'][n_upper:],'k--')
# Rotate and plot
upper = {'x': np.concatenate((flap_data['x'][:n_upper], x_circle_list)),
'y': np.concatenate((flap_data['y'][:n_upper], y_circle_list))}
lower = {'x':(flap_data['x'][n_upper:]),
'y':(flap_data['y'][n_upper:])}
rotated_upper, rotated_lower = af.rotate(upper, lower, hinge, theta,
unit_theta = 'rad')
plt.plot(static_data['x'], static_data['y'],'k')
plt.plot(rotated_upper['x'], rotated_upper['y'],'k')
plt.plot(rotated_lower['x'], rotated_lower['y'],'k')
plt.axes().set_aspect('equal')
l.plot_actuator()
s.plot_actuator()
if y_J != None:
for i in range(y_J):
plt.scatter(x_J , y_J[i])
plt.grid()
plt.locator_params(axis = 'y', nbins=6)
plt.xlabel('${}_{I}x + x_J$')
plt.ylabel('${}_{I}y$')
border = 0.05
plt.xlim(-border, 1+border)
plt.savefig( str(np.floor(100*abs(theta))) + "_configuration.png")
plt.close()
#==============================================================================
# Material and flow properties
#==============================================================================
#SMA properties
E_M = 8.8888e+10
E_A = 3.7427e+10
sigma_crit = 0
H_max = 0.0550
H_min = 0.0387
k = 4.6849e-09
Air_props= air_properties(altitude, unit='feet')
rho = Air_props['Density']
q = 0.5*rho*V**2
#===========================================================================
# Generate Temperature arrays
#===========================================================================
if n_cycles == 0:
T = np.linspace(T_0, T_final, n)
else:
T = np.append(np.linspace(T_0, T_final, n),
np.linspace(T_final, T_0, n))
for i in range(n_cycles-1):
T = np.append(T,T)
T = list(T)
#===========================================================================
# Generate airfoil (NACA0012)
#===========================================================================
xf.call(airfoil, output='Coordinates')
filename = xf.file_name(airfoil, output='Coordinates')
Data = xf.output_reader(filename, output='Coordinates',
header = ['x','y'])
#The coordinates from Xfoil are normalized, hence we have to multiply
#by the chord
x = []
y = []
for i in range(len(Data['x'])):
x.append( Data['x'][i]*chord )
y.append( Data['y'][i]*chord )
filename = airfoil + '_' + str(int(100*J['x'])) + '_' + \
str(int(100*chord)) + '.p'
#Generate aerodynamic moment data. If already exists, load it
# if os.path.isfile(filename):
# with open(filename, "rb") as f:
# Cm_list = pickle.load( f )
# theta_list = pickle.load( f )
# else:
# theta_list = np.linspace(-math.pi/2., math.pi/2., 100)
# Cm_list = []
# for theta in theta_list:
# Cm = calculate_flap_moment(x, y, alpha, J['x'], - theta,
# unit_deflection = 'rad')
# Cm_list.append(Cm)
# with open(filename, "wb") as f:
# pickle.dump( Cm_list, f )
# pickle.dump( theta_list, f )
#
# Cm_function = interp1d(theta_list, Cm_list)
#===========================================================================
# Linear actuator
#===========================================================================
#Linear actuator (l)
l = actuator(linear, J, material = 'linear')
l.k = spring['k']
#Check if crossing joint. If True do nothing
if l.check_crossing_joint(tol = 0.005):
print "problem with linear"
plot_flap(x, y, J['x'], theta= 0)
if all_outputs:
return 0., 0, 0., 200.
else:
return 0, 9999.
else:
l.zero_stress_length = spring['L_0']
l.solid = l.zero_stress_length
l.update()
l.eps_0 = l.eps
l.calculate_force(source = 'strain')
l.calculate_torque()
l.calculate_theta()
#===========================================================================
# SMA actuator
#===========================================================================
tau_w = - r_w*W
#Sma actuator (s)
s = actuator(sma, J, material = 'SMA')
#Initial force
s.F = - s.length_r_0*(l.torque + tau_w)/(s.y_p*s.r_1 - s.x_p*s.r_2)
#Initial stress
s.sigma = s.F/s.area
sigma_o = s.sigma
#Initial transformation strain
eps_t_0 = H_min + (H_max - H_min)*(1. - math.exp(-k*(abs(s.sigma) - \
sigma_crit)))
s.eps_t_0 = eps_t_0
#Define initial strain
eps_0 = s.eps_t_0 + s.sigma/E_M
s.eps_0 = eps_0
s.zero_stress_length = s.length_r_0/(1. + s.eps_0)
s.update()
#Calculate initial torques
s.calculate_torque()
print s.eps, s.F, l.F, s.torque, l.torque, tau_w, s.sigma, sigma_o
#Check if crossing joint. If True do nothing
if s.check_crossing_joint(tol = 0.005):
print "problem with SMA"
plot_flap(x, y, J['x'], theta= 0)
if all_outputs:
return 0., s.theta, 0., 200.
else:
return s.theta, 9999.
else:
t = 0.12
y_J = af.Naca00XX(chord, t, [J['x']], return_dict = 'y')
s.find_limits(y_J, theta_0 = 0)
l.find_limits(y_J, theta_0 = 0)
# print 's: limits', s.max_theta, s.min_theta
# print s.max_theta_A, s.max_theta_B
# print 'l: limits', l.max_theta, l.min_theta
# print l.max_theta_A, l.max_theta_B
# plot_flap(x, y, J['x'], theta= 0.)
max_theta = max(s.max_theta, l.max_theta)
##==============================================================================
# Matlab simulation
##==============================================================================
eps_s = eps_0
eps_s_list = [eps_s]
eps_l_list = [l.eps]
theta_list = [s.theta]
F_l_list =[l.calculate_force()]
L_s_list = [s.length_r]
#Because of the constraint of the maximum deflection, it is possible that
#the number of steps is smaller than n
n_real = 1
# plot_flap(x, y, J['x'], theta= -s.theta)
#Create new data file and erase everything inside
f = open('data', 'w')
f.close()
if n_cycles == 0:
iterations = n
else:
iterations = 2*n*n_cycles
#original number of steps without any restrictions
n_o = n
print s.eps, s.F, l.F, s.torque, l.torque, tau_w
eps_s_prev = [eps_0, eps_0]
for i in range(1, iterations):
#because n_real can be different of n, it is posssible that
#i is greater than the actual number of iterations. Need
#to break
if i == iterations:
break
#Linear prediction
delta_eps = eps_s_prev[1] - eps_s_prev[0]
#Correction with fixed point iteration
try:
eps_s = fixed_point(eps_s_fixed_point, eps_s + delta_eps, args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
except:
# eps_s = fixed_point(eps_s_fixed_point, eps_s, args=((s, l, T,
# MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
# q, chord, J['x'], True)), xtol = 1e-8)
eps_s_start = eps_s + delta_eps
for j in range(10):
try:
eps_s = fixed_point(eps_s_fixed_point, eps_s_start, args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
break
except:
eps_s_start = eps_s_start*float(j)/10.
eps_s_prev[0] = eps_s_prev[1]
eps_s_prev[1] = eps_s
s.eps = eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
f = open('data', 'a')
f.write('Outer loop \t'+ str(i) + '\t'+ str(eps_s) + '\t'+ str(s.theta)+ '\n')
f.close()
# print 'new theta: ', s.theta
#stop if actuator crosses joints, exceds maximum theta and theta is positively increasing
if s.theta <= max_theta or s.check_crossing_joint(tol = 0.001) or l.check_crossing_joint(tol = 0.001) or s.theta > 0.01 or l.length_r <= l.solid:
if n_cycles == 0:
iterations = n_real
T = T[:n_real]
break
else:
n = n_real #+ 10
iterations = 2*n_real*n_cycles
T_cycle = T[:n_real] + T[:n_real][::-1] #+ 10*[T[n_real-1]]
T = T_cycle
for k in range(n_cycles-1):
T += T_cycle
#Correction with fixed point iteration
eps_s = fixed_point(eps_s_fixed_point, eps_s_prev[1], args=((s, l, T,
MVF_init, sigma_o, i, n, r_w, W, x, y, alpha,
q, chord, J['x'], True)), xtol = 1e-8)
eps_s_prev[0] = eps_s_prev[1]
eps_s_prev[1] = eps_s
s.eps = eps_s
s.calculate_theta(theta_0 = s.theta)
s.update()
else:
if n != n_real:
n_real +=1
if n_o == n_real:
n = n_real #+ 10
if n_cycles == 0:
iterations = n_real
else:
iterations = 2*n_real*n_cycles
T_cycle = T[:n_real] + T[:n_real][::-1] #+ 10*[T[n_real-1]]
T = T_cycle
for k in range(n_cycles-1):
T += T_cycle
l.theta = s.theta
l.update()
eps_s_list.append(eps_s)
eps_l_list.append(l.eps)
theta_list.append(s.theta)
F_l_list.append(l.calculate_force())
L_s_list.append(s.length_r)
# print 'final theta: ', s.theta
if all_outputs:
s.theta = theta_list[-1]
l.theta = s.theta
s.update()
l.update()
plot_flap(x, y, J['x'], theta= -s.theta)
s.theta = 0.
l.theta = s.theta
s.update()
l.update()
plot_flap(x, y, J['x'], theta= -s.theta)
if n_real == 1:
return 0., s.theta, 0., 200.
else:
#Extra run with prescribed deformation (which has already been calculated)
# to get all the properties]
#TODO: include back n_real
for i in range(1, iterations):
data = constitutive_model(T, MVF_init, i, iterations,
eps_s_list[i], eps_t_0,
sigma_0 = sigma_o,
eps_0 = eps_0,
plot = 'False')
delta_xi = 1. - data[1][-1][0]
sigma_list = []
for i in range(len(data[0])):
sigma_list.append(data[0][i][0])
MVF_list = []
for i in range(len(data[1])):
MVF_list.append(data[1][i][0])
eps_t_list = []
for i in range(len(data[3])):
eps_t_list.append(data[3][i][0])
return eps_s_list, eps_l_list, theta_list, sigma_list, MVF_list, T, eps_t_list, theta_list, F_l_list, l.k, L_s_list
else:
# print theta_list
return theta_list[-1], l.k
@author: Pedro Leal
"""
import matplotlib.pyplot as plt
import scipy.signal as signal
import scipy.interpolate as interpolate
import numpy as np
from xfoil_module import output_reader
#stress = "50MPa"
#raw_data = output_reader("flexinol_isobaric_trained_" + stress + ".csv", separator=",",
# rows_to_skip=4, header = ['Time', 'Extension',
# 'Load', "Temperature",
# "Strain", "Stress"],)
first_data = output_reader("flexinol_training_first.csv", separator=",",
rows_to_skip=4, header = ['Time', 'Extension',
'Load', "Temperature",
"Strain", "Stress"],)
second_data = output_reader("flexinol_training_second.csv", separator=",",
rows_to_skip=4, header = ['Time', 'Extension',
'Load', "Temperature",
"Strain", "Stress"],)
#==============================================================================
# CORRECTION FACTOR BECAUSE OF INCORRENT SAMPLE LENGTH AT INSTRON
#==============================================================================
first_data["Strain"] = list(np.array(first_data["Strain"])*( 0.045/0.10769))
second_data["Strain"] = list(np.array(second_data["Strain"])*( 0.045/0.10769))
#==============================================================================
# Plot first and last with same scale