Skip to main content

cimstructs/
ThermalGeneratingUnit.rs

1/// A generating unit whose prime mover could be a steam turbine, combustion turbine, or diesel engine.
2#[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]
3pub struct ThermalGeneratingUnit {
4    #[serde(flatten)]
5    pub base: super::GeneratingUnit,
6    /// A thermal generating unit may be a member of a compressed air energy storage plant.
7    #[serde(skip_serializing_if = "Option::is_none")]
8    pub caes_plant: Option<super::base::MridRef>,
9    /// A thermal generating unit may be a member of a cogeneration plant.
10    #[serde(skip_serializing_if = "Option::is_none")]
11    pub cogeneration_plant: Option<super::base::MridRef>,
12    /// A thermal generating unit may be a member of a combined cycle plant.
13    #[serde(skip_serializing_if = "Option::is_none")]
14    pub combined_cycle_plant: Option<super::base::MridRef>,
15}
16impl crate::base::CimElement for ThermalGeneratingUnit {
17    fn mrid(&self) -> &str { &self.base.base.base.base.id }
18    fn type_name(&self) -> &'static str { "ThermalGeneratingUnit" }
19    fn as_any(&self) -> &dyn std::any::Any { self }
20    fn to_json_value(&self) -> serde_json::Value {
21        serde_json::to_value(self).unwrap_or(serde_json::Value::Null)
22    }
23    fn to_block(&self) -> crate::base::RdfBlock {
24        let mut block = self.base.to_block();
25        block.type_name = "ThermalGeneratingUnit".to_string();
26        if let Some(ref v) = self.caes_plant {
27            block.fields.insert("ThermalGeneratingUnit.CAESPlant".into(), crate::base::FieldValue::Resource(v.mrid.clone()));
28        }
29        if let Some(ref v) = self.cogeneration_plant {
30            block.fields.insert("ThermalGeneratingUnit.CogenerationPlant".into(), crate::base::FieldValue::Resource(v.mrid.clone()));
31        }
32        if let Some(ref v) = self.combined_cycle_plant {
33            block.fields.insert("ThermalGeneratingUnit.CombinedCyclePlant".into(), crate::base::FieldValue::Resource(v.mrid.clone()));
34        }
35        block
36    }
37}
38
39impl ThermalGeneratingUnit {
40    pub fn from_block(b: &crate::base::RdfBlock) -> Self {
41        let mut obj = Self::default();
42        obj.base.base.base.base.id.clone_from(&b.mrid);
43        for (key, val) in &b.fields {
44            match key.as_str() {
45                "ThermalGeneratingUnit.CAESPlant" => {
46                    if let crate::base::FieldValue::Resource(sv) = val {
47                        obj.caes_plant = Some(crate::base::MridRef { mrid: sv.clone() });
48                    }
49                }
50                "ThermalGeneratingUnit.CogenerationPlant" => {
51                    if let crate::base::FieldValue::Resource(sv) = val {
52                        obj.cogeneration_plant = Some(crate::base::MridRef { mrid: sv.clone() });
53                    }
54                }
55                "ThermalGeneratingUnit.CombinedCyclePlant" => {
56                    if let crate::base::FieldValue::Resource(sv) = val {
57                        obj.combined_cycle_plant = Some(crate::base::MridRef { mrid: sv.clone() });
58                    }
59                }
60                "GeneratingUnit.genControlSource" => {
61                    if let crate::base::FieldValue::Resource(sv) = val {
62                        obj.base.gen_control_source = Some(crate::base::UriRef { uri: sv.clone() });
63                    }
64                }
65                "GeneratingUnit.governorSCD" => {
66                    match val {
67                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.governor_scd = Some(v); } }
68                        crate::base::FieldValue::TextList(svs) => {
69                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.governor_scd = Some(v); } }
70                        }
71                        _ => {}
72                    }
73                }
74                "GeneratingUnit.longPF" => {
75                    match val {
76                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.long_pf = Some(v); } }
77                        crate::base::FieldValue::TextList(svs) => {
78                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.long_pf = Some(v); } }
79                        }
80                        _ => {}
81                    }
82                }
83                "GeneratingUnit.maxOperatingP" => {
84                    match val {
85                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.max_operating_p = Some(v); } }
86                        crate::base::FieldValue::TextList(svs) => {
87                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.max_operating_p = Some(v); } }
88                        }
89                        _ => {}
90                    }
91                }
92                "GeneratingUnit.maximumAllowableSpinningReserve" => {
93                    match val {
94                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.maximum_allowable_spinning_reserve = Some(v); } }
95                        crate::base::FieldValue::TextList(svs) => {
96                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.maximum_allowable_spinning_reserve = Some(v); } }
97                        }
98                        _ => {}
99                    }
100                }
101                "GeneratingUnit.minOperatingP" => {
102                    match val {
103                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.min_operating_p = Some(v); } }
104                        crate::base::FieldValue::TextList(svs) => {
105                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.min_operating_p = Some(v); } }
106                        }
107                        _ => {}
108                    }
109                }
110                "GeneratingUnit.nominalP" => {
111                    match val {
112                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.nominal_p = Some(v); } }
113                        crate::base::FieldValue::TextList(svs) => {
114                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.nominal_p = Some(v); } }
115                        }
116                        _ => {}
117                    }
118                }
119                "GeneratingUnit.normalPF" => {
120                    match val {
121                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.normal_pf = Some(v); } }
122                        crate::base::FieldValue::TextList(svs) => {
123                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.normal_pf = Some(v); } }
124                        }
125                        _ => {}
126                    }
127                }
128                "GeneratingUnit.ratedGrossMaxP" => {
129                    match val {
130                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.rated_gross_max_p = Some(v); } }
131                        crate::base::FieldValue::TextList(svs) => {
132                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.rated_gross_max_p = Some(v); } }
133                        }
134                        _ => {}
135                    }
136                }
137                "GeneratingUnit.ratedGrossMinP" => {
138                    match val {
139                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.rated_gross_min_p = Some(v); } }
140                        crate::base::FieldValue::TextList(svs) => {
141                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.rated_gross_min_p = Some(v); } }
142                        }
143                        _ => {}
144                    }
145                }
146                "GeneratingUnit.ratedNetMaxP" => {
147                    match val {
148                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.rated_net_max_p = Some(v); } }
149                        crate::base::FieldValue::TextList(svs) => {
150                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.rated_net_max_p = Some(v); } }
151                        }
152                        _ => {}
153                    }
154                }
155                "GeneratingUnit.shortPF" => {
156                    match val {
157                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.short_pf = Some(v); } }
158                        crate::base::FieldValue::TextList(svs) => {
159                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.short_pf = Some(v); } }
160                        }
161                        _ => {}
162                    }
163                }
164                "GeneratingUnit.startupCost" => {
165                    match val {
166                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.startup_cost = Some(v); } }
167                        crate::base::FieldValue::TextList(svs) => {
168                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.startup_cost = Some(v); } }
169                        }
170                        _ => {}
171                    }
172                }
173                "GeneratingUnit.startupTime" => {
174                    match val {
175                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.startup_time = Some(v); } }
176                        crate::base::FieldValue::TextList(svs) => {
177                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.startup_time = Some(v); } }
178                        }
179                        _ => {}
180                    }
181                }
182                "GeneratingUnit.totalEfficiency" => {
183                    match val {
184                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.total_efficiency = Some(v); } }
185                        crate::base::FieldValue::TextList(svs) => {
186                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.total_efficiency = Some(v); } }
187                        }
188                        _ => {}
189                    }
190                }
191                "GeneratingUnit.variableCost" => {
192                    match val {
193                        crate::base::FieldValue::Text(sv) => { if let Ok(v) = sv.trim().parse() { obj.base.variable_cost = Some(v); } }
194                        crate::base::FieldValue::TextList(svs) => {
195                            if let Some(sv) = svs.last() { if let Ok(v) = sv.trim().parse() { obj.base.variable_cost = Some(v); } }
196                        }
197                        _ => {}
198                    }
199                }
200                "Equipment.EquipmentContainer" => {
201                    if let crate::base::FieldValue::Resource(sv) = val {
202                        obj.base.base.equipment_container = Some(crate::base::MridRef { mrid: sv.clone() });
203                    }
204                }
205                "Equipment.aggregate" => {
206                    match val {
207                        crate::base::FieldValue::Text(sv) => { obj.base.base.aggregate = Some(sv.trim() == "true"); }
208                        crate::base::FieldValue::TextList(svs) => {
209                            if let Some(sv) = svs.last() { obj.base.base.aggregate = Some(sv.trim() == "true"); }
210                        }
211                        _ => {}
212                    }
213                }
214                "Equipment.inService" => {
215                    match val {
216                        crate::base::FieldValue::Text(sv) => { obj.base.base.in_service = Some(sv.trim() == "true"); }
217                        crate::base::FieldValue::TextList(svs) => {
218                            if let Some(sv) = svs.last() { obj.base.base.in_service = Some(sv.trim() == "true"); }
219                        }
220                        _ => {}
221                    }
222                }
223                "Equipment.normallyInService" => {
224                    match val {
225                        crate::base::FieldValue::Text(sv) => { obj.base.base.normally_in_service = Some(sv.trim() == "true"); }
226                        crate::base::FieldValue::TextList(svs) => {
227                            if let Some(sv) = svs.last() { obj.base.base.normally_in_service = Some(sv.trim() == "true"); }
228                        }
229                        _ => {}
230                    }
231                }
232                "IdentifiedObject.description" => {
233                    match val {
234                        crate::base::FieldValue::Text(sv) => { obj.base.base.base.base.description = sv.clone(); }
235                        crate::base::FieldValue::TextList(svs) => {
236                            if let Some(sv) = svs.last() { obj.base.base.base.base.description = sv.clone(); }
237                        }
238                        _ => {}
239                    }
240                }
241                "IdentifiedObject.energyIdentCodeEic" => {
242                    match val {
243                        crate::base::FieldValue::Text(sv) => { obj.base.base.base.base.energy_ident_code_eic = sv.clone(); }
244                        crate::base::FieldValue::TextList(svs) => {
245                            if let Some(sv) = svs.last() { obj.base.base.base.base.energy_ident_code_eic = sv.clone(); }
246                        }
247                        _ => {}
248                    }
249                }
250                "IdentifiedObject.mRID" => {
251                    match val {
252                        crate::base::FieldValue::Text(sv) => { obj.base.base.base.base.m_rid = sv.clone(); }
253                        crate::base::FieldValue::TextList(svs) => {
254                            if let Some(sv) = svs.last() { obj.base.base.base.base.m_rid = sv.clone(); }
255                        }
256                        _ => {}
257                    }
258                }
259                "IdentifiedObject.name" => {
260                    match val {
261                        crate::base::FieldValue::Text(sv) => { obj.base.base.base.base.name = sv.clone(); }
262                        crate::base::FieldValue::TextList(svs) => {
263                            if let Some(sv) = svs.last() { obj.base.base.base.base.name = sv.clone(); }
264                        }
265                        _ => {}
266                    }
267                }
268                "IdentifiedObject.shortName" => {
269                    match val {
270                        crate::base::FieldValue::Text(sv) => { obj.base.base.base.base.short_name = sv.clone(); }
271                        crate::base::FieldValue::TextList(svs) => {
272                            if let Some(sv) = svs.last() { obj.base.base.base.base.short_name = sv.clone(); }
273                        }
274                        _ => {}
275                    }
276                }
277                _ => {}
278            }
279        }
280        obj
281    }
282}