コード例 #1
0
ファイル: test_transformation.py プロジェクト: tkn-tub/pogona
def test_rotation():
    t = pg.Transformation(rotation=np.array([0, 0, np.pi / 2]))
    p = np.array([1, 0, 0])
    pp = t.apply_to_point(p)
    np.testing.assert_allclose(pp, [0, 1, 0], **TOLERANCE)

    t = pg.Transformation(rotation=np.array([np.pi, 0, np.pi / 2]))
    p = np.array([1, 0, 0])
    pp = t.apply_to_point(p)
    np.testing.assert_allclose(pp, [0, 1, 0], **TOLERANCE)
コード例 #2
0
 def initialize(
         self,
         simulation_kernel: 'pg.SimulationKernel',
         init_stage: 'pg.InitStages'
 ):
     super().initialize(simulation_kernel, init_stage)
     if init_stage == pg.InitStages.CHECK_ARGUMENTS:
         shift = pg.Transformation(
             translation=np.array([0, 0, -self.inlet_zone])
         )
         self._transformation = (
             self._transformation.apply_to_transformation(shift)
         )
         if (max(self._transformation.scaling) > 1.001
                 or min(self._transformation.scaling) < 0.999):
             LOG.warning(
                 "You are trying to scale a tube mesh by a factor of "
                 f"{self._transformation.scaling}. Keep in mind that "
                 "this mesh already has an inherent scale from the "
                 "OpenFOAM simulation."
             )
         if self.length + self.inlet_zone > 0.15:
             # TODO: determine this dynamically based on available cases
             raise ValueError(
                 "No path to OpenFOAM simulation files is known for a tube "
                 "that is longer than 0.15 m. "
                 f"Selected length: {self.length} m. "
                 f"Keep in mind that the inlet zone of {self.inlet_zone} m "
                 "is not usable."
             )
         self._is_active = not np.isclose(self.flow_rate, 0, atol=1e-20)
     elif init_stage == pg.InitStages.SET_UP_FLOW_SYSTEM:
         self.process_changed_inlet_flow_rate(simulation_kernel, "inlet",
                                              self.flow_rate)
コード例 #3
0
 def get_outlet_area(self, outlet_name: str) -> (
         'pg.Geometry',
         'pg.Transformation'
 ):
     if outlet_name != 'outlet':
         raise ValueError(
             "Outlet not found! "
             "This pipe only has one outlet named 'outlet'."
         )
     geometry = pg.Geometry(pg.Shapes.CYLINDER)
     # TODO(jdrees): calculate the proper transformation for the
     #  outlet based on the tube length and radius
     local_transformation = pg.Transformation(
         translation=np.array((
             0,
             0,
             self.inlet_zone + self.length - self.outlet_zone / 2
         )),
         scaling=np.array((
             self.radius * 2, self.radius * 2, self.outlet_zone
         ))
     )
     return (
         geometry,
         self._transformation.apply_to_transformation(local_transformation)
     )
コード例 #4
0
ファイル: injector.py プロジェクト: tkn-tub/pogona
    def initialize(self, simulation_kernel: 'pg.SimulationKernel',
                   init_stage: 'pg.InitStages'):
        super().initialize(simulation_kernel, init_stage)
        if init_stage == pg.InitStages.CHECK_ARGUMENTS:
            if self.seed == 'random':
                self._rng = np.random.RandomState(seed=None)
            elif self.seed != '':
                self._rng = np.random.RandomState(seed=int(self.seed))
            else:
                self._rng = simulation_kernel.get_random_number_generator()

            self._geometry = pg.Geometry(shape=pg.Shapes[self.shape])
            self._transformation = pg.Transformation(
                translation=np.array(self.translation),
                rotation=np.array(self.rotation),
                scaling=np.array(self.scale))

            if (self.attached_object != '' and self.attached_object
                    not in simulation_kernel.get_components()):
                raise ValueError(
                    "No object component with the name "
                    f"{self.attached_object} attached to the simulation "
                    "kernel could be found.")
        elif init_stage == pg.InitStages.BUILD_SCENE:
            self._attached_object = cast(
                'pg.Object',
                simulation_kernel.get_components()[self.attached_object])
コード例 #5
0
 def __init__(self):
     super().__init__()
     self._turned_on = False
     self._burst_on = False
     self._rng = np.random.RandomState(seed=None)
     self._transformation = pg.Transformation()
     """Transformation of this sensor in the scene."""
コード例 #6
0
ファイル: test_transformation.py プロジェクト: tkn-tub/pogona
def test_inverse():
    t = pg.Transformation(translation=np.array([1, 2, 3]),
                          rotation=np.deg2rad([45, 135, 90]),
                          scaling=np.array([1.5, 2, 2.5]))
    p = np.array([42, 1337, 2])
    np.testing.assert_allclose(p,
                               t.apply_inverse_to_point(t.apply_to_point(p)),
                               **TOLERANCE)
