Skip to content
Snippets Groups Projects
Commit 21d8e2a2 authored by Christoph von Oy's avatar Christoph von Oy
Browse files

Fixes and names

parent 0581dc55
No related branches found
No related tags found
No related merge requests found
......@@ -33,7 +33,7 @@ import pyomo.environ as pyo
# represents a continuus set of time steps relative to the global simulation start t_start
class Dynamic:
# returns the root dynamic of this dynamic
def get_root_dynamic(self):
def root(self):
pass
# return true if other is an ancestor of this dynamic
......@@ -55,22 +55,22 @@ class Dynamic:
# returns the indices between the given start and end positions
# p_start and p_end are relative to this dynamic
def get_indices_within_p(self, p_start, p_end):
def indices_within_p(self, p_start, p_end):
pass
# returns the indices between the given start and end indices
# i_start and i_end are relative to the root dynamic
def get_indices_within(self, i_start, i_end):
def indices_within(self, i_start, i_end):
pass
# returns the index of the given position
# position is relative to this dynamic
def get_index_of(self, position):
def index_of(self, position):
pass
# returns the position of the given index
# index is relative to the root dynamic
def get_position_of(self, index):
def position_of(self, index):
pass
# returns the length of the time step at the given position
......@@ -89,28 +89,28 @@ class Dynamic:
# constructs a sub dynamic containing time steps starting at the time steps at the given positions with the last position representing the end of the last time step
# positions are relative to this dynamic
def get_sub_dynamic_p(self, positions):
def sub_dynamic_p(self, positions):
pass
# constructs a sub dynamic containing time steps starting at the time steps at the given indices with the last index representing the end of the last time step
# indices are relative to the root dynamic
def get_sub_dynamic(self, indices):
def sub_dynamic(self, indices):
pass
# construct a sub dynamic containing time steps between the given positions
# p_start and p_end are relative to the root dynamic
def get_partial_dynamic_p(self, p_start, p_end):
# p_start and p_end are relative to this dynamic
def partial_dynamic_p(self, p_start, p_end):
pass
# construct a sub dynamic containing time steps between the given indices
# i_start and i_end are relative to the root dynamic
def get_partial_dynamic(self, i_start, i_end):
def partial_dynamic(self, i_start, i_end):
pass
def to_string(self):
to_print = "["
for p in range(self.number_of_steps()):
to_print += "(" + str(self.get_index_of(p)) + ", " + str(self.step_size_p(p)) + ")"
to_print += "(" + str(self.index_of(p)) + ", " + str(self.step_size_p(p)) + ")"
if p != self.number_of_steps() - 1:
to_print += ", "
to_print += "]"
......@@ -122,7 +122,7 @@ class TrivialDynamic(Dynamic):
def __init__(self, d_steps):
self.d_steps = d_steps
def get_root_dynamic(self):
def root(self):
return self
def has_ancestor(self, other):
......@@ -137,16 +137,16 @@ class TrivialDynamic(Dynamic):
def has_index(self, index):
return 0 <= index and index <= len(self.d_steps)
def get_indices_within_p(self, p_start, p_end):
def indices_within_p(self, p_start, p_end):
return pd.RangeIndex(p_start, p_end)
def get_indices_within(self, i_start, i_end):
def indices_within(self, i_start, i_end):
return pd.RangeIndex(i_start, i_end)
def get_index_of(self, position):
def index_of(self, position):
return position
def get_position_of(self, index):
def position_of(self, index):
return index
def step_size_p(self, position):
......@@ -158,16 +158,16 @@ class TrivialDynamic(Dynamic):
def step_sizes(self):
return self.d_steps
def get_sub_dynamic_p(self, positions):
def sub_dynamic_p(self, positions):
return BackedDynamic(self, positions)
def get_sub_dynamic(self, indices):
def sub_dynamic(self, indices):
return BackedDynamic(self, indices)
def get_partial_dynamic_p(self, p_start, p_end):
def partial_dynamic_p(self, p_start, p_end):
return PartialDynamic(self, p_start, p_end)
def get_partial_dynamic(self, i_start, i_end):
def partial_dynamic(self, i_start, i_end):
return PartialDynamic(self, i_start, i_end)
# a dynamic definied by taking certain time steps form a reference dynamic
......@@ -179,8 +179,8 @@ class BackedDynamic(Dynamic):
self.reference = reference
self.indices = indices
def get_root_dynamic(self):
return self.reference.get_root_dynamic()
def root(self):
return self.reference.root()
def has_ancestor(self, other):
return self == other or self.reference.has_ancestor(other)
......@@ -194,22 +194,22 @@ class BackedDynamic(Dynamic):
def has_index(self, index):
return index in self.indices
def get_indices_within_p(self, p_start, p_end):
def indices_within_p(self, p_start, p_end):
if p_start < 0 or len(self.indices) <= p_start or p_end < 0 or len(self.indices) <= p_end:
raise IndexError("The dynamic does not have indices at the positions!")
return self.indices[p_start:p_end]
def get_indices_within(self, i_start, i_end):
p_start = self.get_position_of(i_start)
p_end = self.get_position_of(i_end)
def indices_within(self, i_start, i_end):
p_start = self.position_of(i_start)
p_end = self.position_of(i_end)
return self.indices[p_start:p_end]
def get_index_of(self, position):
def index_of(self, position):
if position < 0 or len(self.indices) <= position:
raise IndexError("The dynamic does not have a index for this position!")
return self.indices[position]
def get_position_of(self, index):
def position_of(self, index):
if index not in self.indices:
raise IndexError('The dynamic does not have a position for this index!')
return self.indices.index(index)
......@@ -217,7 +217,7 @@ class BackedDynamic(Dynamic):
def step_size_p(self, position):
if position < 0 or len(self.indices) - 1 <= position:
raise IndexError("The dynamic does not have a time step at this position!")
return sum(self.reference.step_size(index) for index in self.reference.get_indices_within(self.indices[position], self.indices[position + 1]))
return sum(self.reference.step_size(index) for index in self.reference.indices_within(self.indices[position], self.indices[position + 1]))
def step_size(self, index):
if index not in self.indices[:-1]:
......@@ -227,22 +227,22 @@ class BackedDynamic(Dynamic):
def step_sizes(self):
return [self.step_size_p(position) for position in range(self.number_of_steps())]
def get_sub_dynamic_p(self, positions):
def sub_dynamic_p(self, positions):
if any(position < 0 or len(self.indices) <= position for position in positions):
raise IndexError("The dynamic does not have all requested indices!")
return BackedDynamic(self.reference, [self.indices[position] for position in positions])
def get_sub_dynamic(self, indices):
def sub_dynamic(self, indices):
if any(index not in self.indices for index in indices):
raise IndexError("The dynamic does not have all requested indices for the sub dynamic!")
return BackedDynamic(self.reference, indices)
def get_partial_dynamic_p(self, p_start, p_end):
if p_start < 0 or len(self.indices) - 1 <= p_start or p_end < 0 or len(self.indices) - 1 <= p_end:
def partial_dynamic_p(self, p_start, p_end):
if p_start < 0 or len(self.indices) <= p_start or p_end < 0 or len(self.indices) <= p_end:
raise IndexError("The dynamic does not have all requested positions for the sub dynamic!")
return PartialDynamic(self, p_start, p_end)
def get_partial_dynamic(self, i_start, i_end):
def partial_dynamic(self, i_start, i_end):
if i_start not in self.indices or i_end not in self.indices:
raise IndexError("The dynamic does not have all requested indices for the sub dynamic!")
return PartialDynamic(self, self.indices.index(i_start), self.indices.index(i_end))
......@@ -258,8 +258,8 @@ class PartialDynamic(Dynamic):
self.start = start
self.end = end
def get_root_dynamic(self):
return self.reference.get_root_dynamic()
def root(self):
return self.reference.root()
def has_ancestor(self, other):
return self == other or self.reference.has_ancestor(other)
......@@ -271,28 +271,30 @@ class PartialDynamic(Dynamic):
return self.reference.time_steps()[self.start:self.end]
def has_index(self, index):
reference_position = self.reference.get_position_of(index)
return self.start <= reference_position or reference_position <= self.end
if self.reference.has_index(index):
reference_position = self.reference.position_of(index)
return self.start <= reference_position and reference_position <= self.end
return False
def get_indices_within_p(self, p_start, p_end):
def indices_within_p(self, p_start, p_end):
if p_start < self.start or self.end < p_start or p_end < self.start or self.end < p_end:
raise IndexError("The dynamic does not have all requested indices!")
return self.reference.get_indices_within_p(self.start + p_start, self.start + p_end)
return self.reference.indices_within_p(self.start + p_start, self.start + p_end)
def get_indices_within(self, i_start, i_end):
p_start = self.reference.get_position_of(i_start)
p_end = self.reference.get_position_of(i_end)
def indices_within(self, i_start, i_end):
p_start = self.reference.position_of(i_start)
p_end = self.reference.position_of(i_end)
if p_start < self.start or self.end < p_start or p_end < self.start or self.end < p_end:
raise IndexError("The dynamic does not have all requested indices!")
return self.reference.get_indices_within_p(self.start + p_start, self.start + p_end)
return self.reference.indices_within_p(self.start + p_start, self.start + p_end)
def get_index_of(self, position):
def index_of(self, position):
if position < 0 or self.end - self.start < position:
raise IndexError("The dynamic does not have a index for this position!")
return self.reference.get_index_of(self.start + position)
return self.reference.index_of(self.start + position)
def get_position_of(self, index):
reference_position = self.reference.get_position_of(index)
def position_of(self, index):
reference_position = self.reference.position_of(index)
if reference_position < self.start or self.end < reference_position:
raise IndexError('The dynamic does not have a position for this index!')
return reference_position - self.start
......@@ -303,7 +305,7 @@ class PartialDynamic(Dynamic):
return self.reference.step_size_p(self.start + position)
def step_size(self, index):
reference_position = self.reference.get_position_of(index)
reference_position = self.reference.position_of(index)
if reference_position < self.start or self.end <= reference_position:
raise IndexError('The dynamic does not have a time step at this index!')
return self.step_size_p(reference_position - self.start)
......@@ -311,27 +313,27 @@ class PartialDynamic(Dynamic):
def step_sizes(self):
return [self.reference.step_size_p(position) for position in range(self.start, self.end)]
def get_sub_dynamic_p(self, positions):
def sub_dynamic_p(self, positions):
if any(position < 0 or self.end - self.start < position for position in positions):
raise IndexError("The dynamic does not have all requested positions for the sub dynamic!")
return self.reference.get_sub_dynamic_p([self.start + position for position in positions])
return self.reference.sub_dynamic_p([self.start + position for position in positions])
def get_sub_dynamic(self, indices):
def filter(self, index):
reference_position = self.reference.get_position_of(index)
def sub_dynamic(self, indices):
def filter(index):
reference_position = self.reference.position_of(index)
return reference_position < self.start or self.end < reference_position
if any(filter(index) for index in indices):
raise IndexError("The does not have all requested indices for the sub dynamic!")
return self.reference.get_sub_dynamic(indices)
return self.reference.sub_dynamic(indices)
def get_partial_dynamic_p(self, p_start, p_end):
def partial_dynamic_p(self, p_start, p_end):
if p_start < 0 or self.end - self.start < p_start or p_end < 0 or self.end - self.start < p_end:
raise IndexError("The dynamic does not have all requested positions for the sub dynamic!")
return PartialDynamic(self.reference, self.start + p_start, self.start + p_end)
def get_partial_dynamic(self, i_start, i_end):
reference_start = self.reference.get_position_of(i_start)
reference_end = self.reference.get_position_of(i_end)
def partial_dynamic(self, i_start, i_end):
reference_start = self.reference.position_of(i_start)
reference_end = self.reference.position_of(i_end)
if reference_start < self.start or self.end < reference_start or reference_end < self.start or self.end < reference_end:
raise IndexError("The dynamic does not have all requested indices for the sub dynamic!")
return PartialDynamic(self.reference, reference_start, reference_end)
......@@ -351,20 +353,20 @@ class Profile:
# only works if both dynamics share the same root dynamic
def resample(values, dynamic, target_dynamic):
if dynamic.get_root_dynamic() != target_dynamic.get_root_dynamic():
if dynamic.root() != target_dynamic.root():
raise ValueError("Both dynamics have to have the same root dynamic!")
if target_dynamic.get_index_of(0) < dynamic.get_index_of(0) or dynamic.get_index_of(dynamic.number_of_steps()) < target_dynamic.get_index_of(target_dynamic.number_of_steps()):
if target_dynamic.index_of(0) < dynamic.index_of(0) or dynamic.index_of(dynamic.number_of_steps()) < target_dynamic.index_of(target_dynamic.number_of_steps()):
raise ValueError("The source dynamic does not cover the time steps contained in target_dynamic!")
non_partial_dynamic = dynamic
while isinstance(non_partial_dynamic, PartialDynamic):
non_partial_dynamic = non_partial_dynamic.reference
source_p_start = non_partial_dynamic.get_position_of(dynamic.get_index_of(0))
source_p_end = non_partial_dynamic.get_position_of(dynamic.get_index_of(dynamic.number_of_steps()))
source_p_start = non_partial_dynamic.position_of(dynamic.index_of(0))
source_p_end = non_partial_dynamic.position_of(dynamic.index_of(dynamic.number_of_steps()))
non_partial_target_dynamic = target_dynamic
while isinstance(non_partial_target_dynamic, PartialDynamic):
non_partial_target_dynamic = non_partial_target_dynamic.reference
target_p_start = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(0))
target_p_end = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(target_dynamic.number_of_steps()))
target_p_start = non_partial_target_dynamic.position_of(target_dynamic.index_of(0))
target_p_end = non_partial_target_dynamic.position_of(target_dynamic.index_of(target_dynamic.number_of_steps()))
if non_partial_dynamic == non_partial_target_dynamic:
return resample_same(values, non_partial_dynamic, source_p_start, source_p_end, non_partial_target_dynamic, target_p_start, target_p_end)
elif isinstance(non_partial_target_dynamic, BackedDynamic) and non_partial_target_dynamic.has_ancestor(non_partial_dynamic):
......@@ -375,18 +377,18 @@ def resample(values, dynamic, target_dynamic):
return resample_common_reference(values, non_partial_dynamic, source_p_start, source_p_end, non_partial_target_dynamic, target_p_start, target_p_end)
def resample_into(values, dynamic, target_dynamic, target_values):
if dynamic.get_root_dynamic() != target_dynamic.get_root_dynamic():
if dynamic.root() != target_dynamic.root():
raise ValueError("Both dynamics have to have the same root dynamic!")
non_partial_dynamic = dynamic
while isinstance(non_partial_dynamic, PartialDynamic):
non_partial_dynamic = non_partial_dynamic.reference
source_p_start = non_partial_dynamic.get_position_of(dynamic.get_index_of(0))
source_p_end = non_partial_dynamic.get_position_of(dynamic.get_index_of(dynamic.number_of_steps()))
source_p_start = non_partial_dynamic.position_of(dynamic.index_of(0))
source_p_end = non_partial_dynamic.position_of(dynamic.index_of(dynamic.number_of_steps()))
non_partial_target_dynamic = target_dynamic
while isinstance(non_partial_target_dynamic, PartialDynamic):
non_partial_target_dynamic = non_partial_target_dynamic.reference
target_p_start = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(0))
target_p_end = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(target_dynamic.number_of_steps()))
target_p_start = non_partial_target_dynamic.position_of(target_dynamic.index_of(0))
target_p_end = non_partial_target_dynamic.position_of(target_dynamic.index_of(target_dynamic.number_of_steps()))
if non_partial_dynamic == non_partial_target_dynamic:
return resample_into_same(values, non_partial_dynamic, source_p_start, source_p_end, non_partial_target_dynamic, target_p_start, target_p_end, target_values)
elif isinstance(non_partial_target_dynamic, BackedDynamic) and non_partial_target_dynamic.has_ancestor(non_partial_dynamic):
......@@ -398,16 +400,16 @@ def resample_into(values, dynamic, target_dynamic, target_values):
# source_dynamic and target_dynamic are the same dynamic
def resample_same(values, dynamic, source_p_start, source_p_end, target_dnymiac, target_p_start, target_p_end):
return values.loc[target_dnymiac.get_indices_within_p(target_p_start, target_p_end)]
return values.loc[target_dnymiac.indices_within_p(target_p_start, target_p_end)]
def resample_into_same(values, dynamic, source_p_start, source_p_end, target_dnymiac, target_p_start, target_p_end, target_values):
i_start = max(dynamic.get_index_of(source_p_start), target_dnymiac.get_index_of(target_p_start))
i_end = min(dynamic.get_index_of(source_p_end), target_dnymiac.get_index_of(target_p_end))
temp_values = values.loc[dynamic.get_indices_within(i_start, i_end)]
if i_start == target_dnymiac.get_index_of(target_p_start) and i_end == target_dnymiac.get_index_of(target_p_end):
i_start = max(dynamic.index_of(source_p_start), target_dnymiac.index_of(target_p_start))
i_end = min(dynamic.index_of(source_p_end), target_dnymiac.index_of(target_p_end))
temp_values = values.loc[dynamic.indices_within(i_start, i_end)]
if i_start == target_dnymiac.index_of(target_p_start) and i_end == target_dnymiac.index_of(target_p_end):
target_values.loc[:] = temp_values
else:
target_values.loc[target_dnymiac.get_indices_within(i_start, i_end)] = temp_values
target_values.loc[target_dnymiac.indices_within(i_start, i_end)] = temp_values
return target_values
# target_dynamic is BackedDynamic and has dynamic as an ancestor
......@@ -415,122 +417,122 @@ def resample_to_backed(values, dynamic, source_p_start, source_p_end, target_dyn
target_values = values.loc[target_dynamic.indices[target_p_start:target_p_end]]
for target_position in range(target_p_start, target_p_end):
acc = 0
for source_index in dynamic.get_indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
for source_index in dynamic.indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
acc += values.loc[source_index] * dynamic.step_size(source_index)
target_values.loc[target_dynamic.indices[target_position]] = acc / target_dynamic.step_size_p(target_position)
return target_values
def resample_into_to_backed(values, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_values):
source_i_start = dynamic.get_index_of(source_p_start)
source_i_start = dynamic.index_of(source_p_start)
target_i_start = target_dynamic.indices[target_p_start]
if source_i_start == target_i_start:
target_p_start = target_dynamic.get_position_of(source_i_start)
target_p_start = target_dynamic.position_of(source_i_start)
# elif source_i_start < target_i_start: # target_p_start assigned here is the same as the input target_p_start so skip this branch
# target_p_start = target_dynamic.get_position_of(target_i_start)
# target_p_start = target_dynamic.position_of(target_i_start)
elif source_i_start > target_i_start:
while source_i_start not in target_dynamic.indices:
source_p_start += 1
source_i_start = dynamic.get_index_of(source_p_start)
target_p_start = target_dynamic.get_position_of(source_i_start)
source_i_end = dynamic.get_index_of(source_p_end)
source_i_start = dynamic.index_of(source_p_start)
target_p_start = target_dynamic.position_of(source_i_start)
source_i_end = dynamic.index_of(source_p_end)
target_i_end = target_dynamic.indices[target_p_end]
if source_i_end == target_i_end:
target_p_end = target_dynamic.get_position_of(source_i_end)
target_p_end = target_dynamic.position_of(source_i_end)
# elif source_i_end > target_i_end: # target_p_end assigned here is the same as the input target_p_end so skip this branch
# target_p_end = target_dynamic.get_position_of(target_i_end)
# target_p_end = target_dynamic.position_of(target_i_end)
elif source_i_end < target_i_end:
while source_i_end not in target_dynamic.indices:
source_p_end -= 1
source_i_end = dynamic.get_index_of(source_p_end)
target_p_end = target_dynamic.get_position_of(source_i_end)
source_i_end = dynamic.index_of(source_p_end)
target_p_end = target_dynamic.position_of(source_i_end)
for target_position in range(target_p_start, target_p_end):
acc = 0
for source_index in dynamic.get_indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
for source_index in dynamic.indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
acc += values.loc[source_index] * dynamic.step_size(source_index)
target_values.loc[target_dynamic.indices[target_position]] = acc / target_dynamic.step_size_p(target_position)
return target_values
# dynamic is BackedDynamic and has target_dynamic as an ancestor
def resample_from_backed(values, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end):
target_values = pd.Series(dtype = values.dtype, index = (target_dynamic.get_index_of(position) for position in range(target_p_start, target_p_end)))
target_values = pd.Series(dtype = values.dtype, index = (target_dynamic.index_of(position) for position in range(target_p_start, target_p_end)))
source_i_start = dynamic.indices[source_p_start]
target_i_start = target_dynamic.get_index_of(target_p_start)
target_i_start = target_dynamic.index_of(target_p_start)
if source_i_start < target_i_start:
if target_i_start not in dynamic.indices:
target_p_start_succ = target_p_start + 1
target_i_start_succ = target_dynamic.get_index_of(target_p_start_succ)
target_i_start_succ = target_dynamic.index_of(target_p_start_succ)
while target_i_start_succ not in dynamic.indices:
target_p_start_succ += 1
target_i_start_succ = target_dynamic.get_index_of(target_p_start_succ)
source_p_start = dynamic.get_position_of(target_i_start_succ)
target_indices = target_dynamic.get_indices_within(target_i_start, target_i_start_succ)
target_i_start_succ = target_dynamic.index_of(target_p_start_succ)
source_p_start = dynamic.position_of(target_i_start_succ)
target_indices = target_dynamic.indices_within(target_i_start, target_i_start_succ)
target_values.loc[target_indices] = values[dynamic.indices[source_p_start - 1]]
else:
source_p_start = dynamic.get_position_of(target_i_start)
source_p_start = dynamic.position_of(target_i_start)
source_i_end = dynamic.indices[source_p_end]
target_i_end = target_dynamic.get_index_of(target_p_end)
target_i_end = target_dynamic.index_of(target_p_end)
if target_i_end < source_i_end:
if target_i_end not in dynamic.indices:
target_p_end_prev = target_p_end - 1
target_i_end_prev = target_dynamic.get_index_of(target_p_end_prev)
target_i_end_prev = target_dynamic.index_of(target_p_end_prev)
while target_i_end_prev not in dynamic.indices:
target_p_end_prev -= 1
target_i_end_prev = target_dynamic.get_index_of(target_p_end_prev)
source_p_end = dynamic.get_position_of(target_i_end_prev)
target_indices = target_dynamic.get_indices_within(target_i_end_prev, target_i_end)
target_i_end_prev = target_dynamic.index_of(target_p_end_prev)
source_p_end = dynamic.position_of(target_i_end_prev)
target_indices = target_dynamic.indices_within(target_i_end_prev, target_i_end)
target_values.loc[target_indices] = values[dynamic.indices[source_p_end]]
else:
source_p_end = dynamic.get_position_of(target_i_end)
source_p_end = dynamic.position_of(target_i_end)
for source_position in range(source_p_start, source_p_end):
target_indices = target_dynamic.get_indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
target_indices = target_dynamic.indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
target_values.loc[target_indices] = values[dynamic.indices[source_position]]
return target_values
def resample_into_from_backed(values, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_values):
source_i_start = dynamic.indices[source_p_start]
target_i_start = target_dynamic.get_index_of(target_p_start)
target_i_start = target_dynamic.index_of(target_p_start)
if source_i_start < target_i_start:
if target_i_start not in dynamic.indices:
target_p_start_succ = target_p_start + 1
target_i_start_succ = target_dynamic.get_index_of(target_p_start_succ)
target_i_start_succ = target_dynamic.index_of(target_p_start_succ)
while target_i_start_succ not in dynamic.indices:
target_p_start_succ += 1
target_i_start_succ = target_dynamic.get_index_of(target_p_start_succ)
source_p_start = dynamic.get_position_of(target_i_start_succ)
target_indices = target_dynamic.get_indices_within(target_i_start, target_i_start_succ)
target_i_start_succ = target_dynamic.index_of(target_p_start_succ)
source_p_start = dynamic.position_of(target_i_start_succ)
target_indices = target_dynamic.indices_within(target_i_start, target_i_start_succ)
target_values.loc[target_indices] = values[dynamic.indices[source_p_start - 1]]
else:
source_p_start = dynamic.get_position_of(target_i_start)
source_p_start = dynamic.position_of(target_i_start)
source_i_end = dynamic.indices[source_p_end]
target_i_end = target_dynamic.get_index_of(target_p_end)
target_i_end = target_dynamic.index_of(target_p_end)
if target_i_end < source_i_end:
if target_i_end not in dynamic.indices:
target_p_end_prev = target_p_end - 1
target_i_end_prev = target_dynamic.get_index_of(target_p_end_prev)
target_i_end_prev = target_dynamic.index_of(target_p_end_prev)
while target_i_end_prev not in dynamic.indices:
target_p_end_prev -= 1
target_i_end_prev = target_dynamic.get_index_of(target_p_end_prev)
source_p_end = dynamic.get_position_of(target_i_end_prev)
target_indices = target_dynamic.get_indices_within(target_i_end_prev, target_i_end)
target_i_end_prev = target_dynamic.index_of(target_p_end_prev)
source_p_end = dynamic.position_of(target_i_end_prev)
target_indices = target_dynamic.indices_within(target_i_end_prev, target_i_end)
target_values.loc[target_indices] = values[dynamic.indices[source_p_end]]
for source_position in range(source_p_start, source_p_end):
target_indices = target_dynamic.get_indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
target_indices = target_dynamic.indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
target_values.loc[target_indices] = values[dynamic.indices[source_position]]
return target_values
# dynamic and target_dynamic share the same root dynamic
def resample_common_reference(values, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end):
target_values = pd.Series(dtype = values.dtype, index = (target_dynamic.get_index_of(position) for position in range(target_p_start, target_p_end)))
target_i_start = target_dynamic.get_index_of(target_p_start)
root_dynamic = dynamic.get_root_dynamic()
root_p_start = root_dynamic.get_position_of(target_i_start)
target_values = pd.Series(dtype = values.dtype, index = (target_dynamic.index_of(position) for position in range(target_p_start, target_p_end)))
target_i_start = target_dynamic.index_of(target_p_start)
root_dynamic = dynamic.root()
root_p_start = root_dynamic.position_of(target_i_start)
root_i_start = target_i_start
length = 0
while not dynamic.has_index(root_i_start):
root_p_start -= 1
root_i_start = root_dynamic.get_index_of(root_p_start)
root_i_start = root_dynamic.index_of(root_p_start)
length += root_dynamic.step_size(root_i_start)
source_position = dynamic.get_position_of(root_i_start)
source_position = dynamic.position_of(root_i_start)
target_position = target_p_start
remaining_length = dynamic.step_size_p(source_position) - length
while target_position < target_p_end:
......@@ -541,41 +543,41 @@ def resample_common_reference(values, dynamic, source_p_start, source_p_end, tar
source_position += 1
remaining_length = dynamic.step_size_p(source_position)
if remaining_target_length <= remaining_length:
acc += values[dynamic.get_index_of(source_position)] * remaining_target_length
acc += values[dynamic.index_of(source_position)] * remaining_target_length
remaining_length -= remaining_target_length
remaining_target_length -= remaining_target_length
else:
acc += values[dynamic.get_index_of(source_position)] * remaining_length
acc += values[dynamic.index_of(source_position)] * remaining_length
remaining_target_length -= remaining_length
remaining_length -= remaining_length
target_values[target_dynamic.get_index_of(target_position)] = acc / target_dynamic.step_size_p(target_position)
target_values[target_dynamic.index_of(target_position)] = acc / target_dynamic.step_size_p(target_position)
target_position += 1
return target_values
def resample_into_common_reference(values, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_values):
source_i_start = dynamic.get_index_of(source_p_start)
target_i_start = target_dynamic.get_index_of(target_p_start)
source_i_start = dynamic.index_of(source_p_start)
target_i_start = target_dynamic.index_of(target_p_start)
if source_i_start > target_i_start:
root_dynamic = dynamic.get_root_dynamic()
root_p_start = root_dynamic.get_position_of(source_i_start)
root_dynamic = dynamic.root()
root_p_start = root_dynamic.position_of(source_i_start)
root_i_start = source_i_start
length = 0
while not target_dynamic.has_index(root_i_start):
length += root_dynamic.step_size(root_i_start)
root_p_start += 1
root_i_start = root_dynamic.get_index_of(root_p_start)
root_i_start = root_dynamic.index_of(root_p_start)
source_position = source_p_start
target_position = target_dynamic.get_position_of(root_i_start)
target_position = target_dynamic.position_of(root_i_start)
else:
root_dynamic = dynamic.get_root_dynamic()
root_p_start = root_dynamic.get_position_of(target_i_start)
root_dynamic = dynamic.root()
root_p_start = root_dynamic.position_of(target_i_start)
root_i_start = target_i_start
length = 0
while not dynamic.has_index(root_i_start):
root_p_start -= 1
root_i_start = root_dynamic.get_index_of(root_p_start)
root_i_start = root_dynamic.index_of(root_p_start)
length += root_dynamic.step_size(root_i_start)
source_position = dynamic.get_position_of(root_i_start)
source_position = dynamic.position_of(root_i_start)
target_position = target_p_start
remaining_length = dynamic.step_size_p(source_position) - length
while target_position < target_p_end:
......@@ -588,33 +590,33 @@ def resample_into_common_reference(values, dynamic, source_p_start, source_p_end
return target_values
remaining_length = dynamic.step_size_p(source_position)
if remaining_target_length <= remaining_length:
acc += values[dynamic.get_index_of(source_position)] * remaining_target_length
acc += values[dynamic.index_of(source_position)] * remaining_target_length
remaining_length -= remaining_target_length
remaining_target_length -= remaining_target_length
else:
acc += values[dynamic.get_index_of(source_position)] * remaining_length
acc += values[dynamic.index_of(source_position)] * remaining_length
remaining_target_length -= remaining_length
remaining_length -= remaining_length
target_values[target_dynamic.get_index_of(target_position)] = acc / target_dynamic.step_size_p(target_position)
target_values[target_dynamic.index_of(target_position)] = acc / target_dynamic.step_size_p(target_position)
target_position += 1
return target_values
# only works if both dynamics share the same root dynamic
def resample_variable(variable, dynamic, target_dynamic, target_set):
if dynamic.get_root_dynamic() != target_dynamic.get_root_dynamic():
if dynamic.root() != target_dynamic.root():
raise ValueError("Both dynamics have to have the same root dynamic!")
if target_dynamic.get_index_of(0) != dynamic.get_index_of(0) or dynamic.get_index_of(dynamic.number_of_steps()) != target_dynamic.get_index_of(target_dynamic.number_of_steps()):
if not dynamic.has_index(target_dynamic.index_of(0)) or not dynamic.has_index(target_dynamic.index_of(target_dynamic.number_of_steps())):
raise ValueError("The source and target dynamic has to cover the same interval of time!")
non_partial_dynamic = dynamic
while isinstance(non_partial_dynamic, PartialDynamic):
non_partial_dynamic = non_partial_dynamic.reference
source_p_start = non_partial_dynamic.get_position_of(dynamic.get_index_of(0))
source_p_end = non_partial_dynamic.get_position_of(dynamic.get_index_of(dynamic.number_of_steps()))
source_p_start = non_partial_dynamic.position_of(dynamic.index_of(0))
source_p_end = non_partial_dynamic.position_of(dynamic.index_of(dynamic.number_of_steps()))
non_partial_target_dynamic = target_dynamic
while isinstance(non_partial_target_dynamic, PartialDynamic):
non_partial_target_dynamic = non_partial_target_dynamic.reference
target_p_start = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(0))
target_p_end = non_partial_target_dynamic.get_position_of(target_dynamic.get_index_of(target_dynamic.number_of_steps()))
target_p_start = non_partial_target_dynamic.position_of(target_dynamic.index_of(0))
target_p_end = non_partial_target_dynamic.position_of(target_dynamic.index_of(target_dynamic.number_of_steps()))
if non_partial_dynamic == non_partial_target_dynamic:
return resample_variable_same(variable, non_partial_dynamic, source_p_start, source_p_end, non_partial_target_dynamic, target_p_start, target_p_end, target_set)
elif isinstance(non_partial_target_dynamic, BackedDynamic) and non_partial_target_dynamic.has_ancestor(non_partial_dynamic):
......@@ -633,9 +635,9 @@ def resample_variable_same(variable, dynamic, source_p_start, source_p_end, targ
# target_dynamic is BackedDynamic and has dynamic as an ancestor
def resample_variable_to_backed(variable, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_set):
def rule(m, t):
target_position = target_dynamic.get_position_of(t)
target_position = target_dynamic.position_of(t)
acc = 0
for source_index in dynamic.get_indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
for source_index in dynamic.indices_within(target_dynamic.indices[target_position], target_dynamic.indices[target_position + 1]):
acc += variable[source_index] * dynamic.step_size(source_index)
return acc / target_dynamic.step_size_p(target_position)
return pyo.Expression(target_set, rule=rule)
......@@ -644,15 +646,15 @@ def resample_variable_to_backed(variable, dynamic, source_p_start, source_p_end,
def resample_variable_from_backed(variable, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_set):
assignment = dict()
source_i_start = dynamic.indices[source_p_start]
target_i_start = target_dynamic.get_index_of(target_p_start)
target_i_start = target_dynamic.index_of(target_p_start)
if source_i_start < target_i_start:
source_p_start = dynamic.get_position_of(target_i_start)
source_p_start = dynamic.position_of(target_i_start)
source_i_end = dynamic.indices[source_p_end]
target_i_end = target_dynamic.get_index_of(target_p_end)
target_i_end = target_dynamic.index_of(target_p_end)
if target_i_end < source_i_end:
source_p_end = dynamic.get_position_of(target_i_end)
source_p_end = dynamic.position_of(target_i_end)
for source_position in range(source_p_start, source_p_end):
target_indices = target_dynamic.get_indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
target_indices = target_dynamic.indices_within(dynamic.indices[source_position], dynamic.indices[source_position + 1])
for target_index in target_indices:
assignment[target_index] = variable[dynamic.indices[source_position]]
def rule(m, t):
......@@ -662,8 +664,8 @@ def resample_variable_from_backed(variable, dynamic, source_p_start, source_p_en
# dynamic and target_dynamic share the same root dynamic
def resample_variable_common_reference(variable, dynamic, source_p_start, source_p_end, target_dynamic, target_p_start, target_p_end, target_set):
assignment = dict()
target_i_start = target_dynamic.get_index_of(target_p_start)
source_position = dynamic.get_position_of(target_i_start)
target_i_start = target_dynamic.index_of(target_p_start)
source_position = dynamic.position_of(target_i_start)
target_position = target_p_start
remaining_length = dynamic.step_size_p(source_position)
while target_position < target_p_end:
......@@ -674,29 +676,29 @@ def resample_variable_common_reference(variable, dynamic, source_p_start, source
source_position += 1
remaining_length = dynamic.step_size_p(source_position)
if remaining_target_length <= remaining_length:
acc.append((variable[dynamic.get_index_of(source_position)], remaining_target_length))
acc.append((variable[dynamic.index_of(source_position)], remaining_target_length))
remaining_length -= remaining_target_length
remaining_target_length -= remaining_target_length
else:
acc.append((variable[dynamic.get_index_of(source_position)], remaining_length))
acc.append((variable[dynamic.index_of(source_position)], remaining_length))
remaining_target_length -= remaining_length
remaining_length -= remaining_length
for i, (single_variable, factor) in enumerate(acc):
acc[i] = (single_variable, factor / target_dynamic.step_size_p(target_position))
assignment[target_dynamic.get_index_of(target_position)] = acc
assignment[target_dynamic.index_of(target_position)] = acc
target_position += 1
def rule(m, t):
return pyo.quicksum(variable * factor for variable, factor in assignment[t])
return pyo.Expression(target_set, rule=rule)
def test_single_resampling(dynamic, target_dynamic):
index = [dynamic.get_index_of(position) for position in range(dynamic.number_of_steps())]
index = [dynamic.index_of(position) for position in range(dynamic.number_of_steps())]
values = pd.Series(data = [float(i) for i in range(len(index))], index = index)
try:
print(resample(values, dynamic, target_dynamic))
except:
print('hey')
target_index = [target_dynamic.get_index_of(position) for position in range(target_dynamic.number_of_steps())]
target_index = [target_dynamic.index_of(position) for position in range(target_dynamic.number_of_steps())]
target_values = pd.Series(dtype = float, index = target_index)
try:
print(resample_into(values, dynamic, target_dynamic, target_values))
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment