18887449607

Committed 28 Oct 2025 07:53PM UTC coverage: 89.87% (-0.08%) from 89.946%

Build # 18887449607

Build Type

Pull #76

github

Committed by

web-flow

Commit Message

Merge e0df5f970 into f6f121007

Pull Request Pull Request #76: Fix NativeRunner ray tracing failure for parabola surface

Run Details

944 of 994 new or added lines in 28 files covered. (94.97%)

2 existing lines in 1 file now uncovered.

4418 of 4916 relevant lines covered (89.87%)

10138914.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.43

/coretrace/simulation_data/composite_element.hpp

/**
 * @file composite_element.hpp
 * @brief Composite element class for complex optical systems
 *
 * Defines the CompositeElement class which can contain multiple
 * sub-elements, allowing for hierarchical optical system definitions.
 * Enables grouping of related optical elements for easier management
 * and coordinate transformations.
 *
 * @defgroup elements Optical Elements
 * @{
 */

#ifndef SOLTRACE_COMPOSITE_ELEMENT_H
#define SOLTRACE_COMPOSITE_ELEMENT_H

#include <memory>

#include "container.hpp"
#include "element.hpp"

namespace SolTrace::Data
{

    class CompositeElement : public ElementBase
    {
    public:
        /**
         * @brief Default constructor for composite element
         */
        CompositeElement();
        virtual ~CompositeElement();

        /**
         * @brief Disable this composite element and all sub-elements
         */
        virtual void disable() const override;

        /**
         * @brief Enable this composite element and all sub-elements
         */
        virtual void enable() const override;

        /**
         * @brief Check if this element is composite
         * @return Always returns true for composite elements
         */
        virtual bool is_composite() const override
        {
            return true;
        }

        virtual void mark_virtual() const override;
        virtual void unmark_virtual() const override;

        /**
         * @brief Set the stage number for this composite element
         * @param stage Stage number to assign
         */
        virtual void set_stage(int_fast64_t stage) override;

        /**
         * @brief Get the number of sub-elements in this composite
         * @return Number of elements contained in this composite
         */
        virtual uint_fast64_t get_number_of_elements() const override
        {
            // return this->my_elements.get_number_of_items();
            return this->number_of_elements;
        }

        // Element interface functions
        /**
         * @brief Get aperture pointer (always null for composite elements)
         * @return nullptr (composite elements don't have apertures)
         */
        virtual const aperture_ptr get_aperture() const override { return nullptr; }

        /**
         * @brief Get aperture pointer (always null for composite elements)
         * @return nullptr (composite elements don't have apertures)
         */
        virtual aperture_ptr get_aperture() override { return nullptr; }

        /**
         * @brief Set aperture (no-op for composite elements)
         * @param aperture_ptr Ignored for composite elements
         */
        virtual void set_aperture(aperture_ptr) override {}

        /**
         * @brief Get surface pointer (always null for composite elements)
         * @return nullptr (composite elements don't have surfaces)
         */
        virtual const surface_ptr get_surface() const override { return nullptr; }

        /**
         * @brief Get surface pointer (always null for composite elements)
         * @return nullptr (composite elements don't have surfaces)
         */
        virtual surface_ptr get_surface() override { return nullptr; }

        /**
         * @brief Set surface (no-op for composite elements)
         * @param surface_ptr Ignored for composite elements
         */
        virtual void set_surface(surface_ptr) override {}

        /**
         * @brief Get front optical properties (always null for composite elements)
         * @return nullptr (composite elements don't have optical properties)
         */
        virtual const OpticalProperties *get_front_optical_properties() const override
        {
            return nullptr;
        }

        /**
         * @brief Get front optical properties (always null for composite elements)
         * @return nullptr (composite elements don't have optical properties)
         */
        virtual OpticalProperties *get_front_optical_properties() override
        {
            return nullptr;
        }

        /**
         * @brief Set front optical properties (no-op for composite elements)
         * @param op Ignored for composite elements
         */
        virtual void set_front_optical_properties(const OpticalProperties &) override {}

        /**
         * @brief Get back optical properties (always null for composite elements)
         * @return nullptr (composite elements don't have optical properties)
         */
        virtual const OpticalProperties *get_back_optical_properties() const override
        {
            return nullptr;
        }

        /**
         * @brief Get back optical properties (always null for composite elements)
         * @return nullptr (composite elements don't have optical properties)
         */
        virtual OpticalProperties *get_back_optical_properties() override
        {
            return nullptr;
        }

