diff --git a/pvdeg/__init__.py b/pvdeg/__init__.py
index 0b770fc..adf1fa4 100644
--- a/pvdeg/__init__.py
+++ b/pvdeg/__init__.py
@@ -14,6 +14,7 @@
from . import montecarlo
from .scenario import Scenario, GeospatialScenario
from . import spectral
+from . import store
from . import symbolic
from . import standards
from . import temperature
diff --git a/pvdeg/config.py b/pvdeg/config.py
index d40706a..14afbf3 100644
--- a/pvdeg/config.py
+++ b/pvdeg/config.py
@@ -11,6 +11,9 @@
DATA_DIR = PVDEG_DIR / "data"
TEST_DIR = PVDEG_DIR.parent / "tests"
TEST_DATA_DIR = PVDEG_DIR.parent / "tests" / "data"
+
+# downloader target directory
+METOROLOGICAL_DOWNLOAD_PATH = Path.home() / "PVDeg-Meteorological"
# DATA_LIBRARY = PVDEG_DIR.parent / "DataLibrary"
# if not os.path.isdir(DATA_LIBRARY):
diff --git a/pvdeg/store.py b/pvdeg/store.py
new file mode 100644
index 0000000..518d8ba
--- /dev/null
+++ b/pvdeg/store.py
@@ -0,0 +1,185 @@
+from pathlib import Path
+import xarray as xr
+import pandas as pd
+import numpy as np
+import zarr
+import os
+
+from pvdeg import METOROLOGICAL_DOWNLOAD_PATH
+
+def get(group):
+ """
+ Extract a weather xarray dataset and metadata pandas dataframe from your zarr store.
+ `get` pulls the entire datastore into these objects. PVDeg does not make indexing available at this stage.
+ This is practical because all datavariables are stored in dask arrays so they are loaded lazily instead of into memmory when this is called.
+ Choose the points you need after this method is called by using `sel`, `isel`, `loc, `iloc`.
+
+ `store.get` is meant to match the API of other geospatial weather api's from pvdeg like `pvdeg.weather.get`, `pvdeg.weather.distributed_weather`, `GeospatialScenario.get_geospatial_data`
+
+ Parameters
+ -----------
+ group : str
+ name of the group to access from your local zarr store.
+ Groups are created automatically in your store when you save data using `pvdeg.store.store`.
+
+ *From `pvdeg.store.store` docstring*
+ Hourly PVGIS data will be saved to "PVGIS-1hr", 30 minute PVGIS to "PVGIS-30min", similarly 15 minute PVGIS will be saved to "PVGIS-15min"
+
+ Returns
+ -------
+ weather_ds : xr.Dataset
+ Weather data for all locations requested in an xarray.Dataset using a dask array backend. This may be larger than memory.
+ meta_df : pd.DataFrame
+ Pandas DataFrame containing metadata for all requested locations. Each row maps to a single entry in the weather_ds.
+ """
+
+ combined_ds = xr.open_zarr(
+ store=METOROLOGICAL_DOWNLOAD_PATH,
+ group=group
+ )
+
+ weather_ds, meta_df = _seperate_geo_weather_meta(ds_from_zarr=combined_ds)
+
+ return weather_ds, meta_df
+
+def store(weather_ds, meta_df):
+ """
+ Add geospatial meteorolical data to your zarr store. Data will be saved to the correct group based on its periodicity.
+
+ Hourly PVGIS data will be saved to "PVGIS-1hr", 30 minute PVGIS to "PVGIS-30min", similarly 15 minute PVGIS will be saved to "PVGIS-15min"
+
+ Parameters
+ -----------
+ weather_ds : xr.Dataset
+ Weather data for all locations requested in an xarray.Dataset using a dask array backend. This may be larger than memory.
+ meta_df : pd.DataFrame
+ Pandas DataFrame containing metadata for all requested locations. Each row maps to a single entry in the weather_ds.
+
+ Returns
+ --------
+ None
+ """
+
+ group = meta_df.iloc[0]["Source"]
+ rows_per_entry = weather_ds.isel(gid=0).time.size
+
+ if rows_per_entry == 8760:
+ periodicity = "1hr"
+ elif rows_per_entry == 17520:
+ periodicity = "30min"
+ elif rows_per_entry == 35040:
+ periodicity = "15min"
+ else:
+ raise ValueError(f"first location to store has {rows_per_entry} rows, must have 8670, 17520, 35040 rows")
+
+ combined_ds = _combine_geo_weather_meta(weather_ds, meta_df)
+
+ # what mode should this be
+ # we want to add to indexes if need be or overwrite old ones
+ combined_ds.to_zarr(
+ store=METOROLOGICAL_DOWNLOAD_PATH,
+ group=f"{group}-{periodicity}"
+ )
+
+ print(f"dataset saved to zarr store at {METOROLOGICAL_DOWNLOAD_PATH}")
+
+
+
+def check_store():
+ """Check if you have a zarr store at the default download path defined in pvdeg.config"""
+ if os.path.exists(os.path.join(METOROLOGICAL_DOWNLOAD_PATH, ".zattrs")):
+
+ size = sum(f.stat().st_size for f in METOROLOGICAL_DOWNLOAD_PATH.glob('**/*') if f.is_file())
+
+ print(f"""
+ You have a zarr store at {METOROLOGICAL_DOWNLOAD_PATH}.
+
+ It has {size} bytes.
+ """)
+
+ elif os.path.exists(METOROLOGICAL_DOWNLOAD_PATH):
+ print(f"You have a directory but no zarr store at {METOROLOGICAL_DOWNLOAD_PATH}")
+
+ else:
+ raise FileNotFoundError(f"No Directory exists at {METOROLOGICAL_DOWNLOAD_PATH}. Data has not been saved here.")
+
+
+def my_path():
+ """Finds path to your zarr store of data if it exists"""
+ if os.path.exists(os.path.join(METOROLOGICAL_DOWNLOAD_PATH, ".zattrs")):
+ print(METOROLOGICAL_DOWNLOAD_PATH)
+
+ else:
+ print("Directory not found")
+
+def _combine_geo_weather_meta(
+ weather_ds: xr.Dataset,
+ meta_df: pd.DataFrame
+ ):
+ """Combine weather dataset and meta dataframe into a single dataset"""
+
+ meta_ds = xr.Dataset.from_dataframe(meta_df)
+ # we could do some encoding scheme here, dont need to store source? unless the zarr compression handles it for us
+
+ meta_ds['gid'] = meta_ds['index'].values.astype(np.int32)
+ meta_ds = meta_ds.drop_vars(["index"])
+
+ combined = xr.merge([weather_ds, meta_ds]).assign_coords(
+ latitude=("gid", meta_ds.latitude.values),
+ longitude=('gid', meta_ds.longitude.values),
+ )
+
+ return combined
+
+
+def _seperate_geo_weather_meta(
+ ds_from_zarr: xr.Dataset,
+):
+ """
+ Take loaded dataset in the zarr store schema (weather and meta combined)
+ and seperate it into `weather_ds` and `meta_df`.
+ """
+
+ # there may be a more optimal way to do this
+ data = np.column_stack(
+ [
+ ds_from_zarr.gid.to_numpy(),
+ ds_from_zarr.latitude.to_numpy(),
+ ds_from_zarr.longitude.to_numpy(),
+ ds_from_zarr.altitude.to_numpy(),
+ ds_from_zarr.Source.to_numpy(),
+ ds_from_zarr.wind_height.to_numpy(),
+ ]
+ )
+
+ seperated_meta_df = pd.DataFrame(data, columns=["gid", "latitude", "longitude", "altitude", "Source", "wind_height"]).set_index("gid")
+
+ seperated_weather_ds = ds_from_zarr.drop_vars(("latitude", "longitude", "altitude", "Source", "wind_height"))
+
+ return seperated_weather_ds, seperated_meta_df
+
+def _make_coords_to_gid_da(
+ ds_from_zarr: xr.Dataset
+ ):
+ """Create a 2D indexable array that maps coordinates (lat and lon) to gid stored in zarr store"""
+
+ import dask.array as da
+
+ # only want to do this if the arrays are dask arrays
+ lats = ds_from_zarr.latitude.to_numpy()
+ lons = ds_from_zarr.longitude.to_numpy()
+
+ gids = -1 * da.empty((len(lats), len(lons)))
+
+ points = xr.DataArray(
+ data=gids,
+ coords={
+ "latitude": lats,
+ "longitude": lons
+ },
+ dims=["latitude", "longitude"],
+ )
+
+ points.set_index(latitude="latitude", longitude="longitude")
+
+ return points
\ No newline at end of file
diff --git a/pvdeg/weather.py b/pvdeg/weather.py
index 91b1e42..59f7365 100644
--- a/pvdeg/weather.py
+++ b/pvdeg/weather.py
@@ -1014,13 +1014,20 @@ def pvgis_empty_weather_ds(gids_size):
return weather_ds
+# add some check to see if a dask client exists
+# can force user to pass dask client to ensure it exists
+
+# if called without dask client we will return a xr.Dataset
+# with dask backend that does not appear as if it failed until we compute it
def weather_distributed(database, coords):
"""
Grab weather using pvgis for all of the following locations using dask for parallelization.
- You must create a dask client with multiple processes before calling this function, otherwise no speedup will be offered.
+ You must create a dask client with multiple processes before calling this function, otherwise results will not be properly calculated.
PVGIS supports up to 30 requests per second so your dask client should not have more than $x$ workers/threads
that would put you over this limit.
+
+ With eventual NSRDB implementation API keys will be an issue, each key is rate limited.
Parameters
----------
diff --git a/scripts/load_pvgis_distributed.ipynb b/scripts/load_pvgis_distributed.ipynb
index 447e56a..5dc552e 100644
--- a/scripts/load_pvgis_distributed.ipynb
+++ b/scripts/load_pvgis_distributed.ipynb
@@ -46,27 +46,9 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": null,
"metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\Users\\tford\\AppData\\Local\\miniconda3\\envs\\deg\\lib\\site-packages\\distributed\\node.py:182: UserWarning: Port 8787 is already in use.\n",
- "Perhaps you already have a cluster running?\n",
- "Hosting the HTTP server on port 60223 instead\n",
- " warnings.warn(\n"
- ]
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "http://127.0.0.1:60223/status\n"
- ]
- }
- ],
+ "outputs": [],
"source": [
"workers = 4\n",
"\n",
@@ -94,21 +76,88 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "weather_ds.compute()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Saving Geospatial Data Locally\n",
+ "\n",
+ "The goal of `pvdeg.store` is to create a living local database of meteoroligical data that grows overtime as your geospatial data needs grow. To do this `PVDeg` will save to a folder called `PVDeg-Meteorological` your user home directory. For me this is located at `C:\\Users\\tford\\PVDeg-Meteorological`. This directory will contain a `zarr` store, this is a popular format for storing multi-dimensional array data, not dissimilar to `h5` files. It was chosen over `h5` because `zarr` stores arrays in chunked compressed files that make access very easy without opening an entire file like `h5`. This is an oversimplification of the design process but we felt `zarr` was a better fit.\n",
+ "\n",
+ "## Store\n",
+ "\n",
+ "We can use `pvdeg.store.store` to save geospatial data to our living dataset in the common form provided by `pvdeg`. The data is stored in various groups and subfolders but they will be arranged based on the *source* and *periodicity*.\n",
+ "\n",
+ "For example: \n",
+ " - Hourly PVGIS data will be saved to a group called \"PVGIS-1hr\" \n",
+ " - 30 minute PVGIS to a group called \"PVGIS-30min\" \n",
+ " - 15 minute PVGIS will be saved to a group called \"PVGIS-15min\" "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "pvdeg.store.store(weather_ds, meta_df)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Load\n",
+ "\n",
+ "`PVDeg` makes use of `dask` to handle larger than memory datasets. Trandionally, this was only useful in our HPC environment but as your local database grows overtime, it will eventually surpass the limits of your computer's volatile memory. Additionally, `dask` allows us to parallelize geospatial calculations via `pvdeg.geospatial.analysis`. This ability can be utilized on local machines or HPC clusters alike. \n",
+ "\n",
+ "`PVDeg` implements the ability to access your local living database via `pvdeg.store.get`. This method takes a string called `group`. Groups are created automatically in your store when you save data using `pvdeg.store.store`. As described in the `pvdeg.store.store` docstring and the *Store* section above, NSRDB will follow a similar scheme but it not implemented yet. \n",
+ " - Hourly PVGIS data will be saved to a group called \"PVGIS-1hr\" \n",
+ " - 30 minute PVGIS to a group called \"PVGIS-30min\" \n",
+ " - 15 minute PVGIS will be saved to a group called \"PVGIS-15min\" "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Load PVGIS-1hr Data\n",
+ "\n",
+ "The example below shows us loading the hourly tmy data from PVGIS that we gathered and saved to our zarr store in the above cells. This gets us the form of a weather xarray.Dataset (`geo_weather` in this example) and a metadata dataframe (`geo_meta` in this example).\n",
+ "\n",
+ "These can be treated like any other geospatial data shown in the `pvdeg` tutorials and tools or documentation."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "geo_weather, geo_meta = pvdeg.store.get(group=\"PVGIS-1hr\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Inspecting the Results\n",
+ "\n",
+ "explain *.compute() here*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
"metadata": {},
"outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "c:\\Users\\tford\\AppData\\Local\\miniconda3\\envs\\deg\\lib\\site-packages\\distributed\\client.py:3362: UserWarning: Sending large graph of size 13.27 MiB.\n",
- "This may cause some slowdown.\n",
- "Consider loading the data with Dask directly\n",
- " or using futures or delayed objects to embed the data into the graph without repetition.\n",
- "See also https://docs.dask.org/en/stable/best-practices.html#load-data-with-dask for more information.\n",
- " warnings.warn(\n"
- ]
- },
{
"data": {
"text/html": [
@@ -479,76 +528,519 @@
"
<xarray.Dataset> Size: 14MB\n",
"Dimensions: (gid: 22, time: 8760)\n",
"Coordinates:\n",
- " * time (time) datetime64[ns] 70kB 2022-01-01 ... 2022-12-31T2...\n",
" * gid (gid) int32 88B 0 1 2 3 4 5 6 7 ... 15 16 17 18 19 20 21\n",
+ " * time (time) datetime64[ns] 70kB 2022-01-01 ... 2022-12-31T2...\n",
"Data variables:\n",
- " temp_air (gid, time) float64 2MB 4.11 4.7 5.28 ... 0.35 0.37 0.38\n",
- " relative_humidity (gid, time) float64 2MB 87.27 87.03 86.79 ... 86.37 86.14\n",
- " ghi (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " dni (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " dhi (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " IR(h) (gid, time) float64 2MB 314.4 317.4 320.4 ... 271.9 274.1\n",
- " wind_speed (gid, time) float64 2MB 3.11 3.1 3.08 ... 3.53 3.45 3.37\n",
- " wind_direction (gid, time) float64 2MB 269.0 274.0 279.0 ... 245.0 242.0\n",
- " pressure (gid, time) float64 2MB 1.014e+05 1.014e+05 ... 9.965e+04 Attributes: (0)
"
],
"text/plain": [
" Size: 14MB\n",
"Dimensions: (gid: 22, time: 8760)\n",
"Coordinates:\n",
- " * time (time) datetime64[ns] 70kB 2022-01-01 ... 2022-12-31T2...\n",
" * gid (gid) int32 88B 0 1 2 3 4 5 6 7 ... 15 16 17 18 19 20 21\n",
+ " * time (time) datetime64[ns] 70kB 2022-01-01 ... 2022-12-31T2...\n",
"Data variables:\n",
- " temp_air (gid, time) float64 2MB 4.11 4.7 5.28 ... 0.35 0.37 0.38\n",
- " relative_humidity (gid, time) float64 2MB 87.27 87.03 86.79 ... 86.37 86.14\n",
- " ghi (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " dni (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " dhi (gid, time) float64 2MB 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0\n",
- " IR(h) (gid, time) float64 2MB 314.4 317.4 320.4 ... 271.9 274.1\n",
- " wind_speed (gid, time) float64 2MB 3.11 3.1 3.08 ... 3.53 3.45 3.37\n",
- " wind_direction (gid, time) float64 2MB 269.0 274.0 279.0 ... 245.0 242.0\n",
- " pressure (gid, time) float64 2MB 1.014e+05 1.014e+05 ... 9.965e+04"
+ " IR(h) (gid, time) float64 2MB dask.array\n",
+ " dhi (gid, time) float64 2MB dask.array\n",
+ " dni (gid, time) float64 2MB dask.array\n",
+ " ghi (gid, time) float64 2MB dask.array\n",
+ " pressure (gid, time) float64 2MB dask.array\n",
+ " relative_humidity (gid, time) float64 2MB dask.array\n",
+ " temp_air (gid, time) float64 2MB dask.array\n",
+ " wind_direction (gid, time) float64 2MB dask.array\n",
+ " wind_speed (gid, time) float64 2MB dask.array"
]
},
- "execution_count": 7,
+ "execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "weather_ds.compute()"
+ "geo_weather"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"metadata": {},
- "outputs": [],
- "source": []
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " latitude \n",
+ " longitude \n",
+ " altitude \n",
+ " Source \n",
+ " wind_height \n",
+ " \n",
+ " \n",
+ " gid \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 49.95 \n",
+ " 1.5 \n",
+ " 176.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 51.95 \n",
+ " -9.5 \n",
+ " 330.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 51.95 \n",
+ " -8.5 \n",
+ " 137.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 51.95 \n",
+ " -4.5 \n",
+ " 184.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 51.95 \n",
+ " -3.5 \n",
+ " 160.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 5 \n",
+ " 51.95 \n",
+ " -2.5 \n",
+ " 86.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 6 \n",
+ " 51.95 \n",
+ " -1.5 \n",
+ " 217.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 7 \n",
+ " 51.95 \n",
+ " -0.5 \n",
+ " 94.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 8 \n",
+ " 51.95 \n",
+ " 0.5 \n",
+ " 64.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 9 \n",
+ " 53.95 \n",
+ " -9.5 \n",
+ " 119.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 10 \n",
+ " 53.95 \n",
+ " -8.5 \n",
+ " 129.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 11 \n",
+ " 53.95 \n",
+ " -7.5 \n",
+ " 97.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 12 \n",
+ " 53.95 \n",
+ " -6.5 \n",
+ " 33.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 13 \n",
+ " 53.95 \n",
+ " -2.5 \n",
+ " 136.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 14 \n",
+ " 53.95 \n",
+ " -1.5 \n",
+ " 115.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 15 \n",
+ " 53.95 \n",
+ " -0.5 \n",
+ " 33.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 16 \n",
+ " 55.95 \n",
+ " -5.5 \n",
+ " 205.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 17 \n",
+ " 55.95 \n",
+ " -4.5 \n",
+ " 248.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 18 \n",
+ " 55.95 \n",
+ " -3.5 \n",
+ " 122.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 19 \n",
+ " 55.95 \n",
+ " -2.5 \n",
+ " 150.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 20 \n",
+ " 57.95 \n",
+ " -6.5 \n",
+ " 137.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ " 21 \n",
+ " 57.95 \n",
+ " -4.5 \n",
+ " 59.0 \n",
+ " PVGIS \n",
+ " 10 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " latitude longitude altitude Source wind_height\n",
+ "gid \n",
+ "0 49.95 1.5 176.0 PVGIS 10\n",
+ "1 51.95 -9.5 330.0 PVGIS 10\n",
+ "2 51.95 -8.5 137.0 PVGIS 10\n",
+ "3 51.95 -4.5 184.0 PVGIS 10\n",
+ "4 51.95 -3.5 160.0 PVGIS 10\n",
+ "5 51.95 -2.5 86.0 PVGIS 10\n",
+ "6 51.95 -1.5 217.0 PVGIS 10\n",
+ "7 51.95 -0.5 94.0 PVGIS 10\n",
+ "8 51.95 0.5 64.0 PVGIS 10\n",
+ "9 53.95 -9.5 119.0 PVGIS 10\n",
+ "10 53.95 -8.5 129.0 PVGIS 10\n",
+ "11 53.95 -7.5 97.0 PVGIS 10\n",
+ "12 53.95 -6.5 33.0 PVGIS 10\n",
+ "13 53.95 -2.5 136.0 PVGIS 10\n",
+ "14 53.95 -1.5 115.0 PVGIS 10\n",
+ "15 53.95 -0.5 33.0 PVGIS 10\n",
+ "16 55.95 -5.5 205.0 PVGIS 10\n",
+ "17 55.95 -4.5 248.0 PVGIS 10\n",
+ "18 55.95 -3.5 122.0 PVGIS 10\n",
+ "19 55.95 -2.5 150.0 PVGIS 10\n",
+ "20 57.95 -6.5 137.0 PVGIS 10\n",
+ "21 57.95 -4.5 59.0 PVGIS 10"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "geo_meta"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Geospatial Calculations from Locally Stored Data\n",
+ "\n",
+ "As shown above we can load from our `zarr` store and treat it like any other geospatial data in `pvdeg`.\n",
+ "\n",
+ "For demonstration we can run the analysis below to estimate effective standoff height and operating temperatures for the provided data. It may look like the `geo_res` contains empty results but that is because we did not have input data for all of the points in the input grid (think of this as a 2D plane formed between the latitude and longitude axes). Clicking on the stack of three circles in the bottom cell will expand the datavariable (like an attribute of the multidimensional array structure) and show the results.\n",
+ "\n",
+ "Additionally, we can interpolate and plot the results."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The array tilt angle was not provided, therefore the latitude tilt of 50.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 52.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 54.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 56.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 56.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 56.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 56.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 58.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n",
+ "The array tilt angle was not provided, therefore the latitude tilt of 58.0 was used.\n",
+ "The array azimuth was not provided, therefore an azimuth of 180.0 was used.\n"
+ ]
+ }
+ ],
+ "source": [
+ "func=pvdeg.standards.standoff\n",
+ "\n",
+ "template = pvdeg.geospatial.auto_template(\n",
+ " func=func,\n",
+ " ds_gids=geo_weather\n",
+ ")\n",
+ "\n",
+ "geo_res = pvdeg.geospatial.analysis(\n",
+ " weather_ds=geo_weather,\n",
+ " meta_df=geo_meta,\n",
+ " func=func,\n",
+ " template=template\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "
<xarray.Dataset> Size: 2kB\n",
+ "Dimensions: (latitude: 5, longitude: 12)\n",
+ "Coordinates:\n",
+ " * latitude (latitude) float64 40B 49.95 51.95 53.95 55.95 57.95\n",
+ " * longitude (longitude) float64 96B -9.5 -8.5 -7.5 -6.5 ... -1.5 -0.5 0.5 1.5\n",
+ "Data variables:\n",
+ " x (latitude, longitude) float64 480B nan nan nan ... nan nan nan\n",
+ " T98_0 (latitude, longitude) float64 480B nan nan nan ... nan nan nan\n",
+ " T98_inf (latitude, longitude) float64 480B nan nan nan ... nan nan nan Dimensions:
Coordinates: (2)
Data variables: (3)
x
(latitude, longitude)
float64
nan nan nan nan ... nan nan nan nan
array([[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, 0.],\n",
+ " [ 0., 0., nan, nan, nan, 0., 0., 0., 0., 0., 0., nan],\n",
+ " [ 0., 0., 0., 0., nan, nan, nan, 0., 0., 0., nan, nan],\n",
+ " [nan, nan, nan, nan, 0., 0., 0., 0., nan, nan, nan, nan],\n",
+ " [nan, nan, nan, 0., nan, 0., nan, nan, nan, nan, nan, nan]]) T98_0
(latitude, longitude)
float64
nan nan nan nan ... nan nan nan nan
array([[ nan, nan, nan, nan, nan,\n",
+ " nan, nan, nan, nan, nan,\n",
+ " nan, 60.95253061],\n",
+ " [56.59512555, 53.07034099, nan, nan, nan,\n",
+ " 53.20526103, 60.83555564, 59.5257354 , 57.95346809, 57.18719914,\n",
+ " 54.21177014, nan],\n",
+ " [51.0985667 , 48.68402644, 51.01251063, 53.88405413, nan,\n",
+ " nan, nan, 53.63165841, 56.10903587, 56.31863402,\n",
+ " nan, nan],\n",
+ " [ nan, nan, nan, nan, 45.97509778,\n",
+ " 50.89323047, 53.94845641, 50.27927675, nan, nan,\n",
+ " nan, nan],\n",
+ " [ nan, nan, nan, 50.39325135, nan,\n",
+ " 51.69074735, nan, nan, nan, nan,\n",
+ " nan, nan]]) T98_inf
(latitude, longitude)
float64
nan nan nan nan ... nan nan nan nan
array([[ nan, nan, nan, nan, nan,\n",
+ " nan, nan, nan, nan, nan,\n",
+ " nan, 39.30022792],\n",
+ " [36.32938828, 33.34724832, nan, nan, nan,\n",
+ " 34.23649626, 38.69478788, 38.96587081, 38.75905819, 37.49147734,\n",
+ " 35.60277 , nan],\n",
+ " [32.94332711, 31.10865383, 31.97285777, 34.64610402, nan,\n",
+ " nan, nan, 33.34225445, 35.79763983, 36.51414057,\n",
+ " nan, nan],\n",
+ " [ nan, nan, nan, nan, 27.86259826,\n",
+ " 32.34353167, 34.0867343 , 30.60700131, nan, nan,\n",
+ " nan, nan],\n",
+ " [ nan, nan, nan, 30.66841491, nan,\n",
+ " 32.36587173, nan, nan, nan, nan,\n",
+ " nan, nan]]) Indexes: (2)
PandasIndex
PandasIndex(Index([49.95, 51.95, 53.95, 55.95, 57.95], dtype='float64', name='latitude')) PandasIndex
PandasIndex(Index([-9.5, -8.5, -7.5, -6.5, -5.5, -4.5, -3.5, -2.5, -1.5, -0.5, 0.5, 1.5], dtype='float64', name='longitude')) Attributes: (0)
"
+ ],
+ "text/plain": [
+ " Size: 2kB\n",
+ "Dimensions: (latitude: 5, longitude: 12)\n",
+ "Coordinates:\n",
+ " * latitude (latitude) float64 40B 49.95 51.95 53.95 55.95 57.95\n",
+ " * longitude (longitude) float64 96B -9.5 -8.5 -7.5 -6.5 ... -1.5 -0.5 0.5 1.5\n",
+ "Data variables:\n",
+ " x (latitude, longitude) float64 480B nan nan nan ... nan nan nan\n",
+ " T98_0 (latitude, longitude) float64 480B nan nan nan ... nan nan nan\n",
+ " T98_inf (latitude, longitude) float64 480B nan nan nan ... nan nan nan"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "geo_res"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This plot lacks information on the area and does not include political boundary lines. For more information on plotting look at the `Scenario - Non-uniform Mountain Downselect.ipynb` tutorial in the tutorials and tools folder."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(,\n",
+ " )"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "pvdeg.geospatial.plot_sparse_analysis(geo_res, data_var='T98_0', method=\"nearest\")"
+ ]
}
],
"metadata": {