Skip to content

water_use

Water use model for calculating water usage during plant operation.

WaterUse

Bases: Model

Model to calculate water use during plant operation, based on the amount of heat that needs to be rejected through the cooling system, and the cooling mechanism used.

The water use is calculated for two different cooling mechanisms: cooling towers, and cooling through water bodies (pond, lake, river). The water use for cooling through water bodies is calculated for both recirculating and once-through systems.

The water use for cooling towers is calculated as a single value, as the water use for cooling towers is not expected to differ significantly between recirculating and once-through systems.

Source code in process/models/water_use.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
class WaterUse(Model):
    """Model to calculate water use during plant operation, based on the amount of heat
    that needs to be rejected through the cooling system, and the cooling mechanism
    used.

    The water use is calculated for two different cooling mechanisms: cooling towers,
    and cooling through water bodies (pond, lake, river). The water use for cooling
    through water bodies is calculated for both recirculating and once-through systems.

    The water use for cooling towers is calculated as a single value, as the water use
    for cooling towers is not expected to differ significantly between recirculating
    and once-through systems.
    """

    def __init__(self):
        self.outfile = constants.NOUT

    def output(self):
        """Routine to call the water usage calculation routines and write output to
        file.
        """
        self.run(output=True)

    def run(self, output: bool = False):
        """Routine to call the water usage calculation routines.
        This routine calls the different water usage routines.

        Parameters
        ----------
        output :
            indicate whether output should be written to the output file, or not
        """
        rejected_heat = self.data.heat_transport.p_plant_primary_heat_mw * (
            1 - self.data.heat_transport.eta_turbine
        )

        wastethermeng = rejected_heat * SECDAY

        if output:
            po.oheadr(
                self.outfile, "Water usage during plant operation (secondary cooling)"
            )
            po.ocmmnt(
                self.outfile,
                "Estimated amount of water used through different cooling system "
                "options:",
            )
            po.ocmmnt(self.outfile, "1. Cooling towers")
            po.ocmmnt(
                self.outfile,
                "2. Water bodies (pond, lake, river): recirculating or once-through",
            )

        # call subroutines for cooling mechanisms:

        # cooling towers
        self.cooling_towers(wastethermeng, output=output)

        # water-body cooling
        self.cooling_water_body(wastethermeng, output=output)

    def cooling_towers(self, wastetherm: float, output: bool):
        """Water used in cooling towers

        Parameters
        ----------
        wastetherm:
            thermal energy (MJ) to be cooled by this system
        output:

        """
        self.data.water_use.evapratio = 1.0e0 - (
            (
                -0.000279e0 * self.data.water_use.airtemp**3
                + 0.00109e0 * self.data.water_use.airtemp**2
                - 0.345e0 * self.data.water_use.airtemp
                + 26.7e0
            )
            / 100.0e0
        )
        # Diehl et al. USGS Report 2013-5188, http://dx.doi.org/10.3133/sir20135188

        self.data.water_use.volheat = (
            self.data.water_use.waterdens * self.data.water_use.latentheat
        )

        self.data.water_use.energypervol = (
            self.data.water_use.volheat / self.data.water_use.evapratio
        )

        self.data.water_use.volperenergy = (
            1.0e0 / self.data.water_use.energypervol * 1000000.0e0
        )

        self.data.water_use.evapvol = wastetherm * self.data.water_use.volperenergy

        # find water withdrawn from external source
        self.data.water_use.waterusetower = 1.4e0 * self.data.water_use.evapvol
        # Estimated as a ratio to evaporated water (averaged across observed dataset)
        #  as per Diehl et al. USGS Report 2014-5184, http://dx.doi.org/10.3133/sir20145184

        #  Output section
        if output:
            po.ovarre(
                self.outfile,
                "Volume used in cooling tower (m3/day)",
                "(waterusetower)",
                self.data.water_use.waterusetower,
                "OP ",
            )

    def cooling_water_body(self, wastetherm: float, output: bool):
        """Water evaporated in cooling through water bodies
        Based on spreadsheet from Diehl et al. USGS Report 2013-5188, which includes
        cooling coefficients found through fits across a dataset containing a wide range
        of temperatures, windspeeds, and heat loading:
        http://pubs.usgs.gov/sir/2013/5188/appendix/sir2013-5188_appendix4_fews_version_3.104.xlsx


        Parameters
        ----------
        wastetherm:
            thermal energy (MJ) to be cooled by this system
        output:

        """
        evapsum = 0.0e0

        icools = [
            # coefficients as per Brady et al. 1969:
            CoolingWaterBodyCoeffs(
                # wind function coefficients
                a=2.47e0,
                b=0e0,
                c=0.12e0,
                # fitted coefficients of heat loading
                d=3061.331e0,
                e=-48.810e0,
                f=-78.559e0,
                g=-291.820e0,
                h=0.267e0,
                i=-0.610e0,
                j=33.497e0,
                # small pond as a cooling body
                # heat loading, MW/acre, based on estimations from US power plants
                heatload=0.35e0,
            ),
            # coefficients as per Webster et al. 1995:
            CoolingWaterBodyCoeffs(
                # wind function coefficients
                a=1.04e0,
                b=1.05e0,
                c=0.0e0,
                # fitted coefficients of heat loading
                d=3876.843e0,
                e=-49.071e0,
                f=-295.246e0,
                g=-327.935e0,
                h=0.260e0,
                i=10.528e0,
                j=40.188e0,
                # large lake or reservoir as a cooling body
                # heat loading, MW/acre, based on estimations from US power plants
                heatload=0.10e0,
            ),
            # coefficients as per Gulliver et al. 1986:
            CoolingWaterBodyCoeffs(
                # wind function coefficients
                a=2.96e0,
                b=0.64e0,
                c=0.0e0,
                # fitted coefficients of heat loading
                d=2565.009e0,
                e=-43.636e0,
                f=-93.834e0,
                g=-203.767e0,
                h=0.257e0,
                i=2.408e0,
                j=20.596e0,
                # stream or river as a cooling body
                # heat loading, MW/acre, based on estimations from US power plants
                heatload=0.20e0,
            ),
        ]

        for icool in icools:
            # Unfortunately, the source spreadsheet was from the US, so the fits for
            # water body heating due to heat loading and the cooling wind functions
            # are in non-metric units, hence the conversions required here.
            # Limitations: maximum wind speed of ~5 m/s; initial
            # self.data.water_use.watertemp < 25 degC

            # find evaporation ratio: ratio of the heat used to evaporate water
            # to the total heat discharged through the tower
            self.data.water_use.evapratio = (
                icool.delta_e(
                    windspeed=self.data.water_use.windspeed,
                    # estimate resultant heated water temperature
                    watertempheated=self.data.water_use.watertemp
                    + (
                        icool.imp_heatload_conversion()
                        * icool.heat_ratio(
                            self.data.water_use.watertemp, self.data.water_use.windspeed
                        )
                    ),
                    watertemp=self.data.water_use.watertemp,
                    waterdens=self.data.water_use.waterdens,
                    latentheat=self.data.water_use.latentheat,
                )
                / icool.met_heatload_conversion()
            )
            # Diehl et al. USGS Report 2013-5188, http://dx.doi.org/10.3133/sir20135188
            self.data.water_use.volheat = (
                self.data.water_use.waterdens * self.data.water_use.latentheat
            )

            self.data.water_use.energypervol = (
                self.data.water_use.volheat / self.data.water_use.evapratio
            )

            self.data.water_use.volperenergy = (
                1.0e0 / self.data.water_use.energypervol * 1000000.0e0
            )

            self.data.water_use.evapvol = wastetherm * self.data.water_use.volperenergy

            # using this method the estimates for pond, lake and river evaporation
            # produce similar results, the average will be taken and used in the next
            # stage of calculation
            evapsum += self.data.water_use.evapvol

        evapsum /= len(icools)

        # water volume withdrawn from external source depends on recirculation or
        # 'once-through' system choice. Estimated as a ratio to evaporated water
        # (averaged across observed dataset) as per Diehl et al. USGS Report 2014-5184,
        # http://dx.doi.org/10.3133/sir20145184

        # recirculating water system:
        self.data.water_use.wateruserecirc = 1.0e0 * evapsum

        # once-through water system:
        self.data.water_use.wateruseonethru = 98.0e0 * evapsum

        #  Output section
        if output:
            po.ovarre(
                self.outfile,
                "Volume used in recirculating water system (m3/day)",
                "(wateruserecirc)",
                self.data.water_use.wateruserecirc,
                "OP ",
            )
            po.ovarre(
                self.outfile,
                "Volume used in once-through water system (m3/day)",
                "(wateruseonethru)",
                self.data.water_use.wateruseonethru,
                "OP ",
            )

outfile = constants.NOUT instance-attribute

output()

Routine to call the water usage calculation routines and write output to file.

Source code in process/models/water_use.py 
30
31
32
33
34
def output(self):
    """Routine to call the water usage calculation routines and write output to
    file.
    """
    self.run(output=True)

run(output=False)

Routine to call the water usage calculation routines. This routine calls the different water usage routines.

Parameters:

Name Type Description Default
output bool

indicate whether output should be written to the output file, or not

 False
Source code in process/models/water_use.py 
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
def run(self, output: bool = False):
    """Routine to call the water usage calculation routines.
    This routine calls the different water usage routines.

    Parameters
    ----------
    output :
        indicate whether output should be written to the output file, or not
    """
    rejected_heat = self.data.heat_transport.p_plant_primary_heat_mw * (
        1 - self.data.heat_transport.eta_turbine
    )

    wastethermeng = rejected_heat * SECDAY

    if output:
        po.oheadr(
            self.outfile, "Water usage during plant operation (secondary cooling)"
        )
        po.ocmmnt(
            self.outfile,
            "Estimated amount of water used through different cooling system "
            "options:",
        )
        po.ocmmnt(self.outfile, "1. Cooling towers")
        po.ocmmnt(
            self.outfile,
            "2. Water bodies (pond, lake, river): recirculating or once-through",
        )

    # call subroutines for cooling mechanisms:

    # cooling towers
    self.cooling_towers(wastethermeng, output=output)

    # water-body cooling
    self.cooling_water_body(wastethermeng, output=output)

cooling_towers(wastetherm, output)

Water used in cooling towers

Parameters:

Name Type Description Default
wastetherm float

thermal energy (MJ) to be cooled by this system

 required
output bool
required
Source code in process/models/water_use.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
def cooling_towers(self, wastetherm: float, output: bool):
    """Water used in cooling towers

    Parameters
    ----------
    wastetherm:
        thermal energy (MJ) to be cooled by this system
    output:

    """
    self.data.water_use.evapratio = 1.0e0 - (
        (
            -0.000279e0 * self.data.water_use.airtemp**3
            + 0.00109e0 * self.data.water_use.airtemp**2
            - 0.345e0 * self.data.water_use.airtemp
            + 26.7e0
        )
        / 100.0e0
    )
    # Diehl et al. USGS Report 2013-5188, http://dx.doi.org/10.3133/sir20135188

    self.data.water_use.volheat = (
        self.data.water_use.waterdens * self.data.water_use.latentheat
    )

    self.data.water_use.energypervol = (
        self.data.water_use.volheat / self.data.water_use.evapratio
    )

    self.data.water_use.volperenergy = (
        1.0e0 / self.data.water_use.energypervol * 1000000.0e0
    )

    self.data.water_use.evapvol = wastetherm * self.data.water_use.volperenergy

    # find water withdrawn from external source
    self.data.water_use.waterusetower = 1.4e0 * self.data.water_use.evapvol
    # Estimated as a ratio to evaporated water (averaged across observed dataset)
    #  as per Diehl et al. USGS Report 2014-5184, http://dx.doi.org/10.3133/sir20145184

    #  Output section
    if output:
        po.ovarre(
            self.outfile,
            "Volume used in cooling tower (m3/day)",
            "(waterusetower)",
            self.data.water_use.waterusetower,
            "OP ",
        )

cooling_water_body(wastetherm, output)

Water evaporated in cooling through water bodies Based on spreadsheet from Diehl et al. USGS Report 2013-5188, which includes cooling coefficients found through fits across a dataset containing a wide range of temperatures, windspeeds, and heat loading: http://pubs.usgs.gov/sir/2013/5188/appendix/sir2013-5188_appendix4_fews_version_3.104.xlsx

Parameters:

Name Type Description Default
wastetherm float

thermal energy (MJ) to be cooled by this system

 required
output bool
required
Source code in process/models/water_use.py 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
def cooling_water_body(self, wastetherm: float, output: bool):
    """Water evaporated in cooling through water bodies
    Based on spreadsheet from Diehl et al. USGS Report 2013-5188, which includes
    cooling coefficients found through fits across a dataset containing a wide range
    of temperatures, windspeeds, and heat loading:
    http://pubs.usgs.gov/sir/2013/5188/appendix/sir2013-5188_appendix4_fews_version_3.104.xlsx


    Parameters
    ----------
    wastetherm:
        thermal energy (MJ) to be cooled by this system
    output:

    """
    evapsum = 0.0e0

    icools = [
        # coefficients as per Brady et al. 1969:
        CoolingWaterBodyCoeffs(
            # wind function coefficients
            a=2.47e0,
            b=0e0,
            c=0.12e0,
            # fitted coefficients of heat loading
            d=3061.331e0,
            e=-48.810e0,
            f=-78.559e0,
            g=-291.820e0,
            h=0.267e0,
            i=-0.610e0,
            j=33.497e0,
            # small pond as a cooling body
            # heat loading, MW/acre, based on estimations from US power plants
            heatload=0.35e0,
        ),
        # coefficients as per Webster et al. 1995:
        CoolingWaterBodyCoeffs(
            # wind function coefficients
            a=1.04e0,
            b=1.05e0,
            c=0.0e0,
            # fitted coefficients of heat loading
            d=3876.843e0,
            e=-49.071e0,
            f=-295.246e0,
            g=-327.935e0,
            h=0.260e0,
            i=10.528e0,
            j=40.188e0,
            # large lake or reservoir as a cooling body
            # heat loading, MW/acre, based on estimations from US power plants
            heatload=0.10e0,
        ),
        # coefficients as per Gulliver et al. 1986:
        CoolingWaterBodyCoeffs(
            # wind function coefficients
            a=2.96e0,
            b=0.64e0,
            c=0.0e0,
            # fitted coefficients of heat loading
            d=2565.009e0,
            e=-43.636e0,
            f=-93.834e0,
            g=-203.767e0,
            h=0.257e0,
            i=2.408e0,
            j=20.596e0,
            # stream or river as a cooling body
            # heat loading, MW/acre, based on estimations from US power plants
            heatload=0.20e0,
        ),
    ]

    for icool in icools:
        # Unfortunately, the source spreadsheet was from the US, so the fits for
        # water body heating due to heat loading and the cooling wind functions
        # are in non-metric units, hence the conversions required here.
        # Limitations: maximum wind speed of ~5 m/s; initial
        # self.data.water_use.watertemp < 25 degC

        # find evaporation ratio: ratio of the heat used to evaporate water
        # to the total heat discharged through the tower
        self.data.water_use.evapratio = (
            icool.delta_e(
                windspeed=self.data.water_use.windspeed,
                # estimate resultant heated water temperature
                watertempheated=self.data.water_use.watertemp
                + (
                    icool.imp_heatload_conversion()
                    * icool.heat_ratio(
                        self.data.water_use.watertemp, self.data.water_use.windspeed
                    )
                ),
                watertemp=self.data.water_use.watertemp,
                waterdens=self.data.water_use.waterdens,
                latentheat=self.data.water_use.latentheat,
            )
            / icool.met_heatload_conversion()
        )
        # Diehl et al. USGS Report 2013-5188, http://dx.doi.org/10.3133/sir20135188
        self.data.water_use.volheat = (
            self.data.water_use.waterdens * self.data.water_use.latentheat
        )

        self.data.water_use.energypervol = (
            self.data.water_use.volheat / self.data.water_use.evapratio
        )

        self.data.water_use.volperenergy = (
            1.0e0 / self.data.water_use.energypervol * 1000000.0e0
        )

        self.data.water_use.evapvol = wastetherm * self.data.water_use.volperenergy

        # using this method the estimates for pond, lake and river evaporation
        # produce similar results, the average will be taken and used in the next
        # stage of calculation
        evapsum += self.data.water_use.evapvol

    evapsum /= len(icools)

    # water volume withdrawn from external source depends on recirculation or
    # 'once-through' system choice. Estimated as a ratio to evaporated water
    # (averaged across observed dataset) as per Diehl et al. USGS Report 2014-5184,
    # http://dx.doi.org/10.3133/sir20145184

    # recirculating water system:
    self.data.water_use.wateruserecirc = 1.0e0 * evapsum

    # once-through water system:
    self.data.water_use.wateruseonethru = 98.0e0 * evapsum

    #  Output section
    if output:
        po.ovarre(
            self.outfile,
            "Volume used in recirculating water system (m3/day)",
            "(wateruserecirc)",
            self.data.water_use.wateruserecirc,
            "OP ",
        )
        po.ovarre(
            self.outfile,
            "Volume used in once-through water system (m3/day)",
            "(wateruseonethru)",
            self.data.water_use.wateruseonethru,
            "OP ",
        )

