def test_over_time_freq_complex_fields_container_2(): f1 = fields_factory.create_scalar_field(25, locations.elemental) f2 = fields_factory.create_scalar_field(31) f1_im = fields_factory.create_scalar_field(25, locations.elemental) f2_im = fields_factory.create_scalar_field(31) fc = fields_container_factory.over_time_freq_complex_fields_container( { 0.42: f1, 1.10: f2 }, { 0.42: f1_im, 1.10: f2_im }, "Hz") labels = fc.labels assert labels == ["complex", "time"] assert len(fc) == 4 f1_result = fc.get_field_by_time_id(1) f2_result = fc.get_field_by_time_id(2) f1_result_im = fc.get_imaginary_field(1) f2_result_im = fc.get_imaginary_field(2) assert f1_result.location == locations.elemental assert f2_result.location == locations.nodal assert f1_result_im.location == locations.elemental assert f2_result_im.location == locations.nodal support = fc.time_freq_support assert len(support.time_frequencies) == 2 assert len(support.complex_frequencies) == 2 assert support.time_frequencies.data[0] == 0.42 assert support.time_frequencies.data[1] == 1.1 assert support.complex_frequencies.data[0] == 0.42 assert support.complex_frequencies.data[1] == 1.1
def test_over_time_freq_complex_fields_container_1(): f1 = fields_factory.create_scalar_field(25) f2 = fields_factory.create_scalar_field(31) f1_im = fields_factory.create_scalar_field(25) f2_im = fields_factory.create_scalar_field(31) fc = fields_container_factory.over_time_freq_complex_fields_container( [f1, f2], [f1_im, f2_im]) labels = fc.labels assert labels == ["complex", "time"] assert len(fc) == 4 f1_result = fc.get_field_by_time_complex_ids(1, 0) f2_result = fc.get_field_by_time_complex_ids(2, 0) f1_result_im = fc.get_field_by_time_complex_ids(1, 1) f2_result_im = fc.get_field_by_time_complex_ids(2, 1) assert f1_result.location == locations.nodal assert f2_result.location == locations.nodal assert f1_result_im.location == locations.nodal assert f2_result_im.location == locations.nodal f1_result = fc.get_field_by_time_id(1) f2_result = fc.get_field_by_time_id(2) f1_result_im = fc.get_imaginary_field(1) f2_result_im = fc.get_imaginary_field(2) assert f1_result.location == locations.nodal assert f2_result.location == locations.nodal assert f1_result_im.location == locations.nodal assert f2_result_im.location == locations.nodal
def test_complex_fields_container(): freal = fields_factory.create_scalar_field(25) fim = fields_factory.create_scalar_field(25) fc = fields_container_factory.complex_fields_container(freal, fim) assert fc.labels == ["complex"] assert len(fc) == 2 freal_result = fc.get_field_by_time_complex_ids(complexid=0) fim_result = fc.get_field_by_time_complex_ids(complexid=1) assert freal_result.component_count == 1 assert fim_result.component_count == 1
def test_over_time_freq_complex_int_fields_container(): freq = [25, 50, 100, 200, 400] reals = {} ims = {} for k, f in enumerate(freq): reals[f] = fields_factory.create_scalar_field(1) ims[f] = fields_factory.create_scalar_field(1) cplx_fc = fields_container_factory.over_time_freq_complex_fields_container( reals, ims, time_freq_unit="Hz") assert np.allclose(cplx_fc.time_freq_support.time_frequencies.data, freq)
def test_over_time_freq_fields_container_1(): f1 = fields_factory.create_scalar_field(25) f2 = fields_factory.create_scalar_field(31) fc = fields_container_factory.over_time_freq_fields_container([f1, f2]) labels = fc.labels assert labels == ["time"] assert len(fc) == 2 f1_result = fc.get_field_by_time_complex_ids(1) f2_result = fc.get_field_by_time_complex_ids(2) assert f1_result.location == locations.nodal assert f2_result.location == locations.nodal
def over_time_freq_fields_container(fields, time_freq_unit=None, server=None): """Create a fields container with one field by time set. This method can also set the time frequency support with the correct unit if needed. Parameters ---------- fields : Dictionary(time_int_key : Field) or list of Field Dictionary of field entities to add to the fields container. time_freq_unit : str, optional Unit of the time frequency support, which is taken into account if the fields attribute has a dictionary type. The default is ``None``. server : ansys.dpf.core.server, optional Server with the channel connected to the remote or local instance. The default is ``None``, in which case an attempt is made to use the global server. Returns ------- fields_container : FieldsContainer Fields container containing one field by time step. Examples -------- Create a fields container from scratch based on time labels. >>> from ansys.dpf import core as dpf >>> field1 = dpf.Field() >>> field2 = dpf.Field() >>> from ansys.dpf.core import fields_container_factory >>> my_fc = fields_container_factory.over_time_freq_fields_container([ field1, field2 ]) """ if not isinstance(fields, dict) and not isinstance(fields, list): raise dpf_errors.InvalidTypeError("dictionary/list", "fields") fc = FieldsContainer(server=server) fc.labels = {"time"} i = 0 # dict case if isinstance(fields, dict): time_freq = [] for field_key in fields: fc.add_field({"time": i + 1}, fields[field_key]) time_freq.append(field_key) i += 1 time_freq_field = fields_factory.create_scalar_field( len(fields), location=locations.time_freq, server=server) time_freq_field.append(time_freq, 1) time_freq_field.unit = time_freq_unit time_freq_support = TimeFreqSupport(server=server) time_freq_support.time_frequencies = time_freq_field fc.time_freq_support = time_freq_support # list case elif isinstance(fields, list): for field in fields: fc.add_field({"time": i + 1}, field) i += 1 return fc
def test_over_time_freq_complex_fields_container_3(): f1 = fields_factory.create_scalar_field(25, locations.elemental) f2 = fields_factory.create_scalar_field(31) f1_im = fields_factory.create_scalar_field(25, locations.elemental) f2_im = fields_factory.create_scalar_field(31) with pytest.raises(dpf_errors.DpfValueError): fields_container_factory.over_time_freq_complex_fields_container( { 0.42: f1, 1.10: f2 }, [f1_im, f2_im], "Hz") with pytest.raises(dpf_errors.DpfValueError): fields_container_factory.over_time_freq_complex_fields_container( [f1, f2], { 0.42: f1_im, 1.10: f2_im }, "Hz")
def test_update_time_freq_support_real_freq(): tfq = TimeFreqSupport() frequencies = fields_factory.create_scalar_field(3) frequencies.data = [0.1, 0.32, 0.4] tfq.time_frequencies = frequencies frequencies_check = tfq.time_frequencies assert np.allclose(frequencies.data, frequencies_check.data) assert tfq.rpms is None assert tfq.complex_frequencies is None
def test_update_time_freq_support_rpms(): tfq = TimeFreqSupport() rpm = fields_factory.create_scalar_field(3) rpm.data = [0.1, 0.32, 0.4] tfq.rpms = rpm rpm_check = tfq.rpms assert np.allclose(rpm.data, rpm_check.data) assert tfq.time_frequencies is None assert tfq.complex_frequencies is None
def test_update_time_freq_support_real_freq_with_ds(velocity_acceleration): model = Model(velocity_acceleration) disp = model.results.displacement() tfq = disp.outputs.fields_container().time_freq_support assert tfq.time_frequencies is not None frequencies = fields_factory.create_scalar_field(3) frequencies.data = [0.1, 0.32, 0.4] tfq.time_frequencies = frequencies frequencies_check = tfq.time_frequencies assert np.allclose(frequencies.data, frequencies_check.data)
def test_update_time_freq_support_harmonic_indeces(): tfq = TimeFreqSupport() harm = fields_factory.create_scalar_field(3) harm.data = [0.1, 0.32, 0.4] tfq.set_harmonic_indices(harm) harm_check = tfq.get_harmonic_indices() assert np.allclose(harm.data, harm_check.data) assert tfq.time_frequencies is None assert tfq.complex_frequencies is None assert tfq.rpms is None
def test_collection_update_support(): # set time_freq_support fc = FieldsContainer() tfq = TimeFreqSupport() frequencies = fields_factory.create_scalar_field(3) frequencies.data = [0.1, 0.32, 0.4] tfq.time_frequencies = frequencies fc.time_freq_support = tfq # get time_freq_support tfq_check = fc.time_freq_support assert np.allclose(tfq.time_frequencies.data, tfq_check.time_frequencies.data)
def test_update_time_freq_support_harmonic_indeces_with_num_stage(): tfq = TimeFreqSupport() harm = fields_factory.create_scalar_field(3) harm.data = [0.12, 0.32, 0.8] tfq.set_harmonic_indices(harm, 2) harm_check = tfq.get_harmonic_indices(2) assert np.allclose(harm.data, harm_check.data) assert tfq.time_frequencies is None assert tfq.complex_frequencies is None assert tfq.rpms is None harm_check_2 = tfq.get_harmonic_indices(3) assert harm_check_2 is None harm_check_3 = tfq.get_harmonic_indices(0) assert harm_check_3 is None harm_check_4 = tfq.get_harmonic_indices() assert harm_check_4 is None
def over_time_freq_complex_fields_container(real_fields, imaginary_fields, time_freq_unit=None, server=None): """Create a fields container with two fields (real and imaginary) by time set. If the inputs for the fields are dictionaries, this method sets the time frequency support with the correct unit if needed. Parameters ---------- real_fields : Dictionary(time_int_key : Field) or list of Field Dictionary or list of field entities to add to the fields container. imaginary_fields : Dictionary(time_int_key : Field) or list of Field Dictionary or list of field entities to add to the fields container. time_freq_unit : str , optional Unit of the time frequency support, which is taken into account if the field's attribute has a dictionary type. server : ansys.dpf.core.server, optional Server with the channel connected to the remote or local instance. The default is ``None``, in which case an attempt is made to use the global server. Returns ------- fields_container : FieldsContainer Fields container containing two fields (real and imaginary) by time step. """ if not isinstance(real_fields, dict) and not isinstance(real_fields, list): raise dpf_errors.InvalidTypeError("dictionary/list", "real_fields") if not isinstance(imaginary_fields, dict) and not isinstance( imaginary_fields, list): raise dpf_errors.InvalidTypeError("dictionary/list", "imaginary_fields") errorString = ( "Both real_fields and imaginary_fields must have the same type (list or dict)" ) if isinstance(real_fields, dict): if not isinstance(imaginary_fields, dict): raise dpf_errors.DpfValueError(errorString) elif isinstance(real_fields, list): if not isinstance(imaginary_fields, list): raise dpf_errors.DpfValueError(errorString) fc = FieldsContainer(server=server) fc.labels = ["time", "complex"] i = 0 # dict case if isinstance(real_fields, dict): time_freq = [] for field_key in real_fields: fc.add_field({"time": i + 1, "complex": 0}, real_fields[field_key]) time_freq.append(field_key) i += 1 i = 0 im_time_freq = [] for field_key in imaginary_fields: fc.add_field({ "time": i + 1, "complex": 1 }, imaginary_fields[field_key]) im_time_freq.append(field_key) i += 1 time_freq_field = fields_factory.create_scalar_field( len(real_fields), locations.time_freq, server=server) time_freq_field.append(time_freq, 1) time_freq_field.unit = time_freq_unit im_time_freq_field = fields_factory.create_scalar_field( len(imaginary_fields), locations.time_freq, server=server) im_time_freq_field.append(im_time_freq, 1) im_time_freq_field.unit = time_freq_unit time_freq_support = TimeFreqSupport(server=server) time_freq_support.time_frequencies = time_freq_field time_freq_support.complex_frequencies = im_time_freq_field fc.time_freq_support = time_freq_support # list case if isinstance(real_fields, list): for field in real_fields: fc.add_field({"time": i + 1, "complex": 0}, field) i += 1 i = 0 for field in imaginary_fields: fc.add_field({"time": i + 1, "complex": 1}, field) i += 1 return fc
def test_create_scalar_field(): f = fields_factory.create_scalar_field(4) assert f is not None assert f.component_count == 1