4 from matplotlib
import pyplot
as plt
7 import numpy.fft
as fft
12 from yaml
import CLoader
as Loader, CDumper
as Dumper
14 from yaml
import Loader, Dumper
20 numeric_method="_midpoint_",
30 self.
results_path = os.path.dirname(os.path.realpath(__file__)) +
"/../../../../results/" 36 results_folder =
"/results/" 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:]
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))
59 print(len(file_matrix))
68 results_folder =
"/results/" 80 print(
"Saving to path: ", file_path)
81 np.savetxt(file_path, array_or_matrix, delimiter=
',')
87 stream = open(self.
results_path + run_name +
"/doc/yaml/parameters.yaml",
'r') 96 stream = open(self.
results_path + run_name + file_name,
'r') 97 return yaml.load(stream, Loader = Loader)
104 stream = open(run_name + file_name,
'r') 105 return yaml.load(stream, Loader = Loader)
113 yaml.dump(self.
run_parameters, stream, default_flow_style =
False)
120 print(yaml.dump(yaml_element, default_flow_style =
False))
122 yaml.dump(yaml_element, stream, default_flow_style =
False)
142 if(os.path.isfile(self.
results_path + run_name + file_name)):
171 stop = self.
loader.getParameter(
"max_time")
172 return np.linspace(start = start, stop = stop, num = len(singleVector))
179 start = self.
loader.getParameter(
"slider_speed")
180 interval_increment = self.
loader.getParameter(
"increment")
181 stop = start + interval_increment * (intervals - 1)
182 print(
"slider intervals", start, stop, intervals)
183 return np.linspace(start = start, stop = stop, num = intervals)
190 plot_start_interval = None,
191 plot_end_interval = None
193 if((plot_start_interval
or plot_end_interval)
is None):
195 max_time = run_parameters[
"Parameters"][
"max_time"]
197 start = plot_start_interval
198 max_time = plot_end_interval
200 start_block_index = start/run_parameters[
"Parameters"][
"dt"]
201 max_time_block_index = max_time/run_parameters[
"Parameters"][
"dt"]
202 amount_data_points = max_time_block_index - start_block_index
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)
207 return {
'x_values': x,
'block_indexes': block_indexes}
214 amount_data_points = len(single_vector)
215 end_value = run_parameters[
"Parameters"][
"interval"]
216 start_value = end_value / 2
218 print(end_value, start_value)
220 x_values = np.linspace(start = start_value, stop = end_value, num = amount_data_points)
230 plt.plot(vector_values, label =
"plotOneWithOneAxis")
232 plt.plot(vector_values, np.linspace(0, len(vector_values), len(vector_values)), label =
"plotOneWithOneAxis")
234 raise Exception(
"invalid axis name given, please select \"x\" or \"y\" or leave empty.")
240 label = "plotOneWithTwoAxes"
242 plt.plot(x_values, y_values, label = label)
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))
262 return np.split(vector, max_number_of_intervals)
270 max_number_of_intervals = np.floor(matrix.shape[1]/interval_size)
272 if(max_number_of_intervals <= 0):
273 raise Exception(
"the interval is to big or negative: " + str(interval_size))
275 return np.split(matrix, max_number_of_intervals, axis=1)
281 return(int(np.ceil(len(vector)/2.0)))
289 index_amount = int(vector_length*(last_x_percent/100))
290 last_x_percent_index = (vector_length) - index_amount
292 return last_x_percent_index
305 half_point = int(0.5*len(data))
306 data = data[half_point:]
307 spectrum = fft.fft(data)
309 frequency = fft.fftfreq(len(spectrum))
311 threshold = 0.5 * max(abs(spectrum))
312 mask = abs(spectrum) > threshold
313 peaks = frequency[mask]
315 return_values = {
'Spectrum' : spectrum,
'Frequency' : frequency}
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 __init__(self, loader)
def intervalLinspaceFromParameters(self, singleVector, run_parameters, plot_start_interval=None, plot_end_interval=None)
TODO: Finish when needed, needs to return two elements.
def plot_fft_frequencies(data)
def __init__(self, loader)
def calculate_fft(self, data)
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 startSecondHalfIndex(self, vector)
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)