From ff486f1adc9ff27adf926ad779f59798f75e9a9c Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Wed, 24 Jul 2024 11:50:10 -0600 Subject: [PATCH 1/5] add units to docstrings --- pvdeg/degradation.py | 1 - pvdeg/spectral.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/pvdeg/degradation.py b/pvdeg/degradation.py index 2660f239..a07b8892 100644 --- a/pvdeg/degradation.py +++ b/pvdeg/degradation.py @@ -765,7 +765,6 @@ def vecArrhenius( poa_global_scaled = poa_global / 1000 degredation = 0 - # refactor to list comprehension approach for entry in range(len(poa_global_scaled)): degredation += ( R0 diff --git a/pvdeg/spectral.py b/pvdeg/spectral.py index 53b73ea1..81792003 100644 --- a/pvdeg/spectral.py +++ b/pvdeg/spectral.py @@ -68,7 +68,7 @@ def poa_irradiance( ------- poa : pandas.DataFrame Contains keys/columns 'poa_global', 'poa_direct', 'poa_diffuse', - 'poa_sky_diffuse', 'poa_ground_diffuse'. + 'poa_sky_diffuse', 'poa_ground_diffuse'. [W/m2] """ # TODO: change for handling HSAT tracking passed or requested From fb7b9846c080e0ed402b326da71ca9c223c1bcdd Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Fri, 26 Jul 2024 15:22:43 -0600 Subject: [PATCH 2/5] Enhancement: symbolic solver single site --- .../source/_autosummary/pvdeg.degradation.rst | 8 + .../pvdeg.degradation.vecArrhenius.rst | 6 + docs/source/_autosummary/pvdeg.humidity.rst | 8 - ...g.montecarlo.generateCorrelatedSamples.rst | 6 + docs/source/_autosummary/pvdeg.montecarlo.rst | 74 ++++ .../pvdeg.montecarlo.simulate.rst | 6 + .../pvdeg.standards.T98_estimate.rst | 6 + .../pvdeg.standards.eff_gap_parameters.rst | 6 + .../pvdeg.standards.interpret_standoff.rst | 6 + docs/source/_autosummary/pvdeg.standards.rst | 40 +- .../_autosummary/pvdeg.standards.standoff.rst | 6 + .../pvdeg.standards.standoff_x.rst | 6 + .../pvdeg.symbolic.calc_df_symbolic.rst | 6 + .../pvdeg.symbolic.calc_kwarg_floats.rst | 6 + .../pvdeg.symbolic.calc_kwarg_timeseries.rst | 6 + docs/source/_autosummary/pvdeg.symbolic.rst | 69 ++++ .../pvdeg.utilities.meta_as_dict.rst | 6 + docs/source/_autosummary/pvdeg.utilities.rst | 16 + .../pvdeg.utilities.tilt_azimuth_scan.rst | 6 + .../_autosummary/pvdeg.weather.csv_read.rst | 6 + .../pvdeg.weather.get_satellite.rst | 6 + .../pvdeg.weather.ini_h5_geospatial.rst | 6 + .../pvdeg.weather.is_leap_year.rst | 6 + .../_autosummary/pvdeg.weather.map_meta.rst | 6 + .../pvdeg.weather.map_weather.rst | 6 + ...vdeg.weather.repeat_annual_time_series.rst | 6 + docs/source/_autosummary/pvdeg.weather.rst | 64 +++ .../_autosummary/pvdeg.weather.write.rst | 6 + docs/source/api.rst | 1 + docs/source/whatsnew/index.rst | 1 + docs/source/whatsnew/releases/v0.4.0.rst | 16 + pvdeg/__init__.py | 1 + pvdeg/symbolic.py | 121 ++++++ .../Custom-Functions-Nopython.ipynb | 364 ++++++++++++++++++ 34 files changed, 893 insertions(+), 16 deletions(-) create mode 100644 docs/source/_autosummary/pvdeg.degradation.vecArrhenius.rst create mode 100644 docs/source/_autosummary/pvdeg.montecarlo.generateCorrelatedSamples.rst create mode 100644 docs/source/_autosummary/pvdeg.montecarlo.rst create mode 100644 docs/source/_autosummary/pvdeg.montecarlo.simulate.rst create mode 100644 docs/source/_autosummary/pvdeg.standards.T98_estimate.rst create mode 100644 docs/source/_autosummary/pvdeg.standards.eff_gap_parameters.rst create mode 100644 docs/source/_autosummary/pvdeg.standards.interpret_standoff.rst create mode 100644 docs/source/_autosummary/pvdeg.standards.standoff.rst create mode 100644 docs/source/_autosummary/pvdeg.standards.standoff_x.rst create mode 100644 docs/source/_autosummary/pvdeg.symbolic.calc_df_symbolic.rst create mode 100644 docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_floats.rst create mode 100644 docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_timeseries.rst create mode 100644 docs/source/_autosummary/pvdeg.symbolic.rst create mode 100644 docs/source/_autosummary/pvdeg.utilities.meta_as_dict.rst create mode 100644 docs/source/_autosummary/pvdeg.utilities.tilt_azimuth_scan.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.csv_read.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.get_satellite.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.ini_h5_geospatial.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.is_leap_year.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.map_meta.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.map_weather.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.repeat_annual_time_series.rst create mode 100644 docs/source/_autosummary/pvdeg.weather.write.rst create mode 100644 docs/source/whatsnew/releases/v0.4.0.rst create mode 100644 pvdeg/symbolic.py create mode 100644 tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb diff --git a/docs/source/_autosummary/pvdeg.degradation.rst b/docs/source/_autosummary/pvdeg.degradation.rst index 52645e74..9e2e6ca6 100644 --- a/docs/source/_autosummary/pvdeg.degradation.rst +++ b/docs/source/_autosummary/pvdeg.degradation.rst @@ -24,6 +24,7 @@ pvdeg.degradation pvdeg.degradation.arrhenius_deg pvdeg.degradation.degradation pvdeg.degradation.vantHoff_deg + pvdeg.degradation.vecArrhenius @@ -73,6 +74,13 @@ pvdeg.degradation .. minigallery:: pvdeg.degradation.vantHoff_deg :add-heading: + + .. autofunction:: vecArrhenius + + .. _sphx_glr_backref_pvdeg.degradation.vecArrhenius: + + .. minigallery:: pvdeg.degradation.vecArrhenius + :add-heading: diff --git a/docs/source/_autosummary/pvdeg.degradation.vecArrhenius.rst b/docs/source/_autosummary/pvdeg.degradation.vecArrhenius.rst new file mode 100644 index 00000000..774aae76 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.degradation.vecArrhenius.rst @@ -0,0 +1,6 @@ +pvdeg.degradation.vecArrhenius +============================== + +.. currentmodule:: pvdeg.degradation + +.. autofunction:: vecArrhenius \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.humidity.rst b/docs/source/_autosummary/pvdeg.humidity.rst index 5f4df11b..afa61db1 100644 --- a/docs/source/_autosummary/pvdeg.humidity.rst +++ b/docs/source/_autosummary/pvdeg.humidity.rst @@ -27,7 +27,6 @@ pvdeg.humidity pvdeg.humidity.front_encap pvdeg.humidity.module pvdeg.humidity.psat - pvdeg.humidity.run_module pvdeg.humidity.surface_outside @@ -100,13 +99,6 @@ pvdeg.humidity .. minigallery:: pvdeg.humidity.psat :add-heading: - .. autofunction:: run_module - - .. _sphx_glr_backref_pvdeg.humidity.run_module: - - .. minigallery:: pvdeg.humidity.run_module - :add-heading: - .. autofunction:: surface_outside .. _sphx_glr_backref_pvdeg.humidity.surface_outside: diff --git a/docs/source/_autosummary/pvdeg.montecarlo.generateCorrelatedSamples.rst b/docs/source/_autosummary/pvdeg.montecarlo.generateCorrelatedSamples.rst new file mode 100644 index 00000000..b9974f36 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.montecarlo.generateCorrelatedSamples.rst @@ -0,0 +1,6 @@ +pvdeg.montecarlo.generateCorrelatedSamples +========================================== + +.. currentmodule:: pvdeg.montecarlo + +.. autofunction:: generateCorrelatedSamples \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.montecarlo.rst b/docs/source/_autosummary/pvdeg.montecarlo.rst new file mode 100644 index 00000000..02f76416 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.montecarlo.rst @@ -0,0 +1,74 @@ +.. Please when editing this file make sure to keep it matching the + docs in ../configuration.rst:reference_to_examples + +pvdeg.montecarlo +================ + +.. automodule:: pvdeg.montecarlo + + .. this is crazy + + + + + Function Overview + ----------------- + + .. autosummary:: + :toctree: + :nosignatures: + + + pvdeg.montecarlo.generateCorrelatedSamples + pvdeg.montecarlo.simulate + + + + + .. this is crazy + + + + +.. + Functions + --------- + + + + .. autofunction:: generateCorrelatedSamples + + .. _sphx_glr_backref_pvdeg.montecarlo.generateCorrelatedSamples: + + .. minigallery:: pvdeg.montecarlo.generateCorrelatedSamples + :add-heading: + + .. autofunction:: simulate + + .. _sphx_glr_backref_pvdeg.montecarlo.simulate: + + .. minigallery:: pvdeg.montecarlo.simulate + :add-heading: + + + + + + + Classes + ------- + + + .. autoclass:: Corr + :members: + + .. _sphx_glr_backref_pvdeg.montecarlo.Corr: + + .. minigallery:: pvdeg.montecarlo.Corr + :add-heading: + + + + + + \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.montecarlo.simulate.rst b/docs/source/_autosummary/pvdeg.montecarlo.simulate.rst new file mode 100644 index 00000000..c0c00be8 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.montecarlo.simulate.rst @@ -0,0 +1,6 @@ +pvdeg.montecarlo.simulate +========================= + +.. currentmodule:: pvdeg.montecarlo + +.. autofunction:: simulate \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.standards.T98_estimate.rst b/docs/source/_autosummary/pvdeg.standards.T98_estimate.rst new file mode 100644 index 00000000..da5ad848 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.standards.T98_estimate.rst @@ -0,0 +1,6 @@ +pvdeg.standards.T98\_estimate +============================= + +.. currentmodule:: pvdeg.standards + +.. autofunction:: T98_estimate \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.standards.eff_gap_parameters.rst b/docs/source/_autosummary/pvdeg.standards.eff_gap_parameters.rst new file mode 100644 index 00000000..223d771f --- /dev/null +++ b/docs/source/_autosummary/pvdeg.standards.eff_gap_parameters.rst @@ -0,0 +1,6 @@ +pvdeg.standards.eff\_gap\_parameters +==================================== + +.. currentmodule:: pvdeg.standards + +.. autofunction:: eff_gap_parameters \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.standards.interpret_standoff.rst b/docs/source/_autosummary/pvdeg.standards.interpret_standoff.rst new file mode 100644 index 00000000..3843af5d --- /dev/null +++ b/docs/source/_autosummary/pvdeg.standards.interpret_standoff.rst @@ -0,0 +1,6 @@ +pvdeg.standards.interpret\_standoff +=================================== + +.. currentmodule:: pvdeg.standards + +.. autofunction:: interpret_standoff \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.standards.rst b/docs/source/_autosummary/pvdeg.standards.rst index cc597976..0aa89205 100644 --- a/docs/source/_autosummary/pvdeg.standards.rst +++ b/docs/source/_autosummary/pvdeg.standards.rst @@ -19,9 +19,12 @@ pvdeg.standards :nosignatures: - pvdeg.standards.calc_standoff + pvdeg.standards.T98_estimate pvdeg.standards.eff_gap - pvdeg.standards.run_calc_standoff + pvdeg.standards.eff_gap_parameters + pvdeg.standards.interpret_standoff + pvdeg.standards.standoff + pvdeg.standards.standoff_x @@ -37,11 +40,11 @@ pvdeg.standards - .. autofunction:: calc_standoff + .. autofunction:: T98_estimate - .. _sphx_glr_backref_pvdeg.standards.calc_standoff: + .. _sphx_glr_backref_pvdeg.standards.T98_estimate: - .. minigallery:: pvdeg.standards.calc_standoff + .. minigallery:: pvdeg.standards.T98_estimate :add-heading: .. autofunction:: eff_gap @@ -51,11 +54,32 @@ pvdeg.standards .. minigallery:: pvdeg.standards.eff_gap :add-heading: - .. autofunction:: run_calc_standoff + .. autofunction:: eff_gap_parameters - .. _sphx_glr_backref_pvdeg.standards.run_calc_standoff: + .. _sphx_glr_backref_pvdeg.standards.eff_gap_parameters: - .. minigallery:: pvdeg.standards.run_calc_standoff + .. minigallery:: pvdeg.standards.eff_gap_parameters + :add-heading: + + .. autofunction:: interpret_standoff + + .. _sphx_glr_backref_pvdeg.standards.interpret_standoff: + + .. minigallery:: pvdeg.standards.interpret_standoff + :add-heading: + + .. autofunction:: standoff + + .. _sphx_glr_backref_pvdeg.standards.standoff: + + .. minigallery:: pvdeg.standards.standoff + :add-heading: + + .. autofunction:: standoff_x + + .. _sphx_glr_backref_pvdeg.standards.standoff_x: + + .. minigallery:: pvdeg.standards.standoff_x :add-heading: diff --git a/docs/source/_autosummary/pvdeg.standards.standoff.rst b/docs/source/_autosummary/pvdeg.standards.standoff.rst new file mode 100644 index 00000000..8ebc1eaa --- /dev/null +++ b/docs/source/_autosummary/pvdeg.standards.standoff.rst @@ -0,0 +1,6 @@ +pvdeg.standards.standoff +======================== + +.. currentmodule:: pvdeg.standards + +.. autofunction:: standoff \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.standards.standoff_x.rst b/docs/source/_autosummary/pvdeg.standards.standoff_x.rst new file mode 100644 index 00000000..2887f41d --- /dev/null +++ b/docs/source/_autosummary/pvdeg.standards.standoff_x.rst @@ -0,0 +1,6 @@ +pvdeg.standards.standoff\_x +=========================== + +.. currentmodule:: pvdeg.standards + +.. autofunction:: standoff_x \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.symbolic.calc_df_symbolic.rst b/docs/source/_autosummary/pvdeg.symbolic.calc_df_symbolic.rst new file mode 100644 index 00000000..fd63545a --- /dev/null +++ b/docs/source/_autosummary/pvdeg.symbolic.calc_df_symbolic.rst @@ -0,0 +1,6 @@ +pvdeg.symbolic.calc\_df\_symbolic +================================= + +.. currentmodule:: pvdeg.symbolic + +.. autofunction:: calc_df_symbolic \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_floats.rst b/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_floats.rst new file mode 100644 index 00000000..a917d27a --- /dev/null +++ b/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_floats.rst @@ -0,0 +1,6 @@ +pvdeg.symbolic.calc\_kwarg\_floats +================================== + +.. currentmodule:: pvdeg.symbolic + +.. autofunction:: calc_kwarg_floats \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_timeseries.rst b/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_timeseries.rst new file mode 100644 index 00000000..656fe855 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.symbolic.calc_kwarg_timeseries.rst @@ -0,0 +1,6 @@ +pvdeg.symbolic.calc\_kwarg\_timeseries +====================================== + +.. currentmodule:: pvdeg.symbolic + +.. autofunction:: calc_kwarg_timeseries \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.symbolic.rst b/docs/source/_autosummary/pvdeg.symbolic.rst new file mode 100644 index 00000000..4ef3523e --- /dev/null +++ b/docs/source/_autosummary/pvdeg.symbolic.rst @@ -0,0 +1,69 @@ +.. Please when editing this file make sure to keep it matching the + docs in ../configuration.rst:reference_to_examples + +pvdeg.symbolic +============== + +.. automodule:: pvdeg.symbolic + + .. this is crazy + + + + + Function Overview + ----------------- + + .. autosummary:: + :toctree: + :nosignatures: + + + pvdeg.symbolic.calc_df_symbolic + pvdeg.symbolic.calc_kwarg_floats + pvdeg.symbolic.calc_kwarg_timeseries + + + + + .. this is crazy + + + + +.. + Functions + --------- + + + + .. autofunction:: calc_df_symbolic + + .. _sphx_glr_backref_pvdeg.symbolic.calc_df_symbolic: + + .. minigallery:: pvdeg.symbolic.calc_df_symbolic + :add-heading: + + .. autofunction:: calc_kwarg_floats + + .. _sphx_glr_backref_pvdeg.symbolic.calc_kwarg_floats: + + .. minigallery:: pvdeg.symbolic.calc_kwarg_floats + :add-heading: + + .. autofunction:: calc_kwarg_timeseries + + .. _sphx_glr_backref_pvdeg.symbolic.calc_kwarg_timeseries: + + .. minigallery:: pvdeg.symbolic.calc_kwarg_timeseries + :add-heading: + + + + + + + + + + \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.utilities.meta_as_dict.rst b/docs/source/_autosummary/pvdeg.utilities.meta_as_dict.rst new file mode 100644 index 00000000..220be6ea --- /dev/null +++ b/docs/source/_autosummary/pvdeg.utilities.meta_as_dict.rst @@ -0,0 +1,6 @@ +pvdeg.utilities.meta\_as\_dict +============================== + +.. currentmodule:: pvdeg.utilities + +.. autofunction:: meta_as_dict \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.utilities.rst b/docs/source/_autosummary/pvdeg.utilities.rst index 16bd6fd9..8a4e3ae0 100644 --- a/docs/source/_autosummary/pvdeg.utilities.rst +++ b/docs/source/_autosummary/pvdeg.utilities.rst @@ -22,7 +22,9 @@ pvdeg.utilities pvdeg.utilities.convert_tmy pvdeg.utilities.get_kinetics pvdeg.utilities.gid_downsampling + pvdeg.utilities.meta_as_dict pvdeg.utilities.quantile_df + pvdeg.utilities.tilt_azimuth_scan pvdeg.utilities.ts_gid_df pvdeg.utilities.write_gids @@ -61,6 +63,13 @@ pvdeg.utilities .. minigallery:: pvdeg.utilities.gid_downsampling :add-heading: + .. autofunction:: meta_as_dict + + .. _sphx_glr_backref_pvdeg.utilities.meta_as_dict: + + .. minigallery:: pvdeg.utilities.meta_as_dict + :add-heading: + .. autofunction:: quantile_df .. _sphx_glr_backref_pvdeg.utilities.quantile_df: @@ -68,6 +77,13 @@ pvdeg.utilities .. minigallery:: pvdeg.utilities.quantile_df :add-heading: + .. autofunction:: tilt_azimuth_scan + + .. _sphx_glr_backref_pvdeg.utilities.tilt_azimuth_scan: + + .. minigallery:: pvdeg.utilities.tilt_azimuth_scan + :add-heading: + .. autofunction:: ts_gid_df .. _sphx_glr_backref_pvdeg.utilities.ts_gid_df: diff --git a/docs/source/_autosummary/pvdeg.utilities.tilt_azimuth_scan.rst b/docs/source/_autosummary/pvdeg.utilities.tilt_azimuth_scan.rst new file mode 100644 index 00000000..5ffcf7fe --- /dev/null +++ b/docs/source/_autosummary/pvdeg.utilities.tilt_azimuth_scan.rst @@ -0,0 +1,6 @@ +pvdeg.utilities.tilt\_azimuth\_scan +=================================== + +.. currentmodule:: pvdeg.utilities + +.. autofunction:: tilt_azimuth_scan \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.csv_read.rst b/docs/source/_autosummary/pvdeg.weather.csv_read.rst new file mode 100644 index 00000000..d0c3e75d --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.csv_read.rst @@ -0,0 +1,6 @@ +pvdeg.weather.csv\_read +======================= + +.. currentmodule:: pvdeg.weather + +.. autofunction:: csv_read \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.get_satellite.rst b/docs/source/_autosummary/pvdeg.weather.get_satellite.rst new file mode 100644 index 00000000..ba435393 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.get_satellite.rst @@ -0,0 +1,6 @@ +pvdeg.weather.get\_satellite +============================ + +.. currentmodule:: pvdeg.weather + +.. autofunction:: get_satellite \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.ini_h5_geospatial.rst b/docs/source/_autosummary/pvdeg.weather.ini_h5_geospatial.rst new file mode 100644 index 00000000..efa847c3 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.ini_h5_geospatial.rst @@ -0,0 +1,6 @@ +pvdeg.weather.ini\_h5\_geospatial +================================= + +.. currentmodule:: pvdeg.weather + +.. autofunction:: ini_h5_geospatial \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.is_leap_year.rst b/docs/source/_autosummary/pvdeg.weather.is_leap_year.rst new file mode 100644 index 00000000..bd16d550 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.is_leap_year.rst @@ -0,0 +1,6 @@ +pvdeg.weather.is\_leap\_year +============================ + +.. currentmodule:: pvdeg.weather + +.. autofunction:: is_leap_year \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.map_meta.rst b/docs/source/_autosummary/pvdeg.weather.map_meta.rst new file mode 100644 index 00000000..d2348897 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.map_meta.rst @@ -0,0 +1,6 @@ +pvdeg.weather.map\_meta +======================= + +.. currentmodule:: pvdeg.weather + +.. autofunction:: map_meta \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.map_weather.rst b/docs/source/_autosummary/pvdeg.weather.map_weather.rst new file mode 100644 index 00000000..c0933f41 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.map_weather.rst @@ -0,0 +1,6 @@ +pvdeg.weather.map\_weather +========================== + +.. currentmodule:: pvdeg.weather + +.. autofunction:: map_weather \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.repeat_annual_time_series.rst b/docs/source/_autosummary/pvdeg.weather.repeat_annual_time_series.rst new file mode 100644 index 00000000..eed2f443 --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.repeat_annual_time_series.rst @@ -0,0 +1,6 @@ +pvdeg.weather.repeat\_annual\_time\_series +========================================== + +.. currentmodule:: pvdeg.weather + +.. autofunction:: repeat_annual_time_series \ No newline at end of file diff --git a/docs/source/_autosummary/pvdeg.weather.rst b/docs/source/_autosummary/pvdeg.weather.rst index a97538ac..72a35669 100644 --- a/docs/source/_autosummary/pvdeg.weather.rst +++ b/docs/source/_autosummary/pvdeg.weather.rst @@ -19,11 +19,19 @@ pvdeg.weather :nosignatures: + pvdeg.weather.csv_read pvdeg.weather.get pvdeg.weather.get_NSRDB pvdeg.weather.get_NSRDB_fnames + pvdeg.weather.get_satellite + pvdeg.weather.ini_h5_geospatial + pvdeg.weather.is_leap_year + pvdeg.weather.map_meta + pvdeg.weather.map_weather pvdeg.weather.read pvdeg.weather.read_h5 + pvdeg.weather.repeat_annual_time_series + pvdeg.weather.write @@ -39,6 +47,13 @@ pvdeg.weather + .. autofunction:: csv_read + + .. _sphx_glr_backref_pvdeg.weather.csv_read: + + .. minigallery:: pvdeg.weather.csv_read + :add-heading: + .. autofunction:: get .. _sphx_glr_backref_pvdeg.weather.get: @@ -60,6 +75,41 @@ pvdeg.weather .. minigallery:: pvdeg.weather.get_NSRDB_fnames :add-heading: + .. autofunction:: get_satellite + + .. _sphx_glr_backref_pvdeg.weather.get_satellite: + + .. minigallery:: pvdeg.weather.get_satellite + :add-heading: + + .. autofunction:: ini_h5_geospatial + + .. _sphx_glr_backref_pvdeg.weather.ini_h5_geospatial: + + .. minigallery:: pvdeg.weather.ini_h5_geospatial + :add-heading: + + .. autofunction:: is_leap_year + + .. _sphx_glr_backref_pvdeg.weather.is_leap_year: + + .. minigallery:: pvdeg.weather.is_leap_year + :add-heading: + + .. autofunction:: map_meta + + .. _sphx_glr_backref_pvdeg.weather.map_meta: + + .. minigallery:: pvdeg.weather.map_meta + :add-heading: + + .. autofunction:: map_weather + + .. _sphx_glr_backref_pvdeg.weather.map_weather: + + .. minigallery:: pvdeg.weather.map_weather + :add-heading: + .. autofunction:: read .. _sphx_glr_backref_pvdeg.weather.read: @@ -73,6 +123,20 @@ pvdeg.weather .. minigallery:: pvdeg.weather.read_h5 :add-heading: + + .. autofunction:: repeat_annual_time_series + + .. _sphx_glr_backref_pvdeg.weather.repeat_annual_time_series: + + .. minigallery:: pvdeg.weather.repeat_annual_time_series + :add-heading: + + .. autofunction:: write + + .. _sphx_glr_backref_pvdeg.weather.write: + + .. minigallery:: pvdeg.weather.write + :add-heading: diff --git a/docs/source/_autosummary/pvdeg.weather.write.rst b/docs/source/_autosummary/pvdeg.weather.write.rst new file mode 100644 index 00000000..2a15be8b --- /dev/null +++ b/docs/source/_autosummary/pvdeg.weather.write.rst @@ -0,0 +1,6 @@ +pvdeg.weather.write +=================== + +.. currentmodule:: pvdeg.weather + +.. autofunction:: write \ No newline at end of file diff --git a/docs/source/api.rst b/docs/source/api.rst index c59c6b08..6cc1234c 100644 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -27,3 +27,4 @@ Modules, methods, classes and attributes are explained here. temperature utilities weather + symbolic diff --git a/docs/source/whatsnew/index.rst b/docs/source/whatsnew/index.rst index 70fac61f..ac3d1cf8 100644 --- a/docs/source/whatsnew/index.rst +++ b/docs/source/whatsnew/index.rst @@ -4,6 +4,7 @@ What's New ========== PVDegradationTools (pvdeg) change log: +.. include:: releases/v0.4.0.rst .. include:: releases/v0.3.3.rst .. include:: releases/v0.3.2.rst .. include:: releases/v0.3.1.rst diff --git a/docs/source/whatsnew/releases/v0.4.0.rst b/docs/source/whatsnew/releases/v0.4.0.rst new file mode 100644 index 00000000..90b82ecd --- /dev/null +++ b/docs/source/whatsnew/releases/v0.4.0.rst @@ -0,0 +1,16 @@ +v0.4.0 (7-26-2024) +======================= + +Enhancements +------------ +* symbolic equation solver for simple models. +* notebook tutorial `Custom-Functions-Nopython.ipynb` + +Requirements +------------ +* `sympy` package required for `pvdeg.symbolic` functions and notebook. Not added to dependency list. + +Contributors +~~~~~~~~~~~~ +* Tobin Ford (:ghuser:`tobin-ford`) + diff --git a/pvdeg/__init__.py b/pvdeg/__init__.py index 301c9abb..90d6579c 100644 --- a/pvdeg/__init__.py +++ b/pvdeg/__init__.py @@ -18,6 +18,7 @@ from . import temperature from . import utilities from . import weather +from . import symbolic __version__ = version("pvdeg") diff --git a/pvdeg/symbolic.py b/pvdeg/symbolic.py new file mode 100644 index 00000000..c71a3705 --- /dev/null +++ b/pvdeg/symbolic.py @@ -0,0 +1,121 @@ +""" +Collections of functions to enable arbitrary symbolic expression evaluation for simple models +""" + +import sympy as sp +import pandas as pd +import numpy as np + +# from latex2sympy2 import latex2sympy # this potentially useful but if someone has to use this then they proboably wont be able to figure out the rest +# parse: latex -> sympy using latex2sympy2 if nessesscary + + +def calc_kwarg_floats( + expr: sp.core.mul.Mul, + kwarg: dict, +) -> float: + """ + Calculate a symbolic sympy expression using a dictionary of values + + Parameters: + ---------- + expr: sp.core.mul.Mul + symbolic sympy expression to calculate values on. + kwarg: dict + dictionary of kwarg values for the function, keys must match + sympy symbols. + + Returns: + -------- + res: float + calculated value from symbolic equation + """ + res = expr.subs(kwarg).evalf() + return res + + +def calc_df_symbolic( + expr: sp.core.mul.Mul, + df: pd.DataFrame, +) -> pd.Series: + """ + Calculate the expression over the entire dataframe. + + Parameters: + ---------- + expr: sp.core.mul.Mul + symbolic sympy expression to calculate values on. + df: pd.DataFrame + pandas dataframe containing column names matching the sympy symbols. + """ + variables = set(map(str, list(expr.free_symbols))) + if not variables.issubset(df.columns.values): + raise ValueError(f""" + all expression variables need to be in dataframe cols + expr symbols : {expr.free_symbols}") + dataframe cols : {df.columns.values} + """) + + res = df.apply(lambda row: calc_kwarg_floats(expr, row.to_dict()), axis=1) + return res + + +def _have_same_indices(series_list): + if not series_list: + return True + + first_index = series_list[0].index + + same_indicies = all(s.index.equals(first_index) for s in series_list[1:]) + all_series = all(isinstance(value, pd.Series) for value in series_list) + + return same_indicies and all_series + + +def _have_same_length(series_list): + if not series_list: + return True + + first_length = series_list[0].shape[0] + return all(s.shape[0] == first_length for s in series_list[1:]) + + +def calc_kwarg_timeseries( + expr, + kwarg, +): + # check for equal length among timeseries. no nesting loops allowed, no functions can be dependent on their previous results values + numerics, timeseries, series_length = {}, {}, 0 + for key, val in kwarg.items(): + if isinstance(val, (pd.Series, np.ndarray)): + timeseries[key] = val + series_length = len(val) + elif isinstance(val, (int, float)): + numerics[key] = val + else: + raise ValueError(f"only simple numerics or timeseries allowed") + + if not _have_same_length(list(timeseries.values())): + raise NotImplementedError( + f"arrays/series are different lengths. fix mismatched length. otherwise arbitrary symbolic solution is too complex for solver. nested loops or loops dependent on previous results not supported." + ) + + # calculate the expression. we will seperately calculate all values and store then in a timeseries of the same shape. if a user wants to sum the values then they can + if _have_same_indices(list(timeseries.values())): + index = list(timeseries.values())[0].index + else: + index = pd.RangeIndex(start=0, stop=series_length) + res = pd.Series(index=index, dtype=float) + + for i in range(series_length): + # calculate at each point and save value + iter_dict = { + key: value.values[i] for key, value in timeseries.items() + } # pandas indexing will break like this in future versions, we could only + + iter_dict = {**numerics, **iter_dict} + + # we are still getting timeseries at this point + res.iloc[i] = float(expr.subs(iter_dict).evalf()) + + return res diff --git a/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb b/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb new file mode 100644 index 00000000..89568d63 --- /dev/null +++ b/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import sympy as sp\n", + "import matplotlib.pyplot as plt\n", + "import pvdeg\n", + "import pvdeg.symbolic\n", + "from latex2sympy2 import latex2sympy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grabbing Weather Data from PVGIS\n", + "\n", + "Use pvdeg to make an API call to PVGIS to collect location and weather data for Manhattan, NYC." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "weather_df, meta_dict = pvdeg.weather.get(\n", + " database='PVGIS',\n", + " id=(40.776676, -73.971321), # manhattan (latitude, longitude)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculating Temperature and Irradiance\n", + "\n", + "Use pvdeg to calculate timeseries temperature for a theoretical module from the previous metorological data.\n", + "\n", + "*Update this call after scenario has been merged: dev_scenario_geospatial->development->dev_symbolic*" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", + "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 40.8 was used.\n", + "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "module_temps = pvdeg.temperature.module(\n", + " weather_df=weather_df,\n", + " meta=meta_dict,\n", + " conf=\"open_rack_glass_glass\"\n", + ")\n", + "\n", + "poa_irradiance = pvdeg.spectral.poa_irradiance(\n", + " weather_df=weather_df, \n", + " meta=meta_dict\n", + " )\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(module_temps.values) # plotting the values in order because we are using tmy data so the years are not consistent within our data\n", + "plt.title(\"TMY Module Temperature, Manhattan\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(poa_irradiance.values)\n", + "plt.legend(poa_irradiance.columns)\n", + "plt.title(\"TML Module Irradiance, Manhattan\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Custom Expressions from Latex or \n", + "\n", + "We will use an altered arrhenius equation with an irrandiance relation (ignore the fact that this exists in pvdeg already).\n", + "\n", + "$R_{D} = R_{0}I^{X} e^{\\frac{-{Ea}}{kT}}$ *ea is one variable so this may present some issues* \n", + "the raw latex looks like this `R_{0}I^{X} e^{\\frac{-{Ea}}{kT}}`" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle I^{X} lnR_{0} e^{- \\frac{Ea}{T k}}$" + ], + "text/plain": [ + "I**X*lnR_0*exp(-Ea/(T*k))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "lnR_0, I, X, Ea, k, T = sp.symbols('lnR_0 I X Ea k T')\n", + "\n", + "ln_R_D_expr = lnR_0 * I**X * sp.exp( (-Ea)/(k * T) ) # python exponentiation is ** rather than ^\n", + "\n", + "# viewing output \n", + "ln_R_D_expr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculating Degradation Expression\n", + "\n", + "Generally more processing will have to happen outside of these functions than built in pvdeg functions. \n", + "Here we are defining our arguments and correcting units. When trying to calculate using timeseries we will pass `pandas.Series` objects to the arguments.\n", + "\n", + "Results should be strictly scrutinized to make sure the calculation is iterating over your series correctly. It will generally be easier to write python code\n", + "for more complex functions. This is about as complex as we will be able to get using arbitrary symbolic expressions if looping over timeseries data is required." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "module_temps_k = module_temps + 273.15 # convert C -> K\n", + "\n", + "poa_global = poa_irradiance['poa_global'] # take only the global irradiance series from the total irradiance dataframe\n", + "poa_global_kw = poa_global / 1000 # [W/m^2] -> [kW/m^2]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### This is quite slow" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "values_kwarg = {\n", + " 'Ea': 62.08, # activation energy, [kJ/mol]\n", + " 'k': 8.31446e-3, # boltzmans constant, [kJ/(mol * K)]\n", + " 'T': module_temps_k, # module temperature, [K]\n", + " 'I': poa_global_kw, # module plane of array irradiance, [W/m2]\n", + " 'X': 0.0341, # irradiance relation, [unitless] \n", + " 'lnR_0': 13.72, # prefactor degradation [ln(%/h)]\n", + "}\n", + "\n", + "res = pvdeg.symbolic.calc_kwarg_timeseries(\n", + " expr=ln_R_D_expr,\n", + " kwarg=values_kwarg\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Total degradation\n", + "\n", + "To calculate accumulated degradation, we can sum each of the substep values and convert to log scale (need to do this because prefactor was in log scale)." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-5.890059776856161" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.log10(res.sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "leakage current\n", + "$I_{leak} = \\frac{V_{bias}}{R_{enc}}$\n", + "\n", + "$I_{leak}$, leakage current \n", + "${V_{bias}}$, potential difference between cells and frame \n", + "${R_{enc}}$, resistance of the encapsulant \n", + "\n", + "electric field\n", + "$E = \\frac{V_{bias}}{d}$ \n", + "\n", + "$E$, electric field \n", + "$d$, thickness of encapsulant \n", + "\n", + "degradation rage\n", + "$D = k_{D} * E * I{leak}$ \n", + "\n", + "$D$, degradation rate \n", + "$k_D$, degradation constant " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pvdeg.symbolic\n", + "\n", + "rate_of_deg_expression = pvdeg.symbolic.symbolic_from_latex(latex=r\"R_{0} * I^{X} * e^{\\frac{-{ea}}{k T}}\") # ea is breaking this " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pvdeg.symbolic\n", + "\n", + "tex_I_leak = r\"\\frac{V_{bias}}{R_{enc}}\"\n", + "tex_E = r\"\\frac{V_{bias}}{d}\"\n", + "tex_D = r\"k_D \\cdot \\frac{V_{bias}}{d} \\cdot \\frac{V_{bias}}{R_{enc}}\"\n", + "\n", + "# mapping of values\n", + "values = {\n", + " 'V_{bias}': 1000,\n", + " 'R_{enc}': 1e9,\n", + " 'd': 0.0005,\n", + " 'k_D': 1e-9,\n", + " 'alpha': 0.01,\n", + " 'beta': 0.02,\n", + " 't': 10,\n", + " 'P_0': 100,\n", + " 'R_0': 0.1\n", + "}\n", + "\n", + "I_leak_expr = pvdeg.symbolic.symbolic_from_latex(tex_I_leak)\n", + "E_expr = pvdeg.symbolic.symbolic_from_latex(tex_E)\n", + "D_expr = pvdeg.symbolic.symbolic_from_latex(tex_D)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pvdeg.symbolic.calc_kwarg_floats(\n", + " expr=D_expr,\n", + " kwarg=values\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_df = pd.DataFrame([values] * 26)\n", + "values_df['V_{bias}'] = np.linspace(100,2000,26)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "values_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate Values in a Dataframe using a symbolic expression\n", + "\n", + "After creating the symbolic expression in using latex with `pvdeg.symbolic.symbolic_from_latex`, feed it to the function to calculate the leakage current at each row in the dataframe.\n", + "This expression calculation only accesses one dataframe row at a time so we cannot do any summations or windowed timeseries averiging within the call. At this point, write your own python function. If you create functions that would be useful, please email us your source code or create an issue and copy and paste your code there. If it is relevant it may be added to the package (credit will be given)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pvdeg.symbolic.calc_df_symbolic(\n", + " expr=I_leak_expr,\n", + " df=values_df\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fem_diff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1fa555d3dc8e7429fb49c6b2e4cc577483fd4c94 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 1 Aug 2024 13:33:31 -0600 Subject: [PATCH 3/5] symbolic testing --- pyproject.toml | 1 + tests/sandbox.ipynb | 140 +++++++++++++++++- tests/test_symbolic.py | 94 ++++++++++++ .../Custom-Functions-Nopython.ipynb | 95 +++++------- 4 files changed, 271 insertions(+), 59 deletions(-) create mode 100644 tests/test_symbolic.py diff --git a/pyproject.toml b/pyproject.toml index a66326f3..60a3d864 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -70,6 +70,7 @@ docs = [ test = [ "pytest", "pytest-cov", + "sympy", ] books = [ "jupyter-book", diff --git a/tests/sandbox.ipynb b/tests/sandbox.ipynb index 02b7283a..00c725e3 100644 --- a/tests/sandbox.ipynb +++ b/tests/sandbox.ipynb @@ -70,6 +70,144 @@ "source": [ "test_psat()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Symbolic Tests" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import pandas as pd\n", + "import sympy as sp\n", + "import pvdeg\n", + "from pvdeg import TEST_DATA_DIR" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "WEATHER = pd.read_csv(\n", + " os.path.join(TEST_DATA_DIR, r\"weather_day_pytest.csv\"),\n", + " index_col=0,\n", + " parse_dates=True\n", + ")\n", + "\n", + "with open(os.path.join(TEST_DATA_DIR, \"meta.json\"), \"r\") as file:\n", + " META = json.load(file)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n", + "The array tilt angle was not provided, therefore the latitude tilt of 39.7 was used.\n", + "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n" + ] + } + ], + "source": [ + "lnR_0, I, X, Ea, k, T = sp.symbols('lnR_0 I X Ea k T')\n", + "\n", + "ln_R_D_expr = lnR_0 * I**X * sp.exp( (-Ea)/(k * T) )\n", + "\n", + "module_temps = pvdeg.temperature.module(\n", + " weather_df=WEATHER,\n", + " meta=META,\n", + " conf=\"open_rack_glass_glass\"\n", + ")\n", + "\n", + "poa_irradiance = pvdeg.spectral.poa_irradiance(\n", + " weather_df=WEATHER, \n", + " meta=META\n", + " )\n", + "\n", + "module_temps_k = module_temps + 273.15 # convert C -> K\n", + "\n", + "poa_global = poa_irradiance['poa_global'] # take only the global irradiance series from the total irradiance dataframe\n", + "poa_global_kw = poa_global / 1000 # [W/m^2] -> [kW/m^2]\n", + "\n", + "values_kwarg = {\n", + " 'Ea': 62.08, # activation energy, [kJ/mol]\n", + " 'k': 8.31446e-3, # boltzmans constant, [kJ/(mol * K)]\n", + " 'T': module_temps_k, # module temperature, [K]\n", + " 'I': poa_global_kw, # module plane of array irradiance, [W/m2]\n", + " 'X': 0.0341, # irradiance relation, [unitless] \n", + " 'lnR_0': 13.72, # prefactor degradation [ln(%/h)]\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.561658688478015e-09" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res = pvdeg.symbolic.calc_kwarg_timeseries(\n", + " expr=ln_R_D_expr,\n", + " kwarg=values_kwarg\n", + ").sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pytest\n", + "\n", + "res == pytest.approx(6.5617e-09)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "5 " + ] } ], "metadata": { @@ -88,7 +226,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.16" + "version": "3.10.14" }, "orig_nbformat": 4 }, diff --git a/tests/test_symbolic.py b/tests/test_symbolic.py new file mode 100644 index 00000000..e5b900d9 --- /dev/null +++ b/tests/test_symbolic.py @@ -0,0 +1,94 @@ +import pytest +import os +import json +import pandas as pd +import sympy as sp # not a dependency, may cause issues +import pvdeg +from pvdeg import TEST_DATA_DIR + +WEATHER = pd.read_csv( + os.path.join(TEST_DATA_DIR, r"weather_day_pytest.csv"), + index_col=0, + parse_dates=True +) + +with open(os.path.join(TEST_DATA_DIR, "meta.json"), "r") as file: + META = json.load(file) + + +# D = k_d * E * Ileak +# degradation rate, D +# degradation constant, k_d + +# electric field, E = Vbias / d +# Vbias, potential diference between cells and frame +# d, encapsulant thickness + +# leakage current, Ileak = Vbias / Rencap +# Vbias, potential diference between cells and frame +# Rencap, resistance of encapsulant + +k_d, Vbias, Rencap, d = sp.symbols('k_d Vbias Rencap d') +pid = k_d * (Vbias / d) * (Vbias / Rencap) + +pid_kwarg = { + 'Vbias' : 1000, + 'Rencap' : 1e9, + 'd': 0.0005, + 'k_d': 1e-9, +} + +def test_symbolic_floats(): + res = pvdeg.symbolic.calc_kwarg_floats( + expr=pid, + kwarg=pid_kwarg + ) + + assert res == pytest.approx(2e-9) + +def test_symbolic_df(): + pid_df = pd.DataFrame([pid_kwarg] * 5) + + res_series = pvdeg.symbolic.calc_df_symbolic( + expr=pid, + df=pid_df + ) + + pid_values = pd.Series([2e-9]*5) + + pd.testing.assert_series_equal(res_series, pid_values, check_dtype=False) + + +def test_symbolic_timeseries(): + lnR_0, I, X, Ea, k, T = sp.symbols('lnR_0 I X Ea k T') + ln_R_D_expr = lnR_0 * I**X * sp.exp( (-Ea)/(k * T) ) + + module_temps = pvdeg.temperature.module( + weather_df=WEATHER, + meta=META, + conf="open_rack_glass_glass" + ) + poa_irradiance = pvdeg.spectral.poa_irradiance( + weather_df=WEATHER, + meta=META + ) + + module_temps_k = module_temps + 273.15 # convert C -> K + poa_global = poa_irradiance['poa_global'] # take only the global irradiance series from the total irradiance dataframe + poa_global_kw = poa_global / 1000 # [W/m^2] -> [kW/m^2] + + values_kwarg = { + 'Ea': 62.08, # activation energy, [kJ/mol] + 'k': 8.31446e-3, # boltzmans constant, [kJ/(mol * K)] + 'T': module_temps_k, # module temperature, [K] + 'I': poa_global_kw, # module plane of array irradiance, [W/m2] + 'X': 0.0341, # irradiance relation, [unitless] + 'lnR_0': 13.72, # prefactor degradation [ln(%/h)] + } + + res = pvdeg.symbolic.calc_kwarg_timeseries( + expr=ln_R_D_expr, + kwarg=values_kwarg + ).sum() + + assert res == pytest.approx(6.5617e-09) \ No newline at end of file diff --git a/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb b/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb index 89568d63..2da8569f 100644 --- a/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb +++ b/tutorials_and_tools/tutorials_and_tools/Custom-Functions-Nopython.ipynb @@ -6,9 +6,6 @@ "metadata": {}, "outputs": [], "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", "import numpy as np\n", "import pandas as pd\n", "import sympy as sp\n", @@ -221,6 +218,13 @@ "np.log10(res.sum())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example with Single Values" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -247,74 +251,49 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\frac{Vbias^{2} k_{d}}{Rencap d}$" + ], + "text/plain": [ + "Vbias**2*k_d/(Rencap*d)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import pvdeg.symbolic\n", + "k_d, E, Vbias, Rencap, d = sp.symbols('k_d E Vbias Rencap d')\n", "\n", - "rate_of_deg_expression = pvdeg.symbolic.symbolic_from_latex(latex=r\"R_{0} * I^{X} * e^{\\frac{-{ea}}{k T}}\") # ea is breaking this " + "pid = k_d * (Vbias / d) * (Vbias / Rencap)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "import pvdeg.symbolic\n", - "\n", - "tex_I_leak = r\"\\frac{V_{bias}}{R_{enc}}\"\n", - "tex_E = r\"\\frac{V_{bias}}{d}\"\n", - "tex_D = r\"k_D \\cdot \\frac{V_{bias}}{d} \\cdot \\frac{V_{bias}}{R_{enc}}\"\n", - "\n", - "# mapping of values\n", - "values = {\n", - " 'V_{bias}': 1000,\n", - " 'R_{enc}': 1e9,\n", + "import pvdeg\n", + "pid_kwarg = {\n", + " 'Vbias' : 1000,\n", + " 'Rencap' : 1e9,\n", " 'd': 0.0005,\n", - " 'k_D': 1e-9,\n", - " 'alpha': 0.01,\n", - " 'beta': 0.02,\n", - " 't': 10,\n", - " 'P_0': 100,\n", - " 'R_0': 0.1\n", + " 'k_d': 1e-9,\n", "}\n", "\n", - "I_leak_expr = pvdeg.symbolic.symbolic_from_latex(tex_I_leak)\n", - "E_expr = pvdeg.symbolic.symbolic_from_latex(tex_E)\n", - "D_expr = pvdeg.symbolic.symbolic_from_latex(tex_D)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "pvdeg.symbolic.calc_kwarg_floats(\n", - " expr=D_expr,\n", - " kwarg=values\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "values_df = pd.DataFrame([values] * 26)\n", - "values_df['V_{bias}'] = np.linspace(100,2000,26)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "values_df" + "res = pvdeg.symbolic.calc_kwarg_floats(\n", + " expr=pid,\n", + " kwarg=pid_kwarg\n", + ")\n", + "\n", + "res" ] }, { From 08f47c81564926b393731b28283d4d09a1463e9e Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 1 Aug 2024 13:43:31 -0600 Subject: [PATCH 4/5] docs --- docs/source/api.rst | 2 +- pvdeg/__init__.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/api.rst b/docs/source/api.rst index 6cc1234c..6e0bdb0a 100644 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -24,7 +24,7 @@ Modules, methods, classes and attributes are explained here. montecarlo spectral standards + symbolic temperature utilities weather - symbolic diff --git a/pvdeg/__init__.py b/pvdeg/__init__.py index 90d6579c..51cd702c 100644 --- a/pvdeg/__init__.py +++ b/pvdeg/__init__.py @@ -14,11 +14,11 @@ from . import montecarlo from .scenario import Scenario from . import spectral +from . import symbolic from . import standards from . import temperature from . import utilities from . import weather -from . import symbolic __version__ = version("pvdeg") From c592600a424bd0abc48eff03fe2aa80072139b18 Mon Sep 17 00:00:00 2001 From: tobin-ford Date: Thu, 1 Aug 2024 16:27:24 -0600 Subject: [PATCH 5/5] bad test cases --- pvdeg/symbolic.py | 3 +++ tests/test_symbolic.py | 26 ++++++++++++++++++++++++-- 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/pvdeg/symbolic.py b/pvdeg/symbolic.py index c71a3705..748463a7 100644 --- a/pvdeg/symbolic.py +++ b/pvdeg/symbolic.py @@ -64,6 +64,9 @@ def _have_same_indices(series_list): if not series_list: return True + if not isinstance(series_list, pd.Series): + return False + first_index = series_list[0].index same_indicies = all(s.index.equals(first_index) for s in series_list[1:]) diff --git a/tests/test_symbolic.py b/tests/test_symbolic.py index e5b900d9..92c5ffda 100644 --- a/tests/test_symbolic.py +++ b/tests/test_symbolic.py @@ -1,6 +1,7 @@ import pytest import os import json +import numpy as np import pandas as pd import sympy as sp # not a dependency, may cause issues import pvdeg @@ -15,7 +16,6 @@ with open(os.path.join(TEST_DATA_DIR, "meta.json"), "r") as file: META = json.load(file) - # D = k_d * E * Ileak # degradation rate, D # degradation constant, k_d @@ -91,4 +91,26 @@ def test_symbolic_timeseries(): kwarg=values_kwarg ).sum() - assert res == pytest.approx(6.5617e-09) \ No newline at end of file + assert res == pytest.approx(6.5617e-09) + +def test_calc_df_symbolic_bad(): + expr = sp.symbols('not_in_columns') + df = pd.DataFrame([[1,2,3,5]],columns=['a','b','c','d']) + + with pytest.raises(ValueError): + pvdeg.symbolic.calc_df_symbolic(expr=expr, df=df) + +def test_calc_kwarg_timeseries_bad_type(): + # try passing an invalid argument type + with pytest.raises(ValueError, match="only simple numerics or timeseries allowed"): + pvdeg.symbolic.calc_kwarg_timeseries(expr=None, kwarg={'bad':pd.DataFrame()}) + +def test_calc_kwarg_timeseries_bad_mismatch_lengths(): + # arrays of different lengths + with pytest.raises(NotImplementedError, match="arrays/series are different lengths. fix mismatched length. otherwise arbitrary symbolic solution is too complex for solver. nested loops or loops dependent on previous results not supported."): + pvdeg.symbolic.calc_kwarg_timeseries(expr=None, kwarg={'len1':np.zeros((5,)), 'len2':np.zeros(10,)}) + +def test_calc_kwarg_timeseries_no_index(): + + v1, v2 = sp.symbols('v1 v2') + expr = v1 * v2 \ No newline at end of file