def _spec():
     description = (
         """Return the input mesh or meshes container into a meshes container."""
     )
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="meshes",
                 type_names=["meshes_container", "abstract_meshed_region"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="default_label",
                 type_names=["string"],
                 optional=True,
                 document="""This default label is used if a new meshes
     container needs to be created
     (default is unknown)""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="meshes_container",
                 type_names=["meshes_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
 def _spec():
     description = """Read boundary conditions from the results files contained in the
         streams or data sources."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             3:
             PinSpecification(
                 name="streams_container",
                 type_names=["streams_container"],
                 optional=True,
                 document="""""",
             ),
             4:
             PinSpecification(
                 name="data_sources",
                 type_names=["data_sources"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="results_info",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Results info""",
             ),
         },
     )
     return spec
Esempio n. 3
0
 def _spec():
     description = """Evaluates minimum, maximum by time or frequency over all the entities
         of each field"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="min",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="max",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 4
0
 def _spec():
     description = """Read the time freq support from the results files contained in the
         streams or data sources."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             3: PinSpecification(
                 name="streams_container",
                 type_names=["streams_container"],
                 optional=True,
                 document="""Streams (result file container) (optional)""",
             ),
             4: PinSpecification(
                 name="data_sources",
                 type_names=["data_sources"],
                 optional=False,
                 document="""If the stream is null then we need to get the
     file path from the data sources""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="time_freq_support",
                 type_names=["time_freq_support"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 5
0
 def _spec():
     description = """The high pass filter returns all the values strictly superior to the
         threshold value in input."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1: PinSpecification(
                 name="threshold",
                 type_names=["double", "field"],
                 optional=False,
                 document="""A threshold scalar or a field containing one
     value is expected""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 6
0
 def _spec():
     description = """Computes element-wise dot product between two tensor fields."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fieldA",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1:
             PinSpecification(
                 name="fieldB",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 7
0
 def _spec():
     description = """Computes element-wise ln(field[i])."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
 def _spec():
     description = """Transform ElementalNodal field to NodalElemental, compute result on a
         given node scoping."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1: PinSpecification(
                 name="mesh_scoping",
                 type_names=["scoping"],
                 optional=True,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 9
0
 def _spec():
     description = (
         """Take a set of property fields and assemble them in a unique one"""
     )
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="vector_shared_ptr_property_field__",
                 type_names=["property_field"],
                 optional=False,
                 document="""A vector of property fields to merge or
     property fields from pin 0 to ...""",
             ),
             1:
             PinSpecification(
                 name="vector_shared_ptr_property_field__",
                 type_names=["property_field"],
                 optional=False,
                 document="""A vector of property fields to merge or
     property fields from pin 0 to ...""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="property_field",
                 type_names=["property_field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 10
0
 def _spec():
     description = """Read if the model is cyclic form the result file."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             3: PinSpecification(
                 name="streams_container",
                 type_names=["streams_container"],
                 optional=True,
                 document="""Streams (result file container) (optional)""",
             ),
             4: PinSpecification(
                 name="data_sources",
                 type_names=["data_sources"],
                 optional=False,
                 document="""If the stream is null then we need to get the
     file path from the data sources""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="file_path",
                 type_names=["string"],
                 optional=False,
                 document="""Returns 'single_stage' or 'multi_stage' or an
     empty string for non cyclic model""",
             ),
         },
     )
     return spec
Esempio n. 11
0
 def _spec():
     description = """Extract modes from a time freq support"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="time_freq_support",
                 type_names=["time_freq_support"],
                 optional=False,
                 document="""""",
             ),
             1: PinSpecification(
                 name="set_id",
                 type_names=["int32", "vector<int32>"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 12
0
 def _spec():
     description = """Scales a field (in 0) by a scalar field (in 1). If one field's scoping
         has 'overall' location, then these field's values are
         applied on the entire other field."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="field_or_fields_container_A",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1:
             PinSpecification(
                 name="field_or_fields_container_B",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 13
0
 def _spec():
     description = """Computes element-wise field[i]^p."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="factor",
                 type_names=["double"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 14
0
 def _spec():
     description = (
         """Take a set of meshes containers and assemble them in a unique one"""
     )
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="meshes_containers",
                 type_names=["meshes_container"],
                 optional=False,
                 document="""A vector of meshes containers to merge or
     meshes containers from pin 0 to ...""",
             ),
             1:
             PinSpecification(
                 name="meshes_containers",
                 type_names=["meshes_container"],
                 optional=False,
                 document="""A vector of meshes containers to merge or
     meshes containers from pin 0 to ...""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="merged_meshes_container",
                 type_names=["meshes_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
 def _spec():
     description = """Read the material support."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             3:
             PinSpecification(
                 name="streams_container",
                 type_names=["streams_container"],
                 optional=True,
                 document="""Streams (result file container) (optional)""",
             ),
             4:
             PinSpecification(
                 name="data_sources",
                 type_names=["data_sources"],
                 optional=False,
                 document="""If the stream is null then we need to get the
     file path from the data sources""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="abstract_field_support",
                 type_names=["abstract_field_support"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 16
0
 def _spec():
     description = """Finds the Elemental scoping of a set of coordinates."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="coordinates",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
             7: PinSpecification(
                 name="mesh",
                 type_names=["abstract_meshed_region"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="scoping",
                 type_names=["scoping"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 17
0
 def _spec():
     description = """Compute the component-wise average over all the fields having the same
         id for the label set in input in the fields container.
         This computation can be incremental, if the input fields
         container is connected and the operator is ran several
         time, the output field will be on all the inputs connected"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 18
0
 def _spec():
     description = """Compute the component-wise minimum (out 0) and maximum (out 1) over a
         fields container."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field_min",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="field_max",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 19
0
 def _spec():
     description = """Extract an entity from a field, based on its Id."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fieldA",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="scalar_int",
                 type_names=["int32"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 20
0
 def _spec():
     description = """Maps a field defined on solid elements to a field defined on skin
         elements."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1:
             PinSpecification(
                 name="mesh_scoping",
                 type_names=["abstract_meshed_region"],
                 optional=True,
                 document="""Skin mesh region expected""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 21
0
 def _spec():
     description = """Computes the element-wise eigen vectors for each tensor in the fields
         of the field container"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container", "field"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 22
0
 def _spec():
     description = """Tie a support to a field."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1: PinSpecification(
                 name="support",
                 type_names=["abstract_meshed_region", "abstract_field_support"],
                 optional=False,
                 document="""Meshed region or a support of the field""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 23
0
 def _spec():
     description = """Computes division between two field containers containing complex
         fields."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_containerA",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="fields_containerB",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 24
0
 def _spec():
     description = """Returns the node coordinates of the mesh(es) in input"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             7:
             PinSpecification(
                 name="mesh",
                 type_names=["abstract_meshed_region", "meshes_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="coordinates",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""If the input is a meshed region, a field of
     coordinates is the output, else if
     the input is a  meshes container, a
     fields container (one field by mesh)
     is the output""",
             ),
         },
     )
     return spec
Esempio n. 25
0
 def _spec():
     description = (
         """Computes the element-wise Von-Mises criteria on a tensor field."""
     )
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 26
0
 def _spec():
     description = (
         """Computes the phase (in rad) between a real and an imaginary field."""
     )
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="fieldA",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1: PinSpecification(
                 name="fieldB",
                 type_names=["field", "fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 27
0
 def _spec():
     description = """Sum all the elementary data of a field to get one elementary data at
         the end."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0: PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""Field or fields container with only one field
     is expected""",
             ),
             1: PinSpecification(
                 name="ponderation",
                 type_names=["field"],
                 optional=False,
                 document="""Field""",
             ),
         },
         map_output_pin_spec={
             0: PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 28
0
 def _spec():
     description = """Extract a value from a field and make it overall scoping"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="id",
                 type_names=["int32"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="field",
                 type_names=["field"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 29
0
 def _spec():
     description = """Computes element-wise conjugate of field containers containing complex
         fields."""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec
Esempio n. 30
0
 def _spec():
     description = """Rescope / split a fields container to correspond to a scopings
         container"""
     spec = Specification(
         description=description,
         map_input_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
             1:
             PinSpecification(
                 name="scopings_container",
                 type_names=["scopings_container"],
                 optional=False,
                 document="""""",
             ),
         },
         map_output_pin_spec={
             0:
             PinSpecification(
                 name="fields_container",
                 type_names=["fields_container"],
                 optional=False,
                 document="""""",
             ),
         },
     )
     return spec