19040526713

Committed 03 Nov 2025 03:50PM UTC coverage: 90.052% (+0.4%) from 89.643%

Build # 19040526713

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #77 from NREL/74-fix-parabola-intersection-missed-case

74 fix parabola intersection missed case

Run Details

959 of 994 new or added lines in 28 files covered. (96.48%)

2 existing lines in 1 file now uncovered.

4508 of 5006 relevant lines covered (90.05%)

10596530.27 hits per line

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

97.96

/coretrace/simulation_data/cst_templates/linear_fresnel.cpp

#include "linear_fresnel.hpp"

#include <stdexcept>
#include <sstream>

#include "aperture.hpp"
#include "constants.hpp"
#include "element.hpp"
#include "surface.hpp"

#include "cst_templates/utilities.hpp"

namespace SolTrace::Data
{

    LinearFresnel::LinearFresnel()
        : CompositeElement(),
          initialized(false),
          receiver_height(-1.0),
          azimuth(-1.0),
          tilt(-1.0),
          focused_panels(false),
          aperture_size_x(-1.0),
          aperture_size_y(-1.0),
          num_panels_x(-1),
          num_panels_y(-1),
          gap_x(-1.0),
          gap_y(-1.0),
          gap_center(-1.0),
          abs_diameter(-1.0),
          env_diameter(-1.0),
          env_thickness(-1.0),
          // tracking_angle(0.0),
          tracking_limit_lower(-180.0),
          tracking_limit_upper(180.0)
    {
        this->optics_absorber.set_ideal_absorption();
        this->optics_mirror.set_ideal_reflection();
        this->optics_env_out.set_ideal_transmission();
        this->optics_env_in.set_ideal_transmission();

        this->tracking_origin.set_values(1.0, 0.0, 0.0);
        this->rotation_axis.set_values(0.0, 1.0, 0.0);
        this->neutral_normal.set_values(0.0, 0.0, 1.0);
    }

    LinearFresnel::~LinearFresnel()
    {
        // Clear vectors
        this->mirrors.clear();
        this->absorbers.clear();
        this->envelope.clear();

        return;
    }

    // double LinearFresnel::get_tracking_angle_degrees() const
    // {
    //     return this->tracking_angle;
    // }

    // double LinearFresnel::get_tracking_angle_radians() const
    // {
    //     return D2R * this->get_tracking_angle_degrees();
    // }

