My Project
splitMultipleSpeedSegmentsFriction.py
Go to the documentation of this file.
1 from frictionImports import *
2 from makePhaseAnimationData import calculateIntervalSize
3 
4 import re
5 
6 sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '/File')
7 from loadFromResults import LoadFile, SimplePlots, VectorArrayHelper, MathHelper
8 
10  def __init__(
11  self,
12  run_name = "",
13  numeric_method = "_midpoint_"
14  ):
15  self.loader = LoadFile(run_name)
19 
20  #self.singleIncrementRun()
22 
23 
24 
26  self
27  ):
28  self.pad_velocity = self.loader.loadFile("pad_friction")
29  self.x = self.simplePlots.timeSimpleLinspaceFromParameters(self.pad_velocity, self.loader.run_parameters)
30 
32  self.plotPadProperty("pad_friction")
33 
35  self
36  ):
37  file_name_speeds = self.generateFileNamesFromParameters()
38  files = self.loader.loadLastHalfParallelRun("pad_friction", file_name_speeds)
39 
40  # TO DO: brake power * velocity summed over time.
41  if("-brakeenergy" in sys.argv):
42  self.brakeEnergy(files, file_name_speeds)
43 
44  x_values = self.simplePlots.intervalLinspaceParallelHalfRun(files[0], self.loader.run_parameters)
45 
46  amplitudes_and_errors = np.array([self.calculateAmplitude(file) for file in files])
47  amplitudes = amplitudes_and_errors[:,0]
48  errors = amplitudes_and_errors[:,1]
49  averages = amplitudes_and_errors[:,2]
50  max_files_plotted = 2
51  print("Files longer than max files to be plotted: ", len(files) > max_files_plotted)
52 
53  if(len(files) > max_files_plotted):
54  for i in range(0,max_files_plotted):
55  plt.plot(x_values, files[i], label = file_name_speeds[i])
56  #self.mathHelper.calculate_fft(files[i])
57  plt.legend()
58  if(not "-noplot" in sys.argv):
59  plt.show()
60 
61  else:
62  for file in files:
63  plt.plot(file, x_values)
64  self.mathHelper.calculate_fft(file)
65  self.plotAmplitude(amplitudes, errors, averages)
66 
67  def brakeEnergy(
68  self,
69  friction_forces,
70  file_name_speeds
71  ):
72  file_name_speeds = self.simplePlots.sliderSpeedSimpleLinspaceFromParameters(len(friction_forces), self.loader.run_parameters)
73  pad_velocity = self.loader.loadFile("pad_velocity")
74  interval_size = calculateIntervalSize(self.loader)
75  last_half_index = self.VectorArrayHelper.lastXPercentIndex(50, interval_size)
76  pad_velocity_intervals = self.VectorArrayHelper.splitNumpyVectorToMatrix(pad_velocity, interval_size)
77  pad_velocity_intervals = np.array(pad_velocity_intervals)
78  pad_velocity_intervals_last_half = pad_velocity_intervals[:, last_half_index:]
79 
80  brake_energy = [np.sum(abs(friction_force*speed)) for friction_force, speed in zip(friction_forces, file_name_speeds)] # pad_velocity_intervals_last_half)]
81  friction_combined = np.concatenate(friction_forces)
82  pad_velocity_intervals_last_half_combined = np.concatenate(pad_velocity_intervals_last_half)
83 
84  x_values_continous = np.linspace(start=file_name_speeds[0], stop=file_name_speeds[-1], num=len(friction_combined))
85 
86  plt.figure()
87  plt.subplot(212)
88  plt.ylim(-1000, 300000)
89  plt.plot(file_name_speeds, brake_energy, marker='x')
90  plt.subplot(221)
91  plt.ylim(-200,150)
92  plt.plot(x_values_continous, friction_combined)
93  plt.subplot(222)
94  plt.ylim(-0.1,1.51)
95  #plt.plot(pad_velocity_intervals_last_half_combined)
96  plt.plot(file_name_speeds, file_name_speeds)
97  plt.show()
98  quit()
99 
101  self,
102  general_name = "pad_friction"
103  ):
104 
105  interval_size = self.loader.getParameter("interval")
106  slider_speed = self.loader.getParameter("slider_speed")
107  slider_increment = self.loader.getParameter("increment")
108  max_time = self.loader.getParameter("max_time")
109 
110  intervals = int(max_time / interval_size)
111 
112  file_name_speeds = []
113 
114  for i in range(0, intervals):
115  current_slider_speed = np.round(slider_speed + slider_increment * i,4)
116  print(current_slider_speed)
117  file_name_speeds.append(self.addNecessaryZeroes(str(current_slider_speed)))
118 
119  return file_name_speeds
120 
121 
122  def addNecessaryZeroes(
123  self,
124  decimal_number
125  ):
126  number_of_decimals = self.numberOfDecimals(decimal_number)
127  if(number_of_decimals == 0):
128  number_of_decimals = 1
129  decimal_with_zeroes = decimal_number + (6-number_of_decimals)*"0"
130  return decimal_with_zeroes
131 
132  def numberOfDecimals(
133  self,
134  decimal_number
135  ):
136  match = re.match(r"^[0-9]*\.(([0-9]*[1-9])?)0*$", decimal_number)
137  return len(match.group(1)) if match is not None else 0
138 
139 
140 
142  self
143  ):
144  interval_size = int(self.loader.run_parameters["Parameters"]["interval"]/self.loader.run_parameters["Parameters"]["dt"])
145  splitted_values = self.VectorArrayHelper.splitNumpyVectorToMatrix(self.pad_velocity, interval_size)
146 
147  half_index = self.VectorArrayHelper.startSecondHalfIndex(splitted_values[0])
148 
149  a = []
150 
151  for i in range(0, len(splitted_values)):
152  half_of_values = splitted_values[i][half_index:]
153  amplitude_and_error = self.calculateAmplitude(half_of_values)
154  amplitude = amplitude_and_error[0]
155  errors = amplitude_and_error[1]
156  a.append(amplitude)
157 
158  self.plotAmplitude(a, errors)
159 
160  def plotPadProperty(
161  self,
162  pad_property
163  ):
164  pad_property = self.loader.loadFile(pad_property)
165 
166  plot_values_dictionary = self.simplePlots.intervalLinspaceFromParameters(pad_property, self.loader.run_parameters)
167 
168  print(plot_values_dictionary['x_values'])
169 
170  self.simplePlots.plotOneWithTwoAxes(plot_values_dictionary['x_values'], pad_property)
171  plt.show()
172 
173  def calculateAmplitude(
174  self,
175  interval
176  ):
177  interval_average = np.average(interval)
178  amplitude = np.sqrt(2)*np.sqrt(np.average(np.power(interval - interval_average,2)))
179  error = self.calculateError(interval, interval_average, 4)
180  return np.array([amplitude, error, interval_average])
181 
182  def plotAmplitude(
183  self,
184  amplitude,
185  errors,
186  averages
187  ):
188  x_values = self.simplePlots.sliderSpeedSimpleLinspaceFromParameters(len(amplitude), self.loader.run_parameters)
189  self.simplePlots.plotOneWithTwoAxes(x_values, amplitude)
190  self.simplePlots.plotOneWithTwoAxes(x_values, averages)
191  plt.errorbar(x_values, amplitude, yerr=errors)
192  plt.xscale('log')
193  if(not "-noplot" in sys.argv):
194  plt.show()
195  self.loader.saveArray(np.array([x_values, amplitude, errors, averages]), "amplitude_2")
196 
197  def calculateError(
198  self,
199  interval,
200  interval_average,
201  splits
202  ):
203  splitted_interval = np.split(interval, splits)
204  split_averages = np.average(splitted_interval, axis = 1)
205 
206  sigma = np.sqrt(np.average(np.power(split_averages-interval_average, 2)))
207  error = sigma/np.sqrt(splits)
208  print(sigma, interval_average, error)
209  return error
210 
211 
212 
213 
214 def run():
215  splitMultipleSpeedSegmentsFriction = SplitMultipleSpeedSegmentsFriction(sys.argv[1])
216 
217 
218 if __name__ == "__main__":
219  run()
def loadFile(run_name, shared_names, selected='pad_position.csv')