Source code for openmdao.lib.datatypes.domain.zone

import copy

from openmdao.lib.datatypes.domain.flow import FlowSolution
from openmdao.lib.datatypes.domain.grid import GridCoordinates

CARTESIAN = 'Cartesian'
CYLINDRICAL = 'Cylindrical'
_COORD_SYSTEMS = (CARTESIAN, CYLINDRICAL)


[docs]class Zone(object): """ One zone in a possibly multi-zone :class:`DomainObj`. """ def __init__(self): self.grid_coordinates = GridCoordinates() self.flow_solution = FlowSolution() self.reference_state = None self._coordinate_system = CARTESIAN self.right_handed = True self.symmetry = None self.symmetry_axis = None self.symmetry_instances = 1 @property
[docs] def shape(self): """ Coordinate index limits, not including 'ghost/rind' planes. """ return self.grid_coordinates.shape
@property
[docs] def extent(self): """ Coordinate ranges, not including 'ghost/rind' planes. """ return self.grid_coordinates.extent
def _get_coord_sys(self): return self._coordinate_system def _set_coord_sys(self, sys): if sys in _COORD_SYSTEMS: self._coordinate_system = sys else: raise ValueError('invalid coordinate system %r' % sys) coordinate_system = property(_get_coord_sys, _set_coord_sys, doc='Coordinate system in use.')
[docs] def copy(self): """ Returns a deep copy of self. """ return copy.deepcopy(self)
[docs] def is_equivalent(self, other, logger, tolerance=0.): """ Test if self and `other` are equivalent. other: :class:`Zone` Zone to check against. logger: :class:`Logger` or None Used to log debug messages that will indicate what if anything is not equivalent. tolerance: float The maximum relative difference in array values to be considered equivalent. """ if not isinstance(other, Zone): logger.debug('other is not a Zone object.') return False if self.coordinate_system != other.coordinate_system: logger.debug('coordinate_systems are not equal.') return False if self.right_handed != other.right_handed: logger.debug('handedness is not equal.') return False if self.symmetry != other.symmetry: logger.debug('symmetry is not equal.') return False if self.symmetry_axis != other.symmetry_axis: logger.debug('symmetry_axis is not equal.') return False if self.symmetry_instances != other.symmetry_instances: logger.debug('symmetry_instances is not equal.') return False if not self.grid_coordinates.is_equivalent(other.grid_coordinates, logger, tolerance): return False if not self.flow_solution.is_equivalent(other.flow_solution, logger, tolerance): return False return True
[docs] def extract(self, imin, imax, jmin=None, jmax=None, kmin=None, kmax=None, grid_ghosts=None, flow_ghosts=None): """ Construct a new :class:`Zone` from grid and flow data extracted from the specified region. Symmetry data is copied. imin, imax, jmin, jmax, kmin, kmax: int Specifies the region to extract neglecting ghost/rind planes. Negative values are relative to the size in that dimension, so -1 refers to the last element. For 2D zones omit kmin and kmax. For 1D zones omit jmin, jmax, kmin, and kmax. grid_ghosts: int[] The number of ghost/rind planes for the new zone's grid. If ``None`` the grid's existing specification is used. flow_ghosts: int[] The number of ghost/rind planes for the new zone's flow solution. If ``None`` the flow's existing specification is used. """ zone = Zone() zone.grid_coordinates = \ self.grid_coordinates.extract(imin, imax, jmin, jmax, kmin, kmax, grid_ghosts) zone.flow_solution = \ self.flow_solution.extract(imin, imax, jmin, jmax, kmin, kmax, flow_ghosts) if self.reference_state is not None: zone.reference_state = self.reference_state.copy() zone.coordinate_system = self.coordinate_system zone.right_handed = self.right_handed zone.symmetry = self.symmetry zone.symmetry_axis = self.symmetry_axis zone.symmetry_instances = self.symmetry_instances return zone
[docs] def extend(self, axis, delta, grid_points, flow_points, normal=None): """ Construct a new :class:`Zone` by linearly extending the grid and replicating the flow. Symmetry data is copied. axis: 'i', 'j', or 'k' Index axis to extend. delta: float. Fractional amount to move for each point. Multiplies the 'edge' delta in the `axis` direction or the appropriate component of `normal`. A negative value adds points before the current zero-index of `axis`. grid_points: int >= 0 Number of points to add in `axis` dimension. flow_points: int >= 0 Number of points to add in `axis` dimension. normal: float[] For cases where only a single point exists in the `axis` direction, this specifies the direction to move. If not specified, an axis-aligned direction is selected based on minimum grid extent. """ zone = Zone() if grid_points > 0: zone.grid_coordinates = \ self.grid_coordinates.extend(axis, delta, grid_points, normal) else: zone.grid_coordinates = self.grid_coordinates.copy() if flow_points > 0: zone.flow_solution = \ self.flow_solution.extend(axis, delta, flow_points) else: zone.flow_solution = self.flow_solution.copy() if self.reference_state is not None: zone.reference_state = self.reference_state.copy() zone.coordinate_system = self.coordinate_system zone.right_handed = self.right_handed zone.symmetry = self.symmetry zone.symmetry_axis = self.symmetry_axis zone.symmetry_instances = self.symmetry_instances return zone
[docs] def make_cartesian(self, axis='z'): """ Convert to Cartesian coordinate system. axis: string Specifies which is the cylinder axis ('z' or 'x'). """ if self.coordinate_system != CARTESIAN: self.flow_solution.make_cartesian(self.grid_coordinates, axis) self.grid_coordinates.make_cartesian(axis) self.coordinate_system = CARTESIAN
[docs] def make_cylindrical(self, axis='z'): """ Convert to cylindrical coordinate system. axis: string Specifies which is the cylinder axis ('z' or 'x'). """ if self.coordinate_system != CYLINDRICAL: self.grid_coordinates.make_cylindrical(axis) self.flow_solution.make_cylindrical(self.grid_coordinates, axis) self.coordinate_system = CYLINDRICAL
[docs] def make_left_handed(self): """ Convert to left-handed coordinate system. """ if self.right_handed: self.grid_coordinates.flip_z() self.flow_solution.flip_z() self.right_handed = False
[docs] def make_right_handed(self): """ Convert to right-handed coordinate system. """ if not self.right_handed: self.grid_coordinates.flip_z() self.flow_solution.flip_z() self.right_handed = True
[docs] def translate(self, delta_x, delta_y, delta_z): """ Translate coordinates. delta_x, delta_y, delta_z: float Amount of translation along the corresponding axis. """ if self.coordinate_system == CARTESIAN: self.grid_coordinates.translate(delta_x, delta_y, delta_z) else: raise RuntimeError('Zone not in cartesian coordinates')
[docs] def rotate_about_x(self, deg): """ Rotate about the X axis. deg: float (degrees) Amount of rotation. """ if self.coordinate_system == CARTESIAN: self.grid_coordinates.rotate_about_x(deg) self.flow_solution.rotate_about_x(deg) else: raise RuntimeError('Zone not in cartesian coordinates')
[docs] def rotate_about_y(self, deg): """ Rotate about the Y axis. deg: float (degrees) Amount of rotation. """ if self.coordinate_system == CARTESIAN: self.grid_coordinates.rotate_about_y(deg) self.flow_solution.rotate_about_y(deg) else: raise RuntimeError('Zone not in cartesian coordinates')
[docs] def rotate_about_z(self, deg): """ Rotate about the Z axis. deg: float (degrees) Amount of rotation. """ if self.coordinate_system == CARTESIAN: self.grid_coordinates.rotate_about_z(deg) self.flow_solution.rotate_about_z(deg) else: raise RuntimeError('Zone not in cartesian coordinates')
[docs] def promote(self): """ Promote from N-dimensional to N+1 dimensional index space. """ self.grid_coordinates.promote() self.flow_solution.promote()
[docs] def demote(self): """ Demote from N-dimensional to N-1 dimensional index space. """ self.grid_coordinates.demote() self.flow_solution.demote()
OpenMDAO Home