optocad_backscattermeter 0.0.0__tar.gz

optocad_backscattermeter-0.0.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.5
+Name: optocad_backscattermeter
+Version: 0.0.0
+Summary: Tool to operate with the optocad model of the backscattermeter at LAPP
+Project-URL: Documentation, https://git.linarphy.net/linarphy/optocad_backscattermeter/wiki
+Project-URL: Homepage, https://git.linarphy.net/linarphy/optocad_backscattermeter
+Project-URL: Source, https://git.linarphy.net/linarphy/optocad_backscattermeter
+Project-URL: Issues, https://git.linarphy.net/linarphy/optocad_backscattermeter/issues
+Author-email: linarphy <linarphy@linarphy.net>
+License-Expression: GPL-3.0-or-later
+Keywords: backscattered light,virgo
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.14.7
+Requires-Dist: astropy>=8.0.2
+Description-Content-Type: text/markdown
+
+# Optocad backscattermeter
+
+This package is used to manage and work with optocad models of
+[the backscattermeter at LAPP](https://doi.org/10.48550/arXiv.2202.07370).
+
+## Getting started
+
+### Requirements
+
+- Python >= 3.14.7
+- rich >= 13.9.4 (console output)
+- optocad (you need to be in the LVK collaboration) with `occr` in your
+`$PATH`.
+
+### Installation
+
+To install this package in the current python environment, use
+
+```sh
+python -m pip install optocad_backscattermeter
+```

optocad_backscattermeter-0.0.0/README.md

@@ -0,0 +1,21 @@
+# Optocad backscattermeter
+
+This package is used to manage and work with optocad models of
+[the backscattermeter at LAPP](https://doi.org/10.48550/arXiv.2202.07370).
+
+## Getting started
+
+### Requirements
+
+- Python >= 3.14.7
+- rich >= 13.9.4 (console output)
+- optocad (you need to be in the LVK collaboration) with `occr` in your
+`$PATH`.
+
+### Installation
+
+To install this package in the current python environment, use
+
+```sh
+python -m pip install optocad_backscattermeter
+```

optocad_backscattermeter-0.0.0/justfile

@@ -0,0 +1,55 @@
+# run tests
+test:
+	hatch run test:coverage run -m unittest tests/test*.py
+	hatch run test:coverage report
+	rm .coverage
+
+# for development: check typing error and fix them if possible
+fix: test
+	hatch run dev:ruff format
+	hatch run dev:ruff check --fix
+	hatch run dev:ty check
+	markdownlint-cli2 --fix "**/*.md"
+
+# for development: check typing error without fixing anything
+check: test
+	hatch run dev:ruff check
+	hatch run dev:ty check
+	markdownlint-cli2 "**/*.md"
+
+# generate stubs
+stubs:
+	rm -rf typings/
+	hatch run stubs:stubgen -p optocad_backscattermeter --output=typings
+
+# update the package
+update: && uninstall install test
+	git pull
+	hatch env prune
+
+# install the package in the current environment
+install: test
+	python -m pip install . -e
+
+# uninstall the package from the current environment
+uninstall:
+	python -m pip uninstall optocad_backscattermeter
+
+# for development: build release
+build: check
+	hatch build
+
+# for development: delete files created by build
+clean-build: build
+	rm -rf dist
+
+# for development: publish release to pypi and my own package registry
+publish: build && clean-build
+	hatch publish
+	hatch publish -r https://git.linarphy.net/api/packages/linarphy/pypi/ || true
+
+# for development: main command to run after a code change
+release: check && publish
+	jj bookmark advance
+	jj git push --all
+	./hooks/post-commit

optocad_backscattermeter-0.0.0/mise.toml

@@ -0,0 +1,6 @@
+[tools]
+python = "3.14.7"
+uv = "0.11.33"
+just = "1.51.0"
+hatch = "1.16.5"
+markdownlint-cli2 = "0.22.1"

optocad_backscattermeter-0.0.0/pyproject.toml

@@ -0,0 +1,124 @@
+[project]
+name = "optocad_backscattermeter"
+version = "0.0.0"
+description = "Tool to operate with the optocad model of the backscattermeter at LAPP"
+authors = [{ name = "linarphy", email = "linarphy@linarphy.net" }]
+readme = "README.md"
+requires-python = ">=3.14.7"
+license = " GPL-3.0-or-later"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Intended Audience :: Science/Research",
+  "Operating System :: OS Independent",
+  "Development Status :: 1 - Planning",
+  "Topic :: Scientific/Engineering",
+]
+dependencies = ["astropy>=8.0.2"]
+keywords = ["virgo", "backscattered light"]
+
+[project.urls]
+Documentation = "https://git.linarphy.net/linarphy/optocad_backscattermeter/wiki"
+Homepage = "https://git.linarphy.net/linarphy/optocad_backscattermeter"
+Source = "https://git.linarphy.net/linarphy/optocad_backscattermeter"
+Issues = "https://git.linarphy.net/linarphy/optocad_backscattermeter/issues"
+
+[project.scripts]
+optocad_backscattermeter = "optocad_backscattermeter.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/optocad_backscattermeter", "typings/optocad_backscattermeter"]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+  "/.git",
+  "/.jj",
+  "/.forgejo",
+  "/.mypy_cache",
+  "/ruff_cache",
+  "/hooks",
+  "/tests",
+]
+
+[tool.hatch.envs.default]
+installer = "uv"
+
+[tool.hatch.envs.dev]
+installer = "uv"
+dependency-groups = ["dev"]
+
+[tool.hatch.envs.stubs]
+installer = "uv"
+dependency-groups = ["stubs"]
+
+[tool.hatch.envs.test]
+installer = "uv"
+dependency-groups = ["test"]
+
+[tool.ruff]
+line-length = 72
+
+[tool.ruff.lint]
+select = [
+  "E",
+  "W",
+  "F",
+  "UP",
+  "B",
+  "SIM",
+  "I",
+  "ERA",
+  "ANN",
+  "S",
+  "BLE",
+  "FBT",
+  "A",
+  "COM",
+  "C4",
+  "EXE",
+  "FIX",
+  "FA",
+  "INT",
+  "ISC",
+  "PIE",
+  "T20",
+  "PYI",
+  "Q",
+  "RSE",
+  "RET",
+  "SLF",
+  "SLOT",
+  "TD",
+  "TID",
+  "TC",
+  "ARG",
+  "PTH",
+  "C90",
+  "NPY",
+  "N",
+  "PERF",
+  "D",
+  "PL",
+  "UP",
+  "FURB",
+  "RUF",
+  "TRY",
+]
+ignore = ["COM812", "ANN401", "D202", "D203", "D212"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/**/*.py" = ["PLR2004", "S311", "E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true
+
+
+[dependency-groups]
+dev = ["ty>=0.0.83", "ruff>=0.16.8"]
+stubs = ["mypy<=1.20.0"]
+test = ["coverage>=7.14", "rich"]

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/__init__.py

@@ -0,0 +1 @@
+"""Entry-point package."""

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/cli.py

@@ -0,0 +1,143 @@
+"""Cli entry-point."""
+
+from argparse import ArgumentParser, Namespace, _SubParsersAction
+from pathlib import Path
+from sys import argv
+
+from astropy.units import Quantity
+
+from optocad_backscattermeter.utils import scan
+
+
+def build_parser() -> ArgumentParser:
+    """Build argument parser."""
+    parser = ArgumentParser(
+        prog="optocad_backscattermeter",
+        description="Run one or multiple OptoCad simulation.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    build_scan(subparsers)
+
+    return parser
+
+
+def build_scan(
+    subparsers: _SubParsersAction[ArgumentParser],
+) -> ArgumentParser:
+    """Build scan parser."""
+    scan = subparsers.add_parser(name="scan")
+    scan.add_argument(
+        "-n",
+        "--configuration-name",
+        type=str,
+        required=True,
+        help="name of the configuration",
+    )
+    scan.add_argument(
+        "-m",
+        "--motorized-mirror-angle",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "angle offset of the motorized mirror from 45 deg. Can be "
+            "written with unit, default to deg. Can be a list of "
+            "value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-s",
+        "--sample-angle",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "angle offset of the sample compared to the orthogonal."
+            "Can be written with unit, default to deg. Can be a list "
+            "of value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-p",
+        "--sample-position",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "position of the sample on the suspended bench. This is "
+            "the distance between the start of the bench and the "
+            "sample. Can be written with unit, default to cm. Can be a "
+            "list of value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        required=False,
+        help="File to write the result to. If none, stdout",
+    )
+    scan.add_argument(
+        "-w",
+        "--overwrite",
+        action="store_true",
+        help=(
+            "Overwrite the file if it exists. Useless if output is not "
+            "specified"
+        ),
+    )
+
+    return scan
+
+
+def to_quantity(values: list[str], default_unit: str) -> Quantity:
+    """Parse quantity, allows float: add default unit in this case."""
+    result = []
+    for value in values:
+        try:
+            result.append(Quantity(float(value), unit=default_unit))
+        except ValueError:
+            result.append(Quantity(value))
+
+    return Quantity(result)
+
+
+def run_scan(namespace: Namespace) -> int:
+    """Run scan simulation."""
+
+    result = scan(
+        configuration_name=namespace.configuration_name,
+        motorized_mirror_angle=to_quantity(
+            namespace.motorized_mirror_angle, "deg"
+        ),
+        sample_angle=to_quantity(namespace.sample_angle, "deg"),
+        sample_position=to_quantity(namespace.sample_position, "cm"),
+    )
+
+    if namespace.output is None:
+        print(result)  # noqa: T201
+    else:
+        if namespace.output.exists() and not namespace.overwrite:
+            message = (
+                f"output file {namespace.output} already exists, use "
+                "--overwrite to replace it"
+            )
+            raise ValueError(message)
+
+        result.write(
+            namespace.output,
+            format="ascii.ecsv",
+            overwrite=namespace.overwrite,
+        )
+
+    return 0
+
+
+def main() -> int:
+    """Enter the main CLI entry-point."""
+
+    namespace = build_parser().parse_args(argv[1:])
+
+    if namespace.command == "scan":
+        return run_scan(namespace)
+    return 1

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/configuration/1

@@ -0,0 +1,70 @@
+# BEAM
+b	x=36,	y=0,	w=350e-6,	ag=-180, z=0
+
+# BS1
+d	ac=srt,	x=17,	y=0,	rd=1.,	ag=135 # BS1 @ 1, 1, 1.2
+	+ t,	dm=0.2
+
+# MM
+d	ac=r,	x=17,	y=-6,	rd=1.,	ag={absolute_motorized_mirror_angle} # MM @ 1, 0, 1.2
+	+ d,	dm=0.2
+
+# L1
+d ac=t,	x=-0.5,	y=-6,	rd=1.,	ag=0,	f=50 # L1 @ 0, 1.5, 1.2
+	+ t,	dm=0.2
+
+# M4
+d	ac=r,	x=-3.5,	y=-6,	rd=1.,	ag=-217 # M4 @ 0, 1.5, 1.2
+	+ d,	dm=0.2
+
+# M5
+d	ac=r,	x=3.2,	y=-28.5,	rd=1.,	ag=-82.0 # M5 @ 0, -1.5, 1.2
+	+ d,	dm=0.2
+
+# L2
+#d	ac=t,	x=3,	y=-13.5,	rd=1.,	ag=90,	f=-10 # L3 @ 1.5, 0, 1.2
+#	+ t,	dm=0.2
+
+# L3
+d	ac=t,	x=2.961387143,	y=16.5,	rd=2.,	ag=90,	f=40 # L3 @ 2.5, 0, 1.2
+	+ t,	dm=0.2
+
+# start of the bench
+d	ac=t,	x=2.961387143,	y=22.5,	rd=2.,	ag=90, m=0 # start of the bench @ 2.5, 0, 1.2
+	+ t,	dm=0.2
+
+# M6
+d	ac=r,	x=17,	y=4.062426105,	rd=1.,	ag=45 # M6 @ 1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# M7
+d	ac=r,	x=12.5,	y=0,	rd=1.,	ag=-135 # M7 @ -2.5, 0, 1.2
+	+ d,	dm=0.2
+
+# BS2
+d	ac={{srt}}2,	x=12.5, y=4,	rd=1.,	ag=45 # BS2 @ -3, 1, 1.2
+	+ t,	dm=0.2
+
+# BS3
+d	ac={{srt}}2,	x=-7.5,	y=4,	rd=1.,	ag=-45 # BS3 @ 0, 1.5, 1.2
+	+ t,	dm=0.2
+
+# M8
+d	ac=r,	x=12.5,	y=14,	rd=1.,	ag=45 # M8 @ 1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# Camera
+d	ac=d,	x=-14.5,	y=4.124852211,	rd=1.,	ag=0 # C1 @ -1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# PD1
+d	ac=d,	x=-20,	y=14,	rd=1.,	ag=0 # PD1 @ -2, 0, 1.2
+	+ d,	dm=0.2
+
+# PD2
+d	ac=d,	x=-7.312721683,	y=-8,	rd=1.,	ag=90 # PD2 @ -1, -1.5, 1.2
+	+ d,	dm=0.2
+
+# sample
+d	ac=r,	x=2.961387143,	y={absolute_sample_position},	rd=1.,	ag={absolute_sample_angle} # sample @ -1.5, 1, 1.2
+	+ d,	dm=0.2

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/configuration.py

@@ -0,0 +1,76 @@
+"""Configuration class."""
+
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+if TYPE_CHECKING:
+    from astropy.units import Quantity
+
+START_OF_BENCH_Y_CM = 22.5
+MOTORIZED_MIRROR_ANGLE_INIT_DEG = -45
+SAMPLE_ANGLE_INIT_DEG = 90
+
+
+@dataclass
+class Configuration:
+    """Backscattermeter setup configuration."""
+
+    configuration_name: str
+    motorized_mirror_angle: Quantity
+    sample_angle: Quantity
+    sample_position: Quantity
+    configuration_version: ClassVar[str] = "1.0"
+
+    def __post_init__(self) -> None:
+        """Validate and normalize units."""
+        self.sample_angle = self.sample_angle.to("deg")
+        self.motorized_mirror_angle = self.motorized_mirror_angle.to(
+            "deg"
+        )
+        self.sample_position = self.sample_position.to("cm")
+
+    @property
+    def configuration_file(self) -> Path:
+        """Path to the current configuration file."""
+
+        return Path(
+            str(
+                files("optocad_backscattermeter")
+                / "configuration"
+                / self.configuration_name
+            )
+        )
+
+    def read_configuration_file(self) -> str:
+        """Read the configuration file."""
+
+        return self.configuration_file.read_text()
+
+    def format(self, configuration: str) -> str:
+        """Format the configuration."""
+
+        return configuration.format(
+            absolute_motorized_mirror_angle=(
+                MOTORIZED_MIRROR_ANGLE_INIT_DEG
+                + self.motorized_mirror_angle.to_value("deg")
+            ),
+            absolute_sample_position=START_OF_BENCH_Y_CM
+            + self.sample_position.to_value("cm"),
+            absolute_sample_angle=SAMPLE_ANGLE_INIT_DEG
+            + self.sample_angle.to_value("deg"),
+        )
+
+    def generate(self) -> str:
+        """Generate the .ocd file of this configuration."""
+
+        return self.format(self.read_configuration_file())
+
+    def serialize(self) -> dict[str, str]:
+        """Serialize this object to a dict."""
+
+        return {
+            "configuration version": self.configuration_version,
+            "configuration name": self.configuration_name,
+        }

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/fortran/display.f95

@@ -0,0 +1,30 @@
+Program SAMPLE
+  use optocad
+  use rsplot
+
+  call oc_init(psize=(/450., 800./),unit='cm')
+
+  call oc_frame(-30., -40., 50., 100., scale=0.5)
+
+  call oc_set(rix = (/1.45/), &
+              lambda = 1.054e-6, &
+        print = 'rs act dx dy x1 x2 ang med lb')
+
+  call oc_input('', nib)
+
+  icb0=1
+  icb1=2
+  icb2=ps_color((/1., .6, .6/))
+  icb3=ps_color((/1., .8, .8/))
+
+  do ib=1,nib
+    call oc_trace(ib)
+    call oc_beam(3.0, fill=icb3)
+    call oc_beam(2.0, fill=icb2)
+    call oc_beam(1.0, fill=icb1)
+    call oc_beam(0.0, icb0, 5, .1, rns=2., rnc=2)
+  end do
+  call oc_surf
+
+  call oc_exit
+  end

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/parser.py

@@ -0,0 +1,257 @@
+"""Parser class."""
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+from astropy.units import Unit
+
+FIELDS = [
+    "rs",
+    "s1",
+    "s2",
+    "cp",
+    "md",
+    "a",
+    "asoi",
+    "rd",
+    "ang",
+    "Ang",
+    "an1",
+    "an2",
+    "w0t",
+    "w0s",
+    "w1t",
+    "w1s",
+    "w2t",
+    "w2s",
+    "z0t",
+    "z0s",
+    "z1t",
+    "z1s",
+    "z2t",
+    "z2s",
+    "R1t",
+    "R1s",
+    "R2t",
+    "R2s",
+    "C1t",
+    "C1s",
+    "C2t",
+    "C2s",
+    "ipp",
+    "tpp",
+    "pw",
+    "pd",
+    "pa",
+    "tlt",
+    "tls",
+    "ph",
+    "gp1t",
+    "gp1s",
+    "gp2t",
+    "gp2s",
+    "Gp1",
+    "Gp2",
+    "Gp1t",
+    "Gp1s",
+    "Gp2t",
+    "Gp2s",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "dx",
+    "dy",
+    "sas",
+    "Sas",
+    "label",
+]  # from optocad documentation
+
+
+@dataclass
+class Column:
+    """A column of a table."""
+
+    name: str
+    unit: Unit | None
+    values: list[str | float | int | bool] = field(default_factory=list)
+
+
+@dataclass
+class Table:
+    """A table containing multiple columns."""
+
+    columns: list[Column]
+
+    def get(self, name: str) -> Column:
+        """Get a column from its name."""
+
+        for column in self.columns:
+            if column.name == name:
+                return column
+
+        message = f"Column {name} not found."
+        raise KeyError(message)
+
+
+@dataclass
+class Beam:
+    """Multiple tables."""
+
+    tables: list[Table] = field(default_factory=list)
+
+    def add_table(self, columns: list[Column]) -> None:
+        """Add a table to the beam."""
+
+        self.tables.append(Table(columns=columns))
+
+    def last(self) -> Table:
+        """Return the last table added."""
+
+        return self.tables[-1]
+
+
+@dataclass
+class ParserResult:
+    """Main parser result."""
+
+    beams: list[Beam] = field(default_factory=list)
+
+    def add_beam(self) -> None:
+        """Add a beam to the result."""
+
+        self.beams.append(Beam())
+
+    def last(self) -> Beam:
+        """Return the last beam added."""
+
+        return self.beams[-1]
+
+
+class ParserState(StrEnum):
+    """Parser possible state."""
+
+    BEFORE = "not in a beam, still waiting for it"
+    BEAM_START = "first line of a beam"
+    IN_TABLE = "inside a table"
+    BETWEEN_TABLE = "table closed maybe still in a beam"
+    AFTER = "not in a beam anymore"
+
+
+@dataclass
+class Parser:
+    """Parse OptoCad output."""
+
+    state: ParserState = ParserState.BEFORE
+    result: ParserResult = field(default_factory=ParserResult)
+
+    def parse(self, content: str) -> ParserResult:
+        """Parse the given content."""
+
+        self.state = ParserState.BEFORE
+        self.result = ParserResult()
+
+        for line in content.splitlines():
+            self.parse_line(line)
+
+        return self.result
+
+    def parse_line(  # noqa: C901
+        self,
+        line: str,
+    ) -> None:
+        """Parse a single line in function of the current state."""
+
+        if self.state is ParserState.BEFORE:
+            result = self.parse_beam(line)
+            if result:
+                self.state = ParserState.BEAM_START
+        elif self.state is ParserState.BEAM_START:
+            result = self.parse_header(line)
+            if not result:
+                message = f"Cannot parse line: {line!r}"
+                raise ValueError(message)
+            self.state = ParserState.IN_TABLE
+        elif self.state is ParserState.IN_TABLE:
+            result = self.parse_row(line)
+            if not result:
+                self.state = ParserState.BETWEEN_TABLE
+        elif self.state is ParserState.BETWEEN_TABLE:
+            result = self.parse_header(line)
+            if result:
+                self.state = ParserState.IN_TABLE
+            else:
+                result = self.parse_beam(line)
+                if result:
+                    self.state = ParserState.BEAM_START
+                else:
+                    self.state = ParserState.AFTER
+        elif self.state is ParserState.AFTER:
+            pass
+
+    def parse_beam(self, line: str) -> bool:
+        """Read a line announcing a new beam."""
+
+        result = line.startswith(
+            f"Beam # {len(self.result.beams) + 1}:"
+        )
+
+        if result:
+            self.result.add_beam()
+
+        return result
+
+    def parse_header(self, line: str) -> bool:
+        """Parse header line."""
+
+        columns_name = line.split()
+
+        if not columns_name:
+            return False
+
+        columns = []
+
+        for column in columns_name:
+            name, bracket, rest = column.partition("[")
+            unit = rest[:-1] if bracket and rest.endswith("]") else None
+
+            if bracket and unit is None:
+                message = f"Cannot parse {column} name."
+                raise ValueError(message)
+
+            if name not in FIELDS:
+                return False
+
+            if unit is not None:
+                unit = Unit(unit)
+
+            columns.append(Column(name=name, unit=unit))
+
+        self.result.last().add_table(columns=columns)
+
+        return True
+
+    def parse_row(self, line: str) -> bool:
+        """Parse table row."""
+
+        values = line.split(
+            maxsplit=len(self.result.last().last().columns) - 1
+        )
+
+        if not values:
+            return False
+
+        for column, value in zip(
+            self.result.last().last().columns, values, strict=True
+        ):
+            key = column.name
+            if key in ["rs", "s1", "s2", "cp"]:
+                column.values.append(int(value))
+            elif key == "md":
+                column.values.append(bool(int(value)))
+            elif key in ["label", "a", "asoi"]:
+                column.values.append(value)
+            else:
+                column.values.append(float(value))
+
+        return True

optocad_backscattermeter-0.0.0/src/optocad_backscattermeter/utils.py

@@ -0,0 +1,167 @@
+"""Utils function."""
+
+from importlib.resources import files
+from itertools import product
+from pathlib import Path
+from shutil import which
+from subprocess import run
+from tempfile import NamedTemporaryFile
+
+from astropy.table import QTable, vstack
+from astropy.units import Quantity
+from numpy import atleast_1d, concatenate
+
+from optocad_backscattermeter.configuration import Configuration
+from optocad_backscattermeter.parser import Parser
+
+EXECUTABLE_NAME = "occr"
+
+
+def find_optocad() -> Path:
+    """Find the path to OptoCad from the $PATH."""
+
+    executable = which(EXECUTABLE_NAME)
+
+    if executable is None:
+        message = (
+            f"{EXECUTABLE_NAME!r} not found in $PATH. Did you install "
+            "OptoCad ?"
+        )
+        raise FileNotFoundError(message)
+
+    return Path(executable)
+
+
+def run_optocad(
+    ocd_file: Path,
+    fortran_display: Path,
+    executable: Path | None = None,
+) -> str:
+    """
+    Run OptoCad on the given .ocd file.
+
+    Parameters
+    ----------
+    ocd_file: Path
+        Path to the ocd file.
+    fortran_display: Path
+        Path to the necessary Fortran script used to load the ocd file.
+    executable: Path | None
+        Path to the executable. If None, find the path from the $PATH.
+
+    """
+
+    if executable is None:
+        executable = find_optocad()
+
+    completed = run(  # noqa: S603
+        [str(executable), str(fortran_display), str(ocd_file)],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    return completed.stdout
+
+
+def to_table(configuration: Configuration, content: str) -> QTable:
+    """Parse OptoCad output and convert it into an astropy table."""
+
+    result = Parser().parse(content)
+
+    beams = []
+    for beam_number, beam in enumerate(result.beams):
+        header = {column.name for column in beam.tables[0].columns}
+
+        columns = {key: [] for key in sorted(header)}
+        columns["table number"] = []
+        # merge tables
+        for number, table in enumerate(beam.tables):
+            if header != {column.name for column in table.columns}:
+                message = "Different header on the same beam."
+                raise ValueError(message)
+
+            for column in table.columns:
+                if column.unit is not None:
+                    columns[column.name].append(
+                        Quantity(column.values, column.unit)
+                    )
+                else:
+                    columns[column.name].append(column.values)
+
+            columns["table number"].append(
+                [number] * len(table.columns[0].values)
+            )
+
+        for key, column in columns.items():
+            columns[key] = concatenate(column)  # type: ignore[ty:invalid-assignment]
+
+        table = QTable(data=columns)
+        table["beam number"] = beam_number
+        table["motorized mirror angle"] = (
+            configuration.motorized_mirror_angle
+        )
+        table["sample angle"] = configuration.sample_angle
+        table["sample position"] = configuration.sample_position
+
+        beams.append(table)
+
+    table = vstack(beams)
+    table.meta = configuration.serialize()
+
+    return table
+
+
+def scan(
+    configuration_name: str,
+    motorized_mirror_angle: Quantity,
+    sample_angle: Quantity,
+    sample_position: Quantity,
+) -> QTable:
+    """
+    Run one simulation per combination of the scanned values.
+
+    Each parameter is a scalar or a vector of quantities; several
+    vectors are combined as a cartesian product. Scalars are
+    treated as single-value vectors.
+    """
+
+    parameters = {
+        "motorized_mirror_angle": atleast_1d(motorized_mirror_angle),
+        "sample_angle": atleast_1d(sample_angle),
+        "sample_position": atleast_1d(sample_position),
+    }
+
+    tables = []
+    for combination in product(*parameters.values()):
+        arguments = dict(zip(parameters, combination, strict=True))
+        arguments["configuration_name"] = configuration_name
+
+        table = main(configuration=Configuration(**arguments))
+        tables.append(table)
+
+    return vstack(tables)
+
+
+def main(configuration: Configuration) -> QTable:
+    """Run the configuration and give back the result."""
+
+    with NamedTemporaryFile("w+") as file:
+        file.write(configuration.generate())
+        file.flush()
+
+        fortran_display = Path(
+            str(
+                files("optocad_backscattermeter")
+                / "fortran"
+                / "display.f95"
+            )
+        )
+
+        return to_table(
+            configuration,
+            run_optocad(
+                ocd_file=Path(file.name),
+                fortran_display=fortran_display,
+            ),
+        )