-
Notifications
You must be signed in to change notification settings - Fork 993
/
modelchain.py
2090 lines (1784 loc) · 77.4 KB
/
modelchain.py
1
2
3
4
5
6
7
8
9
10
11
12
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
273
274
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
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
"""
The ``modelchain`` module contains functions and classes that combine
many of the PV power modeling steps. These tools make it easy to
get started with pvlib and demonstrate standard ways to use the
library. With great power comes great responsibility: users should take
the time to read the source code for the module.
"""
from functools import partial
import itertools
import warnings
import pandas as pd
from dataclasses import dataclass, field
from typing import Union, Tuple, Optional, TypeVar
from pvlib import (atmosphere, clearsky, inverter, pvsystem, solarposition,
temperature, iam)
import pvlib.irradiance # avoid name conflict with full import
from pvlib.pvsystem import _DC_MODEL_PARAMS
from pvlib.tools import _build_kwargs
from pvlib._deprecation import deprecated
# keys that are used to detect input data and assign data to appropriate
# ModelChain attribute
# for ModelChain.weather
WEATHER_KEYS = ('ghi', 'dhi', 'dni', 'wind_speed', 'temp_air',
'precipitable_water')
# for ModelChain.total_irrad
POA_KEYS = ('poa_global', 'poa_direct', 'poa_diffuse')
# Optional keys to communicate temperature data. If provided,
# 'cell_temperature' overrides ModelChain.temperature_model and sets
# ModelChain.cell_temperature to the data. If 'module_temperature' is provdied,
# overrides ModelChain.temperature_model with
# pvlib.temperature.sapm_celL_from_module
TEMPERATURE_KEYS = ('module_temperature', 'cell_temperature')
DATA_KEYS = WEATHER_KEYS + POA_KEYS + TEMPERATURE_KEYS
# these dictionaries contain the default configuration for following
# established modeling sequences. They can be used in combination with
# basic_chain and ModelChain. They are used by the ModelChain methods
# ModelChain.with_pvwatts, ModelChain.with_sapm, etc.
# pvwatts documentation states that it uses the following reference for
# a temperature model: Fuentes, M. K. (1987). A Simplified Thermal Model
# for Flat-Plate Photovoltaic Arrays. SAND85-0330. Albuquerque, NM:
# Sandia National Laboratories. Accessed September 3, 2013:
# http://prod.sandia.gov/techlib/access-control.cgi/1985/850330.pdf
# pvlib python does not implement that model, so use the SAPM instead.
PVWATTS_CONFIG = dict(
dc_model='pvwatts', ac_model='pvwatts', losses_model='pvwatts',
transposition_model='perez', aoi_model='physical',
spectral_model='no_loss', temperature_model='sapm'
)
SAPM_CONFIG = dict(
dc_model='sapm', ac_model='sandia', losses_model='no_loss',
aoi_model='sapm', spectral_model='sapm', temperature_model='sapm'
)
@deprecated(
since='0.9.1',
name='pvlib.modelchain.basic_chain',
alternative=('pvlib.modelchain.ModelChain.with_pvwatts'
' or pvlib.modelchain.ModelChain.with_sapm'),
addendum='Note that the with_xyz methods take different model parameters.'
)
def basic_chain(times, latitude, longitude,
surface_tilt, surface_azimuth,
module_parameters, temperature_model_parameters,
inverter_parameters,
irradiance=None, weather=None,
transposition_model='haydavies',
solar_position_method='nrel_numpy',
airmass_model='kastenyoung1989',
altitude=None, pressure=None,
**kwargs):
"""
An experimental function that computes all of the modeling steps
necessary for calculating power or energy for a PV system at a given
location.
Parameters
----------
times : DatetimeIndex
Times at which to evaluate the model.
latitude : float.
Positive is north of the equator.
Use decimal degrees notation.
longitude : float.
Positive is east of the prime meridian.
Use decimal degrees notation.
surface_tilt : numeric
Surface tilt angles in decimal degrees.
The tilt angle is defined as degrees from horizontal
(e.g. surface facing up = 0, surface facing horizon = 90)
surface_azimuth : numeric
Surface azimuth angles in decimal degrees.
The azimuth convention is defined
as degrees east of north
(North=0, South=180, East=90, West=270).
module_parameters : dict or Series
Module parameters as defined by the SAPM. See pvsystem.sapm for
details.
temperature_model_parameters : dict or Series
Temperature model parameters as defined by the SAPM.
See temperature.sapm_cell for details.
inverter_parameters : dict or Series
Inverter parameters as defined by the CEC. See
:py:func:`inverter.sandia` for details.
irradiance : DataFrame, optional
If not specified, calculates clear sky data.
Columns must be 'dni', 'ghi', 'dhi'.
weather : DataFrame, optional
If not specified, assumes air temperature is 20 C and
wind speed is 0 m/s.
Columns must be 'wind_speed', 'temp_air'.
transposition_model : str, default 'haydavies'
Passed to system.get_irradiance.
solar_position_method : str, default 'nrel_numpy'
Passed to solarposition.get_solarposition.
airmass_model : str, default 'kastenyoung1989'
Passed to atmosphere.relativeairmass.
altitude : float, optional
If not specified, computed from ``pressure``. Assumed to be 0 m
if ``pressure`` is also unspecified.
pressure : float, optional
If not specified, computed from ``altitude``. Assumed to be 101325 Pa
if ``altitude`` is also unspecified.
**kwargs
Arbitrary keyword arguments.
See code for details.
Returns
-------
output : (dc, ac)
Tuple of DC power (with SAPM parameters) (DataFrame) and AC
power (Series).
"""
if altitude is None and pressure is None:
altitude = 0.
pressure = 101325.
elif altitude is None:
altitude = atmosphere.pres2alt(pressure)
elif pressure is None:
pressure = atmosphere.alt2pres(altitude)
solar_position = solarposition.get_solarposition(
times, latitude, longitude, altitude=altitude, pressure=pressure,
method=solar_position_method, **kwargs)
# possible error with using apparent zenith with some models
airmass = atmosphere.get_relative_airmass(
solar_position['apparent_zenith'], model=airmass_model)
airmass = atmosphere.get_absolute_airmass(airmass, pressure)
dni_extra = pvlib.irradiance.get_extra_radiation(solar_position.index)
aoi = pvlib.irradiance.aoi(surface_tilt, surface_azimuth,
solar_position['apparent_zenith'],
solar_position['azimuth'])
if irradiance is None:
linke_turbidity = clearsky.lookup_linke_turbidity(
solar_position.index, latitude, longitude)
irradiance = clearsky.ineichen(
solar_position['apparent_zenith'],
airmass,
linke_turbidity,
altitude=altitude,
dni_extra=dni_extra
)
total_irrad = pvlib.irradiance.get_total_irradiance(
surface_tilt,
surface_azimuth,
solar_position['apparent_zenith'],
solar_position['azimuth'],
irradiance['dni'],
irradiance['ghi'],
irradiance['dhi'],
model=transposition_model,
dni_extra=dni_extra)
if weather is None:
weather = {'wind_speed': 0, 'temp_air': 20}
cell_temperature = temperature.sapm_cell(
total_irrad['poa_global'], weather['temp_air'], weather['wind_speed'],
temperature_model_parameters['a'], temperature_model_parameters['b'],
temperature_model_parameters['deltaT'])
effective_irradiance = pvsystem.sapm_effective_irradiance(
total_irrad['poa_direct'], total_irrad['poa_diffuse'], airmass, aoi,
module_parameters)
dc = pvsystem.sapm(effective_irradiance, cell_temperature,
module_parameters)
ac = inverter.sandia(dc['v_mp'], dc['p_mp'], inverter_parameters)
return dc, ac
def get_orientation(strategy, **kwargs):
"""
Determine a PV system's surface tilt and surface azimuth
using a named strategy.
Parameters
----------
strategy: str
The orientation strategy.
Allowed strategies include 'flat', 'south_at_latitude_tilt'.
**kwargs:
Strategy-dependent keyword arguments. See code for details.
Returns
-------
surface_tilt, surface_azimuth
"""
if strategy == 'south_at_latitude_tilt':
surface_azimuth = 180
surface_tilt = kwargs['latitude']
elif strategy == 'flat':
surface_azimuth = 180
surface_tilt = 0
else:
raise ValueError('invalid orientation strategy. strategy must '
'be one of south_at_latitude, flat,')
return surface_tilt, surface_azimuth
def _getmcattr(self, attr):
"""
Helper for __repr__ methods, needed to avoid recursion in property
lookups
"""
out = getattr(self, attr)
try:
out = out.__name__
except AttributeError:
pass
return out
def _mcr_repr(obj):
'''
Helper for ModelChainResult.__repr__
'''
if isinstance(obj, tuple):
return "Tuple (" + ", ".join([_mcr_repr(o) for o in obj]) + ")"
if isinstance(obj, pd.DataFrame):
return "DataFrame ({} rows x {} columns)".format(*obj.shape)
if isinstance(obj, pd.Series):
return "Series (length {})".format(len(obj))
# scalar, None, other?
return repr(obj)
# Type for fields that vary between arrays
T = TypeVar('T')
PerArray = Union[T, Tuple[T, ...]]
@dataclass
class ModelChainResult:
# these attributes are used in __setattr__ to determine the correct type.
_singleton_tuples: bool = field(default=False)
_per_array_fields = {'total_irrad', 'aoi', 'aoi_modifier',
'spectral_modifier', 'cell_temperature',
'effective_irradiance', 'dc', 'diode_params',
'dc_ohmic_losses', 'weather', 'albedo'}
# system-level information
solar_position: Optional[pd.DataFrame] = field(default=None)
"""Solar position in a DataFrame containing columns ``'apparent_zenith'``,
``'zenith'``, ``'apparent_elevation'``, ``'elevation'``, ``'azimuth'``
(all in degrees), with possibly other columns depending on the solar
position method; see :py:func:`~pvlib.solarposition.get_solarposition`
for details."""
airmass: Optional[pd.DataFrame] = field(default=None)
"""Air mass in a DataFrame containing columns ``'airmass_relative'``,
``'airmass_absolute'`` (unitless); see
:py:meth:`~pvlib.location.Location.get_airmass` for details."""
ac: Optional[pd.Series] = field(default=None)
"""AC power from the PV system, in a Series [W]"""
tracking: Optional[pd.DataFrame] = field(default=None)
"""Orientation of modules on a single axis tracker, in a DataFrame with
columns ``'surface_tilt'``, ``'surface_azimuth'``, ``'aoi'``; see
:py:func:`~pvlib.tracking.singleaxis` for details.
"""
losses: Optional[Union[pd.Series, float]] = field(default=None)
"""Series containing DC loss as a fraction of total DC power, as
calculated by ``ModelChain.losses_model``.
"""
# per DC array information
total_irrad: Optional[PerArray[pd.DataFrame]] = field(default=None)
""" DataFrame (or tuple of DataFrame, one for each array) containing
columns ``'poa_global'``, ``'poa_direct'`` ``'poa_diffuse'``,
``poa_sky_diffuse'``, ``'poa_ground_diffuse'`` (W/m2); see
:py:func:`~pvlib.irradiance.get_total_irradiance` for details.
"""
aoi: Optional[PerArray[pd.Series]] = field(default=None)
"""
Series (or tuple of Series, one for each array) containing angle of
incidence (degrees); see :py:func:`~pvlib.irradiance.aoi` for details.
"""
aoi_modifier: Optional[PerArray[Union[pd.Series, float]]] = \
field(default=None)
"""Series (or tuple of Series, one for each array) containing angle of
incidence modifier (unitless) calculated by ``ModelChain.aoi_model``,
which reduces direct irradiance for reflections;
see :py:meth:`~pvlib.pvsystem.PVSystem.get_iam` for details.
"""
spectral_modifier: Optional[PerArray[Union[pd.Series, float]]] = \
field(default=None)
"""Series (or tuple of Series, one for each array) containing spectral
modifier (unitless) calculated by ``ModelChain.spectral_model``, which
adjusts broadband plane-of-array irradiance for spectral content.
"""
cell_temperature: Optional[PerArray[pd.Series]] = field(default=None)
"""Series (or tuple of Series, one for each array) containing cell
temperature (C).
"""
effective_irradiance: Optional[PerArray[pd.Series]] = field(default=None)
"""Series (or tuple of Series, one for each array) containing effective
irradiance (W/m2) which is total plane-of-array irradiance adjusted for
reflections and spectral content.
"""
dc: Optional[PerArray[Union[pd.Series, pd.DataFrame]]] = \
field(default=None)
"""Series or DataFrame (or tuple of Series or DataFrame, one for
each array) containing DC power (W) for each array, calculated by
``ModelChain.dc_model``.
"""
diode_params: Optional[PerArray[pd.DataFrame]] = field(default=None)
"""DataFrame (or tuple of DataFrame, one for each array) containing diode
equation parameters (columns ``'I_L'``, ``'I_o'``, ``'R_s'``, ``'R_sh'``,
``'nNsVth'``, present when ModelChain.dc_model is a single diode model;
see :py:func:`~pvlib.pvsystem.singlediode` for details.
"""
dc_ohmic_losses: Optional[PerArray[pd.Series]] = field(default=None)
"""Series (or tuple of Series, one for each array) containing DC ohmic
loss (W) calculated by ``ModelChain.dc_ohmic_model``.
"""
# copies of input data, for user convenience
weather: Optional[PerArray[pd.DataFrame]] = None
"""DataFrame (or tuple of DataFrame, one for each array) contains a
copy of the input weather data.
"""
times: Optional[pd.DatetimeIndex] = None
"""DatetimeIndex containing a copy of the index of the input weather data.
"""
albedo: Optional[PerArray[pd.Series]] = None
"""Series (or tuple of Series, one for each array) containing albedo.
"""
def _result_type(self, value):
"""Coerce `value` to the correct type according to
``self._singleton_tuples``."""
# Allow None to pass through without being wrapped in a tuple
if (self._singleton_tuples
and not isinstance(value, tuple)
and value is not None):
return (value,)
return value
def __setattr__(self, key, value):
if key in ModelChainResult._per_array_fields:
value = self._result_type(value)
super().__setattr__(key, value)
def __repr__(self):
mc_attrs = dir(self)
def _head(obj):
try:
return obj[:3]
except:
return obj
if type(self.dc) is tuple:
num_arrays = len(self.dc)
else:
num_arrays = 1
desc1 = ('=== ModelChainResult === \n')
desc2 = (f'Number of Arrays: {num_arrays} \n')
attr = 'times'
desc3 = ('times (first 3)\n' +
f'{_head(_getmcattr(self, attr))}' +
'\n')
lines = []
for attr in mc_attrs:
if not (attr.startswith('_') or attr=='times'):
lines.append(f' {attr}: ' + _mcr_repr(getattr(self, attr)))
desc4 = '\n'.join(lines)
return (desc1 + desc2 + desc3 + desc4)
class ModelChain:
"""
The ModelChain class to provides a standardized, high-level
interface for all of the modeling steps necessary for calculating PV
power from a time series of weather inputs. The same models are applied
to all ``pvsystem.Array`` objects, so each Array must contain the
appropriate model parameters. For example, if ``dc_model='pvwatts'``,
then each ``Array.module_parameters`` must contain ``'pdc0'``.
See :ref:`modelchaindoc` for examples.
Parameters
----------
system : PVSystem
A :py:class:`~pvlib.pvsystem.PVSystem` object that represents
the connected set of modules, inverters, etc.
location : Location
A :py:class:`~pvlib.location.Location` object that represents
the physical location at which to evaluate the model.
clearsky_model : str, default 'ineichen'
Passed to location.get_clearsky. Only used when DNI is not found in
the weather inputs.
transposition_model : str, default 'haydavies'
Passed to system.get_irradiance.
solar_position_method : str, default 'nrel_numpy'
Passed to location.get_solarposition.
airmass_model : str, default 'kastenyoung1989'
Passed to location.get_airmass.
dc_model : str, or function, optional
If not specified, the model will be inferred from the parameters that
are common to all of system.arrays[i].module_parameters.
Valid strings are 'sapm', 'desoto', 'cec', 'pvsyst', 'pvwatts'.
The ModelChain instance will be passed as the first argument
to a user-defined function.
ac_model : str, or function, optional
If not specified, the model will be inferred from the parameters that
are common to all of system.inverter_parameters.
Valid strings are 'sandia', 'adr', 'pvwatts'. The
ModelChain instance will be passed as the first argument to a
user-defined function.
aoi_model : str, or function, optional
If not specified, the model will be inferred from the parameters that
are common to all of system.arrays[i].module_parameters.
Valid strings are 'physical', 'ashrae', 'sapm', 'martin_ruiz',
'interp' and 'no_loss'. The ModelChain instance will be passed as the
first argument to a user-defined function.
spectral_model : str, or function, optional
If not specified, the model will be inferred from the parameters that
are common to all of system.arrays[i].module_parameters.
Valid strings are 'sapm', 'first_solar', 'no_loss'.
The ModelChain instance will be passed as the first argument to
a user-defined function.
temperature_model : str or function, optional
Valid strings are: 'sapm', 'pvsyst', 'faiman', 'fuentes', 'noct_sam'.
The ModelChain instance will be passed as the first argument to a
user-defined function.
dc_ohmic_model: str or function, default 'no_loss'
Valid strings are 'dc_ohms_from_percent', 'no_loss'. The ModelChain
instance will be passed as the first argument to a user-defined
function.
losses_model: str or function, default 'no_loss'
Valid strings are 'pvwatts', 'no_loss'. The ModelChain instance
will be passed as the first argument to a user-defined function.
name : str, optional
Name of ModelChain instance.
"""
def __init__(self, system, location,
clearsky_model='ineichen',
transposition_model='haydavies',
solar_position_method='nrel_numpy',
airmass_model='kastenyoung1989',
dc_model=None, ac_model=None, aoi_model=None,
spectral_model=None, temperature_model=None,
dc_ohmic_model='no_loss',
losses_model='no_loss', name=None):
self.name = name
self.system = system
self.location = location
self.clearsky_model = clearsky_model
self.transposition_model = transposition_model
self.solar_position_method = solar_position_method
self.airmass_model = airmass_model
# calls setters
self.dc_model = dc_model
self.ac_model = ac_model
self.aoi_model = aoi_model
self.spectral_model = spectral_model
self.temperature_model = temperature_model
self.dc_ohmic_model = dc_ohmic_model
self.losses_model = losses_model
self.results = ModelChainResult()
@classmethod
def with_pvwatts(cls, system, location,
clearsky_model='ineichen',
airmass_model='kastenyoung1989',
name=None,
**kwargs):
"""
ModelChain that follows the PVWatts methods.
Parameters
----------
system : PVSystem
A :py:class:`~pvlib.pvsystem.PVSystem` object that represents
the connected set of modules, inverters, etc.
location : Location
A :py:class:`~pvlib.location.Location` object that represents
the physical location at which to evaluate the model.
clearsky_model : str, default 'ineichen'
Passed to location.get_clearsky.
airmass_model : str, default 'kastenyoung1989'
Passed to location.get_airmass.
name : str, optional
Name of ModelChain instance.
**kwargs
Parameters supplied here are passed to the ModelChain
constructor and take precedence over the default
configuration.
Warning
-------
The PVWatts model defaults to 14 % total system losses. The PVWatts
losses are fractions of DC power and can be modified, as shown in the
example below.
Examples
--------
>>> from pvlib import temperature, pvsystem, location, modelchain
>>> module_parameters = dict(gamma_pdc=-0.003, pdc0=4500)
>>> inverter_parameters = dict(pdc0=4000)
>>> tparams = temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass']
>>> system = pvsystem.PVSystem(
>>> surface_tilt=30, surface_azimuth=180,
>>> module_parameters=module_parameters,
>>> inverter_parameters=inverter_parameters,
>>> temperature_model_parameters=tparams)
>>> loc = location.Location(32.2, -110.9)
>>> modelchain.ModelChain.with_pvwatts(system, loc)
The following example is a modification of the example above but where
custom losses have been specified.
>>> pvwatts_losses = {'soiling': 2, 'shading': 3, 'snow': 0, 'mismatch': 2,
>>> 'wiring': 2, 'connections': 0.5, 'lid': 1.5,
>>> 'nameplate_rating': 1, 'age': 0, 'availability': 30}
>>> system_with_custom_losses = pvsystem.PVSystem(
>>> surface_tilt=30, surface_azimuth=180,
>>> module_parameters=module_parameters,
>>> inverter_parameters=inverter_parameters,
>>> temperature_model_parameters=tparams,
>>> losses_parameters=pvwatts_losses)
>>> modelchain.ModelChain.with_pvwatts(system_with_custom_losses, loc)
ModelChain:
name: None
clearsky_model: ineichen
transposition_model: perez
solar_position_method: nrel_numpy
airmass_model: kastenyoung1989
dc_model: pvwatts_dc
ac_model: pvwatts_inverter
aoi_model: physical_aoi_loss
spectral_model: no_spectral_loss
temperature_model: sapm_temp
losses_model: pvwatts_losses
""" # noqa: E501
config = PVWATTS_CONFIG.copy()
config.update(kwargs)
return ModelChain(
system, location,
clearsky_model=clearsky_model,
airmass_model=airmass_model,
name=name,
**config
)
@classmethod
def with_sapm(cls, system, location,
clearsky_model='ineichen',
transposition_model='haydavies',
solar_position_method='nrel_numpy',
airmass_model='kastenyoung1989',
name=None,
**kwargs):
"""
ModelChain that follows the Sandia Array Performance Model
(SAPM) methods.
Parameters
----------
system : PVSystem
A :py:class:`~pvlib.pvsystem.PVSystem` object that represents
the connected set of modules, inverters, etc.
location : Location
A :py:class:`~pvlib.location.Location` object that represents
the physical location at which to evaluate the model.
clearsky_model : str, default 'ineichen'
Passed to location.get_clearsky.
transposition_model : str, default 'haydavies'
Passed to system.get_irradiance.
solar_position_method : str, default 'nrel_numpy'
Passed to location.get_solarposition.
airmass_model : str, default 'kastenyoung1989'
Passed to location.get_airmass.
name : str, optional
Name of ModelChain instance.
**kwargs
Parameters supplied here are passed to the ModelChain
constructor and take precedence over the default
configuration.
Examples
--------
>>> mods = pvlib.pvsystem.retrieve_sam('sandiamod')
>>> invs = pvlib.pvsystem.retrieve_sam('cecinverter')
>>> module_parameters = mods['Canadian_Solar_CS5P_220M___2009_']
>>> inverter_parameters = invs['ABB__MICRO_0_25_I_OUTD_US_240__240V_']
>>> tparams = TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass']
>>> system = PVSystem(surface_tilt=30, surface_azimuth=180,
... module_parameters=module_parameters,
... inverter_parameters=inverter_parameters,
... temperature_model_parameters=tparams)
>>> location = Location(32.2, -110.9)
>>> ModelChain.with_sapm(system, location)
ModelChain:
name: None
clearsky_model: ineichen
transposition_model: haydavies
solar_position_method: nrel_numpy
airmass_model: kastenyoung1989
dc_model: sapm
ac_model: snlinverter
aoi_model: sapm_aoi_loss
spectral_model: sapm_spectral_loss
temperature_model: sapm_temp
losses_model: no_extra_losses
""" # noqa: E501
config = SAPM_CONFIG.copy()
config.update(kwargs)
return ModelChain(
system, location,
clearsky_model=clearsky_model,
transposition_model=transposition_model,
solar_position_method=solar_position_method,
airmass_model=airmass_model,
name=name,
**config
)
def __repr__(self):
attrs = [
'name', 'clearsky_model',
'transposition_model', 'solar_position_method',
'airmass_model', 'dc_model', 'ac_model', 'aoi_model',
'spectral_model', 'temperature_model', 'losses_model'
]
return ('ModelChain: \n ' + '\n '.join(
f'{attr}: {_getmcattr(self, attr)}' for attr in attrs))
@property
def dc_model(self):
return self._dc_model
@dc_model.setter
def dc_model(self, model):
# guess at model if None
if model is None:
self._dc_model, model = self.infer_dc_model()
# Set model and validate parameters
if isinstance(model, str):
model = model.lower()
if model in _DC_MODEL_PARAMS.keys():
# validate module parameters
module_parameters = tuple(
array.module_parameters for array in self.system.arrays)
missing_params = (
_DC_MODEL_PARAMS[model] - _common_keys(module_parameters))
if missing_params: # some parameters are not in module.keys()
raise ValueError(model + ' selected for the DC model but '
'one or more Arrays are missing '
'one or more required parameters '
' : ' + str(missing_params))
if model == 'sapm':
self._dc_model = self.sapm
elif model == 'desoto':
self._dc_model = self.desoto
elif model == 'cec':
self._dc_model = self.cec
elif model == 'pvsyst':
self._dc_model = self.pvsyst
elif model == 'pvwatts':
self._dc_model = self.pvwatts_dc
else:
raise ValueError(model + ' is not a valid DC power model')
else:
self._dc_model = partial(model, self)
def infer_dc_model(self):
"""Infer DC power model from Array module parameters."""
params = _common_keys(
tuple(array.module_parameters for array in self.system.arrays))
if {'A0', 'A1', 'C7'} <= params:
return self.sapm, 'sapm'
elif {'a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s',
'Adjust'} <= params:
return self.cec, 'cec'
elif {'a_ref', 'I_L_ref', 'I_o_ref', 'R_sh_ref', 'R_s'} <= params:
return self.desoto, 'desoto'
elif {'gamma_ref', 'mu_gamma', 'I_L_ref', 'I_o_ref', 'R_sh_ref',
'R_sh_0', 'R_sh_exp', 'R_s'} <= params:
return self.pvsyst, 'pvsyst'
elif {'pdc0', 'gamma_pdc'} <= params:
return self.pvwatts_dc, 'pvwatts'
else:
raise ValueError(
'Could not infer DC model from the module_parameters '
'attributes of system.arrays. Check the module_parameters '
'attributes or explicitly set the model with the dc_model '
'keyword argument.')
def sapm(self):
dc = self.system.sapm(self.results.effective_irradiance,
self.results.cell_temperature)
self.results.dc = self.system.scale_voltage_current_power(dc)
return self
def _singlediode(self, calcparams_model_function):
def _make_diode_params(photocurrent, saturation_current,
resistance_series, resistance_shunt,
nNsVth):
return pd.DataFrame(
{'I_L': photocurrent, 'I_o': saturation_current,
'R_s': resistance_series, 'R_sh': resistance_shunt,
'nNsVth': nNsVth}
)
params = calcparams_model_function(self.results.effective_irradiance,
self.results.cell_temperature,
unwrap=False)
self.results.diode_params = tuple(itertools.starmap(
_make_diode_params, params))
self.results.dc = tuple(itertools.starmap(
self.system.singlediode, params))
self.results.dc = self.system.scale_voltage_current_power(
self.results.dc,
unwrap=False
)
self.results.dc = tuple(dc.fillna(0) for dc in self.results.dc)
# If the system has one Array, unwrap the single return value
# to preserve the original behavior of ModelChain
if self.system.num_arrays == 1:
self.results.diode_params = self.results.diode_params[0]
self.results.dc = self.results.dc[0]
return self
def desoto(self):
return self._singlediode(self.system.calcparams_desoto)
def cec(self):
return self._singlediode(self.system.calcparams_cec)
def pvsyst(self):
return self._singlediode(self.system.calcparams_pvsyst)
def pvwatts_dc(self):
"""Calculate DC power using the PVWatts model.
Results are stored in ModelChain.results.dc. DC power is computed
from PVSystem.arrays[i].module_parameters['pdc0'] and then scaled by
PVSystem.modules_per_string and PVSystem.strings_per_inverter.
Returns
-------
self
See also
--------
pvlib.pvsystem.PVSystem.pvwatts_dc
pvlib.pvsystem.PVSystem.scale_voltage_current_power
"""
dc = self.system.pvwatts_dc(
self.results.effective_irradiance,
self.results.cell_temperature,
unwrap=False
)
p_mp = tuple(pd.DataFrame(s, columns=['p_mp']) for s in dc)
scaled = self.system.scale_voltage_current_power(p_mp)
self.results.dc = _tuple_from_dfs(scaled, "p_mp")
return self
@property
def ac_model(self):
return self._ac_model
@ac_model.setter
def ac_model(self, model):
if model is None:
self._ac_model = self.infer_ac_model()
elif isinstance(model, str):
model = model.lower()
if model == 'sandia':
self._ac_model = self.sandia_inverter
elif model in 'adr':
self._ac_model = self.adr_inverter
elif model == 'pvwatts':
self._ac_model = self.pvwatts_inverter
else:
raise ValueError(model + ' is not a valid AC power model')
else:
self._ac_model = partial(model, self)
def infer_ac_model(self):
"""Infer AC power model from system attributes."""
inverter_params = set(self.system.inverter_parameters.keys())
if _snl_params(inverter_params):
return self.sandia_inverter
if _adr_params(inverter_params):
if self.system.num_arrays > 1:
raise ValueError(
'The adr inverter function cannot be used for an inverter',
' with multiple MPPT inputs')
else:
return self.adr_inverter
if _pvwatts_params(inverter_params):
return self.pvwatts_inverter
raise ValueError('could not infer AC model from '
'system.inverter_parameters. Check '
'system.inverter_parameters or explicitly '
'set the model with the ac_model kwarg.')
def sandia_inverter(self):
self.results.ac = self.system.get_ac(
'sandia',
_tuple_from_dfs(self.results.dc, 'p_mp'),
v_dc=_tuple_from_dfs(self.results.dc, 'v_mp')
)
return self
def adr_inverter(self):
self.results.ac = self.system.get_ac(
'adr',
self.results.dc['p_mp'],
v_dc=self.results.dc['v_mp']
)
return self
def pvwatts_inverter(self):
ac = self.system.get_ac('pvwatts', self.results.dc)
self.results.ac = ac.fillna(0)
return self
@property
def aoi_model(self):
return self._aoi_model
@aoi_model.setter
def aoi_model(self, model):
if model is None:
self._aoi_model = self.infer_aoi_model()
elif isinstance(model, str):
model = model.lower()
if model == 'ashrae':
self._aoi_model = self.ashrae_aoi_loss
elif model == 'physical':
self._aoi_model = self.physical_aoi_loss
elif model == 'sapm':
self._aoi_model = self.sapm_aoi_loss
elif model == 'martin_ruiz':
self._aoi_model = self.martin_ruiz_aoi_loss
elif model == 'interp':
self._aoi_model = self.interp_aoi_loss
elif model == 'no_loss':
self._aoi_model = self.no_aoi_loss
else:
raise ValueError(model + ' is not a valid aoi loss model')
else:
self._aoi_model = partial(model, self)
def infer_aoi_model(self):
module_parameters = tuple(
array.module_parameters for array in self.system.arrays)
params = _common_keys(module_parameters)
if iam._IAM_MODEL_PARAMS['physical'] <= params:
return self.physical_aoi_loss
elif iam._IAM_MODEL_PARAMS['sapm'] <= params:
return self.sapm_aoi_loss
elif iam._IAM_MODEL_PARAMS['ashrae'] <= params:
return self.ashrae_aoi_loss
elif iam._IAM_MODEL_PARAMS['martin_ruiz'] <= params:
return self.martin_ruiz_aoi_loss
elif iam._IAM_MODEL_PARAMS['interp'] <= params:
return self.interp_aoi_loss
else:
raise ValueError('could not infer AOI model from '
'system.arrays[i].module_parameters. Check that '
'the module_parameters for all Arrays in '
'system.arrays contain parameters for the '
'physical, aoi, ashrae, martin_ruiz or interp '
'model; explicitly set the model with the '
'aoi_model kwarg; or set aoi_model="no_loss".')
def ashrae_aoi_loss(self):
self.results.aoi_modifier = self.system.get_iam(
self.results.aoi,
iam_model='ashrae'
)
return self
def physical_aoi_loss(self):
self.results.aoi_modifier = self.system.get_iam(
self.results.aoi,
iam_model='physical'
)
return self
def sapm_aoi_loss(self):
self.results.aoi_modifier = self.system.get_iam(
self.results.aoi,
iam_model='sapm'
)
return self
def martin_ruiz_aoi_loss(self):
self.results.aoi_modifier = self.system.get_iam(
self.results.aoi, iam_model='martin_ruiz'
)
return self