コード例 #7
0
ファイル: test_transformation.py プロジェクト: tkn-tub/pogona
def test_translation_rotation_scale():
    t = pg.Transformation(translation=np.array([1, 2, 3]),
                          rotation=np.deg2rad([45, 135, 90]),
                          scaling=np.array([1.5, 2, 2.5]))
    p = np.array([1, 0, 0])
    pp = t.apply_to_point(p)
    # Reference from Blender:
    np.testing.assert_allclose(pp, [1, 0.93934, 1.93934], **TOLERANCE)
コード例 #8
0
ファイル: test_transformation.py プロジェクト: tkn-tub/pogona
def test_chaining():
    """
    Concatenation of transformations.
    Test values verified/obtained with Blender.
    """
    p = np.array([1, 2, 3])
    t1 = pg.Transformation(translation=np.array([-.02, .35, 1]),
                           rotation=np.deg2rad([30, 22, 278]),
                           scaling=np.array([.1, 1.1, .56]))
    np.testing.assert_allclose(t1.apply_to_point(p),
                               [1.18099, -0.541337, 3.33142], **TOLERANCE)
    t2 = pg.Transformation(translation=np.array([-.2, -.3, -.4]),
                           rotation=np.deg2rad([1, 2, 3]),
                           scaling=np.array([2, .3, .4]))
    # First execute t1, then t2:
    t3 = t2.apply_to_transformation(t1)
    np.testing.assert_allclose(t3.apply_to_point(p),
                               [2.21336, -0.359409, 0.846289], **TOLERANCE)
コード例 #9
0
ファイル: sensor.py プロジェクト: tkn-tub/pogona
    def __init__(self):
        super().__init__()
        self.sensor_id: int = -1
        """Unique integer sensor ID. Set by the sensor manager."""
        self._transformation = pg.Transformation()
        """Transformation of this sensor in the scene."""

        self._geometry = pg.Geometry(pg.Shapes.NONE)
        """Geometry of this sensor, set from shape."""
コード例 #10
0
 def get_outlet_area(
         self, outlet_name: str) -> ('pg.Geometry', 'pg.Transformation'):
     if outlet_name != "outlet":
         raise ValueError("Outlet not found! "
                          "This pump only has one outlet named 'outlet'.")
     # The pump doesn't really define any outlet area,
     # so let's use a nonexistent one.
     geometry = pg.Geometry(pg.Shapes.NONE)
     transformation = pg.Transformation()  # identity transformation
     return geometry, transformation
コード例 #11
0
ファイル: sensor_flow_rate.py プロジェクト: tkn-tub/pogona
    def initialize(self, simulation_kernel: 'pg.SimulationKernel',
                   init_stage: 'pg.InitStages'):
        if init_stage == pg.InitStages.CHECK_ARGUMENTS:
            self._geometry = pg.Geometry(shape=pg.Shapes[self.shape])

            self._transformation = pg.Transformation(
                translation=np.array(self.translation),
                rotation=np.array(self.rotation),
                scaling=np.array(self.scale))

            if self.attached_object not in simulation_kernel.get_components():
                raise ValueError(
                    "No object component with the name "
                    f"{self.attached_object} attached to the simulation "
                    "kernel could be found.")

            if self.seed == 'random':
                self._rng = np.random.RandomState(seed=None)
            elif self.seed != '':
                self._rng = np.random.RandomState(seed=int(self.seed))
            else:
                self._rng = simulation_kernel.get_random_number_generator()

            self.initialize_sample_points()
        elif init_stage == pg.InitStages.CREATE_FOLDERS:
            os.makedirs(os.path.join(simulation_kernel.results_dir,
                                     self.log_folder),
                        exist_ok=True)
        elif init_stage == pg.InitStages.BUILD_SCENE:
            self._attached_object = cast(
                'pg.Object',
                simulation_kernel.get_components()[self.attached_object])
        elif init_stage == pg.InitStages.CREATE_FILES:
            name = (self.id if self.component_name == "Generic component" else
                    self.component_name)
            self._csv_file = open(os.path.join(simulation_kernel.results_dir,
                                               self.log_folder,
                                               f'sensor[{name}].csv'),
                                  mode='w')
            fieldnames = ['sim_time']
            if self.log_mesh_index:
                fieldnames.append('mesh_index')
            # Assumes self.initialize_sample_points() to have been called:
            fieldnames.extend([
                # e.g., "my_prefix_[0.123, 42.0, 1.21]_x":
                f'{col}_{axis}' for col, axis in zip([
                    self.column_prefix + str(point_global)
                    for point_global in self._sample_points_global
                ], ['x', 'y', 'z'])
            ])
            self._csv_writer = csv.writer(self._csv_file,
                                          delimiter=',',
                                          quotechar='"',
                                          quoting=csv.QUOTE_MINIMAL)
            self._csv_writer.writerow(fieldnames)
