19580451842

Committed 21 Nov 2025 06:52PM UTC coverage: 89.184% (+0.4%) from 88.811%

Build # 19580451842

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #85 from NREL/simdata_io_json

Add json import/export to SimulationData

Run Details

423 of 451 new or added lines in 17 files covered. (93.79%)

9 existing lines in 3 files now uncovered.

5970 of 6694 relevant lines covered (89.18%)

7997777.28 hits per line

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

97.37

/coretrace/simulation_data/composite_element.cpp


#include "composite_element.hpp"

#include <sstream>

#include "single_element.hpp"



namespace SolTrace::Data
{

    CompositeElement::CompositeElement() : ElementBase(),
                                           number_of_elements(0),
                                           my_elements()
    {
        return;
    }

    CompositeElement::CompositeElement(const nlohmann::ordered_json& jnode) : ElementBase(jnode),
        number_of_elements(0),
        my_elements()
    {
        using json = nlohmann::ordered_json;

        // Common parameters are set in ElementBase constructor before here

        json jelements = jnode.at("elements");
        for (auto& [key, jelement] : jelements.items())
        {
            bool is_single = jelement.at("is_single");
            if (is_single)
            {
                element_ptr el = make_element<SingleElement>(jelement);
                this->add_element(el);
            }
            else
            {
                composite_element_ptr comp = make_element<CompositeElement>(jelement);
                this->add_element(comp);
            }
        }
        return;
    }

    CompositeElement::~CompositeElement()
    {
        this->clear();
        return;
    }

    void CompositeElement::disable() const
    {
        this->active = false;
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->disable();
        }
        return;
    }

    void CompositeElement::enable() const
    {
        this->active = true;
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->enable();
        }
        return;
    }

    void CompositeElement::mark_virtual() const
    {
        this->ElementBase::mark_virtual();
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->mark_virtual();
        }
        return;
    }

    void CompositeElement::unmark_virtual() const
    {
        this->ElementBase::unmark_virtual();
        for (auto iter = this->get_const_iterator();
             !this->is_at_end(iter);
             ++iter)
        {
            iter->second->unmark_virtual();
        }
        return;
    }

    void CompositeElement::set_stage(int_fast64_t stage)
    {
        this->stage = stage;
        for (auto iter = this->get_iterator(); !this->is_at_end(iter); ++iter)
        {
            iter->second->set_stage(stage);
        }
        return;
    }

    element_id CompositeElement::add_element(element_ptr el)
    {
        // Cannot nest a StageElement in another CompositeElement
        // assert(!el->is_stage());
        // Disable adding CompositeElements unless `this` is a StageElement
        // assert(this->is_stage() || el->is_single());

        if (el->is_stage() ||
            (el->is_composite() && !this->is_stage()))
        {
            return ELEMENT_INVALID_SETUP;
        }

        el->enforce_user_fields_set();

        element_id id = this->my_elements.add_item(el);
        if (is_success(id))
        {
            this->number_of_elements += el->get_number_of_elements();
            el->set_reference_element(this);
        }
        return id;
    }

    uint_fast64_t CompositeElement::remove_element(element_id id)
    {
        element_ptr el = this->my_elements.get_item(id);
        uint_fast64_t nremoved = this->my_elements.remove_item(id);

        if (nremoved > 0)
        {
            nremoved = el->get_number_of_elements();
            this->number_of_elements -= nremoved;
        }

        return nremoved;
    }

    element_ptr CompositeElement::get_element(element_id id)
    {
        return this->my_elements.get_item(id);
    }

    bool CompositeElement::replace_element(element_id id, element_ptr el)
    {
        element_ptr old_el = this->my_elements.get_item(id);
        bool replaced = this->my_elements.replace_item(id, el);

        if (replaced)
        {
            this->number_of_elements -= old_el->get_number_of_elements();
            this->number_of_elements += el->get_number_of_elements();
        }

        return replaced;
    }

    void CompositeElement::clear()
    {
        this->number_of_elements = 0;
        this->my_elements.clear();
        return;
    }

    void CompositeElement::enforce_user_fields_set() const
    {
        ElementBase::enforce_user_fields_set();

        if (this->number_of_elements == 0)
        {
            std::stringstream ss;
            ss << "CompositeElement (Name: " << this->get_name()
               << ", UUID: " << this->get_id()
               << ") has no subelements.";
            throw std::invalid_argument(ss.str());
        }
        return;
    }

    // Stage and Composite should have the same function
    void CompositeElement::write_json(nlohmann::ordered_json& jnode) const
    {
        using json = nlohmann::ordered_json;

        // Composite/stage specific info
        jnode["is_composite"] = true;
        jnode["is_single"] = false;
        jnode["number_of_elements"] = this->get_number_of_elements();

        // Common properties of all elements
        this->write_common_json(jnode);

        // Loop through each element, writing json node
        json jelements;
        for (auto it = this->get_const_iterator(); !this->is_at_end(it); ++it)
        {
            json jelement;

            SolTrace::Data::element_id i = it->first;
            auto element = it->second;

            element->write_json(jelement);

            jelements[std::to_string(i)] = jelement;
        }
        jnode["elements"] = jelements;
    }

} // namespace SolTrace::Data

1
2	#include "composite_element.hpp"
3
4	#include <sstream>
5
6	#include "single_element.hpp"
7
8
9
10	namespace SolTrace::Data
11	{
12
13	CompositeElement::CompositeElement() : ElementBase(),	346✔
14	number_of_elements(0),	346✔
15	my_elements()	346✔
16	{
17	return;	346✔
18	}
19
20	CompositeElement::CompositeElement(const nlohmann::ordered_json& jnode) : ElementBase(jnode),	9✔
21	number_of_elements(0),	9✔
22	my_elements()	9✔
23	{
24	using json = nlohmann::ordered_json;
25
26	// Common parameters are set in ElementBase constructor before here
27
28	json jelements = jnode.at("elements");	9✔
29	for (auto& [key, jelement] : jelements.items())	4,859✔
30	{
31	bool is_single = jelement.at("is_single");	2,425✔
32	if (is_single)	2,425✔
33	{
34	element_ptr el = make_element<SingleElement>(jelement);	2,425✔
35	this->add_element(el);	2,425✔
36	}	2,425✔
37	else
38	{
NEW 39	composite_element_ptr comp = make_element<CompositeElement>(jelement);	×
NEW 40	this->add_element(comp);	×
NEW 41	}	×
42	}	9✔
43	return;	18✔
44	}	9✔
45
46	CompositeElement::~CompositeElement()	355✔
47	{
48	this->clear();	355✔
49	return;	355✔
50	}	355✔
51
52	void CompositeElement::disable() const	1✔
53	{
54	this->active = false;	1✔
55	for (auto iter = this->get_const_iterator();	1✔
56	!this->is_at_end(iter);	5✔
57	++iter)	4✔
58	{
59	iter->second->disable();	4✔
60	}
61	return;	1✔
62	}
63
64	void CompositeElement::enable() const	258✔
65	{
66	this->active = true;	258✔
67	for (auto iter = this->get_const_iterator();	258✔
68	!this->is_at_end(iter);	493✔
69	++iter)	235✔
70	{
71	iter->second->enable();	235✔
72	}
73	return;	258✔
74	}
75
76	void CompositeElement::mark_virtual() const	1✔
77	{
78	this->ElementBase::mark_virtual();	1✔
79	for (auto iter = this->get_const_iterator();	1✔
80	!this->is_at_end(iter);	5✔
81	++iter)	4✔
82	{
83	iter->second->mark_virtual();	4✔
84	}
85	return;	1✔
86	}
87
88	void CompositeElement::unmark_virtual() const	1✔
89	{
90	this->ElementBase::unmark_virtual();	1✔
91	for (auto iter = this->get_const_iterator();	1✔
92	!this->is_at_end(iter);	5✔
93	++iter)	4✔
94	{
95	iter->second->unmark_virtual();	4✔
96	}
97	return;	1✔
98	}
99
100	void CompositeElement::set_stage(int_fast64_t stage)	294✔
101	{
102	this->stage = stage;	294✔
103	for (auto iter = this->get_iterator(); !this->is_at_end(iter); ++iter)	4,659✔
104	{
105	iter->second->set_stage(stage);	4,365✔
106	}
107	return;	294✔
108	}
109
110	element_id CompositeElement::add_element(element_ptr el)	19,987✔
111	{
112	// Cannot nest a StageElement in another CompositeElement
113	// assert(!el->is_stage());
114	// Disable adding CompositeElements unless `this` is a StageElement
115	// assert(this->is_stage() \|\| el->is_single());
116
117	if (el->is_stage() \|\|	39,974✔
118	(el->is_composite() && !this->is_stage()))	19,987✔
119	{
120	return ELEMENT_INVALID_SETUP;	1✔
121	}
122
123	el->enforce_user_fields_set();	19,986✔
124
125	element_id id = this->my_elements.add_item(el);	19,985✔
126	if (is_success(id))	19,985✔
127	{
128	this->number_of_elements += el->get_number_of_elements();	19,985✔
129	el->set_reference_element(this);	19,985✔
130	}
131	return id;	19,985✔
132	}
133
134	uint_fast64_t CompositeElement::remove_element(element_id id)	1✔
135	{
136	element_ptr el = this->my_elements.get_item(id);	1✔
137	uint_fast64_t nremoved = this->my_elements.remove_item(id);	1✔
138
139	if (nremoved > 0)	1✔
140	{
141	nremoved = el->get_number_of_elements();	1✔
142	this->number_of_elements -= nremoved;	1✔
143	}
144
145	return nremoved;	1✔
146	}	1✔
147
148	element_ptr CompositeElement::get_element(element_id id)	3✔
149	{
150	return this->my_elements.get_item(id);	3✔
151	}
152
153	bool CompositeElement::replace_element(element_id id, element_ptr el)	1✔
154	{
155	element_ptr old_el = this->my_elements.get_item(id);	1✔
156	bool replaced = this->my_elements.replace_item(id, el);	1✔
157
158	if (replaced)	1✔
159	{
160	this->number_of_elements -= old_el->get_number_of_elements();	1✔
161	this->number_of_elements += el->get_number_of_elements();	1✔
162	}
163
164	return replaced;	1✔
165	}	1✔
166
167	void CompositeElement::clear()	621✔
168	{
169	this->number_of_elements = 0;	621✔
170	this->my_elements.clear();	621✔
171	return;	621✔
172	}
173
174	void CompositeElement::enforce_user_fields_set() const	541✔
175	{
176	ElementBase::enforce_user_fields_set();	541✔
177
178	if (this->number_of_elements == 0)	541✔
179	{
180	std::stringstream ss;	2✔
181	ss << "CompositeElement (Name: " << this->get_name()	4✔
182	<< ", UUID: " << this->get_id()	2✔
183	<< ") has no subelements.";	2✔
184	throw std::invalid_argument(ss.str());	2✔
185	}	2✔
186	return;	539✔
187	}
188
189	// Stage and Composite should have the same function
190	void CompositeElement::write_json(nlohmann::ordered_json& jnode) const	11✔
191	{
192	using json = nlohmann::ordered_json;
193
194	// Composite/stage specific info
195	jnode["is_composite"] = true;	11✔
196	jnode["is_single"] = false;	11✔
197	jnode["number_of_elements"] = this->get_number_of_elements();	11✔
198
199	// Common properties of all elements
200	this->write_common_json(jnode);	11✔
201
202	// Loop through each element, writing json node
203	json jelements;	11✔
204	for (auto it = this->get_const_iterator(); !this->is_at_end(it); ++it)	2,463✔
205	{
206	json jelement;	2,452✔
207
208	SolTrace::Data::element_id i = it->first;	2,452✔
209	auto element = it->second;	2,452✔
210
211	element->write_json(jelement);	2,452✔
212
213	jelements[std::to_string(i)] = jelement;	2,452✔
214	}	2,452✔
215	jnode["elements"] = jelements;	11✔
216	}	11✔
217
218	} // namespace SolTrace::Data

NREL / SolTrace / 19580451842

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