My Project
loadFromResults.py
Go to the documentation of this file.
1 import os
2 import sys
3 
4 from matplotlib import pyplot as plt
5 
6 import numpy as np
7 import numpy.fft as fft
8 
9 import yaml
10 
11 try:
12  from yaml import CLoader as Loader, CDumper as Dumper
13 except ImportError:
14  from yaml import Loader, Dumper
15 
16 class LoadFile:
17  def __init__(
18  self,
19  run_name="",
20  numeric_method="_midpoint_",
21  ):
22  self.run_name = run_name
23  self.numeric_method = numeric_method
24  self.setResultsPath()
25  self.loadYamlParameters(run_name)
26 
27  def setResultsPath(
28  self
29  ):
30  self.results_path = os.path.dirname(os.path.realpath(__file__)) + "/../../../../results/"
31 
32  def loadFile(
33  self,
34  file_description
35  ):
36  results_folder = "/results/"
37 
38  shared_names = self.getParameter("file_name")
39 
40  return np.loadtxt(self.results_path + self.run_name + results_folder + shared_names + self.numeric_method + file_description + ".csv", delimiter=",")
41 
43  self,
44  file_description,
45  file_names
46  ):
47  vectorArrayHelper = VectorArrayHelper()
48 
49  file_matrix = self.loadFile(file_description + file_names[0])
50  half_point_index = vectorArrayHelper.startSecondHalfIndex(file_matrix)
51  file_matrix = file_matrix[half_point_index:]
52 
53  for i in range(1, len(file_names)):
54  loaded_file = self.loadFile(file_description + file_names[i])
55  half_point_index = vectorArrayHelper.startSecondHalfIndex(loaded_file)
56  loaded_file = loaded_file[half_point_index:]
57  file_matrix = np.vstack((file_matrix, loaded_file))
58 
59  print(len(file_matrix))
60 
61  return(file_matrix)
62 
63  def saveArray(
64  self,
65  array_matrix,
66  file_description
67  ):
68  results_folder = "/results/"
69 
70  shared_names = self.getParameter("file_name")
71 
72  np.savetxt(self.results_path + self.run_name + results_folder + shared_names + self.numeric_method + file_description + ".csv", array_matrix, delimiter=",")
73 
74  def save_csv(
75  self,
76  file_name,
77  array_or_matrix
78  ):
79  file_path = self.results_path + self.run_name + file_name
80  print("Saving to path: ", file_path)
81  np.savetxt(file_path, array_or_matrix, delimiter=',')
82 
84  self,
85  run_name
86  ):
87  stream = open(self.results_path + run_name + "/doc/yaml/parameters.yaml", 'r')
88  self.run_parameters = yaml.load(stream, Loader = Loader)
89 
90 
91  def loadYaml(
92  self,
93  run_name,
94  file_name
95  ):
96  stream = open(self.results_path + run_name + file_name, 'r')
97  return yaml.load(stream, Loader = Loader)
98 
100  self,
101  run_name,
102  file_name
103  ):
104  stream = open(run_name + file_name, 'r')
105  return yaml.load(stream, Loader = Loader)
106 
108  self,
109  run_name
110  ):
111  print(yaml.dump(self.run_parameters, default_flow_style = False))
112  stream = open(self.results_path + self.run_name + "/doc/yaml/parameters.yaml", "w")
113  yaml.dump(self.run_parameters, stream, default_flow_style = False)
114 
115  def saveYaml(
116  self,
117  yaml_element,
118  file_name
119  ):
120  print(yaml.dump(yaml_element, default_flow_style = False))
121  stream = open(self.results_path + self.run_name + file_name, "w")
122  yaml.dump(yaml_element, stream, default_flow_style = False)
123 
124 
125  def getParameter(
126  self,
127  parameter_name
128  ):
129  return self.run_parameters["Parameters"][parameter_name]
130 
131  def getDebugParameter(
132  self,
133  debug_parameter_name
134  ):
135  return self.run_parameters["Debug"][debug_parameter_name]
136 
138  self,
139  run_name,
140  file_name = ""
141  ):
142  if(os.path.isfile(self.results_path + run_name + file_name)):
143  return True
144  else:
145  return False
146 
148  self,
149  dir_name
150  ):
151  if(os.path.isdir(self.results_path + self.run_name + dir_name)):
152  return True
153  else:
154  return False
155 
156 
158 
159  def __init__(
160  self,
161  loader
162  ):
163  self.loader = loader
164 
166  self,
167  singleVector,
168  run_parameters
169  ):
170  start = 0
171  stop = self.loader.getParameter("max_time")
172  return np.linspace(start = start, stop = stop, num = len(singleVector))
173 
175  self,
176  intervals,
177  run_parameters
178  ):
179  start = self.loader.getParameter("slider_speed")
180  interval_increment = self.loader.getParameter("increment")
181  stop = start + interval_increment * (intervals - 1) # not +1 now
182  print("slider intervals", start, stop, intervals)
183  return np.linspace(start = start, stop = stop, num = intervals)
184 
185 
187  self,
188  singleVector,
189  run_parameters,
190  plot_start_interval = None,
191  plot_end_interval = None
192  ):
193  if((plot_start_interval or plot_end_interval) is None):
194  start = 0
195  max_time = run_parameters["Parameters"]["max_time"]
196  else:
197  start = plot_start_interval
198  max_time = plot_end_interval
199 
200  start_block_index = start/run_parameters["Parameters"]["dt"]
201  max_time_block_index = max_time/run_parameters["Parameters"]["dt"] #(-1 removed)
202  amount_data_points = max_time_block_index - start_block_index
203 
204  x = np.linspace(start = start, stop = max_time, num = amount_data_points)
205  block_indexes = np.linspace(start = start_block_index, stop = max_time_block_index, num = max_time_block_index - start_block_index, dtype=int)
206 
207  return {'x_values': x, 'block_indexes': block_indexes}
208 
210  self,
211  single_vector,
212  run_parameters
213  ):
214  amount_data_points = len(single_vector)
215  end_value = run_parameters["Parameters"]["interval"]
216  start_value = end_value / 2
217 
218  print(end_value, start_value)
219 
220  x_values = np.linspace(start = start_value, stop = end_value, num = amount_data_points)
221 
222  return x_values
223 
224  def plotOneWithOneAxis(
225  self,
226  vector_values,
227  axis = "y"
228  ):
229  if(axis == "y"):
230  plt.plot(vector_values, label = "plotOneWithOneAxis")
231  elif(axis == "x"):
232  plt.plot(vector_values, np.linspace(0, len(vector_values), len(vector_values)), label = "plotOneWithOneAxis")
233  else:
234  raise Exception("invalid axis name given, please select \"x\" or \"y\" or leave empty.")
235 
236  def plotOneWithTwoAxes(
237  self,
238  x_values,
239  y_values,
240  label = "plotOneWithTwoAxes"
241  ):
242  plt.plot(x_values, y_values, label = label)
243 
245  self,
246  fft_results
247  ):
248  self.plotOneWithTwoAxes(fft_results['Frequency'], fft_results['Spectrum'])
249  plt.show()
250 
253  self,
254  vector,
255  interval_size
256  ):
257  print(len(vector), interval_size)
258  max_number_of_intervals = np.floor(len(vector)/interval_size)
259  if(max_number_of_intervals <= 0):
260  raise Exception("the interval is to big or negative: " + str(interval_size))
261 
262  return np.split(vector, max_number_of_intervals)
263 
265  self,
266  matrix,
267  interval_size
268  ):
269  #np.spit returns list of subarrays
270  max_number_of_intervals = np.floor(matrix.shape[1]/interval_size)
271 
272  if(max_number_of_intervals <= 0):
273  raise Exception("the interval is to big or negative: " + str(interval_size))
274 
275  return np.split(matrix, max_number_of_intervals, axis=1)
276 
278  self,
279  vector
280  ):
281  return(int(np.ceil(len(vector)/2.0)))
282 
283  def lastXPercentIndex(
284  self,
285  last_x_percent,
286  vector_length
287  ):
288  #zero-indexation in python, keep in mind
289  index_amount = int(vector_length*(last_x_percent/100))
290  last_x_percent_index = (vector_length) - index_amount
291 
292  return last_x_percent_index
293 
295  def __init__(
296  self,
297  loader
298  ):
299  self.simplePlots = SimplePlots(loader)
300 
301  def calculate_fft(
302  self,
303  data
304  ):
305  half_point = int(0.5*len(data))
306  data = data[half_point:]
307  spectrum = fft.fft(data)
308 
309  frequency = fft.fftfreq(len(spectrum))
310 
311  threshold = 0.5 * max(abs(spectrum))
312  mask = abs(spectrum) > threshold
313  peaks = frequency[mask]
314  print(peaks)
315  return_values = {'Spectrum' : spectrum, 'Frequency' : frequency}
316  self.simplePlots.plot_fft_frequencies(return_values)
317 
318  return return_values
def splitNumpyVectorToMatrix(self, vector, interval_size)
def lastXPercentIndex(self, last_x_percent, vector_length)
def loadLastHalfParallelRun(self, file_description, file_names)
def loadYamlParameters(self, run_name)
def intervalLinspaceFromParameters(self, singleVector, run_parameters, plot_start_interval=None, plot_end_interval=None)
TODO: Finish when needed, needs to return two elements.
def __init__(self, loader)
def plot_fft_frequencies(self, fft_results)
def getDebugParameter(self, debug_parameter_name)
def loadYaml(self, run_name, file_name)
def loadYamlStandAlone(self, run_name, file_name)
def check_if_file_exist_in_run_folder(self, run_name, file_name="")
def save_csv(self, file_name, array_or_matrix)
def saveYaml(self, yaml_element, file_name)
def __init__(self, run_name="", numeric_method="_midpoint_")
def save_yaml_parameters(self, run_name)
def intervalLinspaceParallelHalfRun(self, single_vector, run_parameters)
def loadFile(self, file_description)
def check_if_dir_exist_in_run_folder(self, dir_name)
def plotOneWithOneAxis(self, vector_values, axis="y")
def plotOneWithTwoAxes(self, x_values, y_values, label="plotOneWithTwoAxes")
def getParameter(self, parameter_name)
def timeSimpleLinspaceFromParameters(self, singleVector, run_parameters)
def sliderSpeedSimpleLinspaceFromParameters(self, intervals, run_parameters)
def splitNumpy2DMatrixTo3DMatrix(self, matrix, interval_size)
def saveArray(self, array_matrix, file_description)