コード例 #12
0
ファイル: sensor.py プロジェクト: tkn-tub/pogona
    def initialize(self, simulation_kernel: 'pg.SimulationKernel',
                   init_stage: 'pg.InitStages'):
        super().initialize(simulation_kernel, init_stage)
        if init_stage == pg.InitStages.CHECK_ARGUMENTS:
            self._geometry = pg.Geometry(shape=pg.Shapes[self.shape])

            self._transformation = pg.Transformation(
                translation=np.array(self.translation),
                rotation=np.array(self.rotation),
                scaling=np.array(self.scale))
        if init_stage == pg.InitStages.REGISTER_SENSORS:
            simulation_kernel.get_sensor_manager().register_sensor(self)
コード例 #13
0
ファイル: sensor_flow_rate.py プロジェクト: tkn-tub/pogona
    def __init__(self):
        super().__init__()

        self._transformation = pg.Transformation()
        """Transformation of this sensor in the scene."""

        self._geometry = pg.Geometry(pg.Shapes.NONE)
        """Geometry of this sensor, set from shape."""

        self._attached_object: Optional['pg.Object'] = None
        self._csv_file: Optional[io.TextIOWrapper] = None
        self._csv_writer: Optional[csv.writer] = None
        self._rng = np.random.RandomState(seed=None)
        self._sample_points_global: Optional[np.ndarray] = None
コード例 #14
0
 def initialize(
         self,
         simulation_kernel: 'pg.SimulationKernel',
         init_stage: 'pg.InitStages'
 ):
     super().initialize(simulation_kernel, init_stage)
     if init_stage == pg.InitStages.CHECK_ARGUMENTS:
         self._transformation = pg.Transformation(
             translation=np.array(self.translation),
             rotation=np.array(self.rotation),
             scaling=np.array(self.scale)
         )
     if init_stage == pg.InitStages.CREATE_DATA_STRUCTURES:
         self.load_current_vector_field(simulation_kernel)
     if init_stage == pg.InitStages.BUILD_SCENE:
         simulation_kernel.get_scene_manager().add_object(self)
コード例 #15
0
 def get_vector_field_manager():
     if VectorFieldMgrSingleton._vfm is None:
         VectorFieldMgrSingleton._vfm = pg.VectorFieldManager(
             vector_field=pg.VectorFieldParser.parse_folder(
                 folder=os.path.join(os.path.dirname(__file__), '..',
                                     'pogona', 'objects', 'cavity', '0.5'),
                 walls_patch_names={'fixedWalls'}
                 # 'movingWall', 'frontAndBack'},
                 # ^ Since the cavity mesh is only one cell thick,
                 # it's important not to specify the frontAndBack walls
                 # as walls here.
                 # Otherwise, the Shepard interpolation implementations
                 # will try to make the flow 0 close to these walls.
             ),
             transformation=pg.Transformation())
     return VectorFieldMgrSingleton._vfm
コード例 #16
0
    def initialize(self, simulation_kernel: 'pg.SimulationKernel',
                   init_stage: 'pg.InitStages'):
        super().initialize(simulation_kernel, init_stage)
        if init_stage == pg.InitStages.CHECK_ARGUMENTS:
            if self.seed == 'random':
                self._rng = np.random.RandomState(seed=None)
            elif self.seed != '':
                self._rng = np.random.RandomState(seed=int(self.seed))
            else:
                self._rng = simulation_kernel.get_random_number_generator()

            self._transformation = pg.Transformation(
                translation=np.array(self.translation),
                rotation=np.array(self.rotation),
                scaling=np.array([1, 1, 1]))

        elif init_stage == pg.InitStages.BUILD_SCENE:
            pass
コード例 #17
0
ファイル: object_ypiece.py プロジェクト: tkn-tub/pogona
 def get_outlet_area(self, outlet_name: str) -> (
         'pg.Geometry',
         'pg.Transformation'
 ):
     if outlet_name != "outlet":
         raise ValueError(
             f"Outlet \"{outlet_name}\" not found! "
             "This y-piece only has one outlet named 'outlet'."
         )
     geometry = pg.Geometry(pg.Shapes.CYLINDER)
     local_transformation = pg.Transformation(
         translation=np.array([
             0,
             0,
             self.outlet_length - self.outlet_zone / 2
         ]),
         scaling=np.array([
             self.radius * 2, self.radius * 2, self.outlet_zone
         ])
     )
     return (
         geometry,
         self._transformation.apply_to_transformation(local_transformation)
     )
コード例 #18
0
ファイル: test_transformation.py プロジェクト: tkn-tub/pogona
def test_translation():
    t = pg.Transformation(translation=np.array([1, 2, 3]))
    p = np.array([5, 1, 2.5])
    pp = t.apply_to_point(p)
    np.testing.assert_allclose(pp, [6, 3, 5.5], **TOLERANCE)