        /**
         * @brief Set back optical properties (no-op for composite elements)
         * @param op Ignored for composite elements
         */
        virtual void set_back_optical_properties(const OpticalProperties &) override {};

        // CompositeElement accessors
        /**
         * @brief Add an element to this composite
         * @param el Shared pointer to element to add
         * @return Element ID of the added element
         */
        element_id add_element(element_ptr el);

        /**
         * @brief Remove an element from this composite
         * @param id Element ID to remove
         * @return Number of elements removed (0 or 1)
         */
        uint_fast64_t remove_element(element_id id);

        /**
         * @brief Get an element by ID
         * @param id Element ID to retrieve
         * @return Shared pointer to element, or null if not found
         */
        element_ptr get_element(element_id id);

        /**
         * @brief Replace an element with a new one
         * @param id Element ID to replace
         * @param el New element to insert
         * @return True if replacement was successful
         */
        bool replace_element(element_id id, element_ptr el);

        /**
         * @brief Remove all elements from this composite
         */
        void clear();

        // uint64_t get_total_number_of_elements() const
        // {
        //     return this->my_elements.get_total_number_of_items();
        // }

        /**
         * @brief Get iterator to beginning of element container
         * @return Iterator to first element
         */
        virtual ElementContainer::iterator get_iterator()
        {
            return this->my_elements.get_iterator();
        }
        virtual ElementContainer::const_iterator get_const_iterator() const
        {
            return this->my_elements.get_const_iterator();
        }
        virtual bool is_at_end(ElementContainer::iterator iter)
        {
            return this->my_elements.is_at_end(iter);
        }
        virtual bool is_at_end(ElementContainer::const_iterator citer) const
        {
            return this->my_elements.is_at_end(citer);
        }

        virtual void enforce_user_fields_set() const override;

    private:
        uint_fast64_t number_of_elements;
        ElementContainer my_elements;
    };

    using composite_element_ptr = std::shared_ptr<CompositeElement>;

} // namespace SolTrace::Data

#endif

/**
 * @}
 */

1	/**
2	* @file composite_element.hpp
3	* @brief Composite element class for complex optical systems
4	*
5	* Defines the CompositeElement class which can contain multiple
6	* sub-elements, allowing for hierarchical optical system definitions.
7	* Enables grouping of related optical elements for easier management
8	* and coordinate transformations.
9	*
10	* @defgroup elements Optical Elements
11	* @{
12	*/
13
14	#ifndef SOLTRACE_COMPOSITE_ELEMENT_H
15	#define SOLTRACE_COMPOSITE_ELEMENT_H
16
17	#include <memory>
18
19	#include "container.hpp"
20	#include "element.hpp"
21
22	namespace SolTrace::Data
23	{
24
25	class CompositeElement : public ElementBase
26	{
27	public:
28	/**
29	* @brief Default constructor for composite element
30	*/
31	CompositeElement();
32	virtual ~CompositeElement();
33
34	/**
35	* @brief Disable this composite element and all sub-elements
36	*/
37	virtual void disable() const override;
38
39	/**
40	* @brief Enable this composite element and all sub-elements
41	*/
42	virtual void enable() const override;
43
44	/**
45	* @brief Check if this element is composite
46	* @return Always returns true for composite elements
47	*/
48	virtual bool is_composite() const override	523✔
49	{
50	return true;	523✔
51	}
52
53	virtual void mark_virtual() const override;
54	virtual void unmark_virtual() const override;
55
56	/**
57	* @brief Set the stage number for this composite element
58	* @param stage Stage number to assign
59	*/
60	virtual void set_stage(int_fast64_t stage) override;
61
62	/**
63	* @brief Get the number of sub-elements in this composite
64	* @return Number of elements contained in this composite
65	*/
66	virtual uint_fast64_t get_number_of_elements() const override	795✔
67	{
68	// return this->my_elements.get_number_of_items();
69	return this->number_of_elements;	795✔
70	}
71
72	// Element interface functions
73	/**
74	* @brief Get aperture pointer (always null for composite elements)
75	* @return nullptr (composite elements don't have apertures)
76	*/
NEW 77	virtual const aperture_ptr get_aperture() const override { return nullptr; }	×
78
79	/**
80	* @brief Get aperture pointer (always null for composite elements)
81	* @return nullptr (composite elements don't have apertures)
82	*/
83	virtual aperture_ptr get_aperture() override { return nullptr; }	2✔
84
85	/**
86	* @brief Set aperture (no-op for composite elements)
87	* @param aperture_ptr Ignored for composite elements
88	*/
NEW 89	virtual void set_aperture(aperture_ptr) override {}	×
90
91	/**
92	* @brief Get surface pointer (always null for composite elements)
93	* @return nullptr (composite elements don't have surfaces)
94	*/
NEW 95	virtual const surface_ptr get_surface() const override { return nullptr; }	×
96
97	/**
98	* @brief Get surface pointer (always null for composite elements)
99	* @return nullptr (composite elements don't have surfaces)
100	*/
101	virtual surface_ptr get_surface() override { return nullptr; }	2✔
102
103	/**
104	* @brief Set surface (no-op for composite elements)
105	* @param surface_ptr Ignored for composite elements
106	*/
NEW 107	virtual void set_surface(surface_ptr) override {}	×
108
109	/**
110	* @brief Get front optical properties (always null for composite elements)
111	* @return nullptr (composite elements don't have optical properties)
112	*/
NEW 113	virtual const OpticalProperties *get_front_optical_properties() const override	×
114	{
NEW 115	return nullptr;	×
116	}
117
118	/**
119	* @brief Get front optical properties (always null for composite elements)
120	* @return nullptr (composite elements don't have optical properties)
121	*/
122	virtual OpticalProperties *get_front_optical_properties() override	2✔
123	{
124	return nullptr;	2✔
125	}
126
127	/**
128	* @brief Set front optical properties (no-op for composite elements)
129	* @param op Ignored for composite elements
130	*/
131	virtual void set_front_optical_properties(const OpticalProperties &) override {}	1✔
132
133	/**
134	* @brief Get back optical properties (always null for composite elements)
135	* @return nullptr (composite elements don't have optical properties)
136	*/
NEW 137	virtual const OpticalProperties *get_back_optical_properties() const override	×
138	{
NEW 139	return nullptr;	×
140	}
141
142	/**
143	* @brief Get back optical properties (always null for composite elements)
144	* @return nullptr (composite elements don't have optical properties)
145	*/
146	virtual OpticalProperties *get_back_optical_properties() override	2✔
147	{
148	return nullptr;	2✔
149	}
150
151	/**
152	* @brief Set back optical properties (no-op for composite elements)
153	* @param op Ignored for composite elements
154	*/
155	virtual void set_back_optical_properties(const OpticalProperties &) override {};	1✔
156
157	// CompositeElement accessors
158	/**
159	* @brief Add an element to this composite
160	* @param el Shared pointer to element to add
161	* @return Element ID of the added element
162	*/
163	element_id add_element(element_ptr el);
164
165	/**
166	* @brief Remove an element from this composite
167	* @param id Element ID to remove
168	* @return Number of elements removed (0 or 1)
169	*/
170	uint_fast64_t remove_element(element_id id);
171
172	/**
173	* @brief Get an element by ID
174	* @param id Element ID to retrieve
175	* @return Shared pointer to element, or null if not found
176	*/
177	element_ptr get_element(element_id id);
178
179	/**
180	* @brief Replace an element with a new one
181	* @param id Element ID to replace
182	* @param el New element to insert
183	* @return True if replacement was successful
184	*/
185	bool replace_element(element_id id, element_ptr el);
186
187	/**
188	* @brief Remove all elements from this composite
189	*/
190	void clear();
191
192	// uint64_t get_total_number_of_elements() const
193	// {
194	// return this->my_elements.get_total_number_of_items();
195	// }
196
197	/**
198	* @brief Get iterator to beginning of element container
199	* @return Iterator to first element
200	*/
201	virtual ElementContainer::iterator get_iterator()	272✔
202	{
203	return this->my_elements.get_iterator();	272✔
204	}
205	virtual ElementContainer::const_iterator get_const_iterator() const	534✔
206	{
207	return this->my_elements.get_const_iterator();	534✔
208	}
209	virtual bool is_at_end(ElementContainer::iterator iter)	2,224✔
210	{
211	return this->my_elements.is_at_end(iter);	2,224✔
212	}
213	virtual bool is_at_end(ElementContainer::const_iterator citer) const	9,385✔
214	{
215	return this->my_elements.is_at_end(citer);	9,385✔
216	}
217
218	virtual void enforce_user_fields_set() const override;
219
220	private:
221	uint_fast64_t number_of_elements;
222	ElementContainer my_elements;
223	};
224
225	using composite_element_ptr = std::shared_ptr<CompositeElement>;
226
227	} // namespace SolTrace::Data
228
229	#endif
230
231	/**
232	* @}
233	*/

NREL / SolTrace / 18887449607

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous