def __repr__(self): """Return ``repr(self)``.""" arg_fstr = '\n {!r},\n {!r},\n src_radius={}, det_radius={}' if self.pitch != 0: arg_fstr += ',\n pitch={pitch}' if self.pitch_offset != 0: arg_fstr += ',\n pitch_offset={pitch_offset}' if not np.allclose(self.axis, [0, 0, 1]): arg_fstr += ',\n axis={axis}' default_src_to_det = perpendicular_vector(self.axis) if not np.allclose(self._src_to_det_init, default_src_to_det): arg_fstr += ',\n src_to_det_init={src_to_det_init}' default_axes = [np.cross(self.axis, self._src_to_det_init), self.axis] if not np.allclose(self.detector.axes, default_axes): arg_fstr += ',\n det_init_axes={det_init_axes!r}' arg_str = arg_fstr.format( self.motion_partition, self.det_partition, self.src_radius, self.det_radius, pitch=self.pitch, pitch_offset=self.pitch_offset, axis=list(self.axis), src_to_det_init=list(self.src_to_det_init), det_init_axes=[list(a) for a in self.det_init_axes]) return '{}({})'.format(self.__class__.__name__, arg_str)
def __init__(self, apart, dpart, src_radius, det_radius, **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 1-dim. `RectPartition` Partition of the detector parameter interval src_radius : nonnegative float Radius of the source circle det_radius : nonnegative float Radius of the detector circle src_to_det_init : `array-like` (shape ``(2,)``), optional Initial state of the vector pointing from source to detector reference point. The zero vector is not allowed. Default: ``(1, 0)``. det_init_axis : `array-like` (shape ``(2,)``), optional Initial axis defining the detector orientation. By default, a normalized `perpendicular_vector` to ``src_to_det_init`` is used. """ src_to_det_init = kwargs.pop('src_to_det_init', (1.0, 0.0)) det_init_axis = kwargs.pop('det_init_axis', None) if np.shape(src_to_det_init) != (2,): raise ValueError('`src_to_det_init` has shape {}, ' 'expected (2,)' ''.format(np.shape(src_to_det_init))) if np.linalg.norm(src_to_det_init) <= 1e-10: raise ValueError('`src_to_det_init` {} too close ' 'to zero'.format(src_to_det_init)) self._src_to_det_init = (np.asarray(src_to_det_init, dtype='float64') / np.linalg.norm(src_to_det_init)) if det_init_axis is None: det_init_axis = perpendicular_vector(self._src_to_det_init) self._src_radius, src_radius_in = float(src_radius), src_radius if self.src_radius < 0: raise ValueError('`src_radius` {} is negative' ''.format(src_radius_in)) self._det_radius, det_radius_in = float(det_radius), det_radius if det_radius < 0: raise ValueError('`det_radius` {} is negative' ''.format(det_radius_in)) if self.src_radius == 0 and self.det_radius == 0: raise ValueError('source and detector radii cannot both be 0') detector = Flat1dDetector(dpart, det_init_axis) super().__init__(ndim=2, motion_part=apart, detector=detector)
def __init__(self, apart, dpart, axis=[0, 0, 1], **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 2-dim. `RectPartition` Partition of the detector parameter interval axis : `array-like`, shape ``(3,)``, optional Fixed rotation axis defined by a 3-element vector det_init_pos : `array-like`, shape ``(3,)``, optional Initial position of the detector reference point. The zero vector is only allowed if ``det_init_axes`` is explicitly given. By default, a `perpendicular_vector` to ``axis`` is used. det_init_axes : 2-tuple of `array-like`'s (shape ``(3,)``), optional Initial axes defining the detector orientation. By default, the normalized cross product of ``axis`` and ``det_init_pos`` is used as first axis and ``axis`` as second. """ AxisOrientedGeometry.__init__(self, axis) det_init_pos = kwargs.pop('det_init_pos', perpendicular_vector(axis)) det_init_axes = kwargs.pop('det_init_axes', None) if det_init_axes is None: if np.linalg.norm(det_init_pos) <= 1e-10: raise ValueError('initial detector position {} is close to ' 'zero. This is only allowed for explicit ' '`det_init_axes`.'.format(det_init_pos)) det_init_axis_0 = np.cross(self.axis, det_init_pos) det_init_axis_0 /= np.linalg.norm(det_init_axis_0) det_init_axes = (det_init_axis_0, axis) self.det_init_axes = det_init_axes detector = Flat2dDetector(part=dpart, axes=det_init_axes) super().__init__(ndim=3, apart=apart, detector=detector, det_init_pos=det_init_pos) if self.motion_partition.ndim != 1: raise ValueError('`apart` has dimension {}, expected 1' ''.format(self.motion_partition.ndim))
def __repr__(self): """Return ``repr(self)``.""" inner_fstr = '\n {!r},\n {!r}' if not np.allclose(self.det_init_pos, [1, 0]): inner_fstr += ',\n det_init_pos={det_init_pos!r}' if not np.allclose(self.det_init_pos, perpendicular_vector(self.det_init_pos)): inner_fstr += ',\n det_init_axis={det_init_axis!r}' inner_str = inner_fstr.format(self.motion_partition, self.det_partition, det_init_pos=self._det_init_pos, det_init_axis=self.det_init_axis) return '{}({})'.format(self.__class__.__name__, inner_str)
def __repr__(self): """Return ``repr(self)``.""" arg_fstr = '{!r}, {!r}, src_radius={}, det_radius={}' if not np.allclose(self._src_to_det_init, [1, 0]): arg_fstr += ',\n src_to_det_init={src_to_det_init!r}' default_axis = perpendicular_vector(self._src_to_det_init) if not np.allclose(self.detector.axis, default_axis): arg_fstr += ',\n det_init_axis={det_init_axis!r}' arg_str = arg_fstr.format(self.motion_partition, self.det_partition, self.src_radius, self.det_radius, src_to_det_init=self._src_to_det_init, det_init_axis=self.detector.axis) return '{}({})'.format(self.__class__.__name__, arg_str)
def __init__(self, apart, dpart, **kwargs): """Initialize a new instance. Parameters ---------- apart : 2- or 3-dim. `RectPartition` Partition of the angle parameter set dpart : 2-dim. `RectPartition` Partition of the detector parameter interval det_init_pos : `array-like`, shape ``(3,)``, optional Initial position of the detector reference point. The zero vector is only allowed if ``det_init_axes`` is explicitly given. Default: ``(1, 0, 0)`` det_init_axes : 2-tuple of `array-like`'s (shape ``(3,)``), optional Initial axes defining the detector orientation. By default, a normalized `perpendicular_vector` to ``det_init_pos`` is taken as first axis, and the normalized cross product of these two as second. """ det_init_pos = kwargs.pop('det_init_pos', (1.0, 0.0, 0.0)) det_init_axes = kwargs.pop('det_init_axes', None) if det_init_axes is None: if np.linalg.norm(det_init_pos) <= 1e-10: raise ValueError('`det_init_pos` {} is close to ' 'zero. This is only allowed for explicit ' '`det_init_axes`.'.format(det_init_pos)) det_init_axis_0 = perpendicular_vector(det_init_pos) det_init_axis_1 = np.cross(det_init_pos, det_init_axis_0) det_init_axes = (det_init_axis_0, det_init_axis_1) detector = Flat2dDetector(part=dpart, axes=det_init_axes) super().__init__(ndim=3, apart=apart, detector=detector, det_init_pos=det_init_pos) if self.motion_partition.ndim not in (2, 3): raise ValueError('`apart` has dimension {}, expected ' '2 or 3'.format(self.motion_partition.ndim))
def __repr__(self): """Return ``repr(self)``.""" arg_fstr = '\n {!r},\n {!r}' if not np.allclose(self.axis, [0, 0, 1]): arg_fstr += ',\n axis={axis!r}' if not np.allclose(self._det_init_pos, perpendicular_vector(self.axis)): arg_fstr += ',\n det_init_pos={det_init_pos!r}' default_axes = [np.cross(self.axis, self._det_init_pos), self.axis] if not np.allclose(self.detector.axes, default_axes): arg_fstr += ',\n det_init_axes={det_init_axes!r}' arg_str = arg_fstr.format(self.motion_partition, self.det_partition, axis=self.axis, det_init_pos=self._det_init_pos, det_init_axes=self.detector.axes) return '{}({})'.format(self.__class__.__name__, arg_str)
def __repr__(self): """Return ``repr(self)``.""" arg_fstr = '\n {!r},\n {!r}' if not np.allclose(self.axis, [0, 0, 1]): arg_fstr += ',\n axis={axis!r}' if not np.allclose(self._det_init_pos, perpendicular_vector( self.axis)): arg_fstr += ',\n det_init_pos={det_init_pos!r}' default_axes = [np.cross(self.axis, self._det_init_pos), self.axis] if not np.allclose(self.detector.axes, default_axes): arg_fstr += ',\n det_init_axes={det_init_axes!r}' arg_str = arg_fstr.format(self.motion_partition, self.det_partition, axis=self.axis, det_init_pos=self._det_init_pos, det_init_axes=self.detector.axes) return '{}({})'.format(self.__class__.__name__, arg_str)
def __init__(self, apart, dpart, **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 1-dim. `RectPartition` Partition of the detector parameter interval det_init_pos : `array-like`, shape ``(2,)``, optional Initial position of the detector reference point. The zero vector is only allowed if ``det_init_axis`` is explicitly given. Default: ``(1, 0)``. det_init_axis : `array-like` (shape ``(2,)``), optional Initial axis defining the detector orientation. By default, a normalized `perpendicular_vector` to ``det_init_pos`` is used, which is only valid if ``det_init_axis`` is not zero. """ self._det_init_pos = kwargs.pop('det_init_pos', (1.0, 0.0)) self._det_init_axis = kwargs.pop('det_init_axis', None) if self.det_init_axis is None: if np.linalg.norm(self.det_init_pos) <= 1e-10: raise ValueError('`det_init_pos` {} is close to ' 'zero. This is only allowed for explicit ' 'det_init_axis' ''.format(self.det_init_pos)) det_init_axis = perpendicular_vector(self.det_init_pos) detector = Flat1dDetector(part=dpart, axis=det_init_axis) super().__init__(ndim=2, apart=apart, detector=detector, det_init_pos=self.det_init_pos) if self.motion_partition.ndim != 1: raise ValueError('`apart` dimension {}, expected 1' ''.format(self.motion_partition.ndim))
def __init__(self, part, axis): """Initialize a new instance. Parameters ---------- part : 1-dim. `RectPartition` Partition of the parameter interval, corresponding to the line elements axis : `array-like`, shape ``(2,)`` Principal axis of the detector """ super().__init__(part) if self.ndim != 1: raise ValueError('expected partition to have 1 dimension, ' 'got {}'.format(self.ndim)) if np.linalg.norm(axis) <= 1e-10: raise ValueError('`axis` vector {} too close to zero' ''.format(axis)) self._axis = np.asarray(axis) / np.linalg.norm(axis) self._normal = perpendicular_vector(self.axis)
def __init__(self, part, axis): """Initialize a new instance. Parameters ---------- part : 1-dim. `RectPartition` Partition of the parameter interval, corresponding to the line elements axis : `array-like`, shape ``(2,)`` Principal axis of the detector """ super().__init__(part) if self.ndim != 1: raise ValueError('expected partition to have 1 dimension, ' 'got {}.'.format(self.ndim)) if np.linalg.norm(axis) <= 1e-10: raise ValueError('axis vector {} too close to zero.' ''.format(axis)) self._axis = np.asarray(axis) / np.linalg.norm(axis) self._normal = perpendicular_vector(self.axis)
def __init__(self, apart, dpart, det_rad, axis=[0, 0, 1], **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 2-dim. `RectPartition` Partition of the detector parameter rectangle det_rad : positive float Radius of the circular detector orbit. axis : `array-like`, shape ``(3,)``, optional Fixed rotation axis. orig_to_det_init : `array-like`, shape ``(3,)``, optional Vector pointing towards the detector reference point in the initial position. Default: a `perpendicular_vector` to ``axis``. det_init_axes : 2-tuple of `array-like`'s (shape ``(3,)``), optional Initial axes defining the detector orientation. Default: the normalized cross product of ``axis`` and ``orig_to_det_init`` is used as first axis and ``axis`` as second. """ self._det_radius = float(det_rad) if self.det_radius <= 0: raise ValueError('expected a positive radius, got {}' ''.format(det_rad)) orig_to_det_init = kwargs.pop('orig_to_det_init', perpendicular_vector(axis)) init_pos_norm = np.linalg.norm(orig_to_det_init) if init_pos_norm > 1e-10: orig_to_det_init *= self.det_radius / init_pos_norm else: raise ValueError('`orig_to_det_init` {} is too close to zero' ''.format(orig_to_det_init)) kwargs['det_init_pos'] = orig_to_det_init super().__init__(apart, dpart, axis, **kwargs)
def __init__(self, apart, dpart, src_radius, det_radius, pitch, axis=[0, 0, 1], **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 2-dim. `RectPartition` Partition of the detector parameter rectangle src_radius : nonnegative float Radius of the source circle det_radius : nonnegative float Radius of the detector circle pitch : float Constant vertical distance that a point on the helix traverses when increasing the angle parameter by ``2 * pi`` axis : `array-like`, shape ``(3,)``, optional Fixed rotation axis, the symmetry axis of the helix Other Parameters ---------------- src_to_det_init : `array-like`, shape ``(2,)``, optional Initial state of the vector pointing from source to detector reference point. The zero vector is not allowed. By default, a `perpendicular_vector` to ``axis`` is used. det_init_axes : 2-tuple of `array-like`'s (shape ``(2,)``), optional Initial axes defining the detector orientation. By default, the normalized cross product of ``axis`` and ``src_to_det_init`` is used as first axis and ``axis`` as second. pitch_offset : float, optional Offset along the ``axis`` at ``angle=0`` """ AxisOrientedGeometry.__init__(self, axis) src_to_det_init = kwargs.pop('src_to_det_init', perpendicular_vector(self.axis)) if np.linalg.norm(src_to_det_init) <= 1e-10: raise ValueError('initial source to detector vector {} is too ' 'close to zero'.format(src_to_det_init)) self._src_to_det_init = (np.array(src_to_det_init) / np.linalg.norm(src_to_det_init)) det_init_axes = kwargs.pop('det_init_axes', None) if det_init_axes is None: det_init_axis_0 = np.cross(self.axis, self._src_to_det_init) det_init_axes = (det_init_axis_0, axis) detector = Flat2dDetector(dpart, det_init_axes) super().__init__(ndim=3, motion_part=apart, detector=detector) self._pitch = float(pitch) self._pitch_offset = float(kwargs.pop('pitch_offset', 0)) self._src_radius = float(src_radius) if self.src_radius < 0: raise ValueError('source circle radius {} is negative' ''.format(src_radius)) self._det_radius = float(det_radius) if self.det_radius < 0: raise ValueError('detector circle radius {} is negative' ''.format(det_radius)) if self.src_radius == 0 and self.det_radius == 0: raise ValueError('source and detector circle radii cannot both be ' '0')