    void LinearFresnel::set_angles(double azimuth, double tilt)
    {
        if (azimuth < -180.0 || azimuth > 180.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_angles: Invalid azimuth angle ("
               << azimuth << "). Must be between -180 and 180 degrees.";
            throw std::invalid_argument(ss.str());
        }

        if (tilt < 0.0 || tilt > 90.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_angles: Invalid tilt angle ("
               << tilt << "). Must be between 0 and 90 degrees.";
            throw std::invalid_argument(ss.str());
        }

        this->coordinates_initialized = false;
        this->azimuth = azimuth;
        this->tilt = tilt;

        // Convert input angles to spherical coordinate angles
        double az = azimuth * D2R;
        double el = tilt * D2R;
        double pol = 0.5 * PI - az;
        double inc = 0.5 * PI - el;

        // Convert spherical coordinates to cartesian coordinates
        // y-axis
        this->rotation_axis.set_values(sin(inc) * cos(pol),
                                       sin(inc) * sin(pol),
                                       cos(inc));

        // z-axis
        this->neutral_normal.set_values(sin(-el) * cos(pol),
                                        sin(-el) * sin(pol),
                                        cos(-el));

        cross_product(this->rotation_axis,
                      this->neutral_normal,
                      this->tracking_origin);

        return;
    }

    void LinearFresnel::set_aperture_size(double len_x, double len_y)
    {
        if (len_x <= 0.0 || len_y <= 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_aperture_size: Invalid aperture dimensions. "
               << "len_x (" << len_x << ") and len_y (" << len_y
               << ") must be positive.";
            throw std::invalid_argument(ss.str());
        }

        this->initialized = false;
        this->aperture_size_x = len_x;
        this->aperture_size_y = len_y;

        return;
    }

    void LinearFresnel::set_focused_panels(bool focused)
    {
        this->initialized = false;
        this->focused_panels = focused;
        return;
    }

    void LinearFresnel::set_gaps(double gap_x,
                                 double gap_y,
                                 double gap_center)
    {
        if (gap_x < 0.0 || gap_y < 0.0 || gap_center < 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_gaps: Invalid gap dimensions. "
               << "gap_x (" << gap_x << "), gap_y (" << gap_y
               << "), and gap_center (" << gap_center
               << ") must be non-negative.";
            throw std::invalid_argument(ss.str());
        }

        this->initialized = false;
        this->gap_x = gap_x;
        this->gap_y = gap_y;
        this->gap_center = gap_center;

        return;
    }

    void LinearFresnel::set_number_panels(int_fast64_t num_x,
                                          int_fast64_t num_y)
    {
        if (num_x <= 0 || num_y <= 0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_number_panels: Invalid panel count. "
               << "num_x (" << num_x << ") and num_y (" << num_y
               << ") must be positive.";
            throw std::invalid_argument(ss.str());
        }

        this->initialized = false;
        this->num_panels_x = num_x;
        this->num_panels_y = num_y;

        return;
    }

    void LinearFresnel::set_optics(const OpticalProperties &mirror,
                                   const OpticalProperties &absorber,
                                   const OpticalProperties &envelop_outer,
                                   const OpticalProperties &envelop_inner)
    {
        this->optics_mirror = mirror;
        this->optics_absorber = absorber;
        this->optics_env_out = envelop_outer;
        this->optics_env_in = envelop_inner;
        return;
    }

    void LinearFresnel::set_receiver_height(double height)
    {
        if (height <= 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_receiver_height: Invalid receiver height ("
               << height << "). Height must be positive.";
            throw std::invalid_argument(ss.str());
        }

        this->initialized = false;
        this->receiver_height = height;

        return;
    }

    void LinearFresnel::set_receiver_dimensions(double absorber_diameter,
                                                double envelop_diameter,
                                                double envelop_thickness)
    {
        if (absorber_diameter <= 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_receiver_dimensions: "
               << "Invalid absorber diameter (" << absorber_diameter
               << "). Must be positive.";
            throw std::invalid_argument(ss.str());
        }

        if (envelop_diameter <= 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_receiver_dimensions: "
               << "Invalid envelope diameter (" << envelop_diameter
               << "). Must be positive.";
            throw std::invalid_argument(ss.str());
        }

        if (envelop_thickness < 0.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_receiver_dimensions: "
               << "Invalid envelope thickness (" << envelop_thickness
               << "). Must be non-negative.";
            throw std::invalid_argument(ss.str());
        }

        if (absorber_diameter >= envelop_diameter)
        {
            std::stringstream ss;
            ss << "LinearFresnel::set_receiver_dimensions: "
               << "Absorber diameter (" << absorber_diameter
               << ") must be smaller than envelope diameter ("
               << envelop_diameter << ").";
            throw std::invalid_argument(ss.str());
        }

        this->initialized = false;
        this->abs_diameter = absorber_diameter;
        this->env_diameter = envelop_diameter;
        this->env_thickness = envelop_thickness;

        return;
    }

    void LinearFresnel::set_tracking_limits(double lower, double upper)
    {
        if (lower > upper)
        {
            std::stringstream ss;
            ss << "ParabolicTrough::set_tracking_limits: Invalid tracking "
               << "limits. Lower limit (" << lower
               << ") must be less than or equal to upper limit ("
               << upper << ").";
            throw std::invalid_argument(ss.str());
        }

        this->tracking_limit_lower = lower;
        this->tracking_limit_upper = upper;

        return;
    }

    void LinearFresnel::create_geometry()
    {
        if (this->initialized)
        {
            return;
        }

        // TODO: Does receiver height give the height to the center or bottom edge?
        // Currently assumes it is the center.

        this->enforce_user_fields_set();

        this->mirrors.clear();
        this->absorbers.clear();
        this->envelope.clear();
        this->clear();

        // Create mirrors
        if (this->num_panels_x == 1 && this->gap_center != 0.0)
        {
            // TODO: This should generate a warning.
            this->gap_center = 0.0;
            this->gap_x = 0.0;
        }

        double panel_len_x = this->aperture_size_x -
                             this->gap_x * (this->num_panels_x - 1);
        panel_len_x -= this->gap_center - this->gap_x;
        panel_len_x /= this->num_panels_x;
        double panel_x = -0.5 * this->aperture_size_x + 0.5 * panel_len_x;

        double panel_len_y = this->aperture_size_y -
                             this->gap_y * (this->num_panels_y - 1);
        panel_len_y /= this->num_panels_y;

        element_id sts;
        Vector3d origin;
        Vector3d aim;
        Vector3d receiver_pos(0.0,
                              0.0,
                              this->receiver_height);
        double panel_y, flen;
        single_element_ptr mirror;
        aperture_ptr ap;
        surface_ptr surf;
        Vector3d khat(0.0, 0.0, 1.0);

        for (int_fast64_t i = 0; i < this->num_panels_x; ++i)
        {
            panel_y = -0.5 * this->aperture_size_y + 0.5 * panel_len_y;
            for (int_fast64_t j = 0; j < this->num_panels_y; ++j)
            {
                mirror = make_element<SingleElement>();

                origin.set_values(panel_x, panel_y, 0.0);
                vector_add(1.0, receiver_pos, -1.0, origin, aim);
                // Project into xz-plane
                aim[1] = 0.0;
                make_unit_vector(aim);
                // std::cout << "Panel x: " << panel_x
                //           << "\nPanel y: " << panel_y
                //           << "\nRec: " << aim
                //           << std::endl;
                vector_add(0.5, khat, 0.5, aim);
                // std::cout << "Aim: " << aim << std::endl;
                vector_add(1.0, origin, 1000.0, aim);
                // std::cout << "Aim Point: " << aim << std::endl;
                // std::cout << "Origin: " << origin << std::endl;
                mirror->set_reference_frame_geometry(origin, aim, 0.0);

                ap = make_aperture<Rectangle>(panel_len_x, panel_len_y);
                mirror->set_aperture(ap);

                if (this->focused_panels)
                {
                    flen = sqrt(panel_x * panel_x +
                                this->receiver_height * this->receiver_height);
                    // surf = make_surface<Parabola>(flen,
                    //     std::numeric_limits<double>::infinity());
                    surf = make_surface<Parabola>(flen, 0.0);
                }
                else
                {
                    surf = make_surface<Flat>();
                }
                mirror->set_surface(surf);

                mirror->set_front_optical_properties(this->optics_mirror);
                mirror->set_back_optical_properties(this->optics_mirror);
                mirror->enable();

                std::stringstream name;
                name << "Mirror_" << this->num_panels_y * i + j;
                mirror->set_name(name.str());

                this->mirrors.push_back(mirror);
                sts = this->add_element(mirror);
                if (!Element::is_success(sts))
                {
                    // TODO: Make this more helpful
                    throw std::runtime_error("Failed to add mirror element");
                }

                panel_y += panel_len_y + this->gap_y;
            }
            panel_x += panel_len_x;
            if (i == this->num_panels_x / 2 - 1)
            {
                panel_x += this->gap_center;
            }
            else
            {
                panel_x += this->gap_x;
            }
        }

        // Absorber
        // TODO: Single element at the moment. Break up into multiple tubes.
        auto abs = make_element<SingleElement>();
        abs->set_name("Absorber");
        origin.set_values(0.0, 0.0,
                          this->receiver_height - 0.5 * this->abs_diameter);
        aim.set_values(0.0, 0.0, 1.0);
        vector_add(1.0, origin, 1.0, aim);
        abs->set_reference_frame_geometry(origin, aim, 0.0);
        abs->set_aperture(make_aperture<Rectangle>(this->abs_diameter,
                                                   this->aperture_size_y));
        abs->set_surface(make_surface<Cylinder>(0.5 * this->abs_diameter));
        abs->set_front_optical_properties(this->optics_absorber);
        abs->set_back_optical_properties(this->optics_absorber);
        abs->enable();

        this->absorbers.push_back(abs);
        sts = this->add_element(abs);
        if (!Element::is_success(sts))
        {
            // TODO: Make this more helpful
            throw std::runtime_error("Failed to add absorber element");
        }

        // Envelope -- Outer
        auto envout = make_element<SingleElement>();
        envout->set_name("EnvelopeOuter");
        origin.set_values(0.0, 0.0,
                          this->receiver_height - 0.5 * this->env_diameter);
        aim.set_values(0.0, 0.0, 1.0);
        vector_add(1.0, origin, 1.0, aim);
        envout->set_reference_frame_geometry(origin, aim, 0.0);
        envout->set_aperture(make_aperture<Rectangle>(this->env_diameter,
                                                      this->aperture_size_y));
        envout->set_surface(make_surface<Cylinder>(0.5 * this->env_diameter));
        envout->set_front_optical_properties(this->optics_env_out);
        envout->set_back_optical_properties(this->optics_env_out);
        envout->enable();

        this->envelope.push_back(envout);
        sts = this->add_element(envout);
        if (!Element::is_success(sts))
        {
            throw std::runtime_error("Failed to add outer envelope element");
        }

        // Envelope -- Inner
        auto envin = make_element<SingleElement>();
        envin->set_name("EnvelopeInner");
        origin.set_values(0.0, 0.0,
                          this->receiver_height -
                              0.5 * this->env_diameter + this->env_thickness);
        aim.set_values(0.0, 0.0, 1.0);
        vector_add(1.0, origin, 1.0, aim);
        envin->set_reference_frame_geometry(origin, aim, 0.0);
        double ap_x = this->env_diameter - 2 * this->env_thickness;
        double ap_y = this->aperture_size_y;
        envin->set_aperture(make_aperture<Rectangle>(ap_x, ap_y));
        envin->set_surface(make_surface<Cylinder>(0.5 * ap_x));
        envin->set_front_optical_properties(this->optics_env_in);
        envin->set_back_optical_properties(this->optics_env_in);
        envin->enable();
        this->envelope.push_back(envin);
        sts = this->add_element(envin);
        if (!Element::is_success(sts))
        {
            throw std::runtime_error("Failed to add inner envelope element");
        }

        this->initialized = true;

        return;
    }

    void LinearFresnel::update_geometry(double azimuth, double elevation)
    {
        if (elevation < 0.0 || elevation > 90.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::update_geometry: Invalid elevation ("
               << elevation << "). Elevation must lie between 0 and 90 degrees.";
            throw std::invalid_argument(ss.str());
        }

        if (azimuth < -180.0 || azimuth > 180.0)
        {
            std::stringstream ss;
            ss << "LinearFresnel::update_geometry: Invalid azimuth ("
               << elevation << "). Azimuth must lie between -180 and 180 degrees.";
            throw std::invalid_argument(ss.str());
        }

        if (!this->initialized)
        {
            std::stringstream ss;
            ss << "LinearFresnel::update_geometry: Uninitialized. "
               << "Call create_geometry() first.";
            throw std::invalid_argument(ss.str());
        }

        // NOTE: Setting the aim point and z-rotation only need to be done
        // once. But they need to be done after the LinearFresnel object
        // has been added to its reference element (if any) so we do it
        // here at the cost of repeating ourselves.

        // Set aim point
        Vector3d z_axis_ref, y_axis_ref;
        this->convert_global_to_reference(z_axis_ref, this->neutral_normal);
        this->convert_global_to_reference(y_axis_ref, this->rotation_axis);
        vector_add(1000.0, z_axis_ref, 1.0, this->origin, this->aim);

        // Set z-rotation
        double beta = asin(z_axis_ref[1]);
        double gamma = acos(y_axis_ref[1] / cos(beta));
        this->set_zrot_radians(gamma);

        // Update coordinate conversions so we can use them below
        this->coordinates_initialized = false;
        this->compute_coordinate_rotations();

        // std::cout << "Rotation axis: " << this->rotation_axis
        //           << "\nNeutral normal: " << this->neutral_normal
        //           << std::endl;

        // std::cout << "Global to Local: " << this->get_global_to_local()
        //           << std::endl;

        // std::cout << "z axis ref: " << z_axis_ref
        //           << "\ny axis ref: " << y_axis_ref
        //           << "\nBeta: " << beta
        //           << "\nGamma: " << gamma
        //           << std::endl;

        // Sun position projected into rotation plane and converted
        // to LinearFresnel object coordinates
        Vector3d sun_pos, sun_proj_local;
        sun_position_vector_degrees(sun_pos, azimuth, elevation);
        this->convert_vector_global_to_local(sun_proj_local, sun_pos);
        // Project to rotation plane
        sun_proj_local[1] = 0.0;
        sun_proj_local.make_unit();

        // std::cout << "Sun Position: " << sun_pos
        //           << "\nSun Proj Local: " << sun_proj_local
        //           << std::endl;

        // Set aimpoint for mirrors
        Vector3d aim_mirror_ref;
        // Absorber position projected into the plane of rotation (the xz-plane)
        Vector3d origin_abs_proj(0.0,
                                 0.0,
                                 this->receiver_height);
        // origin_abs_proj.make_unit();
        for (auto iter : this->mirrors)
        {
            // Get mirror to to receiver vector
            vector_add(1.0, origin_abs_proj,
                       -1.0, iter->get_origin_ref(),
                       aim_mirror_ref);

            // Project onto the rotation plane
            aim_mirror_ref[1] = 0.0;
            aim_mirror_ref.make_unit();
            // std::cout << "Origin: " << iter->get_origin_ref()
            //           << "\nMirror to Receiver: " << aim_mirror_ref
            //           << std::endl;

            // Take bisector vector with the sun
            vector_add(1.0, sun_proj_local, 1.0, aim_mirror_ref);
            aim_mirror_ref.make_unit();
            // std::cout << "Sun Proj Local: " << sun_proj_local
            //           << "\nAim Mirror Ref: " << aim_mirror_ref
            //           << std::endl;

            // Dot product with [0, 0, 1]
            double theta = acos(aim_mirror_ref[2]) * R2D;
            // Dot product with [1, 0, 0]
            if (aim_mirror_ref[0] < 0)
                theta = -theta;
            // std::cout << "Theta: " << theta << std::endl;

            if (theta < this->tracking_limit_lower)
            {
                theta = this->tracking_limit_lower * D2R;
                aim_mirror_ref.set_values(sin(theta), 0.0, cos(theta));
            }
            else if (theta > this->tracking_limit_upper)
            {
                theta = this->tracking_limit_upper * D2R;
                aim_mirror_ref.set_values(sin(theta), 0.0, cos(theta));
            }

            // std::cout << "Theta 2: " << theta * R2D
            //           << "\nAim Mirror Ref: " << aim_mirror_ref
            //           << std::endl;

            // Add origin of mirror
            vector_add(1.0, iter->get_origin_ref(), 1000.0, aim_mirror_ref);
            // aim_mirror_ref.scalar_mult(1000.0);

            // Set aim point
            iter->set_aim_vector(aim_mirror_ref);
            iter->compute_coordinate_rotations();
        }

        return;
    }

    void LinearFresnel::enforce_user_fields_set() const
    {
        if (this->initialized)
        {
            CompositeElement::enforce_user_fields_set();
        }

        // Validate that all required parameters have been set
        if (this->aperture_size_x <= 0.0 || this->aperture_size_y <= 0.0)
        {
            throw std::invalid_argument(
                "LinearFresnel: Aperture size must be set "
                "before creating geometry.");
        }

        if (this->num_panels_x <= 0 || this->num_panels_y <= 0)
        {
            throw std::invalid_argument(
                "LinearFresnel: Number of panels must be set "
                "before creating geometry.");
        }

        if (this->receiver_height <= 0.0)
        {
            throw std::invalid_argument(
                "LinearFresnel: Receiver height must be set "
                "before creating geometry.");
        }

        if (this->abs_diameter <= 0.0 ||
            this->env_diameter <= 0.0)
        {
            throw std::invalid_argument(
                "LinearFresnel: Receiver dimensions must be set "
                "before creating geometry.");
        }

        return;
    }

} // namespace SolTrace::Data

1	#include "linear_fresnel.hpp"
2
3	#include <stdexcept>
4	#include <sstream>
5
6	#include "aperture.hpp"
7	#include "constants.hpp"
8	#include "element.hpp"
9	#include "surface.hpp"
10
11	#include "cst_templates/utilities.hpp"
12
13	namespace SolTrace::Data
14	{
15
16	LinearFresnel::LinearFresnel()	15✔
17	: CompositeElement(),
18	initialized(false),	15✔
19	receiver_height(-1.0),	15✔
20	azimuth(-1.0),	15✔
21	tilt(-1.0),	15✔
22	focused_panels(false),	15✔
23	aperture_size_x(-1.0),	15✔
24	aperture_size_y(-1.0),	15✔
25	num_panels_x(-1),	15✔
26	num_panels_y(-1),	15✔
27	gap_x(-1.0),	15✔
28	gap_y(-1.0),	15✔
29	gap_center(-1.0),	15✔
30	abs_diameter(-1.0),	15✔
31	env_diameter(-1.0),	15✔
32	env_thickness(-1.0),	15✔
33	// tracking_angle(0.0),
34	tracking_limit_lower(-180.0),	15✔
35	tracking_limit_upper(180.0)	15✔
36	{
37	this->optics_absorber.set_ideal_absorption();	15✔
38	this->optics_mirror.set_ideal_reflection();	15✔
39	this->optics_env_out.set_ideal_transmission();	15✔
40	this->optics_env_in.set_ideal_transmission();	15✔
41
42	this->tracking_origin.set_values(1.0, 0.0, 0.0);	15✔
43	this->rotation_axis.set_values(0.0, 1.0, 0.0);	15✔
44	this->neutral_normal.set_values(0.0, 0.0, 1.0);	15✔
45	}	15✔
46
47	LinearFresnel::~LinearFresnel()	15✔
48	{
49	// Clear vectors
50	this->mirrors.clear();	15✔
51	this->absorbers.clear();	15✔
52	this->envelope.clear();	15✔
53
54	return;	15✔
55	}	15✔
56
57	// double LinearFresnel::get_tracking_angle_degrees() const
58	// {
59	// return this->tracking_angle;
60	// }
61
62	// double LinearFresnel::get_tracking_angle_radians() const
63	// {
64	// return D2R * this->get_tracking_angle_degrees();
65	// }
66
67	void LinearFresnel::set_angles(double azimuth, double tilt)	12✔
68	{
69	if (azimuth < -180.0 \|\| azimuth > 180.0)	12✔
70	{
71	std::stringstream ss;	2✔
72	ss << "LinearFresnel::set_angles: Invalid azimuth angle ("	2✔
73	<< azimuth << "). Must be between -180 and 180 degrees.";	2✔
74	throw std::invalid_argument(ss.str());	2✔
75	}	2✔
76
77	if (tilt < 0.0 \|\| tilt > 90.0)	10✔
78	{
79	std::stringstream ss;	2✔
80	ss << "LinearFresnel::set_angles: Invalid tilt angle ("	2✔
81	<< tilt << "). Must be between 0 and 90 degrees.";	2✔
82	throw std::invalid_argument(ss.str());	2✔
83	}	2✔
84
85	this->coordinates_initialized = false;	8✔
86	this->azimuth = azimuth;	8✔
87	this->tilt = tilt;	8✔
88
89	// Convert input angles to spherical coordinate angles
90	double az = azimuth * D2R;	8✔
91	double el = tilt * D2R;	8✔
92	double pol = 0.5 * PI - az;	8✔
93	double inc = 0.5 * PI - el;	8✔
94
95	// Convert spherical coordinates to cartesian coordinates
96	// y-axis
97	this->rotation_axis.set_values(sin(inc) * cos(pol),	8✔
98	sin(inc) * sin(pol),	8✔
99	cos(inc));
100
101	// z-axis
102	this->neutral_normal.set_values(sin(-el) * cos(pol),	8✔
103	sin(-el) * sin(pol),	8✔
104	cos(-el));
105
106	cross_product(this->rotation_axis,	8✔
107	this->neutral_normal,	8✔
108	this->tracking_origin);	8✔
109
110	return;	8✔
111	}
112
113	void LinearFresnel::set_aperture_size(double len_x, double len_y)	15✔
114	{
115	if (len_x <= 0.0 \|\| len_y <= 0.0)	15✔
116	{
117	std::stringstream ss;	5✔
118	ss << "LinearFresnel::set_aperture_size: Invalid aperture dimensions. "
119	<< "len_x (" << len_x << ") and len_y (" << len_y	5✔
120	<< ") must be positive.";	5✔
121	throw std::invalid_argument(ss.str());	5✔
122	}	5✔
123
124	this->initialized = false;	10✔
125	this->aperture_size_x = len_x;	10✔
126	this->aperture_size_y = len_y;	10✔
127
128	return;	10✔
129	}
130
131	void LinearFresnel::set_focused_panels(bool focused)	5✔
132	{
133	this->initialized = false;	5✔
134	this->focused_panels = focused;	5✔
135	return;	5✔
136	}
137
138	void LinearFresnel::set_gaps(double gap_x,	10✔
139	double gap_y,
140	double gap_center)
141	{
142	if (gap_x < 0.0 \|\| gap_y < 0.0 \|\| gap_center < 0.0)	10✔
143	{
144	std::stringstream ss;	3✔
145	ss << "LinearFresnel::set_gaps: Invalid gap dimensions. "
146	<< "gap_x (" << gap_x << "), gap_y (" << gap_y	3✔
147	<< "), and gap_center (" << gap_center	3✔
148	<< ") must be non-negative.";	3✔
149	throw std::invalid_argument(ss.str());	3✔
150	}	3✔
151
152	this->initialized = false;	7✔
153	this->gap_x = gap_x;	7✔
154	this->gap_y = gap_y;	7✔
155	this->gap_center = gap_center;	7✔
156
157	return;	7✔
158	}
159
160	void LinearFresnel::set_number_panels(int_fast64_t num_x,	14✔
161	int_fast64_t num_y)
162	{
163	if (num_x <= 0 \|\| num_y <= 0)	14✔
164	{
165	std::stringstream ss;	4✔
166	ss << "LinearFresnel::set_number_panels: Invalid panel count. "
167	<< "num_x (" << num_x << ") and num_y (" << num_y	4✔
168	<< ") must be positive.";	4✔
169	throw std::invalid_argument(ss.str());	4✔
170	}	4✔
171
172	this->initialized = false;	10✔
173	this->num_panels_x = num_x;	10✔
174	this->num_panels_y = num_y;	10✔
175
176	return;	10✔
177	}
178
179	void LinearFresnel::set_optics(const OpticalProperties &mirror,	4✔
180	const OpticalProperties &absorber,
181	const OpticalProperties &envelop_outer,
182	const OpticalProperties &envelop_inner)
183	{
184	this->optics_mirror = mirror;	4✔
185	this->optics_absorber = absorber;	4✔
186	this->optics_env_out = envelop_outer;	4✔
187	this->optics_env_in = envelop_inner;	4✔
188	return;	4✔
189	}
190
191	void LinearFresnel::set_receiver_height(double height)	12✔
192	{
193	if (height <= 0.0)	12✔
194	{
195	std::stringstream ss;	2✔
196	ss << "LinearFresnel::set_receiver_height: Invalid receiver height ("	2✔
197	<< height << "). Height must be positive.";	2✔
198	throw std::invalid_argument(ss.str());	2✔
199	}	2✔
200
201	this->initialized = false;	10✔
202	this->receiver_height = height;	10✔
203
204	return;	10✔
205	}
206
207	void LinearFresnel::set_receiver_dimensions(double absorber_diameter,	17✔
208	double envelop_diameter,
209	double envelop_thickness)
210	{
211	if (absorber_diameter <= 0.0)	17✔
212	{
213	std::stringstream ss;	2✔
214	ss << "LinearFresnel::set_receiver_dimensions: "
215	<< "Invalid absorber diameter (" << absorber_diameter	2✔
216	<< "). Must be positive.";	2✔
217	throw std::invalid_argument(ss.str());	2✔
218	}	2✔
219
220	if (envelop_diameter <= 0.0)	15✔
221	{
222	std::stringstream ss;	2✔
223	ss << "LinearFresnel::set_receiver_dimensions: "
224	<< "Invalid envelope diameter (" << envelop_diameter	2✔
225	<< "). Must be positive.";	2✔
226	throw std::invalid_argument(ss.str());	2✔
227	}	2✔
228
229	if (envelop_thickness < 0.0)	13✔
230	{
231	std::stringstream ss;	1✔
232	ss << "LinearFresnel::set_receiver_dimensions: "
233	<< "Invalid envelope thickness (" << envelop_thickness	1✔
234	<< "). Must be non-negative.";	1✔
235	throw std::invalid_argument(ss.str());	1✔
236	}	1✔
237
238	if (absorber_diameter >= envelop_diameter)	12✔
239	{
240	std::stringstream ss;	2✔
241	ss << "LinearFresnel::set_receiver_dimensions: "
242	<< "Absorber diameter (" << absorber_diameter	2✔
243	<< ") must be smaller than envelope diameter ("	2✔
244	<< envelop_diameter << ").";	2✔
245	throw std::invalid_argument(ss.str());	2✔
246	}	2✔
247
248	this->initialized = false;	10✔
249	this->abs_diameter = absorber_diameter;	10✔
250	this->env_diameter = envelop_diameter;	10✔
251	this->env_thickness = envelop_thickness;	10✔
252
253	return;	10✔
254	}
255
256	void LinearFresnel::set_tracking_limits(double lower, double upper)	4✔
257	{
258	if (lower > upper)	4✔
259	{
260	std::stringstream ss;	1✔
261	ss << "ParabolicTrough::set_tracking_limits: Invalid tracking "
262	<< "limits. Lower limit (" << lower	1✔
263	<< ") must be less than or equal to upper limit ("	1✔
264	<< upper << ").";	1✔
265	throw std::invalid_argument(ss.str());	1✔
266	}	1✔
267
268	this->tracking_limit_lower = lower;	3✔
269	this->tracking_limit_upper = upper;	3✔
270
271	return;	3✔
272	}
273
274	void LinearFresnel::create_geometry()	11✔
275	{
276	if (this->initialized)	11✔
277	{
NEW 278	return;	×
279	}
280
281	// TODO: Does receiver height give the height to the center or bottom edge?
282	// Currently assumes it is the center.
283
284	this->enforce_user_fields_set();	11✔
285
286	this->mirrors.clear();	7✔
287	this->absorbers.clear();	7✔
288	this->envelope.clear();	7✔
289	this->clear();	7✔
290
291	// Create mirrors
292	if (this->num_panels_x == 1 && this->gap_center != 0.0)	7✔
293	{
294	// TODO: This should generate a warning.
NEW 295	this->gap_center = 0.0;	×
NEW 296	this->gap_x = 0.0;	×
297	}
298
299	double panel_len_x = this->aperture_size_x -	7✔
300	this->gap_x * (this->num_panels_x - 1);	7✔
301	panel_len_x -= this->gap_center - this->gap_x;	7✔
302	panel_len_x /= this->num_panels_x;	7✔
303	double panel_x = -0.5 * this->aperture_size_x + 0.5 * panel_len_x;	7✔
304
305	double panel_len_y = this->aperture_size_y -	7✔
306	this->gap_y * (this->num_panels_y - 1);	7✔
307	panel_len_y /= this->num_panels_y;	7✔
308
309	element_id sts;
310	Vector3d origin;	7✔
311	Vector3d aim;	7✔
312	Vector3d receiver_pos(0.0,
313	0.0,
314	this->receiver_height);	7✔
315	double panel_y, flen;
316	single_element_ptr mirror;	7✔
317	aperture_ptr ap;	7✔
318	surface_ptr surf;	7✔
319	Vector3d khat(0.0, 0.0, 1.0);	7✔
320
321	for (int_fast64_t i = 0; i < this->num_panels_x; ++i)	31✔
322	{
323	panel_y = -0.5 * this->aperture_size_y + 0.5 * panel_len_y;	24✔
324	for (int_fast64_t j = 0; j < this->num_panels_y; ++j)	89✔
325	{
326	mirror = make_element<SingleElement>();	65✔
327
328	origin.set_values(panel_x, panel_y, 0.0);	65✔
329	vector_add(1.0, receiver_pos, -1.0, origin, aim);	65✔
330	// Project into xz-plane
331	aim[1] = 0.0;	65✔
332	make_unit_vector(aim);	65✔
333	// std::cout << "Panel x: " << panel_x
334	// << "\nPanel y: " << panel_y
335	// << "\nRec: " << aim
336	// << std::endl;
337	vector_add(0.5, khat, 0.5, aim);	65✔
338	// std::cout << "Aim: " << aim << std::endl;
339	vector_add(1.0, origin, 1000.0, aim);	65✔
340	// std::cout << "Aim Point: " << aim << std::endl;
341	// std::cout << "Origin: " << origin << std::endl;
342	mirror->set_reference_frame_geometry(origin, aim, 0.0);	65✔
343
344	ap = make_aperture<Rectangle>(panel_len_x, panel_len_y);	65✔
345	mirror->set_aperture(ap);	65✔
346
347	if (this->focused_panels)	65✔
348	{
349	flen = sqrt(panel_x * panel_x +	48✔
350	this->receiver_height * this->receiver_height);	48✔
351	// surf = make_surface<Parabola>(flen,
352	// std::numeric_limits<double>::infinity());
353	surf = make_surface<Parabola>(flen, 0.0);	48✔
354	}
355	else
356	{
357	surf = make_surface<Flat>();	17✔
358	}
359	mirror->set_surface(surf);	65✔
360
361	mirror->set_front_optical_properties(this->optics_mirror);	65✔
362	mirror->set_back_optical_properties(this->optics_mirror);	65✔
363	mirror->enable();	65✔
364
365	std::stringstream name;	65✔
366	name << "Mirror_" << this->num_panels_y * i + j;	65✔
367	mirror->set_name(name.str());	65✔
368
369	this->mirrors.push_back(mirror);	65✔
370	sts = this->add_element(mirror);	65✔
371	if (!Element::is_success(sts))	65✔
372	{
373	// TODO: Make this more helpful
NEW 374	throw std::runtime_error("Failed to add mirror element");	×
375	}
376
377	panel_y += panel_len_y + this->gap_y;	65✔
378	}	65✔
379	panel_x += panel_len_x;	24✔
380	if (i == this->num_panels_x / 2 - 1)	24✔
381	{
382	panel_x += this->gap_center;	6✔
383	}
384	else
385	{
386	panel_x += this->gap_x;	18✔
387	}
388	}
389
390	// Absorber
391	// TODO: Single element at the moment. Break up into multiple tubes.
392	auto abs = make_element<SingleElement>();	7✔
393	abs->set_name("Absorber");	14✔
394	origin.set_values(0.0, 0.0,	7✔
395	this->receiver_height - 0.5 * this->abs_diameter);	7✔
396	aim.set_values(0.0, 0.0, 1.0);	7✔
397	vector_add(1.0, origin, 1.0, aim);	7✔
398	abs->set_reference_frame_geometry(origin, aim, 0.0);	7✔
399	abs->set_aperture(make_aperture<Rectangle>(this->abs_diameter,	14✔
400	this->aperture_size_y));	7✔
401	abs->set_surface(make_surface<Cylinder>(0.5 * this->abs_diameter));	7✔
402	abs->set_front_optical_properties(this->optics_absorber);	7✔
403	abs->set_back_optical_properties(this->optics_absorber);	7✔
404	abs->enable();	7✔
405
406	this->absorbers.push_back(abs);	7✔
407	sts = this->add_element(abs);	7✔
408	if (!Element::is_success(sts))	7✔
409	{
410	// TODO: Make this more helpful
NEW 411	throw std::runtime_error("Failed to add absorber element");	×
412	}
413
414	// Envelope -- Outer
415	auto envout = make_element<SingleElement>();	7✔
416	envout->set_name("EnvelopeOuter");	14✔
417	origin.set_values(0.0, 0.0,	7✔
418	this->receiver_height - 0.5 * this->env_diameter);	7✔
419	aim.set_values(0.0, 0.0, 1.0);	7✔
420	vector_add(1.0, origin, 1.0, aim);	7✔
421	envout->set_reference_frame_geometry(origin, aim, 0.0);	7✔
422	envout->set_aperture(make_aperture<Rectangle>(this->env_diameter,	14✔
423	this->aperture_size_y));	7✔
424	envout->set_surface(make_surface<Cylinder>(0.5 * this->env_diameter));	7✔
425	envout->set_front_optical_properties(this->optics_env_out);	7✔
426	envout->set_back_optical_properties(this->optics_env_out);	7✔
427	envout->enable();	7✔
428
429	this->envelope.push_back(envout);	7✔
430	sts = this->add_element(envout);	7✔
431	if (!Element::is_success(sts))	7✔
432	{
NEW 433	throw std::runtime_error("Failed to add outer envelope element");	×
434	}
435
436	// Envelope -- Inner
437	auto envin = make_element<SingleElement>();	7✔
438	envin->set_name("EnvelopeInner");	14✔
439	origin.set_values(0.0, 0.0,	7✔
440	this->receiver_height -	7✔
441	0.5 * this->env_diameter + this->env_thickness);	7✔
442	aim.set_values(0.0, 0.0, 1.0);	7✔
443	vector_add(1.0, origin, 1.0, aim);	7✔
444	envin->set_reference_frame_geometry(origin, aim, 0.0);	7✔
445	double ap_x = this->env_diameter - 2 * this->env_thickness;	7✔
446	double ap_y = this->aperture_size_y;	7✔
447	envin->set_aperture(make_aperture<Rectangle>(ap_x, ap_y));	7✔
448	envin->set_surface(make_surface<Cylinder>(0.5 * ap_x));	7✔
449	envin->set_front_optical_properties(this->optics_env_in);	7✔
450	envin->set_back_optical_properties(this->optics_env_in);	7✔
451	envin->enable();	7✔
452	this->envelope.push_back(envin);	7✔
453	sts = this->add_element(envin);	7✔
454	if (!Element::is_success(sts))	7✔
455	{
NEW 456	throw std::runtime_error("Failed to add inner envelope element");	×
457	}
458
459	this->initialized = true;	7✔
460
461	return;	7✔
462	}	7✔
463
464	void LinearFresnel::update_geometry(double azimuth, double elevation)	8✔
465	{
466	if (elevation < 0.0 \|\| elevation > 90.0)	8✔
467	{
468	std::stringstream ss;	2✔
469	ss << "LinearFresnel::update_geometry: Invalid elevation ("	2✔
470	<< elevation << "). Elevation must lie between 0 and 90 degrees.";	2✔
471	throw std::invalid_argument(ss.str());	2✔
472	}	2✔
473
474	if (azimuth < -180.0 \|\| azimuth > 180.0)	6✔
475	{
476	std::stringstream ss;	2✔
477	ss << "LinearFresnel::update_geometry: Invalid azimuth ("	2✔
478	<< elevation << "). Azimuth must lie between -180 and 180 degrees.";	2✔
479	throw std::invalid_argument(ss.str());	2✔
480	}	2✔
481
482	if (!this->initialized)	4✔
483	{
484	std::stringstream ss;	1✔
485	ss << "LinearFresnel::update_geometry: Uninitialized. "
486	<< "Call create_geometry() first.";	1✔
487	throw std::invalid_argument(ss.str());	1✔
488	}	1✔
489
490	// NOTE: Setting the aim point and z-rotation only need to be done
491	// once. But they need to be done after the LinearFresnel object
492	// has been added to its reference element (if any) so we do it
493	// here at the cost of repeating ourselves.
494
495	// Set aim point
496	Vector3d z_axis_ref, y_axis_ref;	3✔
497	this->convert_global_to_reference(z_axis_ref, this->neutral_normal);	3✔
498	this->convert_global_to_reference(y_axis_ref, this->rotation_axis);	3✔
499	vector_add(1000.0, z_axis_ref, 1.0, this->origin, this->aim);	3✔
500
501	// Set z-rotation
502	double beta = asin(z_axis_ref[1]);	3✔
503	double gamma = acos(y_axis_ref[1] / cos(beta));	3✔
504	this->set_zrot_radians(gamma);	3✔
505
506	// Update coordinate conversions so we can use them below
507	this->coordinates_initialized = false;	3✔
508	this->compute_coordinate_rotations();	3✔
509
510	// std::cout << "Rotation axis: " << this->rotation_axis
511	// << "\nNeutral normal: " << this->neutral_normal
512	// << std::endl;
513
514	// std::cout << "Global to Local: " << this->get_global_to_local()
515	// << std::endl;
516
517	// std::cout << "z axis ref: " << z_axis_ref
518	// << "\ny axis ref: " << y_axis_ref
519	// << "\nBeta: " << beta
520	// << "\nGamma: " << gamma
521	// << std::endl;
522
523	// Sun position projected into rotation plane and converted
524	// to LinearFresnel object coordinates
525	Vector3d sun_pos, sun_proj_local;	3✔
526	sun_position_vector_degrees(sun_pos, azimuth, elevation);	3✔
527	this->convert_vector_global_to_local(sun_proj_local, sun_pos);	3✔
528	// Project to rotation plane
529	sun_proj_local[1] = 0.0;	3✔
530	sun_proj_local.make_unit();	3✔
531
532	// std::cout << "Sun Position: " << sun_pos
533	// << "\nSun Proj Local: " << sun_proj_local
534	// << std::endl;
535
536	// Set aimpoint for mirrors
537	Vector3d aim_mirror_ref;	3✔
538	// Absorber position projected into the plane of rotation (the xz-plane)
539	Vector3d origin_abs_proj(0.0,
540	0.0,
541	this->receiver_height);	3✔
542	// origin_abs_proj.make_unit();
543	for (auto iter : this->mirrors)	11✔
544	{
545	// Get mirror to to receiver vector
546	vector_add(1.0, origin_abs_proj,	8✔
547	-1.0, iter->get_origin_ref(),	16✔
548	aim_mirror_ref);
549
550	// Project onto the rotation plane
551	aim_mirror_ref[1] = 0.0;	8✔
552	aim_mirror_ref.make_unit();	8✔
553	// std::cout << "Origin: " << iter->get_origin_ref()
554	// << "\nMirror to Receiver: " << aim_mirror_ref
555	// << std::endl;
556
557	// Take bisector vector with the sun
558	vector_add(1.0, sun_proj_local, 1.0, aim_mirror_ref);	8✔
559	aim_mirror_ref.make_unit();	8✔
560	// std::cout << "Sun Proj Local: " << sun_proj_local
561	// << "\nAim Mirror Ref: " << aim_mirror_ref
562	// << std::endl;
563
564	// Dot product with [0, 0, 1]
565	double theta = acos(aim_mirror_ref[2]) * R2D;	8✔
566	// Dot product with [1, 0, 0]
567	if (aim_mirror_ref[0] < 0)	8✔
568	theta = -theta;	4✔
569	// std::cout << "Theta: " << theta << std::endl;
570
571	if (theta < this->tracking_limit_lower)	8✔
572	{
573	theta = this->tracking_limit_lower * D2R;	2✔
574	aim_mirror_ref.set_values(sin(theta), 0.0, cos(theta));	2✔
575	}
576	else if (theta > this->tracking_limit_upper)	6✔
577	{
578	theta = this->tracking_limit_upper * D2R;	2✔
579	aim_mirror_ref.set_values(sin(theta), 0.0, cos(theta));	2✔
580	}
581
582	// std::cout << "Theta 2: " << theta * R2D
583	// << "\nAim Mirror Ref: " << aim_mirror_ref
584	// << std::endl;
585
586	// Add origin of mirror
587	vector_add(1.0, iter->get_origin_ref(), 1000.0, aim_mirror_ref);	8✔
588	// aim_mirror_ref.scalar_mult(1000.0);
589
590	// Set aim point
591	iter->set_aim_vector(aim_mirror_ref);	8✔
592	iter->compute_coordinate_rotations();	8✔
593	}	8✔
594
595	return;	6✔
596	}	3✔
597
598	void LinearFresnel::enforce_user_fields_set() const	13✔
599	{
600	if (this->initialized)	13✔
601	{
602	CompositeElement::enforce_user_fields_set();	2✔
603	}
604
605	// Validate that all required parameters have been set
606	if (this->aperture_size_x <= 0.0 \|\| this->aperture_size_y <= 0.0)	13✔
607	{
608	throw std::invalid_argument(
609	"LinearFresnel: Aperture size must be set "
610	"before creating geometry.");	1✔
611	}
612
613	if (this->num_panels_x <= 0 \|\| this->num_panels_y <= 0)	12✔
614	{
615	throw std::invalid_argument(
616	"LinearFresnel: Number of panels must be set "
617	"before creating geometry.");	1✔
618	}
619
620	if (this->receiver_height <= 0.0)	11✔
621	{
622	throw std::invalid_argument(
623	"LinearFresnel: Receiver height must be set "
624	"before creating geometry.");	1✔
625	}
626
627	if (this->abs_diameter <= 0.0 \|\|	10✔
628	this->env_diameter <= 0.0)	9✔
629	{
630	throw std::invalid_argument(
631	"LinearFresnel: Receiver dimensions must be set "
632	"before creating geometry.");	1✔
633	}
634
635	return;	9✔
636	}
637
638	} // namespace SolTrace::Data

NREL / SolTrace / 19040526713

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