Update generated code for DPF 261 on fix/fix_generated_operators_outputs_class

src/ansys/dpf/core/operators/averaging/elemental_difference.py

@@ -88,8 +88,6 @@ def __init__(
             inputs_type=InputsElementalDifference,
             outputs_type=OutputsElementalDifference,
         )
-        self._inputs = InputsElementalDifference(self)
-        self._outputs = OutputsElementalDifference(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_difference_fc.py

@@ -92,8 +92,6 @@ def __init__(
             inputs_type=InputsElementalDifferenceFc,
             outputs_type=OutputsElementalDifferenceFc,
         )
-        self._inputs = InputsElementalDifferenceFc(self)
-        self._outputs = OutputsElementalDifferenceFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/elemental_fraction_fc.py

@@ -92,8 +92,6 @@ def __init__(
             inputs_type=InputsElementalFractionFc,
             outputs_type=OutputsElementalFractionFc,
         )
-        self._inputs = InputsElementalFractionFc(self)
-        self._outputs = OutputsElementalFractionFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/elemental_mean.py

@@ -84,8 +84,6 @@ def __init__(
             inputs_type=InputsElementalMean,
             outputs_type=OutputsElementalMean,
         )
-        self._inputs = InputsElementalMean(self)
-        self._outputs = OutputsElementalMean(self)
         if field is not None:
             self.inputs.field.connect(field)
         if collapse_shell_layers is not None:

src/ansys/dpf/core/operators/averaging/elemental_mean_fc.py

@@ -112,8 +112,6 @@ def __init__(
             inputs_type=InputsElementalMeanFc,
             outputs_type=OutputsElementalMeanFc,
         )
-        self._inputs = InputsElementalMeanFc(self)
-        self._outputs = OutputsElementalMeanFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if collapse_shell_layers is not None:

src/ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal.py

@@ -102,8 +102,6 @@ def __init__(
             inputs_type=InputsElementalNodalToNodal,
             outputs_type=OutputsElementalNodalToNodal,
         )
-        self._inputs = InputsElementalNodalToNodal(self)
-        self._outputs = OutputsElementalNodalToNodal(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal_elemental.py

@@ -67,8 +67,6 @@ def __init__(self, field=None, mesh_scoping=None, config=None, server=None):
             inputs_type=InputsElementalNodalToNodalElemental,
             outputs_type=OutputsElementalNodalToNodalElemental,
         )
-        self._inputs = InputsElementalNodalToNodalElemental(self)
-        self._outputs = OutputsElementalNodalToNodalElemental(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal_elemental_fc.py

@@ -67,8 +67,6 @@ def __init__(
             inputs_type=InputsElementalNodalToNodalElementalFc,
             outputs_type=OutputsElementalNodalToNodalElementalFc,
         )
-        self._inputs = InputsElementalNodalToNodalElementalFc(self)
-        self._outputs = OutputsElementalNodalToNodalElementalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_nodal_to_nodal_fc.py

@@ -118,8 +118,6 @@ def __init__(
             inputs_type=InputsElementalNodalToNodalFc,
             outputs_type=OutputsElementalNodalToNodalFc,
         )
-        self._inputs = InputsElementalNodalToNodalFc(self)
-        self._outputs = OutputsElementalNodalToNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/elemental_to_elemental_nodal.py

@@ -74,8 +74,6 @@ def __init__(
             inputs_type=InputsElementalToElementalNodal,
             outputs_type=OutputsElementalToElementalNodal,
         )
-        self._inputs = InputsElementalToElementalNodal(self)
-        self._outputs = OutputsElementalToElementalNodal(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_to_elemental_nodal_fc.py

@@ -76,8 +76,6 @@ def __init__(
             inputs_type=InputsElementalToElementalNodalFc,
             outputs_type=OutputsElementalToElementalNodalFc,
         )
-        self._inputs = InputsElementalToElementalNodalFc(self)
-        self._outputs = OutputsElementalToElementalNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/elemental_to_nodal.py

@@ -102,8 +102,6 @@ def __init__(
             inputs_type=InputsElementalToNodal,
             outputs_type=OutputsElementalToNodal,
         )
-        self._inputs = InputsElementalToNodal(self)
-        self._outputs = OutputsElementalToNodal(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/elemental_to_nodal_fc.py

@@ -106,8 +106,6 @@ def __init__(
             inputs_type=InputsElementalToNodalFc,
             outputs_type=OutputsElementalToNodalFc,
         )
-        self._inputs = InputsElementalToNodalFc(self)
-        self._outputs = OutputsElementalToNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/extend_to_mid_nodes.py

@@ -67,8 +67,6 @@ def __init__(self, field=None, mesh=None, config=None, server=None):
             inputs_type=InputsExtendToMidNodes,
             outputs_type=OutputsExtendToMidNodes,
         )
-        self._inputs = InputsExtendToMidNodes(self)
-        self._outputs = OutputsExtendToMidNodes(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/extend_to_mid_nodes_fc.py

@@ -66,8 +66,6 @@ def __init__(self, fields_container=None, mesh=None, config=None, server=None):
             inputs_type=InputsExtendToMidNodesFc,
             outputs_type=OutputsExtendToMidNodesFc,
         )
-        self._inputs = InputsExtendToMidNodesFc(self)
-        self._outputs = OutputsExtendToMidNodesFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/force_summation.py

@@ -119,8 +119,6 @@ def __init__(
             inputs_type=InputsForceSummation,
             outputs_type=OutputsForceSummation,
         )
-        self._inputs = InputsForceSummation(self)
-        self._outputs = OutputsForceSummation(self)
         if time_scoping is not None:
             self.inputs.time_scoping.connect(time_scoping)
         if nodal_scoping is not None:

src/ansys/dpf/core/operators/averaging/force_summation_psd.py

@@ -118,8 +118,6 @@ def __init__(
             inputs_type=InputsForceSummationPsd,
             outputs_type=OutputsForceSummationPsd,
         )
-        self._inputs = InputsForceSummationPsd(self)
-        self._outputs = OutputsForceSummationPsd(self)
         if nodal_scoping is not None:
             self.inputs.nodal_scoping.connect(nodal_scoping)
         if elemental_scoping is not None:

src/ansys/dpf/core/operators/averaging/gauss_to_node_fc.py

@@ -77,8 +77,6 @@ def __init__(
             inputs_type=InputsGaussToNodeFc,
             outputs_type=OutputsGaussToNodeFc,
         )
-        self._inputs = InputsGaussToNodeFc(self)
-        self._outputs = OutputsGaussToNodeFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/nodal_difference.py

@@ -77,8 +77,6 @@ def __init__(
             inputs_type=InputsNodalDifference,
             outputs_type=OutputsNodalDifference,
         )
-        self._inputs = InputsNodalDifference(self)
-        self._outputs = OutputsNodalDifference(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/nodal_difference_fc.py

@@ -80,8 +80,6 @@ def __init__(
             inputs_type=InputsNodalDifferenceFc,
             outputs_type=OutputsNodalDifferenceFc,
         )
-        self._inputs = InputsNodalDifferenceFc(self)
-        self._outputs = OutputsNodalDifferenceFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/nodal_fraction_fc.py

@@ -86,8 +86,6 @@ def __init__(
             inputs_type=InputsNodalFractionFc,
             outputs_type=OutputsNodalFractionFc,
         )
-        self._inputs = InputsNodalFractionFc(self)
-        self._outputs = OutputsNodalFractionFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/nodal_to_elemental.py

@@ -79,8 +79,6 @@ def __init__(
             inputs_type=InputsNodalToElemental,
             outputs_type=OutputsNodalToElemental,
         )
-        self._inputs = InputsNodalToElemental(self)
-        self._outputs = OutputsNodalToElemental(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/nodal_to_elemental_fc.py

@@ -102,8 +102,6 @@ def __init__(
             inputs_type=InputsNodalToElementalFc,
             outputs_type=OutputsNodalToElementalFc,
         )
-        self._inputs = InputsNodalToElementalFc(self)
-        self._outputs = OutputsNodalToElementalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/nodal_to_elemental_nodal.py

@@ -79,8 +79,6 @@ def __init__(
             inputs_type=InputsNodalToElementalNodal,
             outputs_type=OutputsNodalToElementalNodal,
         )
-        self._inputs = InputsNodalToElementalNodal(self)
-        self._outputs = OutputsNodalToElementalNodal(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/nodal_to_elemental_nodal_fc.py

@@ -76,8 +76,6 @@ def __init__(
             inputs_type=InputsNodalToElementalNodalFc,
             outputs_type=OutputsNodalToElementalNodalFc,
         )
-        self._inputs = InputsNodalToElementalNodalFc(self)
-        self._outputs = OutputsNodalToElementalNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/to_elemental_fc.py

@@ -101,8 +101,6 @@ def __init__(
             inputs_type=InputsToElementalFc,
             outputs_type=OutputsToElementalFc,
         )
-        self._inputs = InputsToElementalFc(self)
-        self._outputs = OutputsToElementalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/averaging/to_elemental_nodal_fc.py

@@ -77,8 +77,6 @@ def __init__(
             inputs_type=InputsToElementalNodalFc,
             outputs_type=OutputsToElementalNodalFc,
         )
-        self._inputs = InputsToElementalNodalFc(self)
-        self._outputs = OutputsToElementalNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/to_nodal.py

@@ -85,8 +85,6 @@ def __init__(
             inputs_type=InputsToNodal,
             outputs_type=OutputsToNodal,
         )
-        self._inputs = InputsToNodal(self)
-        self._outputs = OutputsToNodal(self)
         if field is not None:
             self.inputs.field.connect(field)
         if mesh_scoping is not None:

src/ansys/dpf/core/operators/averaging/to_nodal_fc.py

@@ -89,8 +89,6 @@ def __init__(
             inputs_type=InputsToNodalFc,
             outputs_type=OutputsToNodalFc,
         )
-        self._inputs = InputsToNodalFc(self)
-        self._outputs = OutputsToNodalFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if mesh is not None:

src/ansys/dpf/core/operators/compression/apply_svd.py

@@ -91,8 +91,6 @@ def __init__(
             inputs_type=InputsApplySvd,
             outputs_type=OutputsApplySvd,
         )
-        self._inputs = InputsApplySvd(self)
-        self._outputs = OutputsApplySvd(self)
         if field_contaner_to_compress is not None:
             self.inputs.field_contaner_to_compress.connect(field_contaner_to_compress)
         if scalar_int is not None:

src/ansys/dpf/core/operators/compression/apply_zfp.py

@@ -109,8 +109,6 @@ def __init__(
             inputs_type=InputsApplyZfp,
             outputs_type=OutputsApplyZfp,
         )
-        self._inputs = InputsApplyZfp(self)
-        self._outputs = OutputsApplyZfp(self)
         if dataIn is not None:
             self.inputs.dataIn.connect(dataIn)
         if mode is not None:

src/ansys/dpf/core/operators/compression/kmeans_clustering.py

@@ -86,8 +86,6 @@ def __init__(
             inputs_type=InputsKmeansClustering,
             outputs_type=OutputsKmeansClustering,
         )
-        self._inputs = InputsKmeansClustering(self)
-        self._outputs = OutputsKmeansClustering(self)
         if clusters_number is not None:
             self.inputs.clusters_number.connect(clusters_number)
         if formula is not None:

src/ansys/dpf/core/operators/compression/quantization.py

@@ -72,8 +72,6 @@ def __init__(self, input_field=None, threshold=None, config=None, server=None):
             inputs_type=InputsQuantization,
             outputs_type=OutputsQuantization,
         )
-        self._inputs = InputsQuantization(self)
-        self._outputs = OutputsQuantization(self)
         if input_field is not None:
             self.inputs.input_field.connect(input_field)
         if threshold is not None:

src/ansys/dpf/core/operators/compression/quantization_fc.py

@@ -72,8 +72,6 @@ def __init__(self, input_fc=None, threshold=None, config=None, server=None):
             inputs_type=InputsQuantizationFc,
             outputs_type=OutputsQuantizationFc,
         )
-        self._inputs = InputsQuantizationFc(self)
-        self._outputs = OutputsQuantizationFc(self)
         if input_fc is not None:
             self.inputs.input_fc.connect(input_fc)
         if threshold is not None:

src/ansys/dpf/core/operators/compression/zfp_decompress.py

@@ -62,8 +62,6 @@ def __init__(self, dataIn=None, config=None, server=None):
             inputs_type=InputsZfpDecompress,
             outputs_type=OutputsZfpDecompress,
         )
-        self._inputs = InputsZfpDecompress(self)
-        self._outputs = OutputsZfpDecompress(self)
         if dataIn is not None:
             self.inputs.dataIn.connect(dataIn)
 

src/ansys/dpf/core/operators/filter/abc_weightings.py

@@ -78,8 +78,6 @@ def __init__(
             inputs_type=InputsAbcWeightings,
             outputs_type=OutputsAbcWeightings,
         )
-        self._inputs = InputsAbcWeightings(self)
-        self._outputs = OutputsAbcWeightings(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if weighting_type is not None:

src/ansys/dpf/core/operators/filter/field_band_pass.py

@@ -80,8 +80,6 @@ def __init__(
             inputs_type=InputsFieldBandPass,
             outputs_type=OutputsFieldBandPass,
         )
-        self._inputs = InputsFieldBandPass(self)
-        self._outputs = OutputsFieldBandPass(self)
         if field is not None:
             self.inputs.field.connect(field)
         if min_threshold is not None:

src/ansys/dpf/core/operators/filter/field_band_pass_fc.py

@@ -80,8 +80,6 @@ def __init__(
             inputs_type=InputsFieldBandPassFc,
             outputs_type=OutputsFieldBandPassFc,
         )
-        self._inputs = InputsFieldBandPassFc(self)
-        self._outputs = OutputsFieldBandPassFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if min_threshold is not None:

src/ansys/dpf/core/operators/filter/field_high_pass.py

@@ -72,8 +72,6 @@ def __init__(self, field=None, threshold=None, both=None, config=None, server=No
             inputs_type=InputsFieldHighPass,
             outputs_type=OutputsFieldHighPass,
         )
-        self._inputs = InputsFieldHighPass(self)
-        self._outputs = OutputsFieldHighPass(self)
         if field is not None:
             self.inputs.field.connect(field)
         if threshold is not None:

src/ansys/dpf/core/operators/filter/field_high_pass_fc.py

@@ -74,8 +74,6 @@ def __init__(
             inputs_type=InputsFieldHighPassFc,
             outputs_type=OutputsFieldHighPassFc,
         )
-        self._inputs = InputsFieldHighPassFc(self)
-        self._outputs = OutputsFieldHighPassFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if threshold is not None:

src/ansys/dpf/core/operators/filter/field_low_pass.py

@@ -72,8 +72,6 @@ def __init__(self, field=None, threshold=None, both=None, config=None, server=No
             inputs_type=InputsFieldLowPass,
             outputs_type=OutputsFieldLowPass,
         )
-        self._inputs = InputsFieldLowPass(self)
-        self._outputs = OutputsFieldLowPass(self)
         if field is not None:
             self.inputs.field.connect(field)
         if threshold is not None:

src/ansys/dpf/core/operators/filter/field_low_pass_fc.py

@@ -74,8 +74,6 @@ def __init__(
             inputs_type=InputsFieldLowPassFc,
             outputs_type=OutputsFieldLowPassFc,
         )
-        self._inputs = InputsFieldLowPassFc(self)
-        self._outputs = OutputsFieldLowPassFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if threshold is not None:

src/ansys/dpf/core/operators/filter/field_signed_high_pass.py

@@ -72,8 +72,6 @@ def __init__(self, field=None, threshold=None, both=None, config=None, server=No
             inputs_type=InputsFieldSignedHighPass,
             outputs_type=OutputsFieldSignedHighPass,
         )
-        self._inputs = InputsFieldSignedHighPass(self)
-        self._outputs = OutputsFieldSignedHighPass(self)
         if field is not None:
             self.inputs.field.connect(field)
         if threshold is not None:

src/ansys/dpf/core/operators/filter/field_signed_high_pass_fc.py

@@ -74,8 +74,6 @@ def __init__(
             inputs_type=InputsFieldSignedHighPassFc,
             outputs_type=OutputsFieldSignedHighPassFc,
         )
-        self._inputs = InputsFieldSignedHighPassFc(self)
-        self._outputs = OutputsFieldSignedHighPassFc(self)
         if fields_container is not None:
             self.inputs.fields_container.connect(fields_container)
         if threshold is not None: