beamstop color option

.github/dependabot.yml

@@ -7,4 +7,4 @@ updates:
   - package-ecosystem: "npm"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "daily"

src/calculations/numericRange.ts

@@ -78,8 +78,8 @@ export default class NumericRange {
 
   /**
    * Applys a function to the range in place
-   * @param func 
-   * @returns 
+   * @param func
+   * @returns
    */
   inPlaceApply(func: (value: number) => number): NumericRange {
     this.min = func(this.min);

src/calculations/qrange.ts

@@ -10,7 +10,7 @@ import { Ray } from "../calculations/ray";
 import NumericRange from "./numericRange";
 
 /**
- * Compute the viable and full qranges 
+ * Compute the viable and full qranges
  * @param detector Detector object with data on how the detector e
  * @param beamstop
  * @param cameraTube

src/calculations/ray.ts

@@ -32,20 +32,23 @@ export class Ray {
   }
 
   /**
-  * Find where the ray insects with a circle.  
-  */
-  public getCircleIntersectionParameterRange(radius: number, centre: Vector2): NumericRange | null {
+   * Find where the ray insects with a circle.
+   */
+  public getCircleIntersectionParameterRange(
+    radius: number,
+    centre: Vector2,
+  ): NumericRange | null {
     const diff = this.initial_point.clone().add(centre.multiplyScalar(-1));
     const a = this.direction.dot(this.direction);
-    const b = 2*diff.dot(this.direction);
-    const c = (diff.dot(diff) - Math.pow(radius,2));
+    const b = 2 * diff.dot(this.direction);
+    const c = diff.dot(diff) - Math.pow(radius, 2);
     const discriminant = Math.pow(b, 2) - 4 * a * c;
-    
+
     if (discriminant < 0) return null;
 
     let t1: number;
     let t2: number;
-  
+
     if (a == 0) {
       if (b == 0)
         return c == 0 ? new NumericRange(0, Number.POSITIVE_INFINITY) : null;
@@ -84,20 +87,18 @@ export class Ray {
         return null;
       return this.getParameterRange(result.min, result.max);
     }
-    
+
     result = result.intersect(
       new NumericRange(
         (ymin - this.initial_point.y) / this.direction.y,
         (ymax - this.initial_point.y) / this.direction.y,
       ),
     );
 
-    if(result ==null){
+    if (result == null) {
       return null;
-    }    
-    
+    }
+
     return this.getParameterRange(result.min, result.max);
   }
 }
-
-

src/data-entry/beamProperties.tsx

@@ -24,6 +24,8 @@ import { useBeamlineConfigStore } from "./beamlineconfigStore";
 import { MathUtils } from "three/src/Three.js";
 
 export default function BeampropertiesDataEntry() {
+  const beamlineConfig = useBeamlineConfigStore();
+
   const minWavelength = useBeamlineConfigStore((state) => {
     if (state.wavelengthUnits === WavelengthUnits.angstroms) {
       return nanometres2Angstroms(state.minWavelength);
@@ -38,68 +40,47 @@ export default function BeampropertiesDataEntry() {
     return state.maxWavelength;
   });
 
-  const cameraLength = useBeamlineConfigStore((state) => state.cameraLength);
-  const minCameraLength = useBeamlineConfigStore(
-    (state) => state.minCameraLength,
-  );
-  const maxCameraLength = useBeamlineConfigStore(
-    (state) => state.maxCameraLength,
-  );
-
-  const energy = useBeamlineConfigStore((state) => state.energy);
-  const energyUnits = useBeamlineConfigStore((state) => state.beamEnergyUnits);
-
-  const updateConfig = useBeamlineConfigStore((state) => state.update);
-
-  const angle = useBeamlineConfigStore((state) => state.angle);
-  const angleUnits = useBeamlineConfigStore((state) => state.angleUnits);
-
   const handleAngleUnits = (event: SelectChangeEvent<AngleUnits>) => {
     const newUnits = event.target.value as AngleUnits;
-    let newAngle = angle;
+    let newAngle = beamlineConfig.angle;
 
     if (
       newAngle !== null &&
       newUnits === AngleUnits.degrees &&
-      angleUnits === AngleUnits.radians
+      beamlineConfig.angleUnits === AngleUnits.radians
     ) {
       newAngle = MathUtils.radToDeg(newAngle);
     } else if (
       newAngle !== null &&
       newUnits === AngleUnits.radians &&
-      angleUnits === AngleUnits.degrees
+      beamlineConfig.angleUnits === AngleUnits.degrees
     ) {
       newAngle = MathUtils.degToRad(newAngle);
     }
-    updateConfig({
+    beamlineConfig.update({
       angle: newAngle,
       angleUnits: newUnits,
     });
   };
 
   const handleAngle = (event: React.ChangeEvent<HTMLInputElement>) => {
-    updateConfig({ angle: parseNumericInput(event.target.value) });
+    beamlineConfig.update({ angle: parseNumericInput(event.target.value) });
   };
 
-  const wavelength = useBeamlineConfigStore((state) => state.wavelength);
-  const wavelengthUnits = useBeamlineConfigStore(
-    (state) => state.wavelengthUnits,
-  );
-
   const handleWavelength = (event: React.ChangeEvent<HTMLInputElement>) => {
     const newWavelength = parseNumericInput(event.target.value);
     let newEnergy: number | null = null;
 
     if (newWavelength === null) {
-      updateConfig({
+      beamlineConfig.update({
         energy: newEnergy,
         wavelength: newWavelength,
       });
       return;
     }
 
     // account for wavelength units
-    if (wavelengthUnits === WavelengthUnits.angstroms) {
+    if (beamlineConfig.wavelengthUnits === WavelengthUnits.angstroms) {
       newEnergy = wavelength2EnergyConverter(
         angstroms2Nanometres(newWavelength),
       );
@@ -108,33 +89,33 @@ export default function BeampropertiesDataEntry() {
     }
 
     // account for energy units
-    if (energyUnits === EnergyUnits.electronVolts) {
+    if (beamlineConfig.beamEnergyUnits === EnergyUnits.electronVolts) {
       newEnergy = electronVots2KiloElectronVolts(newEnergy);
     }
 
-    updateConfig({
+    beamlineConfig.update({
       energy: newEnergy,
       wavelength: newWavelength,
     });
   };
 
   const handleWavelengthUnits = (event: SelectChangeEvent<WavelengthUnits>) => {
     const newUnits = event.target.value as WavelengthUnits;
-    let newWavelength = wavelength;
+    let newWavelength = beamlineConfig.wavelength;
     if (
       newWavelength !== null &&
       newUnits === WavelengthUnits.angstroms &&
-      wavelengthUnits === WavelengthUnits.nanmometres
+      beamlineConfig.wavelengthUnits === WavelengthUnits.nanmometres
     ) {
       newWavelength = nanometres2Angstroms(newWavelength);
     } else if (
       newWavelength !== null &&
       newUnits === WavelengthUnits.nanmometres &&
-      wavelengthUnits === WavelengthUnits.angstroms
+      beamlineConfig.wavelengthUnits === WavelengthUnits.angstroms
     ) {
       newWavelength = angstroms2Nanometres(newWavelength);
     }
-    updateConfig({
+    beamlineConfig.update({
       wavelength: newWavelength,
       wavelengthUnits: newUnits,
     });
@@ -145,55 +126,55 @@ export default function BeampropertiesDataEntry() {
     let newWavelength: number | null = null;
 
     if (newEnergy === null) {
-      updateConfig({
+      beamlineConfig.update({
         energy: newEnergy,
         wavelength: newWavelength,
       });
       return;
     }
 
-    if (energyUnits === EnergyUnits.electronVolts) {
+    if (beamlineConfig.beamEnergyUnits === EnergyUnits.electronVolts) {
       newWavelength = energy2WavelengthConverter(
         electronVots2KiloElectronVolts(newEnergy),
       );
     } else {
       newWavelength = energy2WavelengthConverter(newEnergy);
     }
 
-    if (wavelengthUnits === WavelengthUnits.angstroms) {
+    if (beamlineConfig.wavelengthUnits === WavelengthUnits.angstroms) {
       newWavelength = angstroms2Nanometres(newWavelength);
     }
 
-    updateConfig({
+    beamlineConfig.update({
       energy: newEnergy,
       wavelength: newWavelength,
     });
   };
 
   const handleEnergyUnits = (event: SelectChangeEvent<EnergyUnits>) => {
     const newUnits = event.target.value as EnergyUnits;
-    let newEnergy = energy;
+    let newEnergy = beamlineConfig.energy;
     if (
       newEnergy !== null &&
       newUnits === EnergyUnits.electronVolts &&
-      energyUnits === EnergyUnits.kiloElectronVolts
+      beamlineConfig.beamEnergyUnits === EnergyUnits.kiloElectronVolts
     ) {
       newEnergy = kiloElectronVolts2ElectronVots(newEnergy);
     } else if (
       newEnergy != null &&
       newUnits === EnergyUnits.kiloElectronVolts &&
-      energyUnits === EnergyUnits.electronVolts
+      beamlineConfig.beamEnergyUnits === EnergyUnits.electronVolts
     ) {
       newEnergy = electronVots2KiloElectronVolts(newEnergy);
     }
-    updateConfig({
+    beamlineConfig.update({
       energy: newEnergy,
       beamEnergyUnits: event.target.value as EnergyUnits,
     });
   };
 
   const handleCameraLength = (event: React.ChangeEvent<HTMLInputElement>) => {
-    updateConfig({
+    beamlineConfig.update({
       cameraLength: parseNumericInput(event.target.value),
     });
   };
@@ -206,15 +187,15 @@ export default function BeampropertiesDataEntry() {
         <TextField
           type="number"
           size="small"
-          value={energy}
+          value={beamlineConfig.energy}
           onChange={handleEnergy}
         />
         <FormControl>
           <InputLabel>units</InputLabel>
           <Select
             size="small"
             label="units"
-            value={energyUnits}
+            value={beamlineConfig.beamEnergyUnits}
             onChange={handleEnergyUnits}
           >
             <MenuItem value={EnergyUnits.electronVolts}>
@@ -231,15 +212,15 @@ export default function BeampropertiesDataEntry() {
         <TextField
           type="number"
           size="small"
-          value={wavelength}
+          value={beamlineConfig.wavelength}
           onChange={handleWavelength}
         />
         <FormControl>
           <InputLabel>units</InputLabel>
           <Select
             size="small"
             label="units"
-            value={wavelengthUnits}
+            value={beamlineConfig.wavelengthUnits}
             onChange={handleWavelengthUnits}
           >
             <MenuItem value={WavelengthUnits.nanmometres}>
@@ -252,21 +233,24 @@ export default function BeampropertiesDataEntry() {
         </FormControl>
       </Stack>
       <Typography>
-        Minimum allowed wavelength: {minWavelength} {wavelengthUnits}{" "}
+        Minimum allowed wavelength: {minWavelength}{" "}
+        {beamlineConfig.wavelengthUnits}{" "}
       </Typography>
       <Typography>
-        Maximum allowed wavelength: {maxWavelength} {wavelengthUnits}
+        Maximum allowed wavelength: {maxWavelength}{" "}
+        {beamlineConfig.wavelengthUnits}
       </Typography>
       <Stack direction="row" spacing={1}>
         <Typography>Camera Length: </Typography>
         <TextField
           type="number"
           size="small"
-          value={cameraLength}
+          value={beamlineConfig.cameraLength}
           InputProps={{
             inputProps: {
-              max: maxCameraLength,
-              min: minCameraLength,
+              max: beamlineConfig.maxCameraLength,
+              min: beamlineConfig.minCameraLength,
+              step: beamlineConfig.cameraLengthStep,
             },
           }}
           onChange={handleCameraLength}
@@ -279,15 +263,15 @@ export default function BeampropertiesDataEntry() {
           type="number"
           size="small"
           defaultValue={""}
-          value={angle ?? ""}
+          value={beamlineConfig.angle ?? ""}
           onChange={handleAngle}
         />
         <FormControl>
           <InputLabel>units</InputLabel>
           <Select
             size="small"
             label="units"
-            value={angleUnits}
+            value={beamlineConfig.angleUnits}
             onChange={handleAngleUnits}
           >
             <MenuItem value={AngleUnits.radians}>{AngleUnits.radians}</MenuItem>

src/data-entry/beamlineconfigStore.ts

@@ -20,6 +20,7 @@ export const useBeamlineConfigStore = create<BeamlineConfigStore>((set) => ({
   maxWavelength: defaultConfig.maxWavelength,
   minCameraLength: defaultConfig.minCameraLength,
   maxCameraLength: defaultConfig.maxCameraLength,
+  cameraLengthStep: defaultConfig.cameraLengthStep,
   energy: null,
   wavelength: null,
   beamEnergyUnits: EnergyUnits.kiloElectronVolts,