def test_inputparameters_of_modifymodel():
"""
Test the input constructors of the ModifyModel class.
"""
branches = 3
signal = sumpf.modules.SweepGenerator(samplingrate=48000,
length=2**14).GetSignal()
ref_nlfunctions = [
nlsp.nonlinear_functions.Power(degree=i + 1) for i in range(branches)
]
ref_bpfilters = nlsp.helper_functions.create_arrayof_bpfilter(
branches=branches, sampling_rate=48000)
ref_aliasingcomp = nlsp.aliasing_compensation.ReducedUpsamplingAliasingCompensation(
)
ref_HGM = nlsp.HammersteinGroupModel(
nonlinear_functions=ref_nlfunctions,
filter_impulseresponses=ref_bpfilters,
aliasing_compensation=ref_aliasingcomp)
test_HGM = nlsp.HammersteinGroupModel()
ref_HGM.SetInput(signal)
test_HGM.SetInput(signal)
assert nlsp_private.calculateenergy_timedomain(ref_HGM.GetOutput()) != \
nlsp_private.calculateenergy_timedomain(test_HGM.GetOutput())
modify_model = nlsp.ModifyModel(input_model=test_HGM,
filter_impulseresponses=ref_bpfilters,
nonlinear_functions=ref_nlfunctions,
aliasing_compensation=ref_aliasingcomp)
modified_HGM = modify_model.GetOutputModel()
modified_HGM.SetInput(signal)
assert nlsp_private.calculateenergy_timedomain(ref_HGM.GetOutput()) == \
nlsp_private.calculateenergy_timedomain(modified_HGM.GetOutput())
def GetResult(self):
"""
Get the filter energy analysis report.
:return: the energy of the filters of each branch of nonlinear model
"""
modify = nlsp.ModifyModel(input_model=self._input_model)
filter_kernels = modify._filter_impulseresponses
energy = []
for kernel in filter_kernels:
energy.append(nlsp.common.helper_functions_private.calculateenergy_timedomain(kernel))
return energy
def test_modify_model_SetAliasingCompensation():
"""
Test the SetAliasingCompensation method of the ModifyModel class.
"""
branches = 3
input_signal = sumpf.modules.SweepGenerator(samplingrate=48000.0,
length=2**14).GetSignal()
nonlinear_functions = [
nlsp.nonlinear_functions.Power(degree=i + 1) for i in range(branches)
]
filter_irs = nlsp.helper_functions.create_arrayof_bpfilter(
branches=branches, sampling_rate=48000.0)
downsampling_posititon = nlsp.HammersteinGroupModel.AFTERNONLINEARBLOCK
aliasing_compensation = nlsp.aliasing_compensation.ReducedUpsamplingAliasingCompensation(
)
HGM = nlsp.HammersteinGroupModel(
nonlinear_functions=nonlinear_functions,
filter_impulseresponses=filter_irs,
aliasing_compensation=aliasing_compensation,
downsampling_position=downsampling_posititon)
HGM.SetInput(input_signal=input_signal)
test_HGM = nlsp.HammersteinGroupModel(
downsampling_position=downsampling_posititon)
test_HGM.SetInput(input_signal)
energy1 = nlsp_private.calculateenergy_timedomain(HGM.GetOutput())[0]
energy2 = nlsp_private.calculateenergy_timedomain(test_HGM.GetOutput())[0]
assert energy1 != energy2
modify_model = nlsp.ModifyModel(
input_model=test_HGM,
filter_impulseresponses=filter_irs,
nonlinear_functions=nonlinear_functions,
aliasing_compensation=nlsp.aliasing_compensation.
NoAliasingCompensation(),
downsampling_position=downsampling_posititon)
modified_HGM = modify_model.GetOutputModel()
modified_HGM.SetInput(input_signal)
energy1 = nlsp_private.calculateenergy_timedomain(HGM.GetOutput())[0]
energy2 = nlsp_private.calculateenergy_timedomain(
modified_HGM.GetOutput())[0]
assert energy1 != energy2
modify_model.SetAliasingCompensation(aliasing_compensation)
modified_HGM = modify_model.GetOutputModel()
modified_HGM.SetInput(input_signal)
energy1 = nlsp_private.calculateenergy_timedomain(HGM.GetOutput())[0]
energy2 = nlsp_private.calculateenergy_timedomain(
modified_HGM.GetOutput())[0]
distance = energy1 - energy2
distance = abs(distance)
assert distance < 100
def __SaveModel(self):
"""
Save the model in specific file location.
"""
get_param = nlsp.ModifyModel(input_model=self.__model)
nonlinear_functions = get_param._nonlinear_functions
filter_kernels = get_param._filter_impulseresponses
aliasing = get_param._aliasing_compensation
downsampling_position = get_param._downsampling_position
filter_kernels = sumpf.modules.MergeSignals(signals=filter_kernels).GetOutput()
label = generate_label(nonlinearfunctions=nonlinear_functions, aliasingcomp=aliasing,
downsamplingposition=downsampling_position)
model = sumpf.modules.RelabelSignal(signal=filter_kernels,
labels=(label,) * len(filter_kernels.GetChannels())).GetOutput()
sumpf.modules.SignalFile(filename=self._filename, signal=model, file_format=self._file_format).GetSignal()
def test_modify_model_SetFilterImpulseResponses():
"""
Test the SetFilterImpulseResponses method of the ModifyModel class.
"""
branches = 3
downsampling_posititon = nlsp.HammersteinGroupModel.AFTERNONLINEARBLOCK
input_signal = sumpf.modules.SweepGenerator(samplingrate=48000,
length=2**15).GetSignal()
ref_nlfunctions1 = [
nlsp.nonlinear_functions.Power(degree=i + 1) for i in range(branches)
]
ref_nlfunctions2 = [
nlsp.nonlinear_functions.Power(degree=i + 1) for i in range(branches)
]
ref_bpfilters = nlsp.helper_functions.create_arrayof_bpfilter(
branches=branches, sampling_rate=48000)
ref_aliasingcomp1 = nlsp.aliasing_compensation.ReducedUpsamplingAliasingCompensation(
)
ref_aliasingcomp2 = nlsp.aliasing_compensation.ReducedUpsamplingAliasingCompensation(
)
ref_HGM = nlsp.HammersteinGroupModel(
nonlinear_functions=ref_nlfunctions1,
filter_impulseresponses=ref_bpfilters,
aliasing_compensation=ref_aliasingcomp1,
downsampling_position=downsampling_posititon)
test_HGM = nlsp.HammersteinGroupModel(
downsampling_position=downsampling_posititon)
ref_HGM.SetInput(input_signal)
test_HGM.SetInput(input_signal)
assert nlsp_private.calculateenergy_timedomain(ref_HGM.GetOutput()) != \
nlsp_private.calculateenergy_timedomain(test_HGM.GetOutput())
rev_bp = [i for i in reversed(ref_bpfilters)]
modify_model = nlsp.ModifyModel(input_model=test_HGM,
aliasing_compensation=ref_aliasingcomp2,
nonlinear_functions=ref_nlfunctions2,
filter_impulseresponses=rev_bp)
modified_HGM = modify_model.GetOutputModel()
modified_HGM.SetInput(input_signal)
assert nlsp_private.calculateenergy_timedomain(ref_HGM.GetOutput()) != \
nlsp_private.calculateenergy_timedomain(modified_HGM.GetOutput())
modify_model.SetFilterImpulseResponses(
filter_impulseresponses=ref_bpfilters)
modified_HGM = modify_model.GetOutputModel()
modified_HGM.SetInput(input_signal)
energy1 = nlsp_private.calculateenergy_timedomain(ref_HGM.GetOutput())[0]
energy2 = nlsp_private.calculateenergy_timedomain(
modified_HGM.GetOutput())[0]
assert int(energy1) == int(energy2)
def GetSimulationComplexity(self, iterations=1):
"""
Get the simulation complexity of the system identification algorithm in seconds.
:param iterations: the number of iterations after which the average time is taken
:return: the simulation time
"""
s_t = []
for identification_algorithm in self._identification_algorithms:
sim_time = []
for i in range(iterations):
excitation = identification_algorithm.GetExcitation(
excitation_length=len(self._test_signal),
excitation_sampling_rate=self._test_signal.GetSamplingRate(
))
self._reference_system.SetInput(excitation)
response = self._reference_system.GetOutput()
response = response
identification_algorithm.SetResponse(response=response)
model = identification_algorithm.GetOutputModel()
kernels = identification_algorithm._GetFilterImpuleResponses()
kernels = [
nlsp.common.helper_functions_private.change_length_signal(
signal=kernel, length=self._kernel_length)
for kernel in kernels
]
modify = nlsp.ModifyModel(input_model=model,
filter_impulseresponses=kernels)
model = modify.GetOutputModel()
sim_time_start = time.clock()
model.SetInput(self._test_signal)
output_iden = model.GetOutput()
sim_time_stop = time.clock()
sim_time.append(sim_time_stop - sim_time_start)
s_t.append(numpy.average(sim_time))
return s_t