1 from frictionImports
import *
2 from makePhaseAnimationData
import calculateIntervalSize
6 sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) +
'/File')
7 from loadFromResults
import LoadFile, SimplePlots, VectorArrayHelper, MathHelper
13 numeric_method = "_midpoint_"
38 files = self.
loader.loadLastHalfParallelRun(
"pad_friction", file_name_speeds)
41 if(
"-brakeenergy" in sys.argv):
44 x_values = self.
simplePlots.intervalLinspaceParallelHalfRun(files[0], self.
loader.run_parameters)
47 amplitudes = amplitudes_and_errors[:,0]
48 errors = amplitudes_and_errors[:,1]
49 averages = amplitudes_and_errors[:,2]
51 print(
"Files longer than max files to be plotted: ", len(files) > max_files_plotted)
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])
58 if(
not "-noplot" in sys.argv):
63 plt.plot(file, x_values)
72 file_name_speeds = self.
simplePlots.sliderSpeedSimpleLinspaceFromParameters(len(friction_forces), self.
loader.run_parameters)
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:]
80 brake_energy = [np.sum(abs(friction_force*speed))
for friction_force, speed
in zip(friction_forces, file_name_speeds)]
81 friction_combined = np.concatenate(friction_forces)
82 pad_velocity_intervals_last_half_combined = np.concatenate(pad_velocity_intervals_last_half)
84 x_values_continous = np.linspace(start=file_name_speeds[0], stop=file_name_speeds[-1], num=len(friction_combined))
88 plt.ylim(-1000, 300000)
89 plt.plot(file_name_speeds, brake_energy, marker=
'x')
92 plt.plot(x_values_continous, friction_combined)
96 plt.plot(file_name_speeds, file_name_speeds)
102 general_name = "pad_friction"
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")
110 intervals = int(max_time / interval_size)
112 file_name_speeds = []
114 for i
in range(0, intervals):
115 current_slider_speed = np.round(slider_speed + slider_increment * i,4)
116 print(current_slider_speed)
119 return file_name_speeds
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
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
144 interval_size = int(self.
loader.run_parameters[
"Parameters"][
"interval"]/self.
loader.run_parameters[
"Parameters"][
"dt"])
151 for i
in range(0, len(splitted_values)):
152 half_of_values = splitted_values[i][half_index:]
154 amplitude = amplitude_and_error[0]
155 errors = amplitude_and_error[1]
166 plot_values_dictionary = self.
simplePlots.intervalLinspaceFromParameters(pad_property, self.
loader.run_parameters)
168 print(plot_values_dictionary[
'x_values'])
170 self.
simplePlots.plotOneWithTwoAxes(plot_values_dictionary[
'x_values'], pad_property)
177 interval_average = np.average(interval)
178 amplitude = np.sqrt(2)*np.sqrt(np.average(np.power(interval - interval_average,2)))
180 return np.array([amplitude, error, interval_average])
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)
193 if(
not "-noplot" in sys.argv):
195 self.
loader.saveArray(np.array([x_values, amplitude, errors, averages]),
"amplitude_2")
203 splitted_interval = np.split(interval, splits)
204 split_averages = np.average(splitted_interval, axis = 1)
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)
218 if __name__ ==
"__main__":
def addNecessaryZeroes(self, decimal_number)
def calculateIntervalSize(loader)
def __init__(self, run_name="", numeric_method="_midpoint_")
def calculateAmplitude(self, interval)
def numberOfDecimals(self, decimal_number)
def calculateError(self, interval, interval_average, splits)
def plotAmplitude(self, amplitude, errors, averages)
def parallelIncrementRun(self)
def generateFileNamesFromParameters(self, general_name="pad_friction")
def singleIncrementRun(self)
def loadFile(run_name, shared_names, selected='pad_position.csv')
def amplitudeForSplittedSingleRun(self)
def plotPadProperty(self, pad_property)
def brakeEnergy(self, friction_forces, file_name_speeds)