CoolingWaterBodyCoeffs dataclass

Cooling water body coefficients

Source code in process/models/water_use.py 
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
@dataclass(slots=True)
class CoolingWaterBodyCoeffs:
    """Cooling water body coefficients"""

    a: float = 0.0
    """Constant coefficient in wind function f(W)"""

    b: float = 0.0
    """Wind speed coefficient in wind function f(W), with W in m/s"""

    c: float = 0.0
    """Squared wind speed coefficient in wind function f(W), with W in m/s"""

    d: float = 0.0
    """Constant coefficient in the initial temperature estimate"""

    e: float = 0.0
    """Natural water temperature coefficient in the initial temperature estimate"""

    f: float = 0.0
    """Wind speed coefficient in the initial temperature estimate, with W in mph"""

    g: float = 0.0
    """Added heat load coefficient in the initial temperature estimate"""

    h: float = 0.0
    """Squared water temperature coefficient in the initial temperature estimate"""

    i: float = 0.0
    """Squared wind speed coefficient in the initial temperature estimate"""

    j: float = 0.0
    """Squared added heat load coefficient in the initial temperature estimate"""

    heatload: float = 0.0
    """Added heat load to the water body (MW/acre)"""

    def heat_ratio(self, watertemp, windspeed):
        """Estimate how heat loading will raise temperature, for this water body"""
        # convert self.data.water_use.windspeed to mph
        windspeedmph = windspeed * 2.237
        return (
            self.d
            + (self.e * watertemp)
            + (self.f * windspeedmph)
            + (self.g * self.heatload)
            + (self.h * watertemp**2)
            + (self.i * windspeedmph**2)
            + (self.j * self.heatload**2)
        )

    def imp_heatload_conversion(self):
        """Convert heat loading into cal/(cm2.sec)"""
        return self.heatload * 1e6 * 0.239 / 40469000.0

    def met_heatload_conversion(self):
        """Convert heat loading to J/(m2.day)"""
        return self.heatload * 1e6 / 4046.85642 * SECDAY

    def delta_e(self, windspeed, watertempheated, watertemp, waterdens, latentheat):
        """Find 'forced evaporation' driven by heat inserted into system"""
        # find wind function, m/(day.kPa), applicable to this water body:
        windfunction = (self.a + (self.b * windspeed) + (self.c * windspeed**2)) / 1e3

        # difference in saturation vapour pressure (Clausius-Clapeyron approximation)
        satvapdelta = (
            0.611 * np.exp((17.27 * watertempheated) / (237.3 + watertempheated))
        ) - (0.611 * np.exp((17.27 * watertemp) / (237.3 + watertemp)))

        return waterdens * latentheat * windfunction * satvapdelta

a = 0.0 class-attribute instance-attribute

Constant coefficient in wind function f(W)

b = 0.0 class-attribute instance-attribute

Wind speed coefficient in wind function f(W), with W in m/s

c = 0.0 class-attribute instance-attribute

Squared wind speed coefficient in wind function f(W), with W in m/s

d = 0.0 class-attribute instance-attribute

Constant coefficient in the initial temperature estimate

e = 0.0 class-attribute instance-attribute

Natural water temperature coefficient in the initial temperature estimate

f = 0.0 class-attribute instance-attribute

Wind speed coefficient in the initial temperature estimate, with W in mph

g = 0.0 class-attribute instance-attribute

Added heat load coefficient in the initial temperature estimate

h = 0.0 class-attribute instance-attribute

Squared water temperature coefficient in the initial temperature estimate

i = 0.0 class-attribute instance-attribute

Squared wind speed coefficient in the initial temperature estimate

j = 0.0 class-attribute instance-attribute

Squared added heat load coefficient in the initial temperature estimate

heatload = 0.0 class-attribute instance-attribute

Added heat load to the water body (MW/acre)

heat_ratio(watertemp, windspeed)

Estimate how heat loading will raise temperature, for this water body

Source code in process/models/water_use.py 
312
313
314
315
316
317
318
319
320
321
322
323
324
def heat_ratio(self, watertemp, windspeed):
    """Estimate how heat loading will raise temperature, for this water body"""
    # convert self.data.water_use.windspeed to mph
    windspeedmph = windspeed * 2.237
    return (
        self.d
        + (self.e * watertemp)
        + (self.f * windspeedmph)
        + (self.g * self.heatload)
        + (self.h * watertemp**2)
        + (self.i * windspeedmph**2)
        + (self.j * self.heatload**2)
    )

imp_heatload_conversion()

Convert heat loading into cal/(cm2.sec)

Source code in process/models/water_use.py 
326
327
328
def imp_heatload_conversion(self):
    """Convert heat loading into cal/(cm2.sec)"""
    return self.heatload * 1e6 * 0.239 / 40469000.0

met_heatload_conversion()

Convert heat loading to J/(m2.day)

Source code in process/models/water_use.py 
330
331
332
def met_heatload_conversion(self):
    """Convert heat loading to J/(m2.day)"""
    return self.heatload * 1e6 / 4046.85642 * SECDAY

delta_e(windspeed, watertempheated, watertemp, waterdens, latentheat)

Find 'forced evaporation' driven by heat inserted into system

Source code in process/models/water_use.py 
334
335
336
337
338
339
340
341
342
343
344
def delta_e(self, windspeed, watertempheated, watertemp, waterdens, latentheat):
    """Find 'forced evaporation' driven by heat inserted into system"""
    # find wind function, m/(day.kPa), applicable to this water body:
    windfunction = (self.a + (self.b * windspeed) + (self.c * windspeed**2)) / 1e3

    # difference in saturation vapour pressure (Clausius-Clapeyron approximation)
    satvapdelta = (
        0.611 * np.exp((17.27 * watertempheated) / (237.3 + watertempheated))
    ) - (0.611 * np.exp((17.27 * watertemp) / (237.3 + watertemp)))

    return waterdens * latentheat * windfunction * satvapdelta