From 8f00cd4b75ba5f69cd4057496a21aeeb51e8607b Mon Sep 17 00:00:00 2001 From: cdeline Date: Fri, 31 Jul 2020 13:27:00 -0600 Subject: [PATCH] 2.0.0b0 release (#190) * configure travis to only deploy on one build * prevent NaNs from summing to 0 * Update pandas requirement min_count was added as an argument for dataframe.resample().sum() in 0.22.0 * add energy_from_power() and associated tests * Update example notebook Changes in step 0: -use interpolate to resample the dataframe -use new energy_from_power() function * fix integer division bug for phython 2 * pep8 compliance * Fix docstring spelling errors * change name of series returned by energy_from_power() * Update tests for expected series name * Allow energy_from_power() with single argument * change second argument of energy_from_power() to be a Timedelta (This is more appropriate and versatile than a float with implied units) * Add series interpolation * Add dataframe input capability to interpolate_to_index() * Change function name and add frequency specification capability to interpolate() * Speed up interpolate_series() (converting to integer index under the hood is faster than pandas timestamps) * Run example with rdtools.interpolate() in step 0 * New version of energy_from_power and incorporation into normalization * require pandas >= 0.23 * Remove warnings from interpolation when max_timedelta is inferred * work around for pandas issue * Add non-workaround case for tz naive series * Change the behavior of interpolate to return NaNs where max_delta is exceeded Old behavior was to have those times be missing from the output. The new behavior ensures that interpolate produces regular time series when a frequency is passed as target. * address bug related to python 2 sting casting * Add recomendation against using interpolation for downsampling * Update notebook_requirements to address security issue in notebook version * Update copyright line of LICENSE * Update to use pvlib>0.6.0 * Add code from pv_soiling to soiling.py Includes the addition of the wrapper function soiling_srr. The manual_cleanings keyword was also removed, it was not implimented in pv_soiling. * Add confidence metric keywords and calc_info to soiling_srr() * Avoid manipulating precip input name and change pandas syntax * pass args to calc_monte() in soiling_srr() * rename infer_clean to half_norm_clean * Retain timezone in pm_frame creation * Renormalize to median of first year (per yoy degradation). Renorm factor is also included with calc_info * Keep all the monte carlo soiling profiles * import soiling_srr in __init__.py * Add more to the soiling calc_info output * enable modification of validity criteria in calc_result_frame * Add validity parameters to soiling_srr() * Clarify units of exceedance_prob in degradation_year_on_year * add type to confidence_level in degradation_year_on_year * clean up recenter type specification * Update example notebook with soiling functionality * Add axis labels to soiling plots * Add random_seed to soiling_srr for repeatable results * use true division in soiling.py * require numpy greater than 1.12 Soiling code requires numpy distributions with scale 0, see numpy PR #5822 for more information * Update notebook with note about get_clearsky() behavior change Warnings were also removed from output, and the kernel was changed to `Python [default]` * Replace hashes in soiling_test with more interpretable tests * enforce column order in test_soiling_srr() test * refactored soiling method conditionals * Add soiling rate histogram to example * Refactor soiling to single class * change irradiance-weighted to insolation-weighted in soiling output * add soiling histogram for readme * Update readme with soiling information * Rename the example notebook * Add docstring to srr_analysis.__init__() * Docstring standardization and pep8 formatting (#125) * docstring formatting cleanup for sphinx * add sphinx configuration files and index.rst * document missing parameters for get_clearsky_tamb * Add docstrings for undocumented functions. * integrate ipython notebook examples with sphinx docs * Update requirements.txt for Sphinx: m2r, nbsphinx, nbsphinx-link * need to rev h5py, numpy and scipy to avoid setup install errors. * add ipython to requirements.txt to allow inline ipython notebook examples * rollback scipy to 1.2.2 (py27 compliant) * custom .yml and requirements file for rtd * point to index.html in conf.py * test out path fixes for README.md to RST conversion * Add Changelog to sphinx docs (#134) * add sphinx.ext.extlinks to conf.py * Drop py2.7 and add 3.7 and 3.8 to testing (#135) * Drop 2.7 and add 3.7 and 3.8 to testing, update docs. * creating DatetimeIndex directly is deprecated, switch to pd.date_range * require pandas < 1.0.0 * bump requirements.txt numpy to 1.17.3 for testing on py3.8 * more requirements.txt updates for py3.8 wheel availability * Update v2.0.0.rst * convert README.md to ReSt in index.rst, move images folder into sphinx source * Fix formatting, fix conf.py images folder * Fix crosslinks and image size * mention soiling * another crosslink * Improve module-level docstrings (#137) * Improve module docstrings for sphinx docs module summaries * Update v2.0.0.rst * pare down readme.md * incorporate new rdtools draft mission statement * Add developer notes section to sphinx docs (#136) * Add developer notes page and update setup.py with doc reqs * improve formatting in developer_notes.rst * missed a couple formatting issues * change RTD to use setuptools extras instead of sphinx_requirements.txt * add ipython to doc requirements * change backslashes to forward slashes because they work on windows too. also remove unnecessary note about ipython * cleanup * Update v2.0.0.rst * add [test] requirements to setup.py * update developer notes with more detailed installation instructions * add code requirements section * Add coverage instructions and configuration * link typo * simplify pytest instructions * clarify installing rdtools from local git repo * Bump bleach from 2.1.3 to 3.1.1 in /docs (#149) Bumps [bleach](https://github.com/mozilla/bleach) from 2.1.3 to 3.1.1. - [Release notes](https://github.com/mozilla/bleach/releases) - [Changelog](https://github.com/mozilla/bleach/blob/master/CHANGES) - [Commits](https://github.com/mozilla/bleach/compare/v2.1.3...v3.1.1) Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> * rerun `versioneer install` to fix v-prefix issue (#153) * Cherry-pick the plotting module out of the system analysis branch (#138) * cherry-pick the plotting module commit * add module-level docstring * make plotting module docstrings numpydoc-compliant * update deg/soiling example to use plotting functions * add plotting module to api.rst * fix crosslinks * add matplotlib to setup.py * update requirements.txt matplotlib for 3.8 testing * update changelog * add bins parameter to plotting.degradation_summary_plot from #132 * add basic plotting tests * exercise all kwargs in plotting tests * simplify pytest fixture; test kwargs in separate functions * missed one * fancy error messages * Clean up errant spaces * remove normalize_with_pvwatts import Co-authored-by: Michael Deceglie Co-authored-by: Michael Deceglie * fix typo * make introductions more approachable to non-specialists * docs cleanup * improve contributing notes * drop m2r requirement since index.rst isn't generated from readme.md anymore * remove m2r from conf.py * requested changes * hyphen * Remove low power cutoff in filtering.clipping_filter (#144) * remove low power cutoff in filtering.clipping_filter * Update v2.0.0.rst * shame on me for not running tests locally * Update degradation_and_soiling_example.ipynb * Update degradation_and_soiling_example.ipynb * change normalized filter to > 0.01 per internal discussion * Workaround for reindexing bug in Pandas 1.0.0 (#142) * tentative workaround for pandas 1.0.0 reindexing bug * Bump requirements to Pandas <= 1.0.0 for Travis upgrade-strategy=eager pytests * update pandas req to exclude 1.0.0, 1.0.1 * Revert "tentative workaround for pandas 1.0.0 reindexing bug" This reverts commit 9b69a9d7a7aed76a1a8f0012f5720109466b5c28. * setup.py version lists are combined with AND, so <1.0.0, >=1.0.2 wasn't valid Co-authored-by: cdeline * Remove conflicting reqs (#164) * Remove conflicting reqs Some packages were specified in both notebook_requirements.txt and requirements.txt. In some cases versions conflicted. * Update requirements.txt with indirect requirements * Run notebook * Add a note to first install requirements.txt * Notebook updates -Add directions to install both requirement files -Incorporate bugfix from #166 * Changelog update * Apply suggestions to changelog Co-Authored-By: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Update normalization.irradiance_rescale and create irradiance_rescale_test.py (#152) * Create irradiance_rescale_test.py * pep8 spaces * NameError -> UnboundLocalError * expose convergence_threshold and default method to 'iterative' * bugfix * allow max_iterations=0 * bugfix * changelog Co-authored-by: Michael Deceglie * Empty soiling intervals bugfix (#169) * Closes #129 bug for invalid soiling intervals * changelog entry * Add a test to catch nan soiling interval bug * clean up comment indentation * SRR fixes (#154) * fix precipitation frequency bug * doc typo * Normalized filter cherrypick (#139) * Add normalized_filter() function to replace the mannual filter in example * update docstring * add entry to api.rst * update changelog * update lower bound to 0.01 * changelog for notebook changes * add normalized_filter test to exercise default lower bound Co-authored-by: Michael Deceglie * update soiling docstrings to mention soiling stations and aggregation (#165) * capitalize the SRR class name (#168) * rename srr_analysis to SRRAnalysis * formatting fix * changelog * Miscellaneous cleanups (#162) * remove __future__ imports * normalize_with_sapm duplicate lines * setup.py status from beta to production/stable * Delete build.bat * copyright to 2020 in license and sphinx conf * changelog for energy_from_power, normalize_with_x (#172) * changelog for energy_from_power, normalize_with_x * revise changelog * migrate to pvlib>=0.7.0 (#170) * migrate to pvlib >=0.7.0 * update SAPM normalization docstrings to mention racking_model and module_type * update sapm normalization test to specify module_type * bump docs pvlib requirement to 0.7.1 * Update rdtools/normalization.py Co-Authored-By: Cliff Hansen * don't use keyword names for sapm_celltemp Co-authored-by: Cliff Hansen * better GitHub links in documentation (#156) * tentative fix * fix slash * include branch logic based on RTD version * small improvement * omit GH link element if not building development or master * change github link text to reflect the destination branch * link changelog page to changelog GH folder instead of the template rst file * bugfix * Generalized model normalizaiton (#173) * Add normalize_with_expected_power() and refactor normalization module * make minor adjustments to normalize_with_expected_power * Add tests for normalize_with_expected_power * update changelog * update docstring Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Change test file name * code formatting fixes * simplify conditional * return energy and insolation on same index * minor changelog update * add new function to __init__.py and api.rst Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Include emacs auto-save and backup files in gitignore (#146) * Add example notebook using the NREL PVDAQ #4 system (#171) * Create degradation_and_soiling_example_sanyo.ipynb * various typos * change weather columns based on inspection; rename nz_mask to normalized_mask; improve soiling analysis * bump pandas, pvlib, and statsmodels versions in requirements.txt * add discussion; rerun notebook * rerun original notebook with new requirements to remove warnings * update pvlib links in notebooks to fix rendering on RTD * use sanyo example for the RTD page * changelog * clean up labeling * Notebook updates -Update the notebook to use a more pronounced soiling signal -Comment updates -use normalized_filter() -Use default behavior of infer_freq() and energy_from_power() * Update docs/degradation_and_soiling_example_pvdaq_4.ipynb Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Update docs/degradation_and_soiling_example_pvdaq_4.ipynb Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Update notebook to use new normalize_with_expected_power() * limit notebook line length to 90 characters * Update notebook with data location on datahub * add pickle to gitignore * Cache data and fix typo Co-authored-by: Michael Deceglie * add the logo to documentation home page (#174) * add logo to index.rst * Update logo_horizontal_highres.png * Add logo to readme (#178) * Add logo to readme * Shrink logo * update DKASC link (#180) * SRR precipitation changes (#176) * remove "clean_wo_precip", add "clean_criterion" * loop to cumulative sum * missed some changes * add min_interval_length parameter to SRR * clean up code formatting * Move clean event outage and consecutive day logic to after cleaning events are established * Add precip and shift options for clean_criterion * Add precip_threshold * Update precipitation cleaning detection logic Use a three day window only for precip_and_shift case * Update docstrings about when precipitation is used * update soiling test for precip behavior * rerun notebooks pvdaq4 notebook unaffected * break a docstring line * update the changelog * docstring typo * change log typo fix Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> * Review updates * splat kwargs in test * remove random_seed Co-authored-by: Michael Deceglie * Change interpolate max_timedelta to 2x median, add warning (#182) * change threshold, add warning, update tests * fix how exclusion warning is calculated, rerun notebooks * changelog * add license file to manifest (#183) * Overview update (#186) * Overview update I suggest slightly rephrasing the overview. * Add change to readme * Add GitHub templates and Code of Conduct (#184) * Create pull_request_template.md * add default github templates * improvements from review * Comply with pv-terms (#185) * first pass at pvterms compat * change back to `gamma_pdc` * docstring update power->energy * Capitalize Celsius * dc_power to power_dc (local variable) * modeled_irrad to irrad_sim * 1time_series` to `power` * add simultated to docstring * update test with gamma_pdc * Fix failing tests Possibly related to a pandas update rather than anything in RdTools * Update soiling attributes * pvwatts kwargs docstring update * Updated example notebooks: 'tempco' = 'gamma_pdc'; 'wind' = 'wind_speed' * Pandas > 1.0 requires explicit registering of matplotlib converters. * update normalize_with_pvwatts and clearsky_pvwatts_kws keywords. Pref-> power_dc_rated. * Add sphinx requirements to requirements.txt * Update API example in index.rst. Add #185 updates to whatsnew * Add specific kwarg values that have changed Co-authored-by: Michael Deceglie Co-authored-by: cdeline * Update changelog with 2.0b0 release date Co-authored-by: Michael Deceglie Co-authored-by: Michael Deceglie Co-authored-by: Kevin Anderson <57452607+kanderso-nrel@users.noreply.github.com> Co-authored-by: Kevin Anderson Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Cliff Hansen Co-authored-by: Will Vining --- .coveragerc | 6 + .github/CONTRIBUTING.md | 5 + .github/ISSUE_TEMPLATE/bug_report.md | 23 + .github/ISSUE_TEMPLATE/feature_request.md | 17 + .github/pull_request_template.md | 5 + .gitignore | 11 + .readthedocs.yml | 6 + .travis.yml | 7 +- CODE_OF_CONDUCT.md | 76 ++ MANIFEST.in | 3 +- README.md | 126 +-- docs/degradation_and_soiling_example.ipynb | 834 +++++++++++++++++ ...radation_and_soiling_example_pvdaq_4.ipynb | 859 ++++++++++++++++++ docs/degradation_example.ipynb | 630 ------------- docs/notebook_requirements.txt | 10 +- docs/sphinx/Makefile | 20 + docs/sphinx/make.bat | 35 + .../_images}/Clearsky_result_updated.png | Bin .../source/_images/RdTools_workflows.png | Bin 0 -> 26884 bytes .../sphinx/source/_images}/Workflow1.png | Bin .../_images/logo_horizontal_highres.png | Bin 0 -> 336510 bytes .../source/_images/soiling_histogram.png | Bin 0 -> 36414 bytes docs/sphinx/source/_static/no_scrollbars.css | 11 + .../sphinx/source/_templates/breadcrumbs.html | 32 + docs/sphinx/source/api.rst | 123 +++ docs/sphinx/source/changelog.rst | 4 + docs/sphinx/source/changelog/v2.0.0b0.rst | 93 ++ docs/sphinx/source/conf.py | 197 ++++ docs/sphinx/source/developer_notes.rst | 203 +++++ docs/sphinx/source/example.nblink | 3 + docs/sphinx/source/index.rst | 271 ++++++ rdtools/__init__.py | 9 + rdtools/aggregation.py | 21 +- rdtools/clearsky_temperature.py | 55 +- rdtools/degradation.py | 202 ++-- rdtools/filtering.py | 124 ++- rdtools/normalization.py | 779 +++++++++++----- rdtools/plotting.py | 232 +++++ rdtools/soiling.py | 703 ++++++++++++++ rdtools/test/aggregation_test.py | 2 +- rdtools/test/energy_from_power_test.py | 146 +++ rdtools/test/filtering_test.py | 34 +- rdtools/test/interpolate_test.py | 140 +++ rdtools/test/irradiance_rescale_test.py | 68 ++ rdtools/test/normalization_pvwatts_test.py | 14 +- rdtools/test/normalization_sapm_test.py | 13 +- .../normalize_with_expected_power_test.py | 152 ++++ rdtools/test/plotting_test.py | 164 ++++ rdtools/test/soiling_test.py | 226 +++++ requirements.txt | 25 +- setup.py | 36 +- 51 files changed, 5622 insertions(+), 1133 deletions(-) create mode 100644 .coveragerc create mode 100644 .github/CONTRIBUTING.md create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/pull_request_template.md create mode 100644 .readthedocs.yml create mode 100644 CODE_OF_CONDUCT.md create mode 100644 docs/degradation_and_soiling_example.ipynb create mode 100644 docs/degradation_and_soiling_example_pvdaq_4.ipynb delete mode 100644 docs/degradation_example.ipynb create mode 100644 docs/sphinx/Makefile create mode 100644 docs/sphinx/make.bat rename {screenshots => docs/sphinx/source/_images}/Clearsky_result_updated.png (100%) create mode 100644 docs/sphinx/source/_images/RdTools_workflows.png rename {screenshots => docs/sphinx/source/_images}/Workflow1.png (100%) create mode 100644 docs/sphinx/source/_images/logo_horizontal_highres.png create mode 100644 docs/sphinx/source/_images/soiling_histogram.png create mode 100644 docs/sphinx/source/_static/no_scrollbars.css create mode 100644 docs/sphinx/source/_templates/breadcrumbs.html create mode 100644 docs/sphinx/source/api.rst create mode 100644 docs/sphinx/source/changelog.rst create mode 100644 docs/sphinx/source/changelog/v2.0.0b0.rst create mode 100644 docs/sphinx/source/conf.py create mode 100644 docs/sphinx/source/developer_notes.rst create mode 100644 docs/sphinx/source/example.nblink create mode 100644 docs/sphinx/source/index.rst create mode 100644 rdtools/plotting.py create mode 100644 rdtools/soiling.py create mode 100644 rdtools/test/energy_from_power_test.py create mode 100644 rdtools/test/interpolate_test.py create mode 100644 rdtools/test/irradiance_rescale_test.py create mode 100644 rdtools/test/normalize_with_expected_power_test.py create mode 100644 rdtools/test/plotting_test.py create mode 100644 rdtools/test/soiling_test.py diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 00000000..bc5c5271 --- /dev/null +++ b/.coveragerc @@ -0,0 +1,6 @@ +[run] +omit = + # _version.py doesn't count + rdtools/_version.py + # omit the test files themselves + rdtools/test/* diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 00000000..f6490d94 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,5 @@ +Contributing +============ + +See the contributing page on ReadTheDocs: +[contributing](https://rdtools.readthedocs.io/en/latest/developer_notes.html#contributing) \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 00000000..c2e917d4 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,23 @@ +--- +name: Bug report +about: Create a report to help us improve + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**Full error message and traceback** +Please copy/paste the entire error traceback, if applicable. + +**To Reproduce** +Steps to reproduce the behavior. + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Additional context** +Add any other context about the problem here. diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..066b2d92 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,17 @@ +--- +name: Feature request +about: Suggest an idea for this project + +--- + +**Is your feature request related to a problem? Please describe.** +A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] + +**Describe the solution you'd like** +A clear and concise description of what you want to happen. + +**Describe alternatives you've considered** +A clear and concise description of any alternative solutions or features you've considered. + +**Additional context** +Add any other context or screenshots about the feature request here. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 00000000..3e11386c --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,5 @@ +- [ ] Code changes are covered by tests +- [ ] New functions added to `__init__.py` +- [ ] API.rst is up to date, along with other sphinx docs pages +- [ ] Example notebooks are rerun and differences in results scrutinized +- [ ] Updated changelog \ No newline at end of file diff --git a/.gitignore b/.gitignore index f0f72a34..2a7bf583 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ # ignore coveralls yaml, coverge dir .coveralls.yml .coverage +htmlcov/ # ignore test cache .pytest_cache @@ -19,8 +20,18 @@ docs/.ipynb_checkpoints/degradation_example-checkpoint.ipynb *.ipynb_checkpoints* +# sphinx docs build +docs/sphinx/source/generated + # ignore setup and egg-info .eggs/ build/ dist/ rdtools.egg-info* + +# emacs temp files +*~ +\#*\# +.\#* + +*.pickle diff --git a/.readthedocs.yml b/.readthedocs.yml new file mode 100644 index 00000000..d76e9e31 --- /dev/null +++ b/.readthedocs.yml @@ -0,0 +1,6 @@ +python: + version: 3.6 + use_system_site_packages: true + pip_install: true + extra_requirements: + - doc diff --git a/.travis.yml b/.travis.yml index 8f0729d5..40d2cb1f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,8 +3,9 @@ sudo: false language: python python: - - "2.7" - "3.6" + - "3.7" + - "3.8" # Test two environments: # 1) dependencies with pinned versions from requirements.txt @@ -25,6 +26,8 @@ install: script: - pytest +# Deploy to pypi on the python 3.6 build with upgraded dependencies when +# a new version is tagged on github from the master branch deploy: provider: pypi user: RdTools @@ -33,6 +36,8 @@ deploy: on: tags: true branch: master + python: 3.6 + condition: $REQ_ENV == '--upgrade --upgrade-strategy=eager .' distributions: "sdist bdist_wheel" skip_cleanup: true skip_existing: true diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 00000000..c18f3d79 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at RdTools@nrel.gov. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq \ No newline at end of file diff --git a/MANIFEST.in b/MANIFEST.in index 939650cc..59265954 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,3 +1,4 @@ include versioneer.py include rdtools/_version.py -include rdtools/data/* \ No newline at end of file +include rdtools/data/* +include LICENSE \ No newline at end of file diff --git a/README.md b/README.md index 6ed3d767..9d99e2d8 100644 --- a/README.md +++ b/README.md @@ -1,120 +1,40 @@ -# About RdTools +RdTools logo -Master branch: [![Build Status](https://travis-ci.org/NREL/rdtools.svg?branch=master)](https://travis-ci.org/NREL/rdtools) -Development branch: [![Build Status](https://travis-ci.org/NREL/rdtools.svg?branch=development)](https://travis-ci.org/NREL/rdtools) +Master branch: +[![Build Status](https://travis-ci.org/NREL/rdtools.svg?branch=master)](https://travis-ci.org/NREL/rdtools) -RdTools is a set of Python tools for analysis of photovoltaic data. -In particular, PV production data is evaluated over several years -to obtain rates of performance degradation over time. RdTools can -handle both high frequency (hourly or better) or low frequency (daily, weekly, etc.) -datasets. Best results are obtained with higher frequency data. +Development branch: +[![Build Status](https://travis-ci.org/NREL/rdtools.svg?branch=development)](https://travis-ci.org/NREL/rdtools) -Full examples are worked out in the example notebooks in [rdtools/docs](./docs/degradation_example.ipynb). +RdTools is an open-source library to support reproducible technical analysis of +time series data from photovoltaic energy systems. The library aims to provide +best practice analysis routines along with the building blocks for users to +tailor their own analyses. +Current applications include the evaluation of PV production over several years to obtain +rates of performance degradation and soiling loss. RdTools can handle +both high frequency (hourly or better) or low frequency (daily, weekly, +etc.) datasets. Best results are obtained with higher frequency data. -## Workflow - -0. Import and preliminary calculations -1. Normalize data using a performance metric -2. Filter data that creates bias -3. Aggregate data -4. Analyze aggregated data to estimate the degradation rate - - -RdTools Workflow - -## Degradation Results - -The preferred method for degradation rate estimation is the year-on-year (YOY) approach, -available in `degradation.degradation_year_on_year`. The YOY calculation yields in a distribution -of degradation rates, the central tendency of which is the most representative of the true -degradation. The width of the distribution provides information about the uncertainty in the -estimate via a bootstrap calculation. The [example notebook](./docs/degradation_example.ipynb) uses the output of `degradation.degradation_year_on_year()` -to visualize the calculation. - -RdTools Result - - -Two workflows are available for system performance ratio calculation, and illustrated in an example notebook. -The sensor-based approach assumes that site irradiance and temperature sensors are calibrated and in good repair. -Since this is not always the case, a 'clear-sky' workflow is provided that is based on -modeled temperature and irradiance. Note that site irradiance data is still required to identify -clear-sky conditions to be analyzed. In many cases, the 'clear-sky' analysis can identify conditions -of instrument errors or irradiance sensor drift, such as in the above analysis. - - -## Install RdTools using pip - -RdTools can be installed automatically into Python from PyPI using the command line: -`pip install rdtools` - -Alternatively it can be installed manually using the command line: - -1. Download a [release](https://github.com/NREL/rdtools/releases) (Or to work with a development version, clone or download the rdtools repository). -2. Navigate to the repository: `cd rdtools` -3. Install via pip: `pip install .` - -On some systems installation with `pip` can fail due to problems installing requirements. If this occurs, the requirements specified in `setup.py` may need to be separately installed (for example by using `conda`) before installing `rdtools`. - -RdTools currently runs in both Python 2.7 and 3.6. - -## Usage and examples - - -Full workflow examples are found in the notebooks in [rdtools/docs](./docs/degradation_example.ipynb). The examples are designed to work with python 3.6. For a consistent experience, we recommend installing the packages and versions documented in `docs/notebook_requirements.txt`. This can be achieved in your environment by first installing RdTools as described above, then running `pip install -r docs/notebook_requirements.txt` from the base directory. - -The following functions are used for degradation analysis: +RdTools can be installed automatically into Python from PyPI using the +command line: ``` -import rdtools +pip install rdtools ``` -The most frequently used functions are: +For API documentation and full examples, please see the [documentation](https://rdtools.readthedocs.io). -```Python -normalization.normalize_with_pvwatts(energy, pvwatts_kws) - ''' - Inputs: Pandas time series of raw energy, PVwatts dict for system analysis - (poa_global, P_ref, T_cell, G_ref, T_ref, gamma_pdc) - Outputs: Pandas time series of normalized energy and POA insolation - ''' -``` - -```Python -filtering.poa_filter(poa); filtering.tcell_filter(Tcell); filtering.clip_filter(power); -filtering.csi_filter(insolation, clearsky_insolation) - ''' - Inputs: Pandas time series of raw data to be filtered. - Output: Boolean mask where `True` indicates acceptable data - ''' -``` - -```Python -aggregation.aggregation_insol(normalized, insolation, frequency='D') - ''' - Inputs: Normalized energy and insolation - Output: Aggregated data, weighted by the insolation. - ''' -``` - -```Python -degradation.degradataion_year_on_year(aggregated) - ''' - Inputs: Aggregated, normalized, filtered time series data - Outputs: Tuple: `yoy_rd`: Degradation rate - `yoy_ci`: Confidence interval `yoy_info`: associated analysis data - ''' -``` +RdTools currently is tested on Python 3.6+. ## Citing RdTools -The underlying workflow of RdTools has been published in several places. If you use RdTools in a published work, please cite the following: +The underlying workflow of RdTools has been published in several places. If you use RdTools in a published work, please cite the following as appropriate: - - D. Jordan, C. Deline, S. Kurtz, G. Kimball, M. Anderson, "Robust PV Degradation Methodology and Application", - IEEE Journal of Photovoltaics, 2017 + - D. Jordan, C. Deline, S. Kurtz, G. Kimball, M. Anderson, "Robust PV Degradation Methodology and Application", IEEE Journal of Photovoltaics, 8(2) pp. 525-531, 2018 + - M. G. Deceglie, L. Micheli and M. Muller, "Quantifying Soiling Loss Directly From PV Yield," in IEEE Journal of Photovoltaics, 8(2), pp. 547-551, 2018 - RdTools, version x.x.x, https://github.com/NREL/rdtools, [DOI:10.5281/zenodo.1210316](https://doi.org/10.5281/zenodo.1210316) *(be sure to include the version number used in your analysis)* - ## References The clear sky temperature calculation, `clearsky_temperature.get_clearsky_tamb()`, uses data @@ -124,10 +44,10 @@ https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTN_CLIM_M Other useful references which may also be consulted for degradation rate methodology include: - - D. C. Jordan, M. G. Deceglie, S. R. Kurtz, “PV degradation methodology comparison — A basis for a standard”, in 43rd IEEE Photovoltaic Specialists Conference, Portland, OR, USA, 2016, DOI: 10.1109/PVSC.2016.7749593. + - D. C. Jordan, M. G. Deceglie, S. R. Kurtz, "PV degradation methodology comparison — A basis for a standard", in 43rd IEEE Photovoltaic Specialists Conference, Portland, OR, USA, 2016, DOI: 10.1109/PVSC.2016.7749593. - Jordan DC, Kurtz SR, VanSant KT, Newmiller J, Compendium of Photovoltaic Degradation Rates, Progress in Photovoltaics: Research and Application, 2016, 24(7), 978 - 989. - D. Jordan, S. Kurtz, PV Degradation Rates – an Analytical Review, Progress in Photovoltaics: Research and Application, 2013, 21(1), 12 - 29. - - E. Hasselbrink, M. Anderson, Z. Defreitas, M. Mikofski, Y.-C.Shen, S. Caldwell, A. Terao, D. Kavulak, Z. Campeau, D. DeGraaff, “Validation of the PVLife model using 3 million module-years of live site data”, 39th IEEE Photovoltaic Specialists Conference, Tampa, FL, USA, 2013, p. 7 – 13, DOI: 10.1109/PVSC.2013.6744087. + - E. Hasselbrink, M. Anderson, Z. Defreitas, M. Mikofski, Y.-C.Shen, S. Caldwell, A. Terao, D. Kavulak, Z. Campeau, D. DeGraaff, "Validation of the PVLife model using 3 million module-years of live site data", 39th IEEE Photovoltaic Specialists Conference, Tampa, FL, USA, 2013, p. 7 – 13, DOI: 10.1109/PVSC.2013.6744087. ## Further Instructions and Updates diff --git a/docs/degradation_and_soiling_example.ipynb b/docs/degradation_and_soiling_example.ipynb new file mode 100644 index 00000000..cf4de875 --- /dev/null +++ b/docs/degradation_and_soiling_example.ipynb @@ -0,0 +1,834 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Degradation and soiling example with clearsky workflow\n", + "\n", + "\n", + "This juypter notebook is intended to the RdTools analysis workflow. In addition, the notebook demonstrates the effects of changes in the workflow. For a consistent experience, we recommend installing the specific versions of packages used to develop this notebook. This can be achieved in your environment by running `pip install -r requirements.txt` followed by `pip install -r docs/notebook_requirements.txt` from the base directory. (RdTools must also be separately installed.)\n", + "\n", + "The calculations consist of several steps illustrated here:\n", + "
    \n", + "
  1. Import and preliminary calculations
    2. \n", + "
  2. Normalize data using a performance metric
    3. \n", + "
  3. Filter data that creates bias
    4. \n", + "
  4. Aggregate data
    5. \n", + "
  5. Analyze aggregated data to estimate the degradation rate
    6. \n", + "
  6. Analyze aggregated data to estimate the soiling loss
    7. \n", + "
\n", + "\n", + "After demonstrating these steps using sensor data, a modified version of the workflow is illustrated using modled clear sky irradiance and temperature. The results from the two methods are compared\n", + "\n", + "This notebook works with public data from the the Desert Knowledge Australia Solar Centre. Please download the site data from Site 12, and unzip the csv file in the folder:\n", + "./rdtools/docs/\n", + "\n", + "Note this example was run with data downloaded on Sept. 28, 2018. An older version of the data gave different sensor-based results. If you have an older version of the data and are getting different results, please try redownloading the data.\n", + "\n", + "http://dkasolarcentre.com.au/download?location=alice-springs" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import timedelta\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pvlib\n", + "import rdtools\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Update the style of plots\n", + "import matplotlib\n", + "matplotlib.rcParams.update({'font.size': 12,\n", + " 'figure.figsize': [4.5, 3],\n", + " 'lines.markeredgewidth': 0,\n", + " 'lines.markersize': 2\n", + " })\n", + "# Register time series plotting in pandas > 1.0\n", + "from pandas.plotting import register_matplotlib_converters\n", + "register_matplotlib_converters()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the random seed for numpy to ensure consistent results\n", + "np.random.seed(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0: Import and preliminary calculations\n", + "\n", + "\n", + "This section prepares the data necesary for an `rdtools` calculation. The first step of the `rdtools` workflow is normaliztion, which requires a time series of energy yield, a time series of cell temperature, and a time series of irradiance, along with some metadata (see Step 1: Normalize)\n", + "\n", + "The following section loads the data, adjusts units where needed, and renames the critical columns. The irradiance sensor data source is transposed to plane-of-array, and the temperature sensor data source is converted into estimated cell temperature.\n", + "\n", + "A common challenge is handling datasets with and without daylight savings time. Make sure to specify a `pytz` timezone that does or does not include daylight savings time as appropriate for your dataset.\n", + "\n", + "The steps of this section may change depending on your data source or the system being considered. Note that nothing in this first section utlizes the `rdtools` library. Transposition of irradiance and modeling of cell temperature are generally outside the scope of `rdtools`. A variety of tools for these calculations are avaialble in [pvlib](https://github.com/pvlib/pvlib-python)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "file_name = '84-Site_12-BP-Solar.csv'\n", + "\n", + "df = pd.read_csv(file_name)\n", + "try:\n", + " df.columns = [col.decode('utf-8') for col in df.columns]\n", + "except AttributeError:\n", + " pass # Python 3 strings are already unicode literals\n", + "df = df.rename(columns = {\n", + " u'12 BP Solar - Active Power (kW)':'power',\n", + " u'12 BP Solar - Wind Speed (m/s)': 'wind_speed',\n", + " u'12 BP Solar - Weather Temperature Celsius (\\xb0C)': 'Tamb',\n", + " u'12 BP Solar - Global Horizontal Radiation (W/m\\xb2)': 'ghi',\n", + " u'12 BP Solar - Diffuse Horizontal Radiation (W/m\\xb2)': 'dhi'\n", + "})\n", + "\n", + "# Specify the Metadata\n", + "meta = {\"latitude\": -23.762028,\n", + " \"longitude\": 133.874886,\n", + " \"timezone\": 'Australia/North',\n", + " \"gamma_pdc\": -0.005,\n", + " \"azimuth\": 0,\n", + " \"tilt\": 20,\n", + " \"power_dc_rated\": 5100.0,\n", + " \"temp_model_params\": pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']}\n", + "\n", + "df.index = pd.to_datetime(df.Timestamp)\n", + "# TZ is required for irradiance transposition\n", + "df.index = df.index.tz_localize(meta['timezone'], ambiguous = 'infer') \n", + "\n", + "# Explicitly trim the dates so that runs of this example notebook \n", + "# are comparable when the sourec dataset has been downloaded at different times\n", + "df = df['2008-11-11':'2017-05-15']\n", + "\n", + "# Chage power from kilowatts to watts\n", + "df['power'] = df.power * 1000.0\n", + "\n", + "# There is some missing data, but we can infer the frequency from the first several data points\n", + "freq = pd.infer_freq(df.index[:10])\n", + "\n", + "# Then set the frequency of the dataframe.\n", + "# It is reccomended not to up- or downsample at this step\n", + "# but rather to use interpolate to regularize the time series\n", + "# to it's dominant or underlying frequency. Interpolate is not\n", + "# generally recomended for downsampleing in this applicaiton.\n", + "df = rdtools.interpolate(df, freq, pd.to_timedelta('15 minutes'))\n", + "\n", + "# Calculate energy yield in Wh\n", + "df['energy'] = rdtools.energy_from_power(df.power, max_timedelta=pd.to_timedelta('15 minutes'))\n", + "\n", + "# Calculate POA irradiance from DHI, GHI inputs\n", + "loc = pvlib.location.Location(meta['latitude'], meta['longitude'], tz = meta['timezone'])\n", + "sun = loc.get_solarposition(df.index)\n", + "\n", + "# calculate the POA irradiance\n", + "sky = pvlib.irradiance.isotropic(meta['tilt'], df.dhi)\n", + "df['dni'] = (df.ghi - df.dhi)/np.cos(np.deg2rad(sun.zenith))\n", + "beam = pvlib.irradiance.beam_component(meta['tilt'], meta['azimuth'], sun.zenith, sun.azimuth, df.dni)\n", + "df['poa'] = beam + sky\n", + "\n", + "# Calculate cell temperature\n", + "df['Tcell'] = pvlib.temperature.sapm_cell(df.poa, df.Tamb, df.wind_speed, **meta['temp_model_params'])\n", + "\n", + "# plot the AC power time series\n", + "fig, ax = plt.subplots(figsize=(4,3))\n", + "ax.plot(df.index, df.power, 'o', alpha = 0.01)\n", + "ax.set_ylim(0,7000)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('AC Power (W)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1: Normalize\n", + "\n", + "Data normalization is achieved with `rdtools.normalize_with_pvwatts()`. We provide a time sereis of energy, along with keywords used to run a pvwatts model of the system. More information available in the docstring." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Specify the keywords for the pvwatts model\n", + "pvwatts_kws = {\"poa_global\" : df.poa,\n", + " \"power_dc_rated\" : meta['power_dc_rated'],\n", + " \"temperature_cell\" : df.Tcell,\n", + " \"poa_global_ref\" : 1000,\n", + " \"temperature_cell_ref\": 25,\n", + " \"gamma_pdc\" : meta['gamma_pdc']}\n", + "\n", + "# Calculate the normaliztion, the function also returns the relevant insolation for\n", + "# each point in the normalized PV energy timeseries\n", + "normalized, insolation = rdtools.normalize_with_pvwatts(df.energy, pvwatts_kws)\n", + "\n", + "df['normalized'] = normalized\n", + "df['insolation'] = insolation\n", + "\n", + "# Plot the normalized power time series\n", + "fig, ax = plt.subplots()\n", + "ax.plot(normalized.index, normalized, 'o', alpha = 0.05)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2: Filter\n", + "\n", + "Data filtering is used to exclude data points that represent invalid data, create bias in the analysis, or introduce significant noise.\n", + "\n", + "It can also be useful to remove outages and outliers. Sometimes outages appear as low but non-zero yield. Automatic functions for this are not yet included in `rdtools`. Such filters should be implimented by the analyst if needed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate a collection of boolean masks that can be used\n", + "# to filter the time series\n", + "normalized_mask = rdtools.normalized_filter(df['normalized'])\n", + "poa_mask = rdtools.poa_filter(df['poa'])\n", + "tcell_mask = rdtools.tcell_filter(df['Tcell'])\n", + "clip_mask = rdtools.clip_filter(df['power'])\n", + "\n", + "# filter the time series and keep only the columns needed for the\n", + "# remaining steps\n", + "filtered = df[normalized_mask & poa_mask & tcell_mask & clip_mask]\n", + "filtered = filtered[['insolation', 'normalized']]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(filtered.index, filtered.normalized, 'o', alpha = 0.05)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3: Aggregate\n", + "\n", + "Data is aggregated with an irradiance weighted average. This can be useful, for example with daily aggregation, to reduce the impact of high-error data points in the morning and evening." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "daily = rdtools.aggregation_insol(filtered.normalized, filtered.insolation, frequency = 'D')\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(daily.index, daily, 'o', alpha = 0.1)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4: Degradation calculation\n", + "\n", + "Data is then analyzed to estimate the degradation rate representing the PV system behavior. The results are visualized and statistics are reported, including the 68.2% confidence interval, and the P95 exceedence value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the degradation rate using the YoY method\n", + "yoy_rd, yoy_ci, yoy_info = rdtools.degradation_year_on_year(daily, confidence_level=68.2)\n", + "# Note the default confidence_level of 68.2 is approrpriate if you would like to \n", + "# report a confidence interval analogous to the standard deviation of a normal\n", + "# distribution. The size of the confidence interval is adjustable by setting the\n", + "# confidence_level variable.\n", + "\n", + "# Visualize the results\n", + "\n", + "degradation_fig = rdtools.degradation_summary_plots(yoy_rd, yoy_ci, yoy_info, daily,\n", + " summary_title='Sensor-based degradation results',\n", + " scatter_ymin=0.5, scatter_ymax=1.1,\n", + " hist_xmin=-30, hist_xmax=45)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the confidence interval, the year-on-year method yields an exceedence value (e.g. P95), the degradation rate that was exceeded (slower degradation) with a given probability level. The probability level is set via the `exceedence_prob` keyword in `degradation_year_on_year`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P95 exceedance level is -0.58%/yr\n" + ] + } + ], + "source": [ + "print('The P95 exceedance level is %.2f%%/yr' % yoy_info['exceedance_level'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5: Soiling calculations \n", + "\n", + "This section illustrates how the aggreagated data can be used to estimate soiling losses using the stochastic rate and recovery (SRR) method.1\n", + "\n", + "1M. G. Deceglie, L. Micheli and M. Muller, \"Quantifying Soiling Loss Directly From PV Yield,\" IEEE Journal of Photovoltaics, vol. 8, no. 2, pp. 547-551, March 2018. doi: 10.1109/JPHOTOV.2017.2784682" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the daily insolation, required for the SRR calculation\n", + "daily_insolation = filtered['insolation'].resample('D').sum()\n", + "\n", + "# Perform the SRR calculation\n", + "cl = 68.2\n", + "sr, sr_ci, soiling_info = rdtools.soiling_srr(daily, daily_insolation, confidence_level=cl)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P50 insolation-weighted soiling ratio is 0.973\n" + ] + } + ], + "source": [ + "print('The P50 insolation-weighted soiling ratio is %0.3f'%sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The 68.2 confidence interval for the insolation-weighted soiling ratio is 0.965–0.979\n" + ] + } + ], + "source": [ + "print('The %0.1f confidence interval for the insolation-weighted'\n", + " ' soiling ratio is %0.3f–%0.3f'%(cl, sr_ci[0], sr_ci[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Monte Carlo realizations of soiling profiles\n", + "fig = rdtools.soiling_monte_carlo_plot(soiling_info, daily, profiles=200);" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the slopes for \"valid\" soiling intervals identified,\n", + "# assuming perfect cleaning events\n", + "fig = rdtools.soiling_interval_plot(soiling_info, daily);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
startendslopeslope_lowslope_highinferred_start_lossinferred_end_losslengthvalid
02008-11-13 00:00:00+09:302008-12-11 00:00:00+09:30-0.001403-0.0040200.0000001.0219480.98267028True
12008-12-12 00:00:00+09:302009-01-01 00:00:00+09:30-0.000641-0.0028860.0000000.9902970.97746720True
22009-01-02 00:00:00+09:302009-03-20 00:00:00+09:300.0000000.0000000.0000000.9811100.99576877False
32009-03-21 00:00:00+09:302009-03-24 00:00:00+09:300.0000000.0000000.0000000.9876951.0234333False
42009-03-25 00:00:00+09:302009-05-28 00:00:00+09:30-0.000559-0.000880-0.0002441.0393081.00351064True
\n", + "
" + ], + "text/plain": [ + " start end slope slope_low \\\n", + "0 2008-11-13 00:00:00+09:30 2008-12-11 00:00:00+09:30 -0.001403 -0.004020 \n", + "1 2008-12-12 00:00:00+09:30 2009-01-01 00:00:00+09:30 -0.000641 -0.002886 \n", + "2 2009-01-02 00:00:00+09:30 2009-03-20 00:00:00+09:30 0.000000 0.000000 \n", + "3 2009-03-21 00:00:00+09:30 2009-03-24 00:00:00+09:30 0.000000 0.000000 \n", + "4 2009-03-25 00:00:00+09:30 2009-05-28 00:00:00+09:30 -0.000559 -0.000880 \n", + "\n", + " slope_high inferred_start_loss inferred_end_loss length valid \n", + "0 0.000000 1.021948 0.982670 28 True \n", + "1 0.000000 0.990297 0.977467 20 True \n", + "2 0.000000 0.981110 0.995768 77 False \n", + "3 0.000000 0.987695 1.023433 3 False \n", + "4 -0.000244 1.039308 1.003510 64 True " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# View the first several rows of the soiling interval summary table\n", + "soiling_summary = soiling_info['soiling_interval_summary']\n", + "soiling_summary.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# View a histogram of the valid soiling rates found for the data set\n", + "fig = rdtools.soiling_rate_histogram(soiling_info, bins=15)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## Clear sky workflow\n", + "The clear sky workflow is useful in that it avoids problems due to drift or recalibration of ground-based sensors. We use `pvlib` to model the clear sky irradiance. This is renormalized to align it with ground-based measurements. Finally we use `rdtools.get_clearsky_tamb()` to model the ambient temperature on clear sky days. This modeled ambient temperature is used to model cell temperature with `pvlib`. If high quality amabient temperature data is available, that can be used instead of the modeled ambient; we proceed with the modeled ambient temperature here for illustrative purposes.\n", + "\n", + "In this example, note that we have omitted wind data in the cell temperature calculations for illustrative purposes. Wind data can also be included when the data source is trusted for improved results\n", + "\n", + "**Note that the claculations below rely on some objects from the steps above**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 0: Preliminary Calculations" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the clear sky POA irradiance\n", + "clearsky = loc.get_clearsky(df.index, solar_position=sun)\n", + "# Note: An earlier version of this notebook used pvlib<0.6. In pvlib 0.6, the default \n", + "# behavior of get_clearsky() changed, which affects the results of this example notebook.\n", + "# More details: https://github.com/pvlib/pvlib-python/issues/435\n", + "cs_sky = pvlib.irradiance.isotropic(meta['tilt'], clearsky.dhi)\n", + "cs_beam = pvlib.irradiance.beam_component(meta['tilt'], meta['azimuth'], sun.zenith, sun.azimuth, clearsky.dni)\n", + "df['clearsky_poa'] = cs_beam + cs_sky\n", + "\n", + "# Renormalize the clear sky POA irradiance\n", + "df['clearsky_poa'] = rdtools.irradiance_rescale(df.poa, df.clearsky_poa, method='iterative')\n", + "\n", + "# Calculate the clearsky temperature\n", + "df['clearsky_Tamb'] = rdtools.get_clearsky_tamb(df.index, meta['latitude'], meta['longitude'])\n", + "df['clearsky_Tcell'] = pvlib.temperature.sapm_cell(df.clearsky_poa, df.clearsky_Tamb, 0, **meta['temp_model_params'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 1: Normalize\n", + "Normalize as in step 1 above, but this time using clearsky modeled irradiance and cell temperature" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "clearsky_pvwatts_kws = {\"poa_global\" : df.clearsky_poa,\n", + " \"power_dc_rated\" : meta['power_dc_rated'],\n", + " \"temperature_cell\" :df.clearsky_Tcell,\n", + " \"poa_global_ref\" : 1000,\n", + " \"temperature_cell_ref\": 25,\n", + " \"gamma_pdc\" : meta['gamma_pdc']}\n", + "\n", + "clearsky_normalized, clearsky_insolation = rdtools.normalize_with_pvwatts(df.energy, clearsky_pvwatts_kws)\n", + "\n", + "df['clearsky_normalized'] = clearsky_normalized\n", + "df['clearsky_insolation'] = clearsky_insolation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 2: Filter\n", + "Filter as in step 2 above, but with the addition of a clear sky index (csi) filter so we consider only points well modeled by the clear sky irradiance model." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Perform clearsky filter\n", + "cs_normalized_mask = rdtools.normalized_filter(df['clearsky_normalized'])\n", + "cs_poa_mask = rdtools.poa_filter(df['clearsky_poa'])\n", + "cs_tcell_mask = rdtools.tcell_filter(df['clearsky_Tcell'])\n", + "\n", + "csi_mask = rdtools.csi_filter(df.insolation, df.clearsky_insolation)\n", + "\n", + "\n", + "clearsky_filtered = df[cs_normalized_mask & cs_poa_mask & cs_tcell_mask & clip_mask & csi_mask]\n", + "clearsky_filtered = clearsky_filtered[['clearsky_insolation', 'clearsky_normalized']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 3: Aggregate\n", + "Aggregate the clear sky version of of the filtered data " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "clearsky_daily = rdtools.aggregation_insol(clearsky_filtered.clearsky_normalized, clearsky_filtered.clearsky_insolation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 4: Degradation Calculation\n", + "Estimate the degradation rate and compare to the results obtained with sensors. In this case, we see that irradiance sensor drift may have biased the sensor-based results, a problem that is corrected by the clear sky approach." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P95 exceedance level with the clear sky analysis is -0.35%/yr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the degradation rate using the YoY method\n", + "cs_yoy_rd, cs_yoy_ci, cs_yoy_info = rdtools.degradation_year_on_year(clearsky_daily, confidence_level=68.2)\n", + "# Note the default confidence_level of 68.2 is approrpriate if you would like to \n", + "# report a confidence interval analogous to the standard deviation of a normal\n", + "# distribution. The size of the confidence interval is adjustable by setting the\n", + "# confidence_level variable.\n", + "\n", + "# Visualize the results\n", + "clearsky_fig = rdtools.degradation_summary_plots(cs_yoy_rd, cs_yoy_ci, cs_yoy_info, clearsky_daily,\n", + " summary_title='Clear-sky-based degradation results',\n", + " scatter_ymin=0.5, scatter_ymax=1.1,\n", + " hist_xmin=-30, hist_xmax=45, plot_color='orangered');\n", + "\n", + "print('The P95 exceedance level with the clear sky analysis is %.2f%%/yr' % cs_yoy_info['exceedance_level'])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compare to previous sensor restuls\n", + "degradation_fig" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "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.7.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/degradation_and_soiling_example_pvdaq_4.ipynb b/docs/degradation_and_soiling_example_pvdaq_4.ipynb new file mode 100644 index 00000000..fef481b9 --- /dev/null +++ b/docs/degradation_and_soiling_example_pvdaq_4.ipynb @@ -0,0 +1,859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Degradation and soiling example with clearsky workflow\n", + "\n", + "\n", + "This jupyter notebook is intended to the RdTools analysis workflow. In addition, the notebook demonstrates the effects of changes in the workflow. For a consistent experience, we recommend installing the specific versions of packages used to develop this notebook. This can be achieved in your environment by running `pip install -r requirements.txt` followed by `pip install -r docs/notebook_requirements.txt` from the base directory. (RdTools must also be separately installed.)\n", + "\n", + "The calculations consist of several steps illustrated here:\n", + "
    \n", + "
  1. Import and preliminary calculations
    2. \n", + "
  2. Normalize data using a performance metric
    3. \n", + "
  3. Filter data that creates bias
    4. \n", + "
  4. Aggregate data
    5. \n", + "
  5. Analyze aggregated data to estimate the degradation rate
    6. \n", + "
  6. Analyze aggregated data to estimate the soiling loss
    7. \n", + "
\n", + "\n", + "After demonstrating these steps using sensor data, a modified version of the workflow is illustrated using modeled clear sky irradiance and temperature. The results from the two methods are compared at the end.\n", + "\n", + "This notebook works with data from the NREL PVDAQ `[4] NREL x-Si #1` system. Note that because this system does not experience significant soiling, the dataset contains a synthesized soiling signal for use in the soiling section of the example. This notebook automatically downloads and locally caches the dataset used in this example. The data can also be found on the DuraMAT Datahub (https://datahub.duramat.org/dataset/pvdaq-time-series-with-soiling-signal)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import timedelta\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pvlib\n", + "import rdtools\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Update the style of plots\n", + "import matplotlib\n", + "matplotlib.rcParams.update({'font.size': 12,\n", + " 'figure.figsize': [4.5, 3],\n", + " 'lines.markeredgewidth': 0,\n", + " 'lines.markersize': 2\n", + " })\n", + "# Register time series plotting in pandas > 1.0\n", + "from pandas.plotting import register_matplotlib_converters\n", + "register_matplotlib_converters()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the random seed for numpy to ensure consistent results\n", + "np.random.seed(0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0: Import and preliminary calculations\n", + "\n", + "\n", + "This section prepares the data necessary for an `rdtools` calculation. The first step of the `rdtools` workflow is normalization, which requires a time series of energy yield, a time series of cell temperature, and a time series of irradiance, along with some metadata (see Step 1: Normalize)\n", + "\n", + "The following section loads the data, adjusts units where needed, and renames the critical columns. The ambient temperature sensor data source is converted into estimated cell temperature. This dataset already has plane-of-array irradiance data, so no transposition is necessary.\n", + "\n", + "A common challenge is handling datasets with and without daylight savings time. Make sure to specify a `pytz` timezone that does or does not include daylight savings time as appropriate for your dataset.\n", + "\n", + "The steps of this section may change depending on your data source or the system being considered. Transposition of irradiance and modeling of cell temperature are generally outside the scope of `rdtools`. A variety of tools for these calculations are available in [pvlib](https://github.com/pvlib/pvlib-python)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAASQAAADHCAYAAACwXi50AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eZRsaVXg+9snphxvZt6x5pGimFEpQFsbp36irTwHeE/RRqXbp+89UXtp2/ZSUWx8KrymWxFaQNBWW1GGomnkiQwCBUUx3Kri1nyr6g55h5yHmM989vvjixMZGRkRGZkx5FDnt1ase/OciPOdOHHO/vbe3x5EVUlISEjYD1h7fQIJCQkJMYlASkhI2DckAikhIWHfkAikhISEfUMikBISEvYNiUBKSEjYNyQCKSEhYd8wNIEkIm8QkdMi4orIf2vYfouIqIiUG15vbNgvIvIWEVmtvd4qItL0+c+KSFVEnhCRfzGs75SQkNBf0kMcaw74XeCVwGiL/dOqGrTY/rPADwEvBhT4FHAeeFdt//uB+4B/WXt9SETuUNXl/p5+QkLCoBmahqSqd6vq/wBWd/jRnwLepqpXVPUq8DbgpwFE5NnANwG/raq2qn4YeBh4df/OPCEhYVgMU0PajlkRiTWgX1XVldr25wNnGt53prYt3ndeVUtt9m9CRH4Wo3ExPj7+kuc85zl9PP2EhIRuuP/++1dU9USrfftBIK0ALwW+DhwD3gn8Nca0A5gACg3vLwATNT9S8754//WtBlLV9wDvAbjrrrv09OnTffoKCQkJ3SIis+327blAUtUyEEuGRRF5AzAvIkdUtQiUgSMNHzkClFVVRaR5X7y/REJCwoFjPy77x+UH4pW0RzEO7ZgX17bF+24Tkck2+xMSEg4Qw1z2T4vICJACUiIyUtv2chG5U0QsETkGvB34nKrGpthfAr8sIteLyHXArwD/DUBVn8SYer9dO94PAy8CPjys75WQkNA/hmmy/Sbw2w1//yvgd4CzwO8BJ4Eixqn92ob3vRu4DbN6BvDe2raYH8MIqHXgEvCaZMk/IeFgIs/UAm2JUzshYW8QkftV9a5W+/ajDykhIeEZSiKQEhIS9g2JQEpISNg3JAIpISFh35AIpISEhH1DIpASEhL2DYlASkhI2DckAikhIWHfkAikhISEfUMikBISEvYNiUBKSEjYNyQCKSEhYd+QCKSEhIR9QyKQEhIS9g2JQEpISNg37IdGkd8sIp8SkTURWRaRD4rItQ373yQiflMjydsa9ieNIhMSDgnD1JDiRpF/1rR9BtMJ5BbgZkyB/j9ves/fqepEw+t8w773Aw9iOpb8BqZRZMsWKwkJCfuboZWwVdW7AUTkLuCGhu3/0Pg+EXkH8PlujtnQKPJ7VNUGPiwi/xbTKPJdHT+ckJCw79iPPqRXsLVryKtqJt2jIvJ/NWzfcaPImtl4enk5KbudkLDf2FcCSUReBPwW8KsNmz8APBc4AfwfwG+JSNwEoF2jyElaoKrvUdW7VPWuEycSqy4hYb+xbwSSiDwL+Afgl1T1C/F2VX1MVedUNVTVLwF/BLymtjtpFJmQcIjYFwJJRG4GPg28WVX/apu3K5ubSCaNIvtAFEV7fQoJCfuiUeT1wD8B71TVLY5oEflBEZkRw8uAXwQ+CkmjyH4RRRF+qIlQSthz9kOjSMU0gvxtEanvV9WJ2n9/DBMqkAOuAG9R1b9oOE7SKLJHRARLFBHZ/s0JCQMkaRSZAIBqIpAShkPSKDJhW57JwuiZOinvRxKB1CWqeqhv3MP83TqhqkS6O6f+Qb9m+/H8E4HUBapKGJnXXv6Igxo7fij7ffz9eMM3IyIIiiI7Ot9BXbNhsV/Pv2uBJCITInKDiExs/+7DhYiQsswrZtg/ZBRFA7uB4oeyn2bbfr3hW2Gc+jszWwdxzYaORvvu/DsKJBF5gYj8sYicx0RAXwIKInJORN4hIi8cylnuMVFkfrhG9X5QD1vzMaMoMuYigkbhQG4gVSUIo56+T/Nnd/OQ7wWx9rubz/XrHtipZtbrsePfO4j2X/xZW4EkIu8H/gaYxyzRHweytX9fB1wF/lpE/nYI57lnxDE6QRCgmFnRsqyBPGyNN3kYhoRhiBfUBFIUEqr07QZqvFGjqP3N2c0D0K+HM/5883kcBC1rt+zk2u30OqsqfhC2nCxSlpC2wLL2l9emUxzS36jqx1psXwe+VHv9voj8wEDObJ8gIqAhWCnQCAakoYiI0SowAYpl2yOXSeEHIZlUti4MRbq7gTot48c3tlUzOVKpFFkNSKVSW94XRkrK6ix8RQTRaNO5dfvZ5nMiCgkiyBBhWdaWc+31u7c6927PsR+fa3Wc5u8WRVFLQdHqvZ2IJ9OUZY4Xa/lATdNXLGt/mZ1t725V/Zh0cfer6t/395T2H7G/wA+MxhIEwa5MnHbqc+OsJyIbGksYEGHVNYZ0yur64e50fs3mlKoiVqrt+XUzXiun8E6uT3xOlmUR+F793HZq+u1U44jH6LS/0zl3+95uj9NJW93pOJZlkUmZia7Z1RD4XlfXadja6XYCpyAinxCRXxeRbxORzFDOah8R3+BBEOAFEWHgEyk7XnFr96C0euBSqRS5lJLNZsmmqGsuO3kotxOYjcfq1d9jtMitDtLdHM/3fSqe4vv+jo4TP8DdfpdGc6abiaLTcWJtcLcTVHzuqsYdkBJtqSFtJ6yaERHSKavuYrAsiygMcFwPOxDCwO94nfZiYWI7gfS9wOeAbwU+hhFQnxWR3xGR7xaR0UGf4F4Ta0dBBK7rglikLCGTkvpN080P1mlVpnmmzReKuIFSdTw8P6g71XfCTnxNnd7bzXdrlwuXsqSu8W133LppZlmkJdpkPm53Ds0PahiGXZ9zGIb1hy4ep25Ct/i9Gs+lUfDvRhhFSt1PGJ9HFEUgVsvjdRJW7cZo1FzDMMQNzLg5KySbzXb8/HYriYMQVB2/mareq6p/oKrfDxwF/hnwEeB5wN9i/EmHnnTKAo2o2C5h4G+aEXc0k3YR61KtVrm67lIuFfE8j0LFxQ9CBMXzvK7Ot5tzapydXT9s+WDtZPWt+XPx9QnDcMus3kqjiLWsVsfdTvuwLKvuoPU8j6pnzOpOxA93KpXCkppQC6O6WRNF0Zbfq3GVFdgkzFpdh040ft8wDOsPf6cFE1WtC6tuxoy1RTA+I+ODMpObpDLbXqNW92yj0B6E9rQTF/sUcCNwE6b2NcBn+no2+4z4YYgUPM9jbrXMerFC1fFwvA3NpZt4lG5NCcuykMin6nj4QYjr+aARpXKFlZJntLRt2G6sVn4rjcJN5mnj9+/Gl9I8Xt0kwjwE283qsaZgOy4Vx9/2YWnGsqy6pqShv+148cMdh1W4fojnmzFj86b5d41/61izidissexkcorP1Q/CjePpVod8s9COQnOOjeZmEEZttcL6YkntkGKlSFuQttjW/Gu+txvvj0GFdWwXh/SaWhzSGeAh4MeBC8DPACdrmtOhpTEgMp2yKBYK+L6PJZvNkW6jfDup//HfVipNSn3Wyj6uY5NKpXAch0LVJ/CcHanr7f5uvJksy8IiolhxzMMRBlQcvz5rb+dniB/oZgGHRia6PfC3OMxjAdh8o9u2TRBGVKp2XTPbjVNbrFR3ZlsYbGhDtbHiSSaKopbCuNEEjTWsxu8dP8Dt7of4u4oYsz+TTkEUbNK8Gn1KjduDIMD2jaYcT4ix4G9XPqbZcW/bNl5ojrXdNWqpIUUhXrih1fWb7e7uDwDfBbwNuENVX6uq71TVh3TY7vc9JIyUYrHIuu2ymi+ZH1431PudRrzWZ8gW5lAUBviaIl/IE6oQuFVKtk+pXEE07EogBUFQn/1aCQzYvMLmuB4rJY9qtVr3M4RhiO/7FO1gk4O50Vxo9N00Hjv2z1RtBy8036nx+sQPVqMm5nsuVR8818Hxo037uhH4sUM4bRlB0SlmK36IY00sCCMEJZOS+ipqGLWO4Yk1Etc32msQ1gRvaN5rO27bwNlGjToWgJ4fUHaNZgjGqR9f0/p7a9/fsiw8p1pfNYuP0S6mqPl3932f9bKL69hU3YBK1a6fdysaJ4P4e1uWBVEwsPil7Y76bcBfAT8KzIrIF0Tk90Tk+0SkuXRsR6RNX7bavu8W01OtWnOa39ywT0TkLSKyWnu9VRrubhlwX7YgMKsSTmhRXF3F8wNcz6fsBManFIY7yoOKf1jPDzb5oWKVHSBjKZaVplwuc2l+jbVCmWLFYb3it/UjNQqJUI2ZBEYtD8Owo1mZSqVIq0eEZVR69chkzIJqo4kYm3CxIG303TTe2KomkBOxEA23OGljrSw2s6qOZ85ZzY2esgTHcbrWkOJr6vs+tq9GW2gSgo3EGloQQRj4OF5A1TWCt1Sx6z67dp9Np8xqlRsYDRA117xardbN6uZzbnSi+0GI7RpfpCXUv7dGIX4kRIFXf+AbfUqO4zC/buP7PiMZq66dBWGE43ottblY+IERSMWKQxQGlCtV1stu3TXQzifVylyLJ6y9cGp/qcGpfS3wC8AC8HrgKRF5cAdjtezLJiLHgbuBN2Ic56eBv2t4y88CP4QpTfsi4AeAn2vYP7C+bLG2ICiV4jr5wKJYLRGFARZmZkSjrk2KKDK2vuu6Rm1Xo/YGYe1mDXy80MzwloSUK1WWyw7qVTg6OULouy1npuaZUCOjScUPvh+2Xw2qP8y1aHTfc1mrBOYcowhJZTZpGq18RWFo1Hg/MNHldX+MmtWyVqZBOp2ua4q26xvzqRYQWlhbZs2GfKFYf0+naxpFRsBbloWlAdm01TauKj5nsVJEvmOEMEqpVMLxAgoVF8c1Qr/5vOvmT+xHCnzzcEZqtNdUGiIT0d9Mo3DwfBNC4nkeVTeom8thZOKD3GDzAkbdhAxDbM9c43Q6XT8nx/VYLthbJqt4AnE883s6XkDVdvBD4zOziOoTSjfO6thf1k7r7ge7cWrfiGnqeBTTCaQrVPVuVf0fwGrTrh8BHlXVD6qqA7wJeLGIPKe2/6eAt6nqFVW9ijEffxo29WX7bVW1VfXDwMOYvmw9E/tCIoUj00e57fgoRyenkFTGpHZEStUN8Pxg2x8mXs0qVhyKdkC5XDZLsFFU91OJCGtraywXXZbXC3hBRLW4SjVMs7yySqEa4jgOsHUWi2f0WLjE5xTfbPGrlekWhQGlqmseiCCgULYJgoBMJsORHORyufrNDRtCKX5ARISx7IYTOAhqGkcQtgwJiDUrxGhWpYqN6/ksreZ58uIcc0Ubt7iMr8Z/5vitnbZBEGC7Pq7n1x86OzDntd0kUa1WWS6YcT2nytmL8/iuXV+FCoKAQK36uI2areMZgWIJGxqIWKRTFqPZVFtzRkTq1zBjGX+h77nYvhL6bn2Vzw9Cqq7x8cQCN4ggm81yYjLD6Oho3U0QTzrtYtzigN6K4xtNKIqQyDcCLvCJMCvIsZbUSiONFxyqjreh1Q0ofWonTu0VTMePk8C7geep6g2dPt8lz8f0UgNAVSvAOTZ6q23az+a+awPtyxar54LRXmaOTJmZt5ZXlrWiugreSvtoJI6aHRvJkhGjUVQqlfo+S6BqO1xaKrI8d4nVkk21Uia0Mqwsz7NStCkXVzc0C93q/IRaNLeGRgOo+SHiG6fZJxB/1g+M+aKBW39IgjCiVLEJJFv3IcVCqfHmt227rsVUPCPQMukUUWgeqJS1OWgy1qjESuG5Dr7vs1qoUC6XmV8psLy8yMrKGlhps6Ik1hYfXTyeFxghHwuNVCpFWqJN16aR+AEPw5DltQKlqo/v2iwsr3FmdpnZy1cpV526gBlNa910bRwb2CQE4nOLNcVG4dn4f0s2BFsQGoGQTqcJ3Cp+JNiu8UmlCeqaiOvXvltNOxkfH8f3/bqQjqIIrDQTOauuNTUSRRHZtDHvJPJZKxRZr/gsrORZKzpUq9VNZlirzyMWGvq4oeB5u4+N64btamr/LnAP8P8Cn1fVy30/A9NbrVk6NPZWa+69VgAman6kdn3Zrm81kKq+B9O2m7vuumtbXTO+edaLFe69/yGsdI4TehTfc/HIGvXcymBZ5qGwUum2uUaxc9Z1bBShatuopJjxzRJ1pFAul3l69ir3fs1j+hSM+GXKEYynLa4srnP0GDiOw/j4OKKbV/fMv0a1jyRN5NnI2FTdQWtZ1FX9+kqPRnXzxSkXWB9Nk0lXCSOjIeRGx8mFVbLZ8bowi2d/EXNzlj3IOUaQpQhJp7P4tZUcz/eZHPMJ1GK0dgPHoQChb7NWCQjsIkurBXKMML+8yvlZJTMOC0tLXHvyGJl0iiDcEC5BYISUJZDLpOrCKoz8ekyR7Zpo+mwmXQ+wjLU5NEJDn0qQQoI8VnqG0ZEc6SDACS3W1wtcOzOKWCkzdhCQTqfr318tC1WzKuaHCoSMZNNYIkQqNbMpVx/TDZRs7f31xYwgYK1QZmpyHNexyZc9ZiYdUpKjGhqtZzRyGM2Om3F8n3Qmi2UZf1MQZYk0gGyqbgLGju7GPLg46n0kFaFRyHrJpuz5RG6ZdDpNqVzCC45huz6ZdArLGtl0b4hIvcpELpcjjBwihZLtM5JxOFK7LvH91w8B1VEgqepzOu3vE9v1VmvefwQoq6qKyED7sokIge9x5swZfvdr8KPXuEyMV402EbkEkmUiq4xk04iV6pj8qqqUyhU+8dn7+JaXfqOJBclm6jNh7Bx/6IzLE8DoIlxdhOkMHB9zqfhgr0K5UuXo0aN1U6x5iVlEqJQKkBlj1HVMtYBaLJBHilEJ6zE2kYIAnlNlqehQca+ythAydvwmRnJZAs+m6sOEZ3LLIqx60isYU24i4zA6MlZX533f+FUmchaOlSadsqhWPRjP1c9PNMLKZCBysF2fUrWMHMtx9gmfs2Wj3s4VK8xcWWByfBQ/qpkmUYQbKCkxQoLY0er72F5ILuPjBcbBm05tdaQHXoUIi7FchiweK17AylqeQn6dggPF/Col0pTsY4TiMD6aM0Iu1kQRNDKrf9lMmpT4+JERgCJCShSVFL7voyO5mjnlI5LCccwCSCqVwvdcSq6SS1eNo7lapVjOMDI2QQ6fIPRRaxwwpl1ImjDw66ueWdfjyORE/b6KTb3A90ilRjdML8sihY9YabyaSZhSpWx7iJXF9gMcu0qowvTkGEEYkUmn6vdGSjDmXKhITVvVKMB3bapuirFRY9bHmnM/ko07lR/5RRHpGFsuIjkR+cWezsD0UHtxwzHHgdvZ6K22aT+b+64NtC+b53nc//BZ3vV5Dw+4tAB2tUrFdql6EWuFslGdI902OFJEePSRh/nIQyFnH/06kcJE1jh3Hc/4oS5dXWDOM97/y8BXgLM+FMsQ2VBY2/yDx07MWNWOooiq7bBaCQmcMlEUUXJCbMetmzaN5l0ceuD6IXalyPv+cY3f/3iB1fnzqCqrZZ9LVxcplsqUnQDP8zZVzgwCE6LgeR4Vp2Z6VR1Ktl9f+nY9n9WiXTf7SqWSucFFGB8x5tDSWoFHHj3PB8sm2G12GZYXAubXCxRLZaq2WRlKpVJkUlKPnG9c8WsMoYid641xRJ7nUbCNDy8IAkrlCufmljk3O8cXTi/w+EWYX3GYXywTeA624xqtIfYp1Vbx8qWqEXqOcYhXKhUqtkuh4qIYM96PBNfz67FMQRBQtj1W8ua7pDNZJrPGh1R1A/LrqwRqIaFxPPuRkMYI3Ww2S1rMb1R2ApZXVlkrObiu8fmJiNH4qja2F9bju+JrIiJ4rmOCeV2PDBFPzK+RX1nEdoO6hpyWyFxXWsew+b4JPalUbQLSLK+ub1qd285l0S2dfEjXAOdE5N0i8uMi8hIReXbt39eKyLuBpzA+pW2RNn3ZMKkoLxCRV9f2/xbwkKo+UfvoXwK/LCLXi8h1wK9g2h6hA+7LNj8/zzv/fqku3W46AstVn0qlQrZW0qFRGGyXZpHL5Vi0IV8JeOLCIvNrFeO0dT2IAsbHRuvOsni95CLw1afg0yswl4d8Pg+Y5fiia5yztmdihuISJa7rEmGhUlvCT8mmiOlGn1Lge+TLDg88EPB14HHgk/dUcFyPailPoeJSKNtoFJJOWVsqZ8a+Ggvz0KREGc+l6o71KAxYXcsThiGVSoWHn56vr55lMhlcu8LnHoLPPbBxndaB+SI8dXGdpeUVSs6Gk1eorRr5xn+STllk08ZJnslkjFM5la77OWLSaRNwmkkJvu9TqPosLQfMzhZ44DJ8DVhcNte9UCwxO7+OYxvfThAYk8txHIpOZFYBSw6FQoHVkotjV+u+xtHR0XomfeywB7OiurxWwHE9PM8jl8tRLBbJF4o8ejGgUipgeyFzq2XyhWJ9IaD+wCOEnk2x6lEslfECIyB932elUKVQNUIpRlVxPZ9iucr8aonLc4tcWlzGrhQ5/ajDcsXG923GRrLkLBNu4LgmBMDxAhPOEI8bGEE8v27j+BEjWmWt5NUXWGL6UeK5rcmmqr8uIv8Zs6L1b4AXAtO1++Uh4P8Dfl1Vm1fN2tGyL5uqvklEXg28A/jvGMXgxxre925M37aHa3+/t7YtZmB92WzbpuE54akiTLrguB6jQUQURxPXkm8hqq+WNRPPREvAahFcWebkdI4gmGJhtcTRqQnuu/dpWkUZxX3Fp8CssGAevrHAJpcbIV+qkkmnyKoRONm0WXkJfZflgs1INs1YzsdKpclkMuSyRjOJKxg4foTd4M/MjML6+jpVH6qVAnBsY1UsUkQ2tCzPqeJmJ+pO+ZBJsiklH0S4no9tB+Sd0ERhBwELRY+ThQLHpieJooizZ2c3XeMU5od01mEuBXNrJZ47NcX4yKTxX5SrqKTIpi1UwPMDk27ihhw9MkYum2Es6xKohe8b30gqZcwoN0pBEOC7Plcuz/GZSxBgKg0C3LcA3zxivsfVUok7rp8iOzJGKpsl9DzSmSxedY28HeHa6xyfynF1fonsDdeRzdhYk8cIKnncMI4pUvLVgIkRn2Ihz0rRIXCuMDZxBIuIK6s2F5+Y48ISrK8vcur4DGHgY4daT7h1Pb/ueyxVXYJA0bTxCRVKFSbHcvihMpnVTaEAQWC07krVplB2ePLcJT73dbhxBp4uwPPyMDYTC58UVPKcOj6DoFQdo42mUuamCCKzYDCWjojCgKIdML+8yp03ztTNUEvMCi+p3gImt/MhrQD/qfbqCVV9E2ZJv9W+TwMt/VVqRO6/r71a7b8IfEev59eK5pWaLwPXXgH7Zo9grQiqjI2NAWxoHx2WfGcvzuEA9z4BL7jd59qTLtVqlUjSBHaRG26bgvPNPvoNTkA9KtjxAhxfiaKqMcciJZNOUa465ItlbMckTz558RK3XncK100TSZqxXJpcNlNfjreIcKplFhrGOToDa5WAhcVl1iplVtbyzExPoa5DqiYQjcZjEoG9IGJiJI3t+Lh2hSibq2sV2WyWEfEZHR0lnU5z3eQS4xOTOF5AqWIzv7D5O4aYQLdLEcwsmcjtSNImctq1Wa/4TGR9RrPjFCsOFdtlvVghCCOumRnj/OwVjh8/jutUcLMzqOMzmjMCfDyjLK/kmVsp8vEzMNt0fR8FXhaA4wUsr5YolqscPXYcz/PwNUUY2MzMzCCs4aSMdnd5ucBENoPKNQgrLJd8ysUi0+M3MzqSYzRjHN3LFWV16SqPrUPgL/LS5x9lbmGNNc88hEGYYn6tQuC5ZEfGsdSYU2UnIPKNGVxyQkZTHmGQolwuUwpz3KgmvMIXNat0teteqrr1mKNzT5zlvjNm+Xl23cza5y7BLRORWemMXCJJ47s2YyNTCL6ZgGiIBheth1fML60SWrWAYT8iXTMN/VBJp6Ithf52wjA71x44Jicnt2z7SAm+YWWVlTW44YYRrj0+SRRNUqwak+aIZbX8QaIoYuLIKGBjAU+egxfeWmBs7HZG7AJOaPG5L7QXRgAKHJmcqAfK5YtljkyMoVFIJmuW2lfzJZZW1hkdy+JX1vnwPxX4+R8awZo6hh+49ZkXjHArlSpcurLA2YZx/ut5eP6ti+TLDucvK+OpWU4dmyJKjXAUYXJ81PhLMmky6pLLjACwnM8zM5kjlVFEI9ZXF5kZu45A0uahDkJGJqap2C6j2RRPXrjCo1e3fk8AG7MysbJaxnXduknqOjYjmfF6jlxaInzXxguFp54+xx9/eI5XvvQiJ665hdst4dTJE6QsY6YtrBY58+Qc5y9WN2lljXz9Ctx0vMjsIuTLrolNGh3HCj0kk8VyipRtj6W1IlHgsVyIuOOkQ6VSwYoyzC+uc9+Di1x/aoYbrj1JWiJyuTFS6rO+Dn9z3mSnX728xq23waNzxm8yv+oTpVaZmpjAIqzn4wW+R7FUNTFv1SqrJZ+F4iKqEVPTM2QyU7iOTRTliKTKielx0lFEuerguh4PnnmYTz8CWYUi5gXwGQd+Ig+247JUBtctMj42yuiIWUlLWULV8UilUnUf1OzCOuqVsIMUbrlMNjcCoUcqM1oLaegutakTiUDqQKHQWkD8+WlwgdvPO0yPrzI+Pm7MiEyaybFcy8/Yts1i0edazAy1BrzocoUX31nE0zQf+dADfGj7RH6uzC9x8sTxer5WRkLIZEwwne2wsFqkWC0Tao4vfKXKfcA3fXmR7/jOcTzPx3Ecwslxspk0kVfgwtVl7n1E8ZvG+bXPlHn97fDggnHmX3d8npkT13BkLGuWlsXC9XyqnlHVLY1YWFnhOdfPkFKL9fw6H//aEq8dSTOSHq0F/Ck5KwRJUywWOfPUVb7U4jvmAAdzjUsuLK0WmBgfYyyXNrE3YUBIDg2qRFisl32C0GVucZX7QrjtnDJ79QLXvPLFdb9KFEXMXrzA8orDuYUWg9Y4C1y8BJUA3GoeN7wRv1IlnU5TrpRYK1R4+KkLqAUpN6Jqw9xakaOhRerUSc4/ucgXF+Dljz/C1MRLmc+75NJmAimWjUB4pPaaOm9iVI4C0+dh8ojN9MQ4tm0qSliWRblcZjHvcOJIlpGMxajlUshD5ajD9JTRjP0QZjIRQeCbBQrXp1C28ewyVxeVe122/L4FYG4Vio7iVwtIZgz1bZAjOJ5L1orwNI3lmkBeu5gp2IEAACAASURBVJhnrVBidb1K5EPuGCwvL5MduRlcl9GRXD06vpeVtv1V4XufceJE60D0JUzng3ng4uVlbNfHtu2OTr10Ok1gB9yAEUhjwFjObI/cMh/twhO3CLgNyZ+eH5gAyNCo7a4fUq2UyWbSWNFG+Y5LC/CVM+f5p69d5spyEccxqzTLRZcLF69wroXjqgz88TnzgH4JWFtfZjQjZNMWERZhUCvxoSYOZ21tjcfn4cLlq8ytVvjqV6/woXm4enWOo5MZQhWWCzbFUhnLspibm+OPHoNKi+/pYh6gU0A6gmLFfK5cqVKwQ5N/ZldxQ2EkFTGWsyiUClyegxFgZQ0+fBkef+gMbqCUqi5PPX2O93/eIV/a0BJaUQUcD7QEVnqEcrkMQOi7xkmcX6PkRizNRYQC1QL87WlYL5eoFla48fosV4FcdgQvhGrV+M7ypSoPLm0eK57u1oC8CxKGVG2bq0WHK1eumAJ9QUQYOPhOhQvz65xfqHB1FZbX8xSrZtne9kx+5WrJRJ2rKoViidWCubrNwijm0QL4lTVGxibJiEtAGsdxzIqdr3iug+sbZ3zRBa9c5fxVcH2wl2FsfAINXLCMXrOT4nHt2FZDqgUg3grMqur2NR0OEY1Z7o1Ua/+eA8pqNKnUyCQjDbWgm7l06RJvfmTj7yVAFBy/Fj7QxfmcA8qVYj29IAz8epqGaEgxv85SqYpddln04J6axvUx4GOPmf+/4oVL5HK3GKdosYTjmQdiOz5/L9x2h1lJFNfB9hX1Tb6b69hIKkN11Wgil69e5W01B82XH4DJE0WuPzFFfm2Fsm8xml/hntP5juMVMS1unpiDML3M+EgWOTGDpQHlqsNKvozthYznUqytrvCP9wXcW/vsldBE2hZt44MSzbCwuMTTwPTi9rPwStlc69m5RcanjiFSwfECLl1dwvM88qvw1BycuWJWYADe9ZWQV92+xvqsWak7/XCFFzzXI5c2fpgPfGJpU7pBM6sY53HVrlJYDyhMjFIqFggiWF1bJ/LHWVjOIyFkU6AKge+SSh0hbQWkJIWqZ0IJKmUWVws8fWGdTk/sU8CKA6WlOaanRlldW2dyNGNiqVzzm1qWEHgOc/MLPHgWHvTh2jK86Daz8DE9PU1aIlQtk05jbV/7qhPbCqRaAOLDbEROJzQQODA5lsMJAzy/fULnz/zZU1u2fflh+IZnz3PmiYWuIjkVePJsiVe8zDgwi2WH0miKlYKN4zisl2yWVx0uX4SrntHgmvnKVwu85BtNhvrXH3mauQXoLBoMVg48u4zqVM089AicCgurq4ShT2gXmfPh8rzD157Y+FxuAh44O8exsRQeOcrFBXJMcKaD2QTmoZ4D3BJ4F+DGU3muOTFD1opYKznMLS6jGpBKZShV3E3prLF/6PJ5WH1BAdf1mJocZxSHSODRbVamv45xrrsOZPHwPcgXbZ66vMjMuEUpD18FZho+swB87Rw8fxwIQMZgYXmN0DrC6dMP8Pltru8icHkRxsYDfB9Cp0qgM6zl81xZLVMplZnPw9E0ZAQKZZhbusqJqREuXl7iwUXIjsGtJ4+QtyM++4V17g82Kim2I79UpWKBt2oj1io3XnOMjIZUvDRB6DCeUS7PrXD6UY/P+saUXgBuXgPHD8nn84xkjuKHSrFc5dSxqcEKpBoPAs8GntjujYeJbmIqBKi6AesVn7IdcN0Jd0v+ExgzrZl7gW86s8B/frr7c3r4otHIfD+kWK5wrpqn5CqqEeq7XDgHXwnbaz2nlyFfdrh8/iwffRge63LcggsLq+tcc/J4LcPcZ229zKW5CuOjaSynwizwsSc2P6iPLcP8Mtx53SpV28EOU3z1zBJf7XLcVeCrVfguzyYKPNaLFXzXZrVY4ci4URVKRa3HhDRydwVS956nCrzkWuMo/2QXYTKrmJykyIKnLi8yMXGEoJpnvgBrqxH3VY0Z1GSBcRnwK3AncM0MjE1O460skO+8VgEYB/76OpTykJ4G33PIr6/iuT4rK5CbhgtzsJqBog+LKzA2CTjneNvDEK8H3/L4E6ApPl6z2LeR+ywVaiadD1HaZr1QwotM3aXpmaNUbZe5tSoPFtmkxX8sD99ZrFL113ji7JPcetP1FF2L6YmRljl13dLtJz8HfEJMHaPLsFEsRlX/rM1nDjzdlFFdXcHU0HFDMg25Pc1cw9abwwPeuwNhBPBp4BeWlwmzUzx1YYHJqQxpAkJfKeTh/g7CCEwA4HqhhGRGeWwHJdFngbNXC9xyaoVqYDE2kmX28lWWynBTscCRjFBFebzpc7FJ86efqXLzUciFER/s4gFtZB04PxuxtvwkTI1SXLKxI0iFIWOjEfNrWxMawZh9T14yPqnKZZMd3i1lYH4eMtmqWdEazWKXKqwXW/u9wAiyVcwktVaA808/ySMLVZ7sMm/gfNVoZicqcCkbcLW4gjrwwALkQhMvddY3Gu31wEQJMl/fEEYAi5dhudC9Z+WeRbgOE49VCeHlt5e5su5je1UsDcmNjHDxsikT20gIXF0ssLRc4INL8N0T53n+8+GOG2YYHx/vevxmuhVI34o5p29v2q401Tc6TIyMjGz7nvsL8NL1dTK5cU6O5drGYNxI69lqh88mAJcvX+HYqYj5IkjoMzMtPH4Jnl7dOmu34i1//ijP21F5PTgPfPJxeO6pBUoyymhQZn4tZHUJvFssVtY7dzkJgU+tGS1lN5y+DCdOwok5m0sVWI/g1qMwlVLu6SCBFWNetam31pGHlmFqOmRyVLl0dZ3ZvAnc3O43U+ALT0HGqvLOs/ANXY5XwpjZAXCjA8dHYPaCiZ5PLcOVhvdexfjCzjYd46OXYSdz3AWMALWA0TKs5Iu4LlxZdElJgYlshUq19WfvedQIwwrwP8vw3KD3XLauBJKqfmdPoxxQRkdHuQ7jy2jH08CVqw7X32BxZDTd0lwDeNE4fK3d1LpDPvRF+PHvc7myCIU03BEoF1aN76Mb7gXu7bTU1IangYcedpi8xiGThkefNg9fKojQbe7DRzrv3hYbqCzBddfDeskI3uyaOW4ns+SLuxzPwoyRL8LoSJXHnjamQbcpAA8CD9ekRbe/yxWMMFoB5pZhLAMXakp6q3CtVlPADhVuwEw2zwXsEHy1mMhZZC1YXXOYvuFo2wWXLwM/KNSF/ezX4eiPHN3FGWzQtfdJRI6JyOtE5Fdrf18nIv2oh7RvsSyLW7t43z3n4OzVKquFSlszr42c2hV3TIKkMlyJ4HEPLi/B/f07fEe+ugqeD8UVeELNuItVeEuvEmcbHsOYbrZr4pQWMaVFzw1ovIiaibRofGDrNdVuJ4/bzvqmGC36Woy56ASwsLYhAAfdb+wcRojOzlbx/JDHZ+Gxq/DgmTXu6/C5jzZonp8L4fTp0z2dR1cCSUS+HaMd/gQm+RXgDuBPehp9n+O6Lk928b4HAGw61tYe7WNLzePHoVRYZxUza19oo1IPgoeAfBkKjtEcbeC9T+zeFNsJFeCJFeMH638159bMAvmSSXJeprsQid1yFSMIXeBJ4FK5tWY0CLza69FZmJ21mffhchEuduMDqLHARq7lbulWQ/pD4EdV9XvZEPxfAV7W0+j7nGq12vWN/96rcGX+UtvWMk43gUZdMjVl8q0qmAfzof4delsUKORNlG9Md+0re+cCfaorswMWgFJls/9mUBxlw2FewQj5YQneGD+C5YoRwE9jFlG65WXAqVOnehq/W6f2LaoaN4WMr5G3g88fSLLZ7I5C2f/0noB//k2llqsMudYZJbvi8mWYX9u7GNWvVKGPFuiOGJbwa+Te7d/SF5Ywzn8wwbfNK1vD4GmgsL4R/LsTXngzPS35Q/ca0mMi8sqmbf8CWoZ/HBpEZEcC6UngscdaR/YcO9aXUwKMcPvIsKfOBpYY/sy9lwxLCDbfa12kNvadq2ytgtAtI+neBVK3n/4V4O9F5OPAaK0426uAH+xp9H1OKpVihu2DyxqZnW3tTTmyw2X2Tjw2t/cCYYhuq2cM43QXNT9odutAd93e2yJ1pQCo6pfZKA37Zxht8mWq+rWeRq8hIuWmVygif1zbd4uIaNP+NzZ8VqRDI8lesG27qxyzRtpNENU+PsH7IYdnPzw4h40+uhn3hKrXXTBxJ7rSkERkqtYT7a09jdYGVZ1oGGscs6r7waa3Tatqq2/b2EhSgU9hQive1et5eZ7H4g4/0yYfly5azXfNrTfROhcl4UBz0AVSqbK1ueZO6dZFsiAiD4rIH4rID4tIHz0iW3gNxk3xhe3eWKNtI8leyeVyrfspdeCmm1p7rycmWm7eFW3KNCUccPp4i+wJ6fQAu440MYPxI+WBXwRmReRhEXlHT6O35qeAv9StxuisiFwRkT8X0347plMjyU3stFGk7/s7XumYmppqub2fGlI//VF7zV6t1u1HOiff7H/iLse90K0PyVHVf8KYbL+PKbJ/E0ab6RsichMmX+4vGjavAC/FVFJ4CcaF8tcN+zs1ktyEqr5HVe9S1bvaFV9rJJ1O79hfE9fYbub66/unVF4aRLvOPaJd8bBnIgd9oSCIWncM3gndRmr/gYjchyk/8q8xkebfoqrX9DT6Vn4S+KKq1hUTVS2r6mlVDVR1EXgD8D0iEusJbRtJ9noypvfWBhamImEn2pW9LZX60rsSgBsPUcJO/5sxJ+wVa/ZGe/jd0q3J9gZM04s/Af4IeI+qdltKZyf8JJu1o1bEgia+lzs1kuwJ3/e3ZHZv53hsV5yq19KejbSxCg8kfcyoOfD0lpa69xT6kDze7VMyDbwOY+b+Jsaf8ykR+c3eT8EgIv8MU+blg03bXy4id4qIVXOmvx34nKrGsqJtI8leGR8fp9Gw60YZbVcLppcaMY0IMD3dl0PtC7Yv8HLw6dj+uYED70PK0lMLJOjehxSo6n3AezCNGu/GpK68seMHd8ZPAXerarNtcxvwCUy5mEcwAayvbdj/bkzZ6Idr+z/O5kaSPbGTlY9j0Lb8SK/OvvpxgKNHpw/8ikzMXiXADLO7RXOkd7uxD3oe1smp9j7Ubuk2DuntGGfzHZiqD/dgHNqtutjsClX9uTbb3w+8v8PnOjaS7IVcLlef3UYwauICJqK2lXaaxuS/taJXZ1/MCKYKwV6kFQyCvRJIYxjn417Q7k446P40N2rfGKNbuhXKa8C/Be5T1YMev9U15XK5Xo9mmo0ytO1M5WtpH6kat9PplaOYSpYp7EOxQrVXKTDDTNJtqGHWkb1IHO4nxybbT8jd0m3FyDeBWZYXkeuBq6p66GOFgyCoX6BTbNRdGaG9c7tVt1swaSh9OSdMBHncTPGgM0F7AT9Ihvnwp+iuWNtB15C8aEiR2iJyjYh8HlOd4G7gaRG5p+ZEPrTkcjmmgeMYx1Vcq6qdIEjRXvD4fn+Mkzi+Yabjuw4OOQ5/cGS32V1ZDva1WFw2k2UvdOvbexcmAnpGVa/FPA8P0od8sf1MJpNhEnORPIzAAeNDakVI7zb0dozUzmsnHTT2M0WeecGR7VYW1znY18J0de9NpHbrQ/o24FpV9QFUtSIi/57hVdjcE4IgYAmjEc2w4YBtp1pXaf+D9Cv/LIWJID/IM2kjz8SqATeztVsI7I0w6ta/1RV+7wKpWw1pHXhe07Y7OeT309LSEpcxs3iJjdWRdgLpOto79dq4lnaMA+TzeQ5ROtszjl00fOmanYqD3qKGNnP8mt5Xk7vVkN4KfFpE3ocpKHcz8Hr6G4e075iensa0/quZY7XtR6Bl62uL9oFhbp/W6ceB6667juiQ1B/ptEBwWBjDPPjxPdMuIi1L7872nWpZvVUv2kzKGlK2v6r+KfCjGP/uq2r/vlZV39PT6PucMAxb+o3a1QkIab/s33tmnSGNybHbD0Xa+sFhF0YpTM5V48zfLqi1H7fIXmYV5bJDaBQpItOYaOmv1TL+nzGEYVj3G7n0lubQRRPcrshg8uKG0XYooXdCjObTqCC3i2XO0LsfaS9LZR2dGbCGJCLfj3FcnwauiMgzqoNto4Z0DRvqbTu1+tTR9n2pxsZ6CxiLcTGOw+2LpxwMYs2zn76M7WjULgeVrhFrQUItdqxhX7si+lUO9rJ/vjD4mtpvBn4Nc31/C/h/ehrtgDE1NVW/YatsZGO3neEy7WeIbn+o7R6QkM2a20EnDooc5vdp/CUGFYwYm6Lp2qtxmmoXCDrKwV72nxwdfBuk21T1HapaBd4JPKun0Q4Y5XK57oAUzM0yAZxs8/5q1D4wstsfajsnY4QRegc9M7yZYUYpNwqEPrbL20T8OypbH7J2ZUauB57d47jD1DSbyeQGX6Ctvr9WYP+gJyTviMnJyfoFKGEEkUPri2YBYbV9HEavM0dMiEmune/L0YZLmvaCZ5g5bY0a7qCdwHGt5cZFkXaTTp7Wq7c7YaeOgd5y8zfTjzLN2z0lYyJyT8Pfk01/o6qv6P009ieNYfBjmGCsgI0UkkYiTLZzu9D5fhVoi0MLTrKzfnH7gX4uMfdCow67g9b1u2IZI/Qay9O202Iser9GO40u6WdOXz/yx7cTSP+m6e/39T5ka0Tkc8A3s/GbXFXVO2v7vhtjMt4EfAX4aVWdre0T4A+An2k4x1/rVwnb2KYP2Vhla6eURkF7wdNrFnRMiBFIh6hGG6MYDWlYIQDjbGgig/bZ5DAT2QgbAZHthIYy/Iz/fprKo1MDLj+iqtuVk+03b1DV9zZuqHUYuRsjcD6GcbT/HUZ4wQD7smUymfpDkmJDELV7cDpFzbvbREbm6G52CzFa2GoX792PpNjqwLYxfpVhCaT+VTffngAjjBoFTTuhU4aewzlG2FmzgL4KZG94qSN7yY8Aj6rqB2u1mN4EvFhEnlPbP7C+bJ7n1R8ej40buZWGNAKMdijjuJ0PKR5nu58z4mBrSO3cDGsDHLM5iHTQ1TYbtQ4P85s1PmjtHrp+xJbtZQmTUIfUdWSI/L6IrIjIvSLyHbVtm/quqWoF0/Xk+a3208e+bHFtlzjsv5MNGAKT2falarcr7RnbqdvNWCXMj35Ylv1j+lNxvDXNGsOgVtZiGoXCOEbQ5Nh42Np9134Y9a38U8OqWz6WG1JN7SHxa5iI8Osxtbs/JiK3s7XvGrW/44lvYH3ZstksaYywWaF9QBvUNJcOSlA+35885DywurrKQWzN1kr7i8X0IAVs87iD9hs16ggpTFBtjo0JrZ2A6If/qFXibj9X0jpxbGak58WbfSOQVPUrqlpSVbfmu7oX+Jds7bsGm/NbB9aXTUQ2zVqdZrAQyEj7GaJdJclmtluGHscEbLaLhdrPtNIMqrXtg/QfNd/kg8y2b2aCDY0sviGH/dB1cgP0y8QTIPS9wWpIIvLTIvK3bfa9X0T+VU+jd0Yx33NT3zURGQduZ6P32sD6smUymfoPFhdpa0cK0HT7VYZuVx+2y0VygSNHjgzc7BgE7QTBoEvY7mVH2BxmImv0Dw27Y0wn7bNf8V+K0QwHXcL2/wTe0mbfHwA/39PoNURkWkReKSIjIpIWkZ8AXgH8I/AR4AUi8moRGcGksDykqk/UPj6wvmxBENR9O9u56iappQm0cV6PdMiu3cksZQELCwsHssHifooujwX6oK9jhJmsrKZtw2RoGmEU9WyybReH9CxVfbDVDlU9IyJ39DT6Bhngd4HnYAT6E8APqepZABF5NfAO4L9j4pB+rOGz78b4nh6u/f1e+tSXTUTqWtF2tWq2W7J3nPZGyU5mqQzG/Fs/NI2QDEcYrikVX71BV03IYzrWNBoy/Q47aKwS0KpiwLBimyr24Au0pUTkqKpuWZUVkaP0KXVGVZeBl3bY/2mMsGq1b2B92WzbRjBfcgZY7PDeSUAy7esh9St1JIMZ4xB10waMH2mYAmmYlDFm6ShGAPbbqR4LIWsAx94JV+YHb7J9CfjXbfa9Hrivp9H3OSMjI4xhfvDtfDYFIHDaC55+tUEq0V7oHVSyDC5Ycbul9EEviY9hHrIMGw9bv8eMfWTRLo7dz0J/xRAqld48gttN278DfEZEbgI+DMxj+iG+GhN8+F09jX4ACDCzznaX2QKmOqgtJg6p9/JZAUboddLW9ivtzF6Pwc3sHp0Lnw3a8J2ovRqDIweVP2ex89XKfk4EGe09RaqjhqSqXwW+B/hG4DMY385nan+/UlVP9zT6PseyLFIYVXu7mSQDRG770Pl+aTV5TG2lg1j6tZMvY5DZ/p2E3aCrDMQm/wgbD9s1Ax5zr4jCIZSwVdX7gH8uIqMYV8q6qtoAImKp6n5aPOkrjuPUC2xdB1zs8N4MEKbaZ/v3q1/bOFAqlfa07s1B4wTt66APmhk2ctni32xQ6R17/SCOjA0xdURVbVWdU1VbRF4oIv8JuNLT6PuckZERyhi1/tw2710FfL99ZcheA8ZiKsDExETSBmkH9KEqxq7xMPdPgQ1N7bA+NGINvoTtxmAiJ0Tkl0TkAeDrwF3AL/U0+j7Htm3GMTPadmp2Gih0WCbqNHNcu4NzmsD86HsZ7HeQyAKnOuwfZDLqMeDa7EbGf7ysMSjtdi8Ta8FkKvS6mtzx0yKSAf5XjAP7lcDTwPsxfdn+d1UddH2rPeXIkSNEzJNle9s2wBRoa2eadZo5dmLMjWB8W4ctuXZQCEZLiZfcmxmkDykCSp65N1YaxhrUGmlzd5OY9ADH3DR+H7KDt9OQFjFBhmeBb1bV56nqmxl+Hak9oVwuU8Y4krtxIqe1vVP7yJH2RtbKDs6pQu+xHoedETa0BRcjCPYiUGIdY56dwwjD+FcbVB5iq6jzIwyvV1u+NPg4pIcwgaYvB14qIjM9jXbAKJXMomhEdze0lWuvIVWr/TGybGB8fPyZVdx8h/hs1nwy7F3x+zJGODb++oMyrdrVkxhWsOT4xIB9SKr6HZhE1k8C/w5YEJGPYRZ7DnILqa5odER3E9bol1vnrEVRRLnan4X6NLCysjLUqocHjeY5Wti7DrmtivwP6lxaBUWWGZ45E1bb1wPrlm2d2qo6q6pvVtU7gO/GBEdGwBkReWtPo+9zGs2sbm4iO2yvCU1MbOR49zJbx4GRV3s4xjONvVoOT7PRpaYxsHZQ9YlaaUIRw3N2pzNDXGUDUNUvqurPYhadfgF4YU+j73Ma0z26uannC62TaC3Lwmo4QvMMvlPzq1I5XIm1g2avlv3jvmElNqewDEpDaifohmXe71kJW1V1VPX9qvp9PY2+z2kMg+/GPq3QfobolO0fsLMfYnJy9NAl1w6SvRTfDrXGDJhZvJ+5Y820M82GVRAul+m93de+qRi5H2nsFNJNY8ZJWufyRFGEF3SeOXYyr1y+bPchK+6Zw3HMhBKvyAwzXudaNgqyhZgVoksDGuvmNtuPt9neb7xU54m3GxKB1IFGB3U3IRZ5Wmf1W5ZFLtO/dZ5OSbwJrWmslTPMLrk2G6ZUGqNFD6La5+2YJf7mu2yM4dXUzkQDTq4dFiKSE5H3icisiJRE5EER+b7avltEREWk3PB6Y8NnRUTeIiKrtddbWxX43w2NCbHdrFScpb2GtLreP52meFgLBw2IY2wWDMPEY0MA2gyusoFTO3azf7LK4Dscxxpgye49iXxfCCTM5HEZ+HZMHNcbgQ+IyC0N75lW1Yna680N2xsbRb4I+AHg5/pxUu0SZduhwMWLF7dsj6KIySljMAi9Oxm77BeQUGMF86CWGJ6DNyYufwIbnWkHsRIU0tpZPsrga3jHArfiHhKBpKoVVX2Tql5U1UhV/x64ALyki48PrFHkbpYwx8e39tZIpVJkLHMspXeVfW2QXRUPIXdg8tlOYPx8Nw1x7JnamMKGn3AQJmNjZ+VGMm2295NYBGWiIcQh7QUicgp4Npu7h8yKyBUR+fNae+2YgTWK3E3JkFarDCLC2KjxR42xtafTTunRb/iMI40RCouYrPth9rSzMUIhFkI5BmeytdJNinTuJ9gPnlX797obB586MnRqCb1/DfxFrbPICqbe9s0YjWmytj9mYI0ir7lm56W0WpUZUVWqtpEiVUypkl4434cn6tCH2TewhFmUiCs3DmvVCcwDFq+qTdb+HoQLMGDwDQtakWWj1vy5pw7Zsr+IWMBfYUztNwCoallVT6tqoKqLte3fIyKxojGwRpGLizsvFNsqUjsMQ/xoQz72Gsp/xy09HoC9LQa/F0yysVI6rNbSYAR/XP7kFINzrI+yNxnvHhuxVWF6537XZvaNQKppNO/D/G6vVtV2z0wsaOInfGCNIndTVG16errlcVYW1/txSgD0GAz7jGMFCGSjvvWgG1M2sgTM1f5fxZhWg8hDrLI3DTEF4+wFmM0frjikPwGeC7wqLpELICIvF5E7RcQSkWPA24HPqWpspg2sUWQflKz6caw+pps/OajIukNMKEY7mcCUIx4Wc2wIwLOY1bBBpLJU2JuI9MYnZJrODVG7YV9UsRCRmzFL9S6mokC86+cwZv/vYcrIFIFPAa9t+PjAGkXupvpdsUWQkGVZTIyl6NzUuHt69UE90zgFlCNz8yww2PSN7QgYzKpX8521XWPTQZCj98DIfSGQVHWWzhH97+/w2YE1itxNfGVcQ6kRVeXEyVNsKO+9kaz674wyxkyKr/5eNkioYgTkoNtY7YU/6TyHy2TbdzTmsnXLDTfcsGWbiBAG/XMjtyvEldCaiM1TwV6sRjWyL7SAATBK740iE4HUgd34kNqVsC2X++c5uL1vR3pm0Kwt7LVAOqzFY0Jgssc0gkQgdWA3YfBLS637HvSzDvZhbaMzKJqNiL3uTLGTGuoHiYhDkjqyX9mdQNpqUEVRBFb/FPVnRIeFPtKY6Z8wOC6T+JAGytQu6ny0ihGyLItSoX9RIomGtDMy9Gt9M6ETHr03s0gEUgeWl3euXI+Pt04dST+TcjX2GXvVRvuZxnXA2FhvseiJQOrALhbZWmb7mKSlpAAACllJREFUiwiZdHKp94puqn0m7I7G6TdD4tQeKCdP7jwvv12R8+PHh5nSmZAwHBpN4RWG3HXkmcZuEgXb/SC9xmf0k1YdThMSeiVNIpAGym5W2RYWtgoeVWX20v4RSHsdh5NwOAmA2dneqi8lAqkDo6M71yXybcKoWxQBSEg4VGRpnamwExKB1IHdaEjtHOHj44mhlHC4eWl2d5N4I4lA6kC7NJBOHDvWevvycmIoJRxuKt4hLGG7nzh7dufFRj/zyNZtURTx4Jmt2xMSDhOr7C4hvZFDIZBE5KiIfEREKrXebj/ej+MWdtFK7b4W24Ig4KvD7E6YkLAHBPQeGHlYKiG8ExO5fgr4BuDjInJGVXsqZbu6i0poraKN0uk0F3s5kYSEA8AsybI/IjIOvBp4Y60hwBeB/wm8rtdjf3kXpf1a5ZmtrBzW/O6EhA1KwKOP9lbOXvpVN3qvEJFvBL6kqqMN2/4d8O2q+qqm9/4sptMtwJ2YMseNHKepOkR65rrbdnI+wfrc+ZY7UulM+sjJG1t+xnVJ76DBXrA+d36n59WPcftFMu7hHDNyyuuRU02hwXYz8M2q2rIP2WEw2Zr7slH7e0tSjaq+B3hPuwOJyGlVvau/p7c9InLaryTjJuMe7DHjcXt5hg68ycbWvmzU/h5Et5mEhIQBchgE0pNAWkTuaNjWt95sCQkJw+PACyRVrQB3A/9RRMZF5FuBH8R0wN0pbc25AZOMm4x7GMbsedwD79QGE4cE/Bnwv2Dis/6Dqv7N3p5VQkLCTjkUAikhIeFwcOBNtoSEhMNDIpASEhL2DYlASkhI2Dc8YwSSiBxp+L8McdzUsMesjTfW8P9hft+jIpLeg3GfKyLXDHNcEfnnIvKSYYzVNO53ichrRGSoz6+IvEJE/ouI3DqoMQ69QBKR60Xkk8DdIvIBEbl+iOP+IfC/AeiQVg9E5CYR+TDwlyLyPhGZGsbYInKjiPw98NfA34nIDUP8zq/FxJ29DgZ/rWvf9R+BDwBDqwVaE/YfBz6M6Tq0tcXNYMa9UUQ+AfwT8EvAzuvydMmhFki1xNu/BS5iLuQM8F+BHxjwuK8CPgn8JPCdIvKs2vaBztwi8nrgy5jE63cC3wi8b9Bji8h/AO4HLgA/BdwK/JfavmHcY3cCjwO3ici31cYdyPcVkd8AngCeVtVrVfUzgxinDa8HCqo6o6pvV9VS7ZwG+du+B3gEk/eZAT4PvKrjh3rgUAsk4A5M66jfqJUi+WFgDvhREbl9gONOYx7I1wEnge+Fwc7cNTPpWZiqB7+sqp8Fvh/4IRG5bsBagwv8oKr+gqouYYTTSRERVd1FzYTuaBB2K8DXMBrD94jIhKrqgB7UlwGfV9Wfr53DK2oaxMgAxqpT+67fCnyi9vdrReT/FpEXAQMZW0SyQB74BlX9JWAM81sPTDM7VAJJREZr/8a1Zx3gmzC1o1DVMvB+TFLxawYwbra26W7gQ6r6cYwp8S0i8vLae/r2kDSMm1bVABOd/tGGcxkDvk6fOx81jBunk79dVe8TkeeLyEMYM/UB4MdF5KYBjJsGaBB2dwJ/CfwDph7Wt9T29yyEG8aMH/pfAW4XkTeJyP3AO4AP8f+3d64hWlRhHP897q6orWF3WhaVbsZqkogJJrX5wSAQkuhi2IfatrAPEZVreGFB6ptmEHRlsaCsCErIgrKLmRiBUNQSa3mhQsoUAmO32mV9+vCcccftXd195/LONs8fDvNeZuZ3zpkzzznPuczAdhGp+DSHhNxoAXwj0AwcFZFXgA3AjcBWYHUG3AZV7VfVDlU9HL73An3A/LBP6vbjf2GQROQ8EXkdeB9AVQdCZv0I7AbWxnb/AjgAXCUil6TM7Q+tgl5Vjd4/8hpWg90sIlNSukmGcyOD26Oqx0Mc+jEXFeCXpMwRuP+EbfQg5QuBLao6DViPtUg7khqlkdIbuyH+BGYD27G03i4iL4ktI0qL+Xcw/AewCudhbJnEtZibOhVYFboJqlaltIpInaqeAA4CzwAnVLVFVe8ENgGLRaQ1Ze5A7D9h6J2QO4CW0ApNvfU77g1ScL3eBGYATSLSHv6KbvxtQKuItMCpWnM3Vrv8kQH3tDxV1R5gF1Zwb6qWdzauhNG8wIzSfgvwQzBOeXA/V9Wt4XMv8HyIQ9WPuTkTN3ZDTAe+VNW/gAuwvrtZwHdpMhm6tusxF/VFLLt7MMNwB+bSVKVRcDdjraSZMS9gb/i/4vOFknCja6umKK8HsSdsZOImjnuDFLQNeBBrPj8mIpNCJg5ixqcbeDq2fw/2zKSk77euxB2Mau6Ye/YG1s+xSETWhdq7KUNuZCQWMuTCtYlIp8SmA6TNjRS7WX7HHi2ctJyNxI04h4HNIvINcCnwLnAEu3nTZPYHQzgI7An7Rca2F7vGSUfdKnGj1sr3mFs+j2CAVPUnzDU/kgG3UlneBSzCXMj0O9RVdVwF4GqsdXNR+F4PNIbPzcAnwKZhx1yBNeXfBtqxfpUuYEIW3ErnBTqBk8BvwPIsuYBg7+37AHgI+Bj4FViWdXqBhrBtwUb8not+y4ArIXQGVlv4fQHwLDAz47TWxY7/CtiYVVmOXduGUH73ABux90p8GJ0j4/QK1qG9F7g/jfv5P3HL4qSZRNRGy17GWjafYsO8yyrssxwb5p81rNBcA6zBRinW58CdEEId1oc1AKzOgxu28zEDeBwbecsjvZOw2nMH5g6vy5obfm8CJudYpiZgBn8u8F44fm0O3IlhOxNYgXVor8kpvdFC/GkhzQvTvL9P8bM4aSYRtYv/GeZm1WPG5RBww7D9zseate/EfpsYz/C8ucASYGqO3AbsDSxPEGq+nLj1WA26Mu/0hu2oW7wppbURaMs5rfGyLHnncZT2sXDHFMesTpxK5OxRtFGN/wBwKF7wsL6ZLuCy2DF1wBxsuH0L1l90d424K2vA3Q/cVSPuiqJf3zKltZbcakOuBmYMmXgl5hfvwIZyZwCLCaNVsf3mAvuAW4cdfz02oetn4F7nOrdMaa0lN2ko3CibiLRh/u3XQAc2l2YD1sQ8CiyN9lXVb7Gh3XvCsXVir0XaCXSp6nQNw9DOLS+3TGmtJTcV5WX5xmDZnwTaY9+bsXkPTZjP+xawJPb/MqxpOSV8Pwc417nOLWNaa8lNIxTxvWwvECaXhaUJfdgM1cnYsP3lwCMiclBtDsYC4CNV7YNTE/Kc69xaM8vITa5aWMFRWvlomHEe1qSMRqzmYD5xNzYX4xiw1LnOLSKzjNwkoYgtJOC05Q+twH4Nyx9UtVtEbsMyebaqvupc5xaVWUZuEhXWIMWm6F/H0CMXVmFrlJ5S1X3Y6IBznVtYZhm5SVRYg6S2jqYem6R1sYjsxmao3qeqx5zr3PHALCM3kWrtM54pYMs9TmLrsB53rnPHI7OM3KrjW+sInCUzJwKPApOc69zxyiwjt9rgb651uVyFUeFmartcrvLKDZLL5SqM3CC5XK7CyA2Sy+UqjNwguVyuwsgNksvlKozcILlcrsLIDZLL5SqM/gX+06W/pShQzwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Import the example data\n", + "file_url = ('https://datahub.duramat.org/dataset/a49bb656-7b36-'\n", + " '437a-8089-1870a40c2a7d/resource/5059bc22-640d-4dd4'\n", + " '-b7b1-1e71da15be24/download/pvdaq_system_4_2010-2016'\n", + " '_subset_soilsignal.csv')\n", + "cache_file = 'PVDAQ_system_4_2010-2016_subset_soilsignal.pickle'\n", + "\n", + "try:\n", + " df = pd.read_pickle(cache_file)\n", + "except FileNotFoundError:\n", + " df = pd.read_csv(file_url, index_col=0, parse_dates=True)\n", + " df.to_pickle(cache_file)\n", + "\n", + "df = df.rename(columns = {\n", + " 'ac_power':'power_ac',\n", + " 'wind_speed': 'wind_speed',\n", + " 'ambient_temp': 'Tamb',\n", + " 'poa_irradiance': 'poa',\n", + "})\n", + "\n", + "# Specify the Metadata\n", + "meta = {\"latitude\": 39.7406,\n", + " \"longitude\": -105.1774,\n", + " \"timezone\": 'Etc/GMT+7',\n", + " \"gamma_pdc\": -0.005,\n", + " \"azimuth\": 180,\n", + " \"tilt\": 40,\n", + " \"power_dc_rated\": 1000.0,\n", + " \"temp_model_params\":\n", + " pvlib.temperature.TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_polymer']}\n", + "\n", + "df.index = df.index.tz_localize(meta['timezone'])\n", + "\n", + "loc = pvlib.location.Location(meta['latitude'], meta['longitude'], tz = meta['timezone'])\n", + "sun = loc.get_solarposition(df.index)\n", + "\n", + "# There is some missing data, but we can infer the frequency from\n", + "# the first several data points\n", + "freq = pd.infer_freq(df.index[:10])\n", + "\n", + "# Then set the frequency of the dataframe.\n", + "# It is recommended not to up- or downsample at this step\n", + "# but rather to use interpolate to regularize the time series\n", + "# to its dominant or underlying frequency. Interpolate is not\n", + "# generally recommended for downsampling in this application.\n", + "df = rdtools.interpolate(df, freq)\n", + "\n", + "# Calculate cell temperature\n", + "df['Tcell'] = pvlib.temperature.sapm_cell(df.poa, df.Tamb,\n", + " df.wind_speed, **meta['temp_model_params'])\n", + "\n", + "# plot the AC power time series\n", + "fig, ax = plt.subplots(figsize=(4,3))\n", + "ax.plot(df.index, df.power_ac, 'o', alpha=0.01)\n", + "ax.set_ylim(0,1500)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('AC Power (W)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1: Normalize\n", + "\n", + "Data normalization is achieved with `rdtools.normalize_with_expected_power()`. This function can be used to normalize to any modeled or expected power. Note that realized PV output can be given as energy, rather than power, by using an optional key word argument. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the expected power with a simple PVWatts DC model\n", + "modeled_power = pvlib.pvsystem.pvwatts_dc(df['poa'], df['Tcell'], meta['power_dc_rated'],\n", + " meta['gamma_pdc'], 25.0 )\n", + "\n", + "# Calculate the normalization, the function also returns the relevant insolation for\n", + "# each point in the normalized PV energy timeseries\n", + "normalized, insolation = rdtools.normalize_with_expected_power(df['power_ac'],\n", + " modeled_power,\n", + " df['poa'])\n", + "\n", + "df['normalized'] = normalized\n", + "df['insolation'] = insolation\n", + "\n", + "# Plot the normalized power time series\n", + "fig, ax = plt.subplots()\n", + "ax.plot(normalized.index, normalized, 'o', alpha = 0.05)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2: Filter\n", + "\n", + "Data filtering is used to exclude data points that represent invalid data, create bias in the analysis, or introduce significant noise.\n", + "\n", + "It can also be useful to remove outages and outliers. Sometimes outages appear as low but non-zero yield. Automatic functions for outage detection are not yet included in `rdtools`. However, this example does filter out data points where the normalized energy is less than 1%. System-specific filters should be implemented by the analyst if needed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAADHCAYAAACX8K+cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eZBl2VnY+Tt3X96ae1bW1nu3urXSbDKrACkweAiWiYkZZjwaE9YMDJ5BBOMRjBjQgA3GYeMhDAYNErKx5LFlCRAIyZhoCYQkRrTU6m71Vt1dXWtWVm4v33r3c+aP+7IqKysz62Xly/3+IjLee/fdvOfc+875zne+7zvfEUopCgoKCo4C2n5XoKCgoGBYFAKtoKDgyFAItIKCgiNDIdAKCgqODIVAKygoODIUAq2goODIUAi0goKCI8OeCDQhhC2E+IAQ4qIQoi2EeEoI8b1bnP9uIcScEKIphPigEMLei3oWFBQcbvZKQzOAy8C3A1Xg54H/IIQ4u/5EIcQ7gPcA3wWcBe4F3rdH9SwoKDjEiP1aKSCEeAZ4n1LqY+uOfwS4oJT6uf7n7wI+rJSa2odqFhQUHCKM/ShUCDEJPAg8t8HXjwJ/tObz08CkEGJUKbW07jrvAt4F4Pv+1z388MO7VOOCgt1DKVAoBAIh9rs2+4NSDHzvX/7ylxeVUuMbfbfnAk0IYQIfBv61UurFDU4pAc01n1ffl4FbBJpS6v3A+wEef/xx9eSTTw6/wgUFu4xSiiRTmLpAHEOJFqeSOJNYuoZl3NkKJoS4uNl3eyrQhBAa8PtADPzkJqd1gMqaz6vv27tYtYKCgn3C1AWg9V93xp6FbYh86PkAMAn8sFIq2eTU54A3rvn8RuD6+ulmQcFRIckUcSZJsuOZ+UYIgWVoQ9FO9zIO7V8BjwB/RykVbHHevwF+TAjxOiFEHXgv8KE9qF9Bwb5g6gJLH46GchhRShGnkmE4KPcqDu0M8D8CbwLmhBCd/t+PCiFO99+fBlBKfRr4NeAzwMX+3y/sRT0LCgr2nmFqqHtiQ1NKXQS2Gn5K687/58A/39VKFRQcEOJU0oszPEvHNvX9rs6ecyhtaAUFBRujVK6hFNmjd04h0AoK9hkhBKY+HKP4YeTQTTkPC8c9HqhgfzjuToFiyrlLHHf3ecH+kGSK5Bi3u2GGbRQa2hqGOVIUFGyH4ynKhk8h0NaQjxSFMCvYW477lHOYFFPOgkPFMIMwDwrHfcp56AJrDzJKKaIkI0qyI9VJjipH0c4ppaQbpUgp97sq+0Lh5RwiSaboxRmKYsp5GDiKds4oyWj2YkqWhmub+12dPWeYv+mxF2imLvAs/cb7goK9JpOgRP56HBmmInHsBZoQ4lguNzmsrE5PQDsy2nTVM8iUQ9U7nt1xmPGfx/MJFhxajuKUU6LhOQbymJq0hzlIDfQE+7s0/VQ/dXZBwb4xzCDMg4KGpBemaBzPOecww1YGHRJ+Gfg24LwQ4lNCiP9GCOHuuPSCggKaQcp8J6QZpPtdlX1hzxM8KqU+ppT6IeAU+QYmPwFc6++Z+bYd16Kg4DgjM9phDDLb75ocerY1aVdKLZNnlP1t4BLww8D7hRDnhBDfvQv1Kyg48sQSlMxfC3bGoDY0TQjxDiHEvwVmgR8FfhWYUkrdD/ws8G93r5oFBUeXsq1T8yzKduFt3ymDejlngUVy7ewfKqVm136plPqYEGKzXZwOBUXqoIL9QqLh2sfXyzlMBhVo36+U2nLTS6XUdw6hPvuCUopulKFQgH5k4psKDgcakiBK0Y5pHNowGfQJLgsh7t3geARcU0od6tl/nEriNEMXECkwNNC0YrQs2Bs6cb6WsxNLSt5+1+ZwM6hAe4WbKZsEt6ZvkkKITwA/oZS6PszK7SlCkClFmOSeJtukmH4W7AmunmfbcPWjs+B+vxhUDfn7wIeBBwEHeIjcCfATwOvJBeNv7kYF9wLL0CjZBlXXwLcMTF0cuYwOR4WjmD6oGUnCVNKMDvVE50AwqIb2PuB+pVTY//yKEOLHgXNKqd8RQrwTeHk3KriXaJpGyREopdD6DoKCg8VRXMtZsnTKtkHJKrycO2VQDU0Dzq47dhpY/QU6HOJ1oevzMR3F5TVHhaOY3dU2daqeVSRJGAKDCqF/ATwhhPg94DJwEvgf+scBvg/44vCrt/sopVBKYWriSHWSo8pRzFkXZTdf/f2tyqFnIIGmlPo1IcQzwH8JvAW4BvyYUurT/e//EPjDXavlkFkbc5ZkikQqrDX7IhYxaXvLcX/eZVsjiA3KduFZ3yl3FGhCCB34IPCuVQF22Flrh1mbjma1YymVC7mjZKc5yBxFu9h2iDKBYWhEmcA8fglrh8odhwSlVAa8HXaW20QI8ZNCiCeFEJEQ4kNbnPdOIUQmhOis+fuOnZS9nrV2mHzX6lxTi1PZ71gcOTvNQeYo2sW2g2dp+JaBZx1PDW0/Nkn5deB9QoidjB+z5GmIPjjAuV9USpXW/H12B+Xexnqjf5IpojQjTiWmln9XOAX2juPuhDnu978fm6T8A2AK+GkhxAJrAmuVUqcHuYBS6uMAQojHyZ0KBwZTF4SxopdkGJpBkglMnWPbwAr2ljiV9OIMz9KPpadzPzZJ+W93XNL2eLMQYhFYBn4f+BWl1G3Z74QQ7wLeBXD69EBydVNSqUj6DUtoCv+YNq6CvUepXENx1fGccu75JilKqb8YSmmD8ZfAY8BF4FHg3wMp8Csb1Ov9wPsBHn/88bvSV5VStIOEME7xLB3P0gkSSZzKYz0NKNg7cjtu0daGwaD50GwhxD8SQpwXQjT7x96+GymDlFLnlVKvKaWkUupZ4P8CfmTY5aySZIpunNDoJRhavgOUQKBQxdKngj1hdemdZRxPDW2YbMcp8Bh5YsfVXv4c8OO7Ual1KPIF8buCqQssTce1dYTIvZ0ShaAItC3YG467U2CYXs5BbWg/SL6WsyuEkP1KXBVCzAxakBDC6JenA7oQwgHS9bYxIcT3Al9RSl0XQjwM/Dzw0UHLGZS1wZw130TTNHxbJ5W7KD0LCgpuY5hOkUE1tJh1wk8IMQ4sbaOs9wIB8B5yJ0MAvFcIcbofa7Zq1f8u4BkhRBf4U+DjwD/eRjkDsdZVnEqQKHqxxNRze0aS5Xa0goKC3WdYxp1BNbSPAv9aCPFuACHENPk6zv930IKUUr8I/OImX5fWnPczwM8Met27QSlFlmXEicQ1BIlU9OKUCAALQ4NuLDGS7FhPBY4TWZbRCjIqro6uF97tvWS1j+3lvpw/B1wAngVq5KmCZskN9oeOJFM0g4SFTkQnTEkyhSEgSDI6YUKcStIhBvsVDA8pJZ0wRcrhas+tIKMRxLSCvd9Kbrfu6bCwH/tyxkqpn1JKlYBJoKyUerdSKtpxDfYBUxcYmkBJRZSkdKMEAMcUBGmGUiqfzxt64Rg4YHTClIVOSCcc7qa8JVtg6xole+9/714s6cYpvWO6j91+OAUQQlTJM9WW+p9XK/PEjmuxxwghcE0NAcRZRpQJPFPH0A1SmZFKhWUc37WFBxmlFEky/Iy1YZovVg5T9nyBeL6G8/iu5RxmcoKBBFo/I+1vkidy7K35SgEbbZ5y4OnFGUvdEJTJaNnF1DU0JL1YkcmMVqRwpY6mHc8MEAcVy9DwneHHbAmV0Qpj6o4G3C7RdtPGlmdKPp7CDPJNieI0f93xtQY87x8BP6KU+tTOizw4rA7yqVSkKqMbpXTDFKUMyo5+KDNAHPXcYpqm4VrG0Hfl6sSS3hY7L63a2MCiXiqcBsMklYDIX3eqpA4q0Azgz3ZW1MGi5JicHvVRShEmKVIKSpZGmmlYWh6LJqUkSrJ89cAhEQ5HPbfYMD1ia/HNPFzHNze+bsXVAav/OlyO+iB0JzQkvTDF8Q0G91Nudq3B+CfkMWNHQi9WSiGEwLdNSraOUoKSrWEYBmXHJEwVi52IhU5EM0gPlafzqOcW262o+iDJNbQg2dgwr+s69ZK1KyEdw0yfcxhphRmNXkwr3LmHeVAN7d3k6YP+oRDilmDaQdMHHSSSTBEkEgUkGaRSEiQKU4GpCYQmEFJiGxplW7ux78BhGD2PYs79tUgp6cUSz9KGOu2MkpSVICZK7KFdc1CGmT7nMOIYAtvUcIbQbg9q+qBdxdQFnqWjlKIjJWkm6UUZtmkw4pkYCLQ1KbmlUIhMDSwoiiDN3WM1xAGMoRrSNU3DMfSh2+YG4agPQndC0zRcczh20YOYPmhPUErRizMMXVCyTVayjDjNiFONXioJo5ggBcfQqNnmtkbP5U7EheUeZ0c8xqsbWJgL7prdCnEoWRqOqVPah9CJ425DAxjWbR+49EF7QZxKFtoh15sBSSpxTA1QtIKYIEpI0owwTgiihG6UbDuCuxuEvDbfohuEdz55yBzFncX3guVewmIrZLmXbPj9bj7X425DE0JgDCkf3GFIH7QrZFISpCmtXsj5hRbXlrv0wqQfhR7Si1KSNA/l2K5jYKUXMdcMWent/UKKo945ulHGShDTjYa/RElu0aHiVNKN0l1JWKCLPFhYF0fzN7sTw8wHt2fpgw4SlqHh6IJ2LyEKM+aaCVJmOJZOGElWggyhMtB0DA0qzvaWQIVhwJWVgDB0dvEuNuaoG5hvdH53uJ1/rGRzz5hkrLSxU0DKXKDlhuvh2kV7saSbpBi6oLwLYSEHnWHaEPcyfdCBQQhBIvMsG7qmM12zKTkatqaIMolvCjpRynwnJkoyMrW9hz3bCJlf6THb2Psp51FPFpgpgWlo2/5N7oQSOhXXQomNBcqqYrYbGaVMXWBqB3cQyrKMRicmy/Z+4f52GVSgraYPugdupA/6l2wjfdBBQilFzdU5UbUZLVn4jkGUKOa6GbrQcF0LXddIUkkq5Y0t7gbFsUws08Sx9n7X2KNuQ9utPSxX8+BtJlR8W6fmWfj28DUo29Sp+9aB3ZRnuR3x8kKL5fbBz0Ux6JTz54BfI08f5JGnD/p/gPftUr12lTiVLHYiLi12MJAESUovTPEtDU0DpMQzBEbFYcSzSLN8xcCgms8DUxXe3JE8MFXZ/ZtZx1FfKXDTRqgxzIgYIXLNb7PfdzfXWx70sI1UKbJUkR6CQXLQsI0Y+Cngp/pTzUV1yFWAxW7E1VaIrWtkUhEnikwDEWZYukRoBlXbBE3PA3Bl7lofpOFVSj6PzigqJX9bdRqG+/6o29DiNI9Dc00NxxryxQ91i949xss2uqYz4g+cnGff2PaQo5RaOOzCzDI0psoOp2sej0y4nKya2Lqi3Y1IkgTTEJDFvLbQYnapiaUpSrYxsJDIbSLbz6U2DA/lUbehGRpoYjiZGdZzRB/ZjjEMg4mqg2EcfIF28Gu4S5Qci+kRH11lLHZTwkyQAZEUBFHKucWAi0shaaaYGq3hO4MviQlTlceypdsTTMNMo3JUSTJFlAw/LGWYsVDb5aAH1h70+q3lWHadJFN0opi5Ro+VXkwURyy3e6g4YqnVYbYTorIUshTTAF1lrPSSgR0Dtp53kM3sx5sZ7qMk668nvHtv0lF3CuyWBrqfe2N2g4iX51p0g4NpdN/t2MZhttljKdBMXbDSjXhtvkWz02Ohk3B1ucdXrjZ5aa7DYiPAJ0EIRRZldOIUYxsG6DBVJJncVEPbrIE0uyHnZldodu8+3OOoB9a6Zp5NxN0kzc9hZHalx9cuLzO70rvzyfvAbmdwGWab3XTKKYR42yAXOIwpuJVSNFsdzs93yFKHLEsJ4xSRKkwzNzy/3Iq51IzQNJ03dGOm6wz8g1qGTsk1sTaRgpsZ7rtJnvWju0kKm0E46k6BpU7Ii3MddFFiqj68sJj99A5rKBKRvx5EdtsLO8w2u5UN7QPrPs+Q+4GWgFHyHIhXOIQpuDthyquNmGaYsNyWOJZOydbR7DzbRidVLC726CZg10PmVrrUfBvPquHad1Zqa57JTOZR87bX4WaqNlGqmKnefQqbgx4CsFOuLbf56sUGdUsyUvaHZtfZz4HAs3QqtoFnHcw4tN1mmG12U4GmlLpnTYE/Ry7Efl4p1RNCeORb2B3KlQJpmlIxJZNVi7pv0E0hTjOiFFAJvVjQ6EEnhZUwY66T4Cz1mKqVcO07C6kwBSU233Bjs52iwzRPCx6mcLeLpg6TAXeVNE1Z7qaM+MYdPWmdMGa5E7PSDelG6VB2286XNWUYGiil7bmXuBMmLHYiOuHGC+MLBmdQG9q7gfcopXoA/defBX56tyq2m0SZIsg0kiijHaaYaYSUCQudgFfnQy6sBCwF0EsgjVOmSgYVWxt4SjDIYuONvumGCddbPbo7aNhxKuns0iLq3eLifIM/efoyF+cbdzy35FjUyza+Yw1tgtYOEi4sdbja6NGJ9j5D8VK7y/nrXZba3bu+xlF3Bg3KoAKtC3zDumNfz607QB0ayrZOnKTM9yKWVwIutSTzKymLHbjeyP+WyIWOoUGYZMSZYtB2HqeSXrK5UNnMo5ab3MS2HBAbcsga95MvX+WPn77Mky9fveO5ni7JsoyqxdC8ku1uj+evLNHr9Uizvc960Q0zeklCdwcpqHczG8h2WC9Y93oT5UHj0H4e+LQQ4o+By8Ap4PuB/3m3KrabpBKSNCWNMlJDp9tp0WyDkLAMrDrPE+CFayCNa7zpHsnrT1QHun4vjLi40KJuC2ql2yePm9kMpFSkmUTKu+9Qpi4QCBSDr2zYa9ZPMc/Pd1hsBZyf79zxf5+d7fLSXJuv1S0evmc4TvpnXrnMHz29CA/XqNcq9GJ5W9aL3ZzKT9U9To0nTNV3lgz0IAxf+UqODL9vCtitDMObMejO6b8PfCPwAlABXgS+qX98IIQQPymEeFIIEQkhPnSHc98thJgTQjSFEB8UQgw10XuUpGRSYJkaMs3opRmtBOazm8JslesZvLoU8dpCm2sDLs5daAe8tthloR1sq15BktEJE4IdxKGlEgxDoImD6+m83gz42uwK15v583nDTJ2zEyXeMFPf8v+UUlgiRkmJqydD00I/+rnLfOFiwCe+cG3TrBd3Ci1QShElGUGU0OrFhHE6cN2m62W+7nSN6Xr5rqeOB2FznNVnECcpUZKhlNq1ZAKbMfBKAaXU80KIF4FJpdS1uyhrFvhl4B2Au9lJQoh3AO8B3tb/nz8gXwT/nrsoc0OSLCNOU3phj/muohnCAhuPcDHQbEMvCvH1wdTmTGaEsSST2xNMhi7QNQ1jgEa52vCBW4zYhgYxAs+6s2E7jmNmmzEnqhaWNeyFkRuTpimXFppcWOhxqmIAZR45Pco3BjqPnK5tXd9UEsUZcZLRDRPmVnqMl21c29zR5inL/R9+QeaCod1s8AevNHn7g3VGR0eBjb2ga7W2OJUstgOurfRQSlLzHCarHmXXvOPvEEUxc8td7q9ZJJm37fARKSXLnYhekqFhYRjGtjXJbrfLM9e6vGHax/dvXYM8qHaaC/2MZi9BKYVt5lraXm6iPGgK7poQ4iNACLzSP/ZfCCF+edCClFIfV0r9IXf2jP73wAeUUs8ppRrALwHvHLScQcgyyUIz4LXrigsrMBdura4vA0Gc0EkHayCOaeC7Jo65vZVlrmVxYsTDXSdcsixjuR0RRAlZltEJ8xFwud3lKxeXaHdvaoLbsaU8+9o1PvAXL/Oll64MZONYqz0kScKVpS7dICJN04HzZS22Y16bbzK3EhElaX6sl9IJEhZ76ZblSim5tByy2Al4ca7D5eUuK72YOI555Xqb6402C+3ojvcShiHPX10hDPMA5odKeQzSvX7eKf/wa/N88plrfOJr12/8z0YrFKIkY6kTstDsMb/S4fmL1/nMM6/x589c5cK1JeZbwQ1NZSut69xij1cXQ84t9u5K02r1Yp67usRzl5aZX+lwZalLox3QDgZPH/+JL36NX/6Tp/jEF79223eDBr7qQtELU8L05qqavXZWDNrjfhtoAGeA5/vHvgj8M+C9Q67To8Afrfn8NDAphBhVSt0iDIUQ7wLeBXD69OC76cVpylyjyeWN+8+GXG2meMSbfr92FCu7NtM1h7K7vZly3bdQaNTXZTWYa7T5zPPX8G2d+8Z9lroJ7V6P1xbazHcUzfvH+NZHT2EYBnEqibOMXizuuEHyXzx/lT97ukHcbfLYPSc2tPet3pcuFHPLbV5dCnhozOKrl1Z4eb7HI9MlzoxXmO9m3D/hM17xthzNdVKWOjHdOCVKcm9ulKR0QnlDwK0nyRRRmtHpBlxfadGNM2TQZq7RpmxKLi/B+fkWtiY4OV7F1qsb3ssqT712nU+92OR7H67yzY+cYepElenrTWYmHZIs47QHnm1wapPsEqvPJIhiXp1rEiYxzU7IXzx7iacuxRg2tNot3hJJHG0M33VoBClTFRtvgxQhD417zHdiHhr3BorJWi0/X/srubrU5P976RqxMlBRmys9mC4Z1CoVHp2pUi+5d9SwnnhpkZfm4Alzkf/6u2/9bpAYvSiKeGGuQxoFNCMY8fKNhcI4ZbEbU7ENyq5JKnPBFyRq6FsRwuAC7buAE0qpRIjcBaSUWhBCTAy1NjkloLnm8+r7Muu0O6XU+4H3Azz++OMDDwGtbsSlxe1VanYFvvjqIg/dc2rD76MkoxkkuKaOqYEpwNLuItuGzEfC1XAspRSf++o5fu3PFyibcMqFSx1YkbmL2QPCbpvxuk+t5FN3DSxdQ9e4o1NguRvTSODl5S6Ndvc2IaCUohOmJFk+wn72uct8+plrlC3J+dmMuRjeMgNvOFWlK3w8MUbFtenGGZauUXKM2zrQ5YUVvvDSLJpj0+zkTpaRksvMSMRIaRNLhEy5stjhxcvX+fxLCfPA03OKtNRkpdXi3LUmc+2EE57Oi/M9Soak6k8BbDgtv7DQ4cVryzwyqvPNj4Bj6mg6ZEpjrhlQKpf59ocd7pu5dQqslKIXxsy1QhxDo9Fs8adfeZXFRpcwlvzlqkKXQvR8j3NL55lbWuHeyRroBtrJEc7Yt09Bs0wSxhlZ/zlvJHzWTqnDOOV6K6bqCC4utPj0Uxf41JPLxCY878HVFMYsePDMKLqc4oGZCVIFNddE1/UNBVvdAkfkr+vZTMiuFazPXFzkPz03C3GIsH0MYjzbRkrJ3HKHWQH3jJVwbYs0zdu5Ujq2yVAdLYMKtCYwBtywnQkhTq/9PEQ65I6HVVbft4dVQC+Omd2evZ4u8JdPzvLO737zht+vtNt85qVFHpz0iFPFXCtioRszOXrznCzLWGwGdJKMSV9nMeAW+1U7jLm83ENXNmGiqLg6vTDmdz+7QAtoJXB1XYhaD/jYyzHjlfPUa2XuHS/x+tPjaJaz6QbJqw3xbfdX+ZOvdQlTOHd5jnumR5FS0mgHLPYSJn2DRqQQWUorzvjYpy/xlXX3/cRVeOJqE50mi5dmecdbA4JU8NhMhUq5wqhvEqeSVphScQyeu9bkmetQsiIuLXeQUjJRcbl3PGWi4m5oG/zKSxf4l391laWLPVYDO55agej8HFc0+OyNwSmhylWy9gI/9O0W01U3T6ktxC2dUmQRYZIhstzJo1kWlqXRTiStXsSJsoXULSq+c8PQ3QtjVsKUZqfDVy63GHU0XrpwjY88s7FndhaYvZ7y5evzTDDPtz1S4mTVpt0X2pah3dCgn77S5KuXVxixBbVaDYUCdEydG8KtE+aazphvsdLp9VdLZHzqq5f4zy8ELOe3z1x/+L/YhacbS7RXlvmBr09INYv7J31Krkfdt3CsW7v+D3zDA3StJX7gTaO3HF+vDSaZupG1d6WXkElJlqZ88gvP8PsvSizApMVXX73Gf/X1AQ9Ml/jSqw3iTLEy6eGXyzw84aGERZZBJAD03V8psI7fBT4mhPg/AE0I8c3APyafig6b54A3Av+h//mNwPX1082dEIfJXUnHJ1Y2/+6b/ukXbrx/ax3OnBnhgUrKX/QS3jBdolYpM7/S5U+fnUUqxcmKRVcavGGmzNmJGqYuSFJJECbMNzO6Wcj9Yz4vvHaJVwaYGv/2l1eAvILfOvUCP/iWUzx23zSTtQoVzyJNU2YbAWkacW2lh0RwbjliBWgvwV+fm+U73/QA5653ePHCLM/Mp3zjjElXGiwtN3hlIblNmK0lA/7gKvzBR1/mpA7fep/FyZNTPDbtYVo28ysRJ8dLmFISAiqGV681c3tgBpqC5VaX5661GfU0yp5P1TVZXG7wv374Za5vUObzyzftH6s0gd99NgbnVb7h3jEeOlFH6AYlE6Ik31w6SkEzIEkVjU7MA6MW03WXmZoFCBIl+oI1o9GNWekGPH9lmaVWwPmLl/j8ZcmEB3+9cOffBWAe+I8vdDj/wlP8vR+6F6FZPHZqlOnRCpYhmCzpOJoGScgLV5c4PeLhll3mGyEvXZ3jwkrKWyZNLnZN3nKyxJMvXOBffe4aVR2ebG5ebgr8yQXF+YvnMCd13nFviccevJfHTtSwTf2GsAyCgLl2yv0TLrbrEEQJlqERJLmpIUwVMk04t9DGEHD/RJVMwZXlDt0g5MsvXOBDL+aDUND/+5sFePVPL/DWs/DVCyAceH4EUsvlTTNlHjszwcxoiRP18lA9s4MKtH9C7hD4TcAEPgj8DvB/D1qQEMLol6cDuhDCAVKl1Pru+m+ADwkhPkyuAb4X+NCg5QzCbGNoyt6GfKEBX2gs85++ukwI/K0z8HPf/ya+fH6e3/j0LKM+/OAjHqI6yYSdcP7aPHMdyaMjgtmWQdBo86UFDe/ROv/uc+e3Xf7n5uBzf3qZOpc5MQ6/+B0n8EYn+a1Pf41PXrip4r2+/5oBn/1aTCf4zzy/CItNuA58/G9yzXS75twrGfy7czGcu3Tj2A8/6HNqqowjE0bJO/nLCz1evjJLlCjOzTb5rY9c5SngLPDO757h/X9+ldlt333O7/7NAr/7N7nE+a57ff7OgyUmZk4w4lokSmAojYWVNv/xK69hRiG+Jukk0G42mFvWqPkOs/MRf/XCFf7mlRWu9yAKYPWOXrmLoP6vAFc+fp57Twj+9htO831vPku97KHrGk8/PcdHnoJT5kX+wXeO0r66xC89l/9fGXi4AtMnR4m7Jf7pp65ta2r0vALmMp6ea6RHO4sAACAASURBVPJj3ZfptidxbBPNMHnjyRE++/QFfuMzF5muCQyZ8NpiF4uMTLN4cMJHmS5hr80nvzKLZpj8yJtjlkPJ51+8wheebvLcJgtbloE/udD/EMLlWYCAz1wI4PPzfOM4/Og33cN3v/kshuUMZeop9sr7IIT4ReAX1h1+H7lwfB54nVLqUv/cnwb+d/Lwjo8B/5NSassgsMcff1w9+eSTA9XlR3/hk3z+LlNPXfjV79vw+Nn3fHLb13KACW52EoA3jsLLS/lU8m0ePDGktRhvAJ4ZzqWGSgW4x4en737Vz67wVh+UhC9u0zSxHXTgX3zfSc4vrPDrX7pzULEGvMWHJ4f4rL7Nh54HTy6ABUzpcKnvrK4Abz0F5coIsrHMx2bzOj9egosdmBtSHf63t9b4nscf4eRIaUOnyXqEEF9WSj2+4XeDCDQhxHngI0qp9647/qxS6vWb/Nuesh2BdjfCZ5VhCrSCgoKct54y+ZnvvJe3vO7+O567lUAb1Gc6DfwtIcQfCyHKa46fHfD/CwoKCjblC5cTfunDL+34OoMKtAT4HvL8Z38thLivf/wgLB8rKCg4Ajw1hH2MB45qU0qlSqkfB34D+LwQ4u07L76goKBgeAzq5bzhelBK/Y4Q4nnyXdN3lh6goKCgYIgMKtC+Z+0HpdTnhBDfRL6AvKCgoOBAsNUmKWLNhsJfEkKsn55eBQZOH1RQUFCw22yloTW5uewo5XYHgOgfO547OxQUFBw4thJoj655f8+mZxUUFBQcELba9enymvcX96Y6BQUFBXfPVja032eAODOl1N8dao0OMJum2S0oKDgQbDXlfGXPanFI2CrphQYcno3jCgoOHsOIAdtqyvm+IVz/SLGV92McNkxxU1BQMBhnhnCNgZPeCyEs4CHyRI9rA22fGEI9DgVb7WZ+yoHr4Z5V5a5YdUsXFBxEJqZ2fo2BBJoQ4luAjwI2eShHizxN02Xg3p1X43CwVb7xapU8Y9y68+d3sT7bYRxwHeiFeY6zXcyKcxtnHOiGsM2s58cGv/93UNrKfuAAf/cbdp7Rf9C1nL8O/JpSagRo919/CfitHdfgEDExtvl3k+VbP48Do24u1DzykQBglDXq7R0YbFvjwZDkeeZP1fOca2e3tyHVXaMBUkFNg5P2/q6Vm9HgdL/FV8hTyOwHLrmQX6ULnBzbn4DOGtuYpu0ip+sQGpU7n3gHBhVoD3J7dtpfBd694xocIk5tIWGmxus3HqYGlB2454TJ1Eie4rcCnBRQcfM5+yDs/OfNqQG+2d9UpWRSr5iMVrfWOIeBDzzkgevC6ChM18WNexIMLtiHgQdYAkIJI8BkBdx92JN3Cjhdvb0t2abg5B7XRQMmS1An15BctpGtYkhY5P3C0KETbJL6dhsMWv+1qwauCSFeR/4cSjuuwWFiiw5wesRnxsmFxyhQ9cA1LSbKBqNG3qnPTEA3yDc1HgTH2vnoOa3BA3WwHEgSkEmK71hM1xxGd/nXqwqwbJgqGczUbCqWQd3JG80oucDbC+rkjVeZ4GhgiFwbsrx8sBnlpga9m4wBj8zAyTIo89YSq7bgodNwQs/rtBdI8valyD34KXvzHFYxyX8bz4GJSomZ0Z0HRg0q0D4O/O3++w8AnwG+TG5XOzZ0t8jX5Do25f6USgCmCQgNJTOwwbbA1LZnJ5Hm3U07BfloK4BY5oJx0s0bTsU1cU0TZEZ4l2nIB8EHLDNPY22ZOq5j4bo2vge+yAWLt+783aAElEwwTNAFOHq+IYuuQdXKBVvG8LThzagAMyNwol7Bdfy8XaxB120828a3tp6WD1PYOeRbIi72r2uzt7bVKZELU9OEUzWbscrOW8FAAk0p9VNKqY/03/8z4EeAv09/k9/jwri7uZXDskzKrgABQgMhQUpFlEHQAzIoe3fOl74WQ889L9tBByZF3kAVuZ9iIYBUywUMaChNEKcZnZ1r+JtiA44DmQadSCERVFwbQ881A03L94Fc3TWnTD4dG/aUxwQ8E3QdKh5YpbzAVIDp3ZxinKnsnk3NBUYtSCU0gpiaqZis3SpCS55JN8qI1dZa+U681CXgFPkzcYDT7k0/VkBe7nbb290yDpj9H78dwHwrIYz3bsp5C0qpzymlPqWUOjaxpAZQLm0+goz6FrWSR9nKRxzdygWIZ2qM1KDma6h1U9Y7aQWn6gZT22xhFeDMONT7v2wXWGmDp8GI61BzbTzLoNeRrJA37GFrJ4K804y4MFPRqTk6VdegYgksA3wbxitg23lnHxMwVgLfzTXSrcJjtosLZBJMHRwDJjyYqsDJssW9Iz5TJahXYLQE9VLeoYc97cqAbgydEBpBRKCZTFRu1bV83cAyBaYGo34+FduIAXY03BALGHGg1LeZjZhwZiwfRCAXBK7In/0JffftqwYgs/w1S2G+F3Blaee7vwwatnGafMemN7PObqaUenDHtdhHXAZTsw3A2GIn9E4KBgLTAS0GTYKpGZimxZgT4Pse4yUDQXxjlO2xeWyYCTwwNULLmOevt7HrnqvD2ZpNO4iw2xABmQB0jZpvU6s4jLgmHS3Pq26Re2OtYDhhFYK+cbUCZ2oWKwkkUoHSSBAEaX6SAnSjL7wULHTy/y0bYKW3RcDcFS7g+7mXVTPAtTQEuX2z7Nl4ns1ELWIlzlCGotefgpvkz21YxORGaMJ8Cj7iWlQ8myo3jdOZBoYQ+B6UDMgSaMS3X2s1Zmq7jAuYqkFJh1aQD7q2afG6ezLE5YzltO+N9iFToCJySbwLlAEEBDJ/NgKI4oQk3bmGNqjN+aPAi8D/yd5Os3edEoPdkAnE2eYKacUxqfom9W4+5bRtB9MAYViU/QzTMhj3Naqsbge89Wg7ocHDJ8o8G3TIRd9gTFRBs21cN6LezsvKJLR6kum6RtkxMTWJkeTCrAqMVgRGoli82+F/DVNA2cunlI0oYyHMUEqnm0hKpkIXuSDznPyZLpI/Bwl4Oph2bvOjd/crL1YHCRuw9fyDY0LFsWknkk4U4UqJa+qMlW1kDzw9IFXyhnY5TAxyAek6MF31qZQsTpRNHhuHzy/A/SMwVbWZawQYmsCzdap+ihnng85aRmwwI9jOrtsl4Ow0jJV8Flu5FlRyYbJi00p1TtZXMDv5lFzFsJCQzzSC28sfBg7g2hCloMtcsCnA0Hf+5AcVaA8D33wUp5glGxYGGI41QInNH1fdtym7NoZhULIzyo7NuGfjezqNhqKT6bRScYvwnBTQVbDRjoyeBykanj74Ix8HJmsOZS1jxHewJkMuLUKicg2gG4YsdG1OVHS8smAyUVRMKNsmK3IDdWAATHJNaFVrmKmDZkIzgV6U4WkajmtTsTWWuyErYf7MJ8suF8OAACgLuG9SUHUNFjsJUkLdg2jxpvDfbp10cs2z5OXBxM0MplXGyZqLZ5pUHIOSpVMtuaRahqcZjFaaxMu588aVwxm5VzXWCBjx4PRYiZpr0Eng5IjJ2SDhvnEH19DRVELJNpgu27SjDmVu7kS+yoSXX2xbAk2HmqWjaTpKgWVBzTWxHRunF+O7OjOuoGwaXFwICcJc+LoMX6A5wNRIbgLxPZM0SnjuOqCgZOxcvAwq0P4Y+HZy7+aRYjXoNWVrDXukCvdPbO5/ijLI0pgwVfgGmIZOrWxTFToyibGlhqnCW6YyusobzUa7k9tmbpd7EYtBJmA14MEpqHs2jUSiCYWt5dOrERfOTFZRukGUSAxh8NBUDdvu4Rs6GTqpuDuB9kAdpgx4YiHX9u4bE8TKQu/EnJ2oUqu4NIOMSsnh/LVFLrfgdA08yyJTARrg+XB6pMJU3cZvRCx3urTClO25UG7iAb4FI2WouDZZEpEBJdthsuKRqRDXNphrB8w1IkbKPg9POmRKomjT7YIb5ULxztv/5mxmOhgHJkoQ6TBdd/FcGyV0WkGCZ+nUvIQUjYVORDvJaISKsqnhmRo2kpRbBVoktj8TjDPophJPU5h6f7qpC0ZKNmGq0Y5bKKFzumbRaIbMAkrlbepuprdbMW3CmG8y7ts4jslycwXfU2i6wVy0c5fQoALtfwG+IIR4lXUzAaXU39txLfaR6ihML+Va2lYmyaptYJqbm4t1AUoJ4jgj0MAMAq63TBzLQEqNimcRBrc2xUyA6Au19ZPK8TKcqPlUzTuPkWXg9Sd1vuGeMZRhc21hhSiTaDqUSyZnJ0rcN11BZTGx5vDolIOpayxFgqoRE2Fz/1ibC3cxx6vaMFEx8BZSHAMs26HilWjJHmMVhxNVk3nb4r4RmyfPaXSRdAKwdMWoD4s98GzAAGEa1NyYhbZAZn1vKLlgEeT2lkGQ5FpI3QLX1AgsqJg203UXaRoYlkUsM5aaIdc6Ea7t4NkGVVvDEBDFuUY1qEfRIP8N15o6y/R3Ih+DUx4shhpTZYNJXyfNJC2gmwg6IXTChCiRZIni+hL0ehEnSvkgu16gauru7Itppkgy0ARICZqmYQjBiAt13yWTGQqB5+TOEdfoh9wkgz/3zXDI61whN4nUPJNelrHciHjpouIq8Hgl5c3TO19HMqhA+z3ygeEFjpgN7YG6g06I24GlVi7UVmNy1vbvRCm2iqzVNA3X0lGGIIoV7SijGWa0o4wwg5ouUOsGoETBiRpMZ/B8+6Z6nzsgLHRdZzG684KYcRceOznGdzx6glgKnnd0mG3R6kpEZlKyNOIUqo5H2TIJM43ldkirG6AsnZGKTrVqUr+e0NjW04NuCm7J52ytiWYanJ2ooek6c82EIJYsBBCmEKHzdWeqnFtsMFnVcGyLkudT9bqMexbTdQ/HMFhIBEmUEGUw7oMVgUo3D0YucWun1/rH4gwwNJq9kGs9eHBMQzdNXA1mqhZRkhK0BQYCISSNMOPCSsJKmBvFV2P51trG15e1igNM2rkhvUPedsZMsH2oOBYpMT00GqHkalehyQwhNHRSEgmOJqmXXKarFufmY9oBNPS8La6fhPXSrQfeVQxuDgZVG1zHoWYLWj0NTZNEqWSxHRGm4GiCzLAIwoRulq8qqVh5AHK5sb3p7Xo8cs19kb5zJIRymICmk0jJahbZp+YgUDtfhDXoFd4GnFBKbcPfditCiBHyoNy3k9/fz67Gtq07753989YKzu9XSn32bsveisyqcKJmYJoRZSehHUKWgelCezHXnMrARNnFtjZ/XJahUfFsJlyDxBGcHitxomrTCmKkBNvQ0EoeOks3OkjNg/smXWQqmW1HN9R7CzC03ID+4ITPZhMfh7zBuH5uE/FtF0cJ7hmPaQURy4Yi03TQoBdnlE2BIQ3iOGOxHbASJEw4UHJMVGjiWQlpvHFH2ggPOFvRed2JEUY8kx4Oj50sc6kZ49s9MgSGkjimjq0p7p0e41seEli6wYkRmzDNaMcpJ6o+FccgzsCxBRiCuKcwBUzVIQkhbHObsF1dAbD26ax2ZM8BV1Ms9RQiA88UlBwdqZuMGoLlMGNiNKUtNXzHwlASg4y6C1WtL0hlHlKwWq6zyS8xYuWhFqu2WBso+7kdyrN1XKWDzNBRWFpChoZraGiajmEkCF3DtTVGKw5lI0Z3YKYG1zq5EDDINRyHPKbO485uotH+q9BhtAwjvkO5bOL0IhwjwrZMHMdCJhKp6SQSdEPD0TWko6j6Fm4K3Tii0717r69L7iQz+jbJXgKmLig5FrYwbjzRBAjTvbOhPUP+jO5aoAG/Sf77TAJvAj4phHhaKfXcBud+USn1LTsoa2AenbQ5tyDxY0XFNlBoXGl06cQwrkGowz2l3DtV97ey6ggsQ6fiOqDpTNd8yo7JcpChGxLN1JmxdMrcNHTXPDhR9XG0jJdmI6Igb7gCkEojlYp6ycMnFzKrnXV1CmCRa3hVx8axLQwdLi8HBEFKqjRMy8YXKY0Qaq5CMw10AWGS0e71aAQZQVnHdw2inknVzRueSre2Hc2Qa0wTHjx6aozRWhnXtulKQazZVFzBZN1FKUHFNYl1kzSDS0tdGu2Qs+MVXN3ANAx83cAwNIJMyzu8ZeMYGugZSkKQwnQtH2S6vfzeTfIlXaMjYGuwPH+zYRrA5ChMj1UY9XS6hGhBhG7YGEKjbOlYhiBDoSkHpTRqZRvd1Cn7HonSCMKA+Q4IM++QDXJNZ7NOrekQp3mHFUDNgemajueUqPgWKu4xkqp8UDRsXENg6Do138MUIe1I0osljmExNaEzVSkxYme8fL2DntwMkHaAe+oaYUeyuMU80AVmqvnKliiF0ZJJ3TMIYihZFlN1jZm6x/1jHmGcMr/UJk4Tyq6N5ttEvRiVwUTFoduNmO2rhDUBoeqHoAyIQ+6QKsm8XiNlGPVthGGikps3MUq+fHCnDCrQngD+TAjxe9xuQ/vgnf5ZCOEDPww8ppTqAH8lhPgE8N8B79lelYeL47mUrZBlw+DMqEssJd04ZaxiMHoipaeVeWQMGplFJjaf/gkhsDRFIDV0ldJNwLclhgDXs6nYBomCByvwpVYu1UfKHrZlkmBT9RrMBnmH1YFMKZRSaLp5w3Hgk097rpI3jik/9waOV1zuGbERQkNISZikCAGeIUilgaZJTEvHN808NEEY6LoNoocSoOs6tYrPfVOKxcUWSaMfR9cvd63N5l4fHqzCs9dhrCoYLbtUfIfpqkMoBZO+SRBnBFHKQi/GMnSkVIRpxvn5Li83eiQyo+zm8RQRGcu9iImKzWjFwzMEc55LnAUESYZUGrrQMM0Uh/z5VICzYzAyUqekRTQ6PS72cmE/U4HXn6pxZrKGKTJKtkY7KVH3TUzLxHct0iQhkRo1x0YIHU0IbB18U6PZtyroFqRZvqDdUHmZFR3aG1jkZZavOhDk2plvw8xolcdOVEiFweyi5FovwjBByoya5+K7FvMNk4oNQjNBSkq+zb3jNU7WHQSSU1MBi52MRiMXDHUfJmo1rneWt4xpKetwelyw0FW0UhgveZi2TS+IcSyTccOk7jsYpkUnUCRKEAmDbqLopVo+2FgOrmXiuhoCSUwuzBLydjGo97MJmClM+7ljzbIsMnQcIbjSjSmR2wq/7SEXz9l5SPWgAu1byPvR29cdV8AdBRp5to5MKXVuzbGnyT2nG/FmIcQisEy+9+evKKWGECV1O0kiqdUrOF6Ma2iYAmzTYMQ1qXsWqaZTMRRXOlDzN3cKmLqgkwqUkhimiUlGmApGqx6eAVGicDTF/SddZs8FCAGGyqi4Jo6uqPs6/lJGh75RW8vtcjXfZMSDtJen/oljMLv5SoBTIzol16NWdkmEiW0alD2HIIzw7QxdSOI4RtctTtc9XNdGSoVAcqJqshjYPDBZ4XTFpOvoOKbgy1nM1XZISUHdyVcZXO3f47QBbzzpUHUsLvVamIaDa4Brmpys21hWrsE2uhGWqSPQKNk6aSzpxBkii/JlTraGZhhkaUSc5p432zKo+jamrjEzWkIKnbDXopnmsWSrsxETUBq4rsbZSReVWdwXJsRzCXUX3nR2jLecHaHqO1xrhnhlnToZvudwz6hDO1KEqUQmEYFuUDIF890UITU8xyAVGiXb4EQ1JZJ5MgG/mwuTmQq0ruWNci2+CzMjJsu9hEaQrxCpuBbVSgkp4eKCgW1IklSw2EnwbYPxqstKN6bZg7orqbkWUinqJRuh67iGwZtPj/Lq9RYvdUJ6SX/q6GlY4uZqhpjbnRclG6arFQwjw45SToyWuHfc49KKTicIaUQK1xRYpuBExeCRkzVWOgGNbsJI2cDEoBWBJhSjno1BgCK3Jap++9zMnrgWi1zzCg0wHChbJko3GC0ZGKZJq2tiE6GAqpYixM7Tn9xRoIm8lB8DLu1AqJS4XVNtsvHSsb8EHgMukm+l9+/JhfivbFC3d9FfT3r69Om7qphvwslRn8WWTiuWeJbOQxWPkucyVTZZ6EnGXEG5Jhgtbe6FiVNJyRKcGa9wsmrSlTpSZthIOrFAFxEdYVB2LdI0IAEanYj5TszrJsucnaxxeWWJdqufCcLUcU0dw9CZqAtsR3HfmMfico+rXSj5MFWvUPJtpmoeJ+sevm0wWbFJE5uFIIU0pYXNZEXH8xxGSza9KGOhFSA1E8tSSHTasaLsWCAEvtXCc0NUBmU3t8H0VvoGTQG2YTJdLzG60EXoOik6hqGRSI2ymWuwNUfDtUxmaoJ62aa52KMZRJi6wNbyuLeZsoUjMpaDBNcQCAW2AfVRH9/RcewWL16VGEFET0Ka9tMyAdUyPDRRYrJWwlQZSys96n7KAxNl3nh6hMmRCiOemQsuKUkzgUCghIFnQ6uX0Awly50WFccgQaPbS+h0ewjAM3Q6ekqU5tpZ1YSJqsaYA2VTsrxGPfEBz4KpeokwbfLsrMwrqmnUPBvXNvNBxQioOrASQpQJFBpBJkgU6EauObbCBENTuQarW8zUS1xfCTDsEDuBTgzXu7lQ0fplK3JtKSH/jUrA6XGHs2M+rSRiRDOplkwqJZexTNBLMkaFwncs4hQ0zeLecY0l18Cx8gEmTmPiXkKKzkTVxSdghZv2vDr8/+S9SaxlSXrf94vpzHd6Y85jTd3VzWqSTZmjCUM0aJmWJRoW7I13WliCQRiQvPRGCxuwN4KhhSFAgBaEIRiGQFu0LBqgTHOEm02yyR6ruiqzKseX+Yb77nTmiPAi7st6lVPlQDdF9wcUHuqem+fEjRPxxTf8v/9HLsMh0xNieqeV3Ul2emICTVIt4fw45dw4ZX/pQBgyrbh6puAbnyz5qIYb8w5rX7804XMVmvfeCyG+yevVrS55smRwyFNict77G6f+95tCiH8A/Fc8RaF57/8x8I8BvvrVr75a3a7QHJcOh8Qo2C4i8iTGC0kSGS4mmiKSjL0gS549XQ7BpMiItOHsOEEIKDtHXXd8fFTh8SgR0vM9Ad8zreDeccOb2ylfvLDB0aJiuSixMWxmMUJprBcUaY4SJUWecabQHDJnZAznJylfvLTJuY2C3VFOZz3zqqfpHRKIIsm5RFFECo9gVnZUvSPTIJRkEAW8UW0dZxPFVhFxdH7CtKy4ddTT+VBKNYohb2E4gu0iYTJIuLRV0BNxdpyyUyQMTxXuTyuLF4JhnrI7MHxysGIjj9hDclzBx4cl710TbKQxnZ3jveew7IhnHV84k3FtZ4J1UFY1HDoyYyjLloMGLmTwhSvbvHdlTJQXJMoxXdYcNI6tYcrmMGFnmFJEisSs8FJSKMdh7ci0IIkT6rbl9qFl77hmEQm2RxltV/PxcYUCVpGhcnC4NkH0mkfNCfEECeNIQpYYhIpJdcAMxlJweZJwcTNsGbszIo5jDB17i45zk4Tzo4Q3tnJuHzW8sTtgZxjjvOf2YY+rPEUUEWM5rjq6JiiTWMJmLriXSHLhyDUM8xC/a1cw9bCVw5XNgjzLGAxgjCAyMfOqxzo4O0zQSrORG4zR9M6DBaUjtgvP3qrD9I48idgZGBSKLALaoKQM678G4iYosVyGOtnGgesJNcsedjYV710YUImEjUwzThVSd2QRCKXJ44h4nfkvW5hVLZuj14ujvajL+ScEt/F7r/icDwAthHjTe//99WfvAU9LCDwuz8dLvIJoPi07qp1jI5MUseG47ImjiJ1hyqrzKKUZZjFZJOldcCufJZu5YWeUMZUlZWuJjGFnEDEVnizRGN+xX0mS2DyirBEOtoYJW4OUYZ7y0f6S4b2SVsLZzZztQUxZZ7xzbsjdQ00eG97cyhFxihCady9MePv8FltFRNV5Fm3D4arieNngvWczj2mdwCiJ8J6q6bFegBCkRhFHEVEU0ONpHLEzzLg4L/lGnGLiRbBWUtiNBIURbAzG7G4NGcSazUFOmkbsjAdMis8mS9R6QcdasGgtHslmrhhkMZIVrbP01iGlQAmF8z299ST0ODzDNMx7kSXs9JJJHpGpnka1fHk74r3rW1zYKehlRCIdG4OMy1uenY2MJA4VG957VlXPrLaMCs2kCBs4SzRGGQaxJlGSzkKqJd7F9P2cFhikjlFiaLKOWQOugbJ0tHFIAJwEkHYJWdjcaHLlGGaGjUHNJC/YHGYkkeG4arFekiWGRWlR2qBNRI/i+rkx95YtmTHYvkd4j7Owd3TArWnDj+9qyt7Secg0DBJDkqTs5BFG14xS2BoGPNmBsTSLML4k0lzcKnDSMMkkURSxanq2I42WgrZ3ZIlmkse0Xc/HZUMsPVFiUMuGWS+JpMcIQRzF7Izgzn5wIRXhGW4NbUkIJVNZDPvzkDjRAi5vwlvnNvjylTEog3eeSEuypOO4bELCK5b8zPWY1YcNu6OIpnn9Ct4XVWi/BfwrIcQ/JfQReGQNvUhSwHu/EkL8c+AfCCH+NiHL+TeAn378u0KIvwb8sff+gRDiHeC/5s+Zd+2035xrxSCJUMKyt+jorCXSijRWZJEiidQ64P/8e5ato+kt1gtiI2l7x+Gqo+0cUgis06TGkQ1TvnAW/D6cG8E4jdgeJOgoYmeQcHFi6FTKG9sFWmsubQ34mbfO8md3DtHK8M6FEW9fUlRdz/YgZZxFOCS960M9nFb0a0ttkii0Uszrnt1IghD01hEZSRZHRMajhGAji7kwzojjmCxL2B0m9G1DlKSMdMeDWnFtYtjdnvCVS2MsitqCNposeTKumGhB23XcP2rYyjVSSYpUc+3MBl86qnFC0DY9V88PeHM34d5xS2EkFknbWco2bGKJwGvN5Y2Mt3YyTLHk/EBzdpwyLjJQGt93bAwSvqQl13eHnNsYMswMzjl2RinTusNoSRYHHrhYaSZFyArvbqRoAZNxzkXfcuswpu0920VBvKXQ8ggx72hV0GHLDvzaK4qBCztwdWuEiWN6GeFEwzA2XNvJubhZIKQgNxqfR/TeIfH01uGtpeksq2XJr//+A1oJf+1tw86F86SxYtVHHDQNHydwfjRgsTqi7GAYBUaONInJ45pOgkWRakUSW7IGxrni/CRlNwBRlwAAIABJREFUe5RjZUyxXscPFjWxkijh+fDBgqpzRFqDVCRGc9y4QL6ZhppSj+Cw6jGtZ1KE+G5COITVmigzbgPP3+Utw2Zi8L5kWsPWAN7cGfHW2THXzkyI4qA452VL7xyzSqCMZFykvH3lAveaA0ykOKp+AC7nWn4GuMmTQfwXTQoA/N31dx8SsHp/x3v/7TWTx3eAL3rvbwF/FfinQoiCkMv5VeC/ecFnvLQkaUTTWequJ9YSJRXWg5YSpdQLByqrzlK2jiI1pMpzf9awkUaUwmBKS5YoJlJhvGVvZ8jSLtGZoeosjZdI70kjzdtncg76mI01RMQYw/WdIY11FLHmyu6ItrfcndWMUkO8jltlkUKJiKubkrZpuLdoKVtHpKG2Hut8CNQLQRpJdouI/XmLAPJUk0SaPNG8c2ZM0zlub+QclBbpWnQmubIVs7M5YGuYs1kkTLIELzyD9LPWmXOOe7OG+4smPF+GMqftImVrUOC8548+nlMLgZcRwyzh42OLEz4U0Vcdq7wjUpI0iRh7y2SYcXlrgEkzbOcYZjHDLEYpxbK0WCHZHOXsjoeMi5ApazpLEkXsDlOsdRgtSWPDMFVMV4rtIsL7gliB1JpRatgc5dw9qjm3mfPOuQHOQWuPaaKGHskgixgWNfEUzkTw5bMjvnx5g41BhneWr7cd2xPN1d0BkyIn1orMSJx3aO84mJccVZ6zA4NSkq9/MuUWgIPf+G7Hr1xX5Dqlbwz3ypj/6L0xKh3xxzcM3767pEgiyt6jpQcZCrtTY7iyk5NPFZHpubY74uruCC8Uxnhic/JuPdI7jlYVZdsziDTOC3ZTxbIyXEwdsVYcLWuKLApxOueQRrM7SBhlK+IAp6PqQ6mf0jDKYWsy4As7BWk64/a0ZKNIeffChItbBXmaYIzBKMmisbQ9WASJFKRGcGm74Ge7hmlvOD98feKmF1Jo3vt/53Uf5L0/Av7mUz6/xSlKIu/93wf+/us+73lyQsGiCW5R23u2iphzG4ZJajDrhfg8F/NxGaWGK1sF4Lmxd8R3H9ZksebcJKd1np1BwiRP+PDhjCSJGOUhrrA7iNjIDLOqY2kFwmT4HqanQE9CCPI45tw4IUsipkcl87pnnHoma4UbG0WkJZGW7BQxg8wwzg1aKagdaaSRUmFdT+slViikUTTC0HWeVevJUyiyhJ98Y5fLmzk3D1b4vmHeSs5PYoQOTocxhgubirJ1xOazpmvZhrDwKFJMEsO4iOkwJJEhjSOubKbcXnRcG8ecG2fMFiVb85ZxqvASvHX0FgZJxLtnhyw6ePfckCRJyONwAGSRJjYKKSV179FCMsljxnlga/A+WKhIwflxxmHZkmiJEGKN+eponeDCRkZvLdPKkxvFWDvuIdjNFdd2JjS9Z1xETOclh4uOLJKk2oLumMQSqYNb/N6VHerO0TrYXfb86MUNhlmEEIJlbZnVHffnDTcOa+4ed5wbRbyXGGz1aZ5wM4drZ0bcO1xwmI54bzthe+cM4yzmowfHKFkjhaTpPIcVpAaKSHBle8RXLo24P865ddTwI+cyNoqUxEh2dEJqFFkk8c7zcFFyOKuxzjHMDaNUcVB2dL3DJIbWQ917siRikEi8EGRa4fqC3XHH2EDVtdxdBYosncG5kSSLYq7sDNid5JiPjxmmEdfPTdgeDZjk4eBpOknTdhwYyXZqECoko/reIXVCqgRW/OBqORFCTIC/TsBV3gX+hff+ZStl/o2Q+NTfqvWMssBPBVD2nknk6d3LEf0lkWazSBHCsX8cUeiKxEiKNCJdVNyeloxTxblhQhqbQEGtQyyitxalFINIs7uTsWUV17Y+DY46LzBGoWSwsHaHYbPsDD5LtyKEoHcwax1GKHZGGUUSsTevYK34BolmEGtyDdZZemsZZopJpuisp3OeSGuu7o7ZHhX0fU/rQuZy3sBGHpZM7wAR/p52x1MjgkU2iDmueoaxppcG6+G46vjm92/zrz9YcTXeILt2lskw5dJmj7cdi7JlOzOMs1D2NRWC0UCRJAlSSkxk0FrTOU/TWax3JFqyPco4O0pQKlirnfUkkWSThN72LNpQxNj2llg5jsuG6bLC+4SzoxgrPE4Klq3nsOu4eVTxduu4ujNhY5hzf/+Yr92cIpTkzY2cNKtZVRYTK2or6axgd5Ty3uUztNaxMwzjbXtH0/W0vQ3JJiqOVjVdkyKEoFYZJzDpL11KGSSG+bLk1mHFj2QGECxby6xx9EjGuWYrj6hXmo085spmxnsXR7x1boMsWZLGLdfPFCgdqGAneYRRgs56GueZ1xatJYM1+Ptg1VNXJXuzhrd2MqIoHK5WSDZjiZeKWAn6puWdC1tcHSluHJToaYXvG6xMePtcxu6kYHtUBOLQDs6OE949v4Exhmh9kBglmJWGzVGGKxwIQaJgb9awbHuWfZiv15UXJXj8KeB/JyQFPgH+A+AfCiF+yXv/B689ih+wDAhI9xzYHkYM01CsvbcIOKlYa4ba01lPpF/MSuusxzqL9XB9Z0DZC7YGCXlk+O3/50/5Z9+Fv/UO/OK//RM0rWXWgVlZqoOSS5sr3j2/wYWtgt1MsbSSQf4pyHCcG6SUDJLw0o3WnN94OndUFkk2s4ijvCWPDVJ49qY1o1SQRBFJbLBe4AnQAa0VkTY0VhAJj5Fh8QkhGGYRnOK8OI17DNbrk1as9YI8NXROsLfoyOKWs5OALxPO849+b8YU+O9/4yHvvHmdqrVIYL/sqDqBkoosiUlNqJQ4CdZqGbJ5Sngq6wKUw0OqNZc3I7JTWtUoAZEh1o7DRR8AyiJAa2or8A5KK0l7S2M9eazYyhQ7w4ThtCFdV1TERjGRCWJzwM68I9GKr5wbcHFeszev2SkivnRxzGZhUEpxZpLRWf9oTk7mUSAZ5SnT0nNv3nLzIBQufelMzJXvwTtnJX/zq1eQQvDhfsNH0wU7o6AMxpnh3XNDnJBcHcdsDnO0EFQi5uwo4Y1zG2RJjFAN5zYMZ8YFUgXXWim5HgcUkWKziJikitZaqtaRGliuYGUl9+aW7aEniSNGviOLFSZKSJTl3iLiyqbkykaME4qNYYbyFq9jfvbqEG8ydkcpsVG8d1mzO4zIkrBuvPe0a/hMEinOj3OEd0yrnkQLjFasyhJtA0zpdeVFLbR/CPxd7/0/O/lACPGfAP8D8BOvPYofsJxskgaoWsvOIGye3AgSo9kZmBCDeAmXE6DqHXXb42xPpAXOhwX9v343lDv9i/fhP/x5R1m3eCznJimTjZxRGtF5yblxRq4FvnFE+tMNqpRiUija3q1JJuUzFa2UkmGWMMx6pFQcLGsO6x4hFVEksNYxL2vuTEvatieOI3YH65PceSIlXyhuKIR46hiMEhSx4dp2zqLuGCeKZk2MGRn9qOpgRoi3VU3PrO4pm44GQxYFXjQhBFmkH53anfW01iG9o+0ck0zhRXCnpPysqyKEQEvPcW1praO1IVEea0ViJHac0HQt3otQxeAcZa8oEsMwS8mStTIQIf64UaT8+OVN8khxebPgjbOe/VXHThGRp/Gj+Xp8TkKoQLNRxEg8rl2xLMF2FUYJ0nzIV673/MjFgt3tLSSORHVESjMwwWL2QnF5e4yXhnOjhM1Bxu4gIooN5ycJ5yd5sNpHKd5DlkSk8ZOWexobstYyKxuq9ZxWfSB5bCxc3ogxxtDbjrjXZKkhigwGSREZxnnEzjDm/syyNfCcGRdsDYNl3DpJFoV1c35Df2bfnLw37zxahQRE2fYI6VBKEXv/qLZV6x9ccfpbwP/82Gf/C/A/vvYI/gLkxObQhCD0cd1jnaPpA2TAC/UZhfJC99SSwkgezluO50umtWcjD67hj27A/SP4sS2YN5bGQR5nfPn8mIvndthIJSiItUIK8Dget779uhTqxIJ6mngfXLG+70nWisEIwyRRXN9KSdOMtrM8mJU0bceqdwxzz8Nly+YgRQj56DmvitoWQhAbxbjIuHrG03eh+UXbK8aR5ksK/tDCOxFEWqGEx+FJhKDsfMDpuUceMtZ/+ts661CEgLhDMngOLrBsg/KXiMAtZhRJJLEeZrVj2QbrO4skwgqU8Fg8wgcQr7Uu1OYmmlGiKdIUh6P1oZLgWv5iLdeClSdxziHjnDReUFkToBNGUWQm4AS9o3OOIjHEokHKUHXiCYH9cZGyUSSM8pjeea7tCrYH8SPltVUkzOun49699+H5+HWtqabuBcu6o1KCzWFKHK8DLEIxzCSx1qRGMYwUO+OcC+MECHO2Ncx448zkUZzwdFro8UPuxLJOjaDuBbHyNC1sZoYsUnz0YMW0sZwdaPLkB8dY+33gPwVOs2P8LeCj1x7BX4RIwAUcTRErciOpe4GRwV14SV0GhI3sEHR94J2KZShWz2PFf/ZLX2D83Tm/+EYOrE3vLKZIY6arFqMisjjEOpQWRPpJV+5RfOs5FlRnPbOq45Pjmrp1LDJLawVbo4wiTQLMwii0gumqZnVcc9NBZGp2R3nAJVmHeAlX+1kSm3AaH1UNs8pSRIrGwrmLMLoFX7weoaTnqOyRQpBnEccLS9X3OOeIjUIQMrJCCLwPms0Ix7SxbGfPd0+ySOK9RrieVWvpvadqHUpKhHCsGgsIVq2jsZJMe3oLve3pnWXR9BSJweiQJYy042DRkxhean2cWG3eC37hnW1uLBxfPD+i6XpGg5QLGw2xMuzNayIpaHpBh2O/7Gh7i7UBBhPJT9fEODNIIRmmn2bhpZQIKZ44CCGsi0VjKTu3XpOapG15MG8YRSCUItHBw4iNxEjx6CBBBrxaGhuEd+SJeZSAepFD7yTWumosi9aSKEFlHcILlArP1FKxUSQk5gdnof2XwK8LIX6FEEO7ArxJiKX9pZMr2/D+AxibQHxXJBEDIZjVXVAc1j9CML+MpEaylcdsppJZ44iVYFb1XNwe85OV5MJ2zv1FQxrHSAT7y45eLplkIwZDRW2DZZRH+gk36lkxqxM5sawSLdlKNXu2oW47nIfMaLQM1ug40WwVOWdHJe/fn5PTkEaCIpKf+4wXlZO4Cc6tLQPHdDrlz/ZbnA+p/jhJWDaWzlqsg7FeB/o7S9sHd0RrgbViHdiGSMl1vWRLFmnOPyNr471/BIReNKFQXopPY1LThSaPBIOIEElcx8uSSBMbTe+h7S298yjCelg1loNVyyg1ZAmfi0t8XIQQmGLI1e2aXsZYH9h0dwYpmQnvbpBGXNrOef+gIpM6WFZ4lmtrs+49OZ+GIE5LHqu1m/7kwIwSDGKFcxrnwr1CDEsitURKQdV5yibE1lQkEWKt+Eywar0HKQRSSpR4uuJ8mpysqXnTMV01bKQaoxRKgsSzXSRc3/ZsDpIfTC0ngPf+94UQ14FfAs4RKLn/5RqK8ZdOdgbAg9CrcX9W4S96EqMRTf9aNQlSSiKjWNYWowSrztOuGtrOM8gMi87jeouzPa1XWBtYOeq2e+TmRTrg3x5XKs+KWZ3IiQWXRJoiS0hbh1xnqcq+ZbpqKXuPEQ4pJaNYYq1DxIrUaBzykRX0utL2juOq5ajqgvsoNV+7scfvfrLkjIN3dgZ84eyETEuGSYTzPXcP53x4sOLyICxJLcNh4/xJciZYBKly9NazlT/bQmt7R9lalACtJEVqGKURWaSoe+i9Z944PJIik2SRYZzFXJik3Jn1bBfxI6uwsw7vPakJynAQ6xdS+H497pPEgPeerTzhrd2MK5PA/9Z0PUUsSY0kNQolYHeU8fZOQZIarLOUTU+mIU80qXm2FpVSUiRPvy7WikgrSec9XW8ReLRRbOeG2km09CyblsWyhjziwiTCKIV1Hi3Dumx7i5IhHpfHLxbAP1m3eawZJAYpQyJAIrDeoXQo1P/zsM7gJWAba4jGr/65PPUvWA7W1JGLGg7KlmXVkkYGFfoEv5LLCeHlCRGUSx4HsGZtPbGC1otQqN44ut4x7xzLTrGygk+OKs6MC0wUPVJqLyOn42uRluRGoIRgMze0vWV/0TA0jkUjwVnmjaeqeqTSCBNcCE+wQjrnySP1CLD7KuJ9QMQnSjAaxJQ9iK7leFEzSUJp1Lx1aK24sJnhpw237tY8nNbs75QYFSwA7z115yhi/2hjLHvNMIPOq+fCapwPVRDjNMJ6SLVal30FK1ZKgcSihGS8jsW1FoyWJFphlKTpLGbdujaJNDvrg+ZFLImTYDgEZTEre4aZ4a0zE84MQnXHSQZUa4VD8GDR0PSSnXFK7RXLxpGmDi2Dwnvcan9ZsS4cemmk6J3B04dGPLGm73ua1nLYWHrRszOCQgq8c2vYhQRvg4WdvPxYkkhzdiQfHdxawnEZzLxEnViBr3+gPlehCSH+L55Pre6993/1tUfxFyQa6JygbENqv+4dznry2Kz5ul5cnHM0nV0j4xWj1DDJQ42llqEc5GhZUyQlw9TQCUGsFF6qQGjIp65abF4uKP94fG3ZOMrO0vTQ9B7be2SsGOah4eOibMiV5+zIsJEYjPCUTc8w0a/cyPZk/J0NylVJEbJYRtAD4yJhNKiRsqW2lqr3SKmCa6kE1trQcX7tLp4YG+qxfZMaQddLUvPs+Ym0JLYK5x298xglySKFllC3PfcPj7nzcM6VrYSm6zgqw0YrGwvO0Tq/dvcEZm0Zfp6F/LgYFeJm3ntWjaPqOh7MWuquZ9YohplDS0EcCerOMUoEkVTUjWecaLTSjLOIPFJI4deZ2leXSEsSLSnrlo6glCyCRMtHdZkCh21bRCQZmNC1K9XukaW6qDuOVi1HZcvW6OXW6Emy6GSNdDa4voJwCC9bR9s70tcsFvg8C+1ZFtl5QuOU1+9q8BcgWRxe4JkxnB8n6DUI0q3hBa9ioZWtY1o27M8q2jUNSmxCHWNZrvjTe0sujRRIxezhfX5vD96IEt5+8x3GeUQWa8o+nOovg3+DT+MUIaPkMNLR9w6BJTeSItFsppJpJ1EebpcNnfbEcUwtJA9XPV51pEZhnuLuvqh01tP0lu5UgMV7T+ccSawoTMTbE4UebvDjlwZsZJpV5Tkq20elTudG8aN7QegpelqsFxgTyAKsd0+1mAJcQrFqoOkbDhctinBgPZxX/Nb39vna3TmrOsNJzWbek5uCXId4FbbHes8gVus5efX5cD5AFqzzKOGw1tP3luOypel7mjZcnzU9RaQ4nFV8eFjzk1dHbAzSABb2Ho1/dOC9qJX4uNsrpWTZBTf27ChlO4+ouzXxjxD0XuJQ1A72Vx1pIhEIeheeG7CWbp34erk1ejL2uu1DHan0HJcNWkAW6YBT/HOIoT1363rv/8np/4BfA74A/D3gnxPgHH/p5MpmwaYJLde2BilKSayzrJqe7jnNhJ8nWRSYVZu+Y29WcbCscc5hpOBffuMG/+g33+f//NNPkHh+9wHcmcGvfVDTOYEQIaPnrAuL9xUCzpEOm7zpLbPa4b0LOCwHSgnuLzqqumPRWGxvqZqOuqrwrmMUeZTwtL3F41844Pu4GBV+w7LuEM6uGWcdVd1zXIfWaSJKGWYJrY84WPXcP5zyrdvH7C8bvIdVR+is7v1nspynnxGtzbYT5f+sOcnjMK9V16/frSfWAo3Duo62a5muGm4eVczLmo9nDQ+OV3w8rSmbjumi5IMHc1bVyzPqd9bj8VgboCdaSVITUSSBsqezIfQQ4EI9dd2yanoerBpuHFQ8nDekUUQRa7I1QcKJG/us3/y0MZz+fh4rNrOIRMvQ8FnKNT4mYPTOTxImqWTV9szLmkhJikiCD0oxFR3TsiWT3Usr+RBX7cKhv6g5XDVMVw37yxZrQx3p0xIaLysvWikwJHCS/RfArwM/5r3/ywnZANy6ZmzZh7KjwDzg6J2jf0XTVwjBRm6YVwllY9eZNk/btvze9/Z4/75jS1ZsjYdcicGO4Ze/OKLr7Rp35ql6h1HyiXKiFxWjBG0vSE0YTyI9q6pmf1ayWyi6dQYzMYq6sezNWsTCspXHnDEJae/QyvPc1gmfMwe98yzqHmc7pouOCIkHxrFko0jJU0HZ9DR9S9m2/PGNI/703pKzzpKaOBAu9qGVtlLg3NOzridWx+dtLC0FsZakkWSYaHIjODuKSW9LtNTU8xnfnwlG0tLVDYu2Zzk74nc+kFxMKr5xqPiPf2SDn3r3+kvNRXA5JUYGZZIaSde2HC5KYqXYyAzCW6arFik8kdEMpGBkBINIspmacEgqRd36R/dU6sWz0I9nraWUbBQJrYPOeWLnA4yis3Sd5ajscd7TWuisQEtJ1fVMlw1bheZbeyUfPVzxR5nm8ln3qNTshedECpxWNDoc2kVicDa4+MY5qs4zeM3cwOfF0FICZOPvESiEfvYZTU3+UsnxsmTRwf4qmPFZFECEiZYsmoCDelnprA9p9STizMix6hx933P7sKRuHeME0jTm48OK4c4Gv7xVcPXSiM5JBOHE1CK4u6+TlMgiyYM1N/Ci8zycLvn4sGQU52yPI6aLHuUdzrbMy4YijR5BO5JIo7V4ZYUK6/hhHlGWHcu6YRBHpHHMxmjAm67hTOY59hG7wwTvYW86ZzHv2R0G8sEsSYLbaj2ub7m76Hh7O2O4Zgtue8eqtS+UuGh7R9U7hJD0FhaNJVbQCY0XEicVf3rzmD85AlPPeePyLt5ZbhzWrKbHfLtZ8sAqLhS8tEI7sSrLzpFHYZx35zW3j2tioymymGXVcrDqSKRjs0iITaA5yrOe0joWVcf4FDyj73uOVh07A4Mx5gmX8mljOHELT393nGiOy4ajVY31QbmVdceDwzm3jkouTVJ2RwlZrDicNxyXLfMq4uok4huZYRx7ZlXPRvHiCi1kqQ2jVJNFob41jzWN87i+Z7pq2cw0gULy1eXz9OFNAqfbfwd8HdgVQuye/oL3/l+/1gj+AqR1MrTNsoE3PYvU2mULsY7ehRPx8xbMaTEqZIJSo1gohbKske89b1/c5Op5ybu7KXemK5zzjGJJnsTEkSGPDJ21HC4bJJ5hFj+Bg3veWE6uaRkAjHVVcvNgyUaU0bY9deeIZFAEe0czvn67xtgF9+aWd/OYa9sDzk8yjBKPkhivKrFRjFNB31S0OKy1GCXZyQUfHDgSKcFJEqORWnE47Tko4Z0MLu4M2BwmRCqUM314UPKNOyuMcHzlFP35i9gnJzEbhUf40CN1JMAIxTjVnJ8UXNoc8JvfPGYFfO0O/JV3AvmjsSEOeiGG1qVcnTy7KuBp7+V0cuRkrG3viKVgEgdE/EZmMMJRRJJIBdBxs6aS8tZyd96xrFvGRRLu1zseVh2HZQdknN8wn8mkfl4863QJ0qoL7t/xqmWYKCZ5TCIkf7xsuXvcMsgiskgjhSSWlnnbkyhHJ2I2BxFSRyQvGD87PT/Bg/BYHwC13nlio2iExGFZtZ7nsNy/kHyeQqsJWc6/86zxAtdebwg/eNksIjJaCgOzsqdsLdb23DtaMcpCgBJ4qQUDQamtPCQKiFSgxPEZP/fuZTYzzb2jFV+7ccTd45ZrmymDWJMlEUJKFmXJrcMFRuacnTxJQ3wScG978QhEefpaax1tD03X8607M751e44RlqF0VLVjVfX0bc137q/4+HCBXbRMBbyzWZGnCfG6dhDhn2uhfZ6SPxlL2VnKqmfPBrqir/3xB/zaTctP78LV69cD84Wv+YPDUFP70QH88m7B5rAgi1QobTIC4S2nE86n2RueJ926W7BDcLhsEUIwSoNi0tpwfXfA9d2Cg/X391lTabsATYgjOFvEbBYTzm8/zh7/5O89vUZOPtMCjArJmtp7slizNYyJTGAfnq4aQDCOJVp4mrYnkZ5hahieqsc8ud8oDowr20XYti8DhD5d3I9zaBEUfd0LytZyXPYo4fDOoaVjWnWkcc/9paXuPPulYyNVSBlqbF8UtnF6fiD0h+2txdrQrGfVwCTVa1rw/48rBbz3V177Cf8GyrnNIWcnS/IIHpQtmp4Hs4YPHyz4wtnikSvzMgums56qczjvaawk0YLGCkZpwjhPKZdz/uSTA24+WHLQwb3pkv1VyxkVNu901TCte8rm6cCJk/iY58kM0+ksZ9MJvOvpOohF6Gw+q2qOK8V4lJAZRxYZ7s1bbgH3pvPPZM+azuOEw/vnK6xnKfmu67g/q/HW4oHDqsfKlv/pO5YF8L99DP/5pZ6qs3xwf/mo1+XFbdgZp4zSYHn03iK14fJWQZbGn8nuRTrAPOaVXbNKPOn6hDlRDGLNKI+ItQyU6KuGzgkGiSKNDJeAW4RTef/BPf7oZsuFHDbPKobjgnycMxk8m+f+aWvk5DPvwwFRdSHTe7RseTCrGaYx7dgyLwN1zjA2xNZTNw17pUXblqNKY7tApW5USPpoLRkaiV+3UwyKnfUBw3O9iN6B88GNndUtiyokIYYyAGa9d+ua0QglFcuqY5V2XNvI6L3g0jilsZ7dzAR3/QXDMo/PT2okdRvAvUaB947eSZIogLtfV/584Ll/yeTcOGUr1SSx5PC44v0HCyaZRmmF0Z9aPy+DPTJKkEUKb3sEIWtjlEDIkEX6/Y8O+b8/fMjxEdgIqqajqluWkaayUFc1i7LDu+6pAMOTrN1peprT107GmUWKS7tjGq+4tjvk1sMplhCQTSPNIE1JZMOHhO4837m7VlJ9UFL9Gnwp5dMV1ucp+aOyY29aMYo954cRyzKcwCfdcCygtcQ6x2IeCA5z4MyGZn/RkscRozywgnR1yc2DFe9sKlqbc1qJHi5qPjosub6ZsTN+usI5mcdJFjNKA8VP5wKu6sGDh7y/t+QLIziawU9fh3/yhy1TYLqCv7015McuFfhkwEbx7H6RT1sjn9ZveuiD2121FrAcNw6tepqu53hRMz1eQR846o4bT9V03J/1mFXFN+8v2N2c0K7dsxMIjPefbvznHTCPu3uLyvFwUTGvWrrOoZTGe8t05ci0RwqBlgJp6BPjAAAeHElEQVSJpLeOurecHeV88UyMVoLCWzbHGUYKqs6RvUAbzacxkPTOU3Y9XWVDBYMUpPL1qYPgc2Ab/3+Vu7OWu4c9Hz5sma0ayqYnjwxv7uaMc/NKSYETeTCd81vv73Hj3hTvPZFSREoyX5WUXagaSGNwruPmwYqyrpDC83BW8/27U+4cLJ+alncuFFRr+fyTGEKfgjPjjERLVp2niIKrcLSo2btzj298XHLyC3cSArPDGuekpXguW+8JRORZY0h1sNKatqX3MEgNQmk21tcjoFxboiuvGQCZgrZ13NxfQN+QxwGY/I27C/7gowN+/6Mp0WPZvaP5km98csTR/OndIdveMas69qZzvv7xPg+O54/eh3WeP7xf8scfH3Fr3SX+1z8KvPAnsjNM8SYhi/QjFpK2dy+FZj8B5C4aS9WGIvxJJMiMYFa13J1V3F50PDwu+dP7NXcOFpSNZRJZlISNRNLZsPnnVUf/FHKCExjL097XadiGEAIloOwssZZcHAdygKZpuTOreTBv6fo1O0kUmrokWrFsHbMmYMc6LxnFGi9CY+ZXkbDGJJmRHC8b5mVDogXZa+D9TssPpUJbNS17DdyfQ9s2bBSBTUAKRdkJ6v7lUdknG+g79+d869YRf3R7Rtv3FIkmiyRD6YlUaLIxLaFre2aV4860wSNYtj2r3jGv7VNLn8o2dHQPFNefldObrbOee8cVt6YVd2cVq6anaiwHy5p7xxW/fxf2TvWiGE1A+FAfaa1lVn5aV/oqEnB1guPS0XaeZd3w8eGSd4uQv/qRFKrWUbWOHzuXEQMrC/enjg8eLLh5uHwE4hwYi3eQR+4JJXpY9yxqy+FTKHNO5kMK+ORwxZ/dmvH1W8fUbY9RklVdUU0hjz0/fyXc8/ixe1gByrZ88GDGqq5eGgN2IkYFNH5nLXuHS+7Mm3XBfEdZd0jniaUA2yClZmtgqIgYpYY8TchjhRZiXcoVYnKnN/7zDpjHlZ2UksIoHHB3VnHzsORo1VEoj8LSuZa67Wl7x1ZmQs2mEY8y76mRSCXp+hBeeVURUuD6jo8PFzw8XrFqulea26fJD6XLOc6SwFoggys2ymK87ZlXLedGIbX8KqKk4MzAkMUR2RrNLkTIHN5pJG2/5luy8Ml9+MW/kjJJNRK4NjF8e5Dy3tn8qQotgA71U8GHn3U7JL5r+d6dQ2SXI4UA5Vm1jk7B4NTJeiaCnVzz/v1jzm3k5EZxb9kRqfwJksDH5VnZPeEDBc1mLHl/v+Jw0XDcCt64GtMtJT+RVdypGyYm4/aiYxqmg/ePIZ/UtE2I7ZSdY5DnvHtecn5z/MTz39oZsGoFb+0UT1w7IcKMteLCKKLvGo7mkuliRZzEPJyuWCm4WMScPzOCbz944h7LVcOtqeOjmefcyHB+a8KrMpEIIWjang8PV9x4sEDa0LneSEfVNcwqiRMRW4Ui1hIhPEbLwDgs5SMU/Zqn8oVhNY+7e0WiSWPN3VnF3dt3+M1Pav7dKznJcIOPjlbsTefcO66x3nN1O0dFESscs1WHTRR5nDFOIxbNy3dnOp35bXvLx4cle8c1s8RwfdUgVdgzPNH59OXkh1KhXT8z5N1zEgecGWbcmZYk0nFUOSzipQGDELJvuVdMBjlfvlCxWyRsZEEpJBquphZ96lA76uDi1oiBgZUVTFuBE4K9yj11wT6PTeEzcS0VGGJvT0uqxvGl3YhYKDZiwcI6zm7C2Q66JvRXXDjJjf0ly85zfmjYX1guDD8fWfus7N6qDzGeWeO48XDFcrXi/PaEqztnKBaK1eyYWw9X/P4thaHnZGvsGNBas+gVAkfZdORGcWkj5uzoyVz+5rDgp9/Inokul+tMqNAJWRxxb9bxyeGSKzuag0XFooK2a7g7faLXNQD3pivO5znjLGErfTVslHOOWdnTuxAze/Bgn4+Oes4MFFWV87UPDvmjIzgr4KtvGSbDlNmypmx6Lm9Lskg/AmhrFeJb+NfDKSZaEivBr/7OjJvA7VsN//6/Zbh/tOT+w5L7JWTJkjvHNTJqKEXPt++XXNxM2SxSJnlowl28JBnjoyx9G3qyBriIJk8jJI7jqmGcqs89SD9PfigVmvCeNImIpaCxHd9/uOSLm4GQMH/F1eK9Z1Z2zMqaWdmRKkXT9QyAqvN8MPPcnX/6/fsE1gnrQxFwojVbg5jtUfLSVsDpk9g5h/IW5RyjVPLNbxzwm0uYDWH7zTMM0oR3duHew5p7FRwuQiu7wgjauuKjhw1vbGjYftIqOi3Pyu4lwrGoW8bG4oTAytDH4OqZIcVEsH9/yYdHGiM8bd09+rdRAj/31iZfuTiiDdyLTBuIo4jKP3nAPE/BR1pireXhvEILxxtbMfeWoaHKrKyp6hajoW09v/Od8qn3aDpLoj06MhTJy2G+TqRsHY21eOvpnePuqme2gOPKclz13DgK/T7veej7Et9m3DsqaZuOxSpwxTVdKMkzawbb/Xn9Gc7+FxXvPYuqY9V0KKW4uf78LnB7b5+9yoXO5z54LRuppu0sdd8yr1qsjdfVDyHO+rJr9CRL37ueo9mK20dz5suaJFIgYFF1VJ1l8lJ3fVJ+KBXah4cN91cdibWUvecNGdGOCqJHWcmXl2Xdc7iquX1Y8p1bR3ycxFzYzBjkWeD26hoe3zqdDS5a3VreODvm4lnDtc1nE929CNB3UXXsl45ICuI45veWoa/Qb8zhF46XTCLFj725xYO7n7AAVlN4Y6fARDEf3jridz465nLu+OKVc8/9vc/K7h1WlofLjnQoeHc3485BT1l31L1lezAkYYef6Ja8tR3xvXvHhIaCcHYCP3Flg7woGCaBG6wdp2ij1vTPLy5CCGZVx/v3Znjv2MgTGiyDNOJo1bDsPYkKTVa+fapZtyEoGAM0tufm3gEflRXnUsu5rTFt//nW0el3FKxHg7WhEYxoQ0LojQ3DMBKsWazogRvTnnFWMa8tNz5u+PDoLl8YN/z8V7/Cwbyk6h22U9yZWSJVvLRC66ynbHv25zXHZfeZa3ul43v7MAZ+9FrCL7yzDSLUwJ7NFJNMs5mHyoS7xyUHixa5U7A9enH1cZKlP5w7vn1vxm9/e4+7q4Yf6xxfvbzJ5jAkYF5XfiiTAiPVkyvBZg6ddVgnGOQJRhl6/2pT0vc9h4uKg4Mjbk7L0P/SeqZlS2c9P3plwrnHDI2mtwjvEQJGRcoXz49Jkmdv3hcJTDdtT9t37E87vv7xA64TYBF/YzOwjjqpuDhKebD29T6uQSrDKJHcnjcsqoYb0/qZ93+eeO8pNGhpsV3PQdWxN2+5ebTiYF4RGclGZtgYxFzeGjCJPvXB7y9gUTXgw1zePlqxaHrGaWje8bLStw23jhYslgseLFusC0yv3/3Wt/jd+1A28HgkqAMua5gAR2XD+w8bbhwu+aM7CxZlxTfvTFmU1VOeduoep95RsCL1GggtGRaQJpoz4yG97Th9p/tTOKpaLk1ibgAfzeBX/o8DvPfsLxoezBv25jXLqsXal49hnSQnlqsV37l9zLvrz39OQlsGBL2TsDnMyYuCB7OKD/fmPDhccGvWcbSsqDrHYrniz+4dsyhXLz0GAK0EqVG0TcPDQziar4iU59IkX3cZez35obTQjmtLJyPivmcuJZdHnkuTjJaO3ecwoT5PWget9dyY9jR9wD596fyEnlArd/XsDpfGn3DnFDYg1pLOdhyuOsqme+a94dNGF9559HP2t5CC5ariRglJBT99VfGLb1zhTNrx298/pi0rPtib8++dgV/bg1++CvvLhq2B4a+/M2JvKfjFN5+NjH+edNazaHvmlaWsWr53b8lH9+YMx4aqySjrnv3DJR8+rLm+abh79CmLxUdTuP1giooz9l3P9x8uUAg2iuRRs9oXpc0BuH04488+WTCSC25OG7aGI37qcs5/+yfh+iFwTUou4Lhz6t9FEez30FjHUIB1LedNzXfuHvGvPzgGO+an3n5xoK33nkXtyGLFYgn7xz33Do5IhuPPcM9tKrg8zjhuPnuYCCHYHsYUnaMQDd9etHyx+3TeXrQ87+Tan3x4l3/1/ZK768+/52B3rQUaB2NZsTevaZuee0vH4cGcbz7s8N2YH7m0zcF8xft3Z7w1kVw7u/2cN/CkBEC44vqZAZM0VIjcmTfcmzW8cf71CSzhh9RCm65q5quahy3M2p4HK8/esuXm4f/b3rmHyVXWd/zzm8vOXmavSXaTsFlCSAgQGsBwEYiI9AEtGpEiVahUuVqtVauCPAKPLa39p1J4bEVLRa1WFCsIAopY7jRc5E4SQrK57CbZ2+zu7M7uzM7OzJlf/3jPZGc3k73Onjks5/s888yZmfec85n3nPd3fu/t9yZoH5idd7I4XMZxS2tZtzTIsoYKTj2igkW1YeorTQiY5obwIWF5Bnp7iY+maetP0D889ZN/JJ0lnZ08vE+4PEh77whJYFTBP2Lx4u4IB/a10xqJ8eKeNA+90cHz/ab61JqArqE0ZC0imRBVFUG6U7NrmA36hf6BGG/t62e4P8poJkVvDHZ1pWnd28Hr+6Ps7oqyKxIl0hfjzV1jDfIJ4P4n97EvMkRndx+R2AhLyrOkMkp8NDPjbv1ILE0ilWRvX5JtHcrL7QO82j5+cEZbT5aWCU2FOxOGxTeg9GWhbxC29WZIJEbpHEiQSEweSmjiMIq0pfj9IJbFy73GWD6+bYgL1i0dt9+ODDzT1sfzb473fEx0lAA1FUE6BkdpiyRo7x9rvJjJcBJL4e2eBG1xU831AevrocF+hg8CP30lwWNbDxAb7CMgglppuqJJtu4fZH9/jHg8yYHYEAODhdseJ1PQL5SXBakKBRkeNV5hJgPl/pm3yR1O70oPzcqMEo1m6QCq/BlY2k9vbzkvtQ6xpiZj5uHMUIFAgMW1lVRXhikPpMDvPxilE6CjK0p/bPw+V9+3hx9cfBTbD/Rz8mLBLNdQWLmZCLntw6m8LEDYZ7y9xT54sAsgxrgIAnljUSPdEAwKWXwEyJBIpJlt3FoRoTdukVIlli2jtkLpZgRS8IftWf5sSYZXX+vlhRiskmH2TOhgfCoOFa/sYH80TSjkZ+9ui5FgPZ997yKOW7tmRjf9uuZaWvsTpIey7O6Ok0jB7s7BcWl6slA+YQCavSAYW1JQ12XGp+3rGsI6xkItwcrOrLpnmAPs6uw7WMXsHILa2tpD0r4RGf/5BCCeTPL6vijhkI9MfIThRJIyHZssP5PpeXWVQcJ5z2sFEmUQzRu1Mgg82z6KDEHt0nKWB1OkRmBf/wg79/Wxv3eQfV0j7G8anHj4KSUihMsDBAMBGqorqe5MUFtp5jwXI7gjOOihiUiDiPxaROIi0iYil02S9u9EpEtEBkXkhyIyx8C84xVPmSpHAohYsC2aZkvHAFu7+3llT3TWxw36BX8wRDBYRlbG2gMikQif/O5rtBYoC63RFP0jKXb0zTyIYCGJCGl7rl/9oWXmEO0B1MpSV6ZmURIx77PVmasbOXttE5ed1sx7V495IW1pOGVlLXsSpqrxWBsU+seP7E6zJQovd1ncuxd+uzPK7Y+1TnvZtJwa66ppqa8iFK7hxKNCVATg7b5DZxVMvNr5zm/O1sVGgEyWeGqUmUa/zHlsvaNj7J3A8OjUx/niR5vYvj/C09s6aOuO0dYX4+2eAXZ2jj0Jppq5kS+/38+recsaKfBcN2yfkE6Bp6OwrSPK829k6QQGhqG9f4gX9sSIJuGtnslrFIeTiNDSUMmFp67klBZIqY9tBwZn1S5YSE5WOb+L6XBrAv4S+J6IrJuYSEQ+CNwA/ClmubxVwD8UEyRjjfdA6tKQzVokk5BMT96WNZlEhBOPrOf0o5ewbsVYXea677/IoUM3jc47rpGNRzdx3nGNkx57NG3ROzzKkL3U3qQcVpoA0BKe+gIngc2tPby2t5/+wQR7B4bon0Z1otBUoEwmQ8qCIxdV0rJ0ER8+acXBhUwqgNNXNXLJCX4aA/Dnx/qY7pJhT3RMM2GeEhnY/PIOfvBMJ0fKKCe3VBBPHVroC49CG68Vi2BbR4TWjhjbOiJT71BAZ69uGPd5UXjqav2Dm7vZ1tbLK3uG2N3dz0N/HGJnv8Vvnj3c3TS1ZlIl2zuovG5v9ypYQzG29sAI0OibXjnJv09y24FAgDOOW0FFCl7tTHP9w2088LtHZ/pXCsoRgyYiVcDFwM2qOqyqzwK/AS4vkPzTwF2qutVeaeofgc8Uk6dlSQPH1JkFEcqAeFk5RyypZ8WSGo6YYvzVlMdurGfT+mZaGsdG1OyY4Iq8bxFc+Z4lPP/lDaxc3sRnNq5h5fImJlMqkyWZthAmr3ICaHkVS8qgujbMtz7UwonLKzlcM3Y9MJQeZX8sSXdS8fmgOzm1h5bKZE3bVp7H0juc4tm9Ud44MMz2SJJQKMQXNoRoKoOrNoQoC/i48iMbufXyDVz90Y1TnmMuqikP8H+dEAceOAAXnNRMY+2hswqmUhhoWdZA57CQ8UHn8OyqRqubx1/fQGBq0/JgL7QNpMlY0BO3Dq7q/ersn7k0zaC/Z+Jw5vZUBblTt49Or0cyv40vfzsQCPB8z1i6f3lx9lOp8iXFWotx0pOInAxsVh2r/IvI14D3q+qmCWlfB/5ZVe+xPy/GhKtarKp9E9JeC1xrf1wLvH0YhMVwMPQVAL7y6jq1UqO+ippFViyyH0R85eHabHJ40AxwKK6kdtm6QFlIMgNduzUzmkR1hldQBJ/fT9aypsPnr6pvtOLRHgAJVVVrZjQZrFu2ykqnfT6/P50Z7NrrDy9aZg1FDvjKq+uyI7F+AF9FbUN2ZHAazpO96kY2mz3II+KTQFkI8fk0NXKwdVvKKsOaSuTX98z1EJ8/uGjFsZlYpC1Q27jSGurb7w83HIHP5yebtTSTSkgwVJWJRdp0ND4dZ2oCos8fqF+2KhPt2IVqVsoqKn2hcL2vIrxIUyOxrD9UK6l4RMrKq0X8gXS0YydAsH75mnS0Y6cvVFWNZrPZkVgUwB9uaLKG+2ftHklZRVWgtumozGD3Hk2NxCVUVS1V9StJDLRLqLLGF6yoBiT3/9PRjp1YmbQ/3NCUTQ4PqJVKBRua16T79u+Y/T0q4q9Z0iz+QJn4g+VWYrDbF6qstZLxlD9U4c+mRob8lXVN1shgRHzBMk0lhvzVi1dkk8N91nB/t688XCuhyhor1rN/+vewyBjv2LYEQxWBmsYWgHTfvlzZPaSsFtCRqlqwodupToEwpr0xX4NA9TTS5rarGR8QAVW9E7hzqpOLyEuqesq0aedBIvJSqsQMOQ7LBXlR6uvhFg43MOQ40okBV3DMJT+cakMbBiY6uzUUbsKYmDa3PfMntCdPnt5Vcsqg7QACIrIm77sTgUILrmy1f8tP1z2xuunJkydPE+WIQVPVOGYdz1tEpEpEzgIuBH5aIPlPgKtE5HgRqQduAn48R4Qpq6UOyA0M4A4ONzCAOzjcwAALhMORTgEw49CAHwLnYdrCblDVu0WkBdgGHK+q7XbarwBfx/T23wv8taoWZ6CWJ0+eFqwcM2iePHnyNN96V87l9OTJ08KUZ9A8efK0YOQZNE+ePC0YvaMNmojU5G0XZ7r+7Dj8pWawz1+Zt10SFjsIQaCUDPa5jxORpaXkEJH3iciGUpx7Ase5IvJxESlpeReRs0XkNhE5ar7O8Y40aCJyhIg8CtwnIr8UkSNKyHE7cAmAlqiHRURaRORe4CcicpeI1DrNIiIrROQh4GfAPSLSXML8uBQznvFycP662Hnxe+CXmMjWJZH9cHkYM1JgORx2Su98c6wQkUeAx4EvkYu7Pg96xxk0e6L7L4C9mMypB+4APuIwxybgUeCvgA+IyGr7e0e9ARG5AngeaMNENDkZuMtJFhG5AXgZE43o08BRwG32b6W4x9YCbwGrRGSjzeFUXtyIicjTqqrLVPUxJ857GF0BDKpqvap+R1WHbEbH7lERuRPYgplnHQSeAjZNutMc9I4zaMAazOJ9N6rqVuAioAP4hIgc7SBHHabQXg40Ah8CZ70Bu2q3GhPF5Cuq+gTwYeBjIrLcQZZR4EJV/VtV7cEYt0YREZ3xJPzZK8949gJ/xHgk54tIWFXVoYJ8GvCUqv6NzXS27aHMbKWXOcrOi7OAR+zPl4rI50VkPeAIi4iUYcLKnaSqX8IE8BhlHj1F1xs0Eamw33MBpJLAezBRhFHVYeDnmIn2H3eAIxc35T7gV6r6MKZ6c4aInG6nmbeCk8cRUNUMZrbFA3lslcBrmEHJ882QC3f2HVV9TkTWicgbmCr4K8Bl9sDp+eYIAOQZz7WYGSe/A04CzrB/L34UlTGGnJH4KnC0iPy9iLwM/DvwK+B+EVlR7PMX4MgFnAgDzUC3iPwYuBl4P/Aj4DoHOIKqmlLV61V1j/05jomrusFOU3T741qDJiL1IvIz4GEAVU3bGbATeBr4Rl7yZ4BW4BgRmTyw2Nw5UrbnEVfVXFDT/8Y89T4oIpXzVHAmcuQM+nZV7bWZUnBwacN9DjCM2u+5cKOLgdtUtQ4zZe0i4PpiG7XD5UVeARkC1gH3Y/LhEhG5U8yUu/liSNoPmVbMw+6LmGk8J2Gq4dXA5+wmk6KpUF6IiF9VY8Au4HYgpqrHq+ongG8DG0XknHnmSOf9JowtsvUQcLztNRfde3elQbOrjr8AjgSWi8g19k85Q3E3cI6IHA8Hn7xPY55As4+hPX2OcfmmqtuBJzE37weKdf6pOMTuXbUZcnlzAbDDNm5OMzylqj+yt+PA92yeooWpmowjr4C0AM+p6giwCNPOuRZ4cz4ZGLsvbsJUwf8Dc2m2YwzJX1A48vh8cdyK8dJW5tVwNtu/z3zhjBly5O4NNcpdGwsTUWdeqr2uNGi27gY+i3HZvyoi5XbGWBjjtQX417z02zGx0xY7wGHlvIG86uXPMW03Z4rIjbZHMPlqvcXlyBmW0xmrgl4lIt+UvOEc88mQU17h6cGEXS/2fXY4jtx59wC3ishrwDLg15hFwpvnmSFlG1YLeNZOlzPmccz9Uexez0IcOe9oG6ZJ4mRsA6aqbZhmiQMFjlVsjkLl5EngTEyVuPjNM7lY36V8AcdivKsl9ucAELa3m4HHgG9P2Gc1pjrxP8A1mHajuwCfExyFzgN8E7PORhdwkZMcgGAiiv8W+Dzwv5j1ODY5mRdA0H4/HtP7ekfuOwc4xH590z73Vfb3pwL/Bqx0OC/8efu/ANziVDnJuy+Cdtl4FrgFeA74fe4YDueHYDoENgNXzyUvDss2HwedQcb4gf/EeFaPY7raNxVIcxFmmMbaCTfKn2CicjwC3FQCDp/98mPa9NLAdaXgsN83YAxqL6bn0+m8KMc8fR/CVP1vdDov7O+XAxUlvD99mIfLeuBBe/9vlICjzH5fCVyK6RD4eonyIxcIo87Ok9Pnen0KMs7HQWeQQeuBJzDVxADGOO0Gzp6QrgHjOt+X911ZfiaWmgM4F6guIUcQs6LWDdhPyxIwBDBP4E+VOi/s91l760XKizBwVYnzIr+cSKmvSS5v5sIxKeN8HXiSTKlhzKO4Ftidf/Nh2qLuAlbl7ePHrLu6FTP2aztwmUs4PuUCjreBT7qA4VIX5MWc7g0vL9zJMW1eJ05i/8k1mLr7Q5ju9COBjdi9g3np1gMvAR+bsP9ZmEF67cAVHsfcOdzA4BYONzB4HHN/ObUu51WYOverwPWYsVI3Y9zWbuD8XFpVfQPTvX65va9fzDJ4f8Cs19mi9tAAj2P2HG5gcAuHGxg8jiLJCasJ/BNwTd7nZsxYlOWYevg9wLl5v2/CuKuV9ucqoMbjKB6HGxjcwuEGBo+jOC+n1uX8PvaAQnu6TAIzirkCM+ziaODLIrJLzTiZU4FHVTUBBwdpehzF5XADg1s43MDgcRRDTlpPxrpuT8a4qbkewhMw9fQtmPEyEeB8j2P+OdzA4BYONzB4HHN7OeWhAeOm55wDvK329BxV3SIiF9sZt05V/8vjcIbDDQxu4XADg8cxNzlq0PKmhZzGWFiTz2Hm2X1LVV/C9Jh4HA5xuIHBLRxuYPA45ianPTRLTHiTBky8rKcxo5ivVNWIx+E8hxsY3MLhBgaPY45yuo6Lma6Uxcwz/JrT5/c43MngFg43MHgcs385vtCwmCCEXwDuUNWkoyf3OFzL4BYONzB4HLOXt3K6J0+eFozcHA/NkydPnmYkz6B58uRpwcgzaJ48eVow8gyaJ0+eFow8g+bJk6cFI8+gefLkacHIM2iePHlaMPIMmidPnhaM/h+bzQ1D4GeYpAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate a collection of boolean masks that can be used\n", + "# to filter the time series\n", + "normalized_mask = rdtools.normalized_filter(df['normalized'])\n", + "poa_mask = rdtools.poa_filter(df['poa'])\n", + "tcell_mask = rdtools.tcell_filter(df['Tcell'])\n", + "# Note: This clipping mask may be disabled when you are sure the system is not \n", + "# experiencing clipping due to high DC/AC ratio\n", + "clip_mask = rdtools.clip_filter(df['power_ac'])\n", + "\n", + "# filter the time series and keep only the columns needed for the\n", + "# remaining steps\n", + "filtered = df[normalized_mask & poa_mask & tcell_mask & clip_mask]\n", + "filtered = filtered[['insolation', 'normalized']]\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(filtered.index, filtered.normalized, 'o', alpha = 0.05)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3: Aggregate\n", + "\n", + "Data is aggregated with an irradiance weighted average. This can be useful, for example with daily aggregation, to reduce the impact of high-error data points in the morning and evening." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAATQAAADHCAYAAACX8K+cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO29eZxsV3Xf+11nrLHnvqPuoCshgSQEMgLC8LANzxDHEIcHfo6xSewoyIE4DtgOwViEIXZI+NjAc4IH5QmwGWKDkbGNbcx7YbIfOH4SRBISktB4dXWnnru6hlNnWPnjVLXqlnqovl1T193fz6c/XXXqVO1f7dp77bXXnkRVMRgMhlHAGrQAg8Fg6BbGoBkMhpHBGDSDwTAyGINmMBhGBmPQDAbDyGAMmsFgGBmMQTMYDCNDXwyaiPgicpuIPC4iJRH5toj88Bb3v01EzorIioh8VET8fug0GAx7m355aA7wBPD9wDjwLuAzInK8/UYReRXwDuAVwHHgBPDePuk0GAx7GBnUSgERuRt4r6p+ru36p4HHVPWdjeevAD6lqgcGINNgMOwhnEEkKiL7gauAezd4+VrgT1qe3wXsF5FpVV1o+5ybgZsB8vn88575zGf2SLHBYBgW7rzzznlVnd3otb4bNBFxgU8Bv6eq929wSwFYaXnefFwELjBoqnorcCvAjTfeqHfccUf3BRsMhqFCRB7f7LW+jnKKiAV8AqgDP7fJbWvAWMvz5uNSD6UZDIYRoG8GTUQEuA3YD7xOVcNNbr0XeE7L8+cA59q7mwaDwdBOPz203waeBbxGVatb3Pf7wE0ico2ITAK3AB/vgz6DwbDH6dc8tGPAzwLPBc6KyFrj7ydF5Gjj8VEAVf0i8AHgK8Djjb9390OnwWDY2/RlUEBVHwdki1sKbfd/EPhgT0UZDIaRwyx9MhgMI4MxaAaDYWQwBs1gMIwMxqAZDIaRwRg0g8EwMhiDZjAYRgZj0AwGw8hgDJrBYBgZjEEzGAwjgzFoBoNhZDAGzWAwjAzGoBkMhpGhI4PWOKXprY2tsw0Gg2Eo6dRD+1XgZcAjIvKXIvIGEcn2UJfBYDDsmI4Mmqp+TlX/D+AI6QEmbwHONM7MfHkvBRoMBkOn7CiGpqqLpDvK/g5wEngdcKuIPCgi/3sP9BkMBkPHdBpDs0TkVSLySeA08JPAfwQOqOqVwC8Dn+ydTIPBYNieTnesPQ3Mk3pnb1fV060vqurnRGSzU5wMBoOhL3Rq0F6tqlseeqmqP9gFPQaDwXDRdGrQFkXkxAbXA+CMqiZd1GQwGAwXRacG7SFAG4+l5TFAIiJ/CrxFVc91U5zBYDDshE5HOd8EfAq4CsgAV5MOArwFeDapYfxILwQaDAZDp3Tqob0XuFJVa43nD4nIm4EHVfV3ReSnge/1QqDBYDB0SqcemgUcb7t2FLAbj9fo0xmfBoPBsBmdGqEPA18WkY8BTwCXAT/TuA7wI8A3uy/PYDAYOqcjg6aqHxCRu4EfA74POAPcpKpfbLz+eeDzPVNpMBgMHbCtQRMRG/gocHPTgBkMBsMwsm0MTVVj4JXAruaaicjPicgdIhKIyMe3uO+nRSQWkbWWvx/YTdoGg+HSoNNBgQ8B7xURdxdpnSbdhuijHdz7TVUttPx9dRfpGgyGS4ROBwX+FXAA+AURmaNlYq2qHu3kA1T1dgARuZF0UMFgMBi6SqcG7ad6quLp3CAi88Ai8Ang/aoatd8kIjcDNwMcPdqRXTUYDCNMp6OcX+u1kBa+DlwHPA5cC/whEAHv30DXrcCtADfeeKO2v24wGC4tOt0PzReRXxORR0RkpXHtlb3YMkhVH1HVR1U1UdV7gPcBr+92OgaDYfTYyaDAdaQbOzY9oXuBN/dCVBtKuiDeYDAYtqTTGNprSddylkUkAVDVJ0XkcKcJiYjTSM8GbBHJAFF7bExEfhj4lqqeE5FnAu8CPttpOgaD4dKlUw+tTpvxE5FZYGEHad0CVIF3kA4yVIFbRORoY65ZM6r/CuBuESkDfwHcDvyHHaRjMBguUTr10D4L/J6IvA1ARA6SruP8g04TUtX3AO/Z5OVCy32/BPxSp59rMBgMTTr10N4JPAbcA0yQbhV0mjRgbzAYDENBp9M26sBbgbc2uprzqmqmSRgMhqGi4z3MRGScdKfaQuM5AKr65Z4oMxgMhh3SkUFr7Ej7EdKNHCstLymw0eEpBoPB0Hc69dB+DXi9qv5lL8UYDAbDbuh0UMABvtRLIQaDwbBbOjVo/4l0zlin9xsMBkPf6bTL+TbS7YPeLiIXTKbtdPsgg8Fg6DXDun2QwWAw7Jhh3D7IYDAYLoqh2z7IYLjUSBKlHEQkiZmrvlv2wvZBBsNIUw1j1oKIahgPWsqep2/bBxkMho3JuvYF/w0XT6cGrRvbBxkMhg2wLCHvd7wK0bAFnXY5m9sHXQ7r2wf9F3awfZDBYDD0mt1uH/Te3sgyGAyGnWO2DzIYOiBJlGoYk3VtLMsccTGs7Hgpk6rOGWNmuNQwI5F7AxOJNBg6wIxE7g2MQTMYOsCMRO4NzO4ZBoNhZNi0yRGRl3fyAWYLboPBMCxs5UPf1vb8MOmypwVgmvQ081OYLbgNBsOQsKlBU9XLm49F5J2kRuxdqloRkRzpEXZmpYDBYBgadrLB4yFVDQEaRu2XSSfXvr9X4gwGg2EndDooUAZe0Hbt+Vx4ApTBYDAMlE49tHcBXxSRPwOeAI4Arwb+Za+EGQwGw07pyENT1U8ALwS+C4wB9wN/r3G9I0Tk50TkDhEJROTj29z7NhE5KyIrIvJREfE7TcdgMFy6dDxTUFXvE5H7gf2qeuYi0joN/CrwKiC72U0i8irgHcDLG+/5Y9JF8O+4iDQNBsMlRKdbcE+IyKeBGvBQ49o/FJFf7TQhVb1dVT/P9iOj/xS4TVXvVdUl4N8DP91pOgaD4dKl00GB3wFWgGOkmz0CfBP48R5ouha4q+X5XcB+EZluv1FEbm50Y++Ym5vrgRSDwbCX6NSgvQL4+UZXUyHddQPY1wNNBVLj2aT5uNh+o6reqqo3quqNs7OzPZBiMBj2Ep0atBVgpvWCiBwFLiaWth1rpAMPTZqPSz1Iy2AwjBCdGrT/G/iciPwgYInIi4DfI+2Kdpt7gee0PH8OcE5VzaoEg8GwJZ0atP8EfAb4COACHwX+BPi/Ok1IRBwRyQA2YItIRkQ2GmX9feAmEblGRCaBW4CPd5rOMGDOWTQYBkOn89BUVT+sqteoal5Vn9V4vpMaewtQJZ1+8VONx7eIyFERWWt0YVHVLwIfAL4CPN74e/cO0ukqSaKsVOqcW6kSRcmW9zWNWL92Nx0Vw7mXv8dm2luv7+Xvt9foaB6aiDwCfFpVb2m7fo+qPruTz1DV9wDv2eTlQtu9HwQ+2MnnXiyd7hFfDWOeXK5SDiJEhH1jmQ3vW6oE3PXEMmNZh/2FDIWMu16YLUt2vSd98/2+bVGuR6wFIavV9O/K2SJ1jbnr5DInpnMUsz6zxQyOYz3tM8pBBEDedy56b/xKJeTec6tcNp7Bsi3yjs3JlSrHJ3KEKLUwZtx3WQ5Cso5N3nfWjftG6TYbgObrm3337fKuXo85tVJh3HfxXHtX37FTykHEfDlgJu9TzLotDVqdb59c5vBkBs+yCELl2Eye8ZzXUz2XOp1OrD0IvKSx9OkNqtoM0B/viao+UA4izq5WsQTGMi6rtZCpbFooy/WI1Vqd1WqdlUqdlUrEvkKGMW/z7Hpiscw3HpzHsWNmxvK85IoZLFsIo4TD4zksW1is1JnKeTi2tSPDFkUJJ5fKlGp1Hp4rcep8mVItJFLFFYsH9hdYK9e57/QqM+MZrt4/zo3HJrl8tkg1jEkajvRqrc7D58uMZV0OT2SZzvsEcYLEymPLFU5M5clknv4doyjhbKlKqVonihPueGyBu08uMzvmsi+fw/IsllZq5PMOOcfDdwUQCr4DAhM5D1TIZxwOjmeZLaaNQtNINbe1dkU4v1pL88ix1o1DPYp5YqmCa4MjFlM5/wKDFUUJJ5fX+Ob35ijXIqbHfI5NF8i5DiemC8SSbp2dJMp8OcC3LRzbWjeeuzXy6edW+c6TSwgQRDEnF8p890yJfcUMYzmXvOcwXfQoZlxKtZBaGDOd99cbnShKniofjkUUJcyXA7KOTTHrbqqr1dg3v58tsFoLybk2Z1ar1OsJjmUxW/SZyPvkfYcgTnp24EurJoCVap3lSj2tB1ZaDyYyLkGc9ni62fB0atBC4IeA/wz8rYj8Q1V9mMYUjr1GkiiLlRp3PjqPIzZ+xuLJxSoHxjM8+/A4954uMb9W4bunV1gqR0zkPa4/MsnhmTwHNqjwAL5rU8wKpZqwWg544PwKtXpCGCtL03WOzuR4bL7MkueSzdh4Tloxm8attYC1eyRnlip8+f4nuffkKvNrAXOlANcRcq6NZVk8MLfKuGtjCyyXKjwsoMQ8slCiFijZjIVtCQulGudX6lw2nWO1GnJ4MkPB9zi5WOaeU4vclXE4Ol7g+EyOWpwwkfHAgvvPrvCdU6vU6gGPLdQIo4jTKzVOLipZd42Cb7NaT0BhImOTy/lMZR0EqIURlm0x7nscns5SDSNAeXCuxHIp5LpDY8yMZfFti+/NlViu1Dk0keXYdGG90VlcCzi1VGWlWqcWRut5N1vMMFNw+dYTS3zrkXkWyxE5z+LwdI5TcxUKOYf7z65wsJgFC2yEJ5arFLI2rmVzcMIHhfOrdWbGfPKew6GxLKHqBZW91TtuNhCJpp6oZ1uAcueji3zje+co1WIOTGbJuxa+Lfg+LK/VqDjC/Wd8XITvnF1lqVzn+iPjXD6dNjpnVys8NFfCxuKlJ2ZZi2IeX6ggohybyjNbzDyt0kdRwiMLJc4sV0k0YXktZLlSpxbGnFutoqqU6xEr1ZipgseRyQI3HJ9kKu9xfqXGiekCh6fzF3zPchBRiyLmVgNOTBcuaOA28pSjKOH8Wg1NlIxrU48T6lHMY4trRKEyW/D53lyJcj3mitm0I3ZupYrrWGRth5mxDFfsK1LMul2p2ztZ+hQBbxaRnwX+PxH5J11RMACqYcyj8xVOLdUo+jaH/CxBGPPkUoXlap21csTcWoVzKwGOLcwWPQ4Vs/jW5iHHffkMh6bzLKxWUSzmV+sEUcTSao3VtSr3n3GIY0UtYbboo0DGsch4NgXPZSLrM5F3Kfgu9XrMo0tlrpgu4NsWX3voHH/7wBJzpQoZx+KKfRmKvofnOlSDkPNrEZHYjGUdykHIQilgrVanVIvJui4HxzyqcYyqMO47nF4uc3qxSiXMMZn1Wa0GPDa3xlo15H/IAocnMthi4fupITyzVCGJlXIYpYV0zOfYVIHHzpcIopg4SZjMCCIW+8YzHJrIUgvBseH+0zVsC2wRTi+n9yxV6vzdwwuslOucXa3y4mfMUgli5teqLFYCyvWIKEqYyHk8dK7EE0urnF2o4jjC4lrAfCXExmY874DCudWAUq3ORM6lkPGZX61xOqwgjs2BMZ/vRItUY6XgWWQdhwTBcy3ufdIi0/AmoyQPIsyt1jgwnsV1LFxbOF+qsliq49sOmYzwwJkSrgjZjMtcqcpKpY7vCOcWa6zWYspBSKlsc/Xl04wXPR47W2GtFlGpRyxU54hJmCsFzC9XsS3wLIsnVqo8dr7E6cUadU3IuDbXHxrniaU1kihhvlTj+ZdPk/Pc1Ist11ipBDw2v8bdjy5yerVKNVSq9RBpGJpSLUaSCNu2yXo2FRvmnTL3PSmQwHI1ohREYEMtjMnYNpEmPHB2jXJQZ3Et4J5TS7zg+DRThQx532GxUieME0qWrHtfjy+W+NJdp1GgWHCJg5izpfT3qNZjPEfwHRvftXns/CpBlLBarRNGCbmsxwuPzzBdTLvh3fDUOjVo66mo6u+KyH2kp6bndpX6gMi6NsdncsyXaniOMFvMkHFtnlioUg9CKvWI2bEMGUfYP1XgZVfMIrb9tJhUK45jUXBdFggZz1nU6gm+Y7NQibjnbJmCJxyZzJLzPXxbqNYjlit1EsBzbA5OZJnMZRjL2ZQqEcuVENcWKkHEvSeXyTjKc45NcmJfkf1jWcJIWatHTBYc4kSJQzg2k+He0yVK1YiT8yWqQUgxa2N5NmfPlMn5DvmMRxIoC9UKkcaUgiXqYYzGMWGc4LnCUrnKyaU6li2MeRZJHOP5LnnXppB1ecGVMxyZznJyoUq5XmduKWD/VAZPLHzHoVSvs1ZLyLhw3WUT5LM2llisVus8ubBG1hVsTZjIudSjiFMLZTKew1K5zlI54tT8Ag+dXeHQdJ7TC2XueGyZclBHVfBdizBO8B2lXBMmMhb7iw7POljk4FQO17Y4t1hhoRLiWQlhlODYQqVcJ+P4qGXhWWk30yfh7HLMMw4WqdQjVioxi37Ak8sVJjIec+Ua331yhcVKwPGZAjnX4q6TS/iuxfGpLI/MV1mohNiW4DsWz9qfw7E9XEewHIuVcsh8OaDgOeRzDpVKzNnlMlEiWLYwtxJwn7PCQrnO6eUaWQ/s2CKII/7qvjPcc3KRhXLIgXGfxXKNQ+M5gihhsRxw35MrnFmuslqLcCywEiWxBBfwbGFyMo1vurZQyPhMF13mV2s8cn4V2xKKvk+pWuevHzzHWhATRTFrtYggSjg46XN2JeDxpQpL1ZBnHhxjpuDx6Nwajli4loXjCqdXKnz70SWemF+jGsa4jlCPLSAh4wiIjW2B68BkTjm7HCCWIAJr1ZggqvPQ3Cp5z+XoTJ7LZwu79tQ6NWg/1PpEVf9aRP4e6QLyPYdlCZPZ1MuoxzHVekI9TvA9i0pd2DeZZbbgU8xMU/RdclkPx7K2PMLMEuHgZBbftQnikJOVCpfvz+PYcKwUoLbF7JjPUinGdizCWhpbCCPFtpXlcsBk1mO1FpHxBNv2uHp/Ec+xGMt5XLF/jJdcPcNULsO477JYq6OJUvBdalHM3Fqdgm/zgisynFmuUsg6jGV8Mr7NsekcWdcCbC6fzrJYCRmvu5xfrbKyViPjuRydHeNgPcHzYLkSUYuUOEmYyvsgDjkb1LJ5/uVTHJ8tcHg8x7HJIsvVgLOTASf25amFMScXKmQzFpoE+J7FZZMFZoppDO3Oxxe4//QKlUC56kCBQ5NZVqohS9UAu1rHtYAkphpGLFVCFsshgjKdszk8WaDouUwVU8+0XA2phjGz4xmylsNkwWOy4LNaDRnzXa4UCMKYShBTj2OOzhaYyvlMFXzmVwME5e5TK4RhyPxqiGdZnFupkfUckkR5KFylFsUsV2usVSMW1gKk6GHbQrme8NBChXI1JOcJRyayFDIZrjk6zlTO55HzZbK2hetbZFyH/eMZbODe06vMl0JWayF5x0J9oRbF7B/zG4MnNuV6wlIpZK0eEiNMZG0Wy3WWHp6nFsGBcR/XFlYrAaIJ1x4qcNlkjiiBWCHjW/i2zbOPTOBaFkE9YTLnUYsT7j61xP1PLlOPYw5OZajHCWeXytRjZaUSUauHFHM+jm2T8y3qazFhFPLkUoVH5kvcdXKFcd9muuATRjEPnVtjLQiYyLtM2xnmSgFjrrK/mOWyqQL5rEOijfglsLhcw/FtfIEIEIR6qJwrVynmXI514bjfrQ5JkZZpGX8nIu3uyZNAx9sHDRuWCFMFD1DmS3UqYUTec5k5mGEq63HlbJG877BcC/Fti1qcEMTJpl5a3ne4YqbI/mLIfWdWsCwbWyy+79gsWc8i5zpEScLDc2XCOCHr2CBCLYg4t1ojihJirVMPI1Zq8MwDWRDh6FSel197kKm8y+XTxfX0D7XENvJRgoisB1odEXKew6HJPHGkZHzhipkxbFuo1ROu3DfGyaUKrpNqdGyb5x6fJO951GoR31socXgqx8payGoQcWgyw+HJHBMZj0OTOfaPZ7EsIQwUx7bT0buMx2q1TD1OGM96ZGZc6lHCWNYhCJVEE646UKRaj6jWE67YX2A2n+He0ys8OlfFEcj4Nvmsx9GsQ60W47rCgckcjlpcf2SCIFYmMx553+GxpTWW1lLvpRTETOZcHMsi79fJ+Q7TOQ/LFh5fqJC1LLIZm4NjWVaDkMmsR5woh6ayPHC6xGWTOU4uVRreXMzhySxnVpRyEHJkIoc1ZaMKriXccHyacjUmjiN0xmKm6LOvmOXgZJbLJnLUopi8n4YXDo5liVSJEiWIYjzX5tH5EkHdx7Mt8hmHnOeScW32j+WYLngNTzEkTBKedXCcs8s1Ti9X+PZji8RJwlJFODye4bKpPNNFn2cdnmQi6xInymTWw7KEWpSwr5hZ93aaca7rDo8TxglBlHDd4Qmq9Zi5Uh2XiPGczeyYx4nZAoWcRxQprmMzX6pDrKhlkbdhPGOTcR0qQch03ubI9DQvvmoaS4S1aoRrWWQ8hzBJGMu4uLbFai2iFNTJOB5jOZuc6zKZ98h6NqeWytTqCeM5F0t2PzCwlYe2wlPLjtJI7oVI49qePHk169oUMy4TGZeZQoZKPYdnW0SJXjD6tM9LR4+cllGbjbAsWS9Al03m2F/MrBfoRElH/ADHtji1WGU673HVgTGiKOHMapVTSzUyHiyvpnG7I5M5Cp6L59hcd3hiyxGp5pmRjmPheemoYd5Pv9uplQpzq3VmxjI4VtpdC+OEQxNZhDSeB3BiukjOd6nVIrCFY5M5Tq1UeHSuzInZArPFDK5tMVPw13W0Hr5bDdMKe2Qqx2TWI0FTb8lzOVOqEYQJE3mfVz37MGGUsD+fYbkekvUtTi1VsSxhwncZaxTs86WA+VKdIxM5Dk3kLkgX4MrZMaoTaaC+OaACpIZ8PNW0WKnzjH1FVqppGOGB82tM51wU4chUDse2ePbBKZZrIdcfnuCrD82RsSxmxr20u+ZY7C9mGc+7PDa3Ri1IODyZo3jAI+tZTOd8cr5zQZlJEk0rdxDhuTaTvkM5iIgSG1Ule3BivUGbyvusBiFRrBQyDo5lMZPL4Fg2U3mPIEo4MlXgicUyWd9moVQnjhQFThwocv2hCQoZl6VKSN53mCpm1n+L1rK6UA546Pwavm1x7eFJfNvixHSBhWoAAkmsrFZjVMC1IYqVK/YVG1ODllmoxvhOwuGpAkdn8oSajjyfOFDkGfsmmMy5ZFyHsaxL1rXXR3E922KxWme66FELfZJYQYSxbBorzro2Bd/h5EKFvG9vWb86ZSuDdm3L48s3vWuPEsQJ2vjv2Bb7x7LbGoxOyPsOl03m1ytac2SsUo9IFGzLYqroEYapJzOWdTkyXeDIVJWVSshaIWShHFDIuySSepLbpd0+j8txrPX5ckcn8xQaxq1Z8f1GQSt4DpUwZiyTFsi1ICLjWhydyjOZ85jM+xyeyDORcZ828teeL2lh9MiOpRXqfKkGCJ5nc2w6T5Qk1KNkveKXgwjbspgpZMl5HhM5lzBWpnKpl7FvLDVCOddZn7bQPsrWTLvVa26NwUzlPBYrdU5M5bnnzApL5TrjWYfj0/kLAtD7PJtyEPG841OcXwkQBQuLI1N5jk3lQWGuFODYMcem80xkfRKFsaz7tN/GsoSMa7NQrhMlyfr8u+VqCKSDIkGYIKKcXwuwBDKujYUwt1ZnKp9+Zt5zyHswXw64ev8Y+8cyLJXrnFquUA0iTkwWmcj7JMBMMR2hbc+XJhk3NZCTOZexjLdu7EG4YnYM37HS8pkolYYHvX88g2MJru2wVg9YqybccHyCnOtwdrlGKZewr5Dl8qk8xax7wSj9eM5jnHRU1GtMJ6k4MRnHIoiS9akpTebXArKevWUPqFO2OvXpiZbHj+8qlSGk2RokibIWRERxWvi2m/ezHc0CVQ6i1Mg0Kk4C2JakFVaE0E1wG3Oh8r6D51gsZgIKXpHVICRj24xlvY4Maaun1E7TuJWDiEoYU/AdQlVEhLGsx0T+qRGrptFoGvq876wbxu2mg7Ybt5l86vk1DUepGrIchuTCmHwjnUyj8OYa8/vqcZym6zhppWibhLrdBNx2mo1WLHDlbAFBuGwit2HgOTX0NgfGMyhKMWeTcxz2j2dTrb5N1rbXu9vtXtAFeSFpntajhFqUILD+uzcbk3It5HwpHTWcyntM5Dz22Ra+bVGJYhYr9XVvq6qwr5hlXzHLZN7j/GqdyTFvfR7hdvPJihmXy2cK6/eVg4hYFbcxZWi+HIA2G0ObybwwU0h/v5dcOctqrc5SOUy7xGGMY1tM5jx8Ny1LjmNtaIiaZaJ1cvm6E9G43xJhLONSzDi99dBE5BN0MM9MVffk9I1mZkdRasgqQcSp5Ro5z+a4Y3XskW3GRkamWaBmCv4FFSKdPJpQDZVixuLQRJ61IMJxrI4M61YeZOscKnxnQz1NWgvfbgpXa/f7AhqlqRxEzK8F5Lw0jljwn/Iutkq3PU+3W0HQnGyaJEox4/KsQ2Pr19rfZzUam8VKHd+2cO20O9SseFfuG7vgs7cqH00j7tsWi5U6caIXTOQ94GWJ8j75TEAcp0bPsSzGs2lDaAFxY5lUe8OQhkqemoDbiUfTXj5828KW9Ps286m5oqPdQDbf1/TsFsoBSdHn6HQOx7LWP6OT9DcqW7OFDHJQ0phyF9iq1j7UlRSGlGahbrYaOd/hyFSWrNOdvnx7IWp93Ppa05PLuDb7iv56lws29rh2StN4zBT8C4zMZhVyJ93rjdjIWDTXMM4U/HXvlUZXq3XVxHbptt+zncdmWYJlpfGsjfK8/X1Nj86yhIJz8R5Da1rtjVcTx7E40PD+ykFEospcqbYeb21W/HZD3RpOuFhawy1JolTrMXnP2dBAVsN43bN3HIvZYrqs72JWGWz0GzuORTHjpg14GO/akdiqy/neXX3ykFMNY1ZrIQLr8YedLknqlPZK3uo1JYmSayzjGW/zlrpGb5czXsBGRqa1UjQL9WYVdids1dXe6p7N3td6vVtlYDtD3TS686Vg3ZPs9RrU1u/ZbFw6ubcfenZLx7VGRDzgatKNHlsn2n551yoGQPPHjBtucBAnO4rP7IT2St58XibthRV6WIBbjUc/aKbj22ngv3WtZmusrht5fDFe3Vbv65aunbJRzLGXtH7P7crHTr3i3erZLZ3utiWJe0IAABT1SURBVPFS4LOATzqVY5V0S+wngBNdUdJnNoplQW9aovYK3VrpmzGL3e7GsRnthaV9EXS3edqgCKwPfAwLvcrri2XTmGOf0u70t2nGI3Nud8IyvaDTUvYh4AOq+iERWVLVKRH5d+zxk9O3inP1Mp2NphxsFtfpNouVOudLAcCuYzFb0Uk3on1Xhn4ZmV54GZcC7aGDYaTTX/Mqnr477X8EHgV+vauKLlH6EasA1kelJjLuepewF4Wzk5a/1bAATzMyvfKk+pXXo8ZeyLdODVpz1cAycEZEriE9X7Ow5buGlGHrckD/4jet89IG7aVsFbBPEmV+LVifvtBNjc2Y0Ub7oPWzbAxjOdyKQcUYd0KnQZTbgX/QeHwb6fbYd5LG1fYc5SDi/GptvUBfijSXnQyytW0alo12s62GMbEq9i4GNLba+roaxsyXA+bXggu2Su/X9umdpmW2794ZHZlbVX1ry+PfEJG/I/XO/qpXwnpJFCcsrNWZGFAg9lJiOy+kfQvrJt2YQrFVrKx1ZLF1RNa3LcqNa72mdeJvc9LpTr7DbunUQ9xLnuRF5ZCq/nW3hfSTShixVA6oTPhM4g9azkDoV2C8o3Q2cD660b3ZKubTOrLY2v1uyunGusLt2Gzibyu9jFt1Wgb20iBKp9M2jpKevHQDTz/Q5Koe6BpJhqml61eAd7t0ejlPrlOjeMHcuXoEqn3x0JJEieLkgvTay0i341atn99pGdgLgwFNOs2pzwL3A/+O9Pi5PU3Bdzk8laPg97fLOUwtXb8CvJ3MlB+WvGh2f4N6Qs5zKHbZQ2s3VtUwXYSOQiGTeoS97mK2D7R0kkbrbzRMjfJGdJpjzwRepKqbH0y5hyhmXI5Nb70DbS/YSy1dLxjGytDusRQ8B7Q3g0XtxqoZx0v0qThar7uYmw207ORYx2FplDeiU0V/Bnw/6eim4SIZBm9kkGxUGbaqSP0wgO2a0sXXW2/mebFstASsmHXXY3jN8tGrMrLVQEunhmrYG+VOc+7ngW+IyMPAudYXVPWfdV1Vjxn2VqZXDNpD2qgylIOI86UahYYxadXVj99pIyOz2Ry13TKIwH8n6W+kYbOyMuyNcqfKPgbEwHcZgRjasLcyvaJbJ5RfLJtVhiBKgIhC5sLtY/rxO22kqTlHDe1PBe40jV7+Pv1YhN4POlX6cuBQy4npO0ZEpkgn5b4SmAd+WVU/vcF9P924r9VwvlpVv3qxaW9GPzyWQXtFOxnVGkQhzvsORyZzW+rqNxvFtoYh5tfP32evNvqd5srdwDRw0QYN+AhQB/YDzwX+XETuUtV7N7j3m6r60l2ktSXt2/dA7wrIoFu69vT7HR/ZzqC3zgdrzopvHQXsdd5ttnvtRrGtQdOt36eTRnZYvvNO6VTxl4EvicjHeHoM7aPbvVlE8sDrgOtUdQ34GxH5U+CNwDt2Jnn3bLR9T6/TGlRLt136mx080i06MUqtuwdXWpZB9TLvNkuzlUH/du106/cZdCPbpBe9l06/zUtJz+F8Zdt1BbY1aKS7dcSq+mDLtbtIR0434gYRmQcWSc/+fL9q98bSN9q+p1v0emLkTtku/V4X7k6MQlNDrm19aS/zbrM0Wxn0b9crdmKom14zdH/zyV6UvW0/RUQEuAk4uQujUiDdsaOVFdJNItv5OnAd8DjpUXp/SHou6Ps30HYzcDPA0aNHL1JadxmW1q9Teu2FdGIUurFus51ODlBp/T9s8+N6yU4MdS8HSDpZy7pTtnVPGqen3wPsZlLtGk8dWtxkjA1icqr6iKo+qqqJqt4DvA94/SbablXVG1X1xtnZ2V3I6x7DsIvFTmjd438YNHRrd4ntdrJoTbOfO2zsNZoDJDMFv+tlutmDqYRx1/K+U3P7bdJu4/0Xmc6DgCMiz1DV7zWuPQfYaECgHaWvx3zsjlHtpnSL7SbSdmsPtJ14noOMlQ16FHw7er09eLfzvtMS81XgiyLycdJzBNabz04GBVS1LCK3A+8TkX9OOsr5o8CL2+8VkR8GvqWq50TkmcC72KP7rhmezmbbBUF39kBrspOGZZCN0DCEKAZpVLud951+0ktIt9tuD+J3OigA8JbGvedJd7t9s6re29jJ4z7gGlU9CbwC+LiIFEhHVD8J/IcO0zDsBTbpTfYiljbsDMNI6jAY1W4haYhs73PjjTfqHXfcMWgZhm0Y9i7Wpche+01E5E5VvXGj13ZyLuck8BrgMOkUjj9T1aXuSDRcKpgY4/AxSr9JR5OwRORFwMPAvwCuB34WeLhx3WAwdEAUJZxfrRFFg9+Fa1TPKujULH8YeIuq/kHzgoj8OPCbwPN7IcxgGCa60S3r15monTBKcbNWOp0mfxXwmbZrfwRc2V05o8+otoyjTjfmqk3lPPYV/fWzUQfJXpsv2SmdGrTvAf+47dqPkXZDDTvATOLcm3TDADTPRO314SudMAwTqntBp77mW4EviMjPky5JOg48A3h1j3SNLMMwTD+MDPtI2yAD58OeN8NEp+dyfkNErgB+BDhEuiX3X6jqYi/FjSKjNKLUTUY1ptMNTN50Tse505ii8ckeahlpTCu7NcPouQ7LbzaMeTOsbGnQROQrbDqvG0jXrr+iu5JGE9PKbs0weq6D+s2GbQuqvcR2ubSZR3aY9OCUXHfljC79bGU38iyGxdvYSwzKMzKN38WzZW6p6m2tz0VkGvhl4E2k+5S9r3fSRot+trIbVQhTSXZOr3+zzRoZ08W8eDpdKTAmIv8eeIj0TIDvU9WbVfVUT9WNCP2ee7bRFIP2a8M8H26YtXWTzabwjOqUin6wXQwtSzpl4xdJtxB66SaHmhi2oN/e0UaexaCPKdtJl/dS8SaNJ9Z9tistjwI28AHgDmC/iOxvvUFVv9wjbSPDMBbcfmvaiZEadLyxX5hgf/fZLjdrpKOcb97kdQVOdFXRCDKMBbffmnZipAYdbzTsXbYbFDjeJx2GEWcYjToMp/dsuHgGv6jMYBgggwzAXyqDH/3EGLQBYQqzwWxU0H2Grw9wiWBiN8NDc2DAty2COOnbAIHp7nYfU5P6TGvlYQT3o9qLNBuXMk+t8xvU9BqzomN3GIPWZ9Y9M98ZqGdmKs5TNBuVVg9tUPTLcx/V398YtD7j2xblxv9B0quKsxcrSqunNOjNF/vVDR3VkMfofJM9QhAnxKosVurMFPyBVfpeVZxRrSj9ol/TW0Y1fmdGOftM1rWxRYgbnsyg6NV0hVHdq76fDHIEfK+PvhuD1mcsS5gp+Ixl3ZGs9HtxYfWgKvFm6fZjOsdmaWyXdrfyqld5bvoEA2BYZ81fqpSDiPm1gJmCTzHr9i3dzbrn/egObpbGdml3K6TQq9CEqVUjTnuQfpiC9oPQsmmafUi+Pe3NjEc/GrzN0tgu7W4Z214Z7b51OUVkSkT+WETKIvK4iLxhi3vfJiJnRWRFRD4qIn6/dI4a7V2IYZqd3k8tzS5OOYielmbed9hXzPTciLR/30F3z5NEKVVDStWQKEo66gJ2S3Ovvns/Y2gfAeqkG0T+JPDbInJt+00i8irgHcArSI/LOwG8t38ye8Og4jTtQfphCto3tfi2tZ43zXyKomS9snUjz6phzGotZKVWpxKESKycX60RRUkXvkln+LaF8NSUndYy0TQuS+WAcyvVnutKEmV+LeB8qcb8WsBipb5h49KusdtluNuf2Zcup4jkgdcB16nqGvA3IvKnwBtJjVcr/xS4rbmRZGOn3E9tcN+eYlDTGdq7EMMUv2tqaXpNTZqz9sv1CLQ7mrOuTTmIWCiHVMOYapjQrEN53+nLbxPECdr47zjWBWUCYL4csFiqE2lCNYw5OpXvmfdWDWNiVfK+Q95LG7iNJhW3a+x2PnW7XvSrZF8FxKr6YMu1u4Dv3+Dea4E/abtvv4hMq+pC640icjNwc+Ppmog8sEn6M8D8RSnvHjOItYgm/XMJNtMxDHnRrkEsaz1vmo/FSl2ZbuaZWBZiWSRRjGXvI4nPPS39XtKejsg+VM+vvwYilm0rqiRJ3FNNF2rZvFxs9NsMQsdTHNvshX4ZtAKw0nZtBSh2cG/zcRG4wKCp6q3ArdslLiJ3qOqNHavtASJyhybxQDWs6xiGvBiwhmHRMQwaRklHv2Joa8BY27UxoNTBvc3HG91rMBgM6/TLoD0IOCLyjJZrzwE2OnDl3sZrrfeda+9uGgwGQzt9MWiqWgZuB94nInkReQnwo8AnNrj994GbROQaEZkEbgE+vksJ23ZL+8AwaIDh0DEMGmA4dAyDBhgRHaLan2kEIjIFfBT4IdJY2DtU9dMichS4D7hGVU827v0F4N8CWeBzwL9Q1aAvQg0Gw56lbwbNYDAYeo1ZnG4wGEYGY9AMBsPIYAyawWAYGfa8QRORsZbHA1nlKyL2INNv0ZFreTyovJgSEWeQGhppP0tEDgxSh4j8byLyvEGk3abj5SLyehEZaH0XkZeJyIdE5PJepbFnDZqIHBaRLwG3i8hnROTwgDR8GPgxAB3QCIuIHBWRzwG/LyK3ich4v7WIyBER+QLputs/FJHLBpgfP0E6n/GN0P/fpZEXfwV8BpjoZ9ptOqZE5M9JZwocAvID0nFERL4IfBn418Bqr9Lakwatsdj9D4DHSDNoEvgt4NV91PAa4EvAPwF+UESubFzvqzcgIj8D/C3wOOmOJjcAt/VTi4i8A7gTeJR0c4HLgQ81XhtEGbsa+C5wQkRe2tDRr7z4FeB+4CFVPaiq/70f6W7CzwArqjqpqr+pqqWGxr6VURG5FfgO8ADgAl8DXtOr9PakQQOeAdjArzR25XgtcBr4cRG5ok8aJkgr7RuBfcDfh/56A42u3ZXAu1T1F1T1K8CPAP9IRA71UUsA/Kiq/itNF1rfCewTEVHVvi3GbzGe88D/T+qRvFJECqqqfarILwC+pqr/sqHpZQ0PJdOHtNdp5MVLgC82nv+EiLxFRK4H+qJFRDxgGXiuqv5rIEdaVnrmKe4JgyYi2cb/5v7INeD7gAigsSXRfyNdbP/6HmvwGpduB/5IVf+ctHvzIhF5YeOenlWcFh2Oqkakqy3+pEVbDvifpJOSe62hufHmb6rqN0XkWhG5m7QL/i3gDY2J073W4QC0GM+rSVec/CXwXOBFjde7buBbNDSNxC8CV4jIe0TkTuC/AH8EfF5EjnQ7/Q10NDecKACXAedE5OPAu0h3t/kY8G/6oMNV1bqqvl1VH208LwMV4HmNe7puf4baoInIpIh8CvhzAFUNG5nwPeDrwDtbbv9r4CHgKhHZ30MN9YbnUVbV5cZtnyRt9V4lIrkeVZx2HU1jfr+qzjc01Um73wBP9EFD0Pjf3BVwBviQqk6QLll7LfD2bhu1zfKipYKUSLeh+jxpPvyYiNwq6ZK7XmmoNRqZh0gbu58nXcbzXNJueBF4cyNc0jU2ygsRsVV1FXgY+DCwqqrXqOqPA78OvFREfqDHOsKW1wRolpEvANc0vOaue+9Da9AaXcc/IN376JCIvKnxUtNYfBr4ARG5BtZb36+TtkJLPdZwQb6p6v3AV0kL7w92I+1OdEhjdLWhoZkv/wB4sGHc+q3ha6r6scbjMvDbDT1d26ZqKx0tFeQo8E1VrQLTpHHOq4F7eqmBp8rFLaRd8N8l/WnuJzUk/ydpl6srdKDjN0i9tOMtvZtvNF6f7bWOZtnQlOZvE5PuqNOTbu/QGrQGnwZ+ltRt/0URyTQyJyY1Xt8BPthy//2k+6fN9FhD3PQGWrqX/400dvNiEfmVhkdwqI86moblhTzVBb1JRN4tLdM5eqmhSUvlOU+67Xq3y9lmOprpPgr8hoj8T+Ag8MfAk6SVu5ca6g3DGgN/07ivaczLpOWj26OeG+loekf3kYYkbqBhwFT1cdKwxJN90LFRPfkq8GLSLnH3wzOqOhR/wDNJvavZxnMHKDQeXwb8d+DX295zJWmX4rPAm0hjR7cBVq81bJQG8G4gAc4Cr+1HXjR1kJ5b5AF/AbwF+H+BM8Br+pkXgNv4fw3p6OtvNa/1QYc0/t7dSPumxvXnA/8ZON7nvLBb3v8/gPf1q460lAu3US/+Bngf8E3gr5qf0ef8ENIBgW8A/3w3ebGptl586A4zxwb+K6ln9WXS4fbXbHDPa0mnaVzdVlieTbozxxeBW/qswWr82aTxvBD4NwPIi2bhfR6pQZ0nHfnsd15kSFvfL5B2+3+l33nRuH4IyA6wbFqkjcv1wJ813v/OAejwGv+PAz9BOiDwbweUH82NMCYaefLC3f4+G2rsxYfuMJOuB75C2k10SI3TI8DL2u6bInWfb2+55rVm5CA1AC8HigPMC5f0RK130GgtB6DBIW2Bf2rQedH4f1GeehfzogDcNOC8aK0jMujfpJk3u9GxpcZeffA2GTPGU17FzcAjrQWQNB51G3Ci5T02cB3pFIkPkcbL3jAEGn5qCPLiAeAfD4GGnxiCvBiGcjESeTFMOjrW249EWr7oM0j7718gHVI/BryUxghhy33XA3cA/6jt/S8hnah3EviZvaphWHQMg4Zh0TEMGoyO3f/18+T0m0j73d8G3k46X+pdpK7rOeCVzXtV9W7SIfY3Nt5ri8gNwP9DembnUW1MD9hrGoZFxzBoGBYdw6DB6OgS/bKcwK8Cb2p5fhnpfJRDpH3xPwRe3vL6a0hd1lzjeR4Y2+sahkXHMGgYFh3DoMHo6M5fP4/Q/h0akwobS2YqpDOZs6TTLq4A3ioiD2s6V+b5wJdUtQLrEzVHQcOw6BgGDcOiYxg0GB3doN8WlKeGb28gdVWbo4TXkfbVv0M6Z2YOeOWoahgWHcOgYVh0DIMGo2N3f/300IALluj8APCANpboqOp3ROR1pJl3rar+3ihrGBYdw6BhWHQMgwajY3f03aC1LA15AU9tbfJm0rV2v6aqd5COmoy0hmHRMQwahkXHMGgwOnbHIDy0WNItTqZI98z6OulM5n+mqnOXioZh0TEMGoZFxzBoMDp2ySD6uaTLlRLStYa/dKlqGBYdw6BhWHQMgwaj4+L/BnLQsKQbEf4c8FuqWuu7gCHRMCw6hkHDsOgYBg1Gx8VjTk43GAwjw7Dvh2YwGAwdYwyawWAYGYxBMxgMI4MxaAaDYWQwBs1gMIwMxqAZDIaRwRg0g8EwMhiDZjAYRob/BbwMGXrUl+KcAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "daily = rdtools.aggregation_insol(filtered.normalized, filtered.insolation,\n", + " frequency = 'D')\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(daily.index, daily, 'o', alpha = 0.1)\n", + "ax.set_ylim(0,2)\n", + "fig.autofmt_xdate()\n", + "ax.set_ylabel('Normalized energy');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4: Degradation calculation\n", + "\n", + "Data is then analyzed to estimate the degradation rate representing the PV system behavior. The results are visualized and statistics are reported, including the 68.2% confidence interval, and the P95 exceedance value." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the degradation rate using the YoY method\n", + "yoy_rd, yoy_ci, yoy_info = rdtools.degradation_year_on_year(daily, confidence_level=68.2)\n", + "# Note the default confidence_level of 68.2 is appropriate if you would like to \n", + "# report a confidence interval analogous to the standard deviation of a normal\n", + "# distribution. The size of the confidence interval is adjustable by setting the\n", + "# confidence_level variable.\n", + "\n", + "# Visualize the results\n", + "\n", + "degradation_fig = rdtools.degradation_summary_plots(\n", + " yoy_rd, yoy_ci, yoy_info, daily,\n", + " summary_title='Sensor-based degradation results',\n", + " scatter_ymin=0.5, scatter_ymax=1.1,\n", + " hist_xmin=-30, hist_xmax=45, bins=100\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to the confidence interval, the year-on-year method yields an exceedance value (e.g. P95), the degradation rate that was exceeded (slower degradation) with a given probability level. The probability level is set via the `exceedance_prob` keyword in `degradation_year_on_year`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P95 exceedance level is -0.65%/yr\n" + ] + } + ], + "source": [ + "print('The P95 exceedance level is %.2f%%/yr' % yoy_info['exceedance_level'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5: Soiling calculations \n", + "\n", + "This section illustrates how the aggregated data can be used to estimate soiling losses using the stochastic rate and recovery (SRR) method.1 Since our example system doesn't experience much soiling, we apply an artificially generated soiling signal, just for the sake of example.\n", + "\n", + "1M. G. Deceglie, L. Micheli and M. Muller, \"Quantifying Soiling Loss Directly From PV Yield,\" IEEE Journal of Photovoltaics, vol. 8, no. 2, pp. 547-551, March 2018. doi: 10.1109/JPHOTOV.2017.2784682" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply artificial soiling signal for example\n", + "# be sure to remove this for applications on real data,\n", + "# and proceed with analysis on `daily` instead of `soiled_daily`\n", + "\n", + "soiling = df['soiling'].resample('D').mean()\n", + "soiled_daily = soiling*daily" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the daily insolation, required for the SRR calculation\n", + "daily_insolation = filtered['insolation'].resample('D').sum()\n", + "\n", + "# Perform the SRR calculation\n", + "cl = 68.2\n", + "sr, sr_ci, soiling_info = rdtools.soiling_srr(soiled_daily, daily_insolation,\n", + " confidence_level=cl)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P50 insolation-weighted soiling ratio is 0.945\n" + ] + } + ], + "source": [ + "print('The P50 insolation-weighted soiling ratio is %0.3f'%sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The 68.2 confidence interval for the insolation-weighted soiling ratio is 0.940–0.951\n" + ] + } + ], + "source": [ + "print('The %0.1f confidence interval for the insolation-weighted'\n", + " ' soiling ratio is %0.3f–%0.3f'%(cl, sr_ci[0], sr_ci[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Monte Carlo realizations of soiling profiles\n", + "fig = rdtools.soiling_monte_carlo_plot(soiling_info, soiled_daily, profiles=200);" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the slopes for \"valid\" soiling intervals identified,\n", + "# assuming perfect cleaning events\n", + "fig = rdtools.soiling_interval_plot(soiling_info, soiled_daily);" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
startendslopeslope_lowslope_highinferred_start_lossinferred_end_losslengthvalid
02010-02-25 00:00:00-07:002010-03-07 00:00:00-07:000.0000000.0000000.00.6691200.89601410False
12010-03-08 00:00:00-07:002010-03-11 00:00:00-07:000.0000000.0000000.01.0486151.0119253False
22010-03-12 00:00:00-07:002010-04-08 00:00:00-07:00-0.002423-0.0052080.01.0587340.99332227True
32010-04-09 00:00:00-07:002010-04-11 00:00:00-07:000.0000000.0000000.01.0452651.0452652False
42010-04-12 00:00:00-07:002010-04-20 00:00:00-07:000.0000000.0000000.01.0364451.0264618False
\n", + "
" + ], + "text/plain": [ + " start end slope slope_low \\\n", + "0 2010-02-25 00:00:00-07:00 2010-03-07 00:00:00-07:00 0.000000 0.000000 \n", + "1 2010-03-08 00:00:00-07:00 2010-03-11 00:00:00-07:00 0.000000 0.000000 \n", + "2 2010-03-12 00:00:00-07:00 2010-04-08 00:00:00-07:00 -0.002423 -0.005208 \n", + "3 2010-04-09 00:00:00-07:00 2010-04-11 00:00:00-07:00 0.000000 0.000000 \n", + "4 2010-04-12 00:00:00-07:00 2010-04-20 00:00:00-07:00 0.000000 0.000000 \n", + "\n", + " slope_high inferred_start_loss inferred_end_loss length valid \n", + "0 0.0 0.669120 0.896014 10 False \n", + "1 0.0 1.048615 1.011925 3 False \n", + "2 0.0 1.058734 0.993322 27 True \n", + "3 0.0 1.045265 1.045265 2 False \n", + "4 0.0 1.036445 1.026461 8 False " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# View the first several rows of the soiling interval summary table\n", + "soiling_summary = soiling_info['soiling_interval_summary']\n", + "soiling_summary.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# View a histogram of the valid soiling rates found for the data set\n", + "fig = rdtools.soiling_rate_histogram(soiling_info, bins=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These plots show generally good results from the SRR method. In this example, we have slightly overestimated the soiling loss because we used the default behavior of the `method` key word argument in `rdtools.soiling_srr()`, which does not assume that every cleaning is perfect but the example artificial soiling signal did include perfect cleaning. We encourage you to adjust the options of `rdtools.soiling_srr()` for your application." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "heading_collapsed": true + }, + "source": [ + "## Clear sky workflow\n", + "The clear sky workflow is useful in that it avoids problems due to drift or recalibration of ground-based sensors. We use `pvlib` to model the clear sky irradiance. This is renormalized to align it with ground-based measurements. Finally we use `rdtools.get_clearsky_tamb()` to model the ambient temperature on clear sky days. This modeled ambient temperature is used to model cell temperature with `pvlib`. If high quality ambient temperature data is available, that can be used instead of the modeled ambient; we proceed with the modeled ambient temperature here for illustrative purposes.\n", + "\n", + "In this example, note that we have omitted wind data in the cell temperature calculations for illustrative purposes. Wind data can also be included when the data source is trusted for improved results\n", + "\n", + "We generally recommend that the clear sky workflow be used as a check on the sensor workflow. It tends to be more sensitive than the sensor workflow, and thus we don't recommend it as a stand-alone analysis.\n", + "\n", + "**Note that the calculations below rely on some objects from the steps above**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 0: Preliminary Calculations" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the clear sky POA irradiance\n", + "clearsky = loc.get_clearsky(df.index, solar_position=sun)\n", + "\n", + "cs_sky = pvlib.irradiance.isotropic(meta['tilt'], clearsky.dhi)\n", + "cs_beam = pvlib.irradiance.beam_component(meta['tilt'], meta['azimuth'],\n", + " sun.zenith, sun.azimuth, clearsky.dni)\n", + "df['clearsky_poa'] = cs_beam + cs_sky\n", + "\n", + "# Renormalize the clear sky POA irradiance\n", + "df['clearsky_poa'] = rdtools.irradiance_rescale(df.poa, df.clearsky_poa,\n", + " method='iterative')\n", + "\n", + "# Calculate the clearsky temperature\n", + "df['clearsky_Tamb'] = rdtools.get_clearsky_tamb(df.index, meta['latitude'],\n", + " meta['longitude'])\n", + "df['clearsky_Tcell'] = pvlib.temperature.sapm_cell(df.clearsky_poa, df.clearsky_Tamb,\n", + " 0, **meta['temp_model_params'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 1: Normalize\n", + "Normalize as in step 1 above, but this time using clearsky modeled irradiance and cell temperature" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate the expected power with a simple PVWatts DC model\n", + "clearsky_modeled_power = pvlib.pvsystem.pvwatts_dc(df['clearsky_poa'],\n", + " df['clearsky_Tcell'],\n", + " meta['power_dc_rated'], meta['gamma_pdc'], 25.0 )\n", + "\n", + "# Calculate the normalization, the function also returns the relevant insolation for\n", + "# each point in the normalized PV energy timeseries\n", + "clearsky_normalized, clearsky_insolation = rdtools.normalize_with_expected_power(\n", + " df['power_ac'],\n", + " clearsky_modeled_power,\n", + " df['clearsky_poa']\n", + ")\n", + "\n", + "df['clearsky_normalized'] = clearsky_normalized\n", + "df['clearsky_insolation'] = clearsky_insolation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 2: Filter\n", + "Filter as in step 2 above, but with the addition of a clear sky index (csi) filter so we consider only points well modeled by the clear sky irradiance model." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Perform clearsky filter\n", + "cs_normalized_mask = rdtools.normalized_filter(df['clearsky_normalized'])\n", + "cs_poa_mask = rdtools.poa_filter(df['clearsky_poa'])\n", + "cs_tcell_mask = rdtools.tcell_filter(df['clearsky_Tcell'])\n", + "\n", + "csi_mask = rdtools.csi_filter(df.insolation, df.clearsky_insolation)\n", + "\n", + "clearsky_filtered = df[cs_normalized_mask & cs_poa_mask & cs_tcell_mask &\n", + " clip_mask & csi_mask]\n", + "clearsky_filtered = clearsky_filtered[['clearsky_insolation', 'clearsky_normalized']]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 3: Aggregate\n", + "Aggregate the clear sky version of of the filtered data " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "clearsky_daily = rdtools.aggregation_insol(clearsky_filtered.clearsky_normalized,\n", + " clearsky_filtered.clearsky_insolation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Clear Sky 4: Degradation Calculation\n", + "Estimate the degradation rate and compare to the results obtained with sensors. In this case, we see that the degradation rate estimated with the clearsky methodology is not far off from the sensor-based estimate. " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The P95 exceedance level with the clear sky analysis is -0.91%/yr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the degradation rate using the YoY method\n", + "cs_yoy_rd, cs_yoy_ci, cs_yoy_info = rdtools.degradation_year_on_year(\n", + " clearsky_daily,\n", + " confidence_level=68.2\n", + ")\n", + "\n", + "# Note the default confidence_level of 68.2 is appropriate if you would like to \n", + "# report a confidence interval analogous to the standard deviation of a normal\n", + "# distribution. The size of the confidence interval is adjustable by setting the\n", + "# confidence_level variable.\n", + "\n", + "# Visualize the results\n", + "clearsky_fig = rdtools.degradation_summary_plots(\n", + " cs_yoy_rd, cs_yoy_ci, cs_yoy_info, clearsky_daily,\n", + " summary_title='Clear-sky-based degradation results',\n", + " scatter_ymin=0.5, scatter_ymax=1.1,\n", + " hist_xmin=-30, hist_xmax=45, plot_color='orangered',\n", + " bins=100);\n", + "\n", + "print('The P95 exceedance level with the clear sky analysis is %.2f%%/yr' %\n", + " cs_yoy_info['exceedance_level'])" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Compare to previous sensor results\n", + "degradation_fig" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/degradation_example.ipynb b/docs/degradation_example.ipynb deleted file mode 100644 index b9f5fe56..00000000 --- a/docs/degradation_example.ipynb +++ /dev/null @@ -1,630 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Degradation example with clearsky workflow\n", - "\n", - "\n", - "This juypter notebook is intended to illustrate the degradation analysis workflow. In addition, the notebook demonstrates the effects of changes in the workflow. For a consistent experience, we recommend installing the packages and versions documented in `docs/notebook_requirements.txt`. This can be achieved in your environment by running `pip install -r docs/notebook_requirements.txt` from the base directory. (RdTools must also be separately installed.)\n", - "\n", - "The degradation calculations consist of several steps illustrated here:\n", - "
    \n", - "
  1. Import and preliminary calculations
    2. \n", - "
  2. Normalize data using a performance metric
    3. \n", - "
  3. Filter data that creates bias
    4. \n", - "
  4. Aggregate data
    5. \n", - "
  5. Analyze aggregated data to estimate the degradation rate
    6. \n", - "
\n", - "\n", - "After demonstrating these steps using sensor data, a modified version of the workflow is illustrated using modled clear sky irradiance and temperature. The results from the two methods are compared\n", - "\n", - "This notebook works with public data from the the Desert Knowledge Australia Solar Centre. Please download the site data from Site 12, and unzip the csv file in the folder:\n", - "./rdtools/docs/\n", - "\n", - "Note this example was run with data downloaded on Sept. 28, 2018. An older version of the data gave different sensor-based results. If you have an older version of the data and are getting different results, please try redownloading the data.\n", - "\n", - "http://dkasolarcentre.com.au/download?location=alice-springs" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from datetime import timedelta\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pvlib\n", - "import rdtools\n", - "%matplotlib inline\n", - "\n", - "# This helps dates get plotted properly\n", - "pd.plotting.register_matplotlib_converters()" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "#Update the style of plots\n", - "import matplotlib\n", - "matplotlib.rcParams.update({'font.size': 12,\n", - " 'figure.figsize': [4.5, 3],\n", - " 'lines.markeredgewidth': 0,\n", - " 'lines.markersize': 2\n", - " })" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 0: Import and preliminary calculations\n", - "\n", - "\n", - "This section prepares the data necesary for an `rdtools` calculation. The first step of the `rdtools` workflow is normaliztion, which requires a time series of energy yield, a time series of cell temperature, and a time series of irradiance, along with some metadata (see Step 1: Normalize)\n", - "\n", - "The following section loads the data, adjusts units where needed, and renames the critical columns. The irradiance sensor data source is transposed to plane-of-array, and the temperature sensor data source is converted into estimated cell temperature.\n", - "\n", - "A common challenge is handling datasets with and without daylight savings time. Make sure to specify a `pytz` timezone that does or does not include daylight savings time as appropriate for your dataset.\n", - "\n", - "The steps of this section may change depending on your data source or the system being considered. Note that nothing in this first section utlizes the `rdtools` library. Transposition of irradiance and modeling of cell temperature are generally outside the scope of `rdtools`. A variety of tools for these calculations are avaialble in [`pvlib`](https://github.com/pvlib/pvlib-python)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/anaconda2/envs/notebook_test/lib/python3.6/site-packages/pvlib/irradiance.py:282: RuntimeWarning: invalid value encountered in maximum\n", - " beam = np.maximum(beam, 0)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "file_name = '84-Site_12-BP-Solar.csv'\n", - "\n", - "df = pd.read_csv(file_name)\n", - "try:\n", - " df.columns = [col.decode('utf-8') for col in df.columns]\n", - "except AttributeError:\n", - " pass # Python 3 strings are already unicode literals\n", - "df = df.rename(columns = {\n", - " u'12 BP Solar - Active Power (kW)':'power',\n", - " u'12 BP Solar - Wind Speed (m/s)': 'wind',\n", - " u'12 BP Solar - Weather Temperature Celsius (\\xb0C)': 'Tamb',\n", - " u'12 BP Solar - Global Horizontal Radiation (W/m\\xb2)': 'ghi',\n", - " u'12 BP Solar - Diffuse Horizontal Radiation (W/m\\xb2)': 'dhi'\n", - "})\n", - "\n", - "# Specify the Metadata\n", - "meta = {\"latitude\": -23.762028,\n", - " \"longitude\": 133.874886,\n", - " \"timezone\": 'Australia/North',\n", - " \"tempco\": -0.005,\n", - " \"azimuth\": 0,\n", - " \"tilt\": 20,\n", - " \"pdc\": 5100.0,\n", - " \"temp_model\": 'open_rack_cell_polymerback'}\n", - "\n", - "df.index = pd.to_datetime(df.Timestamp)\n", - "# TZ is required for irradiance transposition\n", - "df.index = df.index.tz_localize(meta['timezone'], ambiguous = 'infer') \n", - "\n", - "# Explicitly trim the dates so that runs of this example notebook \n", - "# are comparable when the sourec dataset has been downloaded at different times\n", - "df = df['2008-11-11':'2017-05-15']\n", - "\n", - "# Chage power from kilowatts to watts\n", - "df['power'] = df.power * 1000.0 \n", - "# There is some missing data, but we can infer the frequency from the first several data points\n", - "freq = pd.infer_freq(df.index[:10])\n", - "\n", - "# And then set the frequency of the dataframe\n", - "df = df.resample(freq).median()\n", - "\n", - "# Calculate energy yield in Wh\n", - "df['energy'] = df.power * pd.to_timedelta(df.power.index.freq).total_seconds()/(3600.0)\n", - "\n", - "# Calculate POA irradiance from DHI, GHI inputs\n", - "loc = pvlib.location.Location(meta['latitude'], meta['longitude'], tz = meta['timezone'])\n", - "sun = loc.get_solarposition(df.index)\n", - "\n", - "# calculate the POA irradiance\n", - "sky = pvlib.irradiance.isotropic(meta['tilt'], df.dhi)\n", - "df['dni'] = (df.ghi - df.dhi)/np.cos(np.deg2rad(sun.zenith))\n", - "beam = pvlib.irradiance.beam_component(meta['tilt'], meta['azimuth'], sun.zenith, sun.azimuth, df.dni)\n", - "df['poa'] = beam + sky\n", - "\n", - "# Calculate cell temperature\n", - "df_temp = pvlib.pvsystem.sapm_celltemp(df.poa, df.wind, df.Tamb, model = meta['temp_model'])\n", - "df['Tcell'] = df_temp.temp_cell\n", - "\n", - "# plot the AC power time series\n", - "fig, ax = plt.subplots(figsize=(4,3))\n", - "ax.plot(df.index, df.power, 'o', alpha = 0.01)\n", - "ax.set_ylim(0,7000)\n", - "fig.autofmt_xdate()\n", - "ax.set_ylabel('AC Power (W)');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 1: Normalize\n", - "\n", - "Data normalization is achieved with `rdtools.normalize_with_pvwatts()`. We provide a time sereis of energy, along with keywords used to run a pvwatts model of the system. More information available in the docstring." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Specify the keywords for the pvwatts model\n", - "pvwatts_kws = {\"poa_global\" : df.poa,\n", - " \"P_ref\" : meta['pdc'],\n", - " \"T_cell\" : df.Tcell,\n", - " \"G_ref\" : 1000,\n", - " \"T_ref\": 25,\n", - " \"gamma_pdc\" : meta['tempco']}\n", - "\n", - "# Calculate the normaliztion, the function also returns the relevant insolation for\n", - "# each point in the normalized PV energy timeseries\n", - "normalized, insolation = rdtools.normalize_with_pvwatts(df.energy, pvwatts_kws)\n", - "\n", - "df['normalized'] = normalized\n", - "df['insolation'] = insolation\n", - "\n", - "# Plot the normalized power time series\n", - "fig, ax = plt.subplots()\n", - "ax.plot(normalized.index, normalized, 'o', alpha = 0.05)\n", - "ax.set_ylim(0,2)\n", - "fig.autofmt_xdate()\n", - "ax.set_ylabel('Normalized energy');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 2: Filter\n", - "\n", - "Data filtering is used to exclude data points that represent invalid data, create bias in the analysis, or introduce significant noise.\n", - "\n", - "It can also be useful to remove outages and outliers. Sometimes outages appear as low but non-zero yield. Automatic functions for this are not yet included in `rdtools`. Such filters should be implimented by the analyst if needed." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate a collection of boolean masks that can be used\n", - "# to filter the time series\n", - "nz_mask = (df['normalized'] > 0)\n", - "poa_mask = rdtools.poa_filter(df['poa'])\n", - "tcell_mask = rdtools.tcell_filter(df['Tcell'])\n", - "clip_mask = rdtools.clip_filter(df['power'])\n", - "\n", - "# filter the time series and keep only the columns needed for the\n", - "# remaining steps\n", - "filtered = df[nz_mask & poa_mask & tcell_mask & clip_mask]\n", - "filtered = filtered[['insolation', 'normalized']]\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.plot(filtered.index, filtered.normalized, 'o', alpha = 0.05)\n", - "ax.set_ylim(0,2)\n", - "fig.autofmt_xdate()\n", - "ax.set_ylabel('Normalized energy');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 3: Aggregate\n", - "\n", - "Data is aggregated with an irradiance weighted average. This can be useful, for example with daily aggregation, to reduce the impact of high-error data points in the morning and evening." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "daily = rdtools.aggregation_insol(filtered.normalized, filtered.insolation, frequency = 'D')\n", - "\n", - "fig, ax = plt.subplots()\n", - "ax.plot(daily.index, daily, 'o', alpha = 0.1)\n", - "ax.set_ylim(0,2)\n", - "fig.autofmt_xdate()\n", - "ax.set_ylabel('Normalized energy');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 4: Degradation calculation\n", - "\n", - "Data is then analyzed to estimate the degradation rate representing the PV system behavior. The results are visualized and statistics are reported, including the 68.2% confidence interval, and the P95 exceedence value." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the degradation rate using the YoY method\n", - "yoy_rd, yoy_ci, yoy_info = rdtools.degradation_year_on_year(daily, confidence_level=68.2)\n", - "# Note the default confidence_level of 68.2 is approrpriate if you would like to \n", - "# report a confidence interval analogous to the standard deviation of a normal\n", - "# distribution. The size of the confidence interval is adjustable by setting the\n", - "# confidence_level variable.\n", - "\n", - "# Visualize the results\n", - "start = daily.index[0]\n", - "end = daily.index[-1]\n", - "years = (end - start).days / 365.0\n", - "yoy_values = yoy_info['YoY_values']\n", - "\n", - "x = [start, end]\n", - "y = [1, 1 + (yoy_rd * years)/100]\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10, 3))\n", - "ax2.hist(yoy_values, label='YOY', bins=len(yoy_values)//40)\n", - "ax2.axvline(x=yoy_rd, color='black', linestyle='dashed', linewidth=3)\n", - "ax2.set_xlim(-30,45)\n", - "ax2.annotate( u' $R_{d}$ = %.2f%%/yr \\n confidence interval: \\n %.2f to %.2f %%/yr' \n", - " %(yoy_rd, yoy_ci[0], yoy_ci[1]), xy=(0.5, 0.7), xycoords='axes fraction',\n", - " bbox=dict(facecolor='white', edgecolor=None, alpha = 0))\n", - "ax2.set_xlabel('Annual degradation (%)');\n", - "\n", - "ax1.plot(daily.index, daily/yoy_info['renormalizing_factor'], 'o', alpha = 0.5)\n", - "ax1.plot(x, y, 'k--', linewidth=3)\n", - "ax1.set_xlabel('Date')\n", - "ax1.set_ylabel('Renormalized Energy')\n", - "ax1.set_ylim(0.5, 1.1)\n", - "fig.autofmt_xdate()\n", - "\n", - "fig.suptitle('Sensor-based degradation results');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In addition to the confidence interval, the year-on-year method yields an exceedence value (e.g. P95), the degradation rate that was exceeded (slower degradation) with a given probability level. The probability level is set via the `exceedence_prob` keyword in `degradation_year_on_year`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The P95 exceedance level is -0.55%/yr\n" - ] - } - ], - "source": [ - "print('The P95 exceedance level is %.2f%%/yr' % yoy_info['exceedance_level'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear sky workflow\n", - "The clear sky workflow is useful in that it avoids problems due to drift or recalibration of ground-based sensors. We use `pvlib` to model the clear sky irradiance. This is renormalized to align it with ground-based measurements. Finally we use `rdtools.get_clearsky_tamb()` to model the ambient temperature on clear sky days. This modeled ambient temperature is used to model cell temperature with `pvlib`. If high quality amabient temperature data is available, that can be used instead of the modeled ambient; we proceed with the modeled ambient temperature here for illustrative purposes.\n", - "\n", - "In this example, note that we have omitted wind data in the cell temperature calculations for illustrative purposes. Wind data can also be included when the data source is trusted for improved results\n", - "\n", - "**Note that the claculations below rely on some objects from the steps above**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear Sky 0: Preliminary Calculations" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Calculate the clear sky POA irradiance\n", - "clearsky = loc.get_clearsky(df.index, solar_position = sun)\n", - "cs_sky = pvlib.irradiance.isotropic(meta['tilt'], clearsky.dhi)\n", - "cs_beam = pvlib.irradiance.beam_component(meta['tilt'], meta['azimuth'], sun.zenith, sun.azimuth, clearsky.dni)\n", - "df['clearsky_poa'] = cs_beam + cs_sky\n", - "\n", - "# Renormalize the clear sky POA irradiance\n", - "df['clearsky_poa'] = rdtools.irradiance_rescale(df.poa, df.clearsky_poa, method='iterative')\n", - "\n", - "# Calculate the clearsky temperature\n", - "df['clearsky_Tamb'] = rdtools.get_clearsky_tamb(df.index, meta['latitude'], meta['longitude'])\n", - "df_clearsky_temp = pvlib.pvsystem.sapm_celltemp(df.clearsky_poa, 0, df.clearsky_Tamb, model = meta['temp_model'])\n", - "df['clearsky_Tcell'] = df_clearsky_temp.temp_cell" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear Sky 1: Normalize\n", - "Normalize as in step 1 above, but this time using clearsky modeled irradiance and cell temperature" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "clearsky_pvwatts_kws = {\"poa_global\" : df.clearsky_poa,\n", - " \"P_ref\" : meta['pdc'],\n", - " \"T_cell\" :df.clearsky_Tcell,\n", - " \"G_ref\" : 1000,\n", - " \"T_ref\": 25,\n", - " \"gamma_pdc\" : meta['tempco']}\n", - "\n", - "clearsky_normalized, clearsky_insolation = rdtools.normalize_with_pvwatts(df.energy, clearsky_pvwatts_kws)\n", - "\n", - "df['clearsky_normalized'] = clearsky_normalized\n", - "df['clearsky_insolation'] = clearsky_insolation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear Sky 2: Filter\n", - "Filter as in step 2 above, but with the addition of a clear sky index (csi) filter so we consider only points well modeled by the clear sky irradiance model." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# Perform clearsky filter\n", - "cs_nz_mask = (df['clearsky_normalized'] > 0)\n", - "cs_poa_mask = rdtools.poa_filter(df['clearsky_poa'])\n", - "cs_tcell_mask = rdtools.tcell_filter(df['clearsky_Tcell'])\n", - "\n", - "csi_mask = rdtools.csi_filter(df.insolation, df.clearsky_insolation)\n", - "\n", - "\n", - "clearsky_filtered = df[cs_nz_mask & cs_poa_mask & cs_tcell_mask & clip_mask & csi_mask]\n", - "clearsky_filtered = clearsky_filtered[['clearsky_insolation', 'clearsky_normalized']]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear Sky 3: Aggregate\n", - "Aggregate the clear sky version of of the filtered data " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "clearsky_daily = rdtools.aggregation_insol(clearsky_filtered.clearsky_normalized, clearsky_filtered.clearsky_insolation)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Clear Sky 4: Degradation Calculation\n", - "Estimate the degradation rate and compare to the results obtained with sensors. In this case, we see that irradiance sensor drift may have biased the sensor-based results, a problem that is corrected by the clear sky approach." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The P95 exceedance level with the clear sky analysis is -0.31%/yr\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the degradation rate using the YoY method\n", - "cs_yoy_rd, cs_yoy_ci, cs_yoy_info = rdtools.degradation_year_on_year(clearsky_daily, confidence_level=68.2)\n", - "# Note the default confidence_level of 68.2 is approrpriate if you would like to \n", - "# report a confidence interval analogous to the standard deviation of a normal\n", - "# distribution. The size of the confidence interval is adjustable by setting the\n", - "# confidence_level variable.\n", - "\n", - "# Visualize the results\n", - "cs_start = clearsky_daily.index[0]\n", - "cs_end = clearsky_daily.index[-1]\n", - "cs_years = (cs_end - cs_start).days / 365.0\n", - "cs_yoy_values = cs_yoy_info['YoY_values']\n", - "\n", - "cs_x = [cs_start, cs_end]\n", - "cs_y = [1, 1 + (cs_yoy_rd * cs_years)/100]\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10, 3))\n", - "ax2.hist(cs_yoy_values, label='YOY', bins=len(cs_yoy_values)//40, color = 'orangered')\n", - "ax2.axvline(x=cs_yoy_rd, color='black', linestyle='dashed', linewidth=3)\n", - "ax2.set_xlim(-30,45)\n", - "ax2.annotate( u' $R_{d}$ = %.2f%%/yr \\n confidence interval: \\n %.2f to %.2f %%/yr' \n", - " %(cs_yoy_rd, cs_yoy_ci[0], cs_yoy_ci[1]), xy=(0.5, 0.7), xycoords='axes fraction',\n", - " bbox=dict(facecolor='white', edgecolor=None, alpha = 0))\n", - "ax2.set_xlabel('Annual degradation (%)');\n", - "\n", - "ax1.plot(clearsky_daily.index, clearsky_daily/cs_yoy_info['renormalizing_factor'], 'o', color = 'orangered', alpha = 0.5)\n", - "ax1.plot(cs_x, cs_y, 'k--', linewidth=3)\n", - "ax1.set_xlabel('Date')\n", - "ax1.set_ylabel('Renormalized Energy')\n", - "ax1.set_ylim(0.5, 1.1)\n", - "fig.autofmt_xdate()\n", - "\n", - "fig.suptitle('Clear-sky-based degradation results');\n", - "\n", - "\n", - "\n", - "# repeat the plots from above\n", - "fig, (ax1, ax2) = plt.subplots(1,2, figsize=(10, 3))\n", - "ax2.hist(yoy_values, label='YOY', bins=len(yoy_values)//40)\n", - "ax2.axvline(x=yoy_rd, color='black', linestyle='dashed', linewidth=3)\n", - "ax2.set_xlim(-30,45)\n", - "ax2.annotate( u' $R_{d}$ = %.2f%%/yr \\n confidence interval: \\n %.2f to %.2f %%/yr' \n", - " %(yoy_rd, yoy_ci[0], yoy_ci[1]), xy=(0.5, 0.7), xycoords='axes fraction',\n", - " bbox=dict(facecolor='white', edgecolor=None, alpha = 0))\n", - "ax2.set_xlabel('Annual degradation (%)');\n", - "\n", - "ax1.plot(daily.index, daily/yoy_info['renormalizing_factor'], 'o', alpha = 0.5)\n", - "ax1.plot(x, y, 'k--', linewidth=3)\n", - "ax1.set_xlabel('Date')\n", - "ax1.set_ylabel('Renormalized Energy')\n", - "ax1.set_ylim(0.5, 1.1)\n", - "fig.autofmt_xdate()\n", - "\n", - "fig.suptitle('Sensor-based degradation results');\n", - "\n", - "print('The P95 exceedance level with the clear sky analysis is %.2f%%/yr' % cs_yoy_info['exceedance_level'])" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python [conda env:notebook_test]", - "language": "python", - "name": "conda-env-notebook_test-py" - }, - "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.6.6" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/docs/notebook_requirements.txt b/docs/notebook_requirements.txt index d1ad2cb0..7b74f3a4 100644 --- a/docs/notebook_requirements.txt +++ b/docs/notebook_requirements.txt @@ -1,7 +1,8 @@ +# This is an incomplete specification of the intended environment +# it is meant to be used tandem with ../requirements.txt appnope==0.1.0 backcall==0.1.0 bleach==3.1.4 -cycler==0.10.0 decorator==4.3.0 entrypoints==0.2.3 html5lib==1.0.1 @@ -16,26 +17,19 @@ jupyter==1.0.0 jupyter-client==5.2.3 jupyter-console==5.2.0 jupyter-core==4.4.0 -kiwisolver==1.0.1 MarkupSafe==1.1.1 -matplotlib==2.2.2 mistune==0.8.3 nbconvert==5.3.1 nbformat==4.4.0 notebook==5.7.8 -numpy==1.16.6 -pandas==0.23.4 pandocfilters==1.4.2 parso==0.3.1 -patsy==0.5.0 pexpect==4.6.0 pickleshare==0.7.4 prometheus-client==0.3.0 prompt-toolkit==1.0.15 ptyprocess==0.6.0 -pvlib==0.5.2 Pygments==2.2.0 -pyparsing==2.2.0 pyzmq==17.1.0 qtconsole==4.3.1 Send2Trash==1.5.0 diff --git a/docs/sphinx/Makefile b/docs/sphinx/Makefile new file mode 100644 index 00000000..d0c3cbf1 --- /dev/null +++ b/docs/sphinx/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/sphinx/make.bat b/docs/sphinx/make.bat new file mode 100644 index 00000000..9534b018 --- /dev/null +++ b/docs/sphinx/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/screenshots/Clearsky_result_updated.png b/docs/sphinx/source/_images/Clearsky_result_updated.png similarity index 100% rename from screenshots/Clearsky_result_updated.png rename to docs/sphinx/source/_images/Clearsky_result_updated.png diff --git a/docs/sphinx/source/_images/RdTools_workflows.png b/docs/sphinx/source/_images/RdTools_workflows.png new file mode 100644 index 0000000000000000000000000000000000000000..cf0d26d913b9f2e6e6cd3d16eebbdbd79a4520f1 GIT binary patch literal 26884 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 literal 0 HcmV?d00001 diff --git a/screenshots/Workflow1.png b/docs/sphinx/source/_images/Workflow1.png similarity index 100% rename from screenshots/Workflow1.png rename to docs/sphinx/source/_images/Workflow1.png diff --git a/docs/sphinx/source/_images/logo_horizontal_highres.png b/docs/sphinx/source/_images/logo_horizontal_highres.png new file mode 100644 index 0000000000000000000000000000000000000000..09b86297ad5445e6f4d04da79c1cd57d0144384b GIT binary patch literal 336510 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 c=WyY_{BO4vDLn%RiMz=C|vE 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�YX(HcF`X`S?elMYF%aBw17+$-j`wlH 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%0AW8J!gd)6DGKFNxUTWJL;Z-`3Y(8_7PNQg}d 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

hh`y4 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 literal 0 HcmV?d00001 diff --git a/docs/sphinx/source/_images/soiling_histogram.png b/docs/sphinx/source/_images/soiling_histogram.png new file mode 100644 index 0000000000000000000000000000000000000000..dd6666fcf90cec98aff90815981781b6c902232a GIT binary patch literal 36414 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ϤWsV*QEs!<4xIHDHJ!z2mxCvVP$GxWg#iY!y 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 s|M4xOWZ+wbn?C;EAQSoj`Cr@ + + {{ link_info['text'] }} + + + {% endif %} +{% endblock %} \ No newline at end of file diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst new file mode 100644 index 00000000..4f4649d3 --- /dev/null +++ b/docs/sphinx/source/api.rst @@ -0,0 +1,123 @@ +.. currentmodule:: rdtools + +############# +API reference +############# + + +Submodules +========== + +RdTools is organized into submodules focused on different parts of the data +analysis workflow. + +.. autosummary:: + :toctree: generated/ + + degradation + soiling + filtering + normalization + aggregation + clearsky_temperature + plotting + + +Degradation +=========== + +Functions for estimating degradation rates from PV system data. + +.. autosummary:: + :toctree: generated/ + + degradation.degradation_classical_decomposition + degradation.degradation_ols + degradation.degradation_year_on_year + + +Soiling +======= + +Functions for estimating soiling rates from PV system data. + +.. autosummary:: + :toctree: generated/ + + soiling.soiling_srr + soiling.SRRAnalysis + soiling.SRRAnalysis.run + + +Filtering +========= + +Functions to perform filtering on PV system data. + +.. autosummary:: + :toctree: generated/ + + filtering.clip_filter + filtering.csi_filter + filtering.poa_filter + filtering.tcell_filter + filtering.normalized_filter + + +Normalization +============= + +Functions for normalizing power measurements for further analysis. + +.. autosummary:: + :toctree: generated/ + + normalization.check_series_frequency + normalization.delta_index + normalization.energy_from_power + normalization.interpolate + normalization.interpolate_series + normalization.irradiance_rescale + normalization.normalize_with_expected_power + normalization.normalize_with_pvwatts + normalization.normalize_with_sapm + normalization.pvwatts_dc_power + normalization.sapm_dc_power + normalization.t_step_nanoseconds + normalization.trapz_aggregate + + +Aggregation +=========== + +Functions to aggregate PV system data. + +.. autosummary:: + :toctree: generated/ + + aggregation.aggregation_insol + + +Clear-Sky Temperature +===================== + +Functions for modeling ambient temperature. + +.. autosummary:: + :toctree: generated/ + + clearsky_temperature.get_clearsky_tamb + + +Plotting +======== + +Functions to visualize degradation and soiling analysis results. + +.. autosummary:: + :toctree: generated/ + + plotting.degradation_summary_plots + plotting.soiling_monte_carlo_plot + plotting.soiling_interval_plot + plotting.soiling_rate_histogram diff --git a/docs/sphinx/source/changelog.rst b/docs/sphinx/source/changelog.rst new file mode 100644 index 00000000..ed8a34b9 --- /dev/null +++ b/docs/sphinx/source/changelog.rst @@ -0,0 +1,4 @@ +RdTools Change Log +================== + +.. include:: changelog/v2.0.0b0.rst diff --git a/docs/sphinx/source/changelog/v2.0.0b0.rst b/docs/sphinx/source/changelog/v2.0.0b0.rst new file mode 100644 index 00000000..c9901904 --- /dev/null +++ b/docs/sphinx/source/changelog/v2.0.0b0.rst @@ -0,0 +1,93 @@ +************************ +v2.0.0b0 (July 31, 2020) +************************ + +API Changes +----------- +* The calculations internal to :py:func:`~rdtools.normalization.normalize_with_pvwatts` + and :py:func:`~rdtools.normalization.normalize_with_sapm` have changed. + Generally, when working with raw power data it should be converted to + right-labeled energy with :py:func:`~rdtools.normalization.energy_from_power` + before being used with these normalization functions (:pull:`105`, :pull:`108`). +* Remove ``low_power_cutoff`` parameter in :py:func:`~rdtools.filtering.clip_filter` (:issue:`84`). +* Rename `soiling.srr_analysis` to :py:class:`~rdtools.soiling.SRRAnalysis` (:pull:`168`). +* Double the default value of the ``max_timedelta`` in :py:func:`~rdtools.normalization.interpolate` + and :py:func:`~rdtools.normalization.interpolate_series` to be twice the + median timedelta (:pull:`182`). +* Support varying logic in soiling module for defining cleaning events from shifts and + precipitation with ``clean_criterion`` parameter. Behavior of ``clean_criterion='precip_and_shift'`` + has changed relative to prior versions using ``precip_clean_only=True`` (:pull:`176`). +* Remove ``random_seed`` parameter from soiling module. Functionality can be obtained by running + ``numpy.random.seed()`` outside of RdTools functions. (:pull:`176`) +* Many kwargs have changed name (but not input order) to bring nomenclature into + closer alignment with the `DuraMAT pv-terms project `_: (:pull:`185`) + + * :py:func:`~rdtools.aggregation.aggregation_insol` first kwarg is now ``energy_normalized``. + * :py:func:`~rdtools.degradation.degradation_year_on_year`, + :py:func:`~rdtools.degradation.degradation_ols` and + :py:func:`~rdtools.degradation.degradation_classical_decomposition` + first kwarg is now ``energy_normalized``. + * :py:func:`~rdtools.filtering.normalized_filter` input kwargs are now ``energy_normalized``, ``energy_normalized_low`` and ``energy_normalized_high``. + * :py:func:`~rdtools.filtering.poa_filter` input kwargs are now ``poa_global``, ``poa_global_low`` and ``poa_global_high``. + * :py:func:`~rdtools.filtering.tcell_filter` input kwargs are now ``temperature_cell``, ``temperature_cell_low`` and ``temperature_cell_high``. + * :py:func:`~rdtools.filtering.clip_filter` input kwargs are now ``power_ac`` and ``quantile``. + * :py:func:`~rdtools.filtering.csi_filter` first two kwargs are now ``poa_global_measured``, ``poa_global_clearsky``. + * :py:func:`~rdtools.normalization.normalize_with_pvwatts` pvwatts_kws dictionary keys have been renamed. + * :py:func:`~rdtools.normalization.pvwatts_dc_power` input kwargs are now ``poa_global``, ``power_dc_rated``, ``temperature_cell``, ``poa_global_ref``, ``temperature_cell_ref``, ``gamma_pdc``. + +Enhancements +------------ +* Add new :py:mod:`~rdtools.soiling` module to implement the stochastic rate and + recovery method (:pull:`112`). +* Add new function :py:func:`~rdtools.normalization.normalize_with_expected_power` (:pull:`173`). +* Add new functions :py:func:`~rdtools.normalization.energy_from_power` and + :py:func:`~rdtools.normalization.interpolate` (:pull:`105`, :pull:`108`). +* Add new function :py:func:`~rdtools.filtering.normalized_filter`. +* Add new :py:mod:`~rdtools.plotting` module for generating standard plots. +* Add parameter ``convergence_threshold`` to + :py:func:`~rdtools.normalization.irradiance_rescale` (:pull:`152`). +* Add parameter ``warning_threshold`` to :py:func:`~rdtools.normalization.interpolate` + and :py:func:`~rdtools.normalization.interpolate_series` (:pull:`182`). + +Bug fixes +--------- +* Allow ``max_iterations=0`` in + :py:func:`~rdtools.normalization.irradiance_rescale` (:pull:`152`). +* Fix a bug in :py:mod:`~rdtools.soiling` code that caused problems for soiling intervals + consisting solely of invalid data. (:pull:`169`) + + +Testing +------- +* Add Python 3.7 and 3.8 to CI testing (:pull:`135`). + +Documentation +------------- +* Create sphinx documentation and set up ReadTheDocs (:pull:`125`). +* Add guides on running tests and building sphinx docs (:pull:`136`). +* Improve module-level docstrings (:pull:`137`). + +Requirements +------------ +* Drop support for Python 2.7, minimum supported version is now 3.6 (:pull:`135`). +* Increase minimum pvlib version to 0.7.0. +* Update requirements.txt and notebook_requirements.txt to avoid conflicting specifications. Taken together, + they represent the complete environment for the notebook example (:pull:`164`). + +Example Updates +--------------- +* Seed ``numpy.random`` to ensure repeatable results (:pull:`164`). +* Use :py:func:`~rdtools.filtering.normalized_filter` instead of manually + filtering the normalized energy timeseries. Also updated the associated mask + variable names (:pull:`139`). +* Add a new example notebook that analyzes data from a PV system located at + NREL's South Table Mountain campus (PVDAQ system #4) (:pull:`171`). +* Explicitly register pandas datetime converters which were `deprecated `_. + + +Contributors +------------ +* Mike Deceglie (:ghuser:`mdeceglie`) +* Kevin Anderson (:ghuser:`kanderso-nrel`) +* Chris Deline (:ghuser:`cdeline`) + diff --git a/docs/sphinx/source/conf.py b/docs/sphinx/source/conf.py new file mode 100644 index 00000000..420d26b3 --- /dev/null +++ b/docs/sphinx/source/conf.py @@ -0,0 +1,197 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# http://www.sphinx-doc.org/en/master/config + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# + + +# prefer local rdtools folder to one installed in a venv or site-packages: +import os +import sys +import inspect +sys.path.insert(0, os.path.abspath('../../..')) + + +# -- Project information ----------------------------------------------------- + +project = 'RdTools' +copyright = '2016–2020 kwhanalytics, Alliance for Sustainable Energy, LLC, and SunPower' +author = 'kwhanalytics, Alliance for Sustainable Energy, LLC, and SunPower' + +# The full version, including alpha/beta/rc tags +import rdtools +release = version = rdtools.__version__ + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.napoleon', + 'sphinx.ext.extlinks', + 'sphinx_rtd_theme', + 'sphinx.ext.autosummary', + 'nbsphinx', + 'nbsphinx_link', +] + +autosummary_generate = True + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. + +exclude_patterns = [] + +source_suffix = ['.rst', '.md'] + +# List of external link aliases. Allows use of :pull:`123` to autolink that PR +extlinks = { + 'issue': ('https://github.com/NREL/rdtools/issues/%s', 'GH #'), + 'pull': ('https://github.com/NREL/rdtools/pull/%s', 'GH #'), + 'ghuser': ('https://github.com/%s', '@') +} + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# toctree sidebar depth +html_theme_options = { + 'navigation_depth': 4, + 'collapse_navigation': False +} +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static', '_images'] + +master_doc = 'index' +# A workaround for the responsive tables always having annoying scrollbars. +def setup(app): + app.add_stylesheet("no_scrollbars.css") + + +# %% helper functions for intelligent "View on Github" linking +# based on +# https://gist.github.com/flying-sheep/b65875c0ce965fbdd1d9e5d0b9851ef1 + +def get_obj_module(qualname): + """ + Get a module/class/attribute and its original module by qualname. + Useful for looking up the original location when a function is imported + into an __init__.py + + Examples + -------- + >>> func, mod = get_obj_module("rdtools.degradation_ols") + >>> mod.__name__ + 'rdtools.degradation' + """ + modname = qualname + classname = None + attrname = None + while modname not in sys.modules: + attrname = classname + modname, classname = modname.rsplit('.', 1) + + # retrieve object and find original module name + if classname: + cls = getattr(sys.modules[modname], classname) + modname = cls.__module__ + obj = getattr(cls, attrname) if attrname else cls + else: + obj = None + + return obj, sys.modules[modname] + + +def get_linenos(obj): + """Get an object’s line numbers in its source code file""" + try: + lines, start = inspect.getsourcelines(obj) + except TypeError: # obj is an attribute or None + return None, None + else: + return start, start + len(lines) - 1 + + +def make_github_url(pagename): + """ + Generate the appropriate GH link for a given docs page. This function + is intended for use in sphinx template files. + The target URL is built differently based on the type of page. Sphinx + provides templates with a built-in `pagename` variable that is the path + at the end of the URL, without the extension. For instance, + https://rdtools.rtfd.io/en/latest/generated/rdtools.soiling.soiling_srr.html + will have pagename = "generated/rdtools.soiling.soiling_srr". + + Returns None if not building development or master. + """ + + # RTD automatically sets READTHEDOCS_VERSION to the version being built. + rtd_version = os.environ.get('READTHEDOCS_VERSION', None) + version_map = { + 'stable': 'master', + 'latest': 'development', + } + try: + branch = version_map[rtd_version] + except KeyError: + # for other builds (PRs, local builds etc), it's unclear where to link + return None + + URL_BASE = "https://github.com/nrel/rdtools/blob/{}/".format(branch) + + # is it an API autogen page? + if pagename.startswith("generated/"): + # pagename looks like "generated/rdtools.degradation.degradation_ols" + qualname = pagename.split("/")[-1] + obj, module = get_obj_module(qualname) + path = module.__name__.replace(".", "/") + ".py" + target_url = URL_BASE + path + # add line numbers if possible: + start, end = get_linenos(obj) + if start and end: + target_url += '#L{}-L{}'.format(start, end) + + # is it the example notebook? + elif pagename == "example": + target_url = URL_BASE + "docs/degradation_and_soiling_example.ipynb" + + # is the the changelog page? + elif pagename == "changelog": + target_url = URL_BASE + "docs/sphinx/source/changelog" + + # Just a normal source RST page + else: + target_url = URL_BASE + "docs/sphinx/source/" + pagename + ".rst" + + display_text = "View on github/" + branch + link_info = { + 'url': target_url, + 'text': display_text + } + return link_info + + +# variables to pass into the HTML templating engine; these are accessible from +# _templates/breadcrumbs.html +html_context = { + 'make_github_url': make_github_url, +} \ No newline at end of file diff --git a/docs/sphinx/source/developer_notes.rst b/docs/sphinx/source/developer_notes.rst new file mode 100644 index 00000000..360941bf --- /dev/null +++ b/docs/sphinx/source/developer_notes.rst @@ -0,0 +1,203 @@ +.. _developer_notes: + +Developer Notes +=============== + +This page documents some of the workflows specific to RdTools development. + +Installing RdTools source code +------------------------------ + +To make changes to RdTools, run the test suite, or build the documentation +locally, you'll need to have a local copy of the git repository. +Installing RdTools using pip will install a condensed version that +doesn't include the full source code. To get the full source code, +you'll need to clone the RdTools source repository from Github with e.g. + +:: + + git clone https://github.com/NREL/rdtools.git + +from the command line, or using a GUI git client like Github Desktop. This +will clone the entire git repository onto your computer. + +Installing RdTools dependencies +------------------------------- + +The packages necessary to run RdTools itself can be installed with ``pip``. +You can install the dependencies along with RdTools itself from +`PyPI `_: + +:: + + pip install rdtools + +This will install the latest official release of RdTools. If you want to work +with a development version and you have cloned the Github repository to your +computer, you can also install RdTools and dependencies by navigating to the +repository root, switching to the branch you're interested in, for instance: + +:: + + git checkout development + +and running: + +:: + + pip install . + +This will install based on whatever RdTools branch you have checked out. You +can check what version is currently installed by inspecting +``rdtools.__version__``: + +:: + + >>> rdtools.__version__ + '1.2.0+188.g5a96bb2' + +The hex string at the end represents the hash of the git commit for your +installed version. + +.. _installing-optional-dependencies: + +Installing optional dependencies +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +RdTools has extra dependencies for running its test suite and building its +documentation. These packages aren't necessary for running RdTools itself and +are only needed if you want to contribute source code to RdTools. + +.. note:: + These will install RdTools along with other packages necessary to build its + documentation and run its test suite. We recommend doing this in a virtual + environment to keep package installations between projects separate! + +Optional dependencies can be installed with the special +`syntax `_: + +:: + + pip install rdtools[test] # test suite dependencies + pip install rdtools[doc] # documentation dependecies + +Or, if your local repository has an updated dependencies list: + +:: + + pip install .[test] # test suite dependencies + pip install .[doc] # documentation dependecies + + +Running the test suite +---------------------- + +RdTools uses `pytest `_ to run its test +suite. If you haven't already, install the testing depencencies +(:ref:`installing-optional-dependencies`). + +To run the entire test suite, navigate to the git repo folder and run + +:: + + pytest + +For convenience, pytest lets you run tests for a single module if you don't +want to wait around for the entire suite to finish: + +:: + + pytest rdtools/test/soiling_test.py + +And even a single test function: + +:: + + pytest rdtools/test/soiling_test.py::test_soiling_srr + +You can also evaluate code coverage when running the test suite using the +`coverage `_ package: + +:: + + coverage run -m pytest + coverage report + +The first line runs the test suite and keeps track of exactly what lines of +code were run during test execution. The second line then prints out a +summary report showing how much much of each source file was +executed in the test suite. If a percentage is below 100, that means a +function isn't tested or a branch inside a function isn't tested. To get +specific details, you can run ``coverage html`` to generate a detailed HTML +report at ``htmlcov/index.html`` to view in a browser. + +Building documentation locally +------------------------------ + +RdTools uses `Sphinx `_ to build its documentation. +If you haven't already, install the documentation depencencies +(:ref:`installing-optional-dependencies`). + +Once the required packages are installed, change your console's working +directory to ``rdtools/docs/sphinx`` and run + +:: + + make html + +Note that on Windows, you don't actually need the ``make`` utility installed for +this to work because there is a ``make.bat`` in this directory. Building the +docs should result in output like this: + +:: + + (venv)$ make html + Running Sphinx v1.8.5 + making output directory... + [autosummary] generating autosummary for: api.rst, example.nblink, index.rst, readme_link.rst + [autosummary] generating autosummary for: C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.aggregation.aggregation_insol.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.aggregation.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.clearsky_temperature.get_clearsky_tamb.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.clearsky_temperature.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.degradation.degradation_classical_decomposition.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.degradation.degradation_ols.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.degradation.degradation_year_on_year.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.degradation.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.filtering.clip_filter.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.filtering.csi_filter.rst, ..., C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.normalize_with_pvwatts.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.normalize_with_sapm.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.pvwatts_dc_power.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.sapm_dc_power.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.t_step_nanoseconds.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.normalization.trapz_aggregate.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.soiling.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.soiling.soiling_srr.rst, C:\Users\KANDERSO\projects\rdtools\docs\sphinx\source\generated\rdtools.soiling.srr_analysis.rst + building [mo]: targets for 0 po files that are out of date + building [html]: targets for 4 source files that are out of date + updating environment: 33 added, 0 changed, 0 removed + reading sources... [100%] readme_link + looking for now-outdated files... none found + pickling environment... done + checking consistency... done + preparing documents... done + writing output... [100%] readme_link + generating indices... genindex py-modindex + writing additional pages... search + copying images... [100%] ../build/doctrees/nbsphinx/example_33_2.png + copying static files... done + copying extra files... done + dumping search index in English (code: en) ... done + dumping object inventory... done + build succeeded. + + The HTML pages are in build\html. + +If you get an error like ``Pandoc wasn't found``, you can install it with conda: + +:: + + conda install -c conda-forge pandoc + +The built documentation should be in ``rdtools/docs/sphinx/build`` and opening +``index.html`` with a web browser will display it. + +Contributing +------------ + +Community participation is welcome! New contributions should be based on the +``development`` branch as the ``master`` branch is used only for releases. + +RdTools follows the `PEP 8 `_ style guide. +We recommend setting up your text editor to automatically highlight style +violations because it's easy to miss some isses (trailing whitespace, etc) otherwise. + +Additionally, our documentation is built in part from docstrings in the source +code. These docstrings must be in `NumpyDoc format `_ +to be rendered correctly in the documentation. + +Finally, all code should be tested. Some older tests in RdTools use the unittest +module, but new tests should all use pytest. \ No newline at end of file diff --git a/docs/sphinx/source/example.nblink b/docs/sphinx/source/example.nblink new file mode 100644 index 00000000..45348257 --- /dev/null +++ b/docs/sphinx/source/example.nblink @@ -0,0 +1,3 @@ +{ + "path": "../../degradation_and_soiling_example_pvdaq_4.ipynb" +} \ No newline at end of file diff --git a/docs/sphinx/source/index.rst b/docs/sphinx/source/index.rst new file mode 100644 index 00000000..40feeba8 --- /dev/null +++ b/docs/sphinx/source/index.rst @@ -0,0 +1,271 @@ +.. RdTools documentation master file, created by + sphinx-quickstart on Wed Nov 6 11:54:52 2019. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +.. image:: _images/logo_horizontal_highres.png + :width: 600 + +.. pipe character renders as a blank line, used as spacer after the logo + | + +RdTools Overview +================ + +RdTools is an open-source library to support reproducible technical analysis of +time series data from photovoltaic energy systems. The library aims to provide +best practice analysis routines along with the building blocks for users to +tailor their own analyses. +Current applications include the evaluation of PV production over several years to obtain +rates of performance degradation and soiling loss. RdTools can handle +both high frequency (hourly or better) or low frequency (daily, weekly, +etc.) datasets. Best results are obtained with higher frequency data. + +Full examples are worked out in the example notebooks in the +`example notebook`_. + +To report issues, contribute code, or suggest improvements to this +documentation, visit the RdTools development repository on `github`_. + +Workflow +-------- + +RdTools supports a number of workflows, but a typical analysis follows +the following: + +0. Import and preliminary calculations +1. Normalize data using a performance metric +2. Filter data that creates bias +3. Aggregate data +4. Analyze aggregated data to estimate the degradation rate and/or + soiling loss + +Steps 1 and 2 may be accomplished with the clearsky workflow (see the +`example notebook`_) which can help eliminate problems from irradiance sensor +drift. + +.. image:: _images/RdTools_workflows.png + :alt: RdTools workflow diagram + +Degradation Results +------------------- + +The preferred method for degradation rate estimation is the year-on-year +(YOY) approach, available in :py:func:`.degradation.degradation_year_on_year`. +The YOY calculation yields in a distribution of degradation rates, the +central tendency of which is the most representative of the true +degradation. The width of the distribution provides information about +the uncertainty in the estimate via a bootstrap calculation. The +`example notebook`_ uses the output of +:py:func:`.degradation.degradation_year_on_year` to visualize the calculation. + +.. image:: _images/Clearsky_result_updated.png + :alt: RdTools degradation results plot + +Two workflows are available for system performance ratio calculation, +and illustrated in an example notebook. The sensor-based approach +assumes that site irradiance and temperature sensors are calibrated and +in good repair. Since this is not always the case, a 'clear-sky' +workflow is provided that is based on modeled temperature and +irradiance. Note that site irradiance data is still required to identify +clear-sky conditions to be analyzed. In many cases, the 'clear-sky' +analysis can identify conditions of instrument errors or irradiance +sensor drift, such as in the above analysis. + +The clear-sky analysis tends to provide less stable results than sensor-based +analysis when details such as filtering are changed. We generally recommend +that the clear-sky analysis be used as a check on the sensor-based results, +rather than as a stand-alone analysis. + +Soiling Results +--------------- + +Soiling can be estimated with the stochastic rate and recovery (SRR) +method (Deceglie 2018). This method works well when soiling patterns +follow a "sawtooth" pattern, a linear decline followed by a sharp +recovery associated with natural or manual cleaning. +:py:func:`.soiling.soiling_srr` performs the calculation and returns the P50 +insolation-weighted soiling ratio, confidence interval, and additional +information (``soiling_info``) which includes a summary of the soiling +intervals identified, ``soiling_info['soiling_interval_summary']``. This +summary table can, for example, be used to plot a histogram of the +identified soiling rates for the dataset. + +.. image:: _images/soiling_histogram.png + :alt: RdTools soiling results plot + :width: 320 + :height: 216 + +Install RdTools using pip +------------------------- + +RdTools can be installed automatically into Python from PyPI using the +command line: + +:: + + pip install rdtools + +Alternatively it can be installed manually using the command line: + +1. Download a `release`_ (Or to work with a development version, clone + or download the rdtools repository). +2. Navigate to the repository: ``cd rdtools`` +3. Install via pip: ``pip install .`` + +On some systems installation with ``pip`` can fail due to problems +installing requirements. If this occurs, the requirements specified in +``setup.py`` may need to be separately installed (for example by using +``conda``) before installing ``rdtools``. + +For more detailed instructions, see the :ref:`developer_notes` page. + +RdTools currently is tested on Python 3.6+. + +Usage and examples +------------------ + +Full workflow examples are found in the notebooks in `example notebook`_. +The examples are designed to work with python 3.6. For a consistent +experience, we recommend installing the packages and versions documented +in ``docs/notebook_requirements.txt``. This can be achieved in your +environment by first installing RdTools as described above, then running +``pip install -r docs/notebook_requirements.txt`` from the base +directory. + +The following functions are used for degradation and soiling analysis: + +.. code:: python + + import rdtools + +The most frequently used functions are: + +.. code:: python + + normalization.normalize_with_pvwatts(energy, pvwatts_kws) + ''' + Inputs: Pandas time series of raw energy, PVwatts dict for system analysis + (poa_global, power_dc_rated, temperature_cell, poa_global_ref, temperature_cell_ref, gamma_pdc) + Outputs: Pandas time series of normalized energy and POA insolation + ''' + +.. code:: python + + filtering.poa_filter(poa_global); filtering.tcell_filter(temperature_cell); + filtering.clip_filter(power_ac); filtering.normalized_filter(energy_normalized); + filtering.csi_filter(poa_global_measured, poa_global_clearsky); + ''' + Inputs: Pandas time series of raw data to be filtered. + Output: Boolean mask where `True` indicates acceptable data + ''' + +.. code:: python + + aggregation.aggregation_insol(energy_normalized, insolation, frequency='D') + ''' + Inputs: Normalized energy and insolation + Output: Aggregated data, weighted by the insolation. + ''' + +.. code:: python + + degradation.degradation_year_on_year(energy_normalized) + ''' + Inputs: Aggregated, normalized, filtered time series data + Outputs: Tuple: `yoy_rd`: Degradation rate + `yoy_ci`: Confidence interval `yoy_info`: associated analysis data + ''' + +.. code:: python + + soiling.soiling_srr(energy_normalized_daily, insolation_daily) + ''' + Inputs: Daily aggregated, normalized, filtered time series data for normalized performance and insolation + Outputs: Tuple: `sr`: Insolation-weighted soiling ratio + `sr_ci`: Confidence interval `soiling_info`: associated analysis data + ''' + +Citing RdTools +-------------- + +The underlying workflow of RdTools has been published in several places. +If you use RdTools in a published work, please cite the following as +appropriate: + +- D. Jordan, C. Deline, S. Kurtz, G. Kimball, M. Anderson, "Robust PV + Degradation Methodology and Application", IEEE Journal of + Photovoltaics, 8(2) pp. 525-531, 2018 + ‌‌ +- M. G. Deceglie, L. Micheli and M. Muller, "Quantifying Soiling Loss + Directly From PV Yield," in IEEE Journal of Photovoltaics, 8(2), + pp. 547-551, 2018 + ‌‌ +- RdTools, version x.x.x, https://github.com/NREL/rdtools, + https://doi.org/10.5281/zenodo.1210316 + + + Be sure to include the version number used in your analysis! + +References +---------- + +- The clear sky temperature calculation, + :py:func:`.clearsky_temperature.get_clearsky_tamb()`, uses data from images + created by Jesse Allen, NASA’s Earth Observatory using data courtesy + of the MODIS Land Group. + + + https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTD_CLIM_M + + https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTN_CLIM_M + +Other useful references which may also be consulted for degradation rate +methodology include: + +- D. C. Jordan, M. G. Deceglie, S. R. Kurtz, "PV degradation + methodology comparison — A basis for a standard", in 43rd IEEE + Photovoltaic Specialists Conference, Portland, OR, USA, 2016, DOI: + 10.1109/PVSC.2016.7749593. +- Jordan DC, Kurtz SR, VanSant KT, Newmiller J, Compendium of + Photovoltaic Degradation Rates, Progress in Photovoltaics: Research + and Application, 2016, 24(7), 978 - 989. +- D. Jordan, S. Kurtz, PV Degradation Rates – an Analytical Review, + Progress in Photovoltaics: Research and Application, 2013, 21(1), 12 + - 29. +- E. Hasselbrink, M. Anderson, Z. Defreitas, M. Mikofski, Y.-C.Shen, S. + Caldwell, A. Terao, D. Kavulak, Z. Campeau, D. DeGraaff, "Validation + of the PVLife model using 3 million module-years of live site data", + 39th IEEE Photovoltaic Specialists Conference, Tampa, FL, USA, 2013, + p. 7 – 13, DOI: 10.1109/PVSC.2013.6744087. + + + +.. include a toctree entry here so that the index page appears in the sidebar + +.. toctree:: + :hidden: + + self + +Documentation Contents +====================== + +.. toctree:: + :maxdepth: 2 + + In-Depth Examples + API Reference + Change Log + Developer Notes + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` + + +.. links and references + +.. _example notebook: https://rdtools.readthedocs.io/en/latest/example.html +.. _release: https://github.com/NREL/rdtools/releases +.. _github: https://github.com/NREL/rdtools diff --git a/rdtools/__init__.py b/rdtools/__init__.py index c8f355c2..8bc6f2d6 100644 --- a/rdtools/__init__.py +++ b/rdtools/__init__.py @@ -1,6 +1,9 @@ from rdtools.normalization import normalize_with_sapm from rdtools.normalization import normalize_with_pvwatts from rdtools.normalization import irradiance_rescale +from rdtools.normalization import energy_from_power +from rdtools.normalization import interpolate +from rdtools.normalization import normalize_with_expected_power from rdtools.degradation import degradation_ols from rdtools.degradation import degradation_classical_decomposition from rdtools.degradation import degradation_year_on_year @@ -10,6 +13,12 @@ from rdtools.filtering import poa_filter from rdtools.filtering import tcell_filter from rdtools.filtering import clip_filter +from rdtools.filtering import normalized_filter +from rdtools.soiling import soiling_srr +from rdtools.plotting import degradation_summary_plots +from rdtools.plotting import soiling_monte_carlo_plot +from rdtools.plotting import soiling_interval_plot +from rdtools.plotting import soiling_rate_histogram from ._version import get_versions __version__ = get_versions()['version'] diff --git a/rdtools/aggregation.py b/rdtools/aggregation.py index 4d3baeb2..d0c42f81 100644 --- a/rdtools/aggregation.py +++ b/rdtools/aggregation.py @@ -1,25 +1,26 @@ -''' -Aggregation Helper Functions -''' +'''Functions for calculating weighted aggregates of PV system data.''' -def aggregation_insol(normalized_energy, insolation, frequency='D'): + +def aggregation_insol(energy_normalized, insolation, frequency='D'): ''' Insolation weighted aggregation Parameters ---------- - normalized_energy: Pandas series (numeric) + energy_normalized : pd.Series Normalized energy time series - insolation: Pandas series (numeric) - Time series of insolation associated with each normalize_energy point - frequency: Pandas offset string + insolation : pd.Series + Time series of insolation associated with each `energy_normalized` + point + frequency : Pandas offset string, default 'D' Target frequency at which to aggregate Returns ------- - aggregated: Pandas Series (numeric) + aggregated : pd.Series Insolation weighted average, aggregated at frequency ''' - aggregated = (insolation * normalized_energy).resample(frequency).sum() / insolation.resample(frequency).sum() + aggregated = (insolation * energy_normalized).resample(frequency).sum() / \ + insolation.resample(frequency).sum() return aggregated diff --git a/rdtools/clearsky_temperature.py b/rdtools/clearsky_temperature.py index 9f6ac915..bbf64afa 100644 --- a/rdtools/clearsky_temperature.py +++ b/rdtools/clearsky_temperature.py @@ -1,3 +1,5 @@ +'''Functions for estimating clear-sky ambient temperature.''' + import h5py from numpy import arange from datetime import timedelta @@ -6,31 +8,42 @@ import numpy as np import warnings -def get_clearsky_tamb(times, latitude, longitude, window_size=40, gauss_std=20): + +def get_clearsky_tamb(times, latitude, longitude, window_size=40, + gauss_std=20): ''' - Description - ----------- - Estimates the ambient temperature at latitude and longitude for the given times + Estimates the ambient temperature at latitude and longitude for the given + times using a Gaussian rolling window. Parameters ---------- - times: DateTimeIndex in local time - latitude: float degrees - longitude: float degrees + times : pd.DatetimeIndex + A pandas DatetimeIndex, localized to local time + latitude : float + Coordinates in decimal degrees. + longitude : float + Coordinates in decimal degrees. + window_size : int, default 40 + The window size in days to use when calculating rolling averages. + gauss_std : int, default 20 + The standard deviation in days to use for the Gaussian rolling window. Returns ------- - pandas Series of clear sky ambient temperature + pd.Series + clear sky ambient temperature - Reference - --------- + Notes + ----- Uses data from images created by Jesse Allen, NASA's Earth Observatory using data courtesy of the MODIS Land Group. - https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTD_CLIM_M - https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTN_CLIM_M + + * https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTD_CLIM_M + * https://neo.sci.gsfc.nasa.gov/view.php?datasetId=MOD_LSTN_CLIM_M ''' - filepath = pkg_resources.resource_filename('rdtools', 'data/temperature.hdf5') + filepath = pkg_resources.resource_filename('rdtools', + 'data/temperature.hdf5') buffer = timedelta(days=window_size) @@ -38,11 +51,13 @@ def get_clearsky_tamb(times, latitude, longitude, window_size=40, gauss_std=20): freq_actual = pd.infer_freq(times) if freq_actual is None: freq_actual = pd.infer_freq(times[:10]) - warnings.warn("Input 'times' has no frequency attribute. Inferring frequency from first 10 timestamps.") + warnings.warn("Input 'times' has no frequency attribute. " + "Inferring frequency from first 10 timestamps.") else: freq_actual = times.freq - dt_daily = pd.date_range(times.date[0] - buffer, times.date[-1] + buffer, freq='D', tz=times.tz) + dt_daily = pd.date_range(times.date[0] - buffer, times.date[-1] + buffer, + freq='D', tz=times.tz) f = h5py.File(filepath, "r") @@ -82,7 +97,8 @@ def get_clearsky_tamb(times, latitude, longitude, window_size=40, gauss_std=20): df.loc[df['month'] == i + 1, 'day'] = ave_day[i] df.loc[df['month'] == i + 1, 'night'] = ave_night[i] - df = df.rolling(window=window_size, win_type='gaussian', min_periods=1, center=True).mean(std=gauss_std) + df = df.rolling(window=window_size, win_type='gaussian', min_periods=1, + center=True).mean(std=gauss_std) df = df.resample(freq_actual).interpolate(method='linear') df['month'] = df.index.month @@ -97,8 +113,11 @@ def solar_noon_offset(utc_offset): df['solar_noon_offset'] = solar_noon_offset(np.array(utc_offsets)) df['hour_of_day'] = df.index.hour + df.index.minute / 60.0 - df['Clear Sky Temperature (C)'] = _get_temperature(df['hour_of_day'].values, df['night'].values,\ - df['day'].values, df['solar_noon_offset'].values) + df['Clear Sky Temperature (C)'] = _get_temperature( + df['hour_of_day'].values, + df['night'].values, + df['day'].values, + df['solar_noon_offset'].values) return df['Clear Sky Temperature (C)'] diff --git a/rdtools/degradation.py b/rdtools/degradation.py index f1721b63..203c6c48 100644 --- a/rdtools/degradation.py +++ b/rdtools/degradation.py @@ -1,40 +1,40 @@ -''' Degradation Module +'''Functions for calculating the degradation rate of photovoltaic systems.''' -This module contains functions to calculate the degradation rate of -photovoltaic systems. -''' - -from __future__ import division import pandas as pd import numpy as np import statsmodels.api as sm -def degradation_ols(normalized_energy, confidence_level=68.2): +def degradation_ols(energy_normalized, confidence_level=68.2): ''' - Description - ----------- - OLS routine + Estimate the trend of a timeseries using ordinary least-squares regression + and calculate various statistics including a Monte Carlo-derived confidence + interval of slope. Parameters ---------- - normalized_energy: Pandas Time Series (numeric) + energy_normalized: pd.Series Daily or lower frequency time series of normalized system ouput. - confidence_level: the size of the confidence interval to return, in percent + confidence_level: float, default 68.2 + The size of the confidence interval to return, in percent. Returns ------- - (degradation rate, confidence interval, calc_info) - calc_info is a dict that contains slope, intercept, + Rd_pct : float + Estimated degradation rate in units percent/year. + Rd_CI : np.array + The calculated confidence interval bounds. + calc_info : dict + A dict that contains slope, intercept, root mean square error of regression ('rmse'), standard error of the slope ('slope_stderr'), intercept ('intercept_stderr'), and least squares RegressionResults object ('ols_results') ''' - normalized_energy.name = 'normalized_energy' - df = normalized_energy.to_frame() + energy_normalized.name = 'energy_normalized' + df = energy_normalized.to_frame() - # calculate a years column as x value for regression, ignoreing leap years + # calculate a years column as x value for regression, ignoring leap years day_diffs = (df.index - df.index[0]) df['days'] = day_diffs.astype('timedelta64[s]') / (60 * 60 * 24) df['years'] = df.days / 365.0 @@ -43,7 +43,8 @@ def degradation_ols(normalized_energy, confidence_level=68.2): df = sm.add_constant(df) # perform regression - ols_model = sm.OLS(endog=df.normalized_energy, exog=df.loc[:, ['const', 'years']], + ols_model = sm.OLS(endog=df.energy_normalized, + exog=df.loc[:, ['const', 'years']], hasconst=True, missing='drop') results = ols_model.fit() @@ -75,32 +76,38 @@ def degradation_ols(normalized_energy, confidence_level=68.2): return (Rd_pct, Rd_CI, calc_info) -def degradation_classical_decomposition(normalized_energy, confidence_level=68.2): +def degradation_classical_decomposition(energy_normalized, + confidence_level=68.2): ''' - Description - ----------- - Classical decomposition routine + Estimate the trend of a timeseries using a classical decomposition approach + (moving average) and calculate various statistics, including the result of + a Mann-Kendall test and a Monte Carlo-derived confidence interval of slope. Parameters ---------- - normalized_energy: Pandas Time Series (numeric) + energy_normalized: pd.Series Daily or lower frequency time series of normalized system ouput. Must be regular time series. - confidence_level: the size of the confidence interval to return, in percent + confidence_level: float, default 68.2 + The size of the confidence interval to return, in percent. Returns ------- - (degradation rate, confidence interval, calc_info) - calc_info is a dict that contains values for - slope, intercept, root mean square error of regression ('rmse'), - standard error of the slope ('slope_stderr') and intercept ('intercept_stderr'), - least squares RegressionResults object ('ols_results'), + Rd_pct : float + Estimated degradation rate in units percent/year. + Rd_CI : np.array + The calculated confidence interval bounds. + calc_info : dict + A dict that contains slope, intercept, + root mean square error of regression ('rmse'), standard error + of the slope ('slope_stderr'), intercept ('intercept_stderr'), + and least squares RegressionResults object ('ols_results'), pandas series for the annual rolling mean ('series'), and Mann-Kendall test trend ('mk_test_trend') ''' - normalized_energy.name = 'normalized_energy' - df = normalized_energy.to_frame() + energy_normalized.name = 'energy_normalized' + df = energy_normalized.to_frame() df_check_freq = df.copy() @@ -109,21 +116,24 @@ def degradation_classical_decomposition(normalized_energy, confidence_level=68.2 df_check_freq = df_check_freq.dropna() if df_check_freq.index.freq is None: - raise ValueError('Classical decomposition requires a regular time series with' - ' defined frequency and no missing data.') + raise ValueError('Classical decomposition requires a regular time ' + 'series with defined frequency and no missing data.') - # calculate a years column as x value for regression, ignoreing leap years + # calculate a years column as x value for regression, ignoring leap years day_diffs = (df.index - df.index[0]) df['days'] = day_diffs.astype('timedelta64[s]') / (60 * 60 * 24) df['years'] = df.days / 365.0 - # Compute yearly rolling mean to isolate trend component using moving average + # Compute yearly rolling mean to isolate trend component using + # moving average it = df.iterrows() energy_ma = [] for i, row in it: - if row.years - 0.5 >= min(df.years) and row.years + 0.5 <= max(df.years): - roll = df[(df.years <= row.years + 0.5) & (df.years >= row.years - 0.5)] - energy_ma.append(roll.normalized_energy.mean()) + if row.years - 0.5 >= min(df.years) and \ + row.years + 0.5 <= max(df.years): + roll = df[(df.years <= row.years + 0.5) & + (df.years >= row.years - 0.5)] + energy_ma.append(roll.energy_normalized.mean()) else: energy_ma.append(np.nan) @@ -170,71 +180,81 @@ def degradation_classical_decomposition(normalized_energy, confidence_level=68.2 return (Rd_pct, Rd_CI, calc_info) -def degradation_year_on_year(normalized_energy, recenter=True, exceedance_prob=95, confidence_level=68.2): +def degradation_year_on_year(energy_normalized, recenter=True, + exceedance_prob=95, confidence_level=68.2): ''' - Description - ----------- - Year-on-year decomposition method + Estimate the trend of a timeseries using the year-on-year decomposition + approach and calculate a Monte Carlo-derived confidence interval of slope. Parameters ---------- - normalized_energy: Pandas Time Series (numeric) + energy_normalized: pd.Series Daily or lower frequency time series of normalized system ouput. - recenter: bool, default value True - specify whether data is centered to normalized yield of 1 based on first year - exceedance_prob (float): the probability level to use for exceedance value calculation - confidence_level: the size of the confidence interval to return, in percent + recenter : bool, default True + Specify whether data is centered to normalized yield of 1 based on + first year. + exceedance_prob : float, default 95 + The probability level to use for exceedance value calculation, + in percent. + confidence_level : float, default 68.2 + The size of the confidence interval to return, in percent. Returns ------- - tuple of (degradation_rate, confidence_interval, calc_info) - degradation_rate: float - rate of relative performance change in %/yr - confidence_interval: numpy ndarray - confidence interval (size specified by confidence_level) of degradation - rate estimate - calc_info: dict - ('YoY_values') pandas series of right-labeled year on year slopes - ('renormalizing_factor') float of value used to recenter data - ('exceedance_level') the degradation rate that was outperformed with - probability of exceedance_prob + degradation_rate : float + rate of relative performance change in %/yr + confidence_interval : np.array + confidence interval (size specified by `confidence_level`) of + degradation rate estimate + calc_info : dict + + * `YoY_values` - pandas series of right-labeled year on year slopes + * `renormalizing_factor` - float of value used to recenter data + * `exceedance_level` - the degradation rate that was outperformed with + probability of `exceedance_prob` ''' # Ensure the data is in order - normalized_energy = normalized_energy.sort_index() - normalized_energy.name = 'energy' - normalized_energy.index.name = 'dt' + energy_normalized = energy_normalized.sort_index() + energy_normalized.name = 'energy' + energy_normalized.index.name = 'dt' # Detect sub-daily data: - if min(np.diff(normalized_energy.index.values, n=1)) < np.timedelta64(23, 'h'): - raise ValueError('normalized_energy must not be more frequent than daily') + if min(np.diff(energy_normalized.index.values, n=1)) < \ + np.timedelta64(23, 'h'): + raise ValueError('energy_normalized must not be ' + 'more frequent than daily') # Detect less than 2 years of data - if normalized_energy.index[-1] - normalized_energy.index[0] < pd.Timedelta('730d'): - raise ValueError('must provide at least two years of normalized energy') + if energy_normalized.index[-1] - energy_normalized.index[0] < \ + pd.Timedelta('730d'): + raise ValueError('must provide at least two years of ' + 'normalized energy') # Auto center if recenter: - start = normalized_energy.index[0] + start = energy_normalized.index[0] oneyear = start + pd.Timedelta('364d') - renorm = normalized_energy[start:oneyear].median() + renorm = energy_normalized[start:oneyear].median() else: renorm = 1.0 - normalized_energy = normalized_energy.reset_index() - normalized_energy['energy'] = normalized_energy['energy'] / renorm + energy_normalized = energy_normalized.reset_index() + energy_normalized['energy'] = energy_normalized['energy'] / renorm - normalized_energy['dt_shifted'] = normalized_energy.dt + pd.DateOffset(years=1) + energy_normalized['dt_shifted'] = energy_normalized.dt + \ + pd.DateOffset(years=1) - # Merge with what happened one year ago, use tolerance of 8 days to allow for - # weekly aggregated data - df = pd.merge_asof(normalized_energy[['dt', 'energy']], normalized_energy, + # Merge with what happened one year ago, use tolerance of 8 days to allow + # for weekly aggregated data + df = pd.merge_asof(energy_normalized[['dt', 'energy']], energy_normalized, left_on='dt', right_on='dt_shifted', suffixes=['', '_right'], tolerance=pd.Timedelta('8D') ) - df['time_diff_years'] = (df.dt - df.dt_right).astype('timedelta64[h]') / 8760.0 + df['time_diff_years'] = (df.dt - df.dt_right).astype('timedelta64[h]') / \ + 8760.0 df['yoy'] = 100.0 * (df.energy - df.energy_right) / (df.time_diff_years) df.index = df.dt @@ -268,21 +288,26 @@ def degradation_year_on_year(normalized_energy, recenter=True, exceedance_prob=9 def _mk_test(x, alpha=0.05): ''' - Description - ----------- - Mann-Kendall test of significance for trend (used in classical decomposition function) + Mann-Kendall test of significance for trend (used in classical + decomposition function) Parameters ---------- - x: a vector of data type float - alpha: float, significance level (0.05 default) + x : numeric + A data vector to test for trend. + alpha: float, default 0.05 + The test significance level. Returns ------- - trend: string, tells the trend (increasing, decreasing or no trend) - h: boolean, True (if trend is present) or False (if trend is absence) - p: float, p value of the significance test - z: float, normalized test statistics + trend : str + Tells the trend ('increasing', 'decreasing', or 'no trend') + h : bool + True (if trend is present) or False (if trend is absent) + p : float + p value of the significance test + z : float + normalized test statistic ''' from scipy.stats import norm @@ -314,7 +339,7 @@ def _mk_test(x, alpha=0.05): if s > 0: z = (s - 1) / np.sqrt(var_s) elif s == 0: - z = 0 + z = 0 elif s < 0: z = (s + 1) / np.sqrt(var_s) @@ -334,14 +359,13 @@ def _mk_test(x, alpha=0.05): def _degradation_CI(results, confidence_level): ''' - Description - ----------- Monte Carlo estimation of uncertainty in degradation rate from OLS results Parameters ---------- results: OLSResults object from fitting a model of the form: - results = sm.OLS(endog = df.energy_ma, exog = df.loc[:,['const','years']]).fit() + results = sm.OLS(endog = df.energy_ma, + exog = df.loc[:,['const','years']]).fit() confidence_level: the size of the confidence interval to return, in percent Returns @@ -350,7 +374,9 @@ def _degradation_CI(results, confidence_level): ''' - sampled_normal = np.random.multivariate_normal(results.params, results.cov_params(), 10000) + sampled_normal = np.random.multivariate_normal(results.params, + results.cov_params(), + 10000) dist = sampled_normal[:, 1] / sampled_normal[:, 0] half_ci = confidence_level / 2.0 Rd_CI = np.percentile(dist, [50.0 - half_ci, 50.0 + half_ci]) * 100.0 diff --git a/rdtools/filtering.py b/rdtools/filtering.py index 09949ce2..5a248f93 100644 --- a/rdtools/filtering.py +++ b/rdtools/filtering.py @@ -1,58 +1,126 @@ -import pandas as pd +'''Functions for filtering and subsetting PV system data.''' +import numpy as np -def poa_filter(poa, low_irradiance_cutoff=200, high_irradiance_cutoff=1200): - # simple filter based on irradiance sensors - return (poa > low_irradiance_cutoff) & (poa < high_irradiance_cutoff) +def normalized_filter(energy_normalized, energy_normalized_low=0.01, + energy_normalized_high=None): + ''' + Select normalized yield between ``low_cutoff`` and ``high_cutoff`` + + Parameters + ---------- + energy_normalized : pd.Series + Normalized energy measurements. + energy_normalized_low : float, default 0.01 + The lower bound of acceptable values. + energy_normalized_high : float, optional + The upper bound of acceptable values. + + Returns + ------- + pd.Series + Boolean Series of whether the given measurement is within acceptable + bounds. + ''' -def tcell_filter(tcell, low_tcell_cutoff=-50, high_tcell_cutoff=110): - # simple filter based on temperature sensors - return (tcell > low_tcell_cutoff) & (tcell < high_tcell_cutoff) + if energy_normalized_low is None: + energy_normalized_low = -np.inf + if energy_normalized_high is None: + energy_normalized_high = np.inf + + return ((energy_normalized > energy_normalized_low) & + (energy_normalized < energy_normalized_high)) + + +def poa_filter(poa_global, poa_global_low=200, poa_global_high=1200): + ''' + Filter POA irradiance readings outside acceptable measurement bounds. + + Parameters + ---------- + poa_global : pd.Series + POA irradiance measurements. + poa_global_low : float, default 200 + The lower bound of acceptable values. + poa_global_high : float, default 1200 + The upper bound of acceptable values. + + Returns + ------- + pd.Series + Boolean Series of whether the given measurement is within acceptable + bounds. + ''' + return (poa_global > poa_global_low) & (poa_global < poa_global_high) + + +def tcell_filter(temperature_cell, temperature_cell_low=-50, + temperature_cell_high=110): + ''' + Filter temperature readings outside acceptable measurement bounds. + + Parameters + ---------- + temperature_cell : pd.Series + Cell temperature measurements. + temperature_cell_low : float, default -50 + The lower bound of acceptable values. + temperature_cell_high : float, default 110 + The upper bound of acceptable values. + + Returns + ------- + pd.Series + Boolean Series of whether the given measurement is within acceptable + bounds. + ''' + return ((temperature_cell > temperature_cell_low) & + (temperature_cell < temperature_cell_high)) -def clip_filter(power, quant=0.98, low_power_cutoff=0.01): +def clip_filter(power_ac, quantile=0.98): ''' Filter data points likely to be affected by clipping - with power greater than or equal to 99% of the 'quant' - quantile and less than 'low_power_cutoff' + with power greater than or equal to 99% of the `quant` + quantile. Parameters ---------- - power: Pandas series (numeric) - AC power - quant: float - threshold for quantile - low_power_cutoff + power_ac : pd.Series + AC power in Watts + quantile : float, default 0.98 + Value for upper threshold quantile Returns ------- - Pandas Series (boolean) - mask to exclude points equal to and - above 99% of the percentile threshold + pd.Series + Boolean Series of whether the given measurement is below 99% of the + quantile filter. ''' - v = power.quantile(quant) - return (power < v * 0.99) & (power > low_power_cutoff) + v = power_ac.quantile(quantile) + return (power_ac < v * 0.99) -def csi_filter(measured_poa, clearsky_poa, threshold=0.15): +def csi_filter(poa_global_measured, poa_global_clearsky, threshold=0.15): ''' - Filtering based on clear sky index (csi) + Filtering based on clear-sky index (csi) Parameters ---------- - measured_poa: Pandas series (numeric) + poa_global_measured : pd.Series Plane of array irradiance based on measurments - clearsky_poa: Pandas series (numeric) + poa_global_clearsky : pd.Series Plane of array irradiance based on a clear sky model - threshold: float + threshold : float, default 0.15 threshold for filter Returns ------- - Pandas Series (boolean) - mask to exclude points below the threshold + pd.Series + Boolean Series of whether the clear-sky index is within the threshold + around 1. ''' - csi = measured_poa / clearsky_poa + csi = poa_global_measured / poa_global_clearsky return (csi >= 1.0 - threshold) & (csi <= 1.0 + threshold) diff --git a/rdtools/normalization.py b/rdtools/normalization.py index a96295e9..3ad1f593 100644 --- a/rdtools/normalization.py +++ b/rdtools/normalization.py @@ -1,8 +1,4 @@ -''' Energy Normalization Module - -This module contains functions to help normalize AC energy output with measured -poa_global in preparation for calculating PV system degradation. -''' +'''Functions for normalizing, rescaling, and regularizing PV system data.''' import pandas as pd import pvlib @@ -12,50 +8,112 @@ class ConvergenceError(Exception): + '''Rescale optimization did not converge''' pass +def normalize_with_expected_power(pv, power_expected, poa_global, + pv_input='power'): + ''' + Normalize pv output based on expected PV power. + + Parameters + ---------- + pv : pd.Series + Right-labeled time series PV energy or power. If energy, should *not* + be cumulative, but only for preceding time step. + power_expected : pd.Series + Right-labeled time series of expected PV power. + poa_global : pd.Series + Right-labeled time series of plane-of-array irradiance associated with + `expected_power` + pv_input : str + 'power' or 'energy' to specify type of input used for pv parameter + + Returns + ------- + energy_normalized : pd.Series + Energy normalized based on `expected_power` + insolation : pd.Series + Insolation associated with each normalized point + + ''' + + freq = check_series_frequency(pv, 'pv') + + if pv_input == 'power': + energy = energy_from_power(pv, freq) + elif pv_input == 'energy': + energy = pv.copy() + energy.name = 'energy_Wh' + else: + raise ValueError("Unexpected value for pv_input. pv_input should be 'power' or 'energy'.") + + model_tds, mean_model_td = delta_index(power_expected) + measure_tds, mean_measure_td = delta_index(energy) + + # Case in which the model less frequent than the measurements + if mean_model_td > mean_measure_td: + power_expected = interpolate(power_expected, pv.index) + poa_global = interpolate(poa_global, pv.index) + + energy_expected = energy_from_power(power_expected, freq) + insolation = energy_from_power(poa_global, freq) + + energy_normalized = energy / energy_expected + + index_union = energy_normalized.index.union(insolation.index) + energy_normalized = energy_normalized.reindex(index_union) + insolation = insolation.reindex(index_union) -def pvwatts_dc_power(poa_global, P_ref, T_cell=None, G_ref=1000, T_ref=25, gamma_pdc=None): + return energy_normalized, insolation + + +def pvwatts_dc_power(poa_global, power_dc_rated, temperature_cell=None, + poa_global_ref=1000, temperature_cell_ref=25, + gamma_pdc=None): ''' PVWatts v5 Module Model: DC power given effective poa poa_global, module nameplate power, and cell temperature. This function differs from the PVLIB implementation by allowing cell temperature to be an optional parameter. - Note: If T_cell or gamma_pdc are omitted, the temperature term will be - ignored. - Parameters ---------- - poa_global: Pandas Series (numeric) + poa_global : pd.Series Total effective plane of array irradiance. - P_ref: numeric + power_dc_rated : float Rated DC power of array in watts - T_cell: Pandas Series (numeric) - Measured or derived cell temperature [degrees celsius]. - Time series assumed to be same frequency as poa_global. - G_ref: numeric, default value is 1000 + temperature_cell : pd.Series, optional + Measured or derived cell temperature [degrees Celsius]. + Time series assumed to be same frequency as `poa_global`. + If omitted, the temperature term will be ignored. + poa_global_ref : float, default 1000 Reference irradiance at standard test condition [W/m**2]. - T_ref: numeric, default value is 25 - Reference temperature at standard test condition [degrees celsius]. - gamma_pdc: numeric, default is None - Linear array efficiency temperature coefficient [1 / degree celsius]. + temperature_cell_ref : float, default 25 + Reference temperature at standard test condition [degrees Celsius]. + gamma_pdc : float, default None + Linear array efficiency temperature coefficient [1 / degree Celsius]. + If omitted, the temperature term will be ignored. - Note: All series are assumed to be right-labeled, meaning that the recorded value - at a given timestamp refers ot the previous time interval + Note + ---- + All series are assumed to be right-labeled, meaning that the recorded + value at a given timestamp refers to the previous time interval Returns ------- - dc_power: Pandas Series (numeric) + power_dc : pd.Series DC power in watts determined by PVWatts v5 equation. ''' - dc_power = P_ref * poa_global / G_ref + power_dc = power_dc_rated * poa_global / poa_global_ref - if T_cell is not None and gamma_pdc is not None: - temperature_factor = 1 + gamma_pdc * (T_cell - T_ref) - dc_power = dc_power * temperature_factor + if temperature_cell is not None and gamma_pdc is not None: + temperature_factor = ( + 1 + gamma_pdc * (temperature_cell - temperature_cell_ref) + ) + power_dc = power_dc * temperature_factor - return dc_power + return power_dc def normalize_with_pvwatts(energy, pvwatts_kws): @@ -67,71 +125,50 @@ def normalize_with_pvwatts(energy, pvwatts_kws): Parameters ---------- - energy: Pandas Series (numeric) + energy : pd.Series Energy time series to be normalized in watt hours. Must be a right-labeled regular time series. - pvwatts_kws: dictionary - Dictionary of parameters used in the pvwatts_dc_power function. - - PVWatts Parameters - ------------------ - poa_global: Pandas Series (numeric) - Total effective plane of array irradiance. - P_ref: numeric - Rated DC power of array in watts. - T_cell: Pandas Series (numeric) - Measured or derived cell temperature [degrees celsius]. - Time series assumed to be same frequency as poa_global. - G_ref: numeric, default value is 1000 - Reference irradiance at standard test condition [W/m**2]. - T_ref: numeric, default value is 25 - Reference temperature at standard test condition [degrees celsius]. - gamma_pdc: numeric, default is None - Linear array efficiency temperature coefficient [1 / degree celsius]. - Note: All series are assumed to be right-labeled, meaning that the recorded value - at a given timestamp refers ot the previous time interval + pvwatts_kws : dict + Dictionary of parameters used in the pvwatts_dc_power function. See + `Other Parameters`. + + Other Parameters + ------------------ + poa_global : pd.Series + Total effective plane of array irradiance. + power_dc_rated : float + Rated DC power of array in watts + temperature_cell : pd.Series, optional + Measured or derived cell temperature [degrees Celsius]. + Time series assumed to be same frequency as `poa_global`. + If omitted, the temperature term will be ignored. + poa_global_ref : float, default 1000 + Reference irradiance at standard test condition [W/m**2]. + temperature_cell_ref : float, default 25 + Reference temperature at standard test condition [degrees Celsius]. + gamma_pdc : float, default None + Linear array efficiency temperature coefficient [1 / degree Celsius]. + If omitted, the temperature term will be ignored. + + Note + ---- + All series are assumed to be right-labeled, meaning that the recorded + value at a given timestamp refers to the previous time interval Returns ------- - tulple (normalized_energy, insolation) - normalized_energy: Pandas Series (numeric) - Energy divided by PVWatts DC energy. - insolation: Pandas Series (numeric) - Insolation associated with each normalized point + energy_normalized : pd.Series + Energy divided by PVWatts DC energy. + insolation : pd.Series + Insolation associated with each normalized point ''' - freq = check_series_frequency(energy, 'energy') - - dc_power = pvwatts_dc_power(**pvwatts_kws) + power_dc = pvwatts_dc_power(**pvwatts_kws) irrad = pvwatts_kws['poa_global'] - model_tds, mean_model_td = delta_index(dc_power) - irrad_tds, mean_irrad_td = delta_index(irrad) - measure_tds, mean_measure_td = delta_index(energy) + energy_normalized, insolation = normalize_with_expected_power(energy, power_dc, irrad, pv_input='energy') - if mean_model_td <= mean_measure_td: - energy_dc = dc_power * model_tds - energy_dc = energy_dc.resample(freq).sum() - energy_dc = energy_dc.reindex(energy.index, method='nearest') - - insolation = irrad * irrad_tds - insolation = insolation.resample(freq).sum() - insolation = insolation.reindex(energy.index, method='nearest') - - elif mean_model_td > mean_measure_td: - dc_power = dc_power.resample(freq).asfreq() - dc_power = dc_power.interpolate() - dc_power = dc_power.reindex(energy.index, method='nearest') - energy_dc = dc_power * measure_tds # timedelta is that of measurment due to reindex - - irrad = irrad.resample(freq).asfreq() - irrad = irrad.interpolate() - irrad = irrad.reindex(energy.index, method='nearest') - insolation = irrad * measure_tds # timedelta is that of measurment due to reindex - - normalized_energy = energy / energy_dc - - return normalized_energy, insolation + return energy_normalized, insolation def sapm_dc_power(pvlib_pvsystem, met_data): @@ -143,23 +180,28 @@ def sapm_dc_power(pvlib_pvsystem, met_data): Parameters ---------- - pvlib_pvsystem: pvlib-python LocalizedPVSystem object + pvlib_pvsystem : pvlib-python LocalizedPVSystem object Object contains orientation, geographic coordinates, equipment - constants (including DC rated power in watts). - met_data: Pandas DataFrame (numeric) + constants (including DC rated power in watts). The object must also + specify either the `temperature_model_parameters` attribute or both + `racking_model` and `module_type` attributes to infer the temperature model parameters. + met_data : pd.DataFrame Measured irradiance components, ambient temperature, and wind speed. Expected met_data DataFrame column names: - ['DNI', 'GHI', 'DHI', 'Temperature', 'Wind Speed'] - Note: All series are assumed to be right-labeled, meaning that the recorded value - at a given timestamp refers ot the previous time interval + ['DNI', 'GHI', 'DHI', 'Temperature', 'Wind Speed'] + + Note + ---- + All series are assumed to be right-labeled, meaning that the recorded + value at a given timestamp refers to the previous time interval Returns ------- - tulple (dc_power, effective_poa) - dc_power: Pandas Series (numeric) - DC power in watts derived using Sandia Array Performance Model and PVWatts. - effective_poa: Pandas Series (numeric) - Effective irradiance calculated with SAPM + power_dc : pd.Series + DC power in watts derived using Sandia Array Performance Model and + PVWatts. + effective_poa : pd.Series + Effective irradiance calculated with SAPM ''' solar_position = pvlib_pvsystem.get_solarposition(met_data.index) @@ -178,24 +220,23 @@ def sapm_dc_power(pvlib_pvsystem, met_data): .get_airmass(solar_position=solar_position, model='kastenyoung1989') airmass_absolute = airmass['airmass_absolute'] - effective_poa = pvlib.pvsystem\ + effective_irradiance = pvlib.pvsystem\ .sapm_effective_irradiance(poa_direct=total_irradiance['poa_direct'], poa_diffuse=total_irradiance['poa_diffuse'], airmass_absolute=airmass_absolute, aoi=aoi, - module=pvlib_pvsystem.module, - reference_irradiance=1) + module=pvlib_pvsystem.module) temp_cell = pvlib_pvsystem\ - .sapm_celltemp(irrad=total_irradiance['poa_global'], - wind=met_data['Wind Speed'], - temp=met_data['Temperature']) + .sapm_celltemp(total_irradiance['poa_global'], + met_data['Temperature'], + met_data['Wind Speed']) - dc_power = pvlib_pvsystem\ - .pvwatts_dc(g_poa_effective=effective_poa, - temp_cell=temp_cell['temp_cell']) + power_dc = pvlib_pvsystem\ + .pvwatts_dc(g_poa_effective=effective_irradiance, + temp_cell=temp_cell) - return dc_power, effective_poa + return power_dc, effective_irradiance def normalize_with_sapm(energy, sapm_kws): @@ -209,123 +250,127 @@ def normalize_with_sapm(energy, sapm_kws): Parameters ---------- - energy: Pandas Series (numeric) + energy : pd.Series Energy time series to be normalized in watt hours. Must be a right-labeled regular time series. - sapm_kws: dictionary - Dictionary of parameters required for sapm_dc_power function. - - SAPM Parameters - --------------- - pvlib_pvsystem: pvlib-python LocalizedPVSystem object - Object contains orientation, geographic coordinates, equipment - constants. - met_data: Pandas DataFrame (numeric) - Measured met_data, ambient temperature, and wind speed. - Note: All series are assumed to be right-labeled, meaning that the recorded value - at a given timestamp refers ot the previous time interval + sapm_kws : dict + Dictionary of parameters required for sapm_dc_power function. See + `Other Parameters`. + + Other Parameters + --------------- + pvlib_pvsystem : pvlib-python LocalizedPVSystem object + Object contains orientation, geographic coordinates, equipment + constants (including DC rated power in watts). The object must also + specify either the `temperature_model_parameters` attribute or both + `racking_model` and `module_type` to infer the model parameters. + met_data : pd.DataFrame + Measured met_data, ambient temperature, and wind speed. Expected + column names are ['DNI', 'GHI', 'DHI', 'Temperature', 'Wind Speed'] + + Note + ---- + All series are assumed to be right-labeled, meaning that the recorded + value at a given timestamp refers to the previous time interval + Returns ------- - tulple (normalized_energy, insolation) - normalized_energy: Pandas Series (numeric) - Energy divided by Sandia Model DC energy. - insolation: Pandas Series (numeric) - Insolation associated with each normalized point + energy_normalized : pd.Series + Energy divided by Sandia Model DC energy. + insolation : pd.Series + Insolation associated with each normalized point ''' - freq = check_series_frequency(energy, 'energy') + power_dc, irrad = sapm_dc_power(**sapm_kws) - dc_power, irrad = sapm_dc_power(**sapm_kws) + energy_normalized, insolation = normalize_with_expected_power(energy, power_dc, irrad, pv_input='energy') - model_tds, mean_model_td = delta_index(dc_power) - irrad_tds, mean_irrad_td = delta_index(irrad) - measure_tds, mean_measure_td = delta_index(energy) - - if mean_model_td <= mean_measure_td: - energy_dc = dc_power * model_tds - energy_dc = energy_dc.resample(freq).sum() - energy_dc = energy_dc.reindex(energy.index, method='nearest') - - insolation = irrad * irrad_tds - insolation = insolation.resample(freq).sum() - insolation = insolation.reindex(energy.index, method='nearest') - - elif mean_model_td > mean_measure_td: - dc_power = dc_power.resample(freq).asfreq() - dc_power = dc_power.interpolate() - dc_power = dc_power.reindex(energy.index, method='nearest') - energy_dc = dc_power * measure_tds # timedelta is that of measurment due to reindex - - irrad = irrad.resample(freq).asfreq() - irrad = irrad.interpolate() - irrad = irrad.reindex(energy.index, method='nearest') - insolation = irrad * measure_tds # timedelta is that of measurment due to reindex - - normalized_energy = energy / energy_dc - - return normalized_energy, insolation + return energy_normalized, insolation def delta_index(series): ''' - Takes a panda series with a DatetimeIndex as input and + Takes a pandas series with a DatetimeIndex as input and returns (time step sizes, average time step size) in hours + + Parameters + ---------- + series : pd.Series + A pandas timeseries + + Returns + ------- + deltas : pd.Series + A timeseries representing the timestep sizes of `series` + mean : float + The average timestep ''' if series.index.freq is None: - # If there is no frequency information, explicily calculate interval sizes - # Length of each interval calculated by using 'int64' to convert to nanoseconds + # If there is no frequency information, explicitly calculate interval + # sizes. Length of each interval calculated by using 'int64' to convert + # to nanoseconds. hours = pd.Series(series.index.astype('int64') / (10.0**9 * 3600.0)) hours.index = series.index deltas = hours.diff() else: - # If there is frequency information, pandas shift can be used to gain a meaningful - # interful for the first element of the timeseries - # Length of each interval calculated by using 'int64' to convert to nanoseconds - deltas = (series.index - series.index.shift(-1)).astype('int64') / (10.0**9 * 3600.0) + # If there is frequency information, pandas shift can be used to gain + # a meaningful interval for the first element of the timeseries + # Length of each interval calculated by using 'int64' to convert to + # nanoseconds. + deltas = (series.index - series.index.shift(-1)).astype('int64') / \ + (10.0**9 * 3600.0) return deltas, np.mean(deltas.dropna()) -def irradiance_rescale(irrad, modeled_irrad, max_iterations=100, method=None): +def irradiance_rescale(irrad, irrad_sim, max_iterations=100, + method='iterative', convergence_threshold=1e-6): ''' - Attempts to rescale modeled irradiance to match measured irradiance on clear days + Attempt to rescale modeled irradiance to match measured irradiance on + clear days. + Parameters ---------- - irrad: Pandas Series (numeric) + irrad : pd.Series measured irradiance time series - modeled_irrad: Pandas Series (numeric) - modeled irradiance time series - max_iterations: (int) - The maximum number of times to attempt rescale optimization, default 100. - Ignored if method = 'single_opt' - method: (str) - The caclulation method to use. 'single_opt' implements the irradiance_rescale of - rdtools v1.1.3 and earlier. 'iterative' implements a more stable calculation - that may yield different results from the single_opt method. Default None issues - a warning then uses the iterative calculation. + irrad_sim : pd.Series + modeled/simulated irradiance time series + max_iterations : int, default 100 + The maximum number of times to attempt rescale optimization. + Ignored if `method` = 'single_opt' + method : str, default 'iterative' + The calculation method to use. 'single_opt' implements the + irradiance_rescale of rdtools v1.1.3 and earlier. 'iterative' + implements a more stable calculation that may yield different results + from the single_opt method. + convergence_threshold : float, default 1e-6 + The acceptable iteration-to-iteration scaling factor difference to + determine convergence. If the threshold is not reached after + `max_iterations`, raise + :py:exc:`rdtools.normalization.ConvergenceError`. + Must be greater than zero. Only used if `method=='iterative'`. Returns ------- - Pandas Series (numeric): resacaled modeled irradaince time series + pd.Series + Rescaled modeled irradiance time series ''' - if method is None: - warnings.warn("The underlying calculations for irradiance_rescale have changed " - "which may affect results. To revert to the version of irradiance_rescale " - "from rdtools v1.1.3 or earlier, use method = 'single_opt'. ") - method = 'iterative' - if method == 'iterative': def _rmse(fact): - "Calculates RMSE with a given rescale fact(or) according to global filt(er)" - rescaled_modeled_irrad = fact * modeled_irrad - rmse = np.sqrt(((rescaled_modeled_irrad[filt] - irrad[filt]) ** 2.0).mean()) + """ + Calculates RMSE with a given rescale fact(or) according to global + filt(er) + """ + rescaled_irrad_sim = fact * irrad_sim + difference = rescaled_irrad_sim[filt] - irrad[filt] + rmse = np.sqrt((difference**2.0).mean()) return rmse - def _single_rescale(irrad, modeled_irrad, guess): + def _single_rescale(irrad, irrad_sim, guess): "Optimizes rescale factor once" global filt - csi = irrad / (guess * modeled_irrad) # clear sky index + csi = irrad / (guess * irrad_sim) # clear sky index filt = (csi >= 0.8) & (csi <= 1.2) & (irrad > 200) min_result = minimize(_rmse, guess, method='Nelder-Mead') @@ -333,35 +378,38 @@ def _single_rescale(irrad, modeled_irrad, guess): return factor # Calculate an initial guess for the rescale factor - factor = np.percentile(irrad.dropna(), 90) / np.percentile(modeled_irrad.dropna(), 90) - - # Iteratively run the optimization, recalculating the clear sky filter each time - convergence_threshold = 10**-6 - for i in range(max_iterations): + factor = (np.percentile(irrad.dropna(), 90) / + np.percentile(irrad_sim.dropna(), 90)) + prev_factor = 1.0 + + # Iteratively run the optimization, + # recalculating the clear sky filter each time + iteration = 0 + while abs(factor - prev_factor) > convergence_threshold: + iteration += 1 + if iteration > max_iterations: + msg = 'Rescale did not converge within max_iterations' + raise ConvergenceError(msg) prev_factor = factor - factor = _single_rescale(irrad, modeled_irrad, factor) - delta = abs(factor - prev_factor) - if delta < convergence_threshold: - break + factor = _single_rescale(irrad, irrad_sim, factor) - if delta >= convergence_threshold: - raise ConvergenceError('Rescale did not converge within max_iterations') - else: - return factor * modeled_irrad + return factor * irrad_sim elif method == 'single_opt': def _rmse(fact): - rescaled_modeled_irrad = fact * modeled_irrad - csi = irrad / rescaled_modeled_irrad + rescaled_irrad_sim = fact * irrad_sim + csi = irrad / rescaled_irrad_sim filt = (csi >= 0.8) & (csi <= 1.2) - rmse = np.sqrt(((rescaled_modeled_irrad[filt] - irrad[filt]) ** 2.0).mean()) + difference = rescaled_irrad_sim[filt] - irrad[filt] + rmse = np.sqrt((difference**2.0).mean()) return rmse - guess = np.percentile(irrad.dropna(), 90) / np.percentile(modeled_irrad.dropna(), 90) + guess = np.percentile(irrad.dropna(), 90) / \ + np.percentile(irrad_sim.dropna(), 90) min_result = minimize(_rmse, guess, method='Nelder-Mead') factor = min_result['x'][0] - out_irrad = factor * modeled_irrad + out_irrad = factor * irrad_sim return out_irrad else: @@ -369,15 +417,340 @@ def _rmse(fact): def check_series_frequency(series, series_description): - '''Returns the inferred frequency of a pandas series, raises ValueError - using series_description if it can't. series_description should be a string''' + ''' + Returns the inferred frequency of a pandas series, raises ValueError + using `series_description` if it can't. + + Parameters + ---------- + series : pd.Series + The timeseries to infer the frequency of. + series_description : str + The description to use when raising an error. + + Returns + ------- + freq : pandas Offsets string + The inferred index frequency + ''' if series.index.freq is None: freq = pd.infer_freq(series.index) if freq is None: - error_string = ('Could not infer frequency of ' + series_description + + error_string = ('Could not infer frequency of ' + + series_description + ', which must be a regular time series') raise ValueError(error_string) else: freq = series.index.freq return freq + + +def t_step_nanoseconds(time_series): + ''' + return a series of right labeled differences in the index of time_series + in nanoseconds + ''' + t_steps = np.diff(time_series.index.astype('int64')).astype('float') + t_steps = np.insert(t_steps, 0, np.nan) + t_steps = pd.Series(index=time_series.index, data=t_steps) + return t_steps + + +def energy_from_power(power, target_frequency=None, max_timedelta=None): + ''' + Returns a regular right-labeled energy time series in units of Wh per + interval from an instantaneous power time series. NaN is filled where the + gap between input data points exceeds `max_timedelta`. Power_series should + be given in Watts. + + Parameters + ---------- + power : pd.Series + Instantaneous time series of power in Watts + target_frequency : DatetimeOffset or frequency string, default None + The frequency of the energy time series to be returned. + If omitted, use the median timestep of `power` + max_timedelta : pd.Timedelta, default None + The maximum allowed gap between power measurements. If the gap between + consecutive power measurements exceeds `max_timedelta`, NaN will be + returned for that interval. If omitted, `max_timedelta` is set + internally to the median time delta in `power`. + + Returns + ------- + pd.Series + right-labeled energy in Wh per interval + ''' + + if not isinstance(power.index, pd.DatetimeIndex): + raise ValueError('power must be a pandas series with a ' + 'DatetimeIndex') + + t_steps = t_step_nanoseconds(power) + median_step_ns = t_steps.median() + + if target_frequency is None: + # 'N' is the Pandas offset alias for ns + target_frequency = str(int(median_step_ns)) + 'N' + + if max_timedelta is None: + max_interval_nanoseconds = median_step_ns + else: + max_interval_nanoseconds = max_timedelta.total_seconds() * 10.0**9 + + try: + freq_interval_size_ns = \ + pd.tseries.frequencies.to_offset(target_frequency).nanos + except ValueError as e: + if 'is a non-fixed frequency' in str(e): + temp_ind = pd.date_range(power.index[0], + power.index[-1], + freq=target_frequency) + temp_series = pd.Series(data=1, index=temp_ind) + temp_diffs = t_step_nanoseconds(temp_series) + freq_interval_size_ns = temp_diffs.median() + else: + raise + + # Upsampling case + if freq_interval_size_ns <= median_step_ns: + resampled = interpolate(power, target_frequency, max_timedelta) + + moving_average = (resampled + resampled.shift()) / 2.0 + + energy = moving_average * t_step_nanoseconds(moving_average) \ + / 10.0**9 / 3600.0 + + # Drop first row with work around for pandas issue #18031 + if energy.index.tz is None: + energy = energy.drop(energy.index[0]) + else: + tz = str(energy.index.tz) + energy.index = energy.index.tz_convert('UTC') + energy = energy.drop(energy.index[0]) + energy.index = energy.index.tz_convert(tz) + + # Downsampling case + elif freq_interval_size_ns > median_step_ns: + energy = trapz_aggregate(power, target_frequency, max_timedelta) + + # Set the frequency if we can + try: + energy.index.freq = pd.infer_freq(energy.index) + except ValueError: + pass + + # enforce max_timedelta + t_steps = t_steps.reindex(energy.index, method='backfill') + energy.loc[t_steps > max_interval_nanoseconds] = np.nan + + energy.name = 'energy_Wh' + + return energy + + +def trapz_aggregate(time_series, target_frequency, max_timedelta=None): + ''' + Returns a right-labeled series with frequency target_frequency generated by + aggregating `time_series` with the trapezoidal rule (in units of hours). + If any interval in `time_series` is greater than `max_timedelta`, it is + ommitted from the sum. + + Parameters + ---------- + time_series : pd.Series + target_frequency : DatetimeOffset, or frequency string + The frequency of the accumulated series to be returned. + max_timedelta : pd.Timedelta, default None + The maximum allowed gap between power measurements. If the gap between + consecutive power measurements exceeds `max_timedelta`, no energy value + will be returned for that interval. If omitted, `max_timedelta` is set + internally to the median time delta in `time_series`. + + Returns + ------- + pd.Series + right-labeled energy in Wh per interval + ''' + + values = time_series.values + timestamps = time_series.index.astype('int64').values + + t_diffs = np.diff(timestamps) + + if max_timedelta is None: + max_interval_nanoseconds = np.median(t_diffs) + else: + max_interval_nanoseconds = max_timedelta.total_seconds() * 10.0**9 + + # in x*hours + trap_sum = (values[1:] + values[:-1]) / 2 * t_diffs / 10**9 / 3600.0 + + trap_sum[t_diffs > max_interval_nanoseconds] = np.nan + + trap_sum = pd.Series(data=trap_sum, index=time_series.index[1:]) + + aggregated = trap_sum.resample(target_frequency, + closed='right', + label='right').sum(min_count=1) + + return aggregated + + +def interpolate_series(time_series, target_index, max_timedelta=None, + warning_threshold=0.1): + ''' + Returns an interpolation of time_series onto target_index, NaN is returned + for times associated with gaps in time_series longer `than max_timedelta`. + + Parameters + ---------- + time_series : pd.Series + Original values to be used in generating the interpolation + target_index : pd.DatetimeIndex + the index onto which the interpolation is to be made + max_timedelta : pd.Timedelta, default None + The maximum allowed gap between values in time_series. Times associated + with gaps longer than `max_timedelta` are excluded from the output. If + omitted, `max_timedelta` is set internally to two times the median + time delta in `time_series.` + warning_threshold : float, default 0.1 + The fraction of data exclusion above which a warning is raised. With + the default value of 0.1, a warning will be raised if the fraction + of data excluded because of data gaps longer than `max_timedelta` is + above than 10%. + + Returns + ------- + pd.Series + + Note + ---- + Timezone information in the DatetimeIndexes is handled automatically, + however both `time_series` and `target_index` should be time zone aware or + they should both be time zone naive. + + ''' + + # note the name of the input, so we can use it for the output + original_name = time_series.name + + # copy, rename, and make df from input + time_series = time_series.copy() + time_series.name = 'data' + df = pd.DataFrame(time_series) + df = df.dropna() + + # convert to integer index and calculate the size of gaps in input + timestamps = df.index.astype('int64') + df['timestamp'] = timestamps + df['gapsize_ns'] = df['timestamp'].diff() + df.index = timestamps + + valid_indput_index = df.index.copy() + + if max_timedelta is None: + max_interval_nanoseconds = 2 * df['gapsize_ns'].median() + else: + max_interval_nanoseconds = max_timedelta.total_seconds() * 10.0**9 + + fraction_excluded = (df['gapsize_ns'] > max_interval_nanoseconds).mean() + if fraction_excluded > warning_threshold: + warnings.warn("Fraction of excluded data " + f"({100*fraction_excluded:0.02f}%) " + "exceeded threshold", + UserWarning) + + # put data on index that includes both original and target indicies + target_timestamps = target_index.astype('int64') + union_index = df.index.append(target_timestamps) + union_index = union_index.drop_duplicates(keep='first') + df = df.reindex(union_index) + df = df.sort_index() + + # calculate the gap size in the original data (timestamps) + df['gapsize_ns'] = df['gapsize_ns'].fillna(method='bfill') + df.loc[valid_indput_index, 'gapsize_ns'] = 0 + + # perform the interpolation when the max gap size criterion is satisfied + df_valid = df[df['gapsize_ns'] <= max_interval_nanoseconds].copy() + df_valid['interpolated_data'] = \ + df_valid['data'].interpolate(method='index') + + df['interpolated_data'] = df_valid['interpolated_data'] + + out = pd.Series(df['interpolated_data']) + out = out.loc[target_timestamps] + out.name = original_name + out.index = pd.to_datetime(out.index, utc=True).tz_convert(target_index.tz) + out = out.reindex(target_index) + + return out + + +def interpolate(time_series, target, max_timedelta=None, warning_threshold=0.1): + ''' + Returns an interpolation of time_series, excluding times associated with + gaps in each column of time_series longer than max_timedelta; NaNs are + returned within those gaps. + + Parameters + ---------- + time_series : pd.Series, pd.DataFrame + Original values to be used in generating the interpolation + target : pd.DatetimeIndex, DatetimeOffset, or frequency string + + * If DatetimeIndex: the index onto which the interpolation is to be + made + * If DatetimeOffset or frequency string: the frequency at which to + resample and interpolate + max_timedelta : pd.Timedelta, default None + The maximum allowed gap between values in `time_series`. Times + associated with gaps longer than `max_timedelta` are excluded from the + output. If omitted, `max_timedelta` is set internally to two times + the median time delta in `time_series`. + warning_threshold : float, default 0.1 + The fraction of data exclusion above which a warning is raised. With + the default value of 0.1, a warning will be raised if the fraction + of data excluded because of data gaps longer than `max_timedelta` is + above than 10%. + + Returns + ------- + pd.Series or pd.DataFrame (matching type of time_series) with DatetimeIndex + + Note + ---- + Timezone information in the DatetimeIndexes is handled automatically, + however both `time_series` and `target` should be time zone aware or they + should both be time zone naive. + ''' + + if isinstance(target, pd.DatetimeIndex): + target_index = target + elif isinstance(target, (pd.tseries.offsets.DateOffset, str)): + target_index = pd.date_range(time_series.index.min(), + time_series.index.max(), + freq=target) + + if (time_series.index.tz is None) ^ (target_index.tz is None): + raise ValueError('Either time_series or target is time-zone aware but ' + 'the other is not. Both must be time-zone aware or ' + 'both must be time-zone naive.') + + if isinstance(time_series, pd.Series): + out = interpolate_series(time_series, target_index, max_timedelta, + warning_threshold) + elif isinstance(time_series, pd.DataFrame): + out_list = [] + for col in time_series.columns: + ts = time_series[col] + series = interpolate_series(ts, target_index, max_timedelta, + warning_threshold) + out_list.append(series) + out = pd.concat(out_list, axis=1) + else: + raise ValueError('time_series must be a Pandas Series or DataFrame') + + return out diff --git a/rdtools/plotting.py b/rdtools/plotting.py new file mode 100644 index 00000000..c66a1736 --- /dev/null +++ b/rdtools/plotting.py @@ -0,0 +1,232 @@ +'''Functions for plotting degradation and soiling analysis results.''' + +import matplotlib.pyplot as plt + + +def degradation_summary_plots(yoy_rd, yoy_ci, yoy_info, normalized_yield, + hist_xmin=None, hist_xmax=None, bins=None, + scatter_ymin=None, scatter_ymax=None, + plot_color=None, summary_title=None, + scatter_alpha=0.5): + ''' + Create plots (scatter plot and histogram) that summarize degradation + analysis results. + + Parameters + ---------- + yoy_rd : float + rate of relative performance change in %/yr + yoy_ci : float + one-sigma confidence interval of degradation rate estimate + yoy_info : dict + a dictionary with keys: + + * YoY_values - pandas series of right-labeled year on year slopes + * renormalizing_factor - float value used to recenter data + * exceedance_level - the degradation rate that was outperformed with + a probability given by the ``exceedance_prob`` parameter in + the :py:func:`.degradation.degradation_year_on_year` + + normalized_yield : pd.Series + PV yield data that is normalized, filtered and aggregated + hist_xmin : float, optional + lower limit of x-axis for the histogram + hist_xmax : float, optional + upper limit of x-axis for the histogram + bins : int, optional + Number of bins in the histogram distribution. If omitted, + ``len(yoy_values) // 40`` will be used + scatter_ymin : float, optional + lower limit of y-axis for the scatter plot + scatter_ymax : float, optional + upper limit of y-axis for the scatter plot + plot_color : str, optional + color of the summary plots + summary_title : str, optional + overall title for summary plots + scatter_alpha : float, default 0.5 + Transparency of the scatter plot + + Note + ---- + It should be noted that the yoy_rd, yoy_ci and yoy_info are the outputs + from :py:func:`.degradation.degradation_year_on_year`. + + Returns + ------- + fig : matplotlib Figure + Figure with two axes + ''' + + yoy_values = yoy_info['YoY_values'] + + if bins is None: + bins = len(yoy_values) // 40 + + bins = int(min(bins, len(yoy_values))) + + # Calculate the degradation line + start = normalized_yield.index[0] + end = normalized_yield.index[-1] + years = (end - start).days / 365.25 + yoy_values = yoy_info['YoY_values'] + + x = [start, end] + y = [1, 1 + (yoy_rd * years) / 100.0] + + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 3)) + ax2.hist(yoy_values, label='YOY', bins=bins, color=plot_color) + ax2.axvline(x=yoy_rd, color='black', linestyle='dashed', linewidth=3) + + ax2.set_xlim(hist_xmin, hist_xmax) + + label = ( + ' $R_{d}$ = %.2f%%/yr \n' + 'confidence interval: \n' + '%.2f to %.2f %%/yr' % (yoy_rd, yoy_ci[0], yoy_ci[1]) + ) + ax2.annotate(label, xy=(0.5, 0.7), xycoords='axes fraction', + bbox=dict(facecolor='white', edgecolor=None, alpha=0)) + ax2.set_xlabel('Annual degradation (%)') + + renormalized_yield = normalized_yield / yoy_info['renormalizing_factor'] + ax1.plot(renormalized_yield.index, renormalized_yield, 'o', + color=plot_color, alpha=scatter_alpha) + ax1.plot(x, y, 'k--', linewidth=3) + ax1.set_xlabel('Date') + ax1.set_ylabel('Renormalized energy') + + ax1.set_ylim(scatter_ymin, scatter_ymax) + + fig.autofmt_xdate() + + if summary_title is not None: + fig.suptitle(summary_title) + + return fig + + +def soiling_monte_carlo_plot(soiling_info, normalized_yield, point_alpha=0.5, + profile_alpha=0.05, ymin=None, ymax=None, + profiles=None, point_color=None, + profile_color='C1'): + ''' + Create figure to visualize Monte Carlo of soiling profiles used in the SRR + analysis. + + Parameters + ---------- + soiling_info : dict + ``soiling_info`` returned by :py:meth:`.soiling.SRRAnalysis.run` or + :py:func:`.soiling.soiling_srr`. + normalized_yield : pd.Series + PV yield data that is normalized, filtered and aggregated. + point_alpha : float, default 0.5 + tranparency of the ``normalized_yield`` points + profile_alpha : float, default 0.05 + transparency of each profile + ymin : float, optional + minimum y coordinate + ymax : float, optional + maximum y coordinate + profiles : int, optional + the number of stochastic profiles to plot. If not specified, plot + all profiles. + point_color : str, optional + color of the normalized_yield points + profile_color : str, default 'C1' + color of the stochastic profiles + + Returns + ------- + fig : matplotlib Figure + ''' + + fig, ax = plt.subplots() + renormalized = normalized_yield / soiling_info['renormalizing_factor'] + ax.plot(renormalized.index, renormalized, 'o', alpha=point_alpha, + color=point_color) + ax.set_ylim(ymin, ymax) + + if profiles is not None: + to_plot = soiling_info['stochastic_soiling_profiles'][:profiles] + else: + to_plot = soiling_info['stochastic_soiling_profiles'] + for profile in to_plot: + ax.plot(profile.index, profile, color=profile_color, + alpha=profile_alpha) + ax.set_ylabel('Renormalized energy') + fig.autofmt_xdate() + + return fig + + +def soiling_interval_plot(soiling_info, normalized_yield, point_alpha=0.5, + profile_alpha=1, ymin=None, ymax=None, + point_color=None, profile_color=None): + ''' + Create figure to visualize valid soiling profiles used in the SRR analysis. + + Parameters + ---------- + soiling_info : dict + ``soiling_info`` returned by :py:meth:`.soiling.SRRAnalysis.run` or + :py:func:`.soiling.soiling_srr`. + normalized_yield : pd.Series + PV yield data that is normalized, filtered and aggregated. + point_alpha : float, default 0.5 + tranparency of the ``normalized_yield`` points + profile_alpha : float, default 1 + transparency of soiling profile + ymin : float, optional + minimum y coordinate + ymax : float, optional + maximum y coordinate + point_color : str, optional + color of the ``normalized_yield`` points + profile_color : str, optional + color of the soiling intervals + + Returns + ------- + fig : matplotlib Figure + ''' + + sratio = soiling_info['soiling_ratio_perfect_clean'] + fig, ax = plt.subplots() + renormalized = normalized_yield / soiling_info['renormalizing_factor'] + ax.plot(renormalized.index, renormalized, 'o') + ax.plot(sratio.index, sratio, 'o') + ax.set_ylim(ymin, ymax) + ax.set_ylabel('Renormalized energy') + + fig.autofmt_xdate() + + return fig + + +def soiling_rate_histogram(soiling_info, bins=None): + ''' + Create histogram of soiling rates found in the SRR analysis. + + Parameters + ---------- + soiling_info : dict + ``soiling_info`` returned by :py:meth:`.soiling.SRRAnalysis.run` or + :py:func:`.soiling.soiling_srr`. + bins : int + number of histogram bins to use + + Returns + ------- + fig : matplotlib Figure + ''' + + soiling_summary = soiling_info['soiling_interval_summary'] + fig, ax = plt.subplots() + ax.hist(100.0 * soiling_summary.loc[soiling_summary['valid'], 'slope'], + bins=bins) + ax.set_xlabel('Soiling rate (%/day)') + ax.set_ylabel('Count') + + return fig diff --git a/rdtools/soiling.py b/rdtools/soiling.py new file mode 100644 index 00000000..d9327425 --- /dev/null +++ b/rdtools/soiling.py @@ -0,0 +1,703 @@ +'''Functions for calculating soiling metrics from photovoltaic system data.''' + +import pandas as pd +import numpy as np +from scipy.stats.mstats import theilslopes + + +# Custom exception +class NoValidIntervalError(Exception): + '''raised when no valid rows appear in the result dataframe''' + pass + + +class SRRAnalysis(): + ''' + Class for running the stochastic rate and recovery (SRR) photovoltaic + soiling loss analysis presented in Deceglie et al. JPV 8(2) p547 2018 + + Parameters + ---------- + energy_normalized_daily : pd.Series + Daily performance metric (i.e. performance index, yield, etc.) + Alternatively, the soiling ratio output of a soiling sensor (e.g. the + photocurrent ratio between matched dirty and clean PV reference cells). + In either case, data should be insolation-weighted daily aggregates. + insolation_daily : pd.Series + Daily plane-of-array insolation corresponding to + `energy_normalized_daily` + precipitation_daily : pd.Series, default None + Daily total precipitation. (Ignored if ``clean_criterion='shift'`` in + subsequent calculations.) + ''' + + def __init__(self, energy_normalized_daily, insolation_daily, + precipitation_daily=None): + self.pm = energy_normalized_daily # daily performance metric + self.insolation_daily = insolation_daily + self.precipitation_daily = precipitation_daily # daily precipitation + self.random_profiles = [] # random soiling profiles in _calc_monte + # insolation-weighted soiling ratios in _calc_monte: + self.monte_losses = [] + + if self.pm.index.freq != 'D': + raise ValueError('Daily performance metric series must have ' + 'daily frequency') + + if self.insolation_daily.index.freq != 'D': + raise ValueError('Daily insolation series must have ' + 'daily frequency') + + if self.precipitation_daily is not None: + if self.precipitation_daily.index.freq != 'D': + raise ValueError('Precipitation series must have ' + 'daily frequency') + + def _calc_daily_df(self, day_scale=14, clean_threshold='infer', + recenter=True, clean_criterion='shift', precip_threshold=0.01): + ''' + Calculates self.daily_df, a pandas dataframe prepared for SRR analysis, + and self.renorm_factor, the renormalization factor for the daily + performance + + Parameters + ---------- + day_scale : int, default 14 + The number of days to use in rolling median for cleaning detection + clean_threshold : float or 'infer', default 'infer' + If float: the fractional positive shift in rolling median for + cleaning detection. + If 'infer': automatically use outliers in the shift as the + threshold + recenter : bool, default True + Whether to recenter (renormalize) the daily performance to the + median of the first year + clean_criterion : {'precip_and_shift', 'precip_or_shift', 'precip', 'shift'} \ + default 'shift' + The method of partitioning the dataset into soiling intervals. + If 'precip_and_shift', rolling median shifts must coincide + with precipitation to be a valid cleaning event. + If 'precip_or_shift', rolling median shifts and precipitation + events are each sufficient on their own to be a cleaning event. + If 'shift', only rolling median shifts are treated as cleaning events. + If 'precip', only precipitation events are treated as cleaning events. + precip_threshold : float, default 0.01 + The daily precipitation threshold for defining precipitation cleaning events. + Units must be consistent with ``self.precipitation_daily``. + ''' + + df = self.pm.to_frame() + df.columns = ['pi'] + df_insol = self.insolation_daily.to_frame() + df_insol.columns = ['insol'] + + df = df.join(df_insol) + precip = self.precipitation_daily + if precip is not None: + df_precip = precip.to_frame() + df_precip.columns = ['precip'] + df = df.join(df_precip) + else: + df['precip'] = 0 + + # find first and last valid data point + start = df[~df.pi.isnull()].index[0] + end = df[~df.pi.isnull()].index[-1] + df = df[start:end] + + # create a day count column + df['day'] = range(len(df)) + + # Recenter to median of first year, as in YoY degradation + if recenter: + oneyear = start + pd.Timedelta('364d') + renorm = df.loc[start:oneyear, 'pi'].median() + else: + renorm = 1 + + df['pi_norm'] = df['pi'] / renorm + + # Find the beginning and ends of outages longer than dayscale + bfill = df['pi_norm'].fillna(method='bfill', limit=day_scale) + ffill = df['pi_norm'].fillna(method='ffill', limit=day_scale) + out_start = (~df['pi_norm'].isnull() & bfill.shift(-1).isnull()) + out_end = (~df['pi_norm'].isnull() & ffill.shift(1).isnull()) + + # clean up the first and last elements + out_start.iloc[-1] = False + out_end.iloc[0] = False + + # Make a forward filled copy, just for use in + # step, slope change detection + df_ffill = df.fillna(method='ffill', limit=day_scale).copy() + + # Calculate rolling median + df['pi_roll_med'] = \ + df_ffill.pi_norm.rolling(day_scale, center=True).median() + + # Detect steps in rolling median + df['delta'] = df.pi_roll_med.diff() + if clean_threshold == 'infer': + deltas = abs(df.delta) + clean_threshold = deltas.quantile(0.75) + \ + 1.5 * (deltas.quantile(0.75) - deltas.quantile(0.25)) + + df['clean_event_detected'] = (df.delta > clean_threshold) + precip_event = (df['precip'] > precip_threshold) + + if clean_criterion == 'precip_and_shift': + # Detect which cleaning events are associated with rain within a 3 day window + precip_event = precip_event.rolling(3, center=True, min_periods=1).apply(any).astype(bool) + df['clean_event'] = (df['clean_event_detected'] & precip_event) + elif clean_criterion == 'precip_or_shift': + df['clean_event'] = (df['clean_event_detected'] | precip_event) + elif clean_criterion == 'precip': + df['clean_event'] = precip_event + elif clean_criterion == 'shift': + df['clean_event'] = df['clean_event_detected'] + else: + raise ValueError('clean_criterion must be one of ' + '{"precip_and_shift", "precip_or_shift", "precip", "shift"}') + + df['clean_event'] = df.clean_event | out_start | out_end + df['clean_event'] = (df.clean_event) & (~df.clean_event.shift(-1).fillna(False)) + + df = df.fillna(0) + + # Give an index to each soiling interval/run + df['run'] = df.clean_event.cumsum() + df.index.name = 'date' # this gets used by name + + self.renorm_factor = renorm + self.daily_df = df + + def _calc_result_df(self, trim=False, max_relative_slope_error=500.0, + max_negative_step=0.05, min_interval_length=2): + ''' + Calculates self.result_df, a pandas dataframe summarizing the soiling + intervals identified and self.analyzed_daily_df, a version of + self.daily_df with additional columns calculated during analysis. + + Parameters + ---------- + trim : bool, default False + whether to trim (remove) the first and last soiling intervals to + avoid inclusion of partial intervals + max_relative_slope_error : float, default 500 + the maximum relative size of the slope confidence interval for an + interval to be considered valid (percentage). + max_negative_step : float, default 0.05 + The maximum magnitude of negative discrete steps allowed in an + interval for the interval to be considered valid (units of + normalized performance metric). + min_interval_length : int, default 2 + The minimum duration for an interval to be considered + valid. Cannot be less than 2 (days). + ''' + + daily_df = self.daily_df + result_list = [] + if trim: + # ignore first and last interval + res_loop = sorted(list(set(daily_df['run'])))[1:-1] + else: + res_loop = sorted(list(set(daily_df['run']))) + + for r in res_loop: + run = daily_df[daily_df['run'] == r] + length = (run.day[-1] - run.day[0]) + start_day = run.day[0] + end_day = run.day[-1] + start = run.index[0] + end = run.index[-1] + run_filtered = run[run.pi_norm > 0] + # use the filtered version if it contains any points + # otherwise use the unfiltered version to populate a + # valid=False row + if not run_filtered.empty: + run = run_filtered + result_dict = { + 'start': start, + 'end': end, + 'length': length, + 'run': r, + 'run_slope': 0, + 'run_slope_low': 0, + 'run_slope_high': 0, + 'max_neg_step': min(run.delta), + 'start_loss': 1, + 'inferred_start_loss': run.pi_norm.mean(), + 'inferred_end_loss': run.pi_norm.mean(), + 'valid': False + } + if len(run) > min_interval_length and run.pi_norm.sum() > 0: + fit = theilslopes(run.pi_norm, run.day) + fit_poly = np.poly1d(fit[0:2]) + result_dict['run_slope'] = fit[0] + result_dict['run_slope_low'] = fit[2] + result_dict['run_slope_high'] = min([0.0, fit[3]]) + result_dict['inferred_start_loss'] = fit_poly(start_day) + result_dict['inferred_end_loss'] = fit_poly(end_day) + result_dict['valid'] = True + result_list.append(result_dict) + + results = pd.DataFrame(result_list) + + if results.empty: + raise NoValidIntervalError('No valid soiling intervals were found') + + # Filter results for each interval, + # setting invalid interval to slope of 0 + results['slope_err'] = (results.run_slope_high-results.run_slope_low)/abs(results.run_slope) + # critera for exclusions + filt = ( + (results.run_slope > 0) | + (results.slope_err >= max_relative_slope_error / 100.0) | + (results.max_neg_step <= -1.0 * max_negative_step) + ) + + results.loc[filt, 'run_slope'] = 0 + results.loc[filt, 'run_slope_low'] = 0 + results.loc[filt, 'run_slope_high'] = 0 + results.loc[filt, 'valid'] = False + + # Calculate the next inferred start loss from next valid interval + results['next_inferred_start_loss'] = np.clip( + results[results.valid].inferred_start_loss.shift(-1), + 0, 1) + # Calculate the inferred recovery at the end of each interval + results['inferred_recovery'] = np.clip( + results.next_inferred_start_loss - results.inferred_end_loss, + 0, 1) + + # Don't consider data outside of first and last valid interverals + if len(results[results.valid]) == 0: + raise NoValidIntervalError('No valid soiling intervals were found') + new_start = results[results.valid].start.iloc[0] + new_end = results[results.valid].end.iloc[-1] + pm_frame_out = daily_df[new_start:new_end] + pm_frame_out = pm_frame_out.reset_index() \ + .merge(results, how='left', on='run') \ + .set_index('date') + + pm_frame_out['loss_perfect_clean'] = np.nan + pm_frame_out['loss_inferred_clean'] = np.nan + pm_frame_out['days_since_clean'] = \ + (pm_frame_out.index - pm_frame_out.start).dt.days + + # Calculate the daily derate + pm_frame_out['loss_perfect_clean'] = \ + pm_frame_out.start_loss + \ + pm_frame_out.days_since_clean * pm_frame_out.run_slope + # filling the flat intervals may need to be recalculated + # for different assumptions + pm_frame_out.loss_perfect_clean = \ + pm_frame_out.loss_perfect_clean.fillna(1) + + pm_frame_out['loss_inferred_clean'] = \ + pm_frame_out.inferred_start_loss + \ + pm_frame_out.days_since_clean * pm_frame_out.run_slope + # filling the flat intervals may need to be recalculated + # for different assumptions + pm_frame_out.loss_inferred_clean = \ + pm_frame_out.loss_inferred_clean.fillna(1) + + self.result_df = results + self.analyzed_daily_df = pm_frame_out + + def _calc_monte(self, monte, method='half_norm_clean'): + ''' + Runs the Monte Carlo step of the SRR method. Calculates + self.random_profiles, a list of the random soiling profiles realized in + the calculation, and self.monte_losses, a list of the + insolation-weighted soiling ratios associated with the realizations. + + Parameters + ---------- + monte : int + number of Monte Carlo simulations to run + method : str, default 'half_norm_clean' + how to treat the recovery of each cleaning event: + * 'random_clean' - a random recovery between 0-100% + * 'perfect_clean' - each cleaning event returns the performance + metric to 1 + * 'half_norm_clean' - The three-sigma lower bound of recovery is + inferred from the fit of the following interval, the upper bound + is 1 with the magnitude drawn from a half normal centered at 1 + ''' + + monte_losses = [] + random_profiles = [] + for _ in range(monte): + results_rand = self.result_df.copy() + df_rand = self.analyzed_daily_df.copy() + # only really need this column from the original frame: + df_rand = df_rand[['insol', 'run']] + results_rand['run_slope'] = \ + np.random.uniform(results_rand.run_slope_low, + results_rand.run_slope_high) + results_rand['run_loss'] = \ + results_rand.run_slope * results_rand.length + + results_rand['end_loss'] = np.nan + results_rand['start_loss'] = np.nan + + # Make groups that start with a valid interval and contain + # subsequent invalid intervals + group_list = [] + group = 0 + for x in results_rand.valid: + if x: + group += 1 + group_list.append(group) + + results_rand['group'] = group_list + + # randomize the extent of the cleaning + inter_start = 1.0 + start_list = [] + if method == 'half_norm_clean': + # Randomize recovery of valid intervals only + valid_intervals = results_rand[results_rand.valid].copy() + valid_intervals['inferred_recovery'] = \ + valid_intervals.inferred_recovery.fillna(1.0) + + end_list = [] + for i, row in valid_intervals.iterrows(): + start_list.append(inter_start) + end = inter_start + row.run_loss + end_list.append(end) + + # Use a half normal with the infered clean at the + # 3sigma point + x = np.clip(end + row.inferred_recovery, 0, 1) + inter_start = 1 - abs(np.random.normal(0.0, (1 - x)/3)) + + # Update the valid rows in results_rand + valid_update = pd.DataFrame() + valid_update['start_loss'] = start_list + valid_update['end_loss'] = end_list + valid_update.index = valid_intervals.index + results_rand.update(valid_update) + + # forward and back fill to note the limits of random constant + # derate for invalid intervals + results_rand['previous_end'] = \ + results_rand.end_loss.fillna(method='ffill') + results_rand['next_start'] = \ + results_rand.start_loss.fillna(method='bfill') + + # Randomly select random constant derate for invalid intervals + # based on previous end and next beginning + invalid_intervals = results_rand[~results_rand.valid].copy() + # fill NaNs at beggining and end + invalid_intervals.previous_end.fillna(1.0, inplace=True) + invalid_intervals.next_start.fillna(1.0, inplace=True) + groups = set(invalid_intervals.group) + replace_levels = [] + + if len(groups) > 0: + for g in groups: + rows = invalid_intervals[invalid_intervals.group == g] + n = len(rows) + low = rows.iloc[0].previous_end + high = rows.iloc[0].next_start + level = np.random.uniform(low, high) + replace_levels.append(np.full(n, level)) + + # Update results rand with the invalid rows + replace_levels = np.concatenate(replace_levels) + invalid_update = pd.DataFrame() + invalid_update['start_loss'] = replace_levels + invalid_update.index = invalid_intervals.index + results_rand.update(invalid_update) + + elif method == 'random_clean': + for i, row in results_rand.iterrows(): + start_list.append(inter_start) + end = inter_start + row.run_loss + inter_start = np.random.uniform(end, 1) + results_rand['start_loss'] = start_list + + elif method == 'perfect_clean': + for i, row in results_rand.iterrows(): + start_list.append(inter_start) + end = inter_start + row.run_loss + inter_start = 1 + results_rand['start_loss'] = start_list + + else: + raise ValueError("Invalid method specification") + + df_rand = df_rand.reset_index() \ + .merge(results_rand, how='left', on='run') \ + .set_index('date') + df_rand['loss'] = np.nan + df_rand['days_since_clean'] = \ + (df_rand.index - df_rand.start).dt.days + df_rand['loss'] = df_rand.start_loss + \ + df_rand.days_since_clean * df_rand.run_slope + + df_rand['soil_insol'] = df_rand.loss * df_rand.insol + + monte_losses.append(df_rand.soil_insol.sum() / df_rand.insol.sum()) + random_profile = df_rand['loss'].copy() + random_profile.name = 'stochastic_soiling_profile' + random_profiles.append(random_profile) + + self.random_profiles = random_profiles + self.monte_losses = monte_losses + + def run(self, reps=1000, day_scale=14, clean_threshold='infer', + trim=False, method='half_norm_clean', + clean_criterion='shift', precip_threshold=0.01, min_interval_length=2, + exceedance_prob=95.0, confidence_level=68.2, recenter=True, + max_relative_slope_error=500.0, max_negative_step=0.05): + ''' + Run the SRR method from beginning to end. Perform the stochastic rate + and recovery soiling loss calculation. Based on the methods presented + in Deceglie et al. JPV 8(2) p547 2018. + + Parameters + ---------- + reps : int, default 1000 + number of Monte Carlo realizations to calculate + day_scale : int, default 14 + The number of days to use in rolling median for cleaning detection, + and the maximum number of days of missing data to tolerate in a + valid interval + clean_threshold : float or 'infer', default 'infer' + The fractional positive shift in rolling median for cleaning + detection. Or specify 'infer' to automatically use outliers in the + shift as the threshold. + trim : bool, default False + Whether to trim (remove) the first and last soiling intervals to + avoid inclusion of partial intervals + method : str, default 'half_norm_clean' + How to treat the recovery of each cleaning event: + + * `random_clean` - a random recovery between 0-100% + * `perfect_clean` - each cleaning event returns the performance + metric to 1 + * `half_norm_clean` (default) - The three-sigma lower bound of + recovery is inferred from the fit of the following interval, the + upper bound is 1 with the magnitude drawn from a half normal + centered at 1 + + clean_criterion : {'precip_and_shift', 'precip_or_shift', 'precip', 'shift'} \ + default 'shift' + The method of partitioning the dataset into soiling intervals. + If 'precip_and_shift', rolling median shifts must coincide + with precipitation to be a valid cleaning event. + If 'precip_or_shift', rolling median shifts and precipitation + events are each sufficient on their own to be a cleaning event. + If 'shift', only rolling median shifts are treated as cleaning events. + If 'precip', only precipitation events are treated as cleaning events. + precip_threshold : float, default 0.01 + The daily precipitation threshold for defining precipitation cleaning events. + Units must be consistent with ``self.precipitation_daily`` + min_interval_length : int, default 2 + The minimum duration for an interval to be considered + valid. Cannot be less than 2 (days). + exceedance_prob : float, default 95.0 + The probability level to use for exceedance value calculation in + percent + confidence_level : float, default 68.2 + The size of the confidence interval to return, in percent + recenter : bool, default True + Specify whether data is centered to normalized yield of 1 based on + first year median + max_relative_slope_error : float, default 500 + the maximum relative size of the slope confidence interval for an + interval to be considered valid (percentage). + max_negative_step : float, default 0.05 + The maximum magnitude of negative discrete steps allowed in an + interval for the interval to be considered valid (units of + normalized performance metric). + + Returns + ------- + insolation_weighted_soiling_ratio : float + P50 insolation weighted soiling ratio based on stochastic rate and + recovery analysis + confidence_interval : np.array + confidence interval (size specified by confidence_level) of + degradation rate estimate + calc_info : dict + * `renormalizing_factor` - value used to recenter data + * `exceedance_level` - the insolation-weighted soiling ratio that + was outperformed with probability of exceedance_prob + * `stochastic_soiling_profiles` - List of Pandas series + corresponding to the Monte Carlo realizations of soiling ratio + profiles + * `soiling_interval_summary` - Pandas dataframe summarizing the + soiling intervals identified + * `soiling_ratio_perfect_clean` - Pandas series of the soiling + ratio during valid soiling intervals assuming perfect cleaning + and P50 slopes. + ''' + self._calc_daily_df(day_scale=day_scale, + clean_threshold=clean_threshold, + recenter=recenter, + clean_criterion=clean_criterion, + precip_threshold=precip_threshold) + self._calc_result_df(trim=trim, + max_relative_slope_error=max_relative_slope_error, + max_negative_step=max_negative_step, + min_interval_length=min_interval_length) + self._calc_monte(reps, method=method) + + # Calculate the P50 and confidence interval + half_ci = confidence_level / 2.0 + result = np.percentile(self.monte_losses, + [50, + 50.0 - half_ci, + 50.0 + half_ci, + 100 - exceedance_prob]) + P_level = result[3] + + # Construct calc_info output + + intervals_out = self.result_df[ + ['start', 'end', 'run_slope', 'run_slope_low', + 'run_slope_high', 'inferred_start_loss', 'inferred_end_loss', + 'length', 'valid']].copy() + intervals_out.rename(columns={'run_slope': 'slope', + 'run_slope_high': 'slope_high', + 'run_slope_low': 'slope_low', + }, inplace=True) + + df_d = self.analyzed_daily_df + sr_perfect = df_d[df_d['valid']]['loss_perfect_clean'] + calc_info = { + 'exceedance_level': P_level, + 'renormalizing_factor': self.renorm_factor, + 'stochastic_soiling_profiles': self.random_profiles, + 'soiling_interval_summary': intervals_out, + 'soiling_ratio_perfect_clean': sr_perfect + } + + return (result[0], result[1:3], calc_info) + + +def soiling_srr(energy_normalized_daily, insolation_daily, reps=1000, + precipitation_daily=None, day_scale=14, clean_threshold='infer', + trim=False, method='half_norm_clean', + clean_criterion='shift', precip_threshold=0.01, min_interval_length=2, + exceedance_prob=95.0, confidence_level=68.2, recenter=True, + max_relative_slope_error=500.0, max_negative_step=0.05): + ''' + Functional wrapper for :py:class:`~rdtools.soiling.SRRAnalysis`. Perform + the stochastic rate and recovery soiling loss calculation. Based on the + methods presented in Deceglie et al. JPV 8(2) p547 2018. + + Parameters + ---------- + energy_normalized_daily : pd.Series + Daily performance metric (i.e. performance index, yield, etc.) + Alternatively, the soiling ratio output of a soiling sensor (e.g. the + photocurrent ratio between matched dirty and clean PV reference cells). + In either case, data should be insolation-weighted daily aggregates. + insolation_daily : pd.Series + Daily plane-of-array insolation corresponding to + `energy_normalized_daily` + reps : int, default 1000 + number of Monte Carlo realizations to calculate + precipitation_daily : pd.Series, default None + Daily total precipitation. Units ambiguous but should be the same as + precip_threshold. Note default behavior of precip_threshold. (Ignored + if ``clean_criterion='shift'``.) + day_scale : int, default 14 + The number of days to use in rolling median for cleaning detection, + and the maximum number of days of missing data to tolerate in a valid + interval + clean_threshold : float or 'infer', default 'infer' + The fractional positive shift in rolling median for cleaning detection. + Or specify 'infer' to automatically use outliers in the shift as the + threshold. + trim : bool, default False + Whether to trim (remove) the first and last soiling intervals to avoid + inclusion of partial intervals + method : str, default 'half_norm_clean' + how to treat the recovery of each cleaning event + + * `random_clean` - a random recovery between 0-100% + * `perfect_clean` - each cleaning event returns the performance metric + to 1 + * `half_norm_clean` (default) - The three-sigma lower bound of recovery + is inferred from the fit of the following interval, the upper bound + is 1 with the magnitude drawn from a half normal centered at 1 + clean_criterion : {'precip_and_shift', 'precip_or_shift', 'precip', 'shift'} \ + default 'shift' + The method of partitioning the dataset into soiling intervals. + If 'precip_and_shift', rolling median shifts must coincide + with precipitation to be a valid cleaning event. + If 'precip_or_shift', rolling median shifts and precipitation + events are each sufficient on their own to be a cleaning event. + If 'shift', only rolling median shifts are treated as cleaning events. + If 'precip', only precipitation events are treated as cleaning events. + precip_threshold : float, default 0.01 + The daily precipitation threshold for defining precipitation cleaning events. + Units must be consistent with precip. + min_interval_length : int, default 2 + The minimum duration for an interval to be considered + valid. Cannot be less than 2 (days). + exceedance_prob : float, default 95.0 + the probability level to use for exceedance value calculation in + percent + confidence_level : float, default 68.2 + the size of the confidence interval to return, in percent + recenter : bool, default True + specify whether data is centered to normalized yield of 1 based on + first year median + max_relative_slope_error : float, default 500.0 + the maximum relative size of the slope confidence interval for an + interval to be considered valid (percentage). + max_negative_step : float, default 0.05 + The maximum magnitude of negative discrete steps allowed in an interval + for the interval to be considered valid (units of normalized + performance metric). + + Returns + ------- + insolation_weighted_soiling_ratio : float + P50 insolation weighted soiling ratio based on stochastic rate and + recovery analysis + confidence_interval : np.array + confidence interval (size specified by `confidence_level`) of + degradation rate estimate + calc_info : dict + Calculation information from the SRR process. + + * `renormalizing_factor` - value used to recenter data + * `exceedance_level` - the insolation-weighted soiling ratio that + was outperformed with probability of exceedance_prob + * `stochastic_soiling_profiles` - List of Pandas series + corresponding to the Monte Carlo realizations of soiling + ratio profiles + * `soiling_interval_summary` - Pandas dataframe summarizing the + soiling intervals identified + * `soiling_ratio_perfect_clean` - Pandas series of the soiling + ratio during valid soiling intervals assuming perfect cleaning + and P50 slopes. + ''' + + srr = SRRAnalysis(energy_normalized_daily, + insolation_daily, + precipitation_daily=precipitation_daily) + + sr, sr_ci, soiling_info = srr.run( + reps=reps, + day_scale=day_scale, + clean_threshold=clean_threshold, + trim=trim, + method=method, + clean_criterion=clean_criterion, + precip_threshold=precip_threshold, + exceedance_prob=exceedance_prob, + confidence_level=confidence_level, + recenter=recenter, + max_relative_slope_error=max_relative_slope_error, + max_negative_step=max_negative_step) + + return sr, sr_ci, soiling_info diff --git a/rdtools/test/aggregation_test.py b/rdtools/test/aggregation_test.py index 9cce004b..aad1be37 100644 --- a/rdtools/test/aggregation_test.py +++ b/rdtools/test/aggregation_test.py @@ -8,7 +8,7 @@ class AggregationTestCase(unittest.TestCase): '''Unit tests for aggregation module''' def setUp(self): - ind = pd.DatetimeIndex(freq='12h', start='2015-01-01', end='2015-01-02 23:59') + ind = pd.date_range('2015-01-01', '2015-01-02 23:59', freq='12h') self.insol = pd.Series(data=[500, 1000, 500, 1000], index=ind) self.energy = pd.Series(data=[1.0, 4, 1.0, 4], index=ind) diff --git a/rdtools/test/energy_from_power_test.py b/rdtools/test/energy_from_power_test.py new file mode 100644 index 00000000..8827338c --- /dev/null +++ b/rdtools/test/energy_from_power_test.py @@ -0,0 +1,146 @@ +import pandas as pd +import numpy as np +from rdtools import energy_from_power +import pytest + + +# Tests for resampling at same frequency +def test_energy_from_power_calculation(): + power_times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:00', freq='15T') + result_times = power_times[1:] + power_series = pd.Series(data=4.0, index=power_times) + expected_energy_series = pd.Series(data=1.0, index=result_times) + expected_energy_series.name = 'energy_Wh' + + result = energy_from_power(power_series, max_timedelta=pd.to_timedelta('15 minutes')) + + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_max_interval(): + power_times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:00', freq='15T') + result_times = power_times[1:] + power_series = pd.Series(data=4.0, index=power_times) + expected_energy_series = pd.Series(data=np.nan, index=result_times) + expected_energy_series.name = 'energy_Wh' + + result = energy_from_power(power_series, max_timedelta=pd.to_timedelta('5 minutes')) + + # We expect series of NaNs, because max_interval_hours is smaller than the + # time step of the power time series + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_validation(): + power_series = pd.Series(data=[4.0] * 4) + with pytest.raises(ValueError): + energy_from_power(power_series, max_timedelta=pd.to_timedelta('15 minutes')) + + +def test_energy_from_power_single_argument(): + power_times = pd.date_range('2018-04-01 12:00', '2018-04-01 15:00', freq='15T') + result_times = power_times[1:] + power_series = pd.Series(data=4.0, index=power_times) + missing = pd.to_datetime('2018-04-01 13:00:00') + power_series = power_series.drop(missing) + + expected_energy_series = pd.Series(data=1.0, index=result_times) + expected_nan = [missing] + expected_nan.append(pd.to_datetime('2018-04-01 13:15:00')) + expected_energy_series.loc[expected_nan] = np.nan + expected_energy_series.name = 'energy_Wh' + + # Test that the result has the expected missing timestamp based on median timestep + result = energy_from_power(power_series) + pd.testing.assert_series_equal(result, expected_energy_series) + + +# Tests for downsampling +def test_energy_from_power_downsample(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:00', freq='15T') + time_series = pd.Series(data=[1.0, 2.0, 3.0, 4.0, 5.0], index=times) + + expected_energy_series = pd.Series(index=[pd.to_datetime('2018-04-01 13:00:00')], + data=3.0, name='energy_Wh') + expected_energy_series.index.freq = '60T' + result = energy_from_power(time_series, '60T') + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_downsample_max_timedelta_exceeded(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:00', freq='15T') + time_series = pd.Series(data=[1.0, 2.0, 3.0, 4.0, 5.0], index=times) + + expected_energy_series = pd.Series(index=[pd.to_datetime('2018-04-01 13:00:00')], + data=1.5, name='energy_Wh') + expected_energy_series.index.freq = '60T' + result = energy_from_power(time_series.drop(time_series.index[2]), '60T', pd.to_timedelta('15 minutes')) + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_downsample_max_timedelta_not_exceeded(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:00', freq='15T') + time_series = pd.Series(data=[1.0, 2.0, 3.0, 4.0, 5.0], index=times) + + expected_energy_series = pd.Series(index=[pd.to_datetime('2018-04-01 13:00:00')], + data=3.0, name='energy_Wh') + expected_energy_series.index.freq = '60T' + result = energy_from_power(time_series.drop(time_series.index[2]), '60T', pd.to_timedelta('60 minutes')) + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_for_issue_107(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 16:00', freq='15T') + dc_power = pd.Series(index=times, data=1.0) + dc_power = dc_power.drop(dc_power.index[5:12]) + + expected_times = pd.date_range('2018-04-01 13:00', '2018-04-01 16:00', freq='60T') + expected_energy_series = pd.Series(index=expected_times, + data=[1.0, np.nan, np.nan, 1.0], + name='energy_Wh') + result = energy_from_power(dc_power, '60T') + pd.testing.assert_series_equal(result, expected_energy_series) + + +# Tests for upsampling +def test_energy_from_power_upsample(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:30', freq='30T') + time_series = pd.Series(data=[1.0, 3.0, 5.0, 6.0], index=times) + + expected_result_times = pd.date_range('2018-04-01 12:15', '2018-04-01 13:30', freq='15T') + expected_energy_series = pd.Series(index=expected_result_times, + data=[0.375, 0.625, 0.875, 1.125, 1.3125, 1.4375], + name='energy_Wh') + + result = energy_from_power(time_series, '15T', pd.to_timedelta('30 minutes')) + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_upsample_maxtimedelta_not_exceeded(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:30', freq='30T') + time_series = pd.Series(data=[1.0, 3.0, 5.0, 6.0], index=times) + + expected_result_times = pd.date_range('2018-04-01 12:15', '2018-04-01 13:30', freq='15T') + expected_energy_series = pd.Series(index=expected_result_times, + data=[0.375, 0.625, 0.875, 1.125, 1.3125, 1.4375], + name='energy_Wh') + + result = energy_from_power(time_series.drop(time_series.index[1]), '15T', pd.to_timedelta('60 minutes')) + pd.testing.assert_series_equal(result, expected_energy_series) + + +def test_energy_from_power_upsample_maxtimedelta_exceeded(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:30', freq='30T') + time_series = pd.Series(data=[1.0, 3.0, 5.0, 6.0], index=times) + + expected_result_times = pd.date_range('2018-04-01 12:15', '2018-04-01 13:30', freq='15T') + expected_energy_series = pd.Series(index=expected_result_times, + data=[np.nan, np.nan, np.nan, np.nan, 1.3125, 1.4375], + name='energy_Wh') + + result = energy_from_power(time_series.drop(time_series.index[1]), '15T', pd.to_timedelta('30 minutes')) + pd.testing.assert_series_equal(result, expected_energy_series) + + + + diff --git a/rdtools/test/filtering_test.py b/rdtools/test/filtering_test.py index 025c37dc..be03a512 100644 --- a/rdtools/test/filtering_test.py +++ b/rdtools/test/filtering_test.py @@ -5,7 +5,7 @@ import pandas as pd import numpy as np -from rdtools import csi_filter, poa_filter, tcell_filter, clip_filter +from rdtools import csi_filter, poa_filter, tcell_filter, clip_filter, normalized_filter class CSIFilterTestCase(unittest.TestCase): @@ -33,8 +33,8 @@ def setUp(self): def test_poa_filter(self): filtered = poa_filter(self.measured_poa, - low_irradiance_cutoff=200, - high_irradiance_cutoff=1200) + poa_global_low=200, + poa_global_high=1200) # Expect high and low POA cutoffs to be non-inclusive. expected_result = np.array([True, True, True, False, False]) @@ -49,8 +49,8 @@ def setUp(self): def test_tcell_filter(self): filtered = tcell_filter(self.tcell, - low_tcell_cutoff=-50, - high_tcell_cutoff=110) + temperature_cell_low=-50, + temperature_cell_high=110) # Expected high and low tcell cutoffs to be non-inclusive. expected_result = np.array([False, True, True, True, False]) @@ -66,21 +66,29 @@ def setUp(self): # use of the Series.quantile() method. def test_clip_filter_upper(self): - filtered = clip_filter(self.power, quant=0.98, - low_power_cutoff=0) + filtered = clip_filter(self.power, quantile=0.98) # Expect 99% of the 98th quantile to be filtered expected_result = self.power < (98 * 0.99) self.assertTrue((expected_result == filtered).all()) - def test_clip_filter_low_cutoff(self): - filtered = clip_filter(self.power, quant=0.98, - low_power_cutoff=2) - # Expect power <=2 to be filtered - expected_result = (self.power > 2) - self.assertTrue((expected_result.iloc[0:5] == filtered.iloc[0:5]).all()) +def test_normalized_filter_default(): + pd.testing.assert_series_equal(normalized_filter(pd.Series([-5, 5])), + pd.Series([False, True])) + pd.testing.assert_series_equal(normalized_filter(pd.Series([-1e6, 1e6]), + energy_normalized_low=None, + energy_normalized_high=None), + pd.Series([True, True])) + + pd.testing.assert_series_equal(normalized_filter(pd.Series([-2, 2]), + energy_normalized_low=-1, + energy_normalized_high=1), + pd.Series([False, False])) + + pd.testing.assert_series_equal(normalized_filter(pd.Series([0.01 - 1e-16, 0.01 + 1e-16, 1e308])), + pd.Series([False, True, True])) if __name__ == '__main__': unittest.main() diff --git a/rdtools/test/interpolate_test.py b/rdtools/test/interpolate_test.py new file mode 100644 index 00000000..e4826a8e --- /dev/null +++ b/rdtools/test/interpolate_test.py @@ -0,0 +1,140 @@ +import pandas as pd +import numpy as np +from rdtools import interpolate +import pytest + + +@pytest.fixture +def time_series(): + times = pd.date_range('2018-04-01 12:00', '2018-04-01 13:15', freq='15T') + time_series = pd.Series(data=[9, 6, 3, 3, 6, 9], index=times, name='foo') + time_series = time_series.drop(times[4]) + return time_series + + +@pytest.fixture +def target_index(time_series): + return pd.date_range(time_series.index.min(), time_series.index.max(), freq='20T') + + +@pytest.fixture +def expected_series(target_index, time_series): + return pd.Series(data=[9.0, 5.0, 3.0, np.nan], index=target_index, name=time_series.name) + + +@pytest.fixture +def test_df(time_series): + time_series1 = time_series.copy() + time_series2 = time_series.copy() + + time_series2.index = time_series2.index + pd.to_timedelta('30 minutes') + time_series2.name = 'bar' + + test_df = pd.concat([time_series1, time_series2], axis=1) + + return test_df + + +@pytest.fixture +def df_target_index(target_index): + return target_index + pd.to_timedelta('15 minutes') + + +@pytest.fixture +def df_expected_result(df_target_index, test_df): + col0 = test_df.columns[0] + col1 = test_df.columns[1] + expected_df_result = pd.DataFrame({ + col0: [6.0, 3.0, np.nan, 9.0], + col1: [np.nan, 8.0, 4.0, 3.0] + }, index=df_target_index) + + expected_df_result = expected_df_result[test_df.columns] + return expected_df_result + + +def test_interpolate_freq_specification(time_series, target_index, expected_series): + # test the string specification + interpolated = interpolate(time_series, target_index.freq.freqstr, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_series_equal(interpolated, expected_series) + + # test the DateOffset specification + interpolated = interpolate(time_series, target_index.freq, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_series_equal(interpolated, expected_series) + + +def test_interpolate_calculation(time_series, target_index, expected_series): + + interpolated = interpolate(time_series, target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_series_equal(interpolated, expected_series) + + +def test_interpolate_two_argument(time_series, target_index, expected_series): + + expected_series.iloc[-1] = 6.0 + interpolated = interpolate(time_series, target_index) + pd.testing.assert_series_equal(interpolated, expected_series) + + +def test_interpolate_tz_validation(time_series, target_index, expected_series): + with pytest.raises(ValueError): + interpolate(time_series, target_index.tz_localize('UTC'), pd.to_timedelta('15 minutes')) + + time_series = time_series.copy() + time_series.index = time_series.index.tz_localize('UTC') + + with pytest.raises(ValueError): + interpolate(time_series, target_index, pd.to_timedelta('15 minutes')) + + +def test_interpolate_same_tz(time_series, target_index, expected_series): + time_series = time_series.copy() + expected_series = expected_series.copy() + + time_series.index = time_series.index.tz_localize('America/Denver') + target_index = target_index.tz_localize('America/Denver') + expected_series.index = expected_series.index.tz_localize('America/Denver') + + interpolated = interpolate(time_series, target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_series_equal(interpolated, expected_series) + + +def test_interpolate_different_tz(time_series, target_index, expected_series): + time_series = time_series.copy() + expected_series = expected_series.copy() + + time_series.index = time_series.index.tz_localize('America/Denver').tz_convert('UTC') + target_index = target_index.tz_localize('America/Denver') + expected_series.index = expected_series.index.tz_localize('America/Denver') + + interpolated = interpolate(time_series, target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_series_equal(interpolated, expected_series) + + +def test_interpolate_dataframe(test_df, df_target_index, df_expected_result): + interpolated = interpolate(test_df, df_target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.21) + pd.testing.assert_frame_equal(interpolated, df_expected_result) + + +def test_interpolate_warning(test_df, df_target_index, df_expected_result): + N = len(test_df) + all_idx = list(range(N)) + # drop every other value in the first third of the dataset + index_with_gaps = all_idx[:N//3][::2] + all_idx[N//3:] + test_df = test_df.iloc[index_with_gaps, :] + with pytest.warns(UserWarning): + interpolate(test_df, df_target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.1) + + with pytest.warns(None) as record: + interpolate(test_df, df_target_index, pd.to_timedelta('15 minutes'), + warning_threshold=0.5) + if record: + pytest.fail("normalize.interpolate raised a warning about " + "excluded data even though the threshold was high") diff --git a/rdtools/test/irradiance_rescale_test.py b/rdtools/test/irradiance_rescale_test.py new file mode 100644 index 00000000..b065dde8 --- /dev/null +++ b/rdtools/test/irradiance_rescale_test.py @@ -0,0 +1,68 @@ +import pandas as pd +from pandas.testing import assert_series_equal +from rdtools import irradiance_rescale +from rdtools.normalization import ConvergenceError +import pytest + + +@pytest.fixture +def simple_irradiance(): + times = pd.date_range('2019-06-01 12:00', freq='15T', periods=5) + time_series = pd.Series([1, 2, 3, 4, 5], index=times, dtype=float) + return time_series + + +@pytest.mark.parametrize("method", ['iterative', 'single_opt']) +def test_rescale(method, simple_irradiance): + # test basic functionality + modeled = simple_irradiance + measured = 1.05 * simple_irradiance + rescaled = irradiance_rescale(measured, modeled, method=method) + expected = measured + assert_series_equal(rescaled, expected, check_exact=False) + + +def test_max_iterations(simple_irradiance): + # use iterative method without enough iterations to converge + measured = simple_irradiance * 100 # method expects irrad > 200 + modeled = measured.copy() + modeled.iloc[2] *= 1.1 + modeled.iloc[3] *= 1.3 + modeled.iloc[4] *= 0.8 + + with pytest.raises(ConvergenceError): + _ = irradiance_rescale(measured, modeled, method='iterative', + max_iterations=2) + + _ = irradiance_rescale(measured, modeled, method='iterative', + max_iterations=10) + + +def test_max_iterations_zero(simple_irradiance): + # zero is sort of a special case, test it separately + + # test series already close enough + true_factor = 1.0 + 1e-8 + rescaled = irradiance_rescale(simple_irradiance, + simple_irradiance * true_factor, + max_iterations=0, + method='iterative') + assert_series_equal(rescaled, simple_irradiance, check_exact=False) + + # tighten threshold so that it isn't already close enough + with pytest.raises(ConvergenceError): + _ = irradiance_rescale(simple_irradiance, + simple_irradiance * true_factor, + max_iterations=0, + convergence_threshold=1e-9, + method='iterative') + + +def test_convergence_threshold(simple_irradiance): + # can't converge if threshold is negative + with pytest.raises(ConvergenceError): + _ = irradiance_rescale(simple_irradiance, + simple_irradiance * 1.05, + max_iterations=5, # reduced count for speed + convergence_threshold=-1, + method='iterative') diff --git a/rdtools/test/normalization_pvwatts_test.py b/rdtools/test/normalization_pvwatts_test.py index aea4f8dd..40d7cf1b 100644 --- a/rdtools/test/normalization_pvwatts_test.py +++ b/rdtools/test/normalization_pvwatts_test.py @@ -60,7 +60,8 @@ def test_pvwatts_dc_power(self): ''' Test PVWatts DC power caculation. ''' dc_power = pvwatts_dc_power(self.poa_global, self.power, - T_cell=self.temp, gamma_pdc=self.gamma_pdc) + temperature_cell=self.temp, + gamma_pdc=self.gamma_pdc) # Assert output has same frequency and length as input self.assertEqual(self.poa_global.index.freq, dc_power.index.freq) @@ -74,8 +75,8 @@ def test_normalization_with_pvw(self): pvw_kws = { 'poa_global': self.poa_global, - 'P_ref': self.power, - 'T_cell': self.temp, + 'power_dc_rated': self.power, + 'temperature_cell': self.temp, 'gamma_pdc': self.gamma_pdc, } @@ -86,12 +87,15 @@ def test_normalization_with_pvw(self): self.assertEqual(len(corr_energy), 12) # Test corrected energy is equal to 1.0 - self.assertTrue((corr_energy == 1.0).all()) + # first value should be nan because we have no irradiance + # data prior to the first energy point + self.assertTrue(np.isnan(corr_energy.iloc[0])) + self.assertTrue((corr_energy.iloc[1:] == 1.0).all()) # rest should be 1 # Test expected behavior when energy has no explicit frequency self.energy.index.freq = None corr_energy, insolation = normalize_with_pvwatts(self.energy, pvw_kws) - self.assertTrue(np.isnan(corr_energy.iloc[0])) # first valye should be nan + self.assertTrue(np.isnan(corr_energy.iloc[0])) # first value should be nan self.assertTrue((corr_energy.iloc[1:] == 1.0).all()) # rest should be 1 # Test for valueError when energy frequency can't be inferred diff --git a/rdtools/test/normalization_sapm_test.py b/rdtools/test/normalization_sapm_test.py index 5e272405..85c21923 100644 --- a/rdtools/test/normalization_sapm_test.py +++ b/rdtools/test/normalization_sapm_test.py @@ -31,7 +31,7 @@ def setUp(self): module_parameters = { 'pdc0': 2.1, 'gamma_pdc': -0.0045 - } + } # define location test_location = pvlib.location\ @@ -43,7 +43,8 @@ def setUp(self): surface_azimuth=180, module=module, module_parameters=module_parameters, - racking_model='insulated_back_polymerback', + racking_model='insulated_back', + module_type='glass_polymer', modules_per_string=6) # define dummy energy data @@ -60,12 +61,8 @@ def setUp(self): # define dummy meteorological data irrad_columns = ['DNI', 'GHI', 'DHI', 'Temperature', 'Wind Speed'] irrad_freq = 'D' - irrad_periods = 31 * energy_periods - irrad_index = pd.date_range(start='2012-01-01', - periods=irrad_periods, - freq=irrad_freq) - irrad_index = pd.date_range(start='2012-01-01', - periods=irrad_periods, + irrad_index = pd.date_range(start=energy_index[0], + end=energy_index[-1] - pd.to_timedelta('1 nanosecond'), freq=irrad_freq) self.irrad = pd.DataFrame([[100, 45, 30, 25, 10]], index=irrad_index, diff --git a/rdtools/test/normalize_with_expected_power_test.py b/rdtools/test/normalize_with_expected_power_test.py new file mode 100644 index 00000000..70d82588 --- /dev/null +++ b/rdtools/test/normalize_with_expected_power_test.py @@ -0,0 +1,152 @@ +import pandas as pd +import pytest +from rdtools.normalization import normalize_with_expected_power +from pandas import Timestamp +import numpy as np + + +@pytest.fixture() +def times_15(): + return pd.date_range(start='20200101 12:00', end='20200101 13:00', freq='15T') + + +@pytest.fixture() +def times_30(): + return pd.date_range(start='20200101 12:00', end='20200101 13:00', freq='30T') + + +@pytest.fixture() +def pv_15(times_15): + return pd.Series([1.0, 2.5, 3.0, 2.2, 2.1], index=times_15) + + +@pytest.fixture() +def expected_15(times_15): + return pd.Series([1.2, 2.3, 2.8, 2.1, 2.0], index=times_15) + + +@pytest.fixture() +def irradiance_15(times_15): + return pd.Series([1000.0, 850.0, 950.0, 975.0, 890.0], index=times_15) + + +@pytest.fixture() +def pv_30(times_30): + return pd.Series([1.0, 3.0, 2.1], index=times_30) + + +@pytest.fixture() +def expected_30(times_30): + return pd.Series([1.2, 2.8, 2.0], index=times_30) + + +@pytest.fixture() +def irradiance_30(times_30): + return pd.Series([1000.0, 950.0, 890.0], index=times_30) + + +def test_normalize_with_expected_power_uniform_frequency(pv_15, expected_15, irradiance_15): + norm, insol = normalize_with_expected_power( + pv_15, expected_15, irradiance_15) + expected_norm = pd.Series( + {Timestamp('2020-01-01 12:15:00', freq='15T'): 1.0, + Timestamp('2020-01-01 12:30:00', freq='15T'): 1.0784313725490198, + Timestamp('2020-01-01 12:45:00', freq='15T'): 1.0612244897959184, + Timestamp('2020-01-01 13:00:00', freq='15T'): 1.0487804878048783} + ) + expected_norm.name = 'energy_Wh' + expected_norm.index.freq = '15T' + + expected_insol = pd.Series( + {Timestamp('2020-01-01 12:15:00', freq='15T'): 231.25, + Timestamp('2020-01-01 12:30:00', freq='15T'): 225.0, + Timestamp('2020-01-01 12:45:00', freq='15T'): 240.625, + Timestamp('2020-01-01 13:00:00', freq='15T'): 233.125} + ) + + expected_insol.name = 'energy_Wh' + expected_insol.index.freq = '15T' + + pd.testing.assert_series_equal(norm, expected_norm) + pd.testing.assert_series_equal(insol, expected_insol) + + +def test_normalize_with_expected_power_energy_option(pv_15, expected_15, irradiance_15): + norm, insol = normalize_with_expected_power( + pv_15, expected_15, irradiance_15, pv_input='energy') + expected_norm = pd.Series( + {Timestamp('2020-01-01 12:00:00', freq='15T'): np.nan, + Timestamp('2020-01-01 12:15:00', freq='15T'): 5.714285714285714, + Timestamp('2020-01-01 12:30:00', freq='15T'): 4.705882352941177, + Timestamp('2020-01-01 12:45:00', freq='15T'): 3.5918367346938775, + Timestamp('2020-01-01 13:00:00', freq='15T'): 4.097560975609756} + ) + + expected_norm.name = 'energy_Wh' + expected_norm.index.freq = '15T' + + expected_insol = pd.Series( + {Timestamp('2020-01-01 12:00:00', freq='15T'): np.nan, + Timestamp('2020-01-01 12:15:00', freq='15T'): 231.25, + Timestamp('2020-01-01 12:30:00', freq='15T'): 225.0, + Timestamp('2020-01-01 12:45:00', freq='15T'): 240.625, + Timestamp('2020-01-01 13:00:00', freq='15T'): 233.125} + ) + + expected_insol.name = 'energy_Wh' + expected_insol.index.freq = '15T' + + pd.testing.assert_series_equal(norm, expected_norm) + pd.testing.assert_series_equal(insol, expected_insol) + + +def test_normalize_with_expected_power_low_freq_pv(pv_30, expected_15, irradiance_15): + norm, insol = normalize_with_expected_power( + pv_30, expected_15, irradiance_15) + + expected_norm = pd.Series( + {Timestamp('2020-01-01 12:30:00', freq='30T'): 0.9302325581395349, + Timestamp('2020-01-01 13:00:00', freq='30T'): 1.1333333333333333} + ) + + expected_norm.name = 'energy_Wh' + expected_norm.index.freq = '30T' + + expected_insol = pd.Series( + {Timestamp('2020-01-01 12:30:00', freq='30T'): 456.25, + Timestamp('2020-01-01 13:00:00', freq='30T'): 473.75} + ) + + expected_insol.name = 'energy_Wh' + expected_insol.index.freq = '30T' + + pd.testing.assert_series_equal(norm, expected_norm) + pd.testing.assert_series_equal(insol, expected_insol) + + +def test_normalized_with_expected_power_low_freq_expected(pv_15, expected_30, irradiance_30): + norm, insol = normalize_with_expected_power( + pv_15, expected_30, irradiance_30) + + expected_norm = pd.Series( + {Timestamp('2020-01-01 12:15:00', freq='15T'): 1.09375, + Timestamp('2020-01-01 12:30:00', freq='15T'): 1.1458333333333335, + Timestamp('2020-01-01 12:45:00', freq='15T'): 1.0000000000000002, + Timestamp('2020-01-01 13:00:00', freq='15T'): 0.9772727272727274} + ) + + expected_norm.name = 'energy_Wh' + expected_norm.index.freq = '15T' + + expected_insol = pd.Series( + {Timestamp('2020-01-01 12:15:00', freq='15T'): 246.875, + Timestamp('2020-01-01 12:30:00', freq='15T'): 240.625, + Timestamp('2020-01-01 12:45:00', freq='15T'): 233.75, + Timestamp('2020-01-01 13:00:00', freq='15T'): 226.25} + ) + + expected_insol.name = 'energy_Wh' + expected_insol.index.freq = '15T' + + pd.testing.assert_series_equal(norm, expected_norm) + pd.testing.assert_series_equal(insol, expected_insol) diff --git a/rdtools/test/plotting_test.py b/rdtools/test/plotting_test.py new file mode 100644 index 00000000..5da59f41 --- /dev/null +++ b/rdtools/test/plotting_test.py @@ -0,0 +1,164 @@ +import pandas as pd +import numpy as np +from rdtools.degradation import degradation_year_on_year +from rdtools.soiling import soiling_srr +from rdtools.plotting import ( + degradation_summary_plots, + soiling_monte_carlo_plot, + soiling_interval_plot, + soiling_rate_histogram +) +import matplotlib.pyplot as plt +import pytest + +# bring in soiling pytest fixtures +from soiling_test import ( + times, # can't rename this or else the others can't find it + normalized_daily as soiling_normalized_daily, + insolation as soiling_insolation, +) + + +def assert_isinstance(obj, klass): + assert isinstance(obj, klass), f'got {type(obj)}, expected {klass}' + + +# can't import degradation fixtures because it's a unittest file. +# roll our own here instead: +@pytest.fixture() +def degradation_power_signal(): + ''' Returns a clean offset sinusoidal with exponential degradation ''' + idx = pd.date_range('2017-01-01', '2020-01-01', freq='d', tz='UTC') + annual_rd = -0.005 + daily_rd = 1 - (1 - annual_rd)**(1/365) + day_count = np.arange(0, len(idx)) + degradation_derate = (1 + daily_rd) ** day_count + + power = 1 - 0.1*np.cos(day_count/365 * 2*np.pi) + power *= degradation_derate + power = pd.Series(power, index=idx) + return power + + +@pytest.fixture() +def degradation_info(degradation_power_signal): + ''' + Return results of running YoY degradation on raw power. + + Note: no normalization needed since power is ~(1.0 + seasonality + deg) + + Returns + ------- + power_signal : pd.Series + degradation_rate : float + confidence_interval : np.array of length 2 + calc_info : dict with keys: + ['YoY_values', 'renormalizing_factor', 'exceedance_level'] + ''' + rd, rd_ci, calc_info = degradation_year_on_year(degradation_power_signal) + return degradation_power_signal, rd, rd_ci, calc_info + + +def test_degradation_summary_plots(degradation_info): + power, yoy_rd, yoy_ci, yoy_info = degradation_info + + # test defaults + result = degradation_summary_plots(yoy_rd, yoy_ci, yoy_info, power) + assert_isinstance(result, plt.Figure) + + +def test_degradation_summary_plots_kwargs(degradation_info): + power, yoy_rd, yoy_ci, yoy_info = degradation_info + + # test kwargs + kwargs = dict( + hist_xmin=-1, + hist_xmax=1, + bins=100, + scatter_ymin=0, + scatter_ymax=1, + plot_color='g', + summary_title='test', + scatter_alpha=1.0, + ) + result = degradation_summary_plots(yoy_rd, yoy_ci, yoy_info, power, + **kwargs) + assert_isinstance(result, plt.Figure) + + +@pytest.fixture() +def soiling_info(soiling_normalized_daily, soiling_insolation): + ''' + Return results of running soiling_srr. + + Returns + ------- + calc_info : dict with keys: + ['renormalizing_factor', 'exceedance_level', + 'stochastic_soiling_profiles', 'soiling_interval_summary', + 'soiling_ratio_perfect_clean'] + ''' + reps = 10 + np.random.seed(1977) + sr, sr_ci, calc_info = soiling_srr(soiling_normalized_daily, + soiling_insolation, + reps=reps) + return calc_info + + +def test_soiling_monte_carlo_plot(soiling_normalized_daily, soiling_info): + # test defaults + result = soiling_monte_carlo_plot(soiling_info, soiling_normalized_daily) + assert_isinstance(result, plt.Figure) + + +def test_soiling_monte_carlo_plot_kwargs(soiling_normalized_daily, soiling_info): + # test kwargs + kwargs = dict( + point_alpha=0.1, + profile_alpha=0.4, + ymin=0, + ymax=1, + profiles=5, + point_color='k', + profile_color='b', + ) + result = soiling_monte_carlo_plot(soiling_info, soiling_normalized_daily, + **kwargs) + assert_isinstance(result, plt.Figure) + + +def test_soiling_interval_plot(soiling_normalized_daily, soiling_info): + # test defaults + result = soiling_interval_plot(soiling_info, soiling_normalized_daily) + assert_isinstance(result, plt.Figure) + + +def test_soiling_interval_plot_kwargs(soiling_normalized_daily, soiling_info): + # test kwargs + kwargs = dict( + point_alpha=0.1, + profile_alpha=0.5, + ymin=0, + ymax=1, + point_color='k', + profile_color='g', + ) + result = soiling_interval_plot(soiling_info, soiling_normalized_daily, + **kwargs) + assert_isinstance(result, plt.Figure) + + +def test_soiling_rate_histogram(soiling_info): + # test defaults + result = soiling_rate_histogram(soiling_info) + assert_isinstance(result, plt.Figure) + + +def test_soiling_rate_histogram_kwargs(soiling_info): + # test kwargs + kwargs = dict( + bins=10, + ) + result = soiling_rate_histogram(soiling_info, **kwargs) + assert_isinstance(result, plt.Figure) diff --git a/rdtools/test/soiling_test.py b/rdtools/test/soiling_test.py new file mode 100644 index 00000000..e194861a --- /dev/null +++ b/rdtools/test/soiling_test.py @@ -0,0 +1,226 @@ +import pandas as pd +import numpy as np +from rdtools import soiling_srr +from rdtools.soiling import NoValidIntervalError +import pytest + + +@pytest.fixture() +def times(): + tz = 'Etc/GMT+7' + times = pd.date_range('2019/01/01', '2019/03/16', freq='D', tz=tz) + return times + + +@pytest.fixture() +def normalized_daily(times): + interval_1 = 1 - 0.005 * np.arange(0, 25, 1) + interval_2 = 1 - 0.002 * np.arange(0, 25, 1) + interval_3 = 1 - 0.001 * np.arange(0, 25, 1) + profile = np.concatenate((interval_1, interval_2, interval_3)) + np.random.seed(1977) + noise = 0.01 * np.random.rand(75) + normalized_daily = pd.Series(data=profile, index=times) + normalized_daily = normalized_daily + noise + + return normalized_daily + + +@pytest.fixture() +def insolation(times): + insolation = np.empty((75,)) + insolation[:30] = 8000 + insolation[30:45] = 6000 + insolation[45:] = 7000 + + insolation = pd.Series(data=insolation, index=times) + + return insolation + + +def test_soiling_srr(normalized_daily, insolation, times): + + reps = 10 + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=reps) + assert 0.963133 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio different from expected value' + assert np.array([0.961054, 0.964019]) == pytest.approx(sr_ci, abs=1e-6),\ + 'Confidence interval different from expected value' + assert 0.958292 == pytest.approx(soiling_info['exceedance_level'], abs=1e-6),\ + 'Exceedance level different from expected value' + assert 0.984079 == pytest.approx(soiling_info['renormalizing_factor'], abs=1e-6),\ + 'Renormalizing factor different from expected value' + assert len(soiling_info['stochastic_soiling_profiles']) == reps,\ + 'Length of soiling_info["stochastic_soiling_profiles"] different than expected' + assert isinstance(soiling_info['stochastic_soiling_profiles'], list),\ + 'soiling_info["stochastic_soiling_profiles"] is not a list' + + # Check soiling_info['soiling_interval_summary'] + expected_summary_columns = ['start', 'end', 'slope', 'slope_low', 'slope_high', + 'inferred_start_loss', 'inferred_end_loss', 'length', 'valid'] + actual_summary_columns = soiling_info['soiling_interval_summary'].columns.values + + for x in actual_summary_columns: + assert x in expected_summary_columns,\ + "'{}' not an expected column in soiling_info['soiling_interval_summary']".format(x) + for x in expected_summary_columns: + assert x in actual_summary_columns,\ + "'{}' was expected as a column, but not in soiling_info['soiling_interval_summary']".format(x) + assert isinstance(soiling_info['soiling_interval_summary'], pd.DataFrame),\ + 'soiling_info["soiling_interval_summary"] not a dataframe' + expected_means = pd.Series({'slope': -0.002617290, + 'slope_low': -0.002828525, + 'slope_high': -0.002396639, + 'inferred_start_loss': 1.021514, + 'inferred_end_loss': 0.9572880, + 'length': 24.0, + 'valid': 1.0}) + expected_means = expected_means[['slope', 'slope_low', 'slope_high', + 'inferred_start_loss', 'inferred_end_loss', + 'length', 'valid']] + pd.testing.assert_series_equal(expected_means, soiling_info['soiling_interval_summary'].mean(), + check_exact=False, check_less_precise=6) + + # Check soiling_info['soiling_ratio_perfect_clean'] + pd.testing.assert_index_equal(soiling_info['soiling_ratio_perfect_clean'].index, times, check_names=False) + assert 0.967170 == pytest.approx(soiling_info['soiling_ratio_perfect_clean'].mean(), abs=1e-6),\ + "The mean of soiling_info['soiling_ratio_perfect_clean'] differs from expected" + assert isinstance(soiling_info['soiling_ratio_perfect_clean'], pd.Series),\ + 'soiling_info["soiling_ratio_perfect_clean"] not a pandas series' + + +def test_soiling_srr_with_precip(normalized_daily, insolation, times): + precip = pd.Series(index=times, data=0) + precip['2019-01-18 00:00:00-07:00'] = 1 + precip['2019-02-20 00:00:00-07:00'] = 1 + + kwargs = { + 'reps': 10, + 'precipitation_daily': precip + } + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, clean_criterion='precip_and_shift', **kwargs) + assert 0.983270 == pytest.approx(sr, abs=1e-6),\ + "Soiling ratio with clean_criterion='precip_and_shift' different from expected" + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, clean_criterion='precip_or_shift', **kwargs) + assert 0.973228 == pytest.approx(sr, abs=1e-6),\ + "Soiling ratio with clean_criterion='precip_or_shift' different from expected" + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, clean_criterion='precip', **kwargs) + assert 0.976196 == pytest.approx(sr, abs=1e-6),\ + "Soiling ratio with clean_criterion='precip' different from expected" + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, clean_criterion='shift', **kwargs) + assert 0.963133 == pytest.approx(sr, abs=1e-6),\ + "Soiling ratio with clean_criterion='shift' different from expected" + + +def test_soiling_srr_confidence_levels(normalized_daily, insolation): + 'Tests SRR with different confidence level settingsf from above' + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, confidence_level=95, reps=10, + exceedance_prob=80.0) + assert np.array([0.957272, 0.964763]) == pytest.approx(sr_ci, abs=1e-6),\ + 'Confidence interval with confidence_level=95 different than expected' + assert 0.961285 == pytest.approx(soiling_info['exceedance_level'], abs=1e-6),\ + 'soiling_info["exceedance_level"] different than expected when exceedance_prob=80' + + +def test_soiling_srr_dayscale(normalized_daily, insolation): + 'Test that a long dayscale can prevent valid intervals from being found' + with pytest.raises(NoValidIntervalError): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, confidence_level=68.2, + reps=10, day_scale=90) + + +def test_soiling_srr_clean_threshold(normalized_daily, insolation): + '''Test that clean test_soiling_srr_clean_threshold works with a float and + can cause no soiling intervals to be found''' + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + clean_threshold=0.01) + assert 0.963133 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio with specified clean_threshold different from expected value' + + with pytest.raises(NoValidIntervalError): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + clean_threshold=0.1) + + +def test_soiling_srr_trim(normalized_daily, insolation): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + trim=True) + + assert 0.978369 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio with trim=True different from expected value' + assert len(soiling_info['soiling_interval_summary']) == 1,\ + 'Wrong number of soiling intervals found with trim=True' + + +def test_soiling_srr_method(normalized_daily, insolation): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + method='random_clean') + assert 0.918767 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio with method="random_clean" different from expected value' + + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + method='perfect_clean') + assert 0.965653 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio with method="perfect_clean" different from expected value' + + +def test_soiling_srr_recenter_false(normalized_daily, insolation): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + recenter=False) + assert 1 == soiling_info['renormalizing_factor'],\ + 'Renormalizing factor != 1 with recenter=False' + assert 0.965158 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio different than expected when recenter=False' + + +def test_soiling_srr_negative_step(normalized_daily, insolation): + stepped_daily = normalized_daily.copy() + stepped_daily.iloc[37:] = stepped_daily.iloc[25:] - 0.1 + + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(stepped_daily, insolation, reps=10) + + assert list(soiling_info['soiling_interval_summary']['valid'].values) == [True, False, True],\ + 'Soiling interval validity differs from expected when a large negative step\ + is incorporated into the data' + + assert 0.934927 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio different from expected when a large negative step is incorporated into the data' + + +def test_soiling_srr_max_negative_slope_error(normalized_daily, insolation): + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_daily, insolation, reps=10, + max_relative_slope_error=50.0) + + assert list(soiling_info['soiling_interval_summary']['valid'].values) == [True, True, False],\ + 'Soiling interval validity differs from expected when max_relative_slope_error=50.0' + + assert 0.952995 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio different from expected when max_relative_slope_error=50.0' + +def test_soiling_srr_with_nan_interval(normalized_daily, insolation, times): + ''' + Previous versions had a bug which would have raised an error when an entire interval + was NaN. See https://github.com/NREL/rdtools/issues/129 + ''' + reps = 10 + normalized_corrupt = normalized_daily.copy() + normalized_corrupt[26:50] = np.nan + np.random.seed(1977) + sr, sr_ci, soiling_info = soiling_srr(normalized_corrupt, insolation, reps=reps) + assert 0.947416 == pytest.approx(sr, abs=1e-6),\ + 'Soiling ratio different from expected value when an entire interval was NaN' diff --git a/requirements.txt b/requirements.txt index ddaf7ce0..9344820c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,10 +1,17 @@ +cycler==0.10.0 h5py==2.10.0 -numpy==1.16.6 -patsy==0.5.0 -pandas==0.23.4 -pvlib==0.5.2 -python-dateutil==2.7.3 -pytz==2018.5 -scipy==1.2.3 -six==1.11.0 -statsmodels==0.10.0 +kiwisolver==1.2.0 +matplotlib==3.1.2 +nbsphinx==0.4.3 +nbsphinx-link==1.3.0 +numpy==1.17.3 +pandas==1.0.3 +patsy==0.5.1 +pvlib==0.7.1 +pyparsing==2.4.7 +python-dateutil==2.8.1 +pytz==2019.3 +scipy==1.3.2 +six==1.14.0 +sphinx-rtd-theme==0.4.3 +statsmodels==0.11.1 \ No newline at end of file diff --git a/setup.py b/setup.py index 231afd92..7956cd16 100755 --- a/setup.py +++ b/setup.py @@ -9,10 +9,12 @@ import versioneer -DESCRIPTION = 'Functions for analyzing the degradation of photovoltaic systems.' +DESCRIPTION = 'Functions for reproducible timeseries analysis of photovoltaic systems.' LONG_DESCRIPTION = """ -Rdtools is a collection of tools for the analysis of photovoltaic degradation. +RdTools is an open-source library to support reproducible technical analysis of +PV time series data. The library aims to provide best practice analysis +routines along with the building blocks for users to tailor their own analyses. Source code: https://github.com/NREL/rdtools """ @@ -34,24 +36,43 @@ ] INSTALL_REQUIRES = [ + 'matplotlib >= 2.2.2', 'numpy >= 1.12', - 'pandas >= 0.23.0, <1.0.0', + 'pandas >= 0.23.0,!=1.0.0,!=1.0.1', # exclude 1.0.0 & 1.0.1 for GH142 'statsmodels >= 0.8.0', 'scipy >= 0.19.1', 'h5py >= 2.7.1', - 'pvlib >= 0.5.0, <0.6.0', + 'pvlib >= 0.7.0, <0.8.0', ] +EXTRAS_REQUIRE = { + 'doc': [ + 'sphinx==1.8.5', + 'nbsphinx==0.4.3', + 'nbsphinx-link==1.3.0', + 'pandas==0.23.0', + 'pvlib==0.7.1', + 'sphinx_rtd_theme==0.4.3', + 'ipython', + ], + 'test': [ + 'pytest', + 'coverage', + ] +} +EXTRAS_REQUIRE['all'] = sorted(set(sum(EXTRAS_REQUIRE.values(), []))) + + CLASSIFIERS = [ - 'Development Status :: 4 - Beta', + 'Development Status :: 5 - Production/Stable', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Intended Audience :: Science/Research', 'Programming Language :: Python', - 'Programming Language :: Python :: 2', - 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.6', + 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', 'Topic :: Scientific/Engineering', ] @@ -83,6 +104,7 @@ setup_requires=SETUP_REQUIRES, tests_require=TESTS_REQUIRE, install_requires=INSTALL_REQUIRES, + extras_require=EXTRAS_REQUIRE, description=DESCRIPTION, long_description=LONG_DESCRIPTION, author=AUTHOR,