def boundary_condition_func(powers_start, powers_end):
powers_start = SlicedArray(powers_start, slices)
powers_end = SlicedArray(powers_end, slices)
current = np.hstack(
(powers_start.forward_signal, powers_start.forward_pump,
powers_start.forward_ase, powers_start.forward_raman,
powers_end.backward_signal, powers_end.backward_pump,
powers_end.backward_ase, powers_end.backward_raman))
return current - expected_powers
def setUpClass(cls):
arr = np.linspace(1, 16, 16)
array_2d = np.reshape(arr, (4,4))
array_1d = array_2d[0,:]
slices = {'s01': slice(0, 1),
's11': slice(1, 1),
's12': slice(1, 2),
's24': slice(2, 4),
's44': slice(4, 4)}
cls.sliced_array_1d = SlicedArray(array_1d, slices)
cls.sliced_array_2d = SlicedArray(array_2d, slices)
def boundary_condition_func(powers_start, powers_end):
powers_start = SlicedArray(powers_start, slices)
powers_end = SlicedArray(powers_end, slices)
current = np.hstack(
(powers_start.forward_signal, powers_start.forward_pump,
powers_start.forward_ase, powers_start.forward_raman,
powers_end.backward_signal, powers_end.backward_pump,
powers_end.backward_ase, powers_end.backward_raman))
# reflections
p_exp = deepcopy(self.expected_powers)
for source_idx, target_idx, R in reflections:
if source_idx < n_forward:
p_exp[target_idx] += R * powers_end[source_idx]
else:
p_exp[target_idx] += R * powers_start[source_idx]
return current - p_exp
def as_array(self):
guess = SlicedArray(np.zeros(self.guess_shape()),
self.input_powers.slices)
guess.forward_signal = self.make_forward_guess(
self.input_powers.forward_signal, self.params.signal)
guess.backward_signal = self.make_backward_guess(
self.input_powers.backward_signal, self.params.signal)
guess.forward_pump = self.make_forward_guess(
self.input_powers.forward_pump, self.params.pump)
guess.backward_pump = self.make_backward_guess(
self.input_powers.backward_pump, self.params.pump)
guess.forward_ase = self.make_forward_guess(
self.input_powers.forward_ase, self.params.ase)
guess.backward_ase = self.make_backward_guess(
self.input_powers.backward_ase, self.params.ase)
guess.forward_raman = self.make_forward_guess(
self.input_powers.forward_raman, self.params.raman)
guess.backward_raman = self.make_backward_guess(
self.input_powers.backward_raman, self.params.raman)
return guess
def __init__(self,
z,
powers,
upper_level_fraction,
channels,
fiber,
backward_raman_allowed=True):
self.z = z
slices = channels.get_slices()
self.channels = channels
self.channel_ids = channels.get_channel_ids()
self.powers = SlicedArray(powers, slices)
self.wavelengths = channels.get_wavelengths()
self.upper_level_fraction = upper_level_fraction
self._backward_raman_allowed = backward_raman_allowed
self.fiber = fiber
self.use_db_scale = False
def _to_sliced_array(self, iterable):
return SlicedArray(np.array(iterable), self.get_slices())