From b6b180d8e0e253c3d7fc6d5adb0c6222cad7f201 Mon Sep 17 00:00:00 2001 From: dpfuser Date: Sat, 25 Jul 2026 00:16:31 +0000 Subject: [PATCH 1/7] DPF dpf-mechanical doc update for 271 (2026.07.24) --- .../api/Ans.DataProcessing/Operator.md | 12 +++ .../api/Ans.DataProcessing/Workflow.md | 18 +++++ .../operators/compression/index.md | 4 + .../operators/compression/zstd_compress.md | 74 +++++++++++++++++++ .../operators/compression/zstd_compress_fc.md | 74 +++++++++++++++++++ .../operators/compression/zstd_decompress.md | 56 ++++++++++++++ .../compression/zstd_decompress_fc.md | 56 ++++++++++++++ .../math/accumulation_per_scoping.md | 34 ++++++++- .../operators/math/correlation.md | 12 +-- .../operators/math/entity_extractor.md | 24 +++++- .../operators/math/expansion_psd.md | 47 +++++++++--- .../operators/math/exponential_fc.md | 13 +++- .../operators/math/fft_approx.md | 38 ++++++---- .../operators/math/fft_eval.md | 35 +++++++-- .../operators/math/fft_gradient_eval.md | 24 +++++- .../math/fft_multi_harmonic_minmax.md | 36 ++++++--- .../operators/math/index.md | 28 +++---- .../operators/math/ln_fc.md | 13 +++- .../Ans.DataProcessing/operators/math/mac.md | 26 +++++-- .../operators/math/make_one_on_comp.md | 16 +++- .../operators/math/matrix_inverse.md | 14 +++- .../operators/math/modal_damping_ratio.md | 2 +- .../operators/math/qr_solve.md | 18 ++++- .../Ans.DataProcessing/operators/math/svd.md | 18 +++-- .../operators/math/time_derivation.md | 18 ++++- .../operators/math/time_freq_interpolation.md | 11 ++- .../operators/math/time_integration.md | 24 ++++-- .../result/mapdl_split_on_facet_indices.md | 2 +- .../result/write_motion_dfmf_file.md | 25 ++++++- .../scoping/compute_element_centroids.md | 24 ++++-- .../operators/scoping/index.md | 2 +- .../operators/serialization/deserializer.md | 4 +- .../operators/serialization/index.md | 2 +- .../operators/serialization/serializer.md | 2 +- .../versions/2027.R1.SP00/api/toc.yml | 8 ++ .../versions/2027.R1.SP00/docfx.json | 7 +- .../versions/2027.R1.SP00/toc.yml | 8 ++ .../versions/2027.R1.SP00/user-guide/index.md | 3 - 38 files changed, 709 insertions(+), 123 deletions(-) create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress_fc.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress_fc.md diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Operator.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Operator.md index 87572a7584..79d70ff3b1 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Operator.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Operator.md @@ -157,6 +157,18 @@ fields_container = my_op.outputs.fields_container.GetData() * **i** (*optional*) +#### GetOutputAsUInt64Collection(i: int = 0) -> Collection + +**Parameters:** + +* **i** (*optional*) + +#### GetOutputAsUIntCollection(i: int = 0) -> Collection + +**Parameters:** + +* **i** (*optional*) + #### GetOutputAsWorkflow(i: int = 0) -> Workflow **Parameters:** diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Workflow.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Workflow.md index 53cca1a46c..eaee63578b 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Workflow.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/Workflow.md @@ -191,6 +191,24 @@ to compute progress while a workflow is running. * **outputPinName** +#### GetOutputAsUInt64Collection(outputPinName: str) -> Collection + +**Parameters:** + +* **outputPinName** + +#### GetOutputAsUIntCollection(outputPinName: str) -> Collection + +**Parameters:** + +* **outputPinName** + +#### GetOutputAsULong(outputPinName: str) -> UInt64 + +**Parameters:** + +* **outputPinName** + #### GetRecordedId() -> int #### HasTag(tag: WorkFlowTags) -> bool diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/index.md index c99ffadd8f..77ea70ab47 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/index.md @@ -14,3 +14,7 @@ uid: Ans.DataProcessing.operators.compression | [quantization](Ans_DataProcessing_operators_compression_quantization.md) | Scales a field to a given precision threshold, then rounds all the values to the unit. | | [quantization_fc](Ans_DataProcessing_operators_compression_quantization_fc.md) | Scales all the fields of a fields container to a given precision threshold, then rounds all the values to the unit. | | [zfp_decompress](Ans_DataProcessing_operators_compression_zfp_decompress.md) | zfp decompression using the information about compression written into the properties of the field(s) ///available inputs: dataIn (CustomTypeFieldsContainer) | +| [zstd_compress](Ans_DataProcessing_operators_compression_zstd_compress.md) | Compresses the data of a field with ZSTD compression algorithm. ///available inputs: input_field (Field, CustomTypeField), zstd_level (Int32) (optional), num_threads (Int32) (optional) | +| [zstd_compress_fc](Ans_DataProcessing_operators_compression_zstd_compress_fc.md) | Compresses a fields container with ZSTD compression algorithm. ///available inputs: input_fc (FieldsContainer, CustomTypeFieldsContainer), zstd_level (Int32) (optional), num_threads (Int32) (optional) | +| [zstd_decompress](Ans_DataProcessing_operators_compression_zstd_decompress.md) | Decompresses a field compressed with ZSTD compression algorithm. ///available inputs: compressed_input (GenericDataContainer) | +| [zstd_decompress_fc](Ans_DataProcessing_operators_compression_zstd_decompress_fc.md) | Decompresses a fields container compressed with ZSTD compression algorithm. ///available inputs: compressed_input (AnyCollection) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress.md new file mode 100644 index 0000000000..868ab1df59 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress.md @@ -0,0 +1,74 @@ +--- +uid: Ans.DataProcessing.operators.compression.zstd_compress +--- + +# *class* zstd_compress(input_field: object = None, zstd_level: object = None, num_threads: object = None, config: OperatorConfig = None) + +Compresses the data of a field with ZSTD compression algorithm. + +available inputs: `input_field` (Field, CustomTypeField), `zstd_level` (Int32) (optional), `num_threads` (Int32) (optional) + +available outputs: `compressed_output` (GenericDataContainer), `output_bytes_size` (ulong) + +**DPF Framework Reference:** [zstd_compress operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/compression/zstd_compress.md) + +**Parameters:** + +* **input_field** +* **zstd_level** +* **num_threads** +* **config** + +**Example:** + +```python +op = zstd_compress() + +op = zstd_compress(input_field=my_input_field,zstd_level=my_zstd_level,num_threads=my_num_threads) +``` + +## Inputs + +### input_field + +Field or custom type field of type "double" to compress. + +**Type:** *LinkableInput* + +### zstd_level + +**Type:** *LinkableInput* + +### num_threads + +Number of threads for parallelization : from 0 to 20. Default = 4. + +**Type:** *LinkableInput* + +## Outputs + +### compressed_output + +**Type:** *LinkableOutput* + +### output_bytes_size + +Total size of compressed data in bytes. + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress_fc.md new file mode 100644 index 0000000000..71d2c73ba3 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_compress_fc.md @@ -0,0 +1,74 @@ +--- +uid: Ans.DataProcessing.operators.compression.zstd_compress_fc +--- + +# *class* zstd_compress_fc(input_fc: object = None, zstd_level: object = None, num_threads: object = None, config: OperatorConfig = None) + +Compresses a fields container with ZSTD compression algorithm. + +available inputs: `input_fc` (FieldsContainer, CustomTypeFieldsContainer), `zstd_level` (Int32) (optional), `num_threads` (Int32) (optional) + +available outputs: `compressed_fc` (AnyCollection), `output_bytes_size` (ulong) + +**DPF Framework Reference:** [zstd_compress_fc operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/compression/zstd_compress_fc.md) + +**Parameters:** + +* **input_fc** +* **zstd_level** +* **num_threads** +* **config** + +**Example:** + +```python +op = zstd_compress_fc() + +op = zstd_compress_fc(input_fc=my_input_fc,zstd_level=my_zstd_level,num_threads=my_num_threads) +``` + +## Inputs + +### input_fc + +Fields container or custom type fields container of type "double" to compress. + +**Type:** *LinkableInput* + +### zstd_level + +**Type:** *LinkableInput* + +### num_threads + +Number of threads for parallelization : from 0 to 20. Default = 4. + +**Type:** *LinkableInput* + +## Outputs + +### compressed_fc + +**Type:** *LinkableOutput* + +### output_bytes_size + +Total size of the compressed data in bytes (sum of the sizes in the vector of output pin 1). + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress.md new file mode 100644 index 0000000000..6c51861fe7 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress.md @@ -0,0 +1,56 @@ +--- +uid: Ans.DataProcessing.operators.compression.zstd_decompress +--- + +# *class* zstd_decompress(compressed_input: object = None, config: OperatorConfig = None) + +Decompresses a field compressed with ZSTD compression algorithm. + +available inputs: `compressed_input` (GenericDataContainer) + +available outputs: `decompressed_field` (Field ,CustomTypeField) + +**DPF Framework Reference:** [zstd_decompress operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/compression/zstd_decompress.md) + +**Parameters:** + +* **compressed_input** +* **config** + +**Example:** + +```python +op = zstd_decompress() + +op = zstd_decompress(compressed_input=my_compressed_input) +``` + +## Inputs + +### compressed_input + +**Type:** *LinkableInput* + +## Outputs + +### decompressed_field + +Decompressed field or custom type field. + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress_fc.md new file mode 100644 index 0000000000..b23358fb51 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/compression/zstd_decompress_fc.md @@ -0,0 +1,56 @@ +--- +uid: Ans.DataProcessing.operators.compression.zstd_decompress_fc +--- + +# *class* zstd_decompress_fc(compressed_input: object = None, config: OperatorConfig = None) + +Decompresses a fields container compressed with ZSTD compression algorithm. + +available inputs: `compressed_input` (AnyCollection) + +available outputs: `decompressed_fc` (FieldsContainer ,CustomTypeFieldsContainer) + +**DPF Framework Reference:** [zstd_decompress_fc operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/compression/zstd_decompress_fc.md) + +**Parameters:** + +* **compressed_input** +* **config** + +**Example:** + +```python +op = zstd_decompress_fc() + +op = zstd_decompress_fc(compressed_input=my_compressed_input) +``` + +## Inputs + +### compressed_input + +**Type:** *LinkableInput* + +## Outputs + +### decompressed_fc + +Decompressed fields container or custom type fields container. + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/accumulation_per_scoping.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/accumulation_per_scoping.md index 119ec8dec5..c36fb56b5c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/accumulation_per_scoping.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/accumulation_per_scoping.md @@ -4,9 +4,25 @@ uid: Ans.DataProcessing.operators.math.accumulation_per_scoping # *class* accumulation_per_scoping(fields_container: object = None, mesh_scoping: object = None, streams_container: object = None, data_sources: object = None, scopings_container: object = None, config: OperatorConfig = None) -This operator calculates the sum and the percentage of total sum of the input fields container for each scoping of the scopings container. +For each scoping in the input scopings container, computes the entity-wise sum of the input fields container values over that scoping, and the percentage of that sum relative to a master sum. -available inputs: `fields_container` (FieldsContainer), `mesh_scoping` (Scoping) (optional), `streams_container` (StreamsContainer), `data_sources` (DataSources), `scopings_container` (ScopingsContainer) +The sum is computed independently for each field in the container; the output contains one output field per input field, regardless of the container label (time, complex, or other). + +The master sum is computed by summing all entity values of the input fields container restricted to the master scoping when provided, or of the full input fields container otherwise. + +For cyclic and multistage models, the master scoping and the input scopings container are first expanded to the full mesh. + +When a master scoping is provided, each scoping in the input scopings container is intersected with it before accumulation. + +Each output field contains one entity per scoping plus one master entity: + +- entity id $0$ holds the master sum (or $100\%$ for the percentage output). + +- entity ids $1$ to $N$ hold the sum (or percentage of the master sum) for the $N$ scopings of the input scopings container, in the same order. + +The percentage is set to $0$ when the master sum is below machine epsilon. + +available inputs: `fields_container` (FieldsContainer), `mesh_scoping` (Scoping) (optional), `streams_container` (StreamsContainer) (optional), `data_sources` (DataSources) (optional), `scopings_container` (ScopingsContainer) available outputs: `accumulation_per_scoping` (FieldsContainer), `accumulation_per_scoping_percentage` (FieldsContainer) @@ -33,25 +49,31 @@ op = accumulation_per_scoping(fields_container=my_fields_container,mesh_scoping= ### fields_container +Fields container containing the values to accumulate per scoping. + **Type:** *LinkableInput* ### mesh_scoping -Master scoping. All scopings in the Scopings Container will be intersected with this scoping. +Master scoping. When provided, each scoping in the input scopings container is intersected with it, and the master sum is computed over this scoping. When omitted, the master sum is computed over the full input fields container and no intersection is performed. **Type:** *LinkableInput* ### streams_container +Streams describing the source result file. Required when no data sources is provided. Used to detect cyclic and multistage models and expand the scopings accordingly. Takes precedence over the data sources when both are provided. + **Type:** *LinkableInput* ### data_sources +Data sources describing the source result file. Required when no streams is provided. Used to detect cyclic and multistage models and expand the scopings accordingly. + **Type:** *LinkableInput* ### scopings_container -The intersection between the of the first will be used. +Scopings container. The sum of the input fields container is computed over each scoping it contains. Must contain at least one scoping. **Type:** *LinkableInput* @@ -59,10 +81,14 @@ The intersection between the of the first will be used. ### accumulation_per_scoping +Fields container with one field per input field. Each field holds the master sum at entity id $0$ and the per-scoping sums at entity ids $1$ to $N$, following the order of the input scopings container. + **Type:** *LinkableOutput* ### accumulation_per_scoping_percentage +Fields container with the same layout as the accumulation output. Entity id $0$ is $100$, entity ids $1$ to $N$ contain the per-scoping sum expressed as a percentage of the master sum, or $0$ when the master sum is below machine epsilon. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/correlation.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/correlation.md index 22cf58d6ef..51b6b73d85 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/correlation.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/correlation.md @@ -26,19 +26,19 @@ correlation(config: OperatorConfig) ### fieldA -Field a. The reference field. +Reference field $a$. **Type:** *LinkableInput* ### fieldB -Field b. If a fields container is provided, correlation is computed for each field. +Field $b$, or a fields container. When a fields container is provided, the correlation is computed independently for each field against the reference field $a$. **Type:** *LinkableInput* ### weights -Field M, optional weighting for correlation computation. +Optional weighting field $M$. When omitted, the standard unweighted $L^2$ inner product is used. **Type:** *LinkableInput* @@ -50,7 +50,7 @@ Deprecated alias of: weights ### absoluteValue -If true, correlation factor is ||aMb||/(||aMa||.||bMb||) +When true, returns $|\rho|$ instead of $\rho$. **Type:** *LinkableInput* @@ -58,13 +58,13 @@ If true, correlation factor is ||aMb||/(||aMa||.||bMb||) ### field -Correlation factor for each input field b. +Correlation coefficient for each input field $b$. The output field contains one entity per input field, labelled from $1$ to $N$. **Type:** *LinkableOutput* ### index -If several b are provided, this output contains the index of the highest correlation factor. +Zero-based index of the field in the input fields container that produced the highest correlation coefficient. Only meaningful when pin 1 receives a fields container. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/entity_extractor.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/entity_extractor.md index 56596e52a5..d2b4bad504 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/entity_extractor.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/entity_extractor.md @@ -4,11 +4,19 @@ uid: Ans.DataProcessing.operators.math.entity_extractor # *class* entity_extractor(fieldA: object = None, scalar_int: object = None, config: OperatorConfig = None) -Extracts an entity from a field, based on its ID. +Extracts a single scalar value from a field by its zero-based scoping index $k$ (pin 1). + +The output field contains one entity: the entity whose scoping index is $k$, + +with its entity ID resolved from the input scoping and its first data component copied. + +Only the first component is extracted regardless of the input field's dimensionality. + +Note: $k$ is the index within the field's scoping, not the entity ID. available inputs: `fieldA` (Field), `scalar_int` (Int32) -available outputs: `field` (Field) +available outputs: `field` (Field), `int32` (Int32) **DPF Framework Reference:** [entity_extractor operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/math/entity_extractor.md) @@ -30,16 +38,28 @@ op = entity_extractor(fieldA=my_fieldA,scalar_int=my_scalar_int) ### fieldA +Input field from which the entity is extracted. + **Type:** *LinkableInput* ### scalar_int +Zero-based scoping index $k$ of the entity to extract. + **Type:** *LinkableInput* ## Outputs ### field +Single-entity scalar field holding the first component of the extracted entity. The entity ID is the ID of the $k$-th entity in the input scoping. Always scalar regardless of the input field's dimensionality. + +**Type:** *LinkableOutput* + +### int32 + +Echo of the input index $k$ (pin 1). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/expansion_psd.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/expansion_psd.md index 54ec9cc9b9..79b18c332c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/expansion_psd.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/expansion_psd.md @@ -2,11 +2,33 @@ uid: Ans.DataProcessing.operators.math.expansion_psd --- -# *class* expansion_psd(mode_shapes: object = None, static_shapes: object = None, rel_rel_covar_matrix: object = None, stat_stat_covar_matrix: object = None, rel_stat_covar_matrix: object = None, config: OperatorConfig = None) +# *class* expansion_psd(mode_shapes: object = None, static_shapes: object = None, rel_rel_covar_matrix: object = None, stat_stat_covar_matrix: object = None, rel_stat_covar_matrix: object = None, is_rpsd_from_harm: object = None, config: OperatorConfig = None) -Computes the PSD response for one-sigma solution. +Computes the response power spectral density (RPSD) or 1-sigma response from a PSD analysis by combining mode shapes (or harmonic results), covariance matrices, and optionally static shapes. -available inputs: `mode_shapes` (FieldsContainer), `static_shapes` (FieldsContainer) (optional), `rel_rel_covar_matrix` (FieldsContainer), `stat_stat_covar_matrix` (FieldsContainer) (optional), `rel_stat_covar_matrix` (FieldsContainer) (optional) +**Response type** + +- If pin 5 is false (default) and constant covariance matrices are provided: 1-sigma response is computed from mode shapes (label "time") and covariance matrix $Q$ (only labels "Mode_i" and "Mode_j"): + +$\displaystyle \sigma_k = \sqrt{\sum_{i=1}^N{\sum_{j=1}^N{\phi_{ik} \phi_{jk} Q_{ij}}}}$ + +- If pin 5 is false (default) and frequency-dependent covariance matrices are provided: RPSD response is computed from mode shapes (label "time") and modal PSD matrix $R(\omega)$ (labels "Mode_i", "Mode_j" and "time"): + +$\displaystyle S_k(\omega) = \sum_{i=1}^N{\sum_{j=1}^N{\phi_{ik} \phi_{jk} R_{ij}(\omega)}}$ + +- If pin 5 is true: RPSD response is computed from harmonic results amplitude (label "input_dof_index" and "time") and input PSD matrix $\bar{S}(\omega)$ (labels "input_dof_index_i", "input_dof_index_j" and "time"): + +$\displaystyle S_k(\omega) = \sum_{i=1}^N{\sum_{j=1}^N{u_{ik}(\omega) u_{jk}(\omega) \bar{S}_{ij}(\omega)}}$ + +**Absolute/relative response computation**: + +- If static shapes (pin 1) are provided and non-empty: computes absolute response ($\sigma^2 = \sigma_{\text{rel}}^2 + \sigma_{\text{stat}}^2 + 2 \sigma_{\text{rel,stat}}^2$). + +- If static shapes are empty or not provided: computes relative response from mode-mode covariance terms only ($\sigma^2 = \sigma_{\text{rel}}^2$). + +- If input mode shapes or harmonic results are empty: output contains an empty field with the same label structure and support as the covariance matrix input. + +available inputs: `mode_shapes` (FieldsContainer), `static_shapes` (FieldsContainer) (optional), `rel_rel_covar_matrix` (FieldsContainer), `stat_stat_covar_matrix` (FieldsContainer) (optional), `rel_stat_covar_matrix` (FieldsContainer) (optional), `is_rpsd_from_harm` (bool) (optional) available outputs: `psd` (FieldsContainer) @@ -19,6 +41,7 @@ available outputs: `psd` (FieldsContainer) * **rel_rel_covar_matrix** * **stat_stat_covar_matrix** * **rel_stat_covar_matrix** +* **is_rpsd_from_harm** * **config** **Example:** @@ -26,38 +49,42 @@ available outputs: `psd` (FieldsContainer) ```python op = expansion_psd() -op = expansion_psd(mode_shapes=my_mode_shapes,static_shapes=my_static_shapes,rel_rel_covar_matrix=my_rel_rel_covar_matrix,stat_stat_covar_matrix=my_stat_stat_covar_matrix,rel_stat_covar_matrix=my_rel_stat_covar_matrix) +op = expansion_psd(mode_shapes=my_mode_shapes,static_shapes=my_static_shapes,rel_rel_covar_matrix=my_rel_rel_covar_matrix,stat_stat_covar_matrix=my_stat_stat_covar_matrix,rel_stat_covar_matrix=my_rel_stat_covar_matrix,is_rpsd_from_harm=my_is_rpsd_from_harm) ``` ## Inputs ### mode_shapes -Fields container containing the mode shapes from modal analysis file: mode shapes for dynamic and pseudo-static displacements +Fields container containing the expansion vectors (mode shapes or harmonic results). Label conventions are defined by pin 5. **Type:** *LinkableInput* ### static_shapes -Fields container containing the static shapes (base excitations) from spectral analysis file +Fields container containing the static shapes (base excitations) from spectral analysis file. If not empty, pins 3 and 4 are required. **Type:** *LinkableInput* ### rel_rel_covar_matrix -Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration mode-mode shapes +Fields container containing the dynamic covariance or PSD matrix (relative-relative term). Covariance and PSD matrices can both represent displacement, velocity, or acceleration. Label conventions are defined by pin 5. **Type:** *LinkableInput* ### stat_stat_covar_matrix -Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration static-static shapes +Fields container containing the static covariance or PSD matrix (static-static term). Covariance and PSD matrices can both represent displacement, velocity, or acceleration. Label conventions are defined by pin 5. **Type:** *LinkableInput* ### rel_stat_covar_matrix -Fields container containing covariance matrices from a psd file: covariance matrix terms for displacement/velocity/acceleration mode-static shapes +Fields container containing the dynamic-static covariance or PSD matrix (relative-static term). Covariance and PSD matrices can both represent displacement, velocity, or acceleration. Label conventions are defined by pin 5. + +**Type:** *LinkableInput* + +### is_rpsd_from_harm **Type:** *LinkableInput* @@ -65,7 +92,7 @@ Fields container containing covariance matrices from a psd file: covariance matr ### psd -PSD solution per label +Response PSD (if frequency-dependent matrices) or 1-sigma response per output label space. Can contain an empty field when mode shapes are empty. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/exponential_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/exponential_fc.md index 24795b62a1..483e56d99e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/exponential_fc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/exponential_fc.md @@ -2,7 +2,7 @@ uid: Ans.DataProcessing.operators.math.exponential_fc --- -# *class* exponential_fc(fields_container: object = None, config: OperatorConfig = None) +# *class* exponential_fc(fields_container: object = None, apply_to_time_freq_support: object = None, config: OperatorConfig = None) Computes the entity-wise [exponential function](https://en.wikipedia.org/wiki/Exponential_function): @@ -12,7 +12,7 @@ The input must be dimensionless; a dimensional input raises an error. The output is dimensionless. -available inputs: `fields_container` (FieldsContainer) +available inputs: `fields_container` (FieldsContainer), `apply_to_time_freq_support` (bool) (optional) available outputs: `fields_container` (FieldsContainer) @@ -21,6 +21,7 @@ available outputs: `fields_container` (FieldsContainer) **Parameters:** * **fields_container** +* **apply_to_time_freq_support** * **config** **Example:** @@ -28,7 +29,7 @@ available outputs: `fields_container` (FieldsContainer) ```python op = exponential_fc() -op = exponential_fc(fields_container=my_fields_container) +op = exponential_fc(fields_container=my_fields_container,apply_to_time_freq_support=my_apply_to_time_freq_support) ``` ## Inputs @@ -39,6 +40,12 @@ Dimensionless field, fields container, or numeric data. **Type:** *LinkableInput* +### apply_to_time_freq_support + +Boolean value indicating if the exponential must be applied to the time/frequency values of the time/frequency support attached to the fields container (if present). Default to false. + +**Type:** *LinkableInput* + ## Outputs ### fields_container diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_approx.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_approx.md index 91a9945776..f10f582fdb 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_approx.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_approx.md @@ -4,9 +4,21 @@ uid: Ans.DataProcessing.operators.math.fft_approx # *class* fft_approx(time_scoping: object = None, mesh_scoping: object = None, entity_to_fit: object = None, component_number: object = None, first_derivative: object = None, second_derivative: object = None, fit_data: object = None, cutoff_fr: object = None, config: OperatorConfig = None) -Computes the fitting curve using FFT filtering and cubic fitting in space (node i: x=time, y=data), with the possibility to compute the first and the second derivatives of the curve. +Computes a frequency-filtered smooth curve fitting using the -available inputs: `time_scoping` (IList int, Scoping, System.Collections.IEnumerable) (optional), `mesh_scoping` (Scoping, ScopingsContainer) (optional), `entity_to_fit` (FieldsContainer), `component_number` (Int32), `first_derivative` (bool), `second_derivative` (bool), `fit_data` (bool), `cutoff_fr` (double, Int32) (optional) +[Fast Fourier Transform](https://en.wikipedia.org/wiki/Fast_Fourier_transform) + +and cubic spline interpolation, operating along the time axis for each spatial entity. + +For each entity (node i), the time-series $y(t)$ is fitted; the FFT filter removes + +frequency components above the cutoff frequency (pin 7), and the cubic spline reconstructs + +the filtered signal at the original time steps. + +First and second time derivatives of the fitted curve are available at output pins 1 and 2. + +available inputs: `time_scoping` (IList int, Scoping, System.Collections.IEnumerable) (optional), `mesh_scoping` (Scoping, ScopingsContainer) (optional), `entity_to_fit` (FieldsContainer), `component_number` (Int32), `first_derivative` (bool) (optional), `second_derivative` (bool) (optional), `fit_data` (bool) (optional), `cutoff_fr` (double, Int32) (optional) available outputs: `fitted_entity_y` (FieldsContainer), `first_der_dy` (FieldsContainer), `second_der_d2y` (FieldsContainer) @@ -36,49 +48,49 @@ op = fft_approx(time_scoping=my_time_scoping,mesh_scoping=my_mesh_scoping,entity ### time_scoping -A time scoping to rescope / split the fields container given as input. +Time scoping to select which time steps are used as input. When omitted, all time steps in the fields container are used. **Type:** *LinkableInput* ### mesh_scoping -A space (mesh entities) scoping (or scopings container) to rescope / split the fields container given as input. +Spatial scoping to restrict which entities are processed. When omitted, all entities in the fields container are processed. **Type:** *LinkableInput* ### entity_to_fit -Data changing in time to be fitted. +Time-varying fields container to fit. Nodal and elemental locations are supported (elemental-nodal inputs are averaged to elemental). **Type:** *LinkableInput* ### component_number -Component number as an integer, for example '0' for X-displacement, '1' for Y-displacement, and so on. +Zero-based index of the component to fit. For example, $0$ for the X-component, $1$ for Y, and so on. Required when the input has more than one component. **Type:** *LinkableInput* ### first_derivative -Calculate the first derivative (bool). The default is false. +When true, computes the first time derivative of the fitted curve at output pin 1. Default is false. **Type:** *LinkableInput* ### second_derivative -Calculate the second derivative (bool). The default is false. +When true, computes the second time derivative of the fitted curve at output pin 2. Default is false. **Type:** *LinkableInput* ### fit_data -Calculate the fitted values (bool). The default is false +When true, computes the fitted values at output pin 0. Default is false. **Type:** *LinkableInput* ### cutoff_fr -Cutoff frequency. +Cutoff frequency for the FFT filter. Harmonics above this frequency are removed before spline fitting. Default is $10$. **Type:** *LinkableInput* @@ -86,19 +98,19 @@ Cutoff frequency. ### fitted_entity_y -The fitted entity is fitted using FFT along the space scoping (node i: x=time, y=data). Fitted Y is expected to be close to the input data. +Fitted time-series fields container. Only produced when pin 6 is true. Same spatial and time layout as the input. **Type:** *LinkableOutput* ### first_der_dy -The first derivative (dY) from the fitted Y. +First time derivative $\mathrm{d}y/\mathrm{d}t$ of the fitted curve. Only produced when pin 4 is true. Same layout as pin 0. **Type:** *LinkableOutput* ### second_der_d2y -The second derivative (d2Y) from the fitted Y. +Second time derivative $\mathrm{d}^2y/\mathrm{d}t^2$ of the fitted curve. Only produced when pin 5 is true. Same layout as pin 0. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_eval.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_eval.md index e4c9ae5791..3cfbbeaf2d 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_eval.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_eval.md @@ -2,11 +2,21 @@ uid: Ans.DataProcessing.operators.math.fft_eval --- -# *class* fft_eval(field_t: object = None, time_scoping: object = None, config: OperatorConfig = None) +# *class* fft_eval(fields_container: object = None, time_scoping: object = None, field_t: object = None, config: OperatorConfig = None) -Evaluate the fast fourier transforms at a given set of fields. +Reconstructs the time-domain signal from a complex FFT coefficients container. -available inputs: `field_t` (Field), `time_scoping` (Scoping) (optional) +For each complex coefficient at frequency $f_k$, evaluates the + +[inverse Fourier series](https://en.wikipedia.org/wiki/Fourier_series): + +$$f(t) = \sum_k \bigl(\mathrm{Re}[k]\,\cos(2\pi f_k t) + \mathrm{Im}[k]\,\sin(2\pi f_k t)\bigr)$$ + +The sum runs over all frequency set IDs in the input, or over the scoping from pin 1 when provided. + +Only scalar fields (one component) are supported. + +available inputs: `fields_container` (FieldsContainer), `time_scoping` (Scoping) (optional), `field_t` (Field) available outputs: `field` (Field), `offset` (Field) @@ -14,8 +24,9 @@ available outputs: `field` (Field), `offset` (Field) **Parameters:** -* **field_t** +* **fields_container** * **time_scoping** +* **field_t** * **config** **Example:** @@ -23,20 +34,26 @@ available outputs: `field` (Field), `offset` (Field) ```python op = fft_eval() -op = fft_eval(field_t=my_field_t,time_scoping=my_time_scoping) +op = fft_eval(fields_container=my_fields_container,time_scoping=my_time_scoping,field_t=my_field_t) ``` ## Inputs -### field_t +### fields_container -field of values to evaluate +Complex FFT coefficients container, as produced by the `fft` operator. Must have a complex label and a frequency-valued time-frequency support. **Type:** *LinkableInput* ### time_scoping -if specified only the results at these set ids are used +Frequency scoping. When provided, only the selected frequency set IDs contribute to the reconstruction. When omitted, all set IDs are used. + +**Type:** *LinkableInput* + +### field_t + +Field of time values at which to evaluate the reconstructed signal. The output contains one entity per entry in this field. **Type:** *LinkableInput* @@ -44,6 +61,8 @@ if specified only the results at these set ids are used ### field +Reconstructed time-domain fields container. One output field per input label combination (excluding the complex label), each evaluated at the time values from pin 2. + **Type:** *LinkableOutput* ### offset diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_gradient_eval.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_gradient_eval.md index cc9f41ee3d..dc8da4612e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_gradient_eval.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_gradient_eval.md @@ -4,7 +4,21 @@ uid: Ans.DataProcessing.operators.math.fft_gradient_eval # *class* fft_gradient_eval(fields_container: object = None, time_scoping: object = None, fs_ratio: object = None, config: OperatorConfig = None) -Evaluate min max based on the fast fourier transform at a given field, using gradient method for adaptative time step. +Reconstitutes the time-domain signal from a complex FFT coefficients container and + +finds its minimum and maximum using an adaptive time-step gradient method. + +For each harmonic component at frequency $f_k$, the signal is: + +$$F(t) = \sum_k A_k \sin(2\pi f_k t - \phi_k + \tfrac{\pi}{2})$$ + +where $A_k$ and $\phi_k$ are the amplitude and phase derived from the complex FFT coefficients. + +The adaptive stepping enlarges the time step when the signal is far from a candidate extremum + +(controlled by the oversampling ratio from pin 2), and refines near the extremum. + +Only scalar fields are supported. available inputs: `fields_container` (FieldsContainer), `time_scoping` (Scoping) (optional), `fs_ratio` (Int32) (optional) @@ -31,17 +45,19 @@ op = fft_gradient_eval(fields_container=my_fields_container,time_scoping=my_time ### fields_container +Complex FFT coefficients container, as produced by the `fft` operator. Must have a complex label and a frequency-valued time-frequency support. Only scalar fields are supported. + **Type:** *LinkableInput* ### time_scoping -if specified only the results at these set ids are used +Frequency scoping. When provided, only the selected frequency set IDs contribute to the reconstruction. When omitted, all set IDs are used. **Type:** *LinkableInput* ### fs_ratio -default value = 20 +Oversampling ratio used to set the base time step as $1/(f_{max} \times \mathit{fs_ratio})$. Default is $20$. **Type:** *LinkableInput* @@ -49,6 +65,8 @@ default value = 20 ### coefficients +Time-domain fields container evaluated at the adaptive time steps. One output field per input label combination (excluding the complex label). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_multi_harmonic_minmax.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_multi_harmonic_minmax.md index 024c0a5b1f..40db259393 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_multi_harmonic_minmax.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/fft_multi_harmonic_minmax.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.math.fft_multi_harmonic_minmax # *class* fft_multi_harmonic_minmax(fields_container: object = None, rpm_scoping: object = None, fs_ratio: object = None, num_subdivisions: object = None, max_num_subdivisions: object = None, num_cycles: object = None, use_harmonic_zero: object = None, calculate_time_series: object = None, substeps_selector: object = None, config: OperatorConfig = None) -Evaluate min max fields on multi harmonic solution. min and max fields are calculated based on evaluating a fourier series sum wrt rpms and using the gradient method for adaptive time steping +Finds the minimum and maximum of a multi-harmonic field over one period using an adaptive time-stepping + +gradient method. The field is expressed as a [Fourier series](https://en.wikipedia.org/wiki/Fourier_series) + +over harmonic orders corresponding to integer multiples of the operating speed (RPMs). + +For each spatial entity, the series is evaluated at adaptively chosen time instants over one period + +and the pointwise minimum and maximum are extracted. + +ElementalNodal locations are not supported. available inputs: `fields_container` (FieldsContainer), `rpm_scoping` (Scoping) (optional), `fs_ratio` (Int32) (optional), `num_subdivisions` (Int32) (optional), `max_num_subdivisions` (Int32) (optional), `num_cycles` (Int32) (optional), `use_harmonic_zero` (bool) (optional), `calculate_time_series` (bool) (optional), `substeps_selector` (IList int, System.Collections.IEnumerable) (optional) @@ -37,53 +47,55 @@ op = fft_multi_harmonic_minmax(fields_container=my_fields_container,rpm_scoping= ### fields_container +Complex multi-harmonic results fields container. Must have a complex label and a time-frequency support whose values are the harmonic excitation frequencies (RPMs). ElementalNodal results are not supported. + **Type:** *LinkableInput* ### rpm_scoping -rpm scoping, by default the fourier series sum is evaluated using all the rpms +RPM scoping. When provided, only the selected RPM set IDs are included in the Fourier series. When omitted, all available RPMs are used. **Type:** *LinkableInput* ### fs_ratio -field or fields container with only one field is expected +Oversampling ratio used to set the uniform time step as $1/(f_{max} \times \mathit{fs_ratio})$. Default is $20$. **Type:** *LinkableInput* ### num_subdivisions -connect number subdivisions, used for uniform discretization +Number of uniform time subdivisions per period. When provided, overrides the adaptive step computation. Default is $-1$ (adaptive). **Type:** *LinkableInput* ### max_num_subdivisions -connect max number subdivisions, used to avoid huge number of sudivisions +Maximum number of time subdivisions to avoid excessively fine discretisation. Default is $8000$. **Type:** *LinkableInput* ### num_cycles -Number of cycle of the periodic signal (default is 2) +Number of periods over which the signal is evaluated. Default is $2$. **Type:** *LinkableInput* ### use_harmonic_zero -use harmonic zero for first rpm (default is false) +When true, includes the harmonic-zero (constant) term for the first RPM. Default is false. **Type:** *LinkableInput* ### calculate_time_series -calculates time series output (output pin 2), setting it to false enhance performance if only min/max are required (default is true) +When true (default), computes the full time series at output pin 2. Set to false to skip the time-series output and only compute min and max, which reduces computation time. **Type:** *LinkableInput* ### substeps_selector -substeps to evaluate (frequencies), by default the operator is evaluated using all the available steps +List of harmonic order (substep) indices to include. When omitted, all available substeps are used. **Type:** *LinkableInput* @@ -91,14 +103,20 @@ substeps to evaluate (frequencies), by default the operator is evaluated using a ### field_min +Fields container of pointwise minimum values over one period. Same spatial layout as the input. + **Type:** *LinkableOutput* ### field_max +Fields container of pointwise maximum values over one period. Same spatial layout as the input. + **Type:** *LinkableOutput* ### all_fields +Full time-series fields container over the evaluation period. Only produced when pin 7 is true (default). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md index fd4a0e4c65..3bd04704fa 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md @@ -15,7 +15,7 @@ uid: Ans.DataProcessing.operators.math | [accumulate_level_over_label_fc](Ans_DataProcessing_operators_math_accumulate_level_over_label_fc.md) | Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container and apply 10.0xlog10(data/10xx-12) on the result. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs. ///available inputs: fields_container (FieldsContainer), label (string) (optional) | | [accumulate_min_over_label_fc](Ans_DataProcessing_operators_math_accumulate_min_over_label_fc.md) | Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container and take its opposite. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs. ///available inputs: fields_container (FieldsContainer), label (string) (optional) | | [accumulate_over_label_fc](Ans_DataProcessing_operators_math_accumulate_over_label_fc.md) | Compute the component-wise sum over all the fields that have the same ID as the label set as input in the fields container. This computation can be incremental. If the input fields container is connected and the operator is run multiple times, the output field will be on all the connected inputs. ///available inputs: fields_container (FieldsContainer), label (string) (optional) | -| [accumulation_per_scoping](Ans_DataProcessing_operators_math_accumulation_per_scoping.md) | This operator calculates the sum and the percentage of total sum of the input fields container for each scoping of the scopings container. ///available inputs: fields_container (FieldsContainer), mesh_scoping (Scoping) (optional), streams_container (StreamsContainer), data_sources (DataSources), scopings_container (ScopingsContainer) | +| [accumulation_per_scoping](Ans_DataProcessing_operators_math_accumulation_per_scoping.md) | For each scoping in the input scopings container, computes the entity-wise sum of the input fields container values over that scoping, and the percentage of that sum relative to a master sum. | | [add](Ans_DataProcessing_operators_math_add.md) | add() | | [add_constant](Ans_DataProcessing_operators_math_add_constant.md) | add_constant() | | [add_constant_fc](Ans_DataProcessing_operators_math_add_constant_fc.md) | add_constant_fc() | @@ -43,15 +43,15 @@ uid: Ans.DataProcessing.operators.math | [dot](Ans_DataProcessing_operators_math_dot.md) | DEPRECATED, PLEASE USE GENERALIZED INNER PRODUCT. Computes element - wise dot product between two vector fields. If one field's scoping has an 'overall' location, then this field's values are applied on the other field entirely.When using a constant or 'work_by_index', you can use 'inplace' to reuse one of the fields, but only in the case where both fields are scalar. ///available inputs: fieldA (Field, FieldsContainer), fieldB (Field, FieldsContainer) | | [dot_tensor](Ans_DataProcessing_operators_math_dot_tensor.md) | DEPRECATED, PLEASE USE GENERALIZED INNER PRODUCT. Computes entity-wise dot product between two tensor fields. ///available inputs: fieldA (Field, FieldsContainer), fieldB (Field, FieldsContainer) | | [eim_solver](Ans_DataProcessing_operators_math_eim_solver.md) | eim_solver() | -| [entity_extractor](Ans_DataProcessing_operators_math_entity_extractor.md) | Extracts an entity from a field, based on its ID. ///available inputs: fieldA (Field), scalar_int (Int32) | -| [expansion_psd](Ans_DataProcessing_operators_math_expansion_psd.md) | Computes the PSD response for one-sigma solution. ///available inputs: mode_shapes (FieldsContainer), static_shapes (FieldsContainer) (optional), rel_rel_covar_matrix (FieldsContainer), stat_stat_covar_matrix (FieldsContainer) (optional), rel_stat_covar_matrix (FieldsContainer) (optional) | +| [entity_extractor](Ans_DataProcessing_operators_math_entity_extractor.md) | Extracts a single scalar value from a field by its zero-based scoping index $k$ (pin 1). | +| [expansion_psd](Ans_DataProcessing_operators_math_expansion_psd.md) | Computes the response power spectral density (RPSD) or 1-sigma response from a PSD analysis by combining mode shapes (or harmonic results), covariance matrices, and optionally static shapes. | | [exponential](Ans_DataProcessing_operators_math_exponential.md) | exponential() | | [exponential_fc](Ans_DataProcessing_operators_math_exponential_fc.md) | Computes the entity-wise [exponential function](https://en.wikipedia.org/wiki/Exponential_function): | | [fastnvh_loadfile](Ans_DataProcessing_operators_math_fastnvh_loadfile.md) | fastnvh_loadfile() | -| [fft_approx](Ans_DataProcessing_operators_math_fft_approx.md) | Computes the fitting curve using FFT filtering and cubic fitting in space (node i: x=time, y=data), with the possibility to compute the first and the second derivatives of the curve. ///available inputs: time_scoping (IList int, Scoping, System.Collections.IEnumerable) (optional), mesh_scoping (Scoping, ScopingsContainer) (optional), entity_to_fit (FieldsContainer), component_number (Int32), first_derivative (bool), second_derivative (bool), fit_data (bool), cutoff_fr (double, Int32) (optional) | -| [fft_eval](Ans_DataProcessing_operators_math_fft_eval.md) | Evaluate the fast fourier transforms at a given set of fields. ///available inputs: field_t (Field), time_scoping (Scoping) (optional) | -| [fft_gradient_eval](Ans_DataProcessing_operators_math_fft_gradient_eval.md) | Evaluate min max based on the fast fourier transform at a given field, using gradient method for adaptative time step. ///available inputs: fields_container (FieldsContainer), time_scoping (Scoping) (optional), fs_ratio (Int32) (optional) | -| [fft_multi_harmonic_minmax](Ans_DataProcessing_operators_math_fft_multi_harmonic_minmax.md) | Evaluate min max fields on multi harmonic solution. min and max fields are calculated based on evaluating a fourier series sum wrt rpms and using the gradient method for adaptive time steping ///available inputs: fields_container (FieldsContainer), rpm_scoping (Scoping) (optional), fs_ratio (Int32) (optional), num_subdivisions (Int32) (optional), max_num_subdivisions (Int32) (optional), num_cycles (Int32) (optional), use_harmonic_zero (bool) (optional), calculate_time_series (bool) (optional), substeps_selector (IList int, System.Collections.IEnumerable) (optional) | +| [fft_approx](Ans_DataProcessing_operators_math_fft_approx.md) | Computes a frequency-filtered smooth curve fitting using the | +| [fft_eval](Ans_DataProcessing_operators_math_fft_eval.md) | Reconstructs the time-domain signal from a complex FFT coefficients container. | +| [fft_gradient_eval](Ans_DataProcessing_operators_math_fft_gradient_eval.md) | Reconstitutes the time-domain signal from a complex FFT coefficients container and | +| [fft_multi_harmonic_minmax](Ans_DataProcessing_operators_math_fft_multi_harmonic_minmax.md) | Finds the minimum and maximum of a multi-harmonic field over one period using an adaptive time-stepping | | [generalized_inner_product](Ans_DataProcessing_operators_math_generalized_inner_product.md) | generalized_inner_product() | | [generalized_inner_product_fc](Ans_DataProcessing_operators_math_generalized_inner_product_fc.md) | generalized_inner_product_fc() | | [img_part](Ans_DataProcessing_operators_math_img_part.md) | Extracts the imaginary-part fields (complex label 1) from a complex-valued fields container. | @@ -62,9 +62,9 @@ uid: Ans.DataProcessing.operators.math | [linearized_stress](Ans_DataProcessing_operators_math_linearized_stress.md) | get linearized stress ///available inputs: stress_comps (FieldsContainer), iComp (Int32), path_coords (Field), rho (double), kbr (Int32), ksxbzro (Int32), out_type (Int32) | | [ln](Ans_DataProcessing_operators_math_ln.md) | ln() | | [ln_fc](Ans_DataProcessing_operators_math_ln_fc.md) | Computes the entity-wise [natural logarithm](https://en.wikipedia.org/wiki/Natural_logarithm): | -| [mac](Ans_DataProcessing_operators_math_mac.md) | Computes MAC Matrix between two fields container, both for real and complex cases. For mixed cases (real-complex and complex) only the real part is considered. Providing inputs with the same component scoping is an user responsability. ///available inputs: fields_containerA (FieldsContainer), fields_containerB (FieldsContainer), weights (Field) | -| [make_one_on_comp](Ans_DataProcessing_operators_math_make_one_on_comp.md) | Takes the input field's scoping and creates a field full of zeros, except for the indexes from pin 1 that will hold 1.0. ///available inputs: fieldA (Field), scalar_int (Int32) | -| [matrix_inverse](Ans_DataProcessing_operators_math_matrix_inverse.md) | Computes the complex matrix inverse for each field in the given fields container. ///available inputs: fields_container (FieldsContainer) | +| [mac](Ans_DataProcessing_operators_math_mac.md) | Computes the [Modal Assurance Criterion (MAC)](https://ansyshelp.ansys.com/public/account/secured?returnurl=/Views/Secured/corp/v261/en/ans_thry/thy_post16.html) | +| [make_one_on_comp](Ans_DataProcessing_operators_math_make_one_on_comp.md) | Returns a scalar field with the same scoping as the input field. | +| [matrix_inverse](Ans_DataProcessing_operators_math_matrix_inverse.md) | Computes the [matrix inverse](https://en.wikipedia.org/wiki/Invertible_matrix) | | [matrix_product](Ans_DataProcessing_operators_math_matrix_product.md) | matrix_product() | | [matrix_product_fc](Ans_DataProcessing_operators_math_matrix_product_fc.md) | matrix_product_fc() | | [minus](Ans_DataProcessing_operators_math_minus.md) | minus() | @@ -83,7 +83,7 @@ uid: Ans.DataProcessing.operators.math | [polar_to_cplx](Ans_DataProcessing_operators_math_polar_to_cplx.md) | Converts a complex-valued fields container from | | [pow](Ans_DataProcessing_operators_math_pow.md) | Computes entity-wise field[i]^p. ///available inputs: field (Field), factor (double), division_by_zero_value (double) (optional) | | [pow_fc](Ans_DataProcessing_operators_math_pow_fc.md) | Computes entity-wise field[i]^p. ///available inputs: fields_container (FieldsContainer), factor (double), division_by_zero_value (double) (optional) | -| [qr_solve](Ans_DataProcessing_operators_math_qr_solve.md) | Computes the solution using QR factorization. ///available inputs: fields_container (FieldsContainer), rhs (FieldsContainer) | +| [qr_solve](Ans_DataProcessing_operators_math_qr_solve.md) | Solves the linear system $A x = b$ using | | [real_part](Ans_DataProcessing_operators_math_real_part.md) | Extracts the real-part fields (complex label 0) from a complex-valued fields container. | | [relative_error](Ans_DataProcessing_operators_math_relative_error.md) | relative_error() | | [scale](Ans_DataProcessing_operators_math_scale.md) | scale() | @@ -96,12 +96,12 @@ uid: Ans.DataProcessing.operators.math | [sqr_fc](Ans_DataProcessing_operators_math_sqr_fc.md) | Computes the entity-wise square | | [sqrt](Ans_DataProcessing_operators_math_sqrt.md) | Computes the entity-wise square root | | [sqrt_fc](Ans_DataProcessing_operators_math_sqrt_fc.md) | Computes the entity-wise square root | -| [svd](Ans_DataProcessing_operators_math_svd.md) | Computes the matrix singular value decomposition (SVD) for each field in the given fields container. ///available inputs: fields_container (FieldsContainer) | +| [svd](Ans_DataProcessing_operators_math_svd.md) | Computes the [Singular Value Decomposition (SVD)](https://en.wikipedia.org/wiki/Singular_value_decomposition) | | [sweeping_phase](Ans_DataProcessing_operators_math_sweeping_phase.md) | Projects a [phasor](https://en.wikipedia.org/wiki/Phasor) field onto a given phase angle $\theta$: | | [sweeping_phase_fc](Ans_DataProcessing_operators_math_sweeping_phase_fc.md) | Projects every [phasor](https://en.wikipedia.org/wiki/Phasor) field pair in the input fields container | -| [time_derivation](Ans_DataProcessing_operators_math_time_derivation.md) | Derives a field of time varying quantities with respect to time ///available inputs: field (Field), spline_fitting (bool) (optional) | +| [time_derivation](Ans_DataProcessing_operators_math_time_derivation.md) | Computes the time [derivative](https://en.wikipedia.org/wiki/Derivative) of a scalar | | [time_freq_interpolation](Ans_DataProcessing_operators_math_time_freq_interpolation.md) | time_freq_interpolation() | -| [time_integration](Ans_DataProcessing_operators_math_time_integration.md) | Integrates a field of time varying quantities over time ///available inputs: field (Field), resample_output (bool) (optional), absolute_error (double) (optional), minimum_step_size (double) (optional), integration_constant (double) (optional) | +| [time_integration](Ans_DataProcessing_operators_math_time_integration.md) | Computes the cumulative [integral](https://en.wikipedia.org/wiki/Integral) of a scalar | | [unit_convert](Ans_DataProcessing_operators_math_unit_convert.md) | Converts an input entity from one unit to another using the linear relation | | [unit_convert_fc](Ans_DataProcessing_operators_math_unit_convert_fc.md) | Converts a fields container from one unit to another using the linear relation | | [window_bartlett](Ans_DataProcessing_operators_math_window_bartlett.md) | Apply bartlett windowing on a given FieldsContainer having time label or a Field located on time. Assume that time sampling is evenly spaced (use time_freq_interpolation before otherwise). ///available inputs: field (Field, FieldsContainer) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/ln_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/ln_fc.md index 4d9964abc5..2d4035c8d6 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/ln_fc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/ln_fc.md @@ -2,7 +2,7 @@ uid: Ans.DataProcessing.operators.math.ln_fc --- -# *class* ln_fc(fields_container: object = None, config: OperatorConfig = None) +# *class* ln_fc(fields_container: object = None, apply_to_time_freq_support: object = None, config: OperatorConfig = None) Computes the entity-wise [natural logarithm](https://en.wikipedia.org/wiki/Natural_logarithm): @@ -12,7 +12,7 @@ The input must be dimensionless; a dimensional input raises an error. The output is dimensionless. -available inputs: `fields_container` (FieldsContainer) +available inputs: `fields_container` (FieldsContainer), `apply_to_time_freq_support` (bool) (optional) available outputs: `fields_container` (FieldsContainer) @@ -21,6 +21,7 @@ available outputs: `fields_container` (FieldsContainer) **Parameters:** * **fields_container** +* **apply_to_time_freq_support** * **config** **Example:** @@ -28,7 +29,7 @@ available outputs: `fields_container` (FieldsContainer) ```python op = ln_fc() -op = ln_fc(fields_container=my_fields_container) +op = ln_fc(fields_container=my_fields_container,apply_to_time_freq_support=my_apply_to_time_freq_support) ``` ## Inputs @@ -39,6 +40,12 @@ Dimensionless field, fields container, or numeric data. **Type:** *LinkableInput* +### apply_to_time_freq_support + +Boolean value indicating if the natural logarithm must be applied to the time/frequency values of the time/frequency support attached to the fields container (if present). Default to false. + +**Type:** *LinkableInput* + ## Outputs ### fields_container diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mac.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mac.md index 3a117545de..013e3354a9 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mac.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mac.md @@ -4,9 +4,23 @@ uid: Ans.DataProcessing.operators.math.mac # *class* mac(fields_containerA: object = None, fields_containerB: object = None, weights: object = None, config: OperatorConfig = None) -Computes MAC Matrix between two fields container, both for real and complex cases. For mixed cases (real-complex and complex) only the real part is considered. Providing inputs with the same component scoping is an user responsability. +Computes the [Modal Assurance Criterion (MAC)](https://ansyshelp.ansys.com/public/account/secured?returnurl=/Views/Secured/corp/v261/en/ans_thry/thy_post16.html) -available inputs: `fields_containerA` (FieldsContainer), `fields_containerB` (FieldsContainer), `weights` (Field) +matrix between two sets of mode shapes. + +For each pair of modes $\phi_i$ (from container A) and $\phi_j$ (from container B): + +$$MAC_{ij} = \frac{|\phi_i^{\,*T} M \phi_j|^2}{(\phi_i^{\,*T} M \phi_i)(\phi_j^{\,*T} M \phi_j)}$$ + +where $^{*T}$ denotes the conjugate transpose and $M$ is the optional mass weighting matrix. + +When $M$ is omitted, the standard (unweighted) inner product is used. + +For mixed real-complex input (one container real, one complex), only the real parts are used. + +Both containers must share the same number of components; this is not verified by the operator. + +available inputs: `fields_containerA` (FieldsContainer), `fields_containerB` (FieldsContainer), `weights` (Field) (optional) available outputs: `field` (Field) @@ -31,19 +45,19 @@ op = mac(fields_containerA=my_fields_containerA,fields_containerB=my_fields_cont ### fields_containerA -Fields Container A. +Fields container $A$. Must have a time label and contain one field per mode shape. **Type:** *LinkableInput* ### fields_containerB -Fields Container B. +Fields container $B$. Must have a time label and contain one field per mode shape. **Type:** *LinkableInput* ### weights -Field M, optional weighting for MAC Matrix computation. +Optional mass weighting field $M$. When omitted, the standard unweighted inner product is used. **Type:** *LinkableInput* @@ -57,7 +71,7 @@ Deprecated alias of: weights ### field -MAC Matrix for all the combinations between mode fields of Field Container A and Field Container B. Results listed row by row. +MAC matrix of size $N_A \times N_B$, where $N_A$ and $N_B$ are the number of mode shapes in containers A and B respectively. Entries are stored row by row: entry at position $(i,j)$ is $MAC_{ij}$. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/make_one_on_comp.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/make_one_on_comp.md index 92d412053c..5b9bd9b4cf 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/make_one_on_comp.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/make_one_on_comp.md @@ -4,7 +4,15 @@ uid: Ans.DataProcessing.operators.math.make_one_on_comp # *class* make_one_on_comp(fieldA: object = None, scalar_int: object = None, config: OperatorConfig = None) -Takes the input field's scoping and creates a field full of zeros, except for the indexes from pin 1 that will hold 1.0. +Returns a scalar field with the same scoping as the input field. + +All values are set to $0.0$, except for entity at index $k$ in the scoping (pin 1) where the value is set to $1.0$. + +This produces the standard basis vector $e_k$ over the input scoping. + +The output is always scalar (one component per entity), regardless of the input field's dimensionality. + +Note: $k$ is the zero-based iteration index within the field's scoping, not the entity ID. available inputs: `fieldA` (Field), `scalar_int` (Int32) @@ -30,16 +38,22 @@ op = make_one_on_comp(fieldA=my_fieldA,scalar_int=my_scalar_int) ### fieldA +Input field. Its scoping is used as the scoping of the output field. + **Type:** *LinkableInput* ### scalar_int +Zero-based iteration index $k$ of the entity to set to $1.0$. + **Type:** *LinkableInput* ## Outputs ### field +Scalar output field (one component per entity) with the same scoping as the input. All values are $0.0$ except the entity at iteration index $k$ which holds $1.0$. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/matrix_inverse.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/matrix_inverse.md index 67665eb418..ea2a7a38cb 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/matrix_inverse.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/matrix_inverse.md @@ -4,7 +4,15 @@ uid: Ans.DataProcessing.operators.math.matrix_inverse # *class* matrix_inverse(fields_container: object = None, config: OperatorConfig = None) -Computes the complex matrix inverse for each field in the given fields container. +Computes the [matrix inverse](https://en.wikipedia.org/wiki/Invertible_matrix) + +for each complex square matrix field in the input fields container. + +Both real and imaginary parts must be present (complex label required). + +The input fields must be square ($n \times n$) matrices; non-square inputs throw an error. + +The output unit is the inverse of the input unit. available inputs: `fields_container` (FieldsContainer) @@ -29,7 +37,7 @@ op = matrix_inverse(fields_container=my_fields_container) ### fields_container -fields_container +Fields container of complex square matrix fields to invert. Must have a complex label with real (index 0) and imaginary (index 1) parts. Each field must be a square matrix. **Type:** *LinkableInput* @@ -37,6 +45,8 @@ fields_container ### fields_container +Fields container of inverted complex matrices. Same label structure as the input. Unit is the inverse of the input unit. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/modal_damping_ratio.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/modal_damping_ratio.md index 45c95d2189..7c8b92e8aa 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/modal_damping_ratio.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/modal_damping_ratio.md @@ -59,7 +59,7 @@ global stiffness matrix multiplier ### field -field of modal damping ratio. +Field of modal damping ratios $\xi_i$, one value per mode, in the same order as the input natural frequencies. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/qr_solve.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/qr_solve.md index a759614005..759d639496 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/qr_solve.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/qr_solve.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.math.qr_solve # *class* qr_solve(fields_container: object = None, rhs: object = None, config: OperatorConfig = None) -Computes the solution using QR factorization. +Solves the linear system $A x = b$ using + +[QR factorization](https://en.wikipedia.org/wiki/QR_decomposition). + +For each time set, $A$ (pin 0) is factored via QR and the solution $x$ is obtained by back-substitution + +against $b$ (pin 1). Both real and complex systems are supported. + +The input matrix $A$ must have at least as many rows as columns. + +The output unit is (unit of $b$) / (unit of $A$). available inputs: `fields_container` (FieldsContainer), `rhs` (FieldsContainer) @@ -30,13 +40,13 @@ op = qr_solve(fields_container=my_fields_container,rhs=my_rhs) ### fields_container -fields_container +Fields container representing the matrix $A$. May be real or complex (complex label required for complex systems). **Type:** *LinkableInput* ### rhs -fields_container +Fields container representing the right-hand side $b$. Must have the same number of rows as $A$ and matching label structure. **Type:** *LinkableInput* @@ -44,6 +54,8 @@ fields_container ### fields_container +Solution fields container $x$ satisfying $A x \approx b$. Same label structure as the input. Unit is (unit of $b$) / (unit of $A$). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/svd.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/svd.md index 21b291b855..8d80607ee6 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/svd.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/svd.md @@ -4,7 +4,15 @@ uid: Ans.DataProcessing.operators.math.svd # *class* svd(fields_container: object = None, config: OperatorConfig = None) -Computes the matrix singular value decomposition (SVD) for each field in the given fields container. +Computes the [Singular Value Decomposition (SVD)](https://en.wikipedia.org/wiki/Singular_value_decomposition) + +$A = U \Sigma V^{*T}$ for each matrix field in the input fields container. + +Both real and complex matrices are supported. + +The decomposition satisfies $A = U S V^T$ (real) or $A = U S V^{*T}$ (complex), + +where $S$ contains the singular values, $U$ is left-unitary, and $V^T$ (or $V^{*T}$) is right-unitary. available inputs: `fields_container` (FieldsContainer) @@ -29,7 +37,7 @@ op = svd(fields_container=my_fields_container) ### fields_container -fields_container +Fields container of matrix fields to decompose. May be real or complex (complex label required for complex inputs). Each field must represent a matrix. **Type:** *LinkableInput* @@ -37,19 +45,19 @@ fields_container ### s_svd -Singular values of the input data, where A=U.S.Vt +Singular values $S$ of the decomposition $A = U S V^{*T}$. Same label structure as the input. **Type:** *LinkableOutput* ### u_svd -U of the input data, where A=U.S.Vt +Left unitary matrix $U$ of the decomposition $A = U S V^{*T}$. Same label structure as the input. **Type:** *LinkableOutput* ### vt_svd -Vt of the input data, where A=U.S.Vt +Conjugate transpose of the right unitary matrix $V^{*T}$ of the decomposition $A = U S V^{*T}$. Same label structure as the input. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_derivation.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_derivation.md index 5700bfe90f..1b8fdfd313 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_derivation.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_derivation.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.math.time_derivation # *class* time_derivation(field: object = None, spline_fitting: object = None, config: OperatorConfig = None) -Derives a field of time varying quantities with respect to time +Computes the time [derivative](https://en.wikipedia.org/wiki/Derivative) of a scalar + +time-varying field. + +The input field must have a time-frequency support that provides the time values. + +When `spline_fitting` (pin 1) is true, the derivative is computed from a + +[cubic spline](https://en.wikipedia.org/wiki/Cubic_spline) fit through the input data, + +producing smooth derivatives. When false (default), finite differences are used. available inputs: `field` (Field), `spline_fitting` (bool) (optional) @@ -30,13 +40,13 @@ op = time_derivation(field=my_field,spline_fitting=my_spline_fitting) ### field -field +Scalar time-varying field to differentiate. Must have a time-frequency support. **Type:** *LinkableInput* ### spline_fitting -Uses spline fitting on the input field to compute smooth derivatives +When true, fits a cubic spline to the input data and computes the derivative analytically from the spline. When false (default), uses finite differences. **Type:** *LinkableInput* @@ -44,6 +54,8 @@ Uses spline fitting on the input field to compute smooth derivatives ### field +Time derivative field. Has the same time support and scoping as the input. Unit is (input unit / second). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_freq_interpolation.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_freq_interpolation.md index e3d32ebf7d..f4d8c93bdf 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_freq_interpolation.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_freq_interpolation.md @@ -2,11 +2,11 @@ uid: Ans.DataProcessing.operators.math.time_freq_interpolation --- -# *class* time_freq_interpolation(fields_container: object = None, time_freq_values: object = None, step: object = None, interpolation_type: object = None, force_new_time_freq_support: object = None, time_freq_support: object = None, config: OperatorConfig = None) +# *class* time_freq_interpolation(fields_container: object = None, time_freq_values: object = None, step: object = None, interpolation_type: object = None, force_new_time_freq_support: object = None, interpolation_scale: object = None, time_freq_support: object = None, config: OperatorConfig = None) time_freq_interpolation() -time_freq_interpolation(fields_container: object, time_freq_values: object, step: object, interpolation_type: object, force_new_time_freq_support: object, time_freq_support: object, config: OperatorConfig) +time_freq_interpolation(fields_container: object, time_freq_values: object, step: object, interpolation_type: object, force_new_time_freq_support: object, interpolation_scale: object, time_freq_support: object, config: OperatorConfig) time_freq_interpolation(config: OperatorConfig) @@ -21,6 +21,7 @@ time_freq_interpolation(config: OperatorConfig) * **step** * **interpolation_type** * **force_new_time_freq_support** +* **interpolation_scale** * **time_freq_support** * **config** @@ -54,6 +55,12 @@ If set to true, the output fields container will always have a new time freq sup **Type:** *LinkableInput* +### interpolation_scale + +Integer indicating the scale in which interpolation is performed: 0 (linear scale - default), 1 (log-log scale). + +**Type:** *LinkableInput* + ### time_freq_support **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_integration.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_integration.md index c89690105b..110fe4f35c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_integration.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/time_integration.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.math.time_integration # *class* time_integration(field: object = None, resample_output: object = None, absolute_error: object = None, minimum_step_size: object = None, integration_constant: object = None, config: OperatorConfig = None) -Integrates a field of time varying quantities over time +Computes the cumulative [integral](https://en.wikipedia.org/wiki/Integral) of a scalar + +time-varying field using adaptive numerical integration. + +The input field must have a time-frequency support that provides the time values. + +When `resample_output` (pin 1) is true, the output time steps are resampled by the integrator + +(producing a new time support); when false, the output reuses the input time support. + +The optional integration constant (pin 4) is added to all output values as an initial condition. available inputs: `field` (Field), `resample_output` (bool) (optional), `absolute_error` (double) (optional), `minimum_step_size` (double) (optional), `integration_constant` (double) (optional) @@ -33,31 +43,31 @@ op = time_integration(field=my_field,resample_output=my_resample_output,absolute ### field -field +Scalar time-varying field to integrate. Must have a time-frequency support. **Type:** *LinkableInput* ### resample_output -Resample the output +When true, the output is resampled to an adaptively chosen set of time steps. When false (default), the output uses the same time support as the input. **Type:** *LinkableInput* ### absolute_error -Absolute error for the resampling +Absolute error tolerance for the resampling step. Only used when pin 1 is true. **Type:** *LinkableInput* ### minimum_step_size -Minimum time step size for the resamplig +Minimum time step size allowed during resampling. Only used when pin 1 is true. **Type:** *LinkableInput* ### integration_constant -Constant to be added to the integrated field +Constant added to all integrated values as an initial condition. Default is $0$. **Type:** *LinkableInput* @@ -65,6 +75,8 @@ Constant to be added to the integrated field ### field +Integrated scalar field. Has the same unit as (input unit $\times$ second). The time support is either the input support (when pin 1 is false) or a resampled support (when pin 1 is true). + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md index 76dceb0943..94b1ee61aa 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md @@ -34,7 +34,7 @@ op = mapdl_split_on_facet_indices(fields_container=my_fields_container,property_ ### fields_container -Fields container to split, with generic number of labels (e.g. time, zone, complex...), and the Fields of the FieldsContainer will have location Elemental and the Scoping Ids will be the Element Ids on the skin mesh. +Fields container to split, with generic number of labels (e.g. time, zone, complex...). Fields may have Elemental or ElementalNodal location; scoping ids are skin element ids. **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/write_motion_dfmf_file.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/write_motion_dfmf_file.md index 3860c084fa..35e18fc29a 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/write_motion_dfmf_file.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/write_motion_dfmf_file.md @@ -2,11 +2,11 @@ uid: Ans.DataProcessing.operators.result.write_motion_dfmf_file --- -# *class* write_motion_dfmf_file(model_data: object = None, mode_shapes: object = None, lumped_mass: object = None, field_coordinates: object = None, nod: object = None, used_node_index: object = None, eigenvalue: object = None, translational_mode_shape: object = None, rotational_mode_shape: object = None, invrt_1: object = None, invrt_2: object = None, invrt_3: object = None, invrt_4: object = None, invrt_5: object = None, invrt_6: object = None, invrt_7: object = None, invrt_8: object = None, dfmffile_path: object = None, rstfile_path: object = None, config: OperatorConfig = None) +# *class* write_motion_dfmf_file(model_data: object = None, mode_shapes: object = None, lumped_mass: object = None, field_coordinates: object = None, nod: object = None, used_node_index: object = None, eigenvalue: object = None, translational_mode_shape: object = None, rotational_mode_shape: object = None, invrt_1: object = None, invrt_2: object = None, invrt_3: object = None, invrt_4: object = None, invrt_5: object = None, invrt_6: object = None, invrt_7: object = None, invrt_8: object = None, dfmffile_path: object = None, rstfile_path: object = None, output_node_type: object = None, wireframe_threshold_scale: object = None, edge_decimation_angular_limit_in_radian: object = None, config: OperatorConfig = None) write_motion_dfmf_file() -write_motion_dfmf_file(model_data: object, mode_shapes: object, lumped_mass: object, field_coordinates: object, nod: object, used_node_index: object, eigenvalue: object, translational_mode_shape: object, rotational_mode_shape: object, invrt_1: object, invrt_2: object, invrt_3: object, invrt_4: object, invrt_5: object, invrt_6: object, invrt_7: object, invrt_8: object, dfmffile_path: object, rstfile_path: object, config: OperatorConfig) +write_motion_dfmf_file(model_data: object, mode_shapes: object, lumped_mass: object, field_coordinates: object, nod: object, used_node_index: object, eigenvalue: object, translational_mode_shape: object, rotational_mode_shape: object, invrt_1: object, invrt_2: object, invrt_3: object, invrt_4: object, invrt_5: object, invrt_6: object, invrt_7: object, invrt_8: object, dfmffile_path: object, rstfile_path: object, output_node_type: object, wireframe_threshold_scale: object, edge_decimation_angular_limit_in_radian: object, config: OperatorConfig) write_motion_dfmf_file(config: OperatorConfig) @@ -35,6 +35,9 @@ write_motion_dfmf_file(config: OperatorConfig) * **invrt_8** * **dfmffile_path** * **rstfile_path** +* **output_node_type** +* **wireframe_threshold_scale** +* **edge_decimation_angular_limit_in_radian** * **config** ## Inputs @@ -125,6 +128,24 @@ path with motion dfmf extension where the export occurs **Type:** *LinkableInput* +### output_node_type + +defines the output node type (0: all nodes, 1: use wireframe, 2: used wireframe + edge decimation, default: 0) + +**Type:** *LinkableInput* + +### wireframe_threshold_scale + +defines the threshold scale for wireframe (default: 2.0) + +**Type:** *LinkableInput* + +### edge_decimation_angular_limit_in_radian + +defines the angular limit in radian for edge decimation (default: 1.0) + +**Type:** *LinkableInput* + ## Outputs ### dfmf_data_source diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/compute_element_centroids.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/compute_element_centroids.md index 06fedc434d..8c658a8ca8 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/compute_element_centroids.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/compute_element_centroids.md @@ -2,11 +2,11 @@ uid: Ans.DataProcessing.operators.scoping.compute_element_centroids --- -# *class* compute_element_centroids(element_scoping: object = None, mesh: object = None, config: OperatorConfig = None) +# *class* compute_element_centroids(element_scoping: object = None, algorithm: object = None, compute_measure: object = None, mesh: object = None, config: OperatorConfig = None) -Computes the element centroids of the mesh. It also outputs the element measure. +Computes the element centroids of the mesh and optionally the element measure. -available inputs: `element_scoping` (Scoping) (optional), `mesh` (MeshedRegion) +available inputs: `element_scoping` (Scoping) (optional), `algorithm` (Int32) (optional), `compute_measure` (bool) (optional), `mesh` (MeshedRegion) available outputs: `centroids` (Field), `measure` (Field) @@ -15,6 +15,8 @@ available outputs: `centroids` (Field), `measure` (Field) **Parameters:** * **element_scoping** +* **algorithm** +* **compute_measure** * **mesh** * **config** @@ -23,7 +25,7 @@ available outputs: `centroids` (Field), `measure` (Field) ```python op = compute_element_centroids() -op = compute_element_centroids(element_scoping=my_element_scoping,mesh=my_mesh) +op = compute_element_centroids(element_scoping=my_element_scoping,algorithm=my_algorithm,compute_measure=my_compute_measure,mesh=my_mesh) ``` ## Inputs @@ -34,6 +36,18 @@ If provided, only the centroids of the elements in the scoping are computed. **Type:** *LinkableInput* +### algorithm + +Centroid algorithm: weighted_average = 1 (default), arithmetic_average = 2. Note: arithmetic_average only supports compute_measure = false. + +**Type:** *LinkableInput* + +### compute_measure + +If true (default), computes and returns measure on pin 1. If false, only centroids are returned. Note: compute_measure = true is only supported with weighted_average algorithm. + +**Type:** *LinkableInput* + ### mesh Mesh to compute centroids @@ -50,7 +64,7 @@ element centroids. ### measure -element measure (length, surface or volume depending on the dimension of the element). +element measure (length, surface or volume depending on the dimension of the element), returned only when compute_measure is true. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md index bd62e7c159..acf85d0351 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md @@ -10,7 +10,7 @@ uid: Ans.DataProcessing.operators.scoping |-------|-------------| | [adapt_with_scopings_container](Ans_DataProcessing_operators_scoping_adapt_with_scopings_container.md) | Rescopes/splits a fields container to correspond to a scopings container. Each field from the input container is rescoped using each scoping from the scopings container, creating a cartesian product of rescoped fields. ///available inputs: field_or_fields_container (FieldsContainer, Field), scopings_container (ScopingsContainer), keep_empty_fields (bool) (optional) | | [change_fc](Ans_DataProcessing_operators_scoping_change_fc.md) | DEPRECATED, PLEASE USE ADAPT WITH SCOPINGS CONTAINER. Rescopes/splits a fields container to correspond to a scopings container. ///available inputs: field_or_fields_container (FieldsContainer, Field), scopings_container (ScopingsContainer) | -| [compute_element_centroids](Ans_DataProcessing_operators_scoping_compute_element_centroids.md) | Computes the element centroids of the mesh. It also outputs the element measure. ///available inputs: element_scoping (Scoping) (optional), mesh (MeshedRegion) | +| [compute_element_centroids](Ans_DataProcessing_operators_scoping_compute_element_centroids.md) | Computes the element centroids of the mesh and optionally the element measure. ///available inputs: element_scoping (Scoping) (optional), algorithm (Int32) (optional), compute_measure (bool) (optional), mesh (MeshedRegion) | | [connectivity_ids](Ans_DataProcessing_operators_scoping_connectivity_ids.md) | Returns the ordered node ids corresponding to the element ids scoping in input. For each element the node ids are its connectivity. ///available inputs: mesh_scoping (Scoping), mesh (MeshedRegion) (optional), take_mid_nodes (bool) (optional) | | [elemental_from_mesh](Ans_DataProcessing_operators_scoping_elemental_from_mesh.md) | Retrieves the elemental scoping from a mesh, containing all element IDs with elemental location. ///available inputs: mesh (MeshedRegion) | | [extend_midside_nodal_scoping](Ans_DataProcessing_operators_scoping_extend_midside_nodal_scoping.md) | Extends the input nodal scoping with the neighbor corner nodes of every midside node in the input. For each midside node in the scoping, the two corner nodes that bound it on the element edge are added to the output scoping. ///available inputs: nodal_mesh_scoping (Scoping), mesh (MeshedRegion), add_new_properties_to_mesh (bool) (optional) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/deserializer.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/deserializer.md index 41c49a6a6c..a2d0a3d0e3 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/deserializer.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/deserializer.md @@ -6,7 +6,7 @@ uid: Ans.DataProcessing.operators.serialization.deserializer Takes a file generated by the serializer and deserializes it into DPF's entities. -available inputs: `stream_type` (Int32), `file_path` (string) +available inputs: `stream_type` (Int32) (optional), `file_path` (string) available outputs: `any_output1` (Any), `any_output2` (Any) @@ -30,7 +30,7 @@ op = deserializer(stream_type=my_stream_type,file_path=my_file_path) ### stream_type -0 for ASCII (default), and 1 for binary +0 for ASCII (default), and 1 for binary. If not provided, the type is auto-detected from the file. **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md index 127cbe05b9..e50344d3dc 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md @@ -11,7 +11,7 @@ uid: Ans.DataProcessing.operators.serialization | [csv_to_field](Ans_DataProcessing_operators_serialization_csv_to_field.md) | transform csv file to a field or fields container ///available inputs: time_scoping (Scoping) (optional), data_sources (DataSources) | | [data_tree_to_json](Ans_DataProcessing_operators_serialization_data_tree_to_json.md) | Writes a json file or string from a DataTree ///available inputs: data_tree (DataTree), path (string) (optional) | | [data_tree_to_txt](Ans_DataProcessing_operators_serialization_data_tree_to_txt.md) | Writes a txt file or string from a DataTree ///available inputs: data_tree (DataTree), path (string) (optional) | -| [deserializer](Ans_DataProcessing_operators_serialization_deserializer.md) | Takes a file generated by the serializer and deserializes it into DPF's entities. ///available inputs: stream_type (Int32), file_path (string) | +| [deserializer](Ans_DataProcessing_operators_serialization_deserializer.md) | Takes a file generated by the serializer and deserializes it into DPF's entities. ///available inputs: stream_type (Int32) (optional), file_path (string) | | [export_symbolic_workflow](Ans_DataProcessing_operators_serialization_export_symbolic_workflow.md) | Transforms a Workflow into a symbolic Workflow and writes it to a file (if a path is set in input) or string ///available inputs: workflow (Workflow), workflow_path (string) (optional), format (Int32) (optional), options (Int32) (optional) | | [field_to_csv](Ans_DataProcessing_operators_serialization_field_to_csv.md) | Exports a field or a fields container into a csv file. Currently only homogenous Fields Definition of Fields Container are supported. ///available inputs: field_or_fields_container (FieldsContainer, Field), file_path (string), storage_type (Int32) (optional) | | [hdf5dpf_custom_read](Ans_DataProcessing_operators_serialization_hdf5dpf_custom_read.md) | Extract a custom result from an hdf5dpf file. This operator is deprecated, please use the 'custom' operator instead. ///available inputs: time_scoping (Scoping) (optional), mesh_scoping (Scoping) (optional), streams (StreamsContainer) (optional), data_sources (DataSources) (optional), meta_data (DataTree) (optional), result_name (Any) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/serializer.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/serializer.md index 8774a6e901..9968bc8e1b 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/serializer.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/serializer.md @@ -32,7 +32,7 @@ op = serializer(stream_type=my_stream_type,file_path=my_file_path,any_input1=my_ ### stream_type -0 for ASCII (default), and 1 for binary +0 for ASCII, and 1 for binary (default) **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml index 0fdc817d26..ada14ada21 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml @@ -164,6 +164,14 @@ href: Ans.DataProcessing/operators/compression/quantization_fc.md - name: zfp_decompress href: Ans.DataProcessing/operators/compression/zfp_decompress.md + - name: zstd_compress + href: Ans.DataProcessing/operators/compression/zstd_compress.md + - name: zstd_compress_fc + href: Ans.DataProcessing/operators/compression/zstd_compress_fc.md + - name: zstd_decompress + href: Ans.DataProcessing/operators/compression/zstd_decompress.md + - name: zstd_decompress_fc + href: Ans.DataProcessing/operators/compression/zstd_decompress_fc.md - name: filter href: Ans.DataProcessing/operators/filter/index.md items: diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/docfx.json b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/docfx.json index 3927cbeca7..61be48056a 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/docfx.json +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/docfx.json @@ -1,13 +1,14 @@ { "build": { "globalMetadata": { - "title": "DPF Mechanical 2027 R1", + "title": "DPF Mechanical 2027 R1 SP00", "summary": "", - "version": "2027 R1", + "version": "2027 R1 SP00", "product": "DPF", "programming language": "IronPython", "product collection": "Structures", - "physics": "Multiphysics, Structures, Fluids" + "physics": "Multiphysics, Structures, Fluids", + "is dpf context": true } } } diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml index cd1b3da591..2797abc0df 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml @@ -190,6 +190,14 @@ href: api/Ans.DataProcessing/operators/compression/quantization_fc.md - name: zfp_decompress href: api/Ans.DataProcessing/operators/compression/zfp_decompress.md + - name: zstd_compress + href: api/Ans.DataProcessing/operators/compression/zstd_compress.md + - name: zstd_compress_fc + href: api/Ans.DataProcessing/operators/compression/zstd_compress_fc.md + - name: zstd_decompress + href: api/Ans.DataProcessing/operators/compression/zstd_decompress.md + - name: zstd_decompress_fc + href: api/Ans.DataProcessing/operators/compression/zstd_decompress_fc.md - name: filter href: api/Ans.DataProcessing/operators/filter/index.md items: diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/user-guide/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/user-guide/index.md index 72be9cc8cd..9bc03cd76e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/user-guide/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/user-guide/index.md @@ -11,15 +11,12 @@ Comprehensive guides for working with DPF IronPython. ## Core Concepts ### [Understanding DPF](core-concepts.md) - Learn the fundamental concepts and architecture of DPF. ### [Data Model](data-model.md) - Understand how DPF organizes and represents simulation data. ### [Operators and Workflows](operators-workflows.md) - Learn about DPF's operator-based processing model. ## Working with Data From b8396eb2b645a60563950343c8bba7a186e1cc1b Mon Sep 17 00:00:00 2001 From: dpfuser Date: Tue, 28 Jul 2026 00:17:22 +0000 Subject: [PATCH 2/7] DPF dpf-mechanical doc update for 271 (2026.07.27) --- .../operators/result/index.md | 1 - .../result/mapdl_split_on_facet_indices.md | 93 ------------------- .../operators/utility/index.md | 1 + .../utility/transpose_fields_container.md | 93 +++++++++++++++++++ .../versions/2027.R1.SP00/api/toc.yml | 4 +- .../versions/2027.R1.SP00/toc.yml | 4 +- 6 files changed, 98 insertions(+), 98 deletions(-) delete mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/transpose_fields_container.md diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md index 18ee3fc9a1..06ec1134b2 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md @@ -223,7 +223,6 @@ uid: Ans.DataProcessing.operators.result | [magnetic_vector_potential](Ans_DataProcessing_operators_result_magnetic_vector_potential.md) | magnetic_vector_potential() | | [mapdl_material_properties](Ans_DataProcessing_operators_result_mapdl_material_properties.md) | Read the values of the properties of a material for a given materials property field (property field that contains materials information for each element of a mesh).It returns a fields container containing a field for each material property, with only one value per material. The following keys can be used: Young's modulus (keys: EX, EY, EZ), Poisson's ratio (keys: NUXY, NUYZ, NUXZ), Shear Modulus (keys: GXY, GYZ, GXZ), Coefficient of Thermal Expansion (keys: ALPX, ALPY, ALPZ), Volumic Mass (key: DENS), second Lame's coefficient (key: MU), Damping coefficient (key: DAMP), thermal Conductivity (keys: KXX, KYY, KZZ), Resistivity (keys: RSVX, RSVY, RSVZ), Specific heat in constant volume (key: C), Film coefficient (key: HF), Viscosity (key: VISC), Emissivity (key: EMIS). ///available inputs: properties_name (string), materials (PropertyField), streams_container (StreamsContainer), data_sources (DataSources) | | [mapdl_section](Ans_DataProcessing_operators_result_mapdl_section.md) | Read the values of the section properties for a given section property field (property field that contains section information for each element of a mesh). The following keys can be used: Thickness, NumLayers. For layered elements, the following keys can be used: Thickness, MatID, Orientation, NumIntPoints. ///available inputs: properties_name (string), section (PropertyField) (optional), streams_container (StreamsContainer), data_sources (DataSources), layer_property (bool) (optional), layers_requested (IList int, System.Collections.IEnumerable) (optional) | -| [mapdl_split_on_facet_indices](Ans_DataProcessing_operators_result_mapdl_split_on_facet_indices.md) | Splits each Field in a FieldsContainer defined on the skin elements of a mesh according to the local facets indices of its corresponding solid element. The output FieldsContainer retains the original labels and adds a 'facet' label, which indicates at which facet of the solid mesh was the original skin element located. The facet ids are according to MAPDL convention. The scoping of the output Fields reflects the element indices in the solid mesh. ///available inputs: fields_container (FieldsContainer), property_field_new_elements_to_old (PropertyField), facet_indices (PropertyField), volume_mesh (MeshedRegion), degenerated_tets (Scoping) (optional), non_degenerated_tets (Scoping) (optional) | | [mapdl_split_to_acmo_facet_indices](Ans_DataProcessing_operators_result_mapdl_split_to_acmo_facet_indices.md) | This will retain the already existing labels from the input FC and will change the facet label to now mean ACMO facet indices.Each Field in the input will be split/merged into several Fields, redistributing the data to the appropriate entity. ///available inputs: fields_container (FieldsContainer), property_fields_container_element_types (PropertyFieldsContainer) | | [mass_flow_rate](Ans_DataProcessing_operators_result_mass_flow_rate.md) | mass_flow_rate() | | [mass_fraction](Ans_DataProcessing_operators_result_mass_fraction.md) | mass_fraction() | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md deleted file mode 100644 index 94b1ee61aa..0000000000 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md +++ /dev/null @@ -1,93 +0,0 @@ ---- -uid: Ans.DataProcessing.operators.result.mapdl_split_on_facet_indices ---- - -# *class* mapdl_split_on_facet_indices(fields_container: object = None, property_field_new_elements_to_old: object = None, facet_indices: object = None, volume_mesh: object = None, degenerated_tets: object = None, non_degenerated_tets: object = None, config: OperatorConfig = None) - -Splits each Field in a FieldsContainer defined on the skin elements of a mesh according to the local facets indices of its corresponding solid element. The output FieldsContainer retains the original labels and adds a 'facet' label, which indicates at which facet of the solid mesh was the original skin element located. The facet ids are according to MAPDL convention. The scoping of the output Fields reflects the element indices in the solid mesh. - -available inputs: `fields_container` (FieldsContainer), `property_field_new_elements_to_old` (PropertyField), `facet_indices` (PropertyField), `volume_mesh` (MeshedRegion), `degenerated_tets` (Scoping) (optional), `non_degenerated_tets` (Scoping) (optional) - -available outputs: `fields_container` (FieldsContainer) - -**DPF Framework Reference:** [mapdl_split_on_facet_indices operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/mapdl_split_on_facet_indices.md) - -**Parameters:** - -* **fields_container** -* **property_field_new_elements_to_old** -* **facet_indices** -* **volume_mesh** -* **degenerated_tets** -* **non_degenerated_tets** -* **config** - -**Example:** - -```python -op = mapdl_split_on_facet_indices() - -op = mapdl_split_on_facet_indices(fields_container=my_fields_container,property_field_new_elements_to_old=my_property_field_new_elements_to_old,facet_indices=my_facet_indices,volume_mesh=my_volume_mesh,degenerated_tets=my_degenerated_tets,non_degenerated_tets=my_non_degenerated_tets) -``` - -## Inputs - -### fields_container - -Fields container to split, with generic number of labels (e.g. time, zone, complex...). Fields may have Elemental or ElementalNodal location; scoping ids are skin element ids. - -**Type:** *LinkableInput* - -### property_field_new_elements_to_old - -This property field provides, for each new face element ID (in the scoping), the corresponding 3D volume element index (in the data) it has been extracted from. The 3D volume element ID can be found with the element scoping of the input mesh. - -**Type:** *LinkableInput* - -### facet_indices - -This property field gives, for each new face element ID (in the scoping), the corresponding face index on the source 3D volume element. The 3D volume element can be extracted from the previous output. - -**Type:** *LinkableInput* - -### volume_mesh - -The solid support. - -**Type:** *LinkableInput* - -### degenerated_tets - -Elemental scoping of tet elements. If connected, the tets in the scoping are treated as degenerated tets (SOLID185), and the rest as non-degenerated tets (SOLID285). Pins 185 and 285 are mutually exclusionary (they cannot be connected at the same time), and if none of them is connected, all tets are treated as non-degenerated (SOLID285). - -**Type:** *LinkableInput* - -### non_degenerated_tets - -Elemental scoping of tet elements. If connected, the tets in the scoping are treated as non-degenerated tets (SOLID285), and the rest as degenerated tets (SOLID185). Pins 185 and 285 are mutually exclusionary (they cannot be connected at the same time), and if none of them is connected, all tets are treated as non-degenerated (SOLID285). - -**Type:** *LinkableInput* - -## Outputs - -### fields_container - -Output splitted fields containter - -**Type:** *LinkableOutput* - -## Methods - -## Properties - -#### *property* inputs: InputSpec - -*get/set* - -#### *property* outputs: OutputSpec - -*get/set* - -#### *property* defaultConfig: Config - -*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md index 54929bb0c3..f79df75fa8 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md @@ -92,6 +92,7 @@ uid: Ans.DataProcessing.operators.utility | [split_in_for_each_range](Ans_DataProcessing_operators_utility_split_in_for_each_range.md) | Split a scoping into several pieces so you can iterate it with a for_each loop. ///available inputs: iterable (Any) (optional), operator_to_iterate (Operator), pin_index (Int32), scoping (Scoping), chunk_size (Int32) | | [strain_from_voigt](Ans_DataProcessing_operators_utility_strain_from_voigt.md) | Converts strain field data from Voigt notation (6-component vector) to standard symmetric matrix format (3x3 tensor). ///available inputs: strain_field (Field, FieldsContainer) | | [strain_from_voigt_fc](Ans_DataProcessing_operators_utility_strain_from_voigt_fc.md) | Converts strain field data from Voigt notation (6-component vector) to standard symmetric matrix format (3x3 tensor). ///available inputs: fields_container (FieldsContainer) | +| [transpose_fields_container](Ans_DataProcessing_operators_utility_transpose_fields_container.md) | Transposes a fields container so that the fields' scoping becomes the container's scoping and a chosen label (default: time) becomes the fields' scoping. | | [txt_file_to_dpf](Ans_DataProcessing_operators_utility_txt_file_to_dpf.md) | Take an input string and parse it into dataProcessing type ///available inputs: input_string (string) | | [unitary_field](Ans_DataProcessing_operators_utility_unitary_field.md) | Takes a field and returns another field of scalars in the same location and scoping as the input field. ///available inputs: field (Field, FieldsContainer) | | [weighted_merge_fields_by_label](Ans_DataProcessing_operators_utility_weighted_merge_fields_by_label.md) | Performs a weighted merge on fields of a fields container that share the same label value. ///available inputs: fields_container (FieldsContainer), label (string), merged_field_support (AbstractFieldSupport) (optional), sum_merge (bool) (optional), weights1 (PropertyField), weights2 (PropertyField) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/transpose_fields_container.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/transpose_fields_container.md new file mode 100644 index 0000000000..b92ca0086d --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/transpose_fields_container.md @@ -0,0 +1,93 @@ +--- +uid: Ans.DataProcessing.operators.utility.transpose_fields_container +--- + +# *class* transpose_fields_container(fields_container: object = None, label: object = None, config: OperatorConfig = None) + +Transposes a fields container so that the fields' scoping becomes the container's scoping and a chosen label (default: time) becomes the fields' scoping. + +Input layout (example with time label, 2 body labels, 3 nodes): + + FC labels: [time, body] + + Field 0: {time:1, body:1} -> scoping {n1, n2, n3}, data [...] + + Field 1: {time:1, body:2} -> scoping {n4, n5}, data [...] + + Field 2: {time:2, body:1} -> scoping {n1, n2, n3}, data [...] + + Field 3: {time:2, body:2} -> scoping {n4, n5}, data [...] + +Output layout (transposed on time): + + FC labels: [Nodal, body] + + Field 0: {Nodal:n1, body:1} -> scoping {t1, t2}, data [gathered from fields 0,2] + + Field 1: {Nodal:n2, body:1} -> scoping {t1, t2}, data [gathered from fields 0,2] + + Field 1: {Nodal:n3, body:1} -> scoping {t1, t2}, data [gathered from fields 0,2] + + Field 2: {Nodal:n4, body:2} -> scoping {t1, t2}, data [gathered from fields 1,3] + + Field 3: {Nodal:n5, body:2} -> scoping {t1, t2}, data [gathered from fields 1,3] + + ... + +Each output field gathers one entity's data across all values of the transposed label from the input fields that share the same non-transposed labels. All input fields sharing a labelspace where only the transposed label changes must have the same scoping and location. + +available inputs: `fields_container` (FieldsContainer), `label` (string) (optional) + +available outputs: `fields_container` (FieldsContainer) + +**DPF Framework Reference:** [transpose_fields_container operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/transpose_fields_container.md) + +**Parameters:** + +* **fields_container** +* **label** +* **config** + +**Example:** + +```python +op = transpose_fields_container() + +op = transpose_fields_container(fields_container=my_fields_container,label=my_label) +``` + +## Inputs + +### fields_container + +It is assumed that the fields container consists of fields having the same scoping. + +**Type:** *LinkableInput* + +### label + +fields container label to use as fields label (default is time) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml index ada14ada21..6808c9e4de 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml @@ -1222,8 +1222,6 @@ href: Ans.DataProcessing/operators/result/mapdl_material_properties.md - name: mapdl_section href: Ans.DataProcessing/operators/result/mapdl_section.md - - name: mapdl_split_on_facet_indices - href: Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md - name: mapdl_split_to_acmo_facet_indices href: Ans.DataProcessing/operators/result/mapdl_split_to_acmo_facet_indices.md - name: mass_flow_rate @@ -1844,6 +1842,8 @@ href: Ans.DataProcessing/operators/utility/strain_from_voigt.md - name: strain_from_voigt_fc href: Ans.DataProcessing/operators/utility/strain_from_voigt_fc.md + - name: transpose_fields_container + href: Ans.DataProcessing/operators/utility/transpose_fields_container.md - name: txt_file_to_dpf href: Ans.DataProcessing/operators/utility/txt_file_to_dpf.md - name: unitary_field diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml index 2797abc0df..73417d3095 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml @@ -1248,8 +1248,6 @@ href: api/Ans.DataProcessing/operators/result/mapdl_material_properties.md - name: mapdl_section href: api/Ans.DataProcessing/operators/result/mapdl_section.md - - name: mapdl_split_on_facet_indices - href: api/Ans.DataProcessing/operators/result/mapdl_split_on_facet_indices.md - name: mapdl_split_to_acmo_facet_indices href: api/Ans.DataProcessing/operators/result/mapdl_split_to_acmo_facet_indices.md - name: mass_flow_rate @@ -1870,6 +1868,8 @@ href: api/Ans.DataProcessing/operators/utility/strain_from_voigt.md - name: strain_from_voigt_fc href: api/Ans.DataProcessing/operators/utility/strain_from_voigt_fc.md + - name: transpose_fields_container + href: api/Ans.DataProcessing/operators/utility/transpose_fields_container.md - name: txt_file_to_dpf href: api/Ans.DataProcessing/operators/utility/txt_file_to_dpf.md - name: unitary_field From 79e7952d30224d5a513fb1bf61667e8168212ed5 Mon Sep 17 00:00:00 2001 From: dpfuser Date: Thu, 30 Jul 2026 00:16:45 +0000 Subject: [PATCH 3/7] DPF dpf-mechanical doc update for 271 (2026.07.29) --- .../filter/filtering_max_over_time.md | 16 +++++---------- .../operators/filter/index.md | 2 +- .../geo/ans_mat_property_field_provider.md | 16 +++++---------- .../Ans.DataProcessing/operators/geo/index.md | 2 +- .../operators/result/index.md | 4 ++-- .../result/mapdl_material_properties.md | 16 +++++---------- .../operators/result/mapdl_section.md | 16 +++++---------- .../operators/scoping/index.md | 4 ++-- .../operators/scoping/on_property.md | 16 +++++---------- .../scoping/split_on_property_type.md | 16 +++++---------- .../operators/serialization/index.md | 2 +- .../operators/serialization/vtu_export.md | 16 +++------------ .../utility/customtypefield_get_attribute.md | 20 +++++++------------ .../operators/utility/fc_get_attribute.md | 16 +++++---------- .../operators/utility/field_get_attribute.md | 20 +++++++------------ .../operators/utility/index.md | 10 +++++----- .../utility/propertyfield_get_attribute.md | 20 +++++++------------ .../operators/utility/set_attribute.md | 16 +++++---------- 18 files changed, 76 insertions(+), 152 deletions(-) diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/filtering_max_over_time.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/filtering_max_over_time.md index 1f338d73d4..7f3f7840ac 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/filtering_max_over_time.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/filtering_max_over_time.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.filter.filtering_max_over_time # *class* filtering_max_over_time(invariant_fc_operator: object = None, output_pin: object = None, list_of_results: object = None, threshold: object = None, config: OperatorConfig = None) -Creates a filtering workflow that will filter results based on a threshold of a selected invariant. +filtering_max_over_time() + +filtering_max_over_time(invariant_fc_operator: object, output_pin: object, list_of_results: object, threshold: object, config: OperatorConfig) + +filtering_max_over_time(config: OperatorConfig) -available inputs: `invariant_fc_operator` (string), `output_pin` (Int32) (optional), `list_of_results` (string) (optional), `threshold` (double) (optional) -available outputs: `workflow` (Workflow) **DPF Framework Reference:** [filtering_max_over_time operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/filter/filtering_max_over_time.md) @@ -20,14 +22,6 @@ available outputs: `workflow` (Workflow) * **threshold** * **config** -**Example:** - -```python -op = filtering_max_over_time() - -op = filtering_max_over_time(invariant_fc_operator=my_invariant_fc_operator,output_pin=my_output_pin,list_of_results=my_list_of_results,threshold=my_threshold) -``` - ## Inputs ### invariant_fc_operator diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/index.md index d6a689e2e6..00c55d528e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/filter/index.md @@ -17,7 +17,7 @@ uid: Ans.DataProcessing.operators.filter | [field_low_pass_fc](Ans_DataProcessing_operators_filter_field_low_pass_fc.md) | The low pass filter returns all the values below (but not equal to) the threshold value in input. ///available inputs: fields_container (FieldsContainer), threshold (double, Field), both (bool) (optional) | | [field_signed_high_pass](Ans_DataProcessing_operators_filter_field_signed_high_pass.md) | The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input. ///available inputs: field (Field, FieldsContainer), threshold (double, Field), both (bool) (optional) | | [field_signed_high_pass_fc](Ans_DataProcessing_operators_filter_field_signed_high_pass_fc.md) | The high pass filter returns all the values above, or equal, in absolute value to the threshold value in input. ///available inputs: fields_container (FieldsContainer), threshold (double, Field), both (bool) (optional) | -| [filtering_max_over_time](Ans_DataProcessing_operators_filter_filtering_max_over_time.md) | Creates a filtering workflow that will filter results based on a threshold of a selected invariant. ///available inputs: invariant_fc_operator (string), output_pin (Int32) (optional), list_of_results (string) (optional), threshold (double) (optional) | +| [filtering_max_over_time](Ans_DataProcessing_operators_filter_filtering_max_over_time.md) | filtering_max_over_time() | | [scoping_band_pass](Ans_DataProcessing_operators_filter_scoping_band_pass.md) | The band pass filter returns all the values above (but not equal to) the minimum threshold value and below (but not equal to) the maximum threshold value in input. ///available inputs: field (Field, FieldsContainer), min_threshold (double, Field), max_threshold (double, Field) (optional) | | [scoping_high_pass](Ans_DataProcessing_operators_filter_scoping_high_pass.md) | The high pass filter returns all the values above (but not equal to) the threshold value in input. ///available inputs: field (Field, FieldsContainer), threshold (double, Field), both (bool) (optional) | | [scoping_low_pass](Ans_DataProcessing_operators_filter_scoping_low_pass.md) | The low pass filter returns all the values below (but not equal to) the threshold value in input. ///available inputs: field (Field, FieldsContainer), threshold (double, Field), both (bool) (optional) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/ans_mat_property_field_provider.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/ans_mat_property_field_provider.md index a03f2a964f..4062cdfc52 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/ans_mat_property_field_provider.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/ans_mat_property_field_provider.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.geo.ans_mat_property_field_provider # *class* ans_mat_property_field_provider(materials_container: object = None, mesh_scoping: object = None, dependencies1: object = None, dependencies2: object = None, unit_system_or_result_info: object = None, material_physic_name: object = None, dpf_mat_id: object = None, material_vuuid: object = None, property_name: object = None, location: object = None, location_standard_condition: object = None, config: OperatorConfig = None) -Load a named property from an ENGD file using ANS_MAT.Important: ANS_MAT uses different property names if compared with ENGD.If there is any value's property equaling 0.0, that means this material doesnt have that named property.This operator returns fields container of named property value. If pin 10 is set False, its scoping will be the mat IDs in Mechanicaland it is only available without dependencies. +ans_mat_property_field_provider() + +ans_mat_property_field_provider(materials_container: object, mesh_scoping: object, dependencies1: object, dependencies2: object, unit_system_or_result_info: object, material_physic_name: object, dpf_mat_id: object, material_vuuid: object, property_name: object, location: object, location_standard_condition: object, config: OperatorConfig) + +ans_mat_property_field_provider(config: OperatorConfig) -available inputs: `materials_container` (MaterialsContainer), `mesh_scoping` (Scoping) (optional), `dependencies1` (Field) (optional), `dependencies2` (Field) (optional), `unit_system_or_result_info` (ResultInfo), `material_physic_name` (string) (optional), `dpf_mat_id` (Int32, IList int, Scoping, System.Collections.IEnumerable) (optional), `material_vuuid` (string) (optional), `property_name` (string) (optional), `location` (string) (optional), `location_standard_condition` (bool) (optional) -available outputs: `fields_container` (FieldsContainer) **DPF Framework Reference:** [ans_mat_property_field_provider operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/geo/ans_mat_property_field_provider.md) @@ -27,14 +29,6 @@ available outputs: `fields_container` (FieldsContainer) * **location_standard_condition** * **config** -**Example:** - -```python -op = ans_mat_property_field_provider() - -op = ans_mat_property_field_provider(materials_container=my_materials_container,mesh_scoping=my_mesh_scoping,dependencies1=my_dependencies1,dependencies2=my_dependencies2,unit_system_or_result_info=my_unit_system_or_result_info,material_physic_name=my_material_physic_name,dpf_mat_id=my_dpf_mat_id,material_vuuid=my_material_vuuid,property_name=my_property_name,location=my_location,location_standard_condition=my_location_standard_condition) -``` - ## Inputs ### materials_container diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/index.md index 45aa7c2491..78955e7764 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/geo/index.md @@ -10,7 +10,7 @@ uid: Ans.DataProcessing.operators.geo |-------|-------------| | [ans_mat_from_materials_data](Ans_DataProcessing_operators_geo_ans_mat_from_materials_data.md) | Create ans_mat materials from materials data. ///available inputs: material_data1 (GenericDataContainer), material_data2 (GenericDataContainer) | | [ans_mat_materials_provider](Ans_DataProcessing_operators_geo_ans_mat_materials_provider.md) | Provide materials through ans_mat ///available inputs: abstract_field_support (AbstractFieldSupport), unit_system_or_result_info (ResultInfo, string, Int32), skip_missing_materials (bool), Engineering_data_file (DataSources) | -| [ans_mat_property_field_provider](Ans_DataProcessing_operators_geo_ans_mat_property_field_provider.md) | Load a named property from an ENGD file using ANS_MAT.Important: ANS_MAT uses different property names if compared with ENGD.If there is any value's property equaling 0.0, that means this material doesnt have that named property.This operator returns fields container of named property value. If pin 10 is set False, its scoping will be the mat IDs in Mechanicaland it is only available without dependencies. ///available inputs: materials_container (MaterialsContainer), mesh_scoping (Scoping) (optional), dependencies1 (Field) (optional), dependencies2 (Field) (optional), unit_system_or_result_info (ResultInfo), material_physic_name (string) (optional), dpf_mat_id (Int32, IList int, Scoping, System.Collections.IEnumerable) (optional), material_vuuid (string) (optional), property_name (string) (optional), location (string) (optional), location_standard_condition (bool) (optional) | +| [ans_mat_property_field_provider](Ans_DataProcessing_operators_geo_ans_mat_property_field_provider.md) | ans_mat_property_field_provider() | | [cartesian_to_spherical](Ans_DataProcessing_operators_geo_cartesian_to_spherical.md) | Converts 3D field from cartesian coordinates to spherical coordinates. ///available inputs: field (Field, FieldsContainer) | | [cartesian_to_spherical_fc](Ans_DataProcessing_operators_geo_cartesian_to_spherical_fc.md) | Converts 3D field from cartesian coordinates to spherical coordinates. ///available inputs: fields_container (FieldsContainer) | | [element_nodal_contribution](Ans_DataProcessing_operators_geo_element_nodal_contribution.md) | Compute the fraction of the element measure attributed to each node of each element (fraction of the volume for 3D elements, fraction of the area for 2D elements or fraction of the length for 1D elements). It is computed by taking the integral of the shape function associated to each node within each element. ///available inputs: mesh (MeshedRegion), scoping (Scoping) (optional), volume_fraction (bool) (optional) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md index 06ec1134b2..924f1399f8 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md @@ -221,8 +221,8 @@ uid: Ans.DataProcessing.operators.result | [magnetic_flux_density_Z](Ans_DataProcessing_operators_result_magnetic_flux_density_Z.md) | magnetic_flux_density_Z() | | [magnetic_scalar_potential](Ans_DataProcessing_operators_result_magnetic_scalar_potential.md) | magnetic_scalar_potential() | | [magnetic_vector_potential](Ans_DataProcessing_operators_result_magnetic_vector_potential.md) | magnetic_vector_potential() | -| [mapdl_material_properties](Ans_DataProcessing_operators_result_mapdl_material_properties.md) | Read the values of the properties of a material for a given materials property field (property field that contains materials information for each element of a mesh).It returns a fields container containing a field for each material property, with only one value per material. The following keys can be used: Young's modulus (keys: EX, EY, EZ), Poisson's ratio (keys: NUXY, NUYZ, NUXZ), Shear Modulus (keys: GXY, GYZ, GXZ), Coefficient of Thermal Expansion (keys: ALPX, ALPY, ALPZ), Volumic Mass (key: DENS), second Lame's coefficient (key: MU), Damping coefficient (key: DAMP), thermal Conductivity (keys: KXX, KYY, KZZ), Resistivity (keys: RSVX, RSVY, RSVZ), Specific heat in constant volume (key: C), Film coefficient (key: HF), Viscosity (key: VISC), Emissivity (key: EMIS). ///available inputs: properties_name (string), materials (PropertyField), streams_container (StreamsContainer), data_sources (DataSources) | -| [mapdl_section](Ans_DataProcessing_operators_result_mapdl_section.md) | Read the values of the section properties for a given section property field (property field that contains section information for each element of a mesh). The following keys can be used: Thickness, NumLayers. For layered elements, the following keys can be used: Thickness, MatID, Orientation, NumIntPoints. ///available inputs: properties_name (string), section (PropertyField) (optional), streams_container (StreamsContainer), data_sources (DataSources), layer_property (bool) (optional), layers_requested (IList int, System.Collections.IEnumerable) (optional) | +| [mapdl_material_properties](Ans_DataProcessing_operators_result_mapdl_material_properties.md) | mapdl_material_properties() | +| [mapdl_section](Ans_DataProcessing_operators_result_mapdl_section.md) | mapdl_section() | | [mapdl_split_to_acmo_facet_indices](Ans_DataProcessing_operators_result_mapdl_split_to_acmo_facet_indices.md) | This will retain the already existing labels from the input FC and will change the facet label to now mean ACMO facet indices.Each Field in the input will be split/merged into several Fields, redistributing the data to the appropriate entity. ///available inputs: fields_container (FieldsContainer), property_fields_container_element_types (PropertyFieldsContainer) | | [mass_flow_rate](Ans_DataProcessing_operators_result_mass_flow_rate.md) | mass_flow_rate() | | [mass_fraction](Ans_DataProcessing_operators_result_mass_fraction.md) | mass_fraction() | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_material_properties.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_material_properties.md index 13120da9d4..9b9b753efe 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_material_properties.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_material_properties.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.result.mapdl_material_properties # *class* mapdl_material_properties(properties_name: object = None, materials: object = None, streams_container: object = None, data_sources: object = None, config: OperatorConfig = None) -Read the values of the properties of a material for a given materials property field (property field that contains materials information for each element of a mesh).It returns a fields container containing a field for each material property, with only one value per material. The following keys can be used: Young's modulus (keys: EX, EY, EZ), Poisson's ratio (keys: NUXY, NUYZ, NUXZ), Shear Modulus (keys: GXY, GYZ, GXZ), Coefficient of Thermal Expansion (keys: ALPX, ALPY, ALPZ), Volumic Mass (key: DENS), second Lame's coefficient (key: MU), Damping coefficient (key: DAMP), thermal Conductivity (keys: KXX, KYY, KZZ), Resistivity (keys: RSVX, RSVY, RSVZ), Specific heat in constant volume (key: C), Film coefficient (key: HF), Viscosity (key: VISC), Emissivity (key: EMIS). +mapdl_material_properties() + +mapdl_material_properties(properties_name: object, materials: object, streams_container: object, data_sources: object, config: OperatorConfig) + +mapdl_material_properties(config: OperatorConfig) -available inputs: `properties_name` (string), `materials` (PropertyField), `streams_container` (StreamsContainer), `data_sources` (DataSources) -available outputs: `properties_value` (FieldsContainer) **DPF Framework Reference:** [mapdl_material_properties operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/mapdl_material_properties.md) @@ -20,14 +22,6 @@ available outputs: `properties_value` (FieldsContainer) * **data_sources** * **config** -**Example:** - -```python -op = mapdl_material_properties() - -op = mapdl_material_properties(properties_name=my_properties_name,materials=my_materials,streams_container=my_streams_container,data_sources=my_data_sources) -``` - ## Inputs ### properties_name diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_section.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_section.md index 608593919f..769861d67c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_section.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/mapdl_section.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.result.mapdl_section # *class* mapdl_section(properties_name: object = None, section: object = None, streams_container: object = None, data_sources: object = None, layer_property: object = None, layers_requested: object = None, config: OperatorConfig = None) -Read the values of the section properties for a given section property field (property field that contains section information for each element of a mesh). The following keys can be used: Thickness, NumLayers. For layered elements, the following keys can be used: Thickness, MatID, Orientation, NumIntPoints. +mapdl_section() + +mapdl_section(properties_name: object, section: object, streams_container: object, data_sources: object, layer_property: object, layers_requested: object, config: OperatorConfig) + +mapdl_section(config: OperatorConfig) -available inputs: `properties_name` (string), `section` (PropertyField) (optional), `streams_container` (StreamsContainer), `data_sources` (DataSources), `layer_property` (bool) (optional), `layers_requested` (IList int, System.Collections.IEnumerable) (optional) -available outputs: `properties_value` (FieldsContainer), `layers_per_section` (PropertyField) **DPF Framework Reference:** [mapdl_section operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/mapdl_section.md) @@ -22,14 +24,6 @@ available outputs: `properties_value` (FieldsContainer), `layers_per_section` (P * **layers_requested** * **config** -**Example:** - -```python -op = mapdl_section() - -op = mapdl_section(properties_name=my_properties_name,section=my_section,streams_container=my_streams_container,data_sources=my_data_sources,layer_property=my_layer_property,layers_requested=my_layers_requested) -``` - ## Inputs ### properties_name diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md index acf85d0351..8ad2c140fe 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/index.md @@ -19,12 +19,12 @@ uid: Ans.DataProcessing.operators.scoping | [nodal_from_mesh](Ans_DataProcessing_operators_scoping_nodal_from_mesh.md) | Retrieves the nodal scoping from a mesh, containing all node IDs. ///available inputs: mesh (MeshedRegion) | | [on_mesh_property](Ans_DataProcessing_operators_scoping_on_mesh_property.md) | Provides a scoping on a given property name and a property number. ///available inputs: requested_location (string) (optional), property_name (string), property_id (IList int, Int32, System.Collections.IEnumerable) (optional), inclusive (Int32) (optional), mesh (MeshedRegion) | | [on_named_selection](Ans_DataProcessing_operators_scoping_on_named_selection.md) | provides a scoping at a given location based on a given named selection ///available inputs: requested_location (string), named_selection_name (string), int_inclusive (Int32) (optional), streams_container (StreamsContainer) (optional), data_sources (DataSources) | -| [on_property](Ans_DataProcessing_operators_scoping_on_property.md) | Provides a scoping at a given location based on a given property name and a property number. ///available inputs: requested_location (string), property_name (string), property_id (Int32), streams_container (StreamsContainer) (optional), data_sources (DataSources) | +| [on_property](Ans_DataProcessing_operators_scoping_on_property.md) | on_property() | | [reduce_sampling](Ans_DataProcessing_operators_scoping_reduce_sampling.md) | Take a scoping and remove half of it's content. ///available inputs: mesh_scoping (Scoping), denominator (Int32) (optional) | | [rescope](Ans_DataProcessing_operators_scoping_rescope.md) | rescope() | | [rescope_custom_type_field](Ans_DataProcessing_operators_scoping_rescope_custom_type_field.md) | Rescopes a custom type field on the given scoping. If an ID does not exist in the original custom type field, the default value (in 2) is used when defined. ///available inputs: fields (CustomTypeFieldsContainer, CustomTypeField), mesh_scoping (Scoping, IList int, System.Collections.IEnumerable) (optional), default_value (CustomTypeFieldCustomTypeField) (optional) | | [rescope_fc](Ans_DataProcessing_operators_scoping_rescope_fc.md) | rescope_fc() | | [rescope_property_field](Ans_DataProcessing_operators_scoping_rescope_property_field.md) | Rescopes a property field on the given scoping. If an ID does not exist in the original property field, the default value (in 2) is used when defined. ///available inputs: fields (PropertyFieldsContainer, PropertyField), mesh_scoping (Scoping, IList int, System.Collections.IEnumerable) (optional), default_value (Int32, IList int, System.Collections.IEnumerable) (optional) | | [scoping_get_attribute](Ans_DataProcessing_operators_scoping_scoping_get_attribute.md) | Uses the Scoping APIs to return a given attribute of the scoping in input. ///available inputs: scoping (Scoping), property_name (string) | -| [split_on_property_type](Ans_DataProcessing_operators_scoping_split_on_property_type.md) | Splits a given scoping or the mesh scoping (nodal or elemental) on given properties (elshape and/or material, since 2025R1 it supports any scalar property field name contained in the mesh property fields) and returns a scopings container with those split scopings. ///available inputs: mesh_scoping (Scoping) (optional), mesh (MeshedRegion), requested_location (string), skin_case (Int32) (optional), label1 (string) (optional), label2 (string) (optional) | +| [split_on_property_type](Ans_DataProcessing_operators_scoping_split_on_property_type.md) | split_on_property_type() | | [transpose](Ans_DataProcessing_operators_scoping_transpose.md) | Transposes the input scoping or scopings container (Elemental/Faces --> Nodal, or Nodal ---> Elemental/Faces), based on the input mesh region. ///available inputs: mesh_scoping (Scoping, ScopingsContainer), meshed_region (MeshedRegion, MeshesContainer), inclusive (Int32) (optional), extend_midside_nodes (bool) (optional), requested_location (string) (optional) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/on_property.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/on_property.md index e2540f28c9..0eec6002ff 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/on_property.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/on_property.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.scoping.on_property # *class* on_property(requested_location: object = None, property_name: object = None, property_id: object = None, streams_container: object = None, data_sources: object = None, config: OperatorConfig = None) -Provides a scoping at a given location based on a given property name and a property number. +on_property() + +on_property(requested_location: object, property_name: object, property_id: object, streams_container: object, data_sources: object, config: OperatorConfig) + +on_property(config: OperatorConfig) -available inputs: `requested_location` (string), `property_name` (string), `property_id` (Int32), `streams_container` (StreamsContainer) (optional), `data_sources` (DataSources) -available outputs: `mesh_scoping` (Scoping) **DPF Framework Reference:** [on_property operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/scoping/on_property.md) @@ -21,14 +23,6 @@ available outputs: `mesh_scoping` (Scoping) * **data_sources** * **config** -**Example:** - -```python -op = on_property() - -op = on_property(requested_location=my_requested_location,property_name=my_property_name,property_id=my_property_id,streams_container=my_streams_container,data_sources=my_data_sources) -``` - ## Inputs ### requested_location diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/split_on_property_type.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/split_on_property_type.md index ac3cb8f064..d78efdb7fd 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/split_on_property_type.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/split_on_property_type.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.scoping.split_on_property_type # *class* split_on_property_type(mesh_scoping: object = None, mesh: object = None, requested_location: object = None, skin_case: object = None, label1: object = None, label2: object = None, config: OperatorConfig = None) -Splits a given scoping or the mesh scoping (nodal or elemental) on given properties (elshape and/or material, since 2025R1 it supports any scalar property field name contained in the mesh property fields) and returns a scopings container with those split scopings. +split_on_property_type() + +split_on_property_type(mesh_scoping: object, mesh: object, requested_location: object, skin_case: object, label1: object, label2: object, config: OperatorConfig) + +split_on_property_type(config: OperatorConfig) -available inputs: `mesh_scoping` (Scoping) (optional), `mesh` (MeshedRegion), `requested_location` (string), `skin_case` (Int32) (optional), `label1` (string) (optional), `label2` (string) (optional) -available outputs: `mesh_scoping` (ScopingsContainer) **DPF Framework Reference:** [split_on_property_type operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/scoping/split_on_property_type.md) @@ -22,14 +24,6 @@ available outputs: `mesh_scoping` (ScopingsContainer) * **label2** * **config** -**Example:** - -```python -op = split_on_property_type() - -op = split_on_property_type(mesh_scoping=my_mesh_scoping,mesh=my_mesh,requested_location=my_requested_location,skin_case=my_skin_case,label1=my_label1,label2=my_label2) -``` - ## Inputs ### mesh_scoping diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md index e50344d3dc..70dece1f79 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md @@ -28,6 +28,6 @@ uid: Ans.DataProcessing.operators.serialization | [txt_to_data_tree](Ans_DataProcessing_operators_serialization_txt_to_data_tree.md) | Reads a txt file or string to a DataTree ///available inputs: string_or_path (string, DataSources) | | [vtk_export](Ans_DataProcessing_operators_serialization_vtk_export.md) | Write the input field and fields container into a given vtk path ///available inputs: export_type (Int32) (optional), file_path (string), mesh (MeshedRegion) (optional), fields1 (FieldsContainer, Field), fields2 (FieldsContainer, Field) | | [vtk_to_fields](Ans_DataProcessing_operators_serialization_vtk_to_fields.md) | Write a field based on a vtk file. ///available inputs: field_name (string) (optional), streams (StreamsContainer) (optional), data_sources (DataSources) | -| [vtu_export](Ans_DataProcessing_operators_serialization_vtu_export.md) | Export DPF mesh and field data to **VTK Unstructured Grid (VTU)** format. | +| [vtu_export](Ans_DataProcessing_operators_serialization_vtu_export.md) | vtu_export() | | [workflow_to_pydpf](Ans_DataProcessing_operators_serialization_workflow_to_pydpf.md) | Generates a PyDPF script that can recreate the given workflow. | | [workflow_to_workflow_topology](Ans_DataProcessing_operators_serialization_workflow_to_workflow_topology.md) | Creates a GenericDataContainer based on WorkflowTopology structure from a Workflow object, allowing to access its operators, operator connections, data connections, and exposed pins. ///available inputs: workflow (Workflow) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/vtu_export.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/vtu_export.md index aacb5e1e3c..f6669be0d1 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/vtu_export.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/vtu_export.md @@ -4,15 +4,13 @@ uid: Ans.DataProcessing.operators.serialization.vtu_export # *class* vtu_export(directory: object = None, base_name: object = None, mesh: object = None, fields1: object = None, fields2: object = None, write_mode: object = None, as_point_cloud: object = None, export_faces: object = None, mesh_properties: object = None, config: OperatorConfig = None) -Export DPF mesh and field data to **VTK Unstructured Grid (VTU)** format. +vtu_export() -Supports time-based data export (creates separate `.vtu` files per time step) and various output modes. +vtu_export(directory: object, base_name: object, mesh: object, fields1: object, fields2: object, write_mode: object, as_point_cloud: object, export_faces: object, mesh_properties: object, config: OperatorConfig) -Compatible with VTK/ParaView visualization tools. +vtu_export(config: OperatorConfig) -available inputs: `directory` (string), `base_name` (string) (optional), `mesh` (MeshedRegion), `fields1` (Field, FieldsContainer, PropertyField), `fields2` (Field, FieldsContainer, PropertyField), `write_mode` (string) (optional), `as_point_cloud` (bool) (optional), `export_faces` (bool) (optional), `mesh_properties` (StringField) (optional) -available outputs: `path` (DataSources) **DPF Framework Reference:** [vtu_export operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/serialization/vtu_export.md) @@ -29,14 +27,6 @@ available outputs: `path` (DataSources) * **mesh_properties** * **config** -**Example:** - -```python -op = vtu_export() - -op = vtu_export(directory=my_directory,base_name=my_base_name,mesh=my_mesh,fields1=my_fields1,fields2=my_fields2,write_mode=my_write_mode,as_point_cloud=my_as_point_cloud,export_faces=my_export_faces,mesh_properties=my_mesh_properties) -``` - ## Inputs ### directory diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/customtypefield_get_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/customtypefield_get_attribute.md index 16512ab779..027bada179 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/customtypefield_get_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/customtypefield_get_attribute.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.utility.customtypefield_get_attribute # *class* customtypefield_get_attribute(custom_type_field: object = None, property_name: object = None, config: OperatorConfig = None) -Gets a property from an input field / fields container. A CustomTypeField in pin 0 and a property name (string) in pin 1 are expected as inputs. +customtypefield_get_attribute() + +customtypefield_get_attribute(custom_type_field: object, property_name: object, config: OperatorConfig) + +customtypefield_get_attribute(config: OperatorConfig) -available inputs: `custom_type_field` (CustomTypeField, CustomTypeFieldsContainer), `property_name` (string) -available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) **DPF Framework Reference:** [customtypefield_get_attribute operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/customtypefield_get_attribute.md) @@ -18,14 +20,6 @@ available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) * **property_name** * **config** -**Example:** - -```python -op = customtypefield_get_attribute() - -op = customtypefield_get_attribute(custom_type_field=my_custom_type_field,property_name=my_property_name) -``` - ## Inputs ### custom_type_field @@ -34,7 +28,7 @@ op = customtypefield_get_attribute(custom_type_field=my_custom_type_field,proper ### property_name -Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header' and 'datasize'. +Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header', 'datasize' and 'data'. **Type:** *LinkableInput* @@ -42,7 +36,7 @@ Property to get. Accepted inputs are specific strings namely: 'unit, 'name','tim ### property -Property value that is returned. Accepted Outputs are: Field, PropertyField, CustomTypeField or their containers. +Property value that is returned. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/fc_get_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/fc_get_attribute.md index 470e7b43ed..21c30f1eda 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/fc_get_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/fc_get_attribute.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.utility.fc_get_attribute # *class* fc_get_attribute(fields_container: object = None, property_name: object = None, property_identifier: object = None, config: OperatorConfig = None) -Uses the FieldsContainer APIs to return a given attribute of the fields container in input. +fc_get_attribute() + +fc_get_attribute(fields_container: object, property_name: object, property_identifier: object, config: OperatorConfig) + +fc_get_attribute(config: OperatorConfig) -available inputs: `fields_container` (FieldsContainer), `property_name` (string), `property_identifier` (string, Int32) (optional) -available outputs: `property` (Scoping ,IList int ,TimeFreqSupport ,LabelSpace ,Field ,Int32 ,string ,StringField ,System.Collections.IEnumerable) **DPF Framework Reference:** [fc_get_attribute operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/fc_get_attribute.md) @@ -19,14 +21,6 @@ available outputs: `property` (Scoping ,IList int ,TimeFreqSupport ,LabelSpace * **property_identifier** * **config** -**Example:** - -```python -op = fc_get_attribute() - -op = fc_get_attribute(fields_container=my_fields_container,property_name=my_property_name,property_identifier=my_property_identifier) -``` - ## Inputs ### fields_container diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/field_get_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/field_get_attribute.md index ea377b641c..ba57f2f82d 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/field_get_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/field_get_attribute.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.utility.field_get_attribute # *class* field_get_attribute(field: object = None, property_name: object = None, config: OperatorConfig = None) -Gets a property from an input field / fields container. A Field in pin 0 and a property name (string) in pin 1 are expected as inputs. +field_get_attribute() + +field_get_attribute(field: object, property_name: object, config: OperatorConfig) + +field_get_attribute(config: OperatorConfig) -available inputs: `field` (Field, FieldsContainer), `property_name` (string) -available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) **DPF Framework Reference:** [field_get_attribute operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/field_get_attribute.md) @@ -18,14 +20,6 @@ available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) * **property_name** * **config** -**Example:** - -```python -op = field_get_attribute() - -op = field_get_attribute(field=my_field,property_name=my_property_name) -``` - ## Inputs ### field @@ -34,7 +28,7 @@ op = field_get_attribute(field=my_field,property_name=my_property_name) ### property_name -Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header' and 'datasize'. +Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header', 'datasize' and 'data'. **Type:** *LinkableInput* @@ -42,7 +36,7 @@ Property to get. Accepted inputs are specific strings namely: 'unit, 'name','tim ### property -Property value that is returned. Accepted Outputs are: Field, PropertyField, CustomTypeField or their containers. +Property value that is returned. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md index f79df75fa8..5c3556bad0 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/index.md @@ -20,7 +20,7 @@ uid: Ans.DataProcessing.operators.utility | [concatenate_fields](Ans_DataProcessing_operators_utility_concatenate_fields.md) | Concatenates fields into a unique one by incrementing the number of components. | | [concatenate_fields_containers](Ans_DataProcessing_operators_utility_concatenate_fields_containers.md) | Concatenates fields containers into a unique one by concatenating each of their fields. | | [csharp_generator](Ans_DataProcessing_operators_utility_csharp_generator.md) | Generates a C# wrapper file (.cs) containing a class for each public operator | -| [customtypefield_get_attribute](Ans_DataProcessing_operators_utility_customtypefield_get_attribute.md) | Gets a property from an input field / fields container. A CustomTypeField in pin 0 and a property name (string) in pin 1 are expected as inputs. ///available inputs: custom_type_field (CustomTypeField, CustomTypeFieldsContainer), property_name (string) | +| [customtypefield_get_attribute](Ans_DataProcessing_operators_utility_customtypefield_get_attribute.md) | customtypefield_get_attribute() | | [cyclic_support_get_attribute](Ans_DataProcessing_operators_utility_cyclic_support_get_attribute.md) | A CyclicSupport in pin 0 and a property name (string) in pin 1 are expected in input. ///available inputs: cyclic_support (CyclicSupport), property_name (string) | | [default_value](Ans_DataProcessing_operators_utility_default_value.md) | Returns the value from pin 0 if provided, otherwise returns the default value from pin 1. This operator acts as a fallback mechanism for optional inputs. ///available inputs: forced_value (Any) (optional), default_value (Any) | | [delegate_to_operator](Ans_DataProcessing_operators_utility_delegate_to_operator.md) | Delegate the run to an Operator instantiated by the name in input (forwards all the input of this Operator to the sub Operator). ///available inputs: operator_name (string) | @@ -31,10 +31,10 @@ uid: Ans.DataProcessing.operators.utility | [extract_sub_mc](Ans_DataProcessing_operators_utility_extract_sub_mc.md) | Creates a new meshes container with all the meshed regions corresponding to the label space in input 1. If pin 1 is not defined, pin 0 input will be copied to the output. ///available inputs: meshes (MeshesContainer), label_space (LabelSpace, Scoping) (optional), collapse_labels (bool) (optional) | | [extract_sub_sc](Ans_DataProcessing_operators_utility_extract_sub_sc.md) | Creates a new scopings container with all the scopings corresponding to the label space in input 1. If pin 1 is not defined, pin 0 input will be copied to the output. ///available inputs: scopings_container (ScopingsContainer), label_space (LabelSpace, Scoping) (optional), collapse_labels (bool) (optional) | | [extract_time_freq](Ans_DataProcessing_operators_utility_extract_time_freq.md) | Extract timefreqs with sets scoping from a time freq support ///available inputs: time_freq_support (TimeFreqSupport), time_scoping (Scoping) (optional), real_or_complex (bool) (optional), rpm_scoping (Int32) (optional) | -| [fc_get_attribute](Ans_DataProcessing_operators_utility_fc_get_attribute.md) | Uses the FieldsContainer APIs to return a given attribute of the fields container in input. ///available inputs: fields_container (FieldsContainer), property_name (string), property_identifier (string, Int32) (optional) | +| [fc_get_attribute](Ans_DataProcessing_operators_utility_fc_get_attribute.md) | fc_get_attribute() | | [field](Ans_DataProcessing_operators_utility_field.md) | Incrementaly merge the input. ///available inputs: input (Field) | | [field_clone_to_shell_layer](Ans_DataProcessing_operators_utility_field_clone_to_shell_layer.md) | Generates a Field from the Field in input 0 that has the same FieldDefinition with the exception of the shellLayers enum that is specified in input 1. The DataPointer is recomputed to the appropriate value. The Data of the output Field is 0.0 for all entities. Scoping can be shared or not based on the optional pin 2. ///available inputs: field (Field), shell_layer (Int32), duplicate_scoping (bool) (optional) | -| [field_get_attribute](Ans_DataProcessing_operators_utility_field_get_attribute.md) | Gets a property from an input field / fields container. A Field in pin 0 and a property name (string) in pin 1 are expected as inputs. ///available inputs: field (Field, FieldsContainer), property_name (string) | +| [field_get_attribute](Ans_DataProcessing_operators_utility_field_get_attribute.md) | field_get_attribute() | | [field_to_fc](Ans_DataProcessing_operators_utility_field_to_fc.md) | Creates a fields container containing the field provided on pin 0. ///available inputs: field (Field, FieldsContainer), label (LabelSpace) | | [fields_container](Ans_DataProcessing_operators_utility_fields_container.md) | Incrementaly merge the input. ///available inputs: input (FieldsContainer) | | [for_each](Ans_DataProcessing_operators_utility_for_each.md) | Allows to write a loop over a chunk of operators. ///available inputs: iterable (Any), iterable_values (Any) (optional), pin_index (Int32) (optional), forward1 (Any), forward2 (Any) | @@ -80,14 +80,14 @@ uid: Ans.DataProcessing.operators.utility | [overlap_fields](Ans_DataProcessing_operators_utility_overlap_fields.md) | Take two fields and superpose them, the overlapping field will override values of base_field. ///available inputs: base_field (Field) (optional), overlapping_field (Field) (optional) | | [producer_consumer_for_each](Ans_DataProcessing_operators_utility_producer_consumer_for_each.md) | Allows to write a loop over operators by connecting data to iterate and by requesting the incrementally output merged.The chain of Operators are split into a first part: the producers and a second part: the consumers. These 2 parts will run asynchronously on 2 threads. ///available inputs: producer_consumer_iterableq (Any), forward1 (Any), forward2 (Any) | | [property_field](Ans_DataProcessing_operators_utility_property_field.md) | Incrementaly merge the input. ///available inputs: input (PropertyField) | -| [propertyfield_get_attribute](Ans_DataProcessing_operators_utility_propertyfield_get_attribute.md) | Gets a property from an input field / fields container. A PropertyField in pin 0 and a property name (string) in pin 1 are expected as inputs. ///available inputs: property_field (PropertyField, PropertyFieldsContainer), property_name (string) | +| [propertyfield_get_attribute](Ans_DataProcessing_operators_utility_propertyfield_get_attribute.md) | propertyfield_get_attribute() | | [python_generator](Ans_DataProcessing_operators_utility_python_generator.md) | Generates .py file with specifications for loaded plugin(s). ///available inputs: dll_source_path (string), output_path (string), load_symbol (string) (optional), library_key (string) (optional) | | [remote_operator_instantiate](Ans_DataProcessing_operators_utility_remote_operator_instantiate.md) | Create a local image of an existing remote operator (identified by an id and an address) for a given protocol registered in the streams. A workflow is created with this operator and returned in output ///available inputs: operator_to_send (Int32), output_pin (Int32), streams_to_remote (StreamsContainer), data_sources_to_remote (DataSources) (optional), output_name (string) | | [remote_workflow_instantiate](Ans_DataProcessing_operators_utility_remote_workflow_instantiate.md) | Sends a local workflow to a remote process (and keep a local image of it) or create a local image of an existing remote workflow (identified by an id and an address) for a given protocol registered in the streams. ///available inputs: workflow_to_send (Workflow, Int32), streams_to_remote (StreamsContainer), data_sources_to_remote (DataSources) (optional) | | [remove_unnecessary_labels](Ans_DataProcessing_operators_utility_remove_unnecessary_labels.md) | Removes the selected label from a fields container. ///available inputs: permissive (bool) (optional), fields_container (FieldsContainer), label_to_remove (string) | | [scalars_to_field](Ans_DataProcessing_operators_utility_scalars_to_field.md) | scalars_to_field() | | [server_path](Ans_DataProcessing_operators_utility_server_path.md) | Returns the platform-specific path to a folder in the Dpf server ///available inputs: subpath (Int32) (optional) | -| [set_attribute](Ans_DataProcessing_operators_utility_set_attribute.md) | Uses the FieldsContainer APIs to modify it. ///available inputs: fields_container (FieldsContainer), property_name (string), property_identifier (LabelSpace, string, StringField) (optional) | +| [set_attribute](Ans_DataProcessing_operators_utility_set_attribute.md) | set_attribute() | | [set_property](Ans_DataProcessing_operators_utility_set_property.md) | Sets a property to an input field / fields container. A Field in pin 0, a property name (string) in pin 1 and a valid property value in pin 2 are expected as inputs. ///available inputs: field (Field, FieldsContainer), property_name (string), property (string, TimeFreqSupport, Scoping, DataTree, Int32, double) | | [split_in_for_each_range](Ans_DataProcessing_operators_utility_split_in_for_each_range.md) | Split a scoping into several pieces so you can iterate it with a for_each loop. ///available inputs: iterable (Any) (optional), operator_to_iterate (Operator), pin_index (Int32), scoping (Scoping), chunk_size (Int32) | | [strain_from_voigt](Ans_DataProcessing_operators_utility_strain_from_voigt.md) | Converts strain field data from Voigt notation (6-component vector) to standard symmetric matrix format (3x3 tensor). ///available inputs: strain_field (Field, FieldsContainer) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/propertyfield_get_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/propertyfield_get_attribute.md index c91483d7d7..8afdb168f3 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/propertyfield_get_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/propertyfield_get_attribute.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.utility.propertyfield_get_attribute # *class* propertyfield_get_attribute(property_field: object = None, property_name: object = None, config: OperatorConfig = None) -Gets a property from an input field / fields container. A PropertyField in pin 0 and a property name (string) in pin 1 are expected as inputs. +propertyfield_get_attribute() + +propertyfield_get_attribute(property_field: object, property_name: object, config: OperatorConfig) + +propertyfield_get_attribute(config: OperatorConfig) -available inputs: `property_field` (PropertyField, PropertyFieldsContainer), `property_name` (string) -available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) **DPF Framework Reference:** [propertyfield_get_attribute operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/propertyfield_get_attribute.md) @@ -18,14 +20,6 @@ available outputs: `property` (string ,TimeFreqSupport ,Scoping ,DataTree) * **property_name** * **config** -**Example:** - -```python -op = propertyfield_get_attribute() - -op = propertyfield_get_attribute(property_field=my_property_field,property_name=my_property_name) -``` - ## Inputs ### property_field @@ -34,7 +28,7 @@ op = propertyfield_get_attribute(property_field=my_property_field,property_name= ### property_name -Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header' and 'datasize'. +Property to get. Accepted inputs are specific strings namely: 'unit, 'name','time_freq_support', 'scoping', 'header', 'datasize' and 'data'. **Type:** *LinkableInput* @@ -42,7 +36,7 @@ Property to get. Accepted inputs are specific strings namely: 'unit, 'name','tim ### property -Property value that is returned. Accepted Outputs are: Field, PropertyField, CustomTypeField or their containers. +Property value that is returned. **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/set_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/set_attribute.md index c51003407a..084c1df6a7 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/set_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/utility/set_attribute.md @@ -4,11 +4,13 @@ uid: Ans.DataProcessing.operators.utility.set_attribute # *class* set_attribute(fields_container: object = None, property_name: object = None, property_identifier: object = None, config: OperatorConfig = None) -Uses the FieldsContainer APIs to modify it. +set_attribute() + +set_attribute(fields_container: object, property_name: object, property_identifier: object, config: OperatorConfig) + +set_attribute(config: OperatorConfig) -available inputs: `fields_container` (FieldsContainer), `property_name` (string), `property_identifier` (LabelSpace, string, StringField) (optional) -available outputs: `fields_container` (FieldsContainer) **DPF Framework Reference:** [set_attribute operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/utility/set_attribute.md) @@ -19,14 +21,6 @@ available outputs: `fields_container` (FieldsContainer) * **property_identifier** * **config** -**Example:** - -```python -op = set_attribute() - -op = set_attribute(fields_container=my_fields_container,property_name=my_property_name,property_identifier=my_property_identifier) -``` - ## Inputs ### fields_container From 367f1e498b65f5c3a075bedd78f4ff1690533be1 Mon Sep 17 00:00:00 2001 From: DPF User Date: Fri, 31 Jul 2026 20:16:40 -0400 Subject: [PATCH 4/7] DPF dpf-mechanical doc update for 271 (2026.07.31) --- .../operators/math/index.md | 1 + .../operators/math/mechanical/index.md | 11 --- .../math/mechanical/min_max_over_time.md | 65 -------------- .../math/mechanical_min_max_over_time.md | 89 +++++++++++++++++++ .../operators/min_max/index.md | 24 ++--- .../min_max/max_over_time_by_entity.md | 16 +++- .../operators/min_max/min_max.md | 22 ++++- .../operators/min_max/min_max_by_entity.md | 26 +++++- .../operators/min_max/min_max_by_time.md | 24 ++++- .../operators/min_max/min_max_fc.md | 24 ++++- .../operators/min_max/min_max_fc_inc.md | 18 +++- .../operators/min_max/min_max_inc.md | 24 ++++- .../min_max/min_max_over_label_fc.md | 40 ++++++++- .../min_max/min_max_over_time_by_entity.md | 30 +++++-- .../min_max/min_over_time_by_entity.md | 16 +++- .../min_max/time_of_max_by_entity.md | 16 +++- .../min_max/time_of_min_by_entity.md | 16 +++- .../result/contact_element_heat_flow.md | 82 +++++++++++++++++ .../result/convection_heat_flow_rate.md | 82 +++++++++++++++++ .../operators/result/index.md | 3 + .../result/radiation_heat_flow_rate.md | 82 +++++++++++++++++ .../versions/2027.R1.SP00/api/index.md | 1 - .../versions/2027.R1.SP00/api/toc.yml | 13 +-- .../versions/2027.R1.SP00/toc.yml | 13 +-- 24 files changed, 613 insertions(+), 125 deletions(-) delete mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/index.md delete mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/contact_element_heat_flow.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/convection_heat_flow_rate.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md index 3bd04704fa..e07f571187 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/index.md @@ -67,6 +67,7 @@ uid: Ans.DataProcessing.operators.math | [matrix_inverse](Ans_DataProcessing_operators_math_matrix_inverse.md) | Computes the [matrix inverse](https://en.wikipedia.org/wiki/Invertible_matrix) | | [matrix_product](Ans_DataProcessing_operators_math_matrix_product.md) | matrix_product() | | [matrix_product_fc](Ans_DataProcessing_operators_math_matrix_product_fc.md) | matrix_product_fc() | +| [mechanical_min_max_over_time](Ans_DataProcessing_operators_math_mechanical_min_max_over_time.md) | Dispatch operator that selects and runs a minimum/maximum operator over time or frequency, based on the integer selector on pin 5. | | [minus](Ans_DataProcessing_operators_math_minus.md) | minus() | | [minus_fc](Ans_DataProcessing_operators_math_minus_fc.md) | minus_fc() | | [modal_damping_ratio](Ans_DataProcessing_operators_math_modal_damping_ratio.md) | modal_damping_ratio() | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/index.md deleted file mode 100644 index 9e74f36413..0000000000 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/index.md +++ /dev/null @@ -1,11 +0,0 @@ ---- -uid: Ans.DataProcessing.operators.math.mechanical ---- - -# Ans.DataProcessing.operators.math.mechanical Namespace - -## Classes - -| Class | Description | -|-------|-------------| -| [min_max_over_time](Ans_DataProcessing_operators_math_mechanical_min_max_over_time.md) | Evaluates minimum/maximum over time/frequency. ///available inputs: fields_container (FieldsContainer), int32 (Int32) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md deleted file mode 100644 index 4777a396c3..0000000000 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md +++ /dev/null @@ -1,65 +0,0 @@ ---- -uid: Ans.DataProcessing.operators.math.mechanical.min_max_over_time ---- - -# *class* min_max_over_time(fields_container: object = None, int32: object = None, config: OperatorConfig = None) - -Evaluates minimum/maximum over time/frequency. - -available inputs: `fields_container` (FieldsContainer), `int32` (Int32) - -available outputs: `field_container_1` (FieldsContainer), `field_container_2` (FieldsContainer) - -**DPF Framework Reference:** [min_max_over_time operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/math/min_max_over_time.md) - -**Parameters:** - -* **fields_container** -* **int32** -* **config** - -**Example:** - -```python -op = min_max_over_time() - -op = min_max_over_time(fields_container=my_fields_container,int32=my_int32) -``` - -## Inputs - -### fields_container - -**Type:** *LinkableInput* - -### int32 - -Define min or max. - -**Type:** *LinkableInput* - -## Outputs - -### field_container_1 - -**Type:** *LinkableOutput* - -### field_container_2 - -**Type:** *LinkableOutput* - -## Methods - -## Properties - -#### *property* inputs: InputSpec - -*get/set* - -#### *property* outputs: OutputSpec - -*get/set* - -#### *property* defaultConfig: Config - -*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md new file mode 100644 index 0000000000..ddb7f1ee00 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md @@ -0,0 +1,89 @@ +--- +uid: Ans.DataProcessing.operators.math.mechanical_min_max_over_time +--- + +# *class* mechanical_min_max_over_time(fields_container: object = None, int32: object = None, config: OperatorConfig = None) + +Dispatch operator that selects and runs a minimum/maximum operator over time or frequency, based on the integer selector on pin 5. + +Selector values on pin 5: + +- `0`: `min_max_by_time` - per-step, per-component minimum and maximum, aggregating every entity of each field (elemental-nodal values collapse into the reduction). + +- `1`: `max_over_time_by_entity` - per-entity, per-component maximum across all time or frequency steps. + +- `2`: `time_of_max_by_entity` - time or frequency at which each per-entity, per-component maximum occurs. + +- `7`: `min_over_time_by_entity` - per-entity, per-component minimum across all time or frequency steps. + +- `8`: `time_of_min_by_entity` - time or frequency at which each per-entity, per-component minimum occurs. + +Selectors 1, 2, 7 and 8 keep the entity axis: the underlying operator (`min_max_over_time_by_entity`) returns one value per entity, per component and per shell layer when available. Selector 0 (`min_max_by_time`) reduces across entities instead. + +Output pin 0 holds the primary result of the selected operator. + +Output pin 1 is optional and populated only when the selected operator produces two outputs (currently only selector `0`). + +available inputs: `fields_container` (FieldsContainer), `int32` (Int32) + +available outputs: `field_container_1` (FieldsContainer), `field_container_2` (FieldsContainer) + +**DPF Framework Reference:** [mechanical_min_max_over_time operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/math/mechanical_min_max_over_time.md) + +**Parameters:** + +* **fields_container** +* **int32** +* **config** + +**Example:** + +```python +op = mechanical_min_max_over_time() + +op = mechanical_min_max_over_time(fields_container=my_fields_container,int32=my_int32) +``` + +## Inputs + +### fields_container + +Input fields container passed through to the selected underlying operator. + +**Type:** *LinkableInput* + +### int32 + +Selector integer that chooses the underlying operator. Supported values: `0` (min_max_by_time), `1` (max_over_time_by_entity), `2` (time_of_max_by_entity), `7` (min_over_time_by_entity), `8` (time_of_min_by_entity). + +**Type:** *LinkableInput* + +## Outputs + +### field_container_1 + +Primary result forwarded from the selected underlying operator. + +**Type:** *LinkableOutput* + +### field_container_2 + +Secondary result forwarded from the selected underlying operator. Populated only when the underlying operator produces two outputs (currently only selector `0` populates this pin). + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/index.md index a8f21fdd68..389ee616fa 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/index.md @@ -10,17 +10,17 @@ uid: Ans.DataProcessing.operators.min_max |-------|-------------| | [max_by_component](Ans_DataProcessing_operators_min_max_max_by_component.md) | Give the maximum for each element rank by comparing several fields. ///available inputs: use_absolute_value (bool), field1 (Field, FieldsContainer), field2 (Field, FieldsContainer) | | [max_over_phase](Ans_DataProcessing_operators_min_max_max_over_phase.md) | Returns, for each entity, the maximum value of (real value * cos(theta) - imaginary value * sin(theta)) for theta in [0, 360]degrees with the increment in input. ///available inputs: real_field (Field), imaginary_field (Field), abs_value (bool) (optional), phase_increment (double) (optional) | -| [max_over_time_by_entity](Ans_DataProcessing_operators_min_max_max_over_time_by_entity.md) | Evaluates maximum over time/frequency. ///available inputs: fields_container (FieldsContainer), abs_value (bool) (optional), compute_amplitude (bool) (optional) | +| [max_over_time_by_entity](Ans_DataProcessing_operators_min_max_max_over_time_by_entity.md) | Thin wrapper around `min_max_over_time_by_entity` that exposes only the per-entity, per-component maximum across all time or frequency steps. | | [min_by_component](Ans_DataProcessing_operators_min_max_min_by_component.md) | Give the minimum for each element rank by comparing several fields. ///available inputs: use_absolute_value (bool), field1 (Field, FieldsContainer), field2 (Field, FieldsContainer) | -| [min_max](Ans_DataProcessing_operators_min_max_min_max.md) | Compute the component-wise minimum (out 0) and maximum (out 1) over a field. ///available inputs: field (Field, FieldsContainer) | -| [min_max_by_entity](Ans_DataProcessing_operators_min_max_min_max_by_entity.md) | Compute the entity-wise minimum (out 0) and maximum (out 1) through all fields of a fields container. ///available inputs: fields_container (FieldsContainer) | -| [min_max_by_time](Ans_DataProcessing_operators_min_max_min_max_by_time.md) | Evaluates minimum, maximum by time or frequency over all the entities of each field ///available inputs: fields_container (FieldsContainer), compute_absolute_value (bool) (optional) | -| [min_max_fc](Ans_DataProcessing_operators_min_max_min_max_fc.md) | Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container. ///available inputs: fields_container (FieldsContainer) | -| [min_max_fc_inc](Ans_DataProcessing_operators_min_max_min_max_fc_inc.md) | Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container. ///available inputs: fields_container (FieldsContainer) | -| [min_max_inc](Ans_DataProcessing_operators_min_max_min_max_inc.md) | Compute the component-wise minimum (out 0) and maximum (out 1) over coming fields. ///available inputs: field (Field), domain_id (Int32) (optional) | -| [min_max_over_label_fc](Ans_DataProcessing_operators_min_max_min_max_over_label_fc.md) | Create two fields (0 min 1 max) by looping over the fields container in input and taking the min/max value by component through all the fields having the same id for the label set in input (in pin 1). If no label is specified or if the specified label doesn't exist, the operation is done over all the fields. The fields out are located on the label set in input, so their scoping are the labels ids.For each min max value, the label id for one other fields container labels is kept and returned in a scoping in pin 2 (min) and 3 (max).The field's scoping ids of the value kept in min max are also returned in the scopings in pin 4 (min) and 5 (max). ///available inputs: fields_container (FieldsContainer), label (string) | -| [min_max_over_time_by_entity](Ans_DataProcessing_operators_min_max_min_max_over_time_by_entity.md) | For each entity and component, evaluates minimum and maximum over time/frequency. | -| [min_over_time_by_entity](Ans_DataProcessing_operators_min_max_min_over_time_by_entity.md) | Evaluates minimum over time/frequency. ///available inputs: fields_container (FieldsContainer), abs_value (bool) (optional), compute_amplitude (bool) (optional) | +| [min_max](Ans_DataProcessing_operators_min_max_min_max.md) | Computes, for each component of the input field, the minimum and the maximum across all entities. | +| [min_max_by_entity](Ans_DataProcessing_operators_min_max_min_max_by_entity.md) | Computes, for each entity and each component, the minimum and the maximum across all fields of the input fields container. | +| [min_max_by_time](Ans_DataProcessing_operators_min_max_min_max_by_time.md) | For each time or frequency step of the input fields container, computes the per-component minimum and maximum across all entities of the field at that step. | +| [min_max_fc](Ans_DataProcessing_operators_min_max_min_max_fc.md) | Computes, for each field of the input fields container and for each component, the minimum and the maximum across all entities of that field. | +| [min_max_fc_inc](Ans_DataProcessing_operators_min_max_min_max_fc_inc.md) | Incremental variant that computes, for each time or frequency step of the input fields container, the per-component minimum and maximum across all successive calls of the operator. | +| [min_max_inc](Ans_DataProcessing_operators_min_max_min_max_inc.md) | Incremental variant that computes, for each component, the minimum and the maximum of successive input fields across all calls of the operator. | +| [min_max_over_label_fc](Ans_DataProcessing_operators_min_max_min_max_over_label_fc.md) | Groups the fields of the input fields container by the given label and, within each group, computes the per-component minimum and maximum across all fields of the group. | +| [min_max_over_time_by_entity](Ans_DataProcessing_operators_min_max_min_max_over_time_by_entity.md) | For each entity, each component and each shell layer (when available), computes the minimum and maximum across all time or frequency steps of the input fields container. | +| [min_over_time_by_entity](Ans_DataProcessing_operators_min_max_min_over_time_by_entity.md) | Thin wrapper around `min_max_over_time_by_entity` that exposes only the per-entity, per-component minimum across all time or frequency steps. | | [phase_of_max](Ans_DataProcessing_operators_min_max_phase_of_max.md) | Evaluates phase of maximum. ///available inputs: real_field (Field), imaginary_field (Field), abs_value (bool) (optional), phase_increment (double) | -| [time_of_max_by_entity](Ans_DataProcessing_operators_min_max_time_of_max_by_entity.md) | Evaluates time/frequency of maximum. ///available inputs: fields_container (FieldsContainer), abs_value (bool) (optional), compute_amplitude (bool) (optional) | -| [time_of_min_by_entity](Ans_DataProcessing_operators_min_max_time_of_min_by_entity.md) | Evaluates time/frequency of minimum. ///available inputs: fields_container (FieldsContainer), abs_value (bool) (optional), compute_amplitude (bool) (optional) | +| [time_of_max_by_entity](Ans_DataProcessing_operators_min_max_time_of_max_by_entity.md) | Thin wrapper around `min_max_over_time_by_entity` that exposes only the time or frequency value at which each per-entity, per-component maximum occurred. | +| [time_of_min_by_entity](Ans_DataProcessing_operators_min_max_time_of_min_by_entity.md) | Thin wrapper around `min_max_over_time_by_entity` that exposes only the time or frequency value at which each per-entity, per-component minimum occurred. | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/max_over_time_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/max_over_time_by_entity.md index 1d504cc629..5407aa0f6e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/max_over_time_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/max_over_time_by_entity.md @@ -4,7 +4,13 @@ uid: Ans.DataProcessing.operators.min_max.max_over_time_by_entity # *class* max_over_time_by_entity(fields_container: object = None, abs_value: object = None, compute_amplitude: object = None, config: OperatorConfig = None) -Evaluates maximum over time/frequency. +Thin wrapper around `min_max_over_time_by_entity` that exposes only the per-entity, per-component maximum across all time or frequency steps. + +The result forwarded on output pin 0 is pin 1 of `min_max_over_time_by_entity` (the `max` fields container), with the same shape: one value per entity, per component and per shell layer when available. + +**When to use:** you only need the per-entity maximum over time. + +Prefer `min_max_over_time_by_entity` directly when you also need the minimum, the time of extremum, or the incremental behaviour on multiple output pins. available inputs: `fields_container` (FieldsContainer), `abs_value` (bool) (optional), `compute_amplitude` (bool) (optional) @@ -31,17 +37,19 @@ op = max_over_time_by_entity(fields_container=my_fields_container,abs_value=my_a ### fields_container +Fields container aggregated per entity across all time or frequency steps. Must expose the `time` label; otherwise the input is forwarded unchanged by the underlying operator. + **Type:** *LinkableInput* ### abs_value -Should use absolute value. +When `true`, absolute values of the field entries are used before the max is computed. Default: `false`. **Type:** *LinkableInput* ### compute_amplitude -Do calculate amplitude. +When `true` and the input fields container has the `complex` label, the amplitude of the complex values is used before the max is computed. Ignored otherwise. Default: `false`. **Type:** *LinkableInput* @@ -49,6 +57,8 @@ Do calculate amplitude. ### fields_container +Per-entity, per-component maximum across all time or frequency steps. Same shape as pin 1 of `min_max_over_time_by_entity`. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max.md index 9726c77df6..59b5eefab0 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max.md @@ -4,7 +4,23 @@ uid: Ans.DataProcessing.operators.min_max.min_max # *class* min_max(field: object = None, config: OperatorConfig = None) -Compute the component-wise minimum (out 0) and maximum (out 1) over a field. +Computes, for each component of the input field, the minimum and the maximum across all entities. + +Also known as component-wise min/max over a field. + +The output minimum (pin 0) and maximum (pin 1) are scalar fields with one entity per component of the input. + +Each entity id in the output scoping is the id of the input entity that holds the returned minimum or maximum value for that component. + +Within the input field, all elementary values contribute to the reduction: elemental-nodal expansions and shell-layer values (when present) are folded into the same per-component min/max. + +If the input is a fields container, it must contain exactly one field. + +**When to use:** you have a single field and want the per-component extrema. + +Example: peak of each stress component over the whole mesh at one time step. + +Use `min_max_fc` when you have several fields and want one summary per field, or `min_max_by_entity` to keep the per-entity resolution while reducing over the fields axis. available inputs: `field` (Field, FieldsContainer) @@ -37,10 +53,14 @@ field or fields container with only one field is expected ### field_min +Scalar field of per-component minimum values. Its scoping ids point to the input entity that holds each minimum. + **Type:** *LinkableOutput* ### field_max +Scalar field of per-component maximum values. Its scoping ids point to the input entity that holds each maximum. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_entity.md index 09436f7e2d..b453a133e7 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_entity.md @@ -4,7 +4,25 @@ uid: Ans.DataProcessing.operators.min_max.min_max_by_entity # *class* min_max_by_entity(fields_container: object = None, config: OperatorConfig = None) -Compute the entity-wise minimum (out 0) and maximum (out 1) through all fields of a fields container. +Computes, for each entity and each component, the minimum and the maximum across all fields of the input fields container. + +Entity ids are matched across fields. + +A field is skipped for a given entity if that entity id is not present in its scoping; + +if the entity id has not been seen in any prior field, it is added to the output with the current field data. + +Fields with no data are skipped entirely. + +The outputs share the same scoping as the first non-empty input field, augmented with any entity ids first seen in later fields. + +Within each input field, all elementary values contribute to the per-entity reduction: elemental-nodal expansions and shell-layer values (when present) are folded into the same per-component min/max. + +**When to use:** you want to keep the entity axis while reducing over the fields axis. + +Example: envelope of nodal stress across load cases, giving one min/max value per node and per component. + +Use `min_max_fc` to get one summary per field instead, or `min_max_over_time_by_entity` when the fields are indexed by a `time` label. available inputs: `fields_container` (FieldsContainer) @@ -29,16 +47,22 @@ op = min_max_by_entity(fields_container=my_fields_container) ### fields_container +Fields container whose fields are aggregated per entity and per component. + **Type:** *LinkableInput* ## Outputs ### field_min +Field of per-entity, per-component minima across all input fields. + **Type:** *LinkableOutput* ### field_max +Field of per-entity, per-component maxima across all input fields. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_time.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_time.md index 3ca53aa369..35d9e779ac 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_time.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_by_time.md @@ -4,7 +4,21 @@ uid: Ans.DataProcessing.operators.min_max.min_max_by_time # *class* min_max_by_time(fields_container: object = None, compute_absolute_value: object = None, config: OperatorConfig = None) -Evaluates minimum, maximum by time or frequency over all the entities of each field +For each time or frequency step of the input fields container, computes the per-component minimum and maximum across all entities of the field at that step. + +Results exposed by component, collapsed by time, shell layers (when available). + +The result is grouped by all labels of the input fields container except `time`. + +For every remaining label combination, the output minimum (pin 0) and maximum (pin 1) each contain one field whose entity ids are the time or frequency step ids and whose values are the per-component minima and maxima at that step. + +If the input does not contain the `time` label, the input fields container is forwarded unchanged. + +**When to use:** you want to keep the time or frequency axis but reduce across entities, giving one per-component min/max value per step. + +Example: peak displacement across the mesh at every time step of a transient analysis. + +Use `min_max_over_time_by_entity` for the dual reduction (keep entities, collapse time), or `min_max_fc_inc` for the incremental variant. available inputs: `fields_container` (FieldsContainer), `compute_absolute_value` (bool) (optional) @@ -30,11 +44,13 @@ op = min_max_by_time(fields_container=my_fields_container,compute_absolute_value ### fields_container +Fields container aggregated per time or frequency step. Must expose the `time` label to trigger the aggregation; otherwise the input is forwarded unchanged. + **Type:** *LinkableInput* ### compute_absolute_value -Calculate the absolute value of field entities before computing the min/max. +When set to `true`, absolute values of the field entries are used before the min and max are computed. Default: `false`. **Type:** *LinkableInput* @@ -42,10 +58,14 @@ Calculate the absolute value of field entities before computing the min/max. ### min +Per-component minima grouped by all input labels except `time`. Within each output field, entity ids are the time or frequency step ids. + **Type:** *LinkableOutput* ### max +Per-component maxima grouped by all input labels except `time`. Within each output field, entity ids are the time or frequency step ids. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc.md index f04e222efd..de1549b3de 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc.md @@ -4,7 +4,23 @@ uid: Ans.DataProcessing.operators.min_max.min_max_fc # *class* min_max_fc(fields_container: object = None, config: OperatorConfig = None) -Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container. +Computes, for each field of the input fields container and for each component, the minimum and the maximum across all entities of that field. + +Also known as component-wise min/max over a fields container. + +The output minimum (pin 0) and maximum (pin 1) are fields with one entity per input field. + +Each entity holds, for each component, the min or max value found in the corresponding input field. + +The entity ids in the output scoping are the input field indices in the fields container. + +Within each input field, all elementary values contribute to the reduction: elemental-nodal expansions and shell-layer values (when present) are folded into the same per-component min/max. + +**When to use:** you want one per-component summary per field of the container, without reducing across fields. + +Example: peak of each stress component per body when the container groups fields by body id. + +Use `min_max` for a single field, `min_max_by_entity` to keep per-entity resolution across fields, or `min_max_over_label_fc` to group fields by label before reducing. available inputs: `fields_container` (FieldsContainer) @@ -29,16 +45,22 @@ op = min_max_fc(fields_container=my_fields_container) ### fields_container +Fields container over which per-field, per-component minima and maxima are computed. + **Type:** *LinkableInput* ## Outputs ### field_min +Field of per-field, per-component minima. One entity per input field. + **Type:** *LinkableOutput* ### field_max +Field of per-field, per-component maxima. One entity per input field. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc_inc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc_inc.md index d3275e3c73..1b20472467 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc_inc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_fc_inc.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.min_max.min_max_fc_inc # *class* min_max_fc_inc(fields_container: object = None, config: OperatorConfig = None) -Compute the component-wise minimum (out 0) and maximum (out 1) over a fields container. +Incremental variant that computes, for each time or frequency step of the input fields container, the per-component minimum and maximum across all successive calls of the operator. + +At each call, results are merged with the previously-cached extrema. + +The output minimum (pin 0) and maximum (pin 1) are fields with one entity per time or frequency step of the input. + +**When to use:** the full set of fields does not fit in memory and results must be aggregated over successive server calls, one fields container at a time. + +Example: peak of each stress component per time step accumulated over a long transient analysis processed one chunk of time steps at a time. + +Use `min_max_by_time` for the non-incremental variant, or `min_max_inc` when input arrives one field at a time instead of one fields container at a time. available inputs: `fields_container` (FieldsContainer) @@ -29,16 +39,22 @@ op = min_max_fc_inc(fields_container=my_fields_container) ### fields_container +Fields container for the current increment. Must expose a time-frequency support so that output entries can be indexed by time or frequency step. + **Type:** *LinkableInput* ## Outputs ### field_min +Field of per-step, per-component minima aggregated across all calls of the operator so far. + **Type:** *LinkableOutput* ### field_max +Field of per-step, per-component maxima aggregated across all calls of the operator so far. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_inc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_inc.md index b57e3502c6..9882c343ff 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_inc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_inc.md @@ -4,7 +4,17 @@ uid: Ans.DataProcessing.operators.min_max.min_max_inc # *class* min_max_inc(field: object = None, domain_id: object = None, config: OperatorConfig = None) -Compute the component-wise minimum (out 0) and maximum (out 1) over coming fields. +Incremental variant that computes, for each component, the minimum and the maximum of successive input fields across all calls of the operator. + +At each call, the per-component minimum and maximum are updated by comparing the current input field with the previously-cached extrema. + +When the optional `domain_id` pin is connected, outputs 2 and 3 return, for each component, the domain id of the call that produced the minimum and maximum, respectively. + +**When to use:** successive fields arrive one at a time (typically streamed from a solver) and the full history does not fit in memory. + +Example: running envelope of nodal stress updated at each iteration of a transient run. + +Use `min_max` for the non-incremental variant, or `min_max_fc_inc` when input arrives one fields container at a time. available inputs: `field` (Field), `domain_id` (Int32) (optional) @@ -30,28 +40,40 @@ op = min_max_inc(field=my_field,domain_id=my_domain_id) ### field +Input field for the current increment. Combined with the previously-cached extrema. + **Type:** *LinkableInput* ### domain_id +Optional identifier for the current call. When set, outputs 2 and 3 track the domain id that produced each per-component minimum and maximum. + **Type:** *LinkableInput* ## Outputs ### field_min +Per-component minimum aggregated across all calls of the operator so far. + **Type:** *LinkableOutput* ### field_max +Per-component maximum aggregated across all calls of the operator so far. + **Type:** *LinkableOutput* ### domain_ids_min +For each component of the output minimum, the id of the call (as passed on the `domain_id` input pin) that produced the current minimum. Populated only when the `domain_id` input pin is connected. + **Type:** *LinkableOutput* ### domain_ids_max +For each component of the output maximum, the id of the call (as passed on the `domain_id` input pin) that produced the current maximum. Populated only when the `domain_id` input pin is connected. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_label_fc.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_label_fc.md index da364bec7c..11ea38379e 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_label_fc.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_label_fc.md @@ -4,7 +4,29 @@ uid: Ans.DataProcessing.operators.min_max.min_max_over_label_fc # *class* min_max_over_label_fc(fields_container: object = None, label: object = None, config: OperatorConfig = None) -Create two fields (0 min 1 max) by looping over the fields container in input and taking the min/max value by component through all the fields having the same id for the label set in input (in pin 1). If no label is specified or if the specified label doesn't exist, the operation is done over all the fields. The fields out are located on the label set in input, so their scoping are the labels ids.For each min max value, the label id for one other fields container labels is kept and returned in a scoping in pin 2 (min) and 3 (max).The field's scoping ids of the value kept in min max are also returned in the scopings in pin 4 (min) and 5 (max). +Groups the fields of the input fields container by the given label and, within each group, computes the per-component minimum and maximum across all fields of the group. + +If the label is not set or does not exist in the fields container, the operation runs over all fields as a single group. + +Outputs: + +- Pins 0 and 1: fields of per-group, per-component minima and maxima. Their scoping is the set of label ids (or a single entity when no label applies). + +- Pins 2 and 3 (optional): for each output entry, the id of one remaining label of the input fields container corresponding to the field that provided the minimum and maximum, respectively. + +- Pins 4 and 5: for each output entry, the input scoping id of the entity within the source field that provided the minimum and maximum. + +Input fields with no data are excluded from the output. + +Within each input field, all elementary values contribute to the per-group reduction: elemental-nodal expansions and shell-layer values (when present) are folded into the same per-component min/max. + +**When to use:** fields in the container are indexed by one or more labels (for example `body`, `zone`) and you want one per-component extremum per label id, collapsing every entity of each group into a single output entry. + +Example: peak of each stress component per body when the container is labelled by body id. + +Without a label, all entities of all fields collapse into a single output entity, equivalent to `min_max(min_max_fc(...))`. + +Use `min_max_by_entity` to keep entity resolution instead, or `min_max_fc` to keep per-field resolution. available inputs: `fields_container` (FieldsContainer), `label` (string) @@ -30,11 +52,13 @@ op = min_max_over_label_fc(fields_container=my_fields_container,label=my_label) ### fields_container +Fields container whose fields are grouped by the label passed on pin 1. + **Type:** *LinkableInput* ### label -label name from the fields container +Name of the label used to group the fields of the input fields container. If not set or not present, all fields are used as a single group. **Type:** *LinkableInput* @@ -42,26 +66,38 @@ label name from the fields container ### field_min +Field of per-group, per-component minima. Scoped on the label ids used for grouping. + **Type:** *LinkableOutput* ### field_max +Field of per-group, per-component maxima. Scoped on the label ids used for grouping. + **Type:** *LinkableOutput* ### domain_ids_min +For each entry of the output minimum field, the id of one remaining label of the input fields container from the field that provided the minimum. Populated only when the input fields container has more than one label. + **Type:** *LinkableOutput* ### domain_ids_max +For each entry of the output maximum field, the id of one remaining label of the input fields container from the field that provided the maximum. Populated only when the input fields container has more than one label. + **Type:** *LinkableOutput* ### scoping_ids_min +For each entry of the output minimum field, the input scoping id of the entity within the source field that provided the minimum. + **Type:** *LinkableOutput* ### scoping_ids_max +For each entry of the output maximum field, the input scoping id of the entity within the source field that provided the maximum. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_time_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_time_by_entity.md index 80c09cfd6f..b6b410fb40 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_time_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_max_over_time_by_entity.md @@ -4,11 +4,21 @@ uid: Ans.DataProcessing.operators.min_max.min_max_over_time_by_entity # *class* min_max_over_time_by_entity(fields_container: object = None, compute_absolute_value: object = None, compute_amplitude: object = None, config: OperatorConfig = None) -For each entity and component, evaluates minimum and maximum over time/frequency. +For each entity, each component and each shell layer (when available), computes the minimum and maximum across all time or frequency steps of the input fields container. -Input pin 4 `compute_amplitude` is only effective when given `fields_container` contains the `complex` label. +Elemental-nodal values are folded into the per-entity reduction; shell-layer values are preserved when the input exposes them. -if given input `fields_container` has a `time_freq_support`, output pins 2 and 3 `fields_container` contains time/freq indices of the minimum and maximum values. +The input `compute_amplitude` pin has effect only when the input fields container carries the `complex` label: when `true`, the amplitude of the complex values is used before the extremum is computed. + +When the input has a time-frequency support, output pins 2 and 3 return fields containers holding the time or frequency value at which each per-entity, per-component minimum and maximum occurred. + +When `compute_absolute_value` is `true`, extrema are computed on the absolute values of the field entries. + +**When to use:** you want to keep the entity axis but reduce across time or frequency, giving one per-component min/max per entity across the whole history. + +Example: peak stress ever reached at each node over an entire transient analysis, along with the time at which each peak occurred (pins 2 and 3). + +Use `min_max_by_time` for the dual reduction (keep time, collapse entities), or `min_max_by_entity` when the fields are not indexed by time. available inputs: `fields_container` (FieldsContainer), `compute_absolute_value` (bool) (optional), `compute_amplitude` (bool) (optional) @@ -35,17 +45,19 @@ op = min_max_over_time_by_entity(fields_container=my_fields_container,compute_ab ### fields_container +Fields container aggregated per entity across all time or frequency steps. Must expose the `time` label; otherwise the input is forwarded unchanged. + **Type:** *LinkableInput* ### compute_absolute_value -Calculate the absolute value of field entities before computing the min/max. +When `true`, absolute values of the field entries are used before the min and max are computed. Default: `false`. **Type:** *LinkableInput* ### compute_amplitude -Do calculate amplitude. +When `true` and the input fields container has the `complex` label, the amplitude of the complex values is used before the extremum is computed. Ignored otherwise. Default: `false`. **Type:** *LinkableInput* @@ -53,18 +65,26 @@ Do calculate amplitude. ### min +Per-entity, per-component minima aggregated across all time or frequency steps. Grouped by all input labels except `time` (and `complex` when `compute_amplitude` is active). + **Type:** *LinkableOutput* ### max +Per-entity, per-component maxima aggregated across all time or frequency steps. Grouped by all input labels except `time` (and `complex` when `compute_amplitude` is active). + **Type:** *LinkableOutput* ### time_freq_of_min +For each entry of the output minimum, the time or frequency value at which it occurred. Populated only when the input carries a time-frequency support. + **Type:** *LinkableOutput* ### time_freq_of_max +For each entry of the output maximum, the time or frequency value at which it occurred. Populated only when the input carries a time-frequency support. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_over_time_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_over_time_by_entity.md index 86796a0a1c..d5ce18abdf 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_over_time_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/min_over_time_by_entity.md @@ -4,7 +4,13 @@ uid: Ans.DataProcessing.operators.min_max.min_over_time_by_entity # *class* min_over_time_by_entity(fields_container: object = None, abs_value: object = None, compute_amplitude: object = None, config: OperatorConfig = None) -Evaluates minimum over time/frequency. +Thin wrapper around `min_max_over_time_by_entity` that exposes only the per-entity, per-component minimum across all time or frequency steps. + +The result forwarded on output pin 0 is pin 0 of `min_max_over_time_by_entity` (the `min` fields container), with the same shape: one value per entity, per component and per shell layer when available. + +**When to use:** you only need the per-entity minimum over time. + +Prefer `min_max_over_time_by_entity` directly when you also need the maximum, the time of extremum, or the incremental behaviour on multiple output pins. available inputs: `fields_container` (FieldsContainer), `abs_value` (bool) (optional), `compute_amplitude` (bool) (optional) @@ -31,17 +37,19 @@ op = min_over_time_by_entity(fields_container=my_fields_container,abs_value=my_a ### fields_container +Fields container aggregated per entity across all time or frequency steps. Must expose the `time` label; otherwise the input is forwarded unchanged by the underlying operator. + **Type:** *LinkableInput* ### abs_value -Should use absolute value. +When `true`, absolute values of the field entries are used before the min is computed. Default: `false`. **Type:** *LinkableInput* ### compute_amplitude -Do calculate amplitude. +When `true` and the input fields container has the `complex` label, the amplitude of the complex values is used before the min is computed. Ignored otherwise. Default: `false`. **Type:** *LinkableInput* @@ -49,6 +57,8 @@ Do calculate amplitude. ### fields_container +Per-entity, per-component minimum across all time or frequency steps. Same shape as pin 0 of `min_max_over_time_by_entity`. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_max_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_max_by_entity.md index 38ea037f7f..4a4a623e95 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_max_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_max_by_entity.md @@ -4,7 +4,13 @@ uid: Ans.DataProcessing.operators.min_max.time_of_max_by_entity # *class* time_of_max_by_entity(fields_container: object = None, abs_value: object = None, compute_amplitude: object = None, config: OperatorConfig = None) -Evaluates time/frequency of maximum. +Thin wrapper around `min_max_over_time_by_entity` that exposes only the time or frequency value at which each per-entity, per-component maximum occurred. + +The result forwarded on output pin 0 is pin 3 of `min_max_over_time_by_entity` (the `time_freq_of_max` fields container). It is populated only when the input carries a time-frequency support. + +**When to use:** you only need the time of maximum. + +Prefer `min_max_over_time_by_entity` directly when you also need the extremum value or the minimum-side outputs. available inputs: `fields_container` (FieldsContainer), `abs_value` (bool) (optional), `compute_amplitude` (bool) (optional) @@ -31,17 +37,19 @@ op = time_of_max_by_entity(fields_container=my_fields_container,abs_value=my_abs ### fields_container +Fields container aggregated per entity across all time or frequency steps. Must expose the `time` label; otherwise the input is forwarded unchanged by the underlying operator. + **Type:** *LinkableInput* ### abs_value -Should use absolute value. +When `true`, absolute values of the field entries are used before the max is computed. Default: `false`. **Type:** *LinkableInput* ### compute_amplitude -Do calculate amplitude. +When `true` and the input fields container has the `complex` label, the amplitude of the complex values is used before the max is computed. Ignored otherwise. Default: `false`. **Type:** *LinkableInput* @@ -49,6 +57,8 @@ Do calculate amplitude. ### fields_container +Time or frequency at which each per-entity, per-component maximum occurred. Populated only when the input carries a time-frequency support. Same shape as pin 3 of `min_max_over_time_by_entity`. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_min_by_entity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_min_by_entity.md index 45dfb1b3a6..090cb70981 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_min_by_entity.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/min_max/time_of_min_by_entity.md @@ -4,7 +4,13 @@ uid: Ans.DataProcessing.operators.min_max.time_of_min_by_entity # *class* time_of_min_by_entity(fields_container: object = None, abs_value: object = None, compute_amplitude: object = None, config: OperatorConfig = None) -Evaluates time/frequency of minimum. +Thin wrapper around `min_max_over_time_by_entity` that exposes only the time or frequency value at which each per-entity, per-component minimum occurred. + +The result forwarded on output pin 0 is pin 2 of `min_max_over_time_by_entity` (the `time_freq_of_min` fields container). It is populated only when the input carries a time-frequency support. + +**When to use:** you only need the time of minimum. + +Prefer `min_max_over_time_by_entity` directly when you also need the extremum value or the maximum-side outputs. available inputs: `fields_container` (FieldsContainer), `abs_value` (bool) (optional), `compute_amplitude` (bool) (optional) @@ -31,17 +37,19 @@ op = time_of_min_by_entity(fields_container=my_fields_container,abs_value=my_abs ### fields_container +Fields container aggregated per entity across all time or frequency steps. Must expose the `time` label; otherwise the input is forwarded unchanged by the underlying operator. + **Type:** *LinkableInput* ### abs_value -Should use absolute value. +When `true`, absolute values of the field entries are used before the min is computed. Default: `false`. **Type:** *LinkableInput* ### compute_amplitude -Do calculate amplitude. +When `true` and the input fields container has the `complex` label, the amplitude of the complex values is used before the min is computed. Ignored otherwise. Default: `false`. **Type:** *LinkableInput* @@ -49,6 +57,8 @@ Do calculate amplitude. ### fields_container +Time or frequency at which each per-entity, per-component minimum occurred. Populated only when the input carries a time-frequency support. Same shape as pin 2 of `min_max_over_time_by_entity`. + **Type:** *LinkableOutput* ## Methods diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/contact_element_heat_flow.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/contact_element_heat_flow.md new file mode 100644 index 0000000000..fee9f08c3f --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/contact_element_heat_flow.md @@ -0,0 +1,82 @@ +--- +uid: Ans.DataProcessing.operators.result.contact_element_heat_flow +--- + +# *class* contact_element_heat_flow(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) + +contact_element_heat_flow() + +contact_element_heat_flow(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) + +contact_element_heat_flow(config: OperatorConfig) + + + +**DPF Framework Reference:** [contact_element_heat_flow operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/contact_element_heat_flow.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +Fields container already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/convection_heat_flow_rate.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/convection_heat_flow_rate.md new file mode 100644 index 0000000000..dbe59fe07f --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/convection_heat_flow_rate.md @@ -0,0 +1,82 @@ +--- +uid: Ans.DataProcessing.operators.result.convection_heat_flow_rate +--- + +# *class* convection_heat_flow_rate(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) + +convection_heat_flow_rate() + +convection_heat_flow_rate(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) + +convection_heat_flow_rate(config: OperatorConfig) + + + +**DPF Framework Reference:** [convection_heat_flow_rate operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/convection_heat_flow_rate.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +Fields container already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md index 924f1399f8..66b6d3fe2c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md @@ -59,6 +59,7 @@ uid: Ans.DataProcessing.operators.result | [compute_total_strain_Y](Ans_DataProcessing_operators_result_compute_total_strain_Y.md) | compute_total_strain_Y() | | [compute_total_strain_YZ](Ans_DataProcessing_operators_result_compute_total_strain_YZ.md) | compute_total_strain_YZ() | | [compute_total_strain_Z](Ans_DataProcessing_operators_result_compute_total_strain_Z.md) | compute_total_strain_Z() | +| [contact_element_heat_flow](Ans_DataProcessing_operators_result_contact_element_heat_flow.md) | contact_element_heat_flow() | | [contact_fluid_penetration_pressure](Ans_DataProcessing_operators_result_contact_fluid_penetration_pressure.md) | contact_fluid_penetration_pressure() | | [contact_friction_stress](Ans_DataProcessing_operators_result_contact_friction_stress.md) | contact_friction_stress() | | [contact_gap_distance](Ans_DataProcessing_operators_result_contact_gap_distance.md) | contact_gap_distance() | @@ -68,6 +69,7 @@ uid: Ans.DataProcessing.operators.result | [contact_status](Ans_DataProcessing_operators_result_contact_status.md) | contact_status() | | [contact_surface_heat_flux](Ans_DataProcessing_operators_result_contact_surface_heat_flux.md) | contact_surface_heat_flux() | | [contact_total_stress](Ans_DataProcessing_operators_result_contact_total_stress.md) | contact_total_stress() | +| [convection_heat_flow_rate](Ans_DataProcessing_operators_result_convection_heat_flow_rate.md) | convection_heat_flow_rate() | | [coordinate_system](Ans_DataProcessing_operators_result_coordinate_system.md) | Extracts the Rotation Matrix and Origin of a specific coordinate system. ///available inputs: cs_id (Int32), streams_container (StreamsContainer) (optional), data_sources (DataSources) | | [coordinates](Ans_DataProcessing_operators_result_coordinates.md) | coordinates() | | [creep_strain](Ans_DataProcessing_operators_result_creep_strain.md) | creep_strain() | @@ -296,6 +298,7 @@ uid: Ans.DataProcessing.operators.result | [pretension](Ans_DataProcessing_operators_result_pretension.md) | Reads the pretension adjustment and tension force. Rotation is not allowed for these results. ///available inputs: time_scoping (ScopingsContainer, Scoping) (optional), mesh_scoping (ScopingsContainer, Scoping) (optional), fields_container (FieldsContainer) (optional), streams_container (StreamsContainer, Stream), data_sources (DataSources), mesh (MeshedRegion, MeshesContainer) (optional), read_cyclic (Int32) (optional), expanded_meshed_region (MeshedRegion, MeshesContainer) (optional), sectors_to_expand (IList int, Scoping, ScopingsContainer, System.Collections.IEnumerable) (optional), phi (double) (optional) | | [prns_to_field](Ans_DataProcessing_operators_result_prns_to_field.md) | Read the presol of nodal field generated file from mapdl. ///available inputs: filepath (string), columns_to_read (Int32, IList int, System.Collections.IEnumerable) (optional) | | [radiation_area](Ans_DataProcessing_operators_result_radiation_area.md) | radiation_area() | +| [radiation_heat_flow_rate](Ans_DataProcessing_operators_result_radiation_heat_flow_rate.md) | radiation_heat_flow_rate() | | [raw_acceleration](Ans_DataProcessing_operators_result_raw_acceleration.md) | raw_acceleration() | | [raw_displacement](Ans_DataProcessing_operators_result_raw_displacement.md) | raw_displacement() | | [raw_reaction_force](Ans_DataProcessing_operators_result_raw_reaction_force.md) | raw_reaction_force() | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md new file mode 100644 index 0000000000..4ad422bb88 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md @@ -0,0 +1,82 @@ +--- +uid: Ans.DataProcessing.operators.result.radiation_heat_flow_rate +--- + +# *class* radiation_heat_flow_rate(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) + +radiation_heat_flow_rate() + +radiation_heat_flow_rate(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) + +radiation_heat_flow_rate(config: OperatorConfig) + + + +**DPF Framework Reference:** [radiation_heat_flow_rate operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/radiation_heat_flow_rate.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +Fields container already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/index.md index 907580d6a0..0b384d1525 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/index.md @@ -19,7 +19,6 @@ uid: index - [Ans.DataProcessing.operators.math](Ans.DataProcessing/operators/math/index.md) - [Ans.DataProcessing.operators.math.hdf5](Ans.DataProcessing/operators/math/hdf5/index.md) - [Ans.DataProcessing.operators.math.hdf5.topo](Ans.DataProcessing/operators/math/hdf5/topo/index.md) -- [Ans.DataProcessing.operators.math.mechanical](Ans.DataProcessing/operators/math/mechanical/index.md) - [Ans.DataProcessing.operators.mesh](Ans.DataProcessing/operators/mesh/index.md) - [Ans.DataProcessing.operators.metadata](Ans.DataProcessing/operators/metadata/index.md) - [Ans.DataProcessing.operators.min_max](Ans.DataProcessing/operators/min_max/index.md) diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml index 6808c9e4de..39d0a92e7b 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml @@ -527,6 +527,8 @@ href: Ans.DataProcessing/operators/math/matrix_product.md - name: matrix_product_fc href: Ans.DataProcessing/operators/math/matrix_product_fc.md + - name: mechanical_min_max_over_time + href: Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md - name: minus href: Ans.DataProcessing/operators/math/minus.md - name: minus_fc @@ -632,11 +634,6 @@ href: Ans.DataProcessing/operators/math/hdf5/topo/elemental_density.md - name: nodal_density href: Ans.DataProcessing/operators/math/hdf5/topo/nodal_density.md - - name: math.mechanical - href: Ans.DataProcessing/operators/math/mechanical/index.md - items: - - name: min_max_over_time - href: Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md - name: mesh href: Ans.DataProcessing/operators/mesh/index.md items: @@ -894,6 +891,8 @@ href: Ans.DataProcessing/operators/result/compute_total_strain_YZ.md - name: compute_total_strain_Z href: Ans.DataProcessing/operators/result/compute_total_strain_Z.md + - name: contact_element_heat_flow + href: Ans.DataProcessing/operators/result/contact_element_heat_flow.md - name: contact_fluid_penetration_pressure href: Ans.DataProcessing/operators/result/contact_fluid_penetration_pressure.md - name: contact_friction_stress @@ -912,6 +911,8 @@ href: Ans.DataProcessing/operators/result/contact_surface_heat_flux.md - name: contact_total_stress href: Ans.DataProcessing/operators/result/contact_total_stress.md + - name: convection_heat_flow_rate + href: Ans.DataProcessing/operators/result/convection_heat_flow_rate.md - name: coordinate_system href: Ans.DataProcessing/operators/result/coordinate_system.md - name: coordinates @@ -1368,6 +1369,8 @@ href: Ans.DataProcessing/operators/result/prns_to_field.md - name: radiation_area href: Ans.DataProcessing/operators/result/radiation_area.md + - name: radiation_heat_flow_rate + href: Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md - name: raw_acceleration href: Ans.DataProcessing/operators/result/raw_acceleration.md - name: raw_displacement diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml index 73417d3095..fa7da66351 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml @@ -553,6 +553,8 @@ href: api/Ans.DataProcessing/operators/math/matrix_product.md - name: matrix_product_fc href: api/Ans.DataProcessing/operators/math/matrix_product_fc.md + - name: mechanical_min_max_over_time + href: api/Ans.DataProcessing/operators/math/mechanical_min_max_over_time.md - name: minus href: api/Ans.DataProcessing/operators/math/minus.md - name: minus_fc @@ -658,11 +660,6 @@ href: api/Ans.DataProcessing/operators/math/hdf5/topo/elemental_density.md - name: nodal_density href: api/Ans.DataProcessing/operators/math/hdf5/topo/nodal_density.md - - name: math.mechanical - href: api/Ans.DataProcessing/operators/math/mechanical/index.md - items: - - name: min_max_over_time - href: api/Ans.DataProcessing/operators/math/mechanical/min_max_over_time.md - name: mesh href: api/Ans.DataProcessing/operators/mesh/index.md items: @@ -920,6 +917,8 @@ href: api/Ans.DataProcessing/operators/result/compute_total_strain_YZ.md - name: compute_total_strain_Z href: api/Ans.DataProcessing/operators/result/compute_total_strain_Z.md + - name: contact_element_heat_flow + href: api/Ans.DataProcessing/operators/result/contact_element_heat_flow.md - name: contact_fluid_penetration_pressure href: api/Ans.DataProcessing/operators/result/contact_fluid_penetration_pressure.md - name: contact_friction_stress @@ -938,6 +937,8 @@ href: api/Ans.DataProcessing/operators/result/contact_surface_heat_flux.md - name: contact_total_stress href: api/Ans.DataProcessing/operators/result/contact_total_stress.md + - name: convection_heat_flow_rate + href: api/Ans.DataProcessing/operators/result/convection_heat_flow_rate.md - name: coordinate_system href: api/Ans.DataProcessing/operators/result/coordinate_system.md - name: coordinates @@ -1394,6 +1395,8 @@ href: api/Ans.DataProcessing/operators/result/prns_to_field.md - name: radiation_area href: api/Ans.DataProcessing/operators/result/radiation_area.md + - name: radiation_heat_flow_rate + href: api/Ans.DataProcessing/operators/result/radiation_heat_flow_rate.md - name: raw_acceleration href: api/Ans.DataProcessing/operators/result/raw_acceleration.md - name: raw_displacement From 5df299e43e54fb1bee51d71edbb0b7b8c0a2565f Mon Sep 17 00:00:00 2001 From: DPF User Date: Mon, 3 Aug 2026 20:13:01 -0400 Subject: [PATCH 5/7] DPF dpf-mechanical doc update for 271 (2026.08.03) --- .../operators/result/creep_strain.md | 33 ++++- .../operators/result/index.md | 12 ++ .../operators/result/total_strain.md | 64 +++++++- .../operators/result/total_strain_X.md | 107 +++++++++++++ .../operators/result/total_strain_XY.md | 107 +++++++++++++ .../operators/result/total_strain_XZ.md | 107 +++++++++++++ .../operators/result/total_strain_Y.md | 107 +++++++++++++ .../operators/result/total_strain_YZ.md | 107 +++++++++++++ .../operators/result/total_strain_Z.md | 107 +++++++++++++ .../operators/result/total_strain_eqv.md | 140 ++++++++++++++++++ .../result/total_strain_intensity.md | 104 +++++++++++++ .../result/total_strain_max_shear.md | 104 +++++++++++++ .../result/total_strain_principal_1.md | 105 +++++++++++++ .../result/total_strain_principal_2.md | 105 +++++++++++++ .../result/total_strain_principal_3.md | 105 +++++++++++++ .../versions/2027.R1.SP00/api/toc.yml | 24 +++ .../versions/2027.R1.SP00/toc.yml | 24 +++ 17 files changed, 1456 insertions(+), 6 deletions(-) create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_X.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XY.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XZ.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Y.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_YZ.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Z.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_eqv.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_intensity.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_max_shear.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_1.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_2.md create mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_3.md diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/creep_strain.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/creep_strain.md index 1a7714f656..f735e2a2e3 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/creep_strain.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/creep_strain.md @@ -2,11 +2,11 @@ uid: Ans.DataProcessing.operators.result.creep_strain --- -# *class* creep_strain(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) +# *class* creep_strain(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, expanded_meshed_region: object = None, sectors_to_expand: object = None, phi: object = None, config: OperatorConfig = None) creep_strain() -creep_strain(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) +creep_strain(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, expanded_meshed_region: object, sectors_to_expand: object, phi: object, config: OperatorConfig) creep_strain(config: OperatorConfig) @@ -20,6 +20,9 @@ creep_strain(config: OperatorConfig) * **mesh_scoping** * **data_sources** * **requested_location** +* **expanded_meshed_region** +* **sectors_to_expand** +* **phi** * **config** ## Inputs @@ -62,7 +65,7 @@ Rotate the result to the global coordinate system if rotations are available (de ### mesh -prevents from reading the mesh in the result files +mesh. If cylic expansion is to be done, mesh of the base sector **Type:** *LinkableInput* @@ -72,6 +75,30 @@ requested location Nodal, Elemental or ElementalNodal **Type:** *LinkableInput* +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### expanded_meshed_region + +mesh expanded, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### sectors_to_expand + +sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### phi + +angle phi in degrees (default value 0.0), use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + ### read_beams elemental nodal beam results are read if this pin is set to true (default is false) diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md index 66b6d3fe2c..73b231aa85 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md @@ -384,6 +384,18 @@ uid: Ans.DataProcessing.operators.result | [total_mass](Ans_DataProcessing_operators_result_total_mass.md) | Reads total mass from mode file. ///available inputs: data_sources (DataSources) | | [total_pressure](Ans_DataProcessing_operators_result_total_pressure.md) | total_pressure() | | [total_strain](Ans_DataProcessing_operators_result_total_strain.md) | total_strain() | +| [total_strain_X](Ans_DataProcessing_operators_result_total_strain_X.md) | total_strain_X() | +| [total_strain_XY](Ans_DataProcessing_operators_result_total_strain_XY.md) | total_strain_XY() | +| [total_strain_XZ](Ans_DataProcessing_operators_result_total_strain_XZ.md) | total_strain_XZ() | +| [total_strain_Y](Ans_DataProcessing_operators_result_total_strain_Y.md) | total_strain_Y() | +| [total_strain_YZ](Ans_DataProcessing_operators_result_total_strain_YZ.md) | total_strain_YZ() | +| [total_strain_Z](Ans_DataProcessing_operators_result_total_strain_Z.md) | total_strain_Z() | +| [total_strain_eqv](Ans_DataProcessing_operators_result_total_strain_eqv.md) | total_strain_eqv() | +| [total_strain_intensity](Ans_DataProcessing_operators_result_total_strain_intensity.md) | total_strain_intensity() | +| [total_strain_max_shear](Ans_DataProcessing_operators_result_total_strain_max_shear.md) | total_strain_max_shear() | +| [total_strain_principal_1](Ans_DataProcessing_operators_result_total_strain_principal_1.md) | total_strain_principal_1() | +| [total_strain_principal_2](Ans_DataProcessing_operators_result_total_strain_principal_2.md) | total_strain_principal_2() | +| [total_strain_principal_3](Ans_DataProcessing_operators_result_total_strain_principal_3.md) | total_strain_principal_3() | | [total_temperature](Ans_DataProcessing_operators_result_total_temperature.md) | total_temperature() | | [transform_invariant_terms_rbd](Ans_DataProcessing_operators_result_transform_invariant_terms_rbd.md) | transform_invariant_terms_rbd() | | [transient_rayleigh_integration](Ans_DataProcessing_operators_result_transient_rayleigh_integration.md) | Computes the transient Rayleigh integral ///available inputs: fields_container (FieldsContainer), mesh (MeshedRegion, MeshesContainer), time_scoping (Int32, IList int, Scoping, System.Collections.IEnumerable), field (Field), observation_mesh (MeshedRegion), mass_density (double), speed_of_sound (double) | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain.md index 9c175c70a1..e29fc831de 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain.md @@ -2,11 +2,11 @@ uid: Ans.DataProcessing.operators.result.total_strain --- -# *class* total_strain(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) +# *class* total_strain(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, expanded_meshed_region: object = None, sectors_to_expand: object = None, phi: object = None, config: OperatorConfig = None) total_strain() -total_strain(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) +total_strain(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, expanded_meshed_region: object, sectors_to_expand: object, phi: object, config: OperatorConfig) total_strain(config: OperatorConfig) @@ -19,6 +19,10 @@ total_strain(config: OperatorConfig) * **time_scoping** * **mesh_scoping** * **data_sources** +* **requested_location** +* **expanded_meshed_region** +* **sectors_to_expand** +* **phi** * **config** ## Inputs @@ -61,7 +65,61 @@ Rotate the result to the global coordinate system if rotations are available (de ### mesh -prevents from reading the mesh in the result files +mesh. If cylic expansion is to be done, mesh of the base sector + +**Type:** *LinkableInput* + +### requested_location + +requested location Nodal, Elemental or ElementalNodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### expanded_meshed_region + +mesh expanded, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### sectors_to_expand + +sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### phi + +angle phi in degrees (default value 0.0), use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +### split_shells + +If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required. + +**Type:** *LinkableInput* + +### shell_layer + +If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. + +**Type:** *LinkableInput* + +### extend_to_mid_nodes + +Compute mid nodes (when available) by averaging the neighbour corner nodes. Default: True **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_X.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_X.md new file mode 100644 index 0000000000..4132fda50f --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_X.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_X +--- + +# *class* total_strain_X(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_X() + +total_strain_X(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_X(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_X operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_X.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XY.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XY.md new file mode 100644 index 0000000000..278c0e65aa --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XY.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_XY +--- + +# *class* total_strain_XY(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_XY() + +total_strain_XY(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_XY(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_XY operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_XY.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XZ.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XZ.md new file mode 100644 index 0000000000..0d0b88f035 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_XZ.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_XZ +--- + +# *class* total_strain_XZ(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_XZ() + +total_strain_XZ(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_XZ(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_XZ operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_XZ.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Y.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Y.md new file mode 100644 index 0000000000..8032573a23 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Y.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_Y +--- + +# *class* total_strain_Y(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_Y() + +total_strain_Y(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_Y(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_Y operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_Y.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_YZ.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_YZ.md new file mode 100644 index 0000000000..3d63dbff1b --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_YZ.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_YZ +--- + +# *class* total_strain_YZ(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_YZ() + +total_strain_YZ(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_YZ(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_YZ operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_YZ.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Z.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Z.md new file mode 100644 index 0000000000..c9271ec5bd --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_Z.md @@ -0,0 +1,107 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_Z +--- + +# *class* total_strain_Z(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_Z() + +total_strain_Z(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_Z(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_Z operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_Z.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +if true the field is rotated to global coordinate system (default true) + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +requested location, default is Nodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_eqv.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_eqv.md new file mode 100644 index 0000000000..fb3bb3ef55 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_eqv.md @@ -0,0 +1,140 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_eqv +--- + +# *class* total_strain_eqv(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, expanded_meshed_region: object = None, sectors_to_expand: object = None, phi: object = None, config: OperatorConfig = None) + +total_strain_eqv() + +total_strain_eqv(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, expanded_meshed_region: object, sectors_to_expand: object, phi: object, config: OperatorConfig) + +total_strain_eqv(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_eqv operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_eqv.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **expanded_meshed_region** +* **sectors_to_expand** +* **phi** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +Fields container already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### mesh + +mesh. If cylic expansion is to be done, mesh of the base sector + +**Type:** *LinkableInput* + +### requested_location + +requested location Nodal, Elemental or ElementalNodal + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### expanded_meshed_region + +mesh expanded, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### sectors_to_expand + +sectors to expand (start at 0), for multistage: use scopings container with 'stage' label, use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### phi + +angle phi in degrees (default value 0.0), use if cyclic expansion is to be done. + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +### split_shells + +If true, this pin forces the results to be split by element shape, indicated by the presence of the 'elshape' label in the output. If false, the results for all elements shapes are combined. Default value is false if averaging is not required and true if averaging is required. + +**Type:** *LinkableInput* + +### shell_layer + +If connected, this pin allows you to extract the result only on the selected shell layer(s). The available values are: 0: Top, 1: Bottom, 2: TopBottom, 3: Mid, 4: TopBottomMid. + +**Type:** *LinkableInput* + +### extend_to_mid_nodes + +Compute mid nodes (when available) by averaging the neighbour corner nodes. Default: True + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_intensity.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_intensity.md new file mode 100644 index 0000000000..481fde887a --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_intensity.md @@ -0,0 +1,104 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_intensity +--- + +# *class* total_strain_intensity(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) + +total_strain_intensity() + +total_strain_intensity(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) + +total_strain_intensity(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_intensity operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_intensity.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +This pin is removed for versions >25.2. An error is raised if connected. + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_max_shear.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_max_shear.md new file mode 100644 index 0000000000..4f2805c145 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_max_shear.md @@ -0,0 +1,104 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_max_shear +--- + +# *class* total_strain_max_shear(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) + +total_strain_max_shear() + +total_strain_max_shear(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) + +total_strain_max_shear(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_max_shear operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_max_shear.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +This pin is removed for versions >25.2. An error is raised if connected. + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_1.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_1.md new file mode 100644 index 0000000000..fd84f88a4c --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_1.md @@ -0,0 +1,105 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_principal_1 +--- + +# *class* total_strain_principal_1(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_principal_1() + +total_strain_principal_1(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_principal_1(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_principal_1 operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_principal_1.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +This pin is removed for versions >25.2. An error is raised if connected. + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_2.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_2.md new file mode 100644 index 0000000000..541edf6b1b --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_2.md @@ -0,0 +1,105 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_principal_2 +--- + +# *class* total_strain_principal_2(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_principal_2() + +total_strain_principal_2(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_principal_2(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_principal_2 operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_principal_2.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +This pin is removed for versions >25.2. An error is raised if connected. + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_3.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_3.md new file mode 100644 index 0000000000..0d6e2defb8 --- /dev/null +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/total_strain_principal_3.md @@ -0,0 +1,105 @@ +--- +uid: Ans.DataProcessing.operators.result.total_strain_principal_3 +--- + +# *class* total_strain_principal_3(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, requested_location: object = None, config: OperatorConfig = None) + +total_strain_principal_3() + +total_strain_principal_3(time_scoping: object, mesh_scoping: object, data_sources: object, requested_location: object, config: OperatorConfig) + +total_strain_principal_3(config: OperatorConfig) + + + +**DPF Framework Reference:** [total_strain_principal_3 operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/total_strain_principal_3.md) + +**Parameters:** + +* **time_scoping** +* **mesh_scoping** +* **data_sources** +* **requested_location** +* **config** + +## Inputs + +### time_scoping + +time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. + +**Type:** *LinkableInput* + +### mesh_scoping + +nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains + +**Type:** *LinkableInput* + +### fields_container + +FieldsContainer already allocated modified inplace + +**Type:** *LinkableInput* + +### streams_container + +result file container allowed to be kept open to cache data + +**Type:** *LinkableInput* + +### data_sources + +result file path container, used if no streams are set + +**Type:** *LinkableInput* + +### bool_rotate_to_global + +This pin is removed for versions >25.2. An error is raised if connected. + +**Type:** *LinkableInput* + +### mesh + +prevents from reading the mesh in the result files + +**Type:** *LinkableInput* + +### requested_location + +**Type:** *LinkableInput* + +### read_cyclic + +if 0 cyclic symmetry is ignored, if 1 cyclic sector is read, if 2 cyclic expansion is done, if 3 cyclic expansion is done and stages are merged (default is 1) + +**Type:** *LinkableInput* + +### read_beams + +elemental nodal beam results are read if this pin is set to true (default is false) + +**Type:** *LinkableInput* + +## Outputs + +### fields_container + +**Type:** *LinkableOutput* + +## Methods + +## Properties + +#### *property* inputs: InputSpec + +*get/set* + +#### *property* outputs: OutputSpec + +*get/set* + +#### *property* defaultConfig: Config + +*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml index 39d0a92e7b..30ed1aa68c 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml @@ -1541,6 +1541,30 @@ href: Ans.DataProcessing/operators/result/total_pressure.md - name: total_strain href: Ans.DataProcessing/operators/result/total_strain.md + - name: total_strain_X + href: Ans.DataProcessing/operators/result/total_strain_X.md + - name: total_strain_XY + href: Ans.DataProcessing/operators/result/total_strain_XY.md + - name: total_strain_XZ + href: Ans.DataProcessing/operators/result/total_strain_XZ.md + - name: total_strain_Y + href: Ans.DataProcessing/operators/result/total_strain_Y.md + - name: total_strain_YZ + href: Ans.DataProcessing/operators/result/total_strain_YZ.md + - name: total_strain_Z + href: Ans.DataProcessing/operators/result/total_strain_Z.md + - name: total_strain_eqv + href: Ans.DataProcessing/operators/result/total_strain_eqv.md + - name: total_strain_intensity + href: Ans.DataProcessing/operators/result/total_strain_intensity.md + - name: total_strain_max_shear + href: Ans.DataProcessing/operators/result/total_strain_max_shear.md + - name: total_strain_principal_1 + href: Ans.DataProcessing/operators/result/total_strain_principal_1.md + - name: total_strain_principal_2 + href: Ans.DataProcessing/operators/result/total_strain_principal_2.md + - name: total_strain_principal_3 + href: Ans.DataProcessing/operators/result/total_strain_principal_3.md - name: total_temperature href: Ans.DataProcessing/operators/result/total_temperature.md - name: transform_invariant_terms_rbd diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml index fa7da66351..d801bb7318 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml @@ -1567,6 +1567,30 @@ href: api/Ans.DataProcessing/operators/result/total_pressure.md - name: total_strain href: api/Ans.DataProcessing/operators/result/total_strain.md + - name: total_strain_X + href: api/Ans.DataProcessing/operators/result/total_strain_X.md + - name: total_strain_XY + href: api/Ans.DataProcessing/operators/result/total_strain_XY.md + - name: total_strain_XZ + href: api/Ans.DataProcessing/operators/result/total_strain_XZ.md + - name: total_strain_Y + href: api/Ans.DataProcessing/operators/result/total_strain_Y.md + - name: total_strain_YZ + href: api/Ans.DataProcessing/operators/result/total_strain_YZ.md + - name: total_strain_Z + href: api/Ans.DataProcessing/operators/result/total_strain_Z.md + - name: total_strain_eqv + href: api/Ans.DataProcessing/operators/result/total_strain_eqv.md + - name: total_strain_intensity + href: api/Ans.DataProcessing/operators/result/total_strain_intensity.md + - name: total_strain_max_shear + href: api/Ans.DataProcessing/operators/result/total_strain_max_shear.md + - name: total_strain_principal_1 + href: api/Ans.DataProcessing/operators/result/total_strain_principal_1.md + - name: total_strain_principal_2 + href: api/Ans.DataProcessing/operators/result/total_strain_principal_2.md + - name: total_strain_principal_3 + href: api/Ans.DataProcessing/operators/result/total_strain_principal_3.md - name: total_temperature href: api/Ans.DataProcessing/operators/result/total_temperature.md - name: transform_invariant_terms_rbd From fadc6118c86a8a5ca8867fc1f79bd16673bc6ee6 Mon Sep 17 00:00:00 2001 From: DPF User Date: Wed, 5 Aug 2026 20:21:42 -0400 Subject: [PATCH 6/7] DPF dpf-mechanical doc update for 271 (2026.08.05) --- .../operators/serialization/hdf5dpf_generate_result_file.md | 4 ++-- .../api/Ans.DataProcessing/operators/serialization/index.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/hdf5dpf_generate_result_file.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/hdf5dpf_generate_result_file.md index 8c65bbdb99..e0370f90f5 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/hdf5dpf_generate_result_file.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/hdf5dpf_generate_result_file.md @@ -6,7 +6,7 @@ uid: Ans.DataProcessing.operators.serialization.hdf5dpf_generate_result_file Generate a dpf result file from provided information. -available inputs: `h5_chunk_size` (Int32) (optional), `append_mode` (bool) (optional), `dataset_size_compression_threshold` (Int32) (optional), `h5_native_compression` (Int32, DataTree) (optional), `export_floats` (bool) (optional), `filename` (string), `mesh_provider_out` (MeshedRegion) (optional), `time_freq_support_out` (TimeFreqSupport) (optional), `ansys_unit_system_id` (Int32, ResultInfo) (optional), `input_name1` (string, Any) (optional), `input_name2` (string, Any) (optional) +available inputs: `h5_chunk_size` (Int32) (optional), `append_mode` (bool, Int32) (optional), `dataset_size_compression_threshold` (Int32) (optional), `h5_native_compression` (Int32, DataTree) (optional), `export_floats` (bool) (optional), `filename` (string), `mesh_provider_out` (MeshedRegion) (optional), `time_freq_support_out` (TimeFreqSupport) (optional), `ansys_unit_system_id` (Int32, ResultInfo) (optional), `input_name1` (string, Any) (optional), `input_name2` (string, Any) (optional) available outputs: `data_sources` (DataSources) @@ -44,7 +44,7 @@ Size of each HDF5 chunk in kilobytes (KB). Default: 1 MB when compression is ena ### append_mode -Experimental: Allow appending chunked data to the file. This disables fields container content deduplication. +Experimental: Allow appending chunked data to the file. This disables fields container content deduplication.0 (false) is default for not appending, 1 (true) for appending, 2 for appending just the time freq support(used in live mapdl export) **Type:** *LinkableInput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md index 70dece1f79..67a71a9918 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/serialization/index.md @@ -15,7 +15,7 @@ uid: Ans.DataProcessing.operators.serialization | [export_symbolic_workflow](Ans_DataProcessing_operators_serialization_export_symbolic_workflow.md) | Transforms a Workflow into a symbolic Workflow and writes it to a file (if a path is set in input) or string ///available inputs: workflow (Workflow), workflow_path (string) (optional), format (Int32) (optional), options (Int32) (optional) | | [field_to_csv](Ans_DataProcessing_operators_serialization_field_to_csv.md) | Exports a field or a fields container into a csv file. Currently only homogenous Fields Definition of Fields Container are supported. ///available inputs: field_or_fields_container (FieldsContainer, Field), file_path (string), storage_type (Int32) (optional) | | [hdf5dpf_custom_read](Ans_DataProcessing_operators_serialization_hdf5dpf_custom_read.md) | Extract a custom result from an hdf5dpf file. This operator is deprecated, please use the 'custom' operator instead. ///available inputs: time_scoping (Scoping) (optional), mesh_scoping (Scoping) (optional), streams (StreamsContainer) (optional), data_sources (DataSources) (optional), meta_data (DataTree) (optional), result_name (Any) | -| [hdf5dpf_generate_result_file](Ans_DataProcessing_operators_serialization_hdf5dpf_generate_result_file.md) | Generate a dpf result file from provided information. ///available inputs: h5_chunk_size (Int32) (optional), append_mode (bool) (optional), dataset_size_compression_threshold (Int32) (optional), h5_native_compression (Int32, DataTree) (optional), export_floats (bool) (optional), filename (string), mesh_provider_out (MeshedRegion) (optional), time_freq_support_out (TimeFreqSupport) (optional), ansys_unit_system_id (Int32, ResultInfo) (optional), input_name1 (string, Any) (optional), input_name2 (string, Any) (optional) | +| [hdf5dpf_generate_result_file](Ans_DataProcessing_operators_serialization_hdf5dpf_generate_result_file.md) | Generate a dpf result file from provided information. ///available inputs: h5_chunk_size (Int32) (optional), append_mode (bool, Int32) (optional), dataset_size_compression_threshold (Int32) (optional), h5_native_compression (Int32, DataTree) (optional), export_floats (bool) (optional), filename (string), mesh_provider_out (MeshedRegion) (optional), time_freq_support_out (TimeFreqSupport) (optional), ansys_unit_system_id (Int32, ResultInfo) (optional), input_name1 (string, Any) (optional), input_name2 (string, Any) (optional) | | [import_symbolic_workflow](Ans_DataProcessing_operators_serialization_import_symbolic_workflow.md) | Reads a file or string holding a Symbolic Workflow and instantiates a WorkFlow with its data. Pin 'workflow_path' refers to a file path, either as a string or as DataSources. Pin 'workflow_as_string' refers to the string representation of the workflow itself. Both pins are mutually exclusive. ///available inputs: workflow_path (string, DataSources) (optional), workflow_as_string (string) (optional), format (Int32) (optional) | | [json_to_data_tree](Ans_DataProcessing_operators_serialization_json_to_data_tree.md) | Reads a json file or string to a DataTree ///available inputs: string_or_path (string, DataSources) | | [mechanical_csv_to_field](Ans_DataProcessing_operators_serialization_mechanical_csv_to_field.md) | Reads mechanical exported csv file ///available inputs: unit (), mesh (MeshedRegion) (optional), data_sources (DataSources), requested_location (string, FieldDefinition) | From 01581667577391a1a1663266781808f5309cf8f4 Mon Sep 17 00:00:00 2001 From: DPF User Date: Thu, 6 Aug 2026 20:14:31 -0400 Subject: [PATCH 7/7] DPF dpf-mechanical doc update for 271 (2026.08.06) --- .../operators/result/elemental_mass.md | 82 ------------------- .../operators/result/index.md | 3 +- .../result/material_property_of_element.md | 38 +++------ .../scoping/scoping_get_attribute.md | 4 +- .../versions/2027.R1.SP00/api/toc.yml | 2 - .../versions/2027.R1.SP00/toc.yml | 2 - 6 files changed, 14 insertions(+), 117 deletions(-) delete mode 100644 docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/elemental_mass.md diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/elemental_mass.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/elemental_mass.md deleted file mode 100644 index 1481ea4f49..0000000000 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/elemental_mass.md +++ /dev/null @@ -1,82 +0,0 @@ ---- -uid: Ans.DataProcessing.operators.result.elemental_mass ---- - -# *class* elemental_mass(time_scoping: object = None, mesh_scoping: object = None, data_sources: object = None, config: OperatorConfig = None) - -elemental_mass() - -elemental_mass(time_scoping: object, mesh_scoping: object, data_sources: object, config: OperatorConfig) - -elemental_mass(config: OperatorConfig) - - - -**DPF Framework Reference:** [elemental_mass operator specification](https://developer-a.synopsys.com/docs/dpf-framework-2027-r1/operator-specifications/result/elemental_mass.md) - -**Parameters:** - -* **time_scoping** -* **mesh_scoping** -* **data_sources** -* **config** - -## Inputs - -### time_scoping - -time/freq values (use doubles or field), time/freq set ids (use ints or scoping) or time/freq step ids (use scoping with TimeFreq_steps location) required in output. To specify time/freq values at specific load steps, put a Field (and not a list) in input with a scoping located on "TimeFreq_steps". Linear time freq intrapolation is performed if the values are not in the result files and the data at the max time or freq is taken when time/freqs are higher than available time/freqs in result files. To get all data for all time/freq sets, connect an int with value -1. - -**Type:** *LinkableInput* - -### mesh_scoping - -nodes or elements scoping required in output. The output fields will be scoped on these node or element IDs. To figure out the ordering of the fields data, look at their scoping IDs as they might not be ordered as the input scoping was. The scoping's location indicates whether nodes or elements are asked for. Using scopings container allows you to split the result fields container into domains - -**Type:** *LinkableInput* - -### fields_container - -Fields container already allocated modified inplace - -**Type:** *LinkableInput* - -### streams_container - -result file container allowed to be kept open to cache data - -**Type:** *LinkableInput* - -### data_sources - -result file path container, used if no streams are set - -**Type:** *LinkableInput* - -### mesh - -prevents from reading the mesh in the result files - -**Type:** *LinkableInput* - -## Outputs - -### fields_container - -**Type:** *LinkableOutput* - -## Methods - -## Properties - -#### *property* inputs: InputSpec - -*get/set* - -#### *property* outputs: OutputSpec - -*get/set* - -#### *property* defaultConfig: Config - -*get* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md index 73b231aa85..03eddbda35 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/index.md @@ -130,7 +130,6 @@ uid: Ans.DataProcessing.operators.result | [element_orientations_Y](Ans_DataProcessing_operators_result_element_orientations_Y.md) | element_orientations_Y() | | [element_orientations_Z](Ans_DataProcessing_operators_result_element_orientations_Z.md) | element_orientations_Z() | | [elemental_heat_generation](Ans_DataProcessing_operators_result_elemental_heat_generation.md) | elemental_heat_generation() | -| [elemental_mass](Ans_DataProcessing_operators_result_elemental_mass.md) | elemental_mass() | | [elemental_volume](Ans_DataProcessing_operators_result_elemental_volume.md) | elemental_volume() | | [emissivity](Ans_DataProcessing_operators_result_emissivity.md) | emissivity() | | [emitted_radiation_heat_flux](Ans_DataProcessing_operators_result_emitted_radiation_heat_flux.md) | emitted_radiation_heat_flux() | @@ -228,7 +227,7 @@ uid: Ans.DataProcessing.operators.result | [mapdl_split_to_acmo_facet_indices](Ans_DataProcessing_operators_result_mapdl_split_to_acmo_facet_indices.md) | This will retain the already existing labels from the input FC and will change the facet label to now mean ACMO facet indices.Each Field in the input will be split/merged into several Fields, redistributing the data to the appropriate entity. ///available inputs: fields_container (FieldsContainer), property_fields_container_element_types (PropertyFieldsContainer) | | [mass_flow_rate](Ans_DataProcessing_operators_result_mass_flow_rate.md) | mass_flow_rate() | | [mass_fraction](Ans_DataProcessing_operators_result_mass_fraction.md) | mass_fraction() | -| [material_property_of_element](Ans_DataProcessing_operators_result_material_property_of_element.md) | Reads a named scalar material property (pin 6) for each element from result files. | +| [material_property_of_element](Ans_DataProcessing_operators_result_material_property_of_element.md) | Reads a material property for each element from result files. | | [mean_static_pressure](Ans_DataProcessing_operators_result_mean_static_pressure.md) | mean_static_pressure() | | [mean_temperature](Ans_DataProcessing_operators_result_mean_temperature.md) | mean_temperature() | | [mean_velocity](Ans_DataProcessing_operators_result_mean_velocity.md) | mean_velocity() | diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/material_property_of_element.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/material_property_of_element.md index 32f3d0704c..c4ffa4f9bb 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/material_property_of_element.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/result/material_property_of_element.md @@ -2,19 +2,17 @@ uid: Ans.DataProcessing.operators.result.material_property_of_element --- -# *class* material_property_of_element(mesh_scoping: object = None, streams_container: object = None, data_sources: object = None, property_name: object = None, default_value: object = None, filter_zero_values: object = None, config: OperatorConfig = None) +# *class* material_property_of_element(mesh_scoping: object = None, streams: object = None, data_sources: object = None, property_name: object = None, config: OperatorConfig = None) -Reads a named scalar material property (pin 6) for each element from result files. +Reads a material property for each element from result files. -The property value is taken from the linear (constant) material data assigned to each element's material. +The operator first retrieves each element's material ID from the mesh property "mat", -The output is a scalar field at elemental location. - -If a default value is provided via pin 7, all elements receive that value unless the property exists for their material, in which case the material value takes precedence. +then maps the requested property name to the corresponding material value. -If no default value is provided and filter_zero_values (pin 8) is true, elements whose property value is exactly zero are excluded from the output. +The output is a scalar field at elemental location. -available inputs: `mesh_scoping` (Scoping) (optional), `streams_container` (StreamsContainer) (optional), `data_sources` (DataSources), `property_name` (string), `default_value` (double) (optional), `filter_zero_values` (bool) (optional) +available inputs: `mesh_scoping` (Scoping) (optional), `streams` (StreamsContainer) (optional), `data_sources` (DataSources) (optional), `property_name` (string) available outputs: `material_properties` (Field) @@ -23,11 +21,9 @@ available outputs: `material_properties` (Field) **Parameters:** * **mesh_scoping** -* **streams_container** +* **streams** * **data_sources** * **property_name** -* **default_value** -* **filter_zero_values** * **config** **Example:** @@ -35,7 +31,7 @@ available outputs: `material_properties` (Field) ```python op = material_property_of_element() -op = material_property_of_element(mesh_scoping=my_mesh_scoping,streams_container=my_streams_container,data_sources=my_data_sources,property_name=my_property_name,default_value=my_default_value,filter_zero_values=my_filter_zero_values) +op = material_property_of_element(mesh_scoping=my_mesh_scoping,streams=my_streams,data_sources=my_data_sources,property_name=my_property_name) ``` ## Inputs @@ -46,15 +42,15 @@ Element scoping that restricts which elements are processed. If not provided, al **Type:** *LinkableInput* -### streams_container +### streams -Streams containing the result file. If provided, data_sources is ignored. +result file container allowed to be kept open to cache data **Type:** *LinkableInput* ### data_sources -Data sources used to open the result file when streams_container is not provided. +result file path container, used if no streams are set **Type:** *LinkableInput* @@ -64,18 +60,6 @@ Name of the linear scalar material property to extract, for example "EX" for You **Type:** *LinkableInput* -### default_value - -Scalar value assigned to elements whose material does not define the requested property. If not set, those elements are excluded from the output. - -**Type:** *LinkableInput* - -### filter_zero_values - -When true and no default_value is set, elements whose property value is exactly zero are excluded from the output. Defaults to false. - -**Type:** *LinkableInput* - ## Outputs ### material_properties diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/scoping_get_attribute.md b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/scoping_get_attribute.md index b641b56f32..93921d5cc0 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/scoping_get_attribute.md +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/Ans.DataProcessing/operators/scoping/scoping_get_attribute.md @@ -34,7 +34,7 @@ op = scoping_get_attribute(scoping=my_scoping,property_name=my_property_name) ### property_name -Supported property names are: "ids", "location". +Supported property names are: "ids", "maximum_id", and "location". **Type:** *LinkableInput* @@ -42,7 +42,7 @@ Supported property names are: "ids", "location". ### property -Returns a vector of int for property: "ids" and a string for property: "location". +Returns a vector of int for property: "ids" an int for "maximum_id" and a string for property: "location". **Type:** *LinkableOutput* diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml index 30ed1aa68c..5176a91662 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/api/toc.yml @@ -1033,8 +1033,6 @@ href: Ans.DataProcessing/operators/result/element_orientations_Z.md - name: elemental_heat_generation href: Ans.DataProcessing/operators/result/elemental_heat_generation.md - - name: elemental_mass - href: Ans.DataProcessing/operators/result/elemental_mass.md - name: elemental_volume href: Ans.DataProcessing/operators/result/elemental_volume.md - name: emissivity diff --git a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml index d801bb7318..55261a2974 100644 --- a/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml +++ b/docs/dpf/dpf-mechanical/versions/2027.R1.SP00/toc.yml @@ -1059,8 +1059,6 @@ href: api/Ans.DataProcessing/operators/result/element_orientations_Z.md - name: elemental_heat_generation href: api/Ans.DataProcessing/operators/result/elemental_heat_generation.md - - name: elemental_mass - href: api/Ans.DataProcessing/operators/result/elemental_mass.md - name: elemental_volume href: api/Ans.DataProcessing/operators/result/elemental_volume.md - name: emissivity