diff --git a/opossum/examples/ghost_focus.rs b/opossum/examples/ghost_focus.rs
index 424d1745205ad1a39df7890382c10439cfce26ca..52e1a1156bade2d3ad17e61d4c9daaa17c66510f 100644
--- a/opossum/examples/ghost_focus.rs
+++ b/opossum/examples/ghost_focus.rs
@@ -1,10 +1,13 @@
use opossum::{
- analyzers::{AnalyzerType, GhostFocusConfig},
+ analyzers::{AnalyzerType, GhostFocusConfig, RayTraceConfig},
coatings::CoatingType,
degree,
error::OpmResult,
joule, millimeter,
- nodes::{round_collimated_ray_source, Lens, NodeGroup, SpotDiagram, Wedge},
+ nodes::{
+ collimated_line_ray_source, round_collimated_ray_source, Lens, NodeGroup, SpotDiagram,
+ Wedge,
+ },
optic_node::{Alignable, OpticNode},
optic_ports::PortType,
refractive_index::RefrIndexConst,
@@ -15,8 +18,8 @@ use std::path::Path;
fn main() -> OpmResult<()> {
let mut scenery = NodeGroup::default();
let i_src = scenery.add_node(
- // collimated_line_ray_source(millimeter!(50.), joule!(1.), 3)?
- round_collimated_ray_source(millimeter!(50.0), joule!(1.0), 5)?,
+ // collimated_line_ray_source(millimeter!(50.), joule!(1.), 100)?
+ round_collimated_ray_source(millimeter!(50.0), joule!(1.0), 7)?,
)?;
let i_sd = scenery.add_node(SpotDiagram::default())?;
@@ -45,7 +48,8 @@ fn main() -> OpmResult<()> {
let mut doc = OpmDocument::new(scenery);
let mut config = GhostFocusConfig::default();
- config.set_max_bounces(2);
+ config.set_max_bounces(1);
doc.add_analyzer(AnalyzerType::GhostFocus(config));
+ // doc.add_analyzer(AnalyzerType::RayTrace(RayTraceConfig::default()));
doc.save_to_file(Path::new("./opossum/playground/ghost_focus.opm"))
}
diff --git a/opossum/src/analyzers/analyzable.rs b/opossum/src/analyzers/analyzable.rs
index 21f08f1026bc21a7e555c0d96e7a9286d8d527ee..b87f97471f21a04bb267652b661b642ba738ad61 100644
--- a/opossum/src/analyzers/analyzable.rs
+++ b/opossum/src/analyzers/analyzable.rs
@@ -1,15 +1,45 @@
//! Marker trait for an optical node that can be analyzed
+
use crate::{
analyzers::{
energy::AnalysisEnergy, ghostfocus::AnalysisGhostFocus, raytrace::AnalysisRayTrace,
},
+ error::{OpmResult, OpossumError},
optic_node::OpticNode,
+ optic_ports::PortType,
+ surface::Surface,
+ utils::geom_transformation::Isometry,
};
use core::fmt::Debug;
use std::fmt::Display;
/// Marker trait for an optical node that can be analyzed
-pub trait Analyzable: OpticNode + AnalysisEnergy + AnalysisRayTrace + AnalysisGhostFocus {}
+pub trait Analyzable:
+ OpticNode + AnalysisEnergy + AnalysisRayTrace + AnalysisGhostFocus + Surface
+{
+ ///Sets the coating and isometry of this surface
+ /// # Errors
+ /// This function errors if the coating cannot be accessed
+ fn set_surface_iso_and_coating(
+ &mut self,
+ port_str: &str,
+ iso: &Isometry,
+ port_type: &PortType,
+ ) -> OpmResult<()> {
+ let node_attr = self.node_attr().clone();
+
+ let input_surf = self.get_surface_mut(port_str);
+ input_surf.set_isometry(iso);
+ input_surf.set_coating(
+ node_attr
+ .ports()
+ .coating(port_type, port_str)
+ .ok_or_else(|| OpossumError::Other("cannot access coating!".into()))?
+ .clone(),
+ );
+ Ok(())
+ }
+}
impl Debug for dyn Analyzable {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
Display::fmt(&self, f)
diff --git a/opossum/src/analyzers/ghostfocus.rs b/opossum/src/analyzers/ghostfocus.rs
index 825013033b0a6e8569b8a4914b318df95c85c7c3..578d0bca951a76674454e486da4317d1f41f707a 100644
--- a/opossum/src/analyzers/ghostfocus.rs
+++ b/opossum/src/analyzers/ghostfocus.rs
@@ -16,7 +16,7 @@ use crate::{
plottable::{PlotArgs, PlotData, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
rays::Rays,
- reporting::analysis_report::{AnalysisReport, NodeReport},
+ reporting::{analysis_report::AnalysisReport, node_report::NodeReport},
};
use super::{raytrace::AnalysisRayTrace, Analyzer, RayTraceConfig};
@@ -76,6 +76,7 @@ impl Analyzer for GhostFocusAnalyzer {
"Performing ghost focus analysis of scenery{scenery_name} up to {} ray bounces.",
self.config.max_bounces
);
+ scenery.clear_edges();
for bounce in 0..=self.config.max_bounces {
let mut ray_collection = Vec::<Rays>::new();
if bounce % 2 == 0 {
@@ -90,6 +91,7 @@ impl Analyzer for GhostFocusAnalyzer {
LightRays::default(),
self.config(),
&mut ray_collection,
+ bounce,
)?;
scenery.clear_edges();
for rays in &ray_collection {
@@ -142,6 +144,7 @@ pub trait AnalysisGhostFocus: OpticNode + AnalysisRayTrace {
_incoming_data: LightRays,
_config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
warn!(
"{}: No ghost focus analysis function defined.",
@@ -155,7 +158,7 @@ pub trait AnalysisGhostFocus: OpticNode + AnalysisRayTrace {
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct GhostFocusHistory {
/// vector of ray positions for each raybundle at a specifc spectral position
- pub rays_pos_history: Vec<Vec<MatrixXx3<Length>>>,
+ pub rays_pos_history: Vec<Vec<Vec<MatrixXx3<Length>>>>,
/// view direction if the rayposition thistory is plotted
pub plot_view_direction: Option<Vector3<f64>>,
}
@@ -171,7 +174,7 @@ impl GhostFocusHistory {
pub fn project_to_plane(
&self,
plane_normal_vec: Vector3<f64>,
- ) -> OpmResult<Vec<Vec<MatrixXx2<Length>>>> {
+ ) -> OpmResult<Vec<Vec<Vec<MatrixXx2<Length>>>>> {
let vec_norm = plane_normal_vec.norm();
if vec_norm < f64::EPSILON {
@@ -203,41 +206,54 @@ impl GhostFocusHistory {
};
let mut projected_history =
- Vec::<Vec<MatrixXx2<Length>>>::with_capacity(self.rays_pos_history.len());
- for ray_bundle in &self.rays_pos_history {
- let mut rays_pos_projection = Vec::<MatrixXx2<Length>>::with_capacity(ray_bundle.len());
- for ray_pos in ray_bundle {
- let mut projected_ray_pos = MatrixXx2::<Length>::zeros(ray_pos.column(0).len());
- for (row, pos) in ray_pos.row_iter().enumerate() {
- // let pos_t = Vector3::from_vec(pos.transpose().iter().map(|p| p.get::<millimeter>()).collect::<Vec<f64>>());
- let pos_t = Vector3::from_vec(
- pos.iter()
- .map(uom::si::f64::Length::get::<millimeter>)
- .collect::<Vec<f64>>(),
- );
- let proj_pos = pos_t - pos_t.dot(&normed_normal_vec) * plane_normal_vec;
+ Vec::<Vec<Vec<MatrixXx2<Length>>>>::with_capacity(self.rays_pos_history.len());
+ for ray_vec_in_bounce in &self.rays_pos_history {
+ let mut rays_vec_pos_projection =
+ Vec::<Vec<MatrixXx2<Length>>>::with_capacity(ray_vec_in_bounce.len());
+ for ray_bundle in ray_vec_in_bounce {
+ let mut rays_pos_projection =
+ Vec::<MatrixXx2<Length>>::with_capacity(ray_bundle.len());
+ for ray_pos in ray_bundle {
+ let mut projected_ray_pos = MatrixXx2::<Length>::zeros(ray_pos.column(0).len());
+ for (row, pos) in ray_pos.row_iter().enumerate() {
+ // let pos_t = Vector3::from_vec(pos.transpose().iter().map(|p| p.get::<millimeter>()).collect::<Vec<f64>>());
+ let pos_t = Vector3::from_vec(
+ pos.iter()
+ .map(uom::si::f64::Length::get::<millimeter>)
+ .collect::<Vec<f64>>(),
+ );
+ let proj_pos = pos_t - pos_t.dot(&normed_normal_vec) * plane_normal_vec;
- projected_ray_pos[(row, 0)] = millimeter!(proj_pos.dot(&co_ax_1));
- projected_ray_pos[(row, 1)] = millimeter!(proj_pos.dot(&co_ax_2));
+ projected_ray_pos[(row, 0)] = millimeter!(proj_pos.dot(&co_ax_1));
+ projected_ray_pos[(row, 1)] = millimeter!(proj_pos.dot(&co_ax_2));
+ }
+ rays_pos_projection.push(projected_ray_pos);
}
- rays_pos_projection.push(projected_ray_pos);
+ rays_vec_pos_projection.push(rays_pos_projection);
}
- projected_history.push(rays_pos_projection);
+ projected_history.push(rays_vec_pos_projection);
}
Ok(projected_history)
}
}
-impl From<Vec<Rays>> for GhostFocusHistory {
- fn from(value: Vec<Rays>) -> Self {
- let mut ghost_focus_history = Vec::<Vec<MatrixXx3<Length>>>::with_capacity(value.len());
- for rays in &value {
- let mut rays_history = Vec::<MatrixXx3<Length>>::with_capacity(rays.nr_of_rays(false));
- for ray in rays {
- rays_history.push(ray.position_history());
+impl From<Vec<Vec<Rays>>> for GhostFocusHistory {
+ fn from(value: Vec<Vec<Rays>>) -> Self {
+ let mut ghost_focus_history =
+ Vec::<Vec<Vec<MatrixXx3<Length>>>>::with_capacity(value.len());
+ for ray_vecs_in_bounce in &value {
+ let mut rays_per_bounce_history =
+ Vec::<Vec<MatrixXx3<Length>>>::with_capacity(ray_vecs_in_bounce.len());
+ for rays in ray_vecs_in_bounce {
+ let mut rays_history =
+ Vec::<MatrixXx3<Length>>::with_capacity(rays.nr_of_rays(false));
+ for ray in rays {
+ rays_history.push(ray.position_history());
+ }
+ rays_per_bounce_history.push(rays_history);
}
- ghost_focus_history.push(rays_history);
+ ghost_focus_history.push(rays_per_bounce_history);
}
Self {
rays_pos_history: ghost_focus_history,
@@ -281,15 +297,16 @@ impl Plottable for GhostFocusHistory {
for (i, bounce_positions) in projected_positions.iter().enumerate() {
let mut proj_pos_mm =
Vec::<MatrixXx2<f64>>::with_capacity(projected_positions.len());
- for ray_pos in bounce_positions {
- proj_pos_mm.push(MatrixXx2::from_vec(
- ray_pos
- .iter()
- .map(uom::si::f64::Length::get::<millimeter>)
- .collect::<Vec<f64>>(),
- ));
+ for rays_in_bounce in bounce_positions {
+ for ray_pos in rays_in_bounce {
+ proj_pos_mm.push(MatrixXx2::from_vec(
+ ray_pos
+ .iter()
+ .map(uom::si::f64::Length::get::<millimeter>)
+ .collect::<Vec<f64>>(),
+ ));
+ }
}
-
let gradient = colorous::TURBO;
let c = if projected_positions.len() > 10 {
diff --git a/opossum/src/analyzers/raytrace.rs b/opossum/src/analyzers/raytrace.rs
index e18b2fcb402c5c417e27c0e18d5f19e97d92051c..496cdfd5f8cfe3303f39a6795ace86a302904a7a 100644
--- a/opossum/src/analyzers/raytrace.rs
+++ b/opossum/src/analyzers/raytrace.rs
@@ -1,16 +1,24 @@
//! Analyzer for sequential ray tracing
-use super::Analyzer;
+use super::{Analyzer, AnalyzerType};
use crate::{
+ degree,
error::{OpmResult, OpossumError},
light_result::LightResult,
- nodes::NodeGroup,
+ lightdata::LightData,
+ nodes::{NodeAttr, NodeGroup},
optic_node::OpticNode,
+ optic_ports::PortType,
picojoule,
+ properties::Proptype,
+ rays::Rays,
+ refractive_index::RefractiveIndexType,
reporting::analysis_report::AnalysisReport,
+ surface::Surface,
+ utils::geom_transformation::Isometry,
};
use log::info;
use serde::{Deserialize, Serialize};
-use uom::si::f64::Energy;
+use uom::si::f64::{Angle, Energy, Length};
//pub type LightResRays = LightDings<Rays>;
@@ -47,7 +55,7 @@ impl Analyzer for RayTracingAnalyzer {
}
}
/// Trait for implementing the ray trace analysis.
-pub trait AnalysisRayTrace: OpticNode {
+pub trait AnalysisRayTrace: OpticNode + Surface {
/// Perform a ray trace analysis an [`OpticNode`].
///
/// # Errors
@@ -73,6 +81,179 @@ pub trait AnalysisRayTrace: OpticNode {
) -> OpmResult<LightResult> {
self.analyze(incoming_data, config)
}
+
+ /// Pass a bundle of rays through an "input"-surface: Rays from outside a node which enter the node.
+ /// # Errors
+ /// This function errors on error propagation
+ fn enter_through_surface(
+ &mut self,
+ rays_bundle: &mut Vec<Rays>,
+ analyzer_type: &AnalyzerType,
+ refri: &RefractiveIndexType,
+ backward: bool,
+ port_name: &str,
+ ) -> OpmResult<()> {
+ if backward {
+ for rays in &mut *rays_bundle {
+ if let Some(aperture) = self.ports().aperture(&PortType::Input, port_name) {
+ rays.apodize(aperture)?;
+ if let AnalyzerType::RayTrace(ref config) = analyzer_type {
+ rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
+ }
+ } else {
+ return Err(OpossumError::OpticPort("output aperture not found".into()));
+ };
+ let surf = self.get_surface_mut(port_name);
+ let reflected_rear = rays.refract_on_surface(surf, Some(refri))?;
+ surf.add_to_forward_rays_cache(reflected_rear);
+ }
+ for rays in self.get_surface_mut(port_name).backwards_rays_cache() {
+ rays_bundle.push(rays.clone());
+ }
+ } else {
+ for rays in &mut *rays_bundle {
+ if let Some(aperture) = self.ports().aperture(&PortType::Input, port_name) {
+ rays.apodize(aperture)?;
+ if let AnalyzerType::RayTrace(ref config) = analyzer_type {
+ rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
+ }
+ } else {
+ return Err(OpossumError::OpticPort("input aperture not found".into()));
+ };
+ let surf = self.get_surface_mut(port_name);
+ let reflected_front = rays.refract_on_surface(surf, Some(refri))?;
+ surf.add_to_backward_rays_cache(reflected_front);
+ }
+ for rays in self.get_surface_mut(port_name).forward_rays_cache() {
+ rays_bundle.push(rays.clone());
+ }
+ }
+ Ok(())
+ }
+
+ /// Pass a bundle of rays through an "exit"-surface: rays from inside a node which leave the node.
+ /// # Errors
+ /// this function errors on error propagation
+ fn exit_through_surface(
+ &mut self,
+ rays_bundle: &mut Vec<Rays>,
+ analyzer_type: &AnalyzerType,
+ refri: &RefractiveIndexType,
+ backward: bool,
+ port_name: &str,
+ ) -> OpmResult<()> {
+ let surf = self.get_surface_mut(port_name);
+ if backward {
+ for rays in &mut *rays_bundle {
+ let reflected_front = rays.refract_on_surface(surf, Some(refri))?;
+ surf.add_to_forward_rays_cache(reflected_front);
+ }
+ for rays in surf.backwards_rays_cache() {
+ rays_bundle.push(rays.clone());
+ }
+ for rays in &mut *rays_bundle {
+ if let Some(aperture) = self.ports().aperture(&PortType::Output, port_name) {
+ rays.apodize(aperture)?;
+ if let AnalyzerType::RayTrace(config) = analyzer_type {
+ rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
+ }
+ } else {
+ return Err(OpossumError::OpticPort("input aperture not found".into()));
+ };
+ }
+ } else {
+ for rays in &mut *rays_bundle {
+ let reflected_rear = rays.refract_on_surface(surf, Some(refri))?;
+ surf.add_to_backward_rays_cache(reflected_rear);
+ }
+ for rays in surf.forward_rays_cache() {
+ rays_bundle.push(rays.clone());
+ }
+ for rays in &mut *rays_bundle {
+ if let Some(aperture) = self.ports().aperture(&PortType::Output, port_name) {
+ rays.apodize(aperture)?;
+ if let AnalyzerType::RayTrace(config) = analyzer_type {
+ rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
+ }
+ } else {
+ return Err(OpossumError::OpticPort("output aperture not found".into()));
+ };
+ }
+ }
+ Ok(())
+ }
+
+ /// Function to pass a bundle of rays through an "inert" surface.
+ /// Here, "inert" refers to a surface that does not mutate the rays in a sense of refraction or reflection, but only adds a new position to its history.
+ /// This functionis used for the propagation through ideal detectors, such as a spot diagram
+ /// # Errors
+ /// This function errors if the effective isometry is not defined
+ fn pass_through_inert_surface(&mut self, rays_bundle: &mut Vec<Rays>) -> OpmResult<()> {
+ if let Some(iso) = self.effective_iso() {
+ let surf = self.get_surface_mut("");
+ surf.set_isometry(&iso);
+ for rays in &mut *rays_bundle {
+ rays.refract_on_surface(surf, None)?;
+ }
+ } else {
+ return Err(OpossumError::Analysis(
+ "no location for surface defined. Aborting".into(),
+ ));
+ }
+ // merge all rays
+ if let Some(ld) = self.get_light_data_mut() {
+ if let LightData::GhostFocus(rays) = ld {
+ for r in rays_bundle {
+ rays.push(r.clone());
+ }
+ }
+ } else {
+ self.set_light_data(LightData::GhostFocus(rays_bundle.clone()));
+ }
+ Ok(())
+ }
+
+ ///returns a mutable reference to the light data.
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ None
+ }
+
+ ///sets the light data field of this detector
+ fn set_light_data(&mut self, _ld: LightData) {}
+
+ ///returns the necessary node attributes for ray tracing
+ /// # Errors
+ /// This function errors if the node attributes: Isometry, Refractive Index or Center Thickness cannot be read,
+ fn get_node_attributes_ray_trace(
+ &self,
+ node_attr: &NodeAttr,
+ ) -> OpmResult<(Isometry, RefractiveIndexType, Length, Angle)> {
+ let Some(eff_iso) = self.effective_iso() else {
+ return Err(OpossumError::Analysis(
+ "no location for surface defined".into(),
+ ));
+ };
+ let Ok(Proptype::RefractiveIndex(index_model)) = node_attr.get_property("refractive index")
+ else {
+ return Err(OpossumError::Analysis(
+ "cannot read refractive index".into(),
+ ));
+ };
+ let Ok(Proptype::Length(center_thickness)) = node_attr.get_property("center thickness")
+ else {
+ return Err(OpossumError::Analysis(
+ "cannot read center thickness".into(),
+ ));
+ };
+
+ let angle = if let Ok(Proptype::Angle(wedge)) = node_attr.get_property("wedge") {
+ *wedge
+ } else {
+ degree!(0.)
+ };
+
+ Ok((eff_iso, index_model.value.clone(), *center_thickness, angle))
+ }
}
// /// enum to define the mode of the raytracing analysis.
// /// Currently only sequential mode
diff --git a/opossum/src/light_result.rs b/opossum/src/light_result.rs
index 5e1de543b9587c47d2ffdf5581ad7f803850bb05..2bdf858afcefae47968ec349a39e53e56b4936ca 100644
--- a/opossum/src/light_result.rs
+++ b/opossum/src/light_result.rs
@@ -11,13 +11,13 @@ pub type LightDings<T> = HashMap<String, T>;
pub type LightResult = LightDings<LightData>;
-pub type LightRays = LightDings<Rays>;
+pub type LightRays = LightDings<Vec<Rays>>;
//pub type LightBouncingRays = LightDings<Vec<Rays>>;
pub fn light_result_to_light_rays(light_result: LightResult) -> OpmResult<LightRays> {
- let mut light_dings_rays = LightDings::<Rays>::new();
+ let mut light_dings_rays = LightDings::<Vec<Rays>>::new();
for lr in light_result {
- let LightData::Geometric(r) = lr.1 else {
+ let LightData::GhostFocus(r) = lr.1 else {
return Err(OpossumError::Other(
"no geometric rays data found in LightResult".into(),
));
@@ -30,7 +30,7 @@ pub fn light_result_to_light_rays(light_result: LightResult) -> OpmResult<LightR
pub fn light_rays_to_light_result(light_rays: LightRays) -> LightResult {
let mut light_result = LightResult::default();
for ld in light_rays {
- light_result.insert(ld.0, LightData::Geometric(ld.1));
+ light_result.insert(ld.0, LightData::GhostFocus(ld.1));
}
light_result
}
diff --git a/opossum/src/lightdata.rs b/opossum/src/lightdata.rs
index 2971dd0d2a46fafbeadb193c1bc30e05e8c2a4ca..1e3b1d475078b23d0738225d36ca379058fc1340 100644
--- a/opossum/src/lightdata.rs
+++ b/opossum/src/lightdata.rs
@@ -16,6 +16,8 @@ pub enum LightData {
Energy(DataEnergy),
/// data type used for geometric optics analysis (ray tracing)
Geometric(Rays),
+ /// data type used for ghost focus analysis (back- and forth ray-tracing)
+ GhostFocus(Vec<Rays>),
/// placeholder value for future Fourier optics analysis, nothing implementd yet.
Fourier,
}
diff --git a/opossum/src/nodes/beam_splitter.rs b/opossum/src/nodes/beam_splitter.rs
index 17eded3ee21630d42ac508c3743bdde9612d808b..ef1463d0be04ac9acf19b822af80ba0174cf47a3 100644
--- a/opossum/src/nodes/beam_splitter.rs
+++ b/opossum/src/nodes/beam_splitter.rs
@@ -15,7 +15,7 @@ use crate::{
ray::SplittingConfig,
rays::Rays,
spectrum::{merge_spectra, Spectrum},
- surface::{OpticalSurface, Plane},
+ surface::{OpticalSurface, Plane, Surface},
utils::EnumProxy,
};
@@ -301,6 +301,11 @@ impl Dottable for BeamSplitter {
"lightpink"
}
}
+impl Surface for BeamSplitter {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl Analyzable for BeamSplitter {}
impl AnalysisGhostFocus for BeamSplitter {}
impl AnalysisEnergy for BeamSplitter {
diff --git a/opossum/src/nodes/cylindric_lens/analysis_ghostfocus.rs b/opossum/src/nodes/cylindric_lens/analysis_ghostfocus.rs
index 72a1bdf9d301775d64955058fac50b811996a17c..2749990c60f5f074fb1a3a3644142e704fd32dce 100644
--- a/opossum/src/nodes/cylindric_lens/analysis_ghostfocus.rs
+++ b/opossum/src/nodes/cylindric_lens/analysis_ghostfocus.rs
@@ -1,10 +1,14 @@
use crate::{
- analyzers::{ghostfocus::AnalysisGhostFocus, AnalyzerType, GhostFocusConfig, RayTraceConfig},
- error::{OpmResult, OpossumError},
+ analyzers::{
+ ghostfocus::AnalysisGhostFocus, raytrace::AnalysisRayTrace, Analyzable, AnalyzerType,
+ GhostFocusConfig,
+ },
+ error::OpmResult,
light_result::LightRays,
optic_node::OpticNode,
- properties::Proptype,
+ optic_ports::PortType,
rays::Rays,
+ utils::geom_transformation::Isometry,
};
use super::CylindricLens;
@@ -13,56 +17,54 @@ impl AnalysisGhostFocus for CylindricLens {
fn analyze(
&mut self,
incoming_data: LightRays,
- _config: &GhostFocusConfig,
+ config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
+ let (eff_iso, refri, center_thickness, _) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
+ let thickness_iso = Isometry::new_along_z(center_thickness)?;
+
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
} else {
- ("front", "rear")
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
};
+
let Some(incoming_rays) = incoming_data.get(in_port) else {
return Ok(LightRays::default());
};
- let rays = incoming_rays;
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays.clone(),
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
- } else {
- self.analyze_forward(
- rays.clone(),
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
- };
+ let mut rays_bundle = incoming_rays.clone();
+
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
let mut out_light_rays = LightRays::default();
- out_light_rays.insert(out_port.to_string(), output);
+ out_light_rays.insert(out_port.to_string(), rays_bundle);
Ok(out_light_rays)
}
}
diff --git a/opossum/src/nodes/cylindric_lens/analysis_raytrace.rs b/opossum/src/nodes/cylindric_lens/analysis_raytrace.rs
index 74856a11300d6829c3c93fb0d9faa2d25b48a0f8..f30adebff21538312b0f4a09e7c66725e282c9e2 100644
--- a/opossum/src/nodes/cylindric_lens/analysis_raytrace.rs
+++ b/opossum/src/nodes/cylindric_lens/analysis_raytrace.rs
@@ -1,70 +1,73 @@
-use crate::{
- analyzers::{raytrace::AnalysisRayTrace, AnalyzerType, RayTraceConfig},
- error::{OpmResult, OpossumError},
- light_result::LightResult,
- lightdata::LightData,
- optic_node::OpticNode,
- properties::Proptype,
-};
-
-use super::CylindricLens;
-
-impl AnalysisRayTrace for CylindricLens {
- fn analyze(
- &mut self,
- incoming_data: LightResult,
- config: &RayTraceConfig,
- ) -> OpmResult<LightResult> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
- } else {
- ("front", "rear")
- };
- let Some(data) = incoming_data.get(in_port) else {
- return Ok(LightResult::default());
- };
- let LightData::Geometric(rays) = data.clone() else {
- return Err(OpossumError::Analysis(
- "expected ray data at input port".into(),
- ));
- };
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays,
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
- } else {
- self.analyze_forward(
- rays,
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
- };
- let light_result = LightResult::from([(out_port.into(), LightData::Geometric(output))]);
- Ok(light_result)
- }
-}
+use crate::{
+ analyzers::{raytrace::AnalysisRayTrace, Analyzable, AnalyzerType, RayTraceConfig},
+ error::{OpmResult, OpossumError},
+ light_result::LightResult,
+ lightdata::LightData,
+ optic_node::OpticNode,
+ optic_ports::PortType,
+ utils::geom_transformation::Isometry,
+};
+
+use super::CylindricLens;
+
+impl AnalysisRayTrace for CylindricLens {
+ fn analyze(
+ &mut self,
+ incoming_data: LightResult,
+ config: &RayTraceConfig,
+ ) -> OpmResult<LightResult> {
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
+
+ let Some(data) = incoming_data.get(in_port) else {
+ return Ok(LightResult::default());
+ };
+ let LightData::Geometric(rays) = data.clone() else {
+ return Err(OpossumError::Analysis(
+ "expected ray data at input port".into(),
+ ));
+ };
+
+ let (eff_iso, refri, center_thickness, _) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let thickness_iso = Isometry::new_along_z(center_thickness)?;
+
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
+ } else {
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
+ };
+
+ let mut rays_bundle = vec![rays];
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
+ let light_result = LightResult::from([(
+ out_port.into(),
+ LightData::Geometric(rays_bundle[0].clone()),
+ )]);
+ Ok(light_result)
+ }
+}
diff --git a/opossum/src/nodes/cylindric_lens/mod.rs b/opossum/src/nodes/cylindric_lens/mod.rs
index e4480ca4bd1a4a0a2e7ec9a0f18af7a11255f751..f0f0547fd045497212dfaba0be9d77b71841e380 100644
--- a/opossum/src/nodes/cylindric_lens/mod.rs
+++ b/opossum/src/nodes/cylindric_lens/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
use super::node_attr::NodeAttr;
use crate::{
- analyzers::{Analyzable, AnalyzerType},
+ analyzers::Analyzable,
dottable::Dottable,
error::{OpmResult, OpossumError},
millimeter,
@@ -13,7 +13,7 @@ use crate::{
properties::Proptype,
rays::Rays,
refractive_index::{RefrIndexConst, RefractiveIndex, RefractiveIndexType},
- surface::{hit_map::HitMap, Cylinder, OpticalSurface, Plane},
+ surface::{hit_map::HitMap, Cylinder, OpticalSurface, Plane, Surface},
utils::{geom_transformation::Isometry, EnumProxy},
};
#[cfg(feature = "bevy")]
@@ -176,123 +176,16 @@ impl CylindricLens {
};
Ok(())
}
- fn analyze_forward(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let isometry = iso.append(&thickness_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(refri))?;
- self.front_surf.set_backwards_rays_cache(reflected_front);
- rays.merge(self.front_surf.forward_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(&ambient_idx))?;
- self.rear_surf.set_backwards_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.forward_rays_cache());
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- Ok(rays)
- }
- fn analyze_inverse(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let isometry = iso.append(&thickness_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(refri))?;
- self.rear_surf.set_forward_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.backwards_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(&ambient_idx))?;
- self.front_surf.set_forward_rays_cache(reflected_front);
- rays.merge(self.front_surf.backwards_rays_cache());
-
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- Ok(rays)
- }
}
impl OpticNode for CylindricLens {
fn reset_data(&mut self) {
- self.front_surf.set_backwards_rays_cache(Rays::default());
- self.front_surf.set_forward_rays_cache(Rays::default());
+ self.front_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.front_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.front_surf.reset_hit_map();
- self.rear_surf.set_backwards_rays_cache(Rays::default());
- self.rear_surf.set_forward_rays_cache(Rays::default());
+ self.rear_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.rear_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.rear_surf.reset_hit_map();
}
@@ -320,6 +213,15 @@ impl Dottable for CylindricLens {
"aqua"
}
}
+impl Surface for CylindricLens {
+ fn get_surface_mut(&mut self, surf_name: &str) -> &mut OpticalSurface {
+ if surf_name == "front" {
+ &mut self.front_surf
+ } else {
+ &mut self.rear_surf
+ }
+ }
+}
impl Analyzable for CylindricLens {}
#[cfg(test)]
diff --git a/opossum/src/nodes/detector.rs b/opossum/src/nodes/detector.rs
index 1ed6f4613bc09d18225c4a131e5ec24bd4326b0c..4a0b3b3c002e29f913259ba8964644519c34b4b8 100644
--- a/opossum/src/nodes/detector.rs
+++ b/opossum/src/nodes/detector.rs
@@ -11,7 +11,7 @@ use crate::{
lightdata::LightData,
optic_node::OpticNode,
optic_ports::{OpticPorts, PortType},
- surface::{OpticalSurface, Plane},
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
use log::warn;
@@ -160,6 +160,18 @@ impl AnalysisRayTrace for Detector {
Ok(LightResult::from([(out_port.into(), data.clone())]))
}
}
+
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
+}
+impl Surface for Detector {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
}
#[cfg(test)]
mod test {
diff --git a/opossum/src/nodes/dummy.rs b/opossum/src/nodes/dummy.rs
index 1eb62a3873082aa5aeca4b1915a71e462fe04af6..38c85e1858de047b32463f589fd2678fde278490 100644
--- a/opossum/src/nodes/dummy.rs
+++ b/opossum/src/nodes/dummy.rs
@@ -11,8 +11,8 @@ use crate::{
lightdata::LightData,
optic_node::OpticNode,
optic_ports::{OpticPorts, PortType},
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
@@ -80,6 +80,11 @@ impl AnalysisEnergy for Dummy {
)
}
}
+impl Surface for Dummy {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl AnalysisRayTrace for Dummy {
fn analyze(
&mut self,
diff --git a/opossum/src/nodes/energy_meter.rs b/opossum/src/nodes/energy_meter.rs
index c2cdd6d5f3160fc633c6478bf7b0b7d8029c6716..0737cc6f6cd092609c824e05dd4bbb0d11009d4e 100644
--- a/opossum/src/nodes/energy_meter.rs
+++ b/opossum/src/nodes/energy_meter.rs
@@ -12,8 +12,8 @@ use crate::{
optic_node::OpticNode,
optic_ports::{OpticPorts, PortType},
properties::{Properties, Proptype},
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
use log::warn;
@@ -140,6 +140,13 @@ impl OpticNode for EnergyMeter {
LightData::Energy(e) => Some(joule!(e.spectrum.total_energy())),
LightData::Geometric(r) => Some(r.total_energy()),
LightData::Fourier => None,
+ LightData::GhostFocus(r) => {
+ let mut energy = joule!(0.);
+ for rays in r {
+ energy += rays.total_energy();
+ }
+ Some(energy)
+ }
};
};
let mut props = Properties::default();
@@ -189,7 +196,11 @@ impl OpticNode for EnergyMeter {
self.surface.reset_hit_map();
}
}
-
+impl Surface for EnergyMeter {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl Debug for EnergyMeter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.light_data {
@@ -269,6 +280,13 @@ impl AnalysisRayTrace for EnergyMeter {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
#[cfg(test)]
mod test {
diff --git a/opossum/src/nodes/fluence_detector.rs b/opossum/src/nodes/fluence_detector.rs
index 29d9d65d2f0a8f485605f88fb981df7d0fade528..1ba600ca179b02b801068e19171b5cf17086ba67 100644
--- a/opossum/src/nodes/fluence_detector.rs
+++ b/opossum/src/nodes/fluence_detector.rs
@@ -21,8 +21,8 @@ use crate::{
plottable::{PlotArgs, PlotData, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
rays::Rays,
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
@@ -46,7 +46,7 @@ pub type Fluence = uom::si::f64::RadiantExposure;
/// different dectector nodes can be "stacked" or used somewhere within the optical setup.
#[derive(Clone, Debug)]
pub struct FluenceDetector {
- light_data: Option<Rays>,
+ light_data: Option<LightData>,
node_attr: NodeAttr,
apodization_warning: bool,
surface: OpticalSurface,
@@ -78,6 +78,11 @@ impl FluenceDetector {
fld
}
}
+impl Surface for FluenceDetector {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl OpticNode for FluenceDetector {
// fn export_data(&self, report_dir: &Path, uuid: &str) -> OpmResult<()> {
// self.light_data.as_ref().map_or_else(
@@ -106,7 +111,7 @@ impl OpticNode for FluenceDetector {
fn node_report(&self, uuid: &str) -> Option<NodeReport> {
let mut props = Properties::default();
let data = &self.light_data;
- if let Some(rays) = data {
+ if let Some(LightData::Geometric(rays)) = data {
let fluence_data_res = rays.calc_fluence_at_position();
if let Ok(fluence_data) = fluence_data_res {
props
@@ -147,6 +152,12 @@ impl OpticNode for FluenceDetector {
}
}
}
+ // else if let Some(LightData::GhostFocus(v_rays)) = data{
+ // todo!()
+ // }
+ // else{
+ // todo!()
+ // }
Some(NodeReport::new(
&self.node_type(),
&self.name(),
@@ -178,31 +189,17 @@ impl AnalysisGhostFocus for FluenceDetector {
incoming_data: LightRays,
_config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("out1", "in1")
- } else {
- ("in1", "out1")
- };
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
let Some(bouncing_rays) = incoming_data.get(in_port) else {
- return Ok(LightRays::default());
+ let mut out_light_rays = LightRays::default();
+ out_light_rays.insert(out_port.into(), Vec::<Rays>::new());
+ return Ok(out_light_rays);
};
let mut rays = bouncing_rays.clone();
- if let Some(iso) = self.effective_iso() {
- self.surface.set_isometry(&iso);
- rays.refract_on_surface(&mut self.surface, None)?;
- } else {
- return Err(OpossumError::Analysis(
- "no location for surface defined. Aborting".into(),
- ));
- }
- // merge all rays
- let mut ray_cache = self
- .light_data
- .clone()
- .map_or_else(Rays::default, |rays| rays);
- ray_cache.merge(&rays);
- self.light_data = Some(ray_cache);
+ self.pass_through_inert_surface(&mut rays)?;
let mut out_light_rays = LightRays::default();
out_light_rays.insert(out_port.to_string(), rays.clone());
@@ -257,7 +254,7 @@ impl AnalysisRayTrace for FluenceDetector {
} else {
return Err(OpossumError::OpticPort("input aperture not found".into()));
};
- self.light_data = Some(rays.clone());
+ self.light_data = Some(LightData::Geometric(rays.clone()));
if let Some(aperture) = self.ports().aperture(&PortType::Output, outport) {
rays.apodize(aperture)?;
rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
@@ -272,6 +269,12 @@ impl AnalysisRayTrace for FluenceDetector {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
impl From<FluenceData> for Proptype {
@@ -528,17 +531,17 @@ mod test {
let node_props = node_report.properties();
let nr_of_props = node_props.iter().fold(0, |c, _p| c + 1);
assert_eq!(nr_of_props, 0);
- fd.light_data = Some(Rays::default());
+ fd.light_data = Some(LightData::Geometric(Rays::default()));
let node_report = fd.node_report("123").unwrap();
assert!(!node_report.properties().contains("Fluence"));
- fd.light_data = Some(
+ fd.light_data = Some(LightData::Geometric(
Rays::new_uniform_collimated(
nanometer!(1053.0),
joule!(1.0),
&Hexapolar::new(millimeter!(1.), 1).unwrap(),
)
.unwrap(),
- );
+ ));
let node_report = fd.node_report("123").unwrap();
assert!(node_report.properties().contains("Fluence"));
let node_props = node_report.properties();
diff --git a/opossum/src/nodes/ideal_filter.rs b/opossum/src/nodes/ideal_filter.rs
index a198c672f188fae6403bafaa4a21953ce8eb762b..15067d1cdad863ff25801e95e3c7d386d40efa77 100644
--- a/opossum/src/nodes/ideal_filter.rs
+++ b/opossum/src/nodes/ideal_filter.rs
@@ -13,7 +13,7 @@ use crate::{
optic_ports::{OpticPorts, PortType},
properties::Proptype,
spectrum::Spectrum,
- surface::{OpticalSurface, Plane},
+ surface::{OpticalSurface, Plane, Surface},
utils::{geom_transformation::Isometry, EnumProxy},
};
use serde::{Deserialize, Serialize};
@@ -209,6 +209,11 @@ impl AnalysisEnergy for IdealFilter {
}
}
}
+impl Surface for IdealFilter {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl AnalysisRayTrace for IdealFilter {
fn analyze(
&mut self,
diff --git a/opossum/src/nodes/lens/analysis_ghostfocus.rs b/opossum/src/nodes/lens/analysis_ghostfocus.rs
index e42d1c3b1278941e7daa30478f014604f8b7d0cf..b3a42a319bf87959e868622970808993ad773c1c 100644
--- a/opossum/src/nodes/lens/analysis_ghostfocus.rs
+++ b/opossum/src/nodes/lens/analysis_ghostfocus.rs
@@ -1,67 +1,69 @@
use super::Lens;
use crate::{
- analyzers::{ghostfocus::AnalysisGhostFocus, AnalyzerType, GhostFocusConfig, RayTraceConfig},
- error::{OpmResult, OpossumError},
+ analyzers::{
+ ghostfocus::AnalysisGhostFocus, raytrace::AnalysisRayTrace, Analyzable, AnalyzerType,
+ GhostFocusConfig,
+ },
+ error::OpmResult,
light_result::LightRays,
optic_node::OpticNode,
- properties::Proptype,
+ optic_ports::PortType,
rays::Rays,
+ utils::geom_transformation::Isometry,
};
impl AnalysisGhostFocus for Lens {
fn analyze(
&mut self,
incoming_data: LightRays,
- _config: &GhostFocusConfig,
+ config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
- } else {
- ("front", "rear")
- };
+ let (eff_iso, refri, center_thickness, _) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
let Some(incoming_rays) = incoming_data.get(in_port) else {
return Ok(LightRays::default());
};
- let rays = incoming_rays;
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays.clone(),
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
+ let thickness_iso: Isometry = Isometry::new_along_z(center_thickness)?;
+
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
} else {
- self.analyze_forward(
- rays.clone(),
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
};
+
+ let mut rays_bundle = incoming_rays.clone();
+
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
let mut out_light_rays = LightRays::default();
- out_light_rays.insert(out_port.to_string(), output);
+ out_light_rays.insert(out_port.to_string(), rays_bundle);
Ok(out_light_rays)
}
}
diff --git a/opossum/src/nodes/lens/analysis_raytrace.rs b/opossum/src/nodes/lens/analysis_raytrace.rs
index d3ad5111419a94359c782d97c08aee2da4959dec..9e67f9c5414de27047d02797a2fc8e4a3a0cd2f7 100644
--- a/opossum/src/nodes/lens/analysis_raytrace.rs
+++ b/opossum/src/nodes/lens/analysis_raytrace.rs
@@ -1,11 +1,12 @@
use super::Lens;
use crate::{
- analyzers::{raytrace::AnalysisRayTrace, AnalyzerType, RayTraceConfig},
+ analyzers::{raytrace::AnalysisRayTrace, Analyzable, AnalyzerType, RayTraceConfig},
error::{OpmResult, OpossumError},
light_result::LightResult,
lightdata::LightData,
optic_node::OpticNode,
- properties::Proptype,
+ optic_ports::PortType,
+ utils::geom_transformation::Isometry,
};
impl AnalysisRayTrace for Lens {
@@ -14,11 +15,9 @@ impl AnalysisRayTrace for Lens {
incoming_data: LightResult,
config: &RayTraceConfig,
) -> OpmResult<LightResult> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
- } else {
- ("front", "rear")
- };
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
+
let Some(data) = incoming_data.get(in_port) else {
return Ok(LightResult::default());
};
@@ -27,43 +26,47 @@ impl AnalysisRayTrace for Lens {
"expected ray data at input port".into(),
));
};
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays,
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
+
+ let (eff_iso, refri, center_thickness, _) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let thickness_iso = Isometry::new_along_z(center_thickness)?;
+
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
} else {
- self.analyze_forward(
- rays,
- *center_thickness,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso),
+ &PortType::Output,
+ )?;
};
- let light_result = LightResult::from([(out_port.into(), LightData::Geometric(output))]);
+
+ let mut rays_bundle = vec![rays];
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
+ let light_result = LightResult::from([(
+ out_port.into(),
+ LightData::Geometric(rays_bundle[0].clone()),
+ )]);
Ok(light_result)
}
}
diff --git a/opossum/src/nodes/lens/mod.rs b/opossum/src/nodes/lens/mod.rs
index f709f0d286e1d1def8e4c9ad1779078b679898f4..e9f2fd9014fb343d9231a04c4fd97634cd29a2a5 100644
--- a/opossum/src/nodes/lens/mod.rs
+++ b/opossum/src/nodes/lens/mod.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
use super::node_attr::NodeAttr;
use crate::{
- analyzers::{Analyzable, AnalyzerType},
+ analyzers::Analyzable,
dottable::Dottable,
error::{OpmResult, OpossumError},
millimeter,
@@ -13,7 +13,7 @@ use crate::{
properties::Proptype,
rays::Rays,
refractive_index::{RefrIndexConst, RefractiveIndex, RefractiveIndexType},
- surface::{hit_map::HitMap, OpticalSurface, Plane, Sphere},
+ surface::{hit_map::HitMap, OpticalSurface, Plane, Sphere, Surface},
utils::{geom_transformation::Isometry, EnumProxy},
};
#[cfg(feature = "bevy")]
@@ -262,122 +262,26 @@ impl Lens {
Some(rear_curvature.abs())
}
}
- fn analyze_forward(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let isometry = iso.append(&thickness_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(refri))?;
- self.front_surf.set_backwards_rays_cache(reflected_front);
- rays.merge(self.front_surf.forward_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(&ambient_idx))?;
- self.rear_surf.set_backwards_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.forward_rays_cache());
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- Ok(rays)
- }
- fn analyze_inverse(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let isometry = iso.append(&thickness_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(refri))?;
- self.rear_surf.set_forward_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.backwards_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(&ambient_idx))?;
- self.front_surf.set_forward_rays_cache(reflected_front);
- rays.merge(self.front_surf.backwards_rays_cache());
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
+}
+
+impl Surface for Lens {
+ fn get_surface_mut(&mut self, surf_name: &str) -> &mut OpticalSurface {
+ if surf_name == "front" {
+ &mut self.front_surf
} else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- Ok(rays)
+ &mut self.rear_surf
+ }
}
}
impl OpticNode for Lens {
fn reset_data(&mut self) {
- self.front_surf.set_backwards_rays_cache(Rays::default());
- self.front_surf.set_forward_rays_cache(Rays::default());
+ self.front_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.front_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.front_surf.reset_hit_map();
- self.rear_surf.set_backwards_rays_cache(Rays::default());
- self.rear_surf.set_forward_rays_cache(Rays::default());
+ self.rear_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.rear_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.rear_surf.reset_hit_map();
}
fn hit_maps(&self) -> HashMap<String, HitMap> {
diff --git a/opossum/src/nodes/node_group/analysis_ghostfocus.rs b/opossum/src/nodes/node_group/analysis_ghostfocus.rs
index 920064b66ccd1e09f3b907dfb3040843ee1cc8d6..cfdc2fb20a157987eb66225de400bdd4cdba2d97 100644
--- a/opossum/src/nodes/node_group/analysis_ghostfocus.rs
+++ b/opossum/src/nodes/node_group/analysis_ghostfocus.rs
@@ -11,15 +11,19 @@ use log::warn;
fn filter_ray_limits(light_rays: &mut LightRays, config: &GhostFocusConfig) {
for lr in light_rays {
- lr.1.filter_by_nr_of_bounces(config.max_bounces());
+ for rays in lr.1 {
+ rays.filter_by_nr_of_bounces(config.max_bounces());
+ }
}
}
+
impl AnalysisGhostFocus for NodeGroup {
fn analyze(
&mut self,
incoming_data: LightRays,
config: &GhostFocusConfig,
ray_collection: &mut Vec<Rays>,
+ bounce_lvl: usize,
) -> OpmResult<LightRays> {
let mut current_bouncing_rays = incoming_data;
@@ -44,6 +48,7 @@ impl AnalysisGhostFocus for NodeGroup {
idx,
&light_rays_to_light_result(current_bouncing_rays.clone()),
);
+
let node_name = format!("{}", node.borrow());
let mut outgoing_edges = AnalysisGhostFocus::analyze(
@@ -51,6 +56,7 @@ impl AnalysisGhostFocus for NodeGroup {
light_result_to_light_rays(incoming_edges)?,
config,
ray_collection,
+ bounce_lvl,
)
.map_err(|e| {
OpossumError::Analysis(format!("analysis of node {node_name} failed: {e}"))
@@ -69,8 +75,10 @@ impl AnalysisGhostFocus for NodeGroup {
.set_outgoing_edge_data(idx, &outgoing_edge.0, &outgoing_edge.1);
if !no_sink {
- if let LightData::Geometric(rays) = outgoing_edge.1 {
- ray_collection.push(rays);
+ if let LightData::GhostFocus(rays) = outgoing_edge.1 {
+ for r in rays {
+ ray_collection.push(r);
+ }
}
}
}
diff --git a/opossum/src/nodes/node_group/mod.rs b/opossum/src/nodes/node_group/mod.rs
index 766f5c5e2139d37afd17c331a8dbfa3bc021b6ea..3181a7b224720e7564bcf5c8eecf9bbebd635978 100644
--- a/opossum/src/nodes/node_group/mod.rs
+++ b/opossum/src/nodes/node_group/mod.rs
@@ -14,7 +14,8 @@ use crate::{
optic_ref::OpticRef,
properties::{Properties, Proptype},
rays::Rays,
- reporting::analysis_report::{AnalysisReport, NodeReport},
+ reporting::{analysis_report::AnalysisReport, node_report::NodeReport},
+ surface::{OpticalSurface, Surface},
SceneryResources,
};
use chrono::Local;
@@ -70,7 +71,7 @@ pub struct NodeGroup {
node_attr: NodeAttr,
input_port_distances: BTreeMap<String, Length>,
#[serde(skip)]
- accumulated_rays: Vec<Rays>,
+ accumulated_rays: Vec<Vec<Rays>>,
}
impl Default for NodeGroup {
fn default() -> Self {
@@ -90,7 +91,7 @@ impl Default for NodeGroup {
graph: OpticGraph::default(),
input_port_distances: BTreeMap::default(),
node_attr,
- accumulated_rays: Vec::<Rays>::new(),
+ accumulated_rays: Vec::<Vec<Rays>>::new(),
}
}
}
@@ -384,7 +385,7 @@ impl NodeGroup {
/// This function returns a bundle of all rays that propagated in a group after a ghost focus analysis.
/// This function is in particular helpful for generating a global ray propagation plot.
#[must_use]
- pub const fn accumulated_rays(&self) -> &Vec<Rays> {
+ pub const fn accumulated_rays(&self) -> &Vec<Vec<Rays>> {
&self.accumulated_rays
}
@@ -394,9 +395,9 @@ impl NodeGroup {
/// - bounce: bouncle level of these rays
pub fn add_to_accumulated_rays(&mut self, rays: &Rays, bounce: usize) {
if self.accumulated_rays.len() <= bounce {
- self.accumulated_rays.push(rays.clone());
+ self.accumulated_rays.push(vec![rays.clone()]);
} else {
- self.accumulated_rays[bounce].merge(rays);
+ self.accumulated_rays[bounce].push(rays.clone());
}
}
@@ -404,6 +405,26 @@ impl NodeGroup {
pub fn clear_edges(&mut self) {
self.graph.clear_edges();
}
+ // fn export_data(&self, report_dir: &Path, _uuid: &str) -> OpmResult<()> {
+ // for node in self.graph.nodes() {
+ // let node_name = node.optical_ref.borrow().name();
+ // info!("export data for node {node_name}");
+ // let uuid = node.uuid().as_simple().to_string();
+ // node.optical_ref.borrow().export_data(report_dir, &uuid)?;
+ // let hitmaps = node.optical_ref.borrow().hit_maps();
+ // for hitmap in &hitmaps {
+ // let port_name = hitmap.0;
+ // info!(" found hitmap for port {port_name}");
+ // let file_path = PathBuf::from(report_dir).join(Path::new(&format!(
+ // "hitmap_{node_name}_{port_name}_{uuid}.svg"
+ // )));
+ // if !hitmap.1.is_empty() {
+ // hitmap.1.to_plot(&file_path, PltBackEnd::SVG)?;
+ // }
+ // }
+ // }
+ // Ok(())
+ // }
}
impl OpticNode for NodeGroup {
@@ -446,33 +467,17 @@ impl OpticNode for NodeGroup {
}
}
}
- Some(NodeReport::new(
- &self.node_type(),
- &self.name(),
- uuid,
- group_props,
- ))
+ if group_props.is_empty() {
+ None
+ } else {
+ Some(NodeReport::new(
+ &self.node_type(),
+ &self.name(),
+ uuid,
+ group_props,
+ ))
+ }
}
- // fn export_data(&self, report_dir: &Path, _uuid: &str) -> OpmResult<()> {
- // for node in self.graph.nodes() {
- // let node_name = node.optical_ref.borrow().name();
- // info!("export data for node {node_name}");
- // let uuid = node.uuid().as_simple().to_string();
- // node.optical_ref.borrow().export_data(report_dir, &uuid)?;
- // let hitmaps = node.optical_ref.borrow().hit_maps();
- // for hitmap in &hitmaps {
- // let port_name = hitmap.0;
- // info!(" found hitmap for port {port_name}");
- // let file_path = PathBuf::from(report_dir).join(Path::new(&format!(
- // "hitmap_{node_name}_{port_name}_{uuid}.svg"
- // )));
- // if !hitmap.1.is_empty() {
- // hitmap.1.to_plot(&file_path, PltBackEnd::SVG)?;
- // }
- // }
- // }
- // Ok(())
- // }
fn node_attr(&self) -> &NodeAttr {
&self.node_attr
}
@@ -494,7 +499,13 @@ impl OpticNode for NodeGroup {
for node in nodes {
node.optical_ref.borrow_mut().reset_data();
}
- self.accumulated_rays = Vec::<Rays>::new();
+ self.accumulated_rays = Vec::<Vec<Rays>>::new();
+ }
+}
+
+impl Surface for NodeGroup {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
}
}
@@ -666,7 +677,7 @@ mod test {
.node_report(&uuid)
.unwrap();
if let Proptype::Energy(e) = report.properties().get("Energy").unwrap() {
- assert_eq!(*e, joule!(1.0));
+ assert_eq!(e, &joule!(1.0));
} else {
assert!(false)
}
diff --git a/opossum/src/nodes/paraxial_surface.rs b/opossum/src/nodes/paraxial_surface.rs
index 2a637f7f468bae28517cec41743a3eb520c2d839..4b3287d432d08b90c71dcab7cfc8b782e84a97f8 100644
--- a/opossum/src/nodes/paraxial_surface.rs
+++ b/opossum/src/nodes/paraxial_surface.rs
@@ -13,7 +13,7 @@ use crate::{
optic_node::{Alignable, OpticNode},
optic_ports::{OpticPorts, PortType},
properties::Proptype,
- surface::{OpticalSurface, Plane},
+ surface::{OpticalSurface, Plane, Surface},
};
use uom::{num_traits::Zero, si::f64::Length};
@@ -118,6 +118,11 @@ impl AnalysisEnergy for ParaxialSurface {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+impl Surface for ParaxialSurface {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl AnalysisRayTrace for ParaxialSurface {
fn analyze(
&mut self,
diff --git a/opossum/src/nodes/ray_propagation_visualizer.rs b/opossum/src/nodes/ray_propagation_visualizer.rs
index 77b4422177f3020fd038229ab1c97e87da0f482f..41f9173de15d0e3c48124e56476ae1187d4e5a5f 100644
--- a/opossum/src/nodes/ray_propagation_visualizer.rs
+++ b/opossum/src/nodes/ray_propagation_visualizer.rs
@@ -25,8 +25,8 @@ use crate::{
plottable::{PlotArgs, PlotData, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
rays::Rays,
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
/// A ray-propagation monitor
@@ -46,7 +46,7 @@ use crate::{
/// different dectector nodes can be "stacked" or used somewhere within the optical setup.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct RayPropagationVisualizer {
- light_data: Option<Rays>,
+ light_data: Option<LightData>,
node_attr: NodeAttr,
apodization_warning: bool,
#[serde(skip)]
@@ -92,45 +92,26 @@ impl RayPropagationVisualizer {
Ok(rpv)
}
}
+impl Surface for RayPropagationVisualizer {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl OpticNode for RayPropagationVisualizer {
- // fn export_data(&self, report_dir: &Path, uuid: &str) -> OpmResult<()> {
- // if self.light_data.is_some() {
- // if let Some(rays) = &self.light_data {
- // let mut ray_prop_data = rays.get_rays_position_history()?;
- // if let Ok(Proptype::Vec3(plot_view_direction)) =
- // self.node_attr.get_property("view_direction")
- // {
- // ray_prop_data.plot_view_direction = Some(*plot_view_direction);
- // } else {
- // warn!("could not read 'view_direction' property. defaulted to yz-plane");
- // ray_prop_data.plot_view_direction = Some(Vector3::x());
- // };
-
- // let file_path = PathBuf::from(report_dir).join(Path::new(&format!(
- // "ray_propagation_{}_{}.svg",
- // self.name(),
- // uuid
- // )));
- // ray_prop_data.to_plot(&file_path, PltBackEnd::SVG)?;
- // } else {
- // warn!("ray-propagation visualizer: wrong light data. Cannot create plot!");
- // }
- // } else {
- // warn!("ray-propagation visualizer: no light data for export available. Cannot create plot!");
- // }
- // Ok(())
- // }
fn node_report(&self, uuid: &str) -> Option<NodeReport> {
let mut props = Properties::default();
let data = &self.light_data;
- if let Some(rays) = data {
- if let Ok(proptype) = <Rays as TryInto<Proptype>>::try_into(rays.clone()) {
+ if let Some(LightData::Geometric(rays)) = data {
+ if let Ok(mut ray_position_histories) = rays.get_rays_position_history() {
+ if let Ok(Proptype::Vec3(view_vec)) = self.properties().get("view_direction") {
+ ray_position_histories.plot_view_direction = Some(*view_vec);
+ }
props
.create(
- "Ray Propagation visualization plot",
+ "Ray plot",
"Ray plot",
None,
- proptype,
+ Proptype::RayPositionHistory(ray_position_histories),
)
.unwrap();
if self.apodization_warning {
@@ -139,7 +120,8 @@ impl OpticNode for RayPropagationVisualizer {
"Warning",
"warning during analysis",
None,
- "Rays have been apodized at input aperture. Results might not be accurate.".into(),
+ "Rays have been apodized at input aperture. Results might not be accurate."
+ .into(),
)
.unwrap();
}
@@ -176,28 +158,17 @@ impl AnalysisGhostFocus for RayPropagationVisualizer {
incoming_data: LightRays,
_config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("out1", "in1")
- } else {
- ("in1", "out1")
- };
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
let Some(bouncing_rays) = incoming_data.get(in_port) else {
- return Ok(LightRays::default());
+ let mut out_light_rays = LightRays::default();
+ out_light_rays.insert(out_port.into(), Vec::<Rays>::new());
+ return Ok(out_light_rays);
};
let mut rays = bouncing_rays.clone();
- if let Some(iso) = self.effective_iso() {
- self.surface.set_isometry(&iso);
- rays.refract_on_surface(&mut self.surface, None)?;
- } else {
- return Err(OpossumError::Analysis(
- "no location for surface defined. Aborting".into(),
- ));
- }
- // merge all rays
- let mut ray_cache = self.light_data.clone().unwrap_or_default();
- ray_cache.merge(&rays);
- self.light_data = Some(ray_cache);
+ self.pass_through_inert_surface(&mut rays)?;
let mut out_light_rays = LightRays::default();
out_light_rays.insert(out_port.to_string(), rays.clone());
@@ -215,7 +186,7 @@ impl AnalysisEnergy for RayPropagationVisualizer {
return Ok(LightResult::default());
};
if let LightData::Geometric(rays) = data.clone() {
- self.light_data = Some(rays);
+ self.light_data = Some(LightData::Geometric(rays));
}
Ok(LightResult::from([(outport.into(), data.clone())]))
}
@@ -254,7 +225,7 @@ impl AnalysisRayTrace for RayPropagationVisualizer {
} else {
return Err(OpossumError::OpticPort("input aperture not found".into()));
};
- self.light_data = Some(rays.clone());
+ self.light_data = Some(LightData::Geometric(rays.clone()));
if let Some(aperture) = self.ports().aperture(&PortType::Output, outport) {
let rays_apodized = rays.apodize(aperture)?;
if rays_apodized {
@@ -272,6 +243,12 @@ impl AnalysisRayTrace for RayPropagationVisualizer {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
/// struct that holds the history of the rays' positions for rays of a specific wavelength
@@ -624,23 +601,19 @@ mod test {
let node_props = node_report.properties();
let nr_of_props = node_props.iter().fold(0, |c, _p| c + 1);
assert_eq!(nr_of_props, 0);
- fd.light_data = Some(Rays::default());
+ fd.light_data = Some(LightData::Geometric(Rays::default()));
let node_report = fd.node_report("").unwrap();
- assert!(!node_report
- .properties()
- .contains("Ray Propagation visualization plot"));
- fd.light_data = Some(
+ assert!(!node_report.properties().contains("Ray plot"));
+ fd.light_data = Some(LightData::Geometric(
Rays::new_uniform_collimated(
nanometer!(1053.0),
joule!(1.0),
&Hexapolar::new(millimeter!(1.), 1).unwrap(),
)
.unwrap(),
- );
+ ));
let node_report = fd.node_report("").unwrap();
- assert!(node_report
- .properties()
- .contains("Ray Propagation visualization plot"));
+ assert!(node_report.properties().contains("Ray plot"));
let node_props = node_report.properties();
let nr_of_props = node_props.iter().fold(0, |c, _p| c + 1);
assert_eq!(nr_of_props, 1);
diff --git a/opossum/src/nodes/reference.rs b/opossum/src/nodes/reference.rs
index f9449c0fc13ebbf69caaff4e47b6ab4022c6eca4..350a5cb489b0c24a987f46b4566ed7eb07390731 100644
--- a/opossum/src/nodes/reference.rs
+++ b/opossum/src/nodes/reference.rs
@@ -15,6 +15,7 @@ use crate::{
optic_node::OpticNode,
optic_ports::OpticPorts,
optic_ref::OpticRef,
+ surface::{OpticalSurface, Surface},
utils::geom_transformation::Isometry,
};
@@ -125,6 +126,11 @@ impl Dottable for NodeReference {
"lightsalmon3"
}
}
+impl Surface for NodeReference {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl Analyzable for NodeReference {}
impl AnalysisGhostFocus for NodeReference {}
impl AnalysisEnergy for NodeReference {
diff --git a/opossum/src/nodes/reflective_grating.rs b/opossum/src/nodes/reflective_grating.rs
index 651c568da8989d81bb4f40af7c444f93c693ec2c..4579db7695ac367edd0fe6d5e5cdb3ebb56095a1 100644
--- a/opossum/src/nodes/reflective_grating.rs
+++ b/opossum/src/nodes/reflective_grating.rs
@@ -18,7 +18,7 @@ use crate::{
properties::Proptype,
radian,
refractive_index::refr_index_vaccuum,
- surface::Plane,
+ surface::{OpticalSurface, Plane, Surface},
};
use approx::relative_eq;
use nalgebra::Vector3;
@@ -161,6 +161,11 @@ impl Dottable for ReflectiveGrating {
"cornsilk"
}
}
+impl Surface for ReflectiveGrating {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl Analyzable for ReflectiveGrating {}
impl AnalysisGhostFocus for ReflectiveGrating {}
impl AnalysisEnergy for ReflectiveGrating {
diff --git a/opossum/src/nodes/source.rs b/opossum/src/nodes/source.rs
index e1576f7addd774d2b5bfc20f59782e94219010a2..4a0ca6feb5aaa865ad0017bc4eb44677b966909c 100644
--- a/opossum/src/nodes/source.rs
+++ b/opossum/src/nodes/source.rs
@@ -11,7 +11,7 @@ use crate::{
dottable::Dottable,
error::{OpmResult, OpossumError},
joule,
- light_result::{light_result_to_light_rays, LightRays, LightResult},
+ light_result::{LightRays, LightResult},
lightdata::LightData,
millimeter,
optic_node::{Alignable, OpticNode},
@@ -19,7 +19,7 @@ use crate::{
properties::Proptype,
ray::Ray,
rays::Rays,
- surface::{hit_map::HitMap, OpticalSurface, Plane},
+ surface::{hit_map::HitMap, OpticalSurface, Plane, Surface},
utils::{geom_transformation::Isometry, EnumProxy},
};
use std::{collections::HashMap, fmt::Debug};
@@ -269,34 +269,41 @@ impl AnalysisGhostFocus for Source {
incoming_data: LightRays,
_config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ bounce_lvl: usize,
) -> OpmResult<LightRays> {
let mut rays = if self.inverted() {
let Some(bouncing_rays) = incoming_data.get("out1") else {
return Err(OpossumError::Analysis("no light at port".into()));
};
bouncing_rays.clone()
- } else if let Ok(Proptype::LightData(data)) = self.node_attr.get_property("light data") {
- let Some(mut data) = data.value.clone() else {
- return Err(OpossumError::Analysis(
- "source has empty light data defined".into(),
- ));
- };
- if let LightData::Geometric(rays) = &mut data {
- if let Some(iso) = self.effective_iso() {
- *rays = rays.transformed_rays(&iso);
+ } else if bounce_lvl == 0 {
+ if let Ok(Proptype::LightData(data)) = self.node_attr.get_property("light data") {
+ let Some(mut data) = data.value.clone() else {
+ return Err(OpossumError::Analysis(
+ "source has empty light data defined".into(),
+ ));
+ };
+ if let LightData::Geometric(rays) = &mut data {
+ if let Some(iso) = self.effective_iso() {
+ *rays = rays.transformed_rays(&iso);
+ }
+ vec![rays.clone()]
+ } else {
+ return Err(OpossumError::Analysis(
+ "source has wrong light data type defined".into(),
+ ));
}
- rays.clone()
} else {
- return Err(OpossumError::Analysis(
- "source has wrong light data type defined".into(),
- ));
+ return Err(OpossumError::Analysis("could not read light data".into()));
}
} else {
- return Err(OpossumError::Analysis("could not read light data".into()));
+ Vec::<Rays>::new()
};
if let Some(iso) = self.effective_iso() {
self.surface.set_isometry(&iso);
- rays.refract_on_surface(&mut self.surface, None)?;
+ for r in &mut rays {
+ r.refract_on_surface(&mut self.surface, None)?;
+ }
} else {
return Err(OpossumError::Analysis(
"no location for surface defined. Aborting".into(),
@@ -307,8 +314,18 @@ impl AnalysisGhostFocus for Source {
// light_rays_to_light_result(incoming_data),
// &RayTraceConfig::default(),
// )?;
- let outgoing = LightResult::from([("out1".into(), LightData::Geometric(rays))]);
- light_result_to_light_rays(outgoing)
+ let mut out_light_rays = LightRays::default();
+ out_light_rays.insert("out1".into(), rays);
+ Ok(out_light_rays)
+
+ // let outgoing = LightResult::from([("out1".into(), LightData::Geometric(rays))]);
+ // light_result_to_light_rays(outgoing)
+ }
+}
+
+impl Surface for Source {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ &mut self.surface
}
}
diff --git a/opossum/src/nodes/spectrometer.rs b/opossum/src/nodes/spectrometer.rs
index 5db3969289b728f974aff5f9f15ba6814b2f8809..fee7f36ddab2ba3e287f36256fbb361291aaf7fb 100644
--- a/opossum/src/nodes/spectrometer.rs
+++ b/opossum/src/nodes/spectrometer.rs
@@ -18,8 +18,9 @@ use crate::{
optic_ports::{OpticPorts, PortType},
plottable::{PlotArgs, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ rays::Rays,
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::geom_transformation::Isometry,
};
use std::fmt::{Debug, Display};
@@ -160,6 +161,13 @@ impl OpticNode for Spectrometer {
LightData::Energy(e) => Some(e.spectrum.clone()),
LightData::Geometric(r) => r.to_spectrum(&nanometer!(0.2)).ok(),
LightData::Fourier => None,
+ LightData::GhostFocus(r) => {
+ let mut all_rays = Rays::default();
+ for rays in r {
+ all_rays.merge(rays);
+ }
+ all_rays.to_spectrum(&nanometer!(0.2)).ok()
+ }
};
if spectrum.is_some() {
props
@@ -207,6 +215,12 @@ impl OpticNode for Spectrometer {
}
}
+impl Surface for Spectrometer {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
+
impl Debug for Spectrometer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.light_data {
@@ -298,6 +312,13 @@ impl AnalysisRayTrace for Spectrometer {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
impl Plottable for Spectrometer {
diff --git a/opossum/src/nodes/spot_diagram.rs b/opossum/src/nodes/spot_diagram.rs
index 8cd4470d92cc4a8fd7242bd32e32e7662f56b577..437473fa96515df49c3babbe376f6c3777307899 100644
--- a/opossum/src/nodes/spot_diagram.rs
+++ b/opossum/src/nodes/spot_diagram.rs
@@ -24,8 +24,8 @@ use crate::{
plottable::{AxLims, PlotArgs, PlotData, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
rays::Rays,
- reporting::analysis_report::NodeReport,
- surface::{hit_map::HitMap, OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{hit_map::HitMap, OpticalSurface, Plane, Surface},
utils::{
geom_transformation::Isometry,
unit_format::{
@@ -55,7 +55,7 @@ use std::collections::HashMap;
/// different dectector nodes can be "stacked" or used somewhere within the optical setup.
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct SpotDiagram {
- light_data: Option<Rays>,
+ light_data: Option<LightData>,
node_attr: NodeAttr,
#[serde(skip)]
surface: OpticalSurface,
@@ -96,6 +96,11 @@ impl SpotDiagram {
sd
}
}
+impl Surface for SpotDiagram {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ &mut self.surface
+ }
+}
impl Alignable for SpotDiagram {}
@@ -108,7 +113,7 @@ impl OpticNode for SpotDiagram {
fn node_report(&self, uuid: &str) -> Option<NodeReport> {
let mut props = Properties::default();
let data = &self.light_data;
- if let Some(rays) = data {
+ if let Some(LightData::Geometric(rays)) = data {
let mut transformed_rays = Rays::default();
let iso = self.effective_iso().unwrap_or_else(Isometry::identity);
for ray in rays {
@@ -199,31 +204,17 @@ impl AnalysisGhostFocus for SpotDiagram {
incoming_data: LightRays,
_config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("out1", "in1")
- } else {
- ("in1", "out1")
- };
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
let Some(bouncing_rays) = incoming_data.get(in_port) else {
- return Ok(LightRays::default());
+ let mut out_light_rays = LightRays::default();
+ out_light_rays.insert(out_port.into(), Vec::<Rays>::new());
+ return Ok(out_light_rays);
};
let mut rays = bouncing_rays.clone();
- if let Some(iso) = self.effective_iso() {
- self.surface.set_isometry(&iso);
- rays.refract_on_surface(&mut self.surface, None)?;
- } else {
- return Err(OpossumError::Analysis(
- "no location for surface defined. Aborting".into(),
- ));
- }
- // merge all rays
- let mut ray_cache = self
- .light_data
- .clone()
- .map_or_else(Rays::default, |rays| rays);
- ray_cache.merge(&rays);
- self.light_data = Some(ray_cache);
+ self.pass_through_inert_surface(&mut rays)?;
let mut out_light_rays = LightRays::default();
out_light_rays.insert(out_port.to_string(), rays);
@@ -240,8 +231,8 @@ impl AnalysisEnergy for SpotDiagram {
let Some(data) = incoming_data.get(inport) else {
return Ok(LightResult::default());
};
- if let LightData::Geometric(rays) = data {
- self.light_data = Some(rays.clone());
+ if let LightData::Geometric(_) = data {
+ self.light_data = Some(data.clone());
}
Ok(LightResult::from([(outport.into(), data.clone())]))
}
@@ -280,12 +271,12 @@ impl AnalysisRayTrace for SpotDiagram {
} else {
return Err(OpossumError::OpticPort("input aperture not found".into()));
};
- if let Some(old_rays) = &self.light_data {
+ if let Some(LightData::Geometric(old_rays)) = &self.light_data {
let mut rays_tob_merged = old_rays.clone();
rays_tob_merged.merge(&rays);
- self.light_data = Some(rays_tob_merged.clone());
+ self.light_data = Some(LightData::Geometric(rays_tob_merged.clone()));
} else {
- self.light_data = Some(rays.clone());
+ self.light_data = Some(LightData::Geometric(rays.clone()));
}
if let Some(aperture) = self.ports().aperture(&PortType::Output, "out1") {
rays.apodize(aperture)?;
@@ -301,6 +292,13 @@ impl AnalysisRayTrace for SpotDiagram {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
impl From<SpotDiagram> for Proptype {
@@ -331,7 +329,7 @@ impl Plottable for SpotDiagram {
) -> OpmResult<Option<Vec<PlotSeries>>> {
let data = &self.light_data;
match data {
- Some(rays) => {
+ Some(LightData::Geometric(rays)) => {
let (split_rays_bundles, wavelengths) =
rays.split_ray_bundle_by_wavelength(nanometer!(0.2), true)?;
let num_series = split_rays_bundles.len();
@@ -578,17 +576,17 @@ mod test {
let node_props = node_report.properties();
let nr_of_props = node_props.iter().fold(0, |c, _p| c + 1);
assert_eq!(nr_of_props, 0);
- sd.light_data = Some(Rays::default());
+ sd.light_data = Some(LightData::Geometric(Rays::default()));
let node_report = sd.node_report("").unwrap();
assert!(node_report.properties().contains("Spot diagram"));
- sd.light_data = Some(
+ sd.light_data = Some(LightData::Geometric(
Rays::new_uniform_collimated(
nanometer!(1053.0),
joule!(1.0),
&Hexapolar::new(Length::zero(), 1).unwrap(),
)
.unwrap(),
- );
+ ));
let node_report = sd.node_report("").unwrap();
let node_props = node_report.properties();
let nr_of_props = node_props.iter().fold(0, |c, _p| c + 1);
diff --git a/opossum/src/nodes/thin_mirror.rs b/opossum/src/nodes/thin_mirror.rs
index 58e61d075bfd7bac5b52d4a89b60cdfc246ee489..0e8170238c281f7563fdc146d887341ae446151f 100644
--- a/opossum/src/nodes/thin_mirror.rs
+++ b/opossum/src/nodes/thin_mirror.rs
@@ -15,7 +15,7 @@ use crate::{
optic_node::{Alignable, OpticNode},
optic_ports::{OpticPorts, PortType},
properties::Proptype,
- surface::{OpticalSurface, Plane, Sphere},
+ surface::{OpticalSurface, Plane, Sphere, Surface},
};
use num::Zero;
use uom::si::f64::Length;
@@ -120,6 +120,12 @@ impl OpticNode for ThinMirror {
}
}
+impl Surface for ThinMirror {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
+
impl Alignable for ThinMirror {}
impl Dottable for ThinMirror {
diff --git a/opossum/src/nodes/wavefront.rs b/opossum/src/nodes/wavefront.rs
index d87805fa45bf731e5a4c23c9e1af382c74e2bdc2..dc62f47da191b97238b3844fb4cf65b63089f009 100644
--- a/opossum/src/nodes/wavefront.rs
+++ b/opossum/src/nodes/wavefront.rs
@@ -20,8 +20,8 @@ use crate::{
optic_ports::{OpticPorts, PortType},
plottable::{AxLims, PlotArgs, PlotData, PlotParameters, PlotSeries, PlotType, Plottable},
properties::{Properties, Proptype},
- reporting::analysis_report::NodeReport,
- surface::{OpticalSurface, Plane},
+ reporting::node_report::NodeReport,
+ surface::{OpticalSurface, Plane, Surface},
utils::{
geom_transformation::Isometry,
griddata::{create_linspace_axes, interpolate_3d_scatter_data},
@@ -280,6 +280,11 @@ impl Dottable for WaveFront {
"goldenrod1"
}
}
+impl Surface for WaveFront {
+ fn get_surface_mut(&mut self, _surf_name: &str) -> &mut OpticalSurface {
+ todo!()
+ }
+}
impl Analyzable for WaveFront {}
impl AnalysisGhostFocus for WaveFront {}
impl AnalysisEnergy for WaveFront {
@@ -345,6 +350,13 @@ impl AnalysisRayTrace for WaveFront {
Ok(LightResult::from([(outport.into(), data.clone())]))
}
}
+
+ fn get_light_data_mut(&mut self) -> Option<&mut LightData> {
+ self.light_data.as_mut()
+ }
+ fn set_light_data(&mut self, ld: LightData) {
+ self.light_data = Some(ld);
+ }
}
impl Plottable for WaveFrontErrorMap {
diff --git a/opossum/src/nodes/wedge/analysis_ghostfocus.rs b/opossum/src/nodes/wedge/analysis_ghostfocus.rs
index a106408a8f7cbec8b575f27c3c0c29b61effe916..a6d09454069fa985c9b0c3d963f26146b9e4d46c 100644
--- a/opossum/src/nodes/wedge/analysis_ghostfocus.rs
+++ b/opossum/src/nodes/wedge/analysis_ghostfocus.rs
@@ -1,72 +1,77 @@
+use nalgebra::Point3;
+use num::Zero;
+use uom::si::f64::Angle;
+
use super::Wedge;
use crate::{
- analyzers::{ghostfocus::AnalysisGhostFocus, AnalyzerType, GhostFocusConfig, RayTraceConfig},
- error::{OpmResult, OpossumError},
+ analyzers::{
+ ghostfocus::AnalysisGhostFocus, raytrace::AnalysisRayTrace, Analyzable, AnalyzerType,
+ GhostFocusConfig,
+ },
+ error::OpmResult,
light_result::LightRays,
optic_node::OpticNode,
- properties::Proptype,
+ optic_ports::PortType,
rays::Rays,
+ utils::geom_transformation::Isometry,
};
impl AnalysisGhostFocus for Wedge {
fn analyze(
&mut self,
incoming_data: LightRays,
- _config: &GhostFocusConfig,
+ config: &GhostFocusConfig,
_ray_collection: &mut Vec<Rays>,
+ _bounce_lvl: usize,
) -> OpmResult<LightRays> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
- } else {
- ("front", "rear")
- };
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
+
let Some(incoming_rays) = incoming_data.get(in_port) else {
return Ok(LightRays::default());
};
- let rays = incoming_rays;
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let Ok(Proptype::Angle(angle)) = self.node_attr.get_property("wedge") else {
- return Err(OpossumError::Analysis("cannot wedge angle".into()));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays.clone(),
- *center_thickness,
- *angle,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
+ let (eff_iso, refri, center_thickness, wedge) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let thickness_iso: Isometry = Isometry::new_along_z(center_thickness)?;
+ let wedge_iso = Isometry::new(
+ Point3::origin(),
+ Point3::new(wedge, Angle::zero(), Angle::zero()),
+ )?;
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso).append(&wedge_iso),
+ &PortType::Output,
+ )?;
} else {
- self.analyze_forward(
- rays.clone(),
- *center_thickness,
- *angle,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(RayTraceConfig::default()),
- )?
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso).append(&wedge_iso),
+ &PortType::Output,
+ )?;
};
+
+ let mut rays_bundle = incoming_rays.clone();
+
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::GhostFocus(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
let mut out_light_rays = LightRays::default();
- out_light_rays.insert(out_port.to_string(), output);
+ out_light_rays.insert(out_port.to_string(), rays_bundle);
Ok(out_light_rays)
}
}
diff --git a/opossum/src/nodes/wedge/analysis_raytrace.rs b/opossum/src/nodes/wedge/analysis_raytrace.rs
index 4cfc53c57a94e328404fd34a600d2da2fa5a83ff..8aa656dd62beef3d874bdc816138cbf88e894266 100644
--- a/opossum/src/nodes/wedge/analysis_raytrace.rs
+++ b/opossum/src/nodes/wedge/analysis_raytrace.rs
@@ -1,74 +1,80 @@
-use super::Wedge;
-use crate::{
- analyzers::{raytrace::AnalysisRayTrace, AnalyzerType, RayTraceConfig},
- error::{OpmResult, OpossumError},
- light_result::LightResult,
- lightdata::LightData,
- optic_node::OpticNode,
- properties::Proptype,
-};
-
-impl AnalysisRayTrace for Wedge {
- fn analyze(
- &mut self,
- incoming_data: LightResult,
- config: &RayTraceConfig,
- ) -> OpmResult<LightResult> {
- let (in_port, out_port) = if self.inverted() {
- ("rear", "front")
- } else {
- ("front", "rear")
- };
- let Some(data) = incoming_data.get(in_port) else {
- return Ok(LightResult::default());
- };
- let LightData::Geometric(rays) = data.clone() else {
- return Err(OpossumError::Analysis(
- "expected ray data at input port".into(),
- ));
- };
- let Some(eff_iso) = self.effective_iso() else {
- return Err(OpossumError::Analysis(
- "no location for surface defined".into(),
- ));
- };
- let Ok(Proptype::RefractiveIndex(index_model)) =
- self.node_attr.get_property("refractive index")
- else {
- return Err(OpossumError::Analysis(
- "cannot read refractive index".into(),
- ));
- };
- let Ok(Proptype::Length(center_thickness)) =
- self.node_attr.get_property("center thickness")
- else {
- return Err(OpossumError::Analysis(
- "cannot read center thickness".into(),
- ));
- };
- let Ok(Proptype::Angle(angle)) = self.node_attr.get_property("wedge") else {
- return Err(OpossumError::Analysis("cannot wedge angle".into()));
- };
- let output = if self.inverted() {
- self.analyze_inverse(
- rays,
- *center_thickness,
- *angle,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
- } else {
- self.analyze_forward(
- rays,
- *center_thickness,
- *angle,
- &index_model.value.clone(),
- &eff_iso,
- &AnalyzerType::RayTrace(config.clone()),
- )?
- };
- let light_result = LightResult::from([(out_port.into(), LightData::Geometric(output))]);
- Ok(light_result)
- }
-}
+use nalgebra::Point3;
+use num::Zero;
+use uom::si::angle::Angle;
+
+use super::Wedge;
+use crate::{
+ analyzers::{raytrace::AnalysisRayTrace, Analyzable, AnalyzerType, RayTraceConfig},
+ error::{OpmResult, OpossumError},
+ light_result::LightResult,
+ lightdata::LightData,
+ optic_node::OpticNode,
+ optic_ports::PortType,
+ utils::geom_transformation::Isometry,
+};
+
+impl AnalysisRayTrace for Wedge {
+ fn analyze(
+ &mut self,
+ incoming_data: LightResult,
+ config: &RayTraceConfig,
+ ) -> OpmResult<LightResult> {
+ let in_port = &self.ports().names(&PortType::Input)[0];
+ let out_port = &self.ports().names(&PortType::Output)[0];
+
+ let Some(data) = incoming_data.get(in_port) else {
+ return Ok(LightResult::default());
+ };
+ let LightData::Geometric(rays) = data.clone() else {
+ return Err(OpossumError::Analysis(
+ "expected ray data at input port".into(),
+ ));
+ };
+
+ let (eff_iso, refri, center_thickness, wedge) =
+ self.get_node_attributes_ray_trace(&self.node_attr)?;
+ let thickness_iso = Isometry::new_along_z(center_thickness)?;
+ let wedge_iso = Isometry::new(
+ Point3::origin(),
+ Point3::new(wedge, Angle::zero(), Angle::zero()),
+ )?;
+
+ if self.inverted() {
+ self.set_surface_iso_and_coating(out_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ in_port,
+ &eff_iso.append(&thickness_iso).append(&wedge_iso),
+ &PortType::Output,
+ )?;
+ } else {
+ self.set_surface_iso_and_coating(in_port, &eff_iso, &PortType::Input)?;
+ self.set_surface_iso_and_coating(
+ out_port,
+ &eff_iso.append(&thickness_iso).append(&wedge_iso),
+ &PortType::Output,
+ )?;
+ };
+
+ let mut rays_bundle = vec![rays];
+ self.enter_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &refri,
+ self.inverted(),
+ in_port,
+ )?;
+ self.exit_through_surface(
+ &mut rays_bundle,
+ &AnalyzerType::RayTrace(config.clone()),
+ &self.ambient_idx(),
+ self.inverted(),
+ out_port,
+ )?;
+
+ let light_result = LightResult::from([(
+ out_port.into(),
+ LightData::Geometric(rays_bundle[0].clone()),
+ )]);
+ Ok(light_result)
+ }
+}
diff --git a/opossum/src/nodes/wedge/mod.rs b/opossum/src/nodes/wedge/mod.rs
index 6e365b29b844a9b1b275a1f6054eb2c1310e5d8e..1855e86ea2f9f1c89359688e314d1492661e8068 100644
--- a/opossum/src/nodes/wedge/mod.rs
+++ b/opossum/src/nodes/wedge/mod.rs
@@ -2,18 +2,17 @@ use std::collections::HashMap;
use super::NodeAttr;
use crate::{
- analyzers::{Analyzable, AnalyzerType},
+ analyzers::Analyzable,
dottable::Dottable,
- error::{OpmResult, OpossumError},
+ error::OpmResult,
millimeter,
optic_node::{Alignable, OpticNode},
optic_ports::{OpticPorts, PortType},
rays::Rays,
refractive_index::{RefrIndexConst, RefractiveIndex, RefractiveIndexType},
- surface::{hit_map::HitMap, OpticalSurface, Plane},
+ surface::{hit_map::HitMap, OpticalSurface, Plane, Surface},
utils::{geom_transformation::Isometry, EnumProxy},
};
-use nalgebra::Point3;
use num::Zero;
use uom::si::{
angle::degree,
@@ -123,132 +122,26 @@ impl Wedge {
wedge.node_attr.set_property("wedge", wedge_angle.into())?;
Ok(wedge)
}
- fn analyze_forward(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- wedge: Angle,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let wedge_iso = Isometry::new(
- Point3::origin(),
- Point3::new(wedge, Angle::zero(), Angle::zero()),
- )?;
- let isometry = iso.append(&thickness_iso).append(&wedge_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(refri))?;
- self.front_surf.set_backwards_rays_cache(reflected_front);
- rays.merge(self.front_surf.forward_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(&ambient_idx))?;
- self.rear_surf.set_backwards_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.forward_rays_cache());
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- Ok(rays)
- }
- fn analyze_inverse(
- &mut self,
- incoming_rays: Rays,
- thickness: Length,
- wedge: Angle,
- refri: &RefractiveIndexType,
- iso: &Isometry,
- analyzer_type: &AnalyzerType,
- ) -> OpmResult<Rays> {
- let ambient_idx = self.ambient_idx();
- let mut rays = incoming_rays;
- self.front_surf.set_isometry(iso);
- self.front_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Input, "front")
- .unwrap()
- .clone(),
- );
- let thickness_iso = Isometry::new_along_z(thickness)?;
- let wedge_iso = Isometry::new(
- Point3::origin(),
- Point3::new(wedge, Angle::zero(), Angle::zero()),
- )?;
- let isometry = iso.append(&thickness_iso).append(&wedge_iso);
- self.rear_surf.set_isometry(&isometry);
- self.rear_surf.set_coating(
- self.node_attr()
- .ports()
- .coating(&PortType::Output, "rear")
- .unwrap()
- .clone(),
- );
- if let Some(aperture) = self.ports().aperture(&PortType::Output, "front") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
- } else {
- return Err(OpossumError::OpticPort("output aperture not found".into()));
- };
- let reflected_rear = rays.refract_on_surface(&mut self.rear_surf, Some(refri))?;
- self.rear_surf.set_forward_rays_cache(reflected_rear);
- rays.merge(self.rear_surf.backwards_rays_cache());
- rays.set_refractive_index(refri)?;
- let reflected_front = rays.refract_on_surface(&mut self.front_surf, Some(&ambient_idx))?;
- self.front_surf.set_forward_rays_cache(reflected_front);
- rays.merge(self.front_surf.backwards_rays_cache());
- if let Some(aperture) = self.ports().aperture(&PortType::Input, "rear") {
- rays.apodize(aperture)?;
- if let AnalyzerType::RayTrace(config) = analyzer_type {
- rays.invalidate_by_threshold_energy(config.min_energy_per_ray())?;
- }
+}
+
+impl Surface for Wedge {
+ fn get_surface_mut(&mut self, surf_name: &str) -> &mut OpticalSurface {
+ if surf_name == "front" {
+ &mut self.front_surf
} else {
- return Err(OpossumError::OpticPort("input aperture not found".into()));
- };
- Ok(rays)
+ &mut self.rear_surf
+ }
}
}
impl OpticNode for Wedge {
fn reset_data(&mut self) {
- self.front_surf.set_backwards_rays_cache(Rays::default());
- self.front_surf.set_forward_rays_cache(Rays::default());
+ self.front_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.front_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.front_surf.reset_hit_map();
- self.rear_surf.set_backwards_rays_cache(Rays::default());
- self.rear_surf.set_forward_rays_cache(Rays::default());
+ self.rear_surf.set_backwards_rays_cache(Vec::<Rays>::new());
+ self.rear_surf.set_forward_rays_cache(Vec::<Rays>::new());
self.rear_surf.reset_hit_map();
}
fn hit_maps(&self) -> HashMap<String, HitMap> {
diff --git a/opossum/src/optic_node.rs b/opossum/src/optic_node.rs
index 9187627a221689bb7b21733693bbe25c47aa8687..5b5c2558f583ea73244110ca908a3c9c3b7064ef 100644
--- a/opossum/src/optic_node.rs
+++ b/opossum/src/optic_node.rs
@@ -18,7 +18,7 @@ use crate::{
optic_senery_rsc::SceneryResources,
properties::{Properties, Proptype},
refractive_index::RefractiveIndexType,
- reporting::analysis_report::NodeReport,
+ reporting::node_report::NodeReport,
surface::hit_map::HitMap,
utils::geom_transformation::Isometry,
};
diff --git a/opossum/src/plottable.rs b/opossum/src/plottable.rs
index c06e94fa96e328b0ab472f3a17da2afea4ac392e..afcc29312b381e024889e04560186021742e3121 100644
--- a/opossum/src/plottable.rs
+++ b/opossum/src/plottable.rs
@@ -1121,6 +1121,9 @@ impl PlotData {
]
}
Self::MultiDim3 { vec_of_xyz_data } => {
+ if vec_of_xyz_data.is_empty() {
+ return vec![None, None, None];
+ }
let num_cols = vec_of_xyz_data[0].row(0).len();
let mut max = vec![f64::NEG_INFINITY; num_cols];
let mut min = vec![f64::INFINITY; num_cols];
@@ -1147,6 +1150,9 @@ impl PlotData {
}
Self::MultiDim2 { vec_of_xy_data } => {
+ if vec_of_xy_data.is_empty() {
+ return vec![None, None];
+ }
let num_cols = vec_of_xy_data[0].row(0).len();
let mut max = vec![f64::NEG_INFINITY; num_cols];
let mut min = vec![f64::INFINITY; num_cols];
diff --git a/opossum/src/properties/mod.rs b/opossum/src/properties/mod.rs
index 605c5b9f1ebb490be2ad4fd6b25889469353f492..3b42b5014bf83c78a1052d6a80ffa18da140de7a 100644
--- a/opossum/src/properties/mod.rs
+++ b/opossum/src/properties/mod.rs
@@ -98,6 +98,10 @@ impl Properties {
pub fn iter(&self) -> std::collections::btree_map::Iter<'_, String, Property> {
self.props.iter()
}
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.props.is_empty()
+ }
/// Return `true`if a property with the given name exists.
#[must_use]
pub fn contains(&self, key: &str) -> bool {
@@ -142,21 +146,17 @@ impl Properties {
)
}
#[must_use]
- pub fn html_props(&self, node_name: &str, uuid: &str) -> Vec<HtmlProperty> {
+ pub fn html_props(&self, id: &str) -> Vec<HtmlProperty> {
let mut html_props: Vec<HtmlProperty> = Vec::new();
for prop in &self.props {
// Check if property is a NodeReport (= group node) and use the uuid of the individual sub nodes
// instead of the uuid of the group node itself.
- let node_uuid = if let Ok(Proptype::NodeReport(r)) = self.get(prop.0) {
- r.uuid()
- } else {
- uuid
- };
- if let Ok(html_prop_value) = prop
- .1
- .prop()
- .to_html((prop.0.to_owned() + "_" + node_name).as_str(), node_uuid)
- {
+ // let node_uuid = if let Ok(Proptype::NodeReport(r)) = self.get(prop.0) {
+ // r.uuid()
+ // } else {
+ // uuid
+ // };
+ if let Ok(html_prop_value) = prop.1.prop().to_html(id, prop.0) {
let html_prop = HtmlProperty {
name: prop.0.to_owned(),
description: prop.1.description().into(),
@@ -181,7 +181,7 @@ impl Properties {
pub fn export_data(&self, report_path: &Path, id: &str) -> OpmResult<()> {
for prop in &self.props {
prop.1
- .export_data(report_path, (prop.0.to_owned() + "_" + id).as_str())?;
+ .export_data(report_path, &format!("{id}_{}", prop.0))?;
}
Ok(())
}
diff --git a/opossum/src/properties/property.rs b/opossum/src/properties/property.rs
index d59129149643a6162d22965d1455b1f41580cb9d..2e416a1a510bee67c81dbdc42ad3ec894b3ff5a6 100644
--- a/opossum/src/properties/property.rs
+++ b/opossum/src/properties/property.rs
@@ -174,25 +174,23 @@ impl Property {
pub fn export_data(&self, report_path: &Path, id: &str) -> OpmResult<()> {
match &self.prop {
Proptype::SpotDiagram(spot_diagram) => {
- let file_path = report_path.join(Path::new(&format!("spot_diagram_{id}.svg")));
+ let file_path = report_path.join(Path::new(&format!("{id}.svg")));
spot_diagram.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
}
Proptype::FluenceDetector(fluence) => {
- let file_path = report_path.join(Path::new(&format!("fluence_diagram_{id}.png")));
+ let file_path = report_path.join(Path::new(&format!("{id}.png")));
fluence.to_plot(&file_path, crate::plottable::PltBackEnd::Bitmap)?;
}
Proptype::Spectrometer(spectrometer) => {
- let file_path = report_path.join(Path::new(&format!("spectrometer_{id}.svg")));
+ let file_path = report_path.join(Path::new(&format!("{id}.svg")));
spectrometer.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
}
Proptype::RayPositionHistory(ray_hist) => {
- let file_path = report_path.join(Path::new(&format!("ray_propagation_{id}.svg")));
- let mut ray_hist_clone = ray_hist.clone();
- ray_hist_clone.plot_view_direction = Some(vector![1.0, 0.0, 0.0]);
- ray_hist_clone.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
+ let file_path = report_path.join(Path::new(&format!("{id}.svg")));
+ ray_hist.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
}
Proptype::GhostFocusHistory(ghost_hist) => {
- let file_path = report_path.join(Path::new(&format!("ghost_propagation_{id}.svg")));
+ let file_path = report_path.join(Path::new(&format!("{id}.svg")));
let mut ghost_hist = ghost_hist.clone();
ghost_hist.plot_view_direction = Some(vector![1.0, 0.0, 0.0]);
ghost_hist.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
@@ -201,9 +199,15 @@ impl Property {
todo!()
}
Proptype::HitMap(hit_map) => {
- let file_path = report_path.join(Path::new(&format!("hit_map_{id}.svg")));
+ let file_path = report_path.join(Path::new(&format!("{id}.svg")));
hit_map.to_plot(&file_path, crate::plottable::PltBackEnd::SVG)?;
}
+ Proptype::NodeReport(report) => {
+ for prop in report.properties() {
+ prop.1
+ .export_data(report_path, &format!("{id}_{}_{}", report.uuid(), prop.0))?;
+ }
+ }
_ => {}
}
Ok(())
diff --git a/opossum/src/properties/proptype.rs b/opossum/src/properties/proptype.rs
index 896d345758c370d41e781f25762f372b9ad541d2..0bb7d3d36ed159eb9b8ef281938187942bde9c37 100644
--- a/opossum/src/properties/proptype.rs
+++ b/opossum/src/properties/proptype.rs
@@ -11,7 +11,7 @@ use crate::{
optic_ports::OpticPorts,
ray::SplittingConfig,
refractive_index::RefractiveIndexType,
- reporting::{analysis_report::NodeReport, html_report::HtmlNodeReport},
+ reporting::{html_report::HtmlNodeReport, node_report::NodeReport},
surface::hit_map::HitMap,
utils::{
geom_transformation::Isometry,
@@ -119,7 +119,7 @@ impl Proptype {
/// This function will return an error if
/// - underlying html templates could not be compiled
/// - a property value could not be converted to html code.
- pub fn to_html(&self, property_name: &str, uuid: &str) -> OpmResult<String> {
+ pub fn to_html(&self, id: &str, property_name: &str) -> OpmResult<String> {
let mut tt = TinyTemplate::new();
tt.add_template("simple", HTML_PROP_SIMPLE)
.map_err(|e| OpossumError::Other(e.to_string()))?;
@@ -134,30 +134,26 @@ impl Proptype {
Self::Bool(value) => tt.render("simple", &format!("{value}")),
Self::SpectrometerType(value) => tt.render("simple", &value.to_string()),
Self::Metertype(value) => tt.render("simple", &value.to_string()),
- Self::Spectrometer(_) => tt.render(
- "image",
- &format!("data/spectrometer_{property_name}_{uuid}.svg"),
- ),
- Self::SpotDiagram(_) => tt.render(
- "image",
- &format!("data/spot_diagram_{property_name}_{uuid}.svg"),
- ),
- Self::HitMap(_) => {
- tt.render("image", &format!("data/hit_map_{property_name}_{uuid}.svg"))
+ Self::Spectrometer(_)
+ | Self::SpotDiagram(_)
+ | Self::HitMap(_)
+ | Self::RayPositionHistory(_)
+ | Self::GhostFocusHistory(_) => {
+ tt.render("image", &format!("data/{id}_{property_name}.svg"))
}
- Self::WaveFrontData(_value) => tt.render(
- "image",
- &format!("data/wavefront_diagram_{property_name}_{uuid}.png"),
- ),
- Self::FluenceDetector(_value) => {
- tt.render("image", &format!("data/fluence_{property_name}_{uuid}.png"))
+ Self::WaveFrontData(_) | Self::FluenceDetector(_) => {
+ tt.render("image", &format!("data/{id}_{property_name}.png"))
}
Self::NodeReport(report) => {
let html_node_report = HtmlNodeReport {
node_name: report.name().into(),
node_type: report.node_type().into(),
- props: report.properties().html_props(report.name(), uuid),
- uuid: uuid.to_string(),
+ props: report.properties().html_props(&format!(
+ "{id}_{}_{}",
+ report.name(),
+ report.uuid()
+ )),
+ uuid: report.uuid().to_string(),
};
tt.render("group", &html_node_report)
}
@@ -179,15 +175,6 @@ impl Proptype {
),
Self::Length(value) => tt.render("simple", &format_quantity(meter, *value)),
Self::Energy(value) => tt.render("simple", &format_quantity(joule, *value)),
- Self::RayPositionHistory(_) => tt.render(
- "image",
- &format!("data/ray_propagation_{property_name}_{uuid}.svg"),
- ),
- Self::GhostFocusHistory(_) => tt.render(
- "image",
- &format!("data/ghost_propagation_{property_name}_{uuid}.svg"),
- ),
-
_ => Ok("unknown property type".into()),
};
string_value.map_err(|e| OpossumError::Other(e.to_string()))
diff --git a/opossum/src/ray.rs b/opossum/src/ray.rs
index 8e29c9a1843b67e1634757f7dc4d270a89976db7..38cf782542c8931431853ea9f5286b360736a94c 100644
--- a/opossum/src/ray.rs
+++ b/opossum/src/ray.rs
@@ -442,6 +442,8 @@ impl Ray {
self.dir = refract_dir;
self.e = input_energy * (1. - reflectivity);
let mut reflected_ray = self.clone();
+ reflected_ray.pos_hist.clear();
+ reflected_ray.add_to_pos_hist(reflected_ray.pos);
reflected_ray.dir = reflected_dir;
reflected_ray.e = input_energy * reflectivity;
reflected_ray.number_of_bounces += 1;
@@ -1005,7 +1007,7 @@ mod test {
assert_eq!(reflected_ray.pos, millimeter!(0., 0., 10.));
assert_eq!(reflected_ray.refractive_index, 1.0);
assert_eq!(reflected_ray.dir, -1.0 * Vector3::z());
- assert_eq!(reflected_ray.pos_hist, vec![Point3::origin()]);
+ assert_eq!(reflected_ray.pos_hist, vec![millimeter!(0., 0., 10.)]);
assert_eq!(reflected_ray.path_length(), plane_z_pos);
assert_eq!(reflected_ray.number_of_bounces(), 1);
assert_eq!(reflected_ray.number_of_refractions(), 0);
diff --git a/opossum/src/reporting/analysis_report.rs b/opossum/src/reporting/analysis_report.rs
index 107d8c569ae658bcd5f7b0f40d45c6a08282c4f1..9f9fc1049cdee202df69abd5da2f85faa0456e25 100644
--- a/opossum/src/reporting/analysis_report.rs
+++ b/opossum/src/reporting/analysis_report.rs
@@ -3,15 +3,17 @@
use std::path::Path;
-use super::html_report::{HtmlNodeReport, HtmlReport};
+use super::{
+ html_report::{HtmlNodeReport, HtmlReport},
+ node_report::NodeReport,
+};
use crate::{
error::{OpmResult, OpossumError},
nodes::NodeGroup,
optic_node::OpticNode,
- properties::{Properties, Proptype},
};
use chrono::{DateTime, Local};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
#[derive(Serialize, Debug, Clone)]
/// Structure for storing data being integrated in an analysis report.
@@ -57,10 +59,7 @@ impl AnalysisReport {
pub fn export_data(&self, report_path: &Path) -> OpmResult<()> {
let report_path = report_path.join(Path::new("data"));
for node_report in &self.node_reports {
- node_report.properties.export_data(
- &report_path,
- &format!("{}_{}", &node_report.name, &node_report.uuid),
- )?;
+ node_report.export_data(&report_path, "")?;
}
Ok(())
}
@@ -76,7 +75,7 @@ impl AnalysisReport {
let html_node_reports: Vec<HtmlNodeReport> = self
.node_reports
.iter()
- .map(NodeReport::to_html_node_report)
+ .map(|r| r.to_html_node_report(""))
.collect();
Ok(HtmlReport::new(
self.opossum_version.clone(),
@@ -94,64 +93,10 @@ impl AnalysisReport {
}
}
-#[derive(Serialize, Deserialize, Clone, Debug)]
-/// Structure for storing node specific data to be integrated in the [`AnalysisReport`].
-pub struct NodeReport {
- node_type: String,
- name: String,
- uuid: String,
- properties: Properties,
-}
-impl NodeReport {
- /// Creates a new [`NodeReport`].
- #[must_use]
- pub fn new(node_type: &str, name: &str, uuid: &str, properties: Properties) -> Self {
- Self {
- node_type: node_type.to_owned(),
- name: name.to_owned(),
- uuid: uuid.to_string(),
- properties,
- }
- }
- /// Returns a reference to the node type of this [`NodeReport`].
- #[must_use]
- pub fn node_type(&self) -> &str {
- self.node_type.as_ref()
- }
- /// Returns a reference to the name of this [`NodeReport`].
- #[must_use]
- pub fn name(&self) -> &str {
- self.name.as_ref()
- }
- /// Returns a reference to the properties of this [`NodeReport`].
- #[must_use]
- pub const fn properties(&self) -> &Properties {
- &self.properties
- }
- /// Return an [`HtmlNodeReport`] from this [`NodeReport`].
- #[must_use]
- pub fn to_html_node_report(&self) -> HtmlNodeReport {
- HtmlNodeReport {
- node_name: self.name.clone(),
- node_type: self.node_type.clone(),
- props: self.properties.html_props(self.name(), &self.uuid),
- uuid: self.uuid.clone(),
- }
- }
- /// Returns a reference to the uuid of this [`NodeReport`].
- #[must_use]
- pub fn uuid(&self) -> &str {
- &self.uuid
- }
-}
-
-impl From<NodeReport> for Proptype {
- fn from(value: NodeReport) -> Self {
- Self::NodeReport(value)
- }
-}
#[cfg(test)]
mod test {
+ use crate::properties::Properties;
+
use super::*;
#[test]
fn analysis_report_new() {
@@ -179,15 +124,4 @@ mod test {
));
assert_eq!(report.node_reports.len(), 1);
}
- #[test]
- fn node_report_new() {
- let report = NodeReport::new(
- "test detector",
- "detector name",
- "123",
- Properties::default(),
- );
- assert_eq!(report.node_type, "test detector");
- assert_eq!(report.name, "detector name");
- }
}
diff --git a/opossum/src/reporting/mod.rs b/opossum/src/reporting/mod.rs
index d51d2614ff27a0a51428538d93877eaf75248c66..500f605333037b0b8c3e43fb23559e2bc7175a8d 100644
--- a/opossum/src/reporting/mod.rs
+++ b/opossum/src/reporting/mod.rs
@@ -1,2 +1,3 @@
pub mod analysis_report;
pub mod html_report;
+pub mod node_report;
diff --git a/opossum/src/reporting/node_report.rs b/opossum/src/reporting/node_report.rs
new file mode 100644
index 0000000000000000000000000000000000000000..73f1aa34eb5405237d1bf4f7623ae7a5171b69cb
--- /dev/null
+++ b/opossum/src/reporting/node_report.rs
@@ -0,0 +1,94 @@
+use std::path::Path;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+ error::OpmResult,
+ properties::{Properties, Proptype},
+};
+
+use super::html_report::HtmlNodeReport;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+/// Structure for storing node specific data to be integrated in the [`AnalysisReport`].
+pub struct NodeReport {
+ node_type: String,
+ name: String,
+ uuid: String,
+ properties: Properties,
+}
+impl NodeReport {
+ /// Creates a new [`NodeReport`].
+ #[must_use]
+ pub fn new(node_type: &str, name: &str, uuid: &str, properties: Properties) -> Self {
+ Self {
+ node_type: node_type.to_owned(),
+ name: name.to_owned(),
+ uuid: uuid.to_string(),
+ properties,
+ }
+ }
+ /// Returns a reference to the node type of this [`NodeReport`].
+ #[must_use]
+ pub fn node_type(&self) -> &str {
+ self.node_type.as_ref()
+ }
+ /// Returns a reference to the name of this [`NodeReport`].
+ #[must_use]
+ pub fn name(&self) -> &str {
+ self.name.as_ref()
+ }
+ /// Returns a reference to the properties of this [`NodeReport`].
+ #[must_use]
+ pub const fn properties(&self) -> &Properties {
+ &self.properties
+ }
+ /// Return an [`HtmlNodeReport`] from this [`NodeReport`].
+ #[must_use]
+ pub fn to_html_node_report(&self, id: &str) -> HtmlNodeReport {
+ HtmlNodeReport {
+ node_name: self.name.clone(),
+ node_type: self.node_type.clone(),
+ props: self
+ .properties
+ .html_props(&format!("{id}_{}_{}", self.name, self.uuid)),
+ uuid: self.uuid.clone(),
+ }
+ }
+ /// Returns a reference to the uuid of this [`NodeReport`].
+ #[must_use]
+ pub fn uuid(&self) -> &str {
+ &self.uuid
+ }
+ /// .
+ ///
+ /// # Errors
+ ///
+ /// This function will return an error if .
+ pub fn export_data(&self, report_path: &Path, id: &str) -> OpmResult<()> {
+ self.properties
+ .export_data(report_path, &format!("{id}_{}_{}", &self.name, &self.uuid))
+ }
+}
+
+impl From<NodeReport> for Proptype {
+ fn from(value: NodeReport) -> Self {
+ Self::NodeReport(value)
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ #[test]
+ fn node_report_new() {
+ let report = NodeReport::new(
+ "test detector",
+ "detector name",
+ "123",
+ Properties::default(),
+ );
+ assert_eq!(report.node_type, "test detector");
+ assert_eq!(report.name, "detector name");
+ }
+}
diff --git a/opossum/src/surface/hit_map.rs b/opossum/src/surface/hit_map.rs
index 3e736d7667f28ed6b140f527278285213c11efa7..da2c1d0c5c2e2a343d4d18c5c0c9f9a4991690ac 100644
--- a/opossum/src/surface/hit_map.rs
+++ b/opossum/src/surface/hit_map.rs
@@ -19,23 +19,37 @@ use crate::{
/// [`OpticalSurface`](crate::surface::OpticalSurface).
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct HitMap {
- hit_map: Vec<Vec<(Point3<Length>, Energy)>>,
+ /// Stores the hitpoints of the rays on this surface, separated by their bounce level and the individual ray bundle
+ /// First Vec stores a vector of hitmaps from different ray bundles, sorted by their bounce level
+ /// Second Vec stores the hitmaps of the individual ray bundle. No sorting.
+ /// Last vec stores the hitpoints of one ray bundle on this surface
+ #[allow(clippy::type_complexity)]
+ hit_map: Vec<Vec<Vec<(Point3<Length>, Energy)>>>,
}
impl HitMap {
/// Returns a reference to the hit map of this [`HitMap`].
///
/// This function returns a vector of intersection points (with energies) of [`Rays`](crate::rays::Rays) that hit the surface.
#[must_use]
- pub fn hit_map(&self) -> &[Vec<(Point3<Length>, Energy)>] {
+ #[allow(clippy::type_complexity)]
+ pub fn hit_map(&self) -> &[Vec<Vec<(Point3<Length>, Energy)>>] {
&self.hit_map
}
/// Add intersection point (with energy) to this [`HitMap`].
///
- pub fn add_point(&mut self, hit_point: (Point3<Length>, Energy), bounce: usize) {
+ pub fn add_to_hitmap(&mut self, hit_point: (Point3<Length>, Energy), bounce: usize) {
if self.hit_map.len() <= bounce {
- self.hit_map.push(vec![hit_point]);
+ for _i in 0..=bounce {
+ if self.hit_map.len() < bounce {
+ self.hit_map.push(vec![vec![]]);
+ }
+ }
+ self.hit_map.push(vec![vec![hit_point]]);
} else {
- self.hit_map[bounce].push(hit_point);
+ let hm_len = self.hit_map[bounce].len();
+ if hm_len > 0 {
+ self.hit_map[bounce][hm_len - 1].push(hit_point);
+ }
}
}
/// Reset this [`HitMap`].
@@ -62,83 +76,92 @@ impl Plottable for HitMap {
_legend: bool,
) -> OpmResult<Option<Vec<PlotSeries>>> {
//ray plot series
- let mut plt_series = Vec::<PlotSeries>::with_capacity(self.hit_map.len());
- let mut xy_positions = Vec::<Vec<Point2<Length>>>::with_capacity(self.hit_map.len());
- let mut x_max = f64::NEG_INFINITY;
- let mut y_max = f64::NEG_INFINITY;
- let mut x_min = f64::INFINITY;
- let mut y_min = f64::INFINITY;
+ if self.hit_map.is_empty() {
+ Ok(None)
+ } else {
+ let mut plt_series = Vec::<PlotSeries>::with_capacity(self.hit_map.len());
+ let mut xy_positions = Vec::<Vec<Point2<Length>>>::with_capacity(self.hit_map.len());
+ let mut x_max = f64::NEG_INFINITY;
+ let mut y_max = f64::NEG_INFINITY;
+ let mut x_min = f64::INFINITY;
+ let mut y_min = f64::INFINITY;
- for hit_map in &self.hit_map {
- let mut xy_pos = Vec::<Point2<Length>>::with_capacity(hit_map.len());
- for p in hit_map {
- xy_pos.push(Point2::new(p.0.x, p.0.y));
+ for bounced_ray_bundles in &self.hit_map {
+ for ray_bundle in bounced_ray_bundles {
+ let mut xy_pos = Vec::<Point2<Length>>::with_capacity(ray_bundle.len());
+ for p in ray_bundle {
+ xy_pos.push(Point2::new(p.0.x, p.0.y));
- x_max = x_max.max(p.0.x.value);
- y_max = y_max.max(p.0.y.value);
- x_min = x_min.min(p.0.x.value);
- y_min = y_min.min(p.0.y.value);
+ x_max = x_max.max(p.0.x.value);
+ y_max = y_max.max(p.0.y.value);
+ x_min = x_min.min(p.0.x.value);
+ y_min = y_min.min(p.0.y.value);
+ }
+ xy_positions.push(xy_pos);
+ }
}
- xy_positions.push(xy_pos);
- }
- let x_exponent = get_exponent_for_base_unit_in_e3_steps(x_max);
- let y_exponent = get_exponent_for_base_unit_in_e3_steps(y_max);
- let y_prefix = get_prefix_for_base_unit(y_max);
- let x_prefix = get_prefix_for_base_unit(x_max);
+ let x_exponent = get_exponent_for_base_unit_in_e3_steps(x_max);
+ let y_exponent = get_exponent_for_base_unit_in_e3_steps(y_max);
+ let y_prefix = get_prefix_for_base_unit(y_max);
+ let x_prefix = get_prefix_for_base_unit(x_max);
- plt_type.set_plot_param(&PlotArgs::XLabel(format!("x position ({y_prefix}m)")))?;
- plt_type.set_plot_param(&PlotArgs::YLabel(format!("y position ({x_prefix}m)")))?;
+ plt_type.set_plot_param(&PlotArgs::XLabel(format!("x position ({y_prefix}m)")))?;
+ plt_type.set_plot_param(&PlotArgs::YLabel(format!("y position ({x_prefix}m)")))?;
- for (i, xy_pos) in xy_positions.iter().enumerate() {
- let x_vals = xy_pos
- .iter()
- .map(|p| get_unit_value_as_length_with_format_by_exponent(p.x, x_exponent))
- .collect::<Vec<f64>>();
- let y_vals = xy_pos
- .iter()
- .map(|p| get_unit_value_as_length_with_format_by_exponent(p.y, y_exponent))
- .collect::<Vec<f64>>();
+ for (i, xy_pos) in xy_positions.iter().enumerate() {
+ if xy_pos.is_empty() {
+ continue;
+ }
+ let x_vals = xy_pos
+ .iter()
+ .map(|p| get_unit_value_as_length_with_format_by_exponent(p.x, x_exponent))
+ .collect::<Vec<f64>>();
+ let y_vals = xy_pos
+ .iter()
+ .map(|p| get_unit_value_as_length_with_format_by_exponent(p.y, y_exponent))
+ .collect::<Vec<f64>>();
- let data = PlotData::Dim2 {
- xy_data: MatrixXx2::from_columns(&[
- DVector::from_vec(x_vals),
- DVector::from_vec(y_vals),
- ]),
- };
+ let data = PlotData::Dim2 {
+ xy_data: MatrixXx2::from_columns(&[
+ DVector::from_vec(x_vals),
+ DVector::from_vec(y_vals),
+ ]),
+ };
- let gradient = colorous::TURBO;
- let c = if self.hit_map.len() > 10 {
- gradient.eval_rational(i, self.hit_map.len())
- } else {
- colorous::CATEGORY10[i]
- };
- let label = format!("Bounce: {i}");
- plt_series.push(PlotSeries::new(
- &data,
- RGBAColor(c.r, c.g, c.b, 1.),
- Some(label),
- ));
- }
+ let gradient = colorous::TURBO;
+ let c = if self.hit_map.len() > 10 {
+ gradient.eval_rational(i, self.hit_map.len())
+ } else {
+ colorous::CATEGORY10[i]
+ };
+ let label = format!("Bounce: {i}");
+ plt_series.push(PlotSeries::new(
+ &data,
+ RGBAColor(c.r, c.g, c.b, 1.),
+ Some(label),
+ ));
+ }
- x_max *= f64::powi(10., -x_exponent);
- y_max *= f64::powi(10., -y_exponent);
- x_min *= f64::powi(10., -x_exponent);
- y_min *= f64::powi(10., -y_exponent);
+ x_max *= f64::powi(10., -x_exponent);
+ y_max *= f64::powi(10., -y_exponent);
+ x_min *= f64::powi(10., -x_exponent);
+ y_min *= f64::powi(10., -y_exponent);
- let x_diff = x_max - x_min;
- let y_diff = y_max - y_min;
- let x_limits = AxLims::create_useful_axlims(
- 0.1f64.mul_add(-x_diff, x_min),
- 0.1f64.mul_add(x_diff, x_max),
- );
- let y_limits = AxLims::create_useful_axlims(
- 0.1f64.mul_add(-y_diff, y_min),
- 0.1f64.mul_add(y_diff, y_max),
- );
+ let x_diff = x_max - x_min;
+ let y_diff = y_max - y_min;
+ let x_limits = AxLims::create_useful_axlims(
+ 0.1f64.mul_add(-x_diff, x_min),
+ 0.1f64.mul_add(x_diff, x_max),
+ );
+ let y_limits = AxLims::create_useful_axlims(
+ 0.1f64.mul_add(-y_diff, y_min),
+ 0.1f64.mul_add(y_diff, y_max),
+ );
- plt_type.set_plot_param(&PlotArgs::XLim(x_limits))?;
- plt_type.set_plot_param(&PlotArgs::YLim(y_limits))?;
- Ok(Some(plt_series))
+ plt_type.set_plot_param(&PlotArgs::XLim(x_limits))?;
+ plt_type.set_plot_param(&PlotArgs::YLim(y_limits))?;
+ Ok(Some(plt_series))
+ }
}
fn add_plot_specific_params(&self, plt_params: &mut PlotParameters) -> OpmResult<()> {
plt_params
diff --git a/opossum/src/surface/mod.rs b/opossum/src/surface/mod.rs
index 5377bd20449254cd0de52ec11b53f3cecc4c735e..c174fcad696d5e90bbb3f606cd0868326ac53e8f 100644
--- a/opossum/src/surface/mod.rs
+++ b/opossum/src/surface/mod.rs
@@ -62,3 +62,9 @@ impl Debug for dyn GeoSurface {
write!(f, "Surface")
}
}
+
+///Surface trait
+pub trait Surface {
+ ///returns a mutable reference to the surface with a given name
+ fn get_surface_mut(&mut self, surf_name: &str) -> &mut OpticalSurface;
+}
diff --git a/opossum/src/surface/optical_surface.rs b/opossum/src/surface/optical_surface.rs
index 9cf78e72f8bf32a19a140f566d102e09b4098b04..bb045f3adb0d015078e29efab2d019c237af5f61 100644
--- a/opossum/src/surface/optical_surface.rs
+++ b/opossum/src/surface/optical_surface.rs
@@ -10,8 +10,8 @@ use crate::{coatings::CoatingType, rays::Rays, utils::geom_transformation::Isome
pub struct OpticalSurface {
geo_surface: Box<dyn GeoSurface>,
coating: CoatingType,
- backward_rays_cache: Rays,
- forward_rays_cache: Rays,
+ backward_rays_cache: Vec<Rays>,
+ forward_rays_cache: Vec<Rays>,
hit_map: HitMap,
}
impl Default for OpticalSurface {
@@ -19,8 +19,8 @@ impl Default for OpticalSurface {
Self {
geo_surface: Box::new(Plane::new(&Isometry::identity())),
coating: CoatingType::IdealAR,
- backward_rays_cache: Rays::default(),
- forward_rays_cache: Rays::default(),
+ backward_rays_cache: Vec::<Rays>::new(),
+ forward_rays_cache: Vec::<Rays>::new(),
hit_map: HitMap::default(),
}
}
@@ -43,8 +43,8 @@ impl OpticalSurface {
Self {
geo_surface,
coating: CoatingType::IdealAR,
- backward_rays_cache: Rays::default(),
- forward_rays_cache: Rays::default(),
+ backward_rays_cache: Vec::<Rays>::new(),
+ forward_rays_cache: Vec::<Rays>::new(),
hit_map: HitMap::default(),
}
}
@@ -63,21 +63,29 @@ impl OpticalSurface {
&(*self.geo_surface)
}
/// Sets the backwards rays cache of this [`OpticalSurface`].
- pub fn set_backwards_rays_cache(&mut self, backward_rays_cache: Rays) {
+ pub fn set_backwards_rays_cache(&mut self, backward_rays_cache: Vec<Rays>) {
self.backward_rays_cache = backward_rays_cache;
}
+ /// Adds a rays bundle to the backwards rays cache of this [`OpticalSurface`].
+ pub fn add_to_backward_rays_cache(&mut self, rays: Rays) {
+ self.backward_rays_cache.push(rays);
+ }
/// Returns a reference to the backwards rays cache of this [`OpticalSurface`].
#[must_use]
- pub const fn backwards_rays_cache(&self) -> &Rays {
+ pub const fn backwards_rays_cache(&self) -> &Vec<Rays> {
&self.backward_rays_cache
}
/// Sets the forward rays cache of this [`OpticalSurface`].
- pub fn set_forward_rays_cache(&mut self, forward_rays_cache: Rays) {
+ pub fn set_forward_rays_cache(&mut self, forward_rays_cache: Vec<Rays>) {
self.forward_rays_cache = forward_rays_cache;
}
+ /// Adds a rays bundle to the forward rays cache of this [`OpticalSurface`].
+ pub fn add_to_forward_rays_cache(&mut self, rays: Rays) {
+ self.forward_rays_cache.push(rays);
+ }
/// Returns a reference to the forward rays cache of this [`OpticalSurface`].
#[must_use]
- pub const fn forward_rays_cache(&self) -> &Rays {
+ pub const fn forward_rays_cache(&self) -> &Vec<Rays> {
&self.forward_rays_cache
}
/// Sets the isometry of this [`OpticalSurface`].
@@ -94,7 +102,7 @@ impl OpticalSurface {
/// Add intersection point (with energy) to hit map.
///
pub fn add_to_hit_map(&mut self, hit_point: (Point3<Length>, Energy), bounce: usize) {
- self.hit_map.add_point(hit_point, bounce);
+ self.hit_map.add_to_hitmap(hit_point, bounce);
}
/// Reset hit map of this [`OpticalSurface`].
pub fn reset_hit_map(&mut self) {