11592777954

Committed 29 Oct 2024 03:09PM UTC coverage: 67.508% (-0.08%) from 67.591%

Build # 11592777954

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #564 from SPF-OST/560-black-change-line-length-to-pep8-standard-of-79-and-check-ci-reaction

changed line length in black to 79

Run Details

1054 of 1475 new or added lines in 174 files covered. (71.46%)

150 existing lines in 74 files now uncovered.

10399 of 15404 relevant lines covered (67.51%)

0.68 hits per line

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

88.37

/trnsysGUI/connection/singlePipeConnection.py

from __future__ import annotations

import typing as _tp

import PyQt5.QtWidgets as _qtw

import trnsysGUI.PortItemBase as _pib
import trnsysGUI.TVentil as _tventil
import trnsysGUI.connection.connectionBase as _cb
import trnsysGUI.connection.deleteSinglePipeConnectionCommand as _dspc
import trnsysGUI.connection.hydraulicExport.singlePipe.createExportHydraulicSinglePipeConnection as _cehspc
import trnsysGUI.connection.hydraulicExport.singlePipe.dummy as _he
import trnsysGUI.connection.singlePipeConnectionModel as _model
import trnsysGUI.connection.singlePipeDefaultValues as _defaults
import trnsysGUI.connection.values as _values
import trnsysGUI.globalNames as _gnames
import trnsysGUI.hydraulicLoops.names as _names
import trnsysGUI.internalPiping as _pi
import trnsysGUI.massFlowSolver.names as _mnames
import trnsysGUI.massFlowSolver.networkModel as _mfn
import trnsysGUI.names.undo as _nu
import trnsysGUI.segments.singlePipeSegmentItem as _spsi
import trnsysGUI.singlePipePortItem as _sppi
import trnsysGUI.temperatures as _temps
from . import _massFlowLabels as _mfl

if _tp.TYPE_CHECKING:
    import trnsysGUI.diagram.Editor as _ed


class SinglePipeConnection(
    _cb.ConnectionBase
):  # pylint: disable=too-many-instance-attributes
    def __init__(
        self,
        displayName: str,
        fromPort: _sppi.SinglePipePortItem,
        toPort: _sppi.SinglePipePortItem,
        parent: _ed.Editor,  # type: ignore[name-defined]
    ):
        super().__init__(
            displayName,
            fromPort,
            toPort,
            _defaults.DEFAULT_SHALL_CREATE_TRNSYS_UNIT,
            _defaults.DEFAULT_LENGTH_IN_M,
            parent,
        )

        self.diameterInCm: _values.Value = _defaults.DEFAULT_DIAMETER_IN_CM
        self.uValueInWPerM2K: _values.Value = (
            _defaults.DEFAULT_U_VALUE_IN_W_PER_M2_K
        )

        self._setModels()

    @property
    def fromPort(self) -> _sppi.SinglePipePortItem:
        assert isinstance(self._fromPort, _sppi.SinglePipePortItem)
        return self._fromPort

    @property
    def toPort(self) -> _sppi.SinglePipePortItem:
        assert isinstance(self._toPort, _sppi.SinglePipePortItem)
        return self._toPort

    def getModelPipe(self, portItemType: _mfn.PortItemType) -> _mfn.Pipe:
        if portItemType != _mfn.PortItemType.STANDARD:
            raise ValueError(
                f"Single pipe connections can only have model port items of type {_mfn.PortItemType.STANDARD}"
            )

        return self.modelPipe

    def _createSegmentItem(self, startNode, endNode):
        return _spsi.SinglePipeSegmentItem(startNode, endNode, self)

    def _setModels(self) -> None:
        fromPort = _mfn.PortItem("In", _mfn.PortItemDirection.INPUT)
        toPort = _mfn.PortItem("Out", _mfn.PortItemDirection.OUTPUT)
        self.modelPipe = _mfn.Pipe(fromPort, toPort)

    def getRadius(self):
        rad = 2
        return rad

    def editHydraulicLoop(self) -> None:
        self._editor.editHydraulicLoop(self)

    def createDeleteUndoCommand(
        self, parentCommand: _tp.Optional[_qtw.QUndoCommand] = None
    ) -> _qtw.QUndoCommand:
        undoNamingHelper = _nu.UndoNamingHelper.create(
            self._editor.namesManager
        )

        hydraulicLoopsData = _dspc.HydraulicLoopsData(
            self._editor.hydraulicLoops,
            self._editor.fluids.fluids,
            self._editor.fluids.WATER,
        )

        undoCommand = _dspc.DeleteSinglePipeConnectionCommand(
            self,
            undoNamingHelper,
            hydraulicLoopsData,
            self._editor.diagramScene,
            parentCommand,
        )

        return undoCommand

    def encode(self):
        if len(self.segments) > 0:
            labelPos = self._label.pos().x(), self._label.pos().y()
            labelMassPos = (
                self.massFlowLabel.pos().x(),
                self.massFlowLabel.pos().y(),
            )
        else:
            self.logger.debug("This connection has no segment")
            defaultPos = (
                self.fromPort.pos().x(),
                self.fromPort.pos().y(),
            )  # pylint: disable = duplicate-code # 2
            labelPos = defaultPos
            labelMassPos = defaultPos

        corners = []
        for s in self.getCorners():  # pylint: disable=invalid-name
            cornerTupel = (s.pos().x(), s.pos().y())
            corners.append(cornerTupel)

        connectionModel = _model.ConnectionModel(
            self.connId,
            self.displayName,
            self.id,
            corners,
            labelPos,
            labelMassPos,
            self.fromPort.id,
            self.toPort.id,
            self.trnsysId,
            self.diameterInCm,
            self.uValueInWPerM2K,
            self.lengthInM,
            self.shallBeSimulated,
        )

        dictName = "Connection-"
        return dictName, connectionModel.to_dict()

    def decode(self, i):
        model = _model.ConnectionModel.from_dict(i)

        self.id = model.id
        self.connId = model.connectionId
        self.trnsysId = model.trnsysId
        self.setDisplayName(model.name)

        self.setLabelPos(model.labelPos)
        self.setMassLabelPos(model.massFlowLabelPos)

        self.diameterInCm = model.diameterInCm
        self.uValueInWPerM2K = model.uValueInWPerM2K
        self.lengthInM = model.lengthInM

        self.shallBeSimulated = model.shallBeSimulated

        if len(model.segmentsCorners) > 0:
            self._loadSegments(model.segmentsCorners)

    def getInternalPiping(self) -> _pi.InternalPiping:
        return _pi.InternalPiping(
            [self.modelPipe],
            {
                self.modelPipe.fromPort: self.fromPort,
                self.modelPipe.toPort: self.toPort,
            },
        )

    def exportPipeAndTeeTypesForTemp(
        self, startingUnit: int
    ) -> _tp.Tuple[str, int]:
        unitNumber = startingUnit

        exportHydraulicConnection = (
            _cehspc.createExportHydraulicSinglePipeConnection(
                self, self.fromPort, self.toPort, self.modelPipe
            )
        )

        if not self.shallBeSimulated:
            return _he.exportDummyConnection(
                exportHydraulicConnection, unitNumber
            )

        return self._exportSimulatedPipe(exportHydraulicConnection, unitNumber)

    def _exportSimulatedPipe(
        self, exportHydraulicConnection, unitNumber
    ) -> _tp.Tuple[str, int]:
        canonicalMfrName = _mnames.getCanonicalMassFlowVariableName(
            componentDisplayName=exportHydraulicConnection.displayName,
            pipeName=None,
        )

        outputTemperatureName = _temps.getTemperatureVariableName(
            shallRenameOutputInHydraulicFile=False,
            componentDisplayName=exportHydraulicConnection.displayName,
            nodeName=None,
        )

        exportPipe = exportHydraulicConnection.pipe
        unitText = self._getSimulatedPipeUnitText(
            unitNumber,
            exportPipe.inputPort.massFlowRateVariableName,
            canonicalMfrName,
            exportPipe.inputPort.inputTemperatureVariableName,
            exportPipe.outputPort.inputTemperatureVariableName,
            outputTemperatureName,
        )

        nextUnitNumber = unitNumber + 1

        return unitText, nextUnitNumber

    def _getSimulatedPipeUnitText(  # pylint: disable=too-many-locals
        self,
        unitNumber,
        inputMfrName,
        canonicalMfrName,
        inputTemperatureVariableName,
        revInputTemperatureVariableName,
        outputTemperatureName,
    ):
        loop = self._editor.hydraulicLoops.getLoopForExistingConnection(self)
        densityVar = _names.getDensityName(loop.name.value)
        specHeatVar = _names.getHeatCapacityName(loop.name.value)
        lengthInM = _values.getConvertedValueOrName(self.lengthInM)
        diameterInM = _values.getConvertedValueOrName(
            self.diameterInCm, 1 / 100
        )
        uValueInkJPerHourM2K = _values.getConvertedValueOrName(
            self.uValueInWPerM2K, 60 * 60 / 1000
        )
        uValueInSIUnitsComment = (
            f" (= {self.uValueInWPerM2K} W/(m^2*K))"
            if isinstance(self.uValueInWPerM2K, float)
            else ""
        )
        convectedHeatFluxName = self.getConvectedHeatFluxVariableName()
        dissipatedHeatFluxName = self.getDissipatedHeatFluxVariableName()
        internalHeatName = self.getInternalHeatVariableName()

        unitText = f"""\
UNIT {unitNumber} TYPE 931
! {self.displayName}
PARAMETERS 6
{diameterInM} ! diameter [m]
{lengthInM} ! length [m]
{uValueInkJPerHourM2K} ! U-value [kJ/(h*m^2*K)] {uValueInSIUnitsComment}
{densityVar} ! density [kg/m^3]
{specHeatVar} ! specific heat [kJ/(kg*K)]
{_gnames.SinglePipes.INITIAL_TEMPERATURE} ! Initial fluid temperature [deg C]
INPUTS 4
{inputTemperatureVariableName} ! input flow temperature [deg C]
{inputMfrName} ! input mass flow [kg/h]
TRoomStore ! ambient temperature [deg C]
{revInputTemperatureVariableName} ! reverse flow input temperature [deg C]
***Initial values
20 0.0 20 20

EQUATIONS 5
{outputTemperatureName} = [{unitNumber},1] ! Output flow temperature [deg C]
{dissipatedHeatFluxName} = [{unitNumber},3]/3600 ! Dissipated heat [kW]
{convectedHeatFluxName} = [{unitNumber},4]/3600 ! Convected heat [kW]
{internalHeatName} = [{unitNumber},5] ! Accumulated internal energy since start of simulation [kJ]
{canonicalMfrName} = {inputMfrName}

"""
        return unitText

    def getConvectedHeatFluxVariableName(self) -> str:
        return f"P{self.displayName}Conv_kW"

    def getDissipatedHeatFluxVariableName(self) -> str:
        return f"P{self.displayName}_kW"

    def getInternalHeatVariableName(self) -> str:
        return f"P{self.displayName}Int_kJ"

    def _getFromAndToPortsAndParentBlockItems(
        self,
    ) -> _tp.Tuple[
        _tp.Tuple[_pib.PortItemBase, _pi.HasInternalPiping],
        _tp.Tuple[_pib.PortItemBase, _pi.HasInternalPiping],
    ]:
        isToPortValveOutput = (
            isinstance(self.toPort.parent, _tventil.TVentil)
            and self.fromPort in self.toPort.parent.outputs
        )
        if isToPortValveOutput:
            return (self.toPort, self.toPort.parent), (
                self.fromPort,
                self.fromPort.parent,
            )

        return (self.fromPort, self.fromPort.parent), (
            self.toPort,
            self.toPort.parent,
        )

    def setMassFlowAndTemperature(
        self, massFlow: float, temperature: float
    ) -> None:
        label = _mfl.getFormattedMassFlowAndTemperature(massFlow, temperature)
        self.massFlowLabel.setPlainText(label)

1	from __future__ import annotations	1✔
2
3	import typing as _tp	1✔
4
5	import PyQt5.QtWidgets as _qtw	1✔
6
7	import trnsysGUI.PortItemBase as _pib	1✔
8	import trnsysGUI.TVentil as _tventil	1✔
9	import trnsysGUI.connection.connectionBase as _cb	1✔
10	import trnsysGUI.connection.deleteSinglePipeConnectionCommand as _dspc	1✔
11	import trnsysGUI.connection.hydraulicExport.singlePipe.createExportHydraulicSinglePipeConnection as _cehspc	1✔
12	import trnsysGUI.connection.hydraulicExport.singlePipe.dummy as _he	1✔
13	import trnsysGUI.connection.singlePipeConnectionModel as _model	1✔
14	import trnsysGUI.connection.singlePipeDefaultValues as _defaults	1✔
15	import trnsysGUI.connection.values as _values	1✔
16	import trnsysGUI.globalNames as _gnames	1✔
17	import trnsysGUI.hydraulicLoops.names as _names	1✔
18	import trnsysGUI.internalPiping as _pi	1✔
19	import trnsysGUI.massFlowSolver.names as _mnames	1✔
20	import trnsysGUI.massFlowSolver.networkModel as _mfn	1✔
21	import trnsysGUI.names.undo as _nu	1✔
22	import trnsysGUI.segments.singlePipeSegmentItem as _spsi	1✔
23	import trnsysGUI.singlePipePortItem as _sppi	1✔
24	import trnsysGUI.temperatures as _temps	1✔
25	from . import _massFlowLabels as _mfl	1✔
26
27	if _tp.TYPE_CHECKING:	1✔
28	import trnsysGUI.diagram.Editor as _ed	×
29
30
31	class SinglePipeConnection(	1✔
32	_cb.ConnectionBase
33	): # pylint: disable=too-many-instance-attributes
34	def __init__(	1✔
35	self,
36	displayName: str,
37	fromPort: _sppi.SinglePipePortItem,
38	toPort: _sppi.SinglePipePortItem,
39	parent: _ed.Editor, # type: ignore[name-defined]
40	):
41	super().__init__(	1✔
42	displayName,
43	fromPort,
44	toPort,
45	_defaults.DEFAULT_SHALL_CREATE_TRNSYS_UNIT,
46	_defaults.DEFAULT_LENGTH_IN_M,
47	parent,
48	)
49
50	self.diameterInCm: _values.Value = _defaults.DEFAULT_DIAMETER_IN_CM	1✔
51	self.uValueInWPerM2K: _values.Value = (	1✔
52	_defaults.DEFAULT_U_VALUE_IN_W_PER_M2_K
53	)
54
55	self._setModels()	1✔
56
57	@property	1✔
58	def fromPort(self) -> _sppi.SinglePipePortItem:	1✔
59	assert isinstance(self._fromPort, _sppi.SinglePipePortItem)	1✔
60	return self._fromPort	1✔
61
62	@property	1✔
63	def toPort(self) -> _sppi.SinglePipePortItem:	1✔
64	assert isinstance(self._toPort, _sppi.SinglePipePortItem)	1✔
65	return self._toPort	1✔
66
67	def getModelPipe(self, portItemType: _mfn.PortItemType) -> _mfn.Pipe:	1✔
68	if portItemType != _mfn.PortItemType.STANDARD:	1✔
69	raise ValueError(	×
70	f"Single pipe connections can only have model port items of type {_mfn.PortItemType.STANDARD}"
71	)
72
73	return self.modelPipe	1✔
74
75	def _createSegmentItem(self, startNode, endNode):	1✔
76	return _spsi.SinglePipeSegmentItem(startNode, endNode, self)	1✔
77
78	def _setModels(self) -> None:	1✔
79	fromPort = _mfn.PortItem("In", _mfn.PortItemDirection.INPUT)	1✔
80	toPort = _mfn.PortItem("Out", _mfn.PortItemDirection.OUTPUT)	1✔
81	self.modelPipe = _mfn.Pipe(fromPort, toPort)	1✔
82
83	def getRadius(self):	1✔
84	rad = 2	1✔
85	return rad	1✔
86
87	def editHydraulicLoop(self) -> None:	1✔
88	self._editor.editHydraulicLoop(self)	×
89
90	def createDeleteUndoCommand(	1✔
91	self, parentCommand: _tp.Optional[_qtw.QUndoCommand] = None
92	) -> _qtw.QUndoCommand:
NEW 93	undoNamingHelper = _nu.UndoNamingHelper.create(	×
94	self._editor.namesManager
95	)
96
97	hydraulicLoopsData = _dspc.HydraulicLoopsData(	×
98	self._editor.hydraulicLoops,
99	self._editor.fluids.fluids,
100	self._editor.fluids.WATER,
101	)
102
103	undoCommand = _dspc.DeleteSinglePipeConnectionCommand(	×
104	self,
105	undoNamingHelper,
106	hydraulicLoopsData,
107	self._editor.diagramScene,
108	parentCommand,
109	)
110
111	return undoCommand	×
112
113	def encode(self):	1✔
114	if len(self.segments) > 0:	1✔
115	labelPos = self._label.pos().x(), self._label.pos().y()	1✔
116	labelMassPos = (	1✔
117	self.massFlowLabel.pos().x(),
118	self.massFlowLabel.pos().y(),
119	)
120	else:
121	self.logger.debug("This connection has no segment")	×
NEW 122	defaultPos = (	×
123	self.fromPort.pos().x(),
124	self.fromPort.pos().y(),
125	) # pylint: disable = duplicate-code # 2
126	labelPos = defaultPos	×
127	labelMassPos = defaultPos	×
128
129	corners = []	1✔
130	for s in self.getCorners(): # pylint: disable=invalid-name	1✔
131	cornerTupel = (s.pos().x(), s.pos().y())	1✔
132	corners.append(cornerTupel)	1✔
133
134	connectionModel = _model.ConnectionModel(	1✔
135	self.connId,
136	self.displayName,
137	self.id,
138	corners,
139	labelPos,
140	labelMassPos,
141	self.fromPort.id,
142	self.toPort.id,
143	self.trnsysId,
144	self.diameterInCm,
145	self.uValueInWPerM2K,
146	self.lengthInM,
147	self.shallBeSimulated,
148	)
149
150	dictName = "Connection-"	1✔
151	return dictName, connectionModel.to_dict()	1✔
152
153	def decode(self, i):	1✔
154	model = _model.ConnectionModel.from_dict(i)	1✔
155
156	self.id = model.id	1✔
157	self.connId = model.connectionId	1✔
158	self.trnsysId = model.trnsysId	1✔
159	self.setDisplayName(model.name)	1✔
160
161	self.setLabelPos(model.labelPos)	1✔
162	self.setMassLabelPos(model.massFlowLabelPos)	1✔
163
164	self.diameterInCm = model.diameterInCm	1✔
165	self.uValueInWPerM2K = model.uValueInWPerM2K	1✔
166	self.lengthInM = model.lengthInM	1✔
167
168	self.shallBeSimulated = model.shallBeSimulated	1✔
169
170	if len(model.segmentsCorners) > 0:	1✔
171	self._loadSegments(model.segmentsCorners)	1✔
172
173	def getInternalPiping(self) -> _pi.InternalPiping:	1✔
174	return _pi.InternalPiping(	1✔
175	[self.modelPipe],
176	{
177	self.modelPipe.fromPort: self.fromPort,
178	self.modelPipe.toPort: self.toPort,
179	},
180	)
181
182	def exportPipeAndTeeTypesForTemp(	1✔
183	self, startingUnit: int
184	) -> _tp.Tuple[str, int]:
185	unitNumber = startingUnit	1✔
186
187	exportHydraulicConnection = (	1✔
188	_cehspc.createExportHydraulicSinglePipeConnection(
189	self, self.fromPort, self.toPort, self.modelPipe
190	)
191	)
192
193	if not self.shallBeSimulated:	1✔
194	return _he.exportDummyConnection(	1✔
195	exportHydraulicConnection, unitNumber
196	)
197
198	return self._exportSimulatedPipe(exportHydraulicConnection, unitNumber)	1✔
199
200	def _exportSimulatedPipe(	1✔
201	self, exportHydraulicConnection, unitNumber
202	) -> _tp.Tuple[str, int]:
203	canonicalMfrName = _mnames.getCanonicalMassFlowVariableName(	1✔
204	componentDisplayName=exportHydraulicConnection.displayName,
205	pipeName=None,
206	)
207
208	outputTemperatureName = _temps.getTemperatureVariableName(	1✔
209	shallRenameOutputInHydraulicFile=False,
210	componentDisplayName=exportHydraulicConnection.displayName,
211	nodeName=None,
212	)
213
214	exportPipe = exportHydraulicConnection.pipe	1✔
215	unitText = self._getSimulatedPipeUnitText(	1✔
216	unitNumber,
217	exportPipe.inputPort.massFlowRateVariableName,
218	canonicalMfrName,
219	exportPipe.inputPort.inputTemperatureVariableName,
220	exportPipe.outputPort.inputTemperatureVariableName,
221	outputTemperatureName,
222	)
223
224	nextUnitNumber = unitNumber + 1	1✔
225
226	return unitText, nextUnitNumber	1✔
227
228	def _getSimulatedPipeUnitText( # pylint: disable=too-many-locals	1✔
229	self,
230	unitNumber,
231	inputMfrName,
232	canonicalMfrName,
233	inputTemperatureVariableName,
234	revInputTemperatureVariableName,
235	outputTemperatureName,
236	):
237	loop = self._editor.hydraulicLoops.getLoopForExistingConnection(self)	1✔
238	densityVar = _names.getDensityName(loop.name.value)	1✔
239	specHeatVar = _names.getHeatCapacityName(loop.name.value)	1✔
240	lengthInM = _values.getConvertedValueOrName(self.lengthInM)	1✔
241	diameterInM = _values.getConvertedValueOrName(	1✔
242	self.diameterInCm, 1 / 100
243	)
244	uValueInkJPerHourM2K = _values.getConvertedValueOrName(	1✔
245	self.uValueInWPerM2K, 60 * 60 / 1000
246	)
247	uValueInSIUnitsComment = (	1✔
248	f" (= {self.uValueInWPerM2K} W/(m^2*K))"
249	if isinstance(self.uValueInWPerM2K, float)
250	else ""
251	)
252	convectedHeatFluxName = self.getConvectedHeatFluxVariableName()	1✔
253	dissipatedHeatFluxName = self.getDissipatedHeatFluxVariableName()	1✔
254	internalHeatName = self.getInternalHeatVariableName()	1✔
255
256	unitText = f"""\	1✔
257	UNIT {unitNumber} TYPE 931
258	! {self.displayName}
259	PARAMETERS 6
260	{diameterInM} ! diameter [m]
261	{lengthInM} ! length [m]
262	{uValueInkJPerHourM2K} ! U-value [kJ/(hm^2K)] {uValueInSIUnitsComment}
263	{densityVar} ! density [kg/m^3]
264	{specHeatVar} ! specific heat [kJ/(kg*K)]
265	{_gnames.SinglePipes.INITIAL_TEMPERATURE} ! Initial fluid temperature [deg C]
266	INPUTS 4
267	{inputTemperatureVariableName} ! input flow temperature [deg C]
268	{inputMfrName} ! input mass flow [kg/h]
269	TRoomStore ! ambient temperature [deg C]
270	{revInputTemperatureVariableName} ! reverse flow input temperature [deg C]
271	***Initial values
272	20 0.0 20 20
273
274	EQUATIONS 5
275	{outputTemperatureName} = [{unitNumber},1] ! Output flow temperature [deg C]
276	{dissipatedHeatFluxName} = [{unitNumber},3]/3600 ! Dissipated heat [kW]
277	{convectedHeatFluxName} = [{unitNumber},4]/3600 ! Convected heat [kW]
278	{internalHeatName} = [{unitNumber},5] ! Accumulated internal energy since start of simulation [kJ]
279	{canonicalMfrName} = {inputMfrName}
280
281	"""
282	return unitText	1✔
283
284	def getConvectedHeatFluxVariableName(self) -> str:	1✔
285	return f"P{self.displayName}Conv_kW"	1✔
286
287	def getDissipatedHeatFluxVariableName(self) -> str:	1✔
288	return f"P{self.displayName}_kW"	1✔
289
290	def getInternalHeatVariableName(self) -> str:	1✔
291	return f"P{self.displayName}Int_kJ"	1✔
292
293	def _getFromAndToPortsAndParentBlockItems(	1✔
294	self,
295	) -> _tp.Tuple[
296	_tp.Tuple[_pib.PortItemBase, _pi.HasInternalPiping],
297	_tp.Tuple[_pib.PortItemBase, _pi.HasInternalPiping],
298	]:
299	isToPortValveOutput = (	×
300	isinstance(self.toPort.parent, _tventil.TVentil)
301	and self.fromPort in self.toPort.parent.outputs
302	)
303	if isToPortValveOutput:	×
NEW 304	return (self.toPort, self.toPort.parent), (	×
305	self.fromPort,
306	self.fromPort.parent,
307	)
308
NEW 309	return (self.fromPort, self.fromPort.parent), (	×
310	self.toPort,
311	self.toPort.parent,
312	)
313
314	def setMassFlowAndTemperature(	1✔
315	self, massFlow: float, temperature: float
316	) -> None:
317	label = _mfl.getFormattedMassFlowAndTemperature(massFlow, temperature)	1✔
318	self.massFlowLabel.setPlainText(label)	1✔

SPF-OST / pytrnsys_gui / 11592777954

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