20283049329

Committed 16 Dec 2025 09:19PM UTC coverage: 88.351% (-0.8%) from 89.184%

Build # 20283049329

Build Type

Pull #91

github

Committed by

web-flow

Commit Message

Merge d2f36f095 into a73a760a4

Pull Request Pull Request #91: Implement multi-threading in NativeRunner

Run Details

366 of 468 new or added lines in 11 files covered. (78.21%)

34 existing lines in 6 files now uncovered.

6007 of 6799 relevant lines covered (88.35%)

7475791.74 hits per line

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

97.83

/coretrace/simulation_runner/native_runner/find_element_hit.cpp


#include "simulation_data_export.hpp"

#include "determine_element_intersection_new.hpp"
#include "find_element_hit.hpp"
#include "native_runner_types.hpp"

namespace SolTrace::NativeRunner
{

        void FindElementHit(
                // stage info
                const int i,
                const tstage_ptr Stage,
                const bool PT_override,
                const bool AsPowerTower,
                // element info
                const int nintelements,
                const std::vector<void *> &sunint_elements,
                const std::vector<void *> &reflint_elements,
                // ray info
                const int RayNumber,
                const bool in_multi_hit_loop,
                double (&PosRayStage)[3],
                double (&CosRayStage)[3],
                // outputs
                double (&LastPosRaySurfElement)[3],
                double (&LastCosRaySurfElement)[3],
                double (&LastDFXYZ)[3],
                uint_fast64_t &LastElementNumber,
                uint_fast64_t &LastRayNumber,
                double (&LastPosRaySurfStage)[3],
                double (&LastCosRaySurfStage)[3],
                int &ErrorFlag,
                int &LastHitBackSide,
                bool &StageHit)
        {
                // Initialize Variables
                double LastPathLength = 1e99;
                int HitBackSide = 0;
                int InterceptFlag = 0;
                double DFXYZ[3] = {0.0, 0.0, 0.0};
                double PosRayElement[3] = {0.0, 0.0, 0.0};
                double CosRayElement[3] = {0.0, 0.0, 0.0};
                double PosRaySurfStage[3] = {0.0, 0.0, 0.0};
                double CosRaySurfStage[3] = {0.0, 0.0, 0.0};
                double PosRaySurfElement[3] = {0.0, 0.0, 0.0};
                double CosRaySurfElement[3] = {0.0, 0.0, 0.0};
                StageHit = false;

                for (uint_fast64_t j = 0; j < nintelements; j++)
                {
                        TElement *Element; // = Stage->ElementList[j];
                        if (i == 0 && !PT_override)
                        {
                                if (in_multi_hit_loop)
                                {
                                        if (AsPowerTower)
                                        {
                                                Element = (TElement *)reflint_elements.at(j);
                                        }
                                        else
                                        {
                                                Element = Stage->ElementList[j].get();
                                        }
                                }
                                else
                                {
                                        Element = (TElement *)sunint_elements.at(j);
                                }
                        }
                        else
                        {
                                Element = Stage->ElementList[j].get();
                        }

                        // if (!Element->Enabled)
                        //         continue;

                        //  {Transform ray to element[j] coord system of Stage[i]}
                        TransformToLocal(PosRayStage, CosRayStage,
                                                         Element->Origin, Element->RRefToLoc,
                                                         PosRayElement, CosRayElement);

                        ErrorFlag = 0;
                        HitBackSide = 0;
                        InterceptFlag = 0;
                        double PathLength = 0;

                        // increment position by tiny amount to get off the element
                        // if tracing to the same element
                        PosRayElement[0] = PosRayElement[0] + 1.0e-5 * CosRayElement[0];
                        PosRayElement[1] = PosRayElement[1] + 1.0e-5 * CosRayElement[1];
                        PosRayElement[2] = PosRayElement[2] + 1.0e-5 * CosRayElement[2];

                        // {Determine if ray intersects element[j]; if so, Find intersection
                        // point with surface of element[j] }
                        DetermineElementIntersectionNew(Element,
                                                                                        PosRayElement,
                                                                                        CosRayElement,
                                                                                        PosRaySurfElement,
                                                                                        CosRaySurfElement,
                                                                                        DFXYZ,
                                                                                        &PathLength,
                                                                                        &ErrorFlag,
                                                                                        &InterceptFlag,
                                                                                        &HitBackSide);

                        if (InterceptFlag)
                        {
                                // {If hit multiple elements, this loop determines which one hit
                                // first. Also makes sure that correct part of closed surface is
                                // hit. Also, handles wavy, but close to flat zernikes and
                                // polynomials correctly.}
                                if (PathLength < LastPathLength)
                                {
                                        // if (PosRaySurfElement[2] <= Element->ZAperture ||
                                        //         Element->SurfaceIndex == 'm' ||
                                        //         Element->SurfaceIndex == 'M' ||
                                        //         Element->SurfaceIndex == 'r' ||
                                        //         Element->SurfaceIndex == 'R')
                                        // TODO: Is this the correct thing to do?
                                        if (PosRaySurfElement[2] <= Element->ZAperture)
                                        {
                                                StageHit = true;
                                                LastPathLength = PathLength;
                                                CopyVec3(LastPosRaySurfElement, PosRaySurfElement);
                                                CopyVec3(LastCosRaySurfElement, CosRaySurfElement);
                                                CopyVec3(LastDFXYZ, DFXYZ);
                                                // LastElementNumber = ((i == 0 && !PT_override) ? Element->element_number : j + 1); // mjw change from j index to element id
                                                LastElementNumber = Element->element_number;
                                                LastRayNumber = RayNumber;
                                                TransformToReference(PosRaySurfElement, CosRaySurfElement,
                                                                                         Element->Origin, Element->RLocToRef,
                                                                                         PosRaySurfStage, CosRaySurfStage);

                                                CopyVec3(LastPosRaySurfStage, PosRaySurfStage);
                                                CopyVec3(LastCosRaySurfStage, CosRaySurfStage);
                                                LastHitBackSide = HitBackSide;
                                        }
                                }
                        }
                }
        }

} // namespace SolTrace::NativeRunner

1
2	#include "simulation_data_export.hpp"
3
4	#include "determine_element_intersection_new.hpp"
5	#include "find_element_hit.hpp"
6	#include "native_runner_types.hpp"
7
8	namespace SolTrace::NativeRunner
9	{
10
11	void FindElementHit(	12,700,982✔
12	// stage info
13	const int i,
14	const tstage_ptr Stage,
15	const bool PT_override,
16	const bool AsPowerTower,
17	// element info
18	const int nintelements,
19	const std::vector<void *> &sunint_elements,
20	const std::vector<void *> &reflint_elements,
21	// ray info
22	const int RayNumber,
23	const bool in_multi_hit_loop,
24	double (&PosRayStage)[3],
25	double (&CosRayStage)[3],
26	// outputs
27	double (&LastPosRaySurfElement)[3],
28	double (&LastCosRaySurfElement)[3],
29	double (&LastDFXYZ)[3],
30	uint_fast64_t &LastElementNumber,
31	uint_fast64_t &LastRayNumber,
32	double (&LastPosRaySurfStage)[3],
33	double (&LastCosRaySurfStage)[3],
34	int &ErrorFlag,
35	int &LastHitBackSide,
36	bool &StageHit)
37	{
38	// Initialize Variables
39	double LastPathLength = 1e99;	12,700,982✔
40	int HitBackSide = 0;	12,700,982✔
41	int InterceptFlag = 0;	12,700,982✔
42	double DFXYZ[3] = {0.0, 0.0, 0.0};	12,700,982✔
43	double PosRayElement[3] = {0.0, 0.0, 0.0};	12,700,982✔
44	double CosRayElement[3] = {0.0, 0.0, 0.0};	12,700,982✔
45	double PosRaySurfStage[3] = {0.0, 0.0, 0.0};	12,700,982✔
46	double CosRaySurfStage[3] = {0.0, 0.0, 0.0};	12,700,982✔
47	double PosRaySurfElement[3] = {0.0, 0.0, 0.0};	12,700,982✔
48	double CosRaySurfElement[3] = {0.0, 0.0, 0.0};	12,700,982✔
49	StageHit = false;	12,700,982✔
50
51	for (uint_fast64_t j = 0; j < nintelements; j++)	335,788,159✔
52	{
53	TElement *Element; // = Stage->ElementList[j];
54	if (i == 0 && !PT_override)	323,087,177✔
55	{
56	if (in_multi_hit_loop)	281,024,428✔
57	{
58	if (AsPowerTower)	278,229,910✔
59	{
UNCOV 60	Element = (TElement *)reflint_elements.at(j);	×
61	}
62	else
63	{
64	Element = Stage->ElementList[j].get();	278,229,910✔
65	}
66	}
67	else
68	{
69	Element = (TElement *)sunint_elements.at(j);	2,794,518✔
70	}
71	}
72	else
73	{
74	Element = Stage->ElementList[j].get();	42,062,749✔
75	}
76
77	// if (!Element->Enabled)
78	// continue;
79
80	// {Transform ray to element[j] coord system of Stage[i]}
81	TransformToLocal(PosRayStage, CosRayStage,	323,087,177✔
82	Element->Origin, Element->RRefToLoc,	323,087,177✔
83	PosRayElement, CosRayElement);
84
85	ErrorFlag = 0;	323,087,177✔
86	HitBackSide = 0;	323,087,177✔
87	InterceptFlag = 0;	323,087,177✔
88	double PathLength = 0;	323,087,177✔
89
90	// increment position by tiny amount to get off the element
91	// if tracing to the same element
92	PosRayElement[0] = PosRayElement[0] + 1.0e-5 * CosRayElement[0];	323,087,177✔
93	PosRayElement[1] = PosRayElement[1] + 1.0e-5 * CosRayElement[1];	323,087,177✔
94	PosRayElement[2] = PosRayElement[2] + 1.0e-5 * CosRayElement[2];	323,087,177✔
95
96	// {Determine if ray intersects element[j]; if so, Find intersection
97	// point with surface of element[j] }
98	DetermineElementIntersectionNew(Element,	323,087,177✔
99	PosRayElement,
100	CosRayElement,
101	PosRaySurfElement,
102	CosRaySurfElement,
103	DFXYZ,
104	&PathLength,
105	&ErrorFlag,
106	&InterceptFlag,
107	&HitBackSide);
108
109	if (InterceptFlag)	323,087,177✔
110	{
111	// {If hit multiple elements, this loop determines which one hit
112	// first. Also makes sure that correct part of closed surface is
113	// hit. Also, handles wavy, but close to flat zernikes and
114	// polynomials correctly.}
115	if (PathLength < LastPathLength)	2,014,403✔
116	{
117	// if (PosRaySurfElement[2] <= Element->ZAperture \|\|
118	// Element->SurfaceIndex == 'm' \|\|
119	// Element->SurfaceIndex == 'M' \|\|
120	// Element->SurfaceIndex == 'r' \|\|
121	// Element->SurfaceIndex == 'R')
122	// TODO: Is this the correct thing to do?
123	if (PosRaySurfElement[2] <= Element->ZAperture)	1,946,637✔
124	{
125	StageHit = true;	1,931,127✔
126	LastPathLength = PathLength;	1,931,127✔
127	CopyVec3(LastPosRaySurfElement, PosRaySurfElement);	1,931,127✔
128	CopyVec3(LastCosRaySurfElement, CosRaySurfElement);	1,931,127✔
129	CopyVec3(LastDFXYZ, DFXYZ);	1,931,127✔
130	// LastElementNumber = ((i == 0 && !PT_override) ? Element->element_number : j + 1); // mjw change from j index to element id
131	LastElementNumber = Element->element_number;	1,931,127✔
132	LastRayNumber = RayNumber;	1,931,127✔
133	TransformToReference(PosRaySurfElement, CosRaySurfElement,	1,931,127✔
134	Element->Origin, Element->RLocToRef,	1,931,127✔
135	PosRaySurfStage, CosRaySurfStage);
136
137	CopyVec3(LastPosRaySurfStage, PosRaySurfStage);	1,931,127✔
138	CopyVec3(LastCosRaySurfStage, CosRaySurfStage);	1,931,127✔
139	LastHitBackSide = HitBackSide;	1,931,127✔
140	}
141	}
142	}
143	}
144	}	12,700,982✔
145
146	} // namespace SolTrace::NativeRunner

NREL / SolTrace / 20283049329

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