Geometrical optics is a model that describes the propagation of light in terms of rays (see [19]). This model can be figured out from approximate solutions of Maxwell’s equations and is valid whenever the waves of light are propagated across and around objects with dimensions greater than the wavelength. Hence, ray theory does not cover phenomena such as interference and diffraction, but notice that OTSun is supplemented by the 1D transform matrix method (TMM) to consider interference in thin films (see item PolarizedThinFilm in Section The Material class).

The first main ingredient in this model is given by the Lambert-Beers law, which states that the initial and final energies (E₀ and E, respectively) of a ray with wavelength λ traveling a distance ℓ inside an optical medium are related by the equation E = E 0 e - α ( λ ) ℓ , (1) where α(λ) = 4πk(λ) is the absorption coefficient of the medium.

The second main ingredient establishes what happens when a ray hits a surface delimiting two different optical media. In this case, different phenomena can take place, since the ray may get absorbed, reflected or transmitted (or a combination of those). In either case, this models determines the ray direction in the new medium v → 2 in terms of the initial ray direction v → 1 and n →, the unit vector normal to the surface at the point of incidence, and pointing towards the first medium. The vector v → 1 also characterizes the incidence angle θ₁ by means of the equation cos θ 1 = - v → 1 · n →. Analogously, v → 2 characterizes the reflection/refraction angle θ₂ via cos θ 2 = ± v → 2 · n →, where the sign is positive in case of reflection and negative in case of refraction.

In case of reflection, the new ray direction is given by the law of reflection: v → 2 = v → 1 + 2 cos θ 1 n → . (2)

If the ray is refracted (transmitted) the new ray direction v → 2 is then given by the Snell’s law: v → 2 = r v → 1 + ( r cos θ 1 - 1 - r 2 sin 2 θ 1 ) n → . (3)

In this equation, r = Re ( n ˜ 1 / n ˜ 2 ), where n ˜ i ( λ ) = n i ( λ ) - i k i ( λ ) (for i = 1, 2) is the complex refractive index in each of the two media. Finally, Fresnel’s equations give the reflectance R and transmittance T rates for the energy of incident rays as follows (we have used the formalism exposed in [20, Ch. 2]): R= ( η 1 - η 2 η 1 + η 2 ) ( η 1 - η 2 η 1 + η 2 ) * , (4) T= 4 η 1 Re ( η 2 ) ( η 1 + η 2 ) ( η 1 + η 2 ) * , (5) where η₁ and η₂ are the tilted optical admittances of the two optical media, and they depend on the polarization of the incident light: η i = { n ˜ i ( λ ) cos θ i Z 0 , fors - polarization , n ˜ i ( λ ) Z 0 cos θ i , forp- polarization , (6) being Z 0 = μ 0 / ∈ 0 the optical impedance of free space.

The key ingredients for any ray tracing simulation are shown in Fig 1. The light source is the geometric region from where rays are emitted to the scene. The optical system is formed by different elements that interact with the rays, some of which are made of absorber materials that capture energy. In our implementation, the optical system is composed by surface and volume elements generated by FreeCAD, and each of them must be associated to an optical material (otherwise it will not interact with light rays). Two kinds of special materials are implemented for defining the absorber material: thermal materials (for solar-thermal collectors) and the PV materials (the active materials of photovoltaic cells). See Section Implementation for details on how we implement all these ingredients.

An overview of the algorithm for the tracing of each single ray is shown in Fig 2. The path followed by a ray is composed of several “hops”, corresponding to different rectilinear segments where the ray moves inside a fixed optical medium. The algorithm starts with the simulation of the emission of a ray from the light source. The point of emission, direction, polarization and wavelength are determined by the light source, while the energy is normalized to be unitary. Then, we sequentially simulate hops, determined by the interaction of the ray with the scene as follows. First, we find the closest intersection of the simulated ray with the scene; in case no intersection is found, then the ray has exited the scene and the tracing is finished. In case we find such an intersection, we update the energy level of the ray at this point, since it could have been traveling inside a dissipative medium during the current hop; also, and in the case that this medium is a “PV material”, we compute the collected energy for future computations. Next, we determine if the ray has been absorbed at the point of intersection, either by having found a “Thermal material” (and in this case we compute the absorbed energy for future computations) or some other absorbent material; in any case, the ray tracing is finished. Likewise, if the energy level of the ray is below a threshold (by default 10⁻⁶), the ray is assumed to have disappeared and the tracing is finished too. Furthermore, we check if the number of hops has reached its maximum (200 hops by default), in which case we determine that the ray has been caught in a loop and stop the simulation. Otherwise, and since at this point the tracing of the ray has to continue, we simulate the optical effect (either reflection or refraction) of the materials on the ray to compute its new direction and polarization, and proceed to the simulation of the next hop.

An experiment is initialized giving the parameters that define it: An scene and a light_source that describe the physical environment where the experiment takes place, and the number of rays that have to be simulated. The execution of the experiment is launched with the experiment.run() method, and once it is finished, the information that has been recollected is found in instance variables like experiment.captured_energy_Th and experiment.captured_energy_PV, that give the overall thermal and photovoltaic (respectively) energy that has been collected by the active materials found in the scene.

Instances of the class Scene hold the data used to describe the physical objects present in an experiment, stored in three main variables, faces, solids and materials. Each object in the array faces (resp. solids) is a Part.Face (resp. Part.Solid) object of FreeCAD that represents a surface (resp. volume) that can affect the propagation of a ray incident with it. The dictionary materials assigns to each face or solid a material that describes its optical properties.

Such a scene is initialized with an array objects, all whose elements are instances of Part.Feature, and typically they are all the objects included in a FreeCAD document. The assignation of materials to each object is done by looking at its label. Namely, if an object obj in a FreeCAD document has a label of the form “Label(mat_name)”, then the assigned material scene.materials[obj] will be the Material instance mat such that mat.name is mat_name.

For instance, the file ParabolicTrough.FCStd in the public repository https://github.com/bielcardona/OTSunSuppMat (see also Section The MultiTracking class) contains a model prepared to analyze a parabolic trough collector. The parabolic mirror (in blue) is made by extruding a parabolic segment, and its label is Parabolic_reflector(Mir1). It means that when imported with OTSun, it will have an associated material whose parameter name is Mir1. In turn, this material has to be properly defined (see Section The Material class) so that it behaves as a mirror. Other elements in this model are the central cylindrical surface (in red), labeled Cylindrical_absorber(Abs1), and its covering (in green), labeled Tube_glass(Glass1); hence, materials named Abs1 and Glass1 have to be defined as an absorber surface and as a transparent volume material, respectively (see Section The Material class).

Instances of the class LightSource are used to model the source of rays in an experiment. There are many parameters that define its behaviour, like its emitting_region, describing the physical location of the source of the rays to be emitted, and its light_spectrum and direction_distribution, describing respectively the distribution of wavelengths and directions of the rays to be emitted.

The parameter light_spectrum can either be a constant, meaning that all rays will be emitted with the same specified wavelength (given in nanometers), or a cumulative distribution function (CDF) F(λ) which is defined by interpolation on the discrete values (λ_i, F(λ_i)) stored in an array ((λ₁, λ₂, …), (F(λ₁), F(λ₂) …).

The emitting_region has to be an instance of any class that implements the method random_point(), which returns a random point from where a ray will be emitted, and has an attribute main_direction, giving the direction of the emitted ray. For convenience, the class SunWindow implements such an emitting region as a plane rectangle Π in the space, orthogonal to a fixed direction u →, and such that all the objects in the scene are contained in the rectangular semi-prism { Π + ξ u → ∣ ξ ≥ 0 }.

The parameter direction_distribution can either be None (meaning that the emitted rays are emitted in the main direction) or an instance of a class that implements the method angle_distribution(), giving a random angle (in degrees) of deviation for the emitted ray with respect to the main direction u →. For convenience, the class BuieDistribution implements such deviation according to the Buie distribution [21], determined by its circumsolar ratio (CSR), which is a parameter of the class.

Instances of the class Ray model light rays, which are emitted by a light_source. A ray is initialized giving its initial optical_state, as well as the scene where it will travel. Instances of OpticalState gather some relevant information of a light ray at a given moment, like its direction, polarization and material, giving, respectively, the direction and polarization vector of the ray, and the material (optical medium) where it is traveling. When the method ray.run() is called, the propagation of the ray inside the scene starts to be simulated. A simplified version of the iteration process is (see also Section The ray tracing algorithm):

The Material class is the most complex of all the classes implemented in OTSun, since there are many kinds of materials, and their optical properties need to be explicitly defined. There are two main subclasses, SurfaceMaterial and VolumeMaterial, corresponding, respectively, to materials that can be assumed to be two-dimensional (like first surface mirrors and selective absorbers) or not (like glasses, second surface mirrors, PV active materials, thin films,…). Any material has an important property, material.name, indicating how it will be called when identifying objects in a scene as explained in Section The Scene class. The physical properties of a material are encoded in material.properties, a dictionary whose contents depend on the kind of material.

Any user willing to use his own materials in his experiments can subclass SurfaceMaterial or VolumeMaterial to adapt the contents of material.properties, which implement the specific properties of the materials. The user must override the method material.change_of_optical_state() to implement the computation of how the interaction with the material changes the optical state (direction, polarization, etc.) of a ray.

Additionally, since it is interesting to store externally the properties of materials, the method material.to_json() and the class method SubclassedMaterial.load_from_json(info) should be implemented. The first one must convert any information stored in material.properties into a serializable dictionary, and the second one must use this dictionary to reconstruct the material.properties dictionary.

The class MultiTracking is designed to implement movements of the active elements in a scene so that the rays emitted by a given light_source tend to be focused on a target (in case that the attribute target is set to a point) or tend to return it to the source (in case that the attribute is not set). That is, MultiTracking can be used either to orient the solar collector to the sun or to direct rays to a target, as happens with the segment mirrors of a Linear Fresnel Collector (LFR) or the heliostats in solar power tower plants.

Movements of elements are implemented by the helper class Joint, and its subclasses CentralJoint and AxialJoint. The former implements rotations around a given point in space (that is, with two degrees of freedom), while in the latter the rotations are around an axis (and hence with a single degree of freedom). Each kind of joint can be easily represented by a geometrical object in FreeCAD, either by a Vertex or an Edge with two points.

To describe the movement of a concrete element in the scene, one needs to associate to this object a joint, but since the goal is to direct the rays to a specified region, one also needs to specify the corresponding principal vector. Here, by the principal vector, we mean the direction that best approaches the normal of the mobile element. When multi_tracking.target is not set, the element will be moved so that this vector points to the source; otherwise, the movement will be computed so that a solar ray reflected on the plane normal to the principal vector and passing through the joint hits the point stored in multi_tracking.target.

We associate objects in the scene to joints using the following convention (see also Section The Scene class): Instead of giving to the object under consideration a label of the form “Label(mat_name)”, where mat_name is the identifier of the material of the object, we use a label of the form “Label(mat_name,joint_name,normal_name)” or “Label(mat_name,joint_name,normal_name,target_name)”, where joint_name is the label of the FreeCAD object that describes the joint (i.e. either a Vertex or a Edge), normal_name is the label of the FreeCAD Edge whose direction is the principal vector of the optical element, and target_name (if present) is the label of the FreeCAD object acting as target.

A multi_tracking is created by giving the scene (which includes the elements that describe the joints, together with their principal vectors and targets, if needed) and the light_source, a Base.Vector giving the main direction of the sun rays. Once it is created, the method target_tracking.make_movements() transforms the scene, rotating conveniently the elements, so that the scene behaves as explained above.

We have compared the computations of the optical efficiency of a Linear Fresnel Reflector (LFR) obtained using OTSun and Tonatiuh [4]. We have chosen this geometry due to its complexity, having mobile objects and using four different types of optical materials. The geometry of the LFR is composed by 11 parabolic mirrors of 500 mm width, a secondary CPC reflector with a maximum concentration of 1.66 truncated at 61.81 mm, and a flat receiver of 70 mm width placed 6 meters above the mirrors field. The parabolic mirrors track the sun with the purpose of reflecting the sunlight to a target located at 46.45 mm under the flat receiver. Each parabolic mirror has a focal length equal to the distance between its center position (which includes the rotation axis) and the mentioned target. The files LFR.FCStd and LFR.tnh contain the implementation of this geometry in FreeCAD and Tonatiuh, respectively. Additionally, the file LFR_output.FCStd shows the output given by OTSun with the simulation of some rays with a transversal incidence angle equal to 45 degrees. Since the optics implemented in Tonatiuh is not based on the Fresnel equations in all its generality, we took the decision to use materials with constant optical properties, so that we can use materials with the same properties in both programs. The file validation1.py contains the specification of the optical materials used in this example, as well as the code used to compute the optical efficiency.

In our computations (both with OTSun and Tonatiuh), we have simulated the emission of 100,000 sun rays per each sun position, using the Buie model approach [21] with a value of 0.05 for the circumsolar ratio. Fig 3 shows the optical efficiencies obtained with the two software packages using different angles for the sun position in both the transversal and longitudinal planes.

We have determined the reflectance of a second surface mirror composed by a layer of 4 mm of borosilicate glass with a silver coating. The model can be found in the file mirror.FCStd, where it can be seen that we created a surface material formed by two layers to be put over the mirror. The outside layer is a transparent material, while the inner one is an ideal thermal material absorber. With this setting, the rays that reach the outer layer pass through it, and those that are later reflected by the mirror are collected by the absorber material, hence providing a measure of the optical efficiency of the mirror. This efficiency, divided by the cosine of the incidence angle of the light rays with respect to the normal vector of the mirror surface, gives the reflectance of the mirror. See the files mirror.FCStd and validation2.py for more details on this geometry and the script we have used to make the simulation with OTSun. Also, file mirror_output.FCStd shows the output produced by OTSun with some simulated rays drawn.

The optical properties of this configuration can also be determined by the analytic transform matrix method (TMM), as exposed in [23] and implemented in [24]. A comparison of the results obtained using these two methods is shown in Fig 4, where the reflectances are plot as a function of the wavelength using two different incidence angles (θ = 45° and θ = 80° degrees) and with parallel and perpendicular polarizations.

To prove the robustness of the validations, we have computed the mean error (ME) and the root mean square error (RMSE) between the results obtained by OTSun and those obtained either by Tonatiuh or TMM. Table 1 summarizes these computations.

One remark is due for these results. In the case of the second experiment, plotted in Fig 3, the optical efficiency in the longitudinal plane for angles greater than or equal to 80 degrees is nearly zero, since the sun is nearly in the direction of the axis of the mirrors and hence nearly no reflections are captured by the receiver. To avoid the spurious behaviour of the indicators due to values close to zero, we have opted for omitting the values corresponding to these angles in the computation of ME and RMSE.

From Table 1, we see that the ME takes both positive and negative values, which implies that OTSun does not present any tendency to overestimate or underestimate the results with respect to the reference models. From the result obtained by OTSun respect to the reference cases, we can see that OTSun presents RMSE values between 0.0013 and 0.0025 for the cases analyzed, which represents an error lower than 0.25%.