Update generated code for DPF 252_daily on master (#2122)

* update generated code

* "ponderation" -> "weights" (#2130)

* "ponderation" -> "weights"

* "ponderation" -> "weights"

* temporarily skip retro for animation tests using ponderation explicitly

* Reinstate translator.py

* Keep translator.py during code generation

---------

Co-authored-by: PProfizi <[email protected]>

Author: pyansys-ci-bot

.ci/code_generation.py

@@ -17,6 +17,8 @@
 for file_path in files:
     if file_path.stem == "specification":
         continue
+    if file_path.stem == "translator":
+        continue
     if file_path.name == "build.py":
         continue
     if file_path.name == "operator.mustache":

doc/source/_static/dpf_operators.html

@@ -105,27 +105,27 @@
 # ~~~~~~~~~~
 # First we define fields. By default, fields represent 3D vectors
 # so one elementary data is a 3D vector.
-# The optional ponderation field is a field which takes one value per entity,
+# The optional weights field is a field which takes one value per entity,
 # so we need to change its dimensionality (1D).
 num_entities = 3
 input_field = dpf.Field(nentities=num_entities)
-ponderation_field = dpf.Field(num_entities)
-ponderation_field.dimensionality = dpf.Dimensionality([1])
+weights_field = dpf.Field(num_entities)
+weights_field.dimensionality = dpf.Dimensionality([1])
 
 input_field.scoping.ids = range(num_entities)
-ponderation_field.scoping.ids = range(num_entities)
+weights_field.scoping.ids = range(num_entities)
 
 ###############################################################################
 # Fill fields with data.
 # Add nine values because there are three entities.
 input_field.data = [-2.0, 2.0, 4.0, -5.0, 0.5, 1.0, 7.0, 3.0, -3.0]
 ###############################################################################
 # Three weights, one per entity.
-ponderation_field.data = [0.5, 2.0, 0.5]
+weights_field.data = [0.5, 2.0, 0.5]
 
 ###############################################################################
 # Retrieve the result.
-acc = dpf.operators.math.accumulate(fieldA=input_field, ponderation=ponderation_field)
+acc = dpf.operators.math.accumulate(fieldA=input_field, weights=weights_field)
 output_field = acc.outputs.field()
 
 # (-2.0 * 0.5) + (-5.0 * 2.0) + (7.0 * 0.5)  = -7.5

examples/00-basic/10-math_operations.py

@@ -94,11 +94,11 @@
 
 # Add a constant
 # Add 2 to each value in the field
-stress_2 = maths.add_constant_fc(fields_container=stress_2, ponderation=2.0).eval()
+stress_2 = maths.add_constant_fc(fields_container=stress_2, weights=2.0).eval()
 
 # Multiply by a constant
 # Multiply each value in the field by 3
-stress_3 = maths.scale_fc(fields_container=stress_3, ponderation=3.0).eval()
+stress_3 = maths.scale_fc(fields_container=stress_3, weights=3.0).eval()
 
 # Add fields containers
 # Each value of each field is added by the correspondent component of the others fields

examples/01-mathematical-operations/matrix-operations.py

@@ -177,7 +177,7 @@
 divide.inputs.fieldB.connect(stress_ref_nodal_op)
 rel_error = dpf.operators.math.scale()
 rel_error.inputs.field.connect(divide)
-rel_error.inputs.ponderation.connect(1.0)
+rel_error.inputs.weights.connect(1.0)
 
 ###############################################################################
 # Plot absolute and relative errors.

examples/04-advanced/04-extrapolation_stress_3d.py

@@ -167,7 +167,7 @@
 divide.inputs.fieldB.connect(strain_ref_nodal_op)
 rel_error = dpf.operators.math.scale()
 rel_error.inputs.field.connect(divide)
-rel_error.inputs.ponderation.connect(1.0)
+rel_error.inputs.weights.connect(1.0)
 
 ###############################################################################
 # Plot absolute and relative errors.

examples/04-advanced/05-extrapolation_strain_2d.py

@@ -110,7 +110,7 @@
 # using :class:`scale <ansys.dpf.core.operators.math.scale.scale>` operator
 # inwards in the geometry, to get the path direction.
 #
-normal_vec_in_field = ops.math.scale(field=normal_vec_out_field, ponderation=-1.0)
+normal_vec_in_field = ops.math.scale(field=normal_vec_out_field, weights=-1.0)
 normal_vec_in = normal_vec_in_field.outputs.field.get_data().data[0]
 ###############################################################################
 # Get nodal coordinates, they serve as the first point on the line.

examples/04-advanced/06-stress_gradient_path.py

@@ -114,7 +114,7 @@
 
 poisson_ratio_correction = 1.3 / 1.5
 eppleqvmech_op = dpf.operators.math.scale_fc(
-    fields_container=eppleqv, ponderation=poisson_ratio_correction
+    fields_container=eppleqv, weights=poisson_ratio_correction
 )
 eppleqvmech = eppleqvmech_op.outputs.fields_container()
 
@@ -134,23 +134,23 @@
 s123 = s123_op.outputs.fields_container()
 # SVM_scale=SVM*3
 ratio = 3.0
-seqvs_op = dpf.operators.math.scale_fc(fields_container=seqv, ponderation=ratio)
+seqvs_op = dpf.operators.math.scale_fc(fields_container=seqv, weights=ratio)
 seqvs = seqvs_op.outputs.fields_container()
 # S123/SVM*3
 sratio_op = dpf.operators.math.component_wise_divide(fieldA=s123, fieldB=seqvs)
 sratio = sratio_op.outputs.field()
 # S123/SVM*3-0.33
-sterm_op = dpf.operators.math.add_constant(field=sratio, ponderation=-1 / 3)
+sterm_op = dpf.operators.math.add_constant(field=sratio, weights=-1 / 3)
 sterm = sterm_op.outputs.field()
 # -alfasl/(1+m2)*stressterm
 ratio2 = -alfasl / (1 + m2)
-expt_op = dpf.operators.math.scale(field=sterm, ponderation=ratio2)
+expt_op = dpf.operators.math.scale(field=sterm, weights=ratio2)
 expt = expt_op.outputs.field()
 # exp(-alfasl/(1+m2)*stressterm)
 exp_op = dpf.operators.math.exponential(field=expt)
 exp = exp_op.outputs.field()
 # elu*exp(-alfasl/(1+m2)*stressterm)
-strainlimit_op = dpf.operators.math.scale(field=exp, ponderation=m2)
+strainlimit_op = dpf.operators.math.scale(field=exp, weights=m2)
 strainlimit = strainlimit_op.outputs.field()
 
 ###############################################################################

examples/04-advanced/10-asme_secviii_divtwo.py

@@ -68,7 +68,7 @@
 print(field)
 
 # Instantiate an Entry (not licensed) DPF operator
-op_entry = dpf.operators.math.add_constant(field=field, ponderation=2.0, server=server)
+op_entry = dpf.operators.math.add_constant(field=field, weights=2.0, server=server)
 
 # Instantiate a Premium (licensed) DPF operator
 op_premium = dpf.operators.filter.field_high_pass(field=field, threshold=0.0, server=server)

examples/04-advanced/13-manage_licensing.py

@@ -120,7 +120,7 @@
 divide.inputs.fieldB.connect(fc_out)
 scale = dpf.operators.math.scale()
 scale.inputs.field.connect(divide)
-scale.inputs.ponderation.connect(100.0)
+scale.inputs.weights.connect(100.0)
 rel_error = scale.eval()
 
 ###############################################################################