xopto.mcml.mcdetector.probe.lineararraypl module

class LinearArrayPl(fiber: xopto.mcbase.mcutil.fiber.MultimodeFiber, n=1, spacing: Optional[float] = None, plaxis: Optional[xopto.mcbase.mcutil.axis.Axis] = None, orientation: Tuple[float, float] = (1.0, 0.0), position: Tuple[float, float] = (0.0, 0.0), direction: Tuple[float, float, float] = (0.0, 0.0, 1.0))

Bases: xopto.mcml.mcdetector.base.Detector

Optical fiber probe detector with a linear array of optical fibers that are optionally tilted(direction parameter). The optical fibers are always polished in a way that forms a tight optical contact with the surface of the sample.

Parameters

• fiber (MultimodeFiber) – Optical properties of the fibers.

• n (int) – The number of optical fibers in the linear array. This option is a compile-time feature and caanot be changed once the detector object is created.

• spacing (float) – Spacing between the optical fibers. If spacing is None, a tight layout is used with spacing set to the outer diameter of the fiber cladding.

• plaxis (axis.Axis) – Object that defines the accumulators along the optical path length axis (this axis supports log-scale).

• orientation ((float, float)) – Vector that points in the direction of the linear fiber array. By default the fibers are place in the direction of x axis, i.e. vector (1.0, 0.0). The orientation must point in the direction from the first to the last optical fiber!

• position ((float, float)) – Position of the center of the linear fiber array.

• direction ((float, float, float)) – Reference direction / orientation of the detector fibers. Fibers are oriented in this direction and polished to form a tight optical contact with the sample (the fiber cross sections are ellipsoids if the direction is not perpendicular, i.e different from (0, 0, 1).

check()

Check if the configuration has errors and raise exceptions if so.

cl_declaration(mc: xopto.mcbase.mcobject.McObject) → str

Structure that defines the detector in the Monte Carlo simulator.

cl_implementation(mc: xopto.mcbase.mcobject.McObject) → str

Implementation of the detector accumulator in the Monte Carlo simulator.

cl_options(mc, target=None) → List[Tuple[str, str]]

OpenCL kernel options defined by this object.

cl_pack(mc: xopto.mcbase.mcobject.McObject, target: Optional[xopto.cl.cltypes.Structure] = None) → xopto.cl.cltypes.Structure

Fills the structure (target) with the data required by the Monte Carlo simulator. See the LinearArrayPl.cl_type() method for a detailed list of fields.

Parameters

• mc (mcobject.McObject) – Monte Carlo simulator instance.

• target (cltypes.Structure) – Ctypes structure that is filled with the source data.

Returns

target – Filled structure received as an input argument or a new instance if the input argument target is None.

Return type

cltypes.Structure

static cl_type(mc: xopto.mcbase.mcobject.McObject) → xopto.cl.cltypes.Structure

property direction: Tuple[float, float, float]

Detector reference direction.

property fiber: Tuple[float, float]

Properties of the optical fibers used by the detector.

fiber_position(index: int) → Tuple[float, float]

Returns the position of the fiber center as a tuple (x, y).

Parameters

index (int) – Fiber index from 0 to n -1.

Returns

position – The position of the fiber center as a tuple (x, y).

Return type

(float, float)

static fromdict(data) → xopto.mcml.mcdetector.probe.lineararraypl.LinearArrayPl

Create an accumulator instance from a dictionary.

Parameters

data (dict) – Dictionary created by the LinearArrayPl.todict() method.

property n: int

Number of optical fiber in the linear array.

property normalized: numpy.ndarray

Normalized.

property npl

Number of accumulators in the optical pathlength axis.

property orientation: Tuple[float, float]

Orientation / direction of the linear fiber array.

property pl

Centers of the optical pathlength axis accumulators.

property plaxis: xopto.mcbase.mcutil.axis.Axis

Path length axis object.

property pledges

Edges of the optical pathlength axis accumulators.

property position: Tuple[float, float]

Position of the fiber array center as a tuple (x, y).

property reflectance: numpy.ndarray

Reflectance.

property spacing: float

Spacing between the centers of the optical fibers

todict() → dict

Save the accumulator configuration without the accumulator data to a dictionary. Use the LinearArrayPl.fromdict() method to create a new accumulator instance from the returned data.

Returns

data – Accumulator configuration as a dictionary.

Return type

dict

property transmittance: numpy.ndarray

Transmittance.

update(other: xopto.mcml.mcdetector.probe.lineararraypl.LinearArrayPl)

Update this detector configuration from the other detector. The other detector must be of the same type as this detector or a dict with appropriate fields.

Parameters

other (LinearArrayPl or dict) – This source is updated with the configuration of the other source.