Cycles-utils 1.0.0__tar.gz

Cycles-utils-1.0.0/Cycles_utils.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: Cycles-utils
+Version: 1.0.0
+Summary: Python scripts to build Cycles input files and post-process Cycles output files
+Home-page: https://github.com/PSUmodeling/Cycles-utils
+Author: Yuning Shi
+Author-email: shiyuning@gmail.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: soilgrids
+License-File: LICENSE
+
+# Cycles-utils
+Library for building [Cycles](https://github.com/PSUmodeling/Cycles) input files and post-processing Cycles output files.
+
+## Installation
+
+To install:
+
+```shell
+pip install Cycles-utils
+```

Cycles-utils-1.0.0/Cycles_utils.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+Cycles_utils.egg-info/PKG-INFO
+Cycles_utils.egg-info/SOURCES.txt
+Cycles_utils.egg-info/dependency_links.txt
+Cycles_utils.egg-info/requires.txt
+Cycles_utils.egg-info/top_level.txt
+cycles/__init__.py
+cycles/cycles_read.py
+cycles/gadm/__init__.py
+cycles/gadm/gadm.py
+cycles/gssurgo/__init__.py
+cycles/gssurgo/gssurgo.py
+cycles/soil/__init__.py
+cycles/soil/soil.py
+cycles/soilgrids/__init__.py
+cycles/soilgrids/soilgrids.py

Cycles-utils-1.0.0/Cycles_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

Cycles-utils-1.0.0/Cycles_utils.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy>=1.19.5
+geopandas>=0.9.0
+pandas>=1.2.4
+
+[soilgrids]
+rioxarray>=0.5.0
+owslib>=0.24.1
+rasterio>=1.2.3
+shapely>=1.7.1

Cycles-utils-1.0.0/Cycles_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+cycles

Cycles-utils-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Penn State Earth System Modeling Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Cycles-utils-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: Cycles-utils
+Version: 1.0.0
+Summary: Python scripts to build Cycles input files and post-process Cycles output files
+Home-page: https://github.com/PSUmodeling/Cycles-utils
+Author: Yuning Shi
+Author-email: shiyuning@gmail.com
+License: MIT
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: soilgrids
+License-File: LICENSE
+
+# Cycles-utils
+Library for building [Cycles](https://github.com/PSUmodeling/Cycles) input files and post-processing Cycles output files.
+
+## Installation
+
+To install:
+
+```shell
+pip install Cycles-utils
+```

Cycles-utils-1.0.0/README.md

@@ -0,0 +1,10 @@
+# Cycles-utils
+Library for building [Cycles](https://github.com/PSUmodeling/Cycles) input files and post-processing Cycles output files.
+
+## Installation
+
+To install:
+
+```shell
+pip install Cycles-utils
+```

Cycles-utils-1.0.0/cycles/__init__.py

@@ -0,0 +1,3 @@
+from . cycles_read import read_operations
+from . cycles_read import read_season
+from . cycles_read import read_weather

Cycles-utils-1.0.0/cycles/cycles_read.py

@@ -0,0 +1,124 @@
+import pandas as pd
+
+HARVEST_TOOLS = [
+    'grain_harvest',
+    'harvest_grain',
+    'grainharvest',
+    'harvestgrain',
+    'forage_harvest',
+    'harvest_forage',
+    'forageharvest',
+    'harvestforage',
+]
+
+
+def read_season(cycles_path, simulation):
+    '''Read season output file for harvested crop, harvest time, plant time, and yield
+    '''
+    df = pd.read_csv(
+        f'{cycles_path}/output/{simulation}/harvest.txt',
+        sep='\t',
+        header=0,
+        skiprows=[1],
+        skipinitialspace=True,
+    )
+    df = df.rename(columns=lambda x: x.strip().lower().replace(' ', '_'))
+    df['crop'] = df['crop'].str.strip()
+
+    for col in ['date', 'plant_date']: df[col] = pd.to_datetime(df[col])
+
+    return df
+
+
+def read_operations(cycles_path, operation):
+    with open(f'{cycles_path}/input/{operation}.operation') as f:
+        lines = f.read().splitlines()
+
+    lines = [line for line in lines if (not line.strip().startswith('#')) and len(line.strip()) > 0]
+
+    operations = []
+    k = 0
+    while k < len(lines):
+        if lines[k] == 'FIXED_FERTILIZATION':
+            operations.append(
+                {
+                    'type': 'fertilization',
+                    'year': int(lines[k + 1].split()[1]),
+                    'doy': int(lines[k + 2].split()[1]),
+                    'source': lines[k + 3].split()[1],
+                    'mass': lines[k + 4].split()[1],
+                }
+            )
+            k += 5
+        elif lines[k] == 'TILLAGE':
+            if lines[k + 3].split()[1].strip().lower() in HARVEST_TOOLS:
+                operations.append(
+                    {
+                        'type': 'harvest',
+                        'year': int(lines[k + 1].split()[1]),
+                        'doy': int(lines[k + 2].split()[1]),
+                        'crop': lines[k + 7].split()[1],
+                    }
+                )
+            elif lines[k + 3].split()[1].strip().lower() == 'kill_crop':
+                operations.append(
+                    {
+                        'type': 'kill',
+                        'year': int(lines[k + 1].split()[1]),
+                        'doy': int(lines[k + 2].split()[1]),
+                        'crop': lines[k + 7].split()[1],
+                    }
+                )
+            else:
+                operations.append(
+                    {
+                        'type': 'tillage',
+                        'year': int(lines[k + 1].split()[1]),
+                        'doy': int(lines[k + 2].split()[1]),
+                        'tool': lines[k + 3].split()[1],
+                    }
+                )
+            k += 8
+        elif lines[k] == 'PLANTING':
+            operations.append(
+                {
+                    'type': 'planting',
+                    'year': int(lines[k + 1].split()[1]),
+                    'doy': int(lines[k + 2].split()[1]),
+                    'crop': lines[k + 8].split()[1],
+                }
+            )
+            k += 9
+        else:
+            k += 1
+
+    df = pd.DataFrame(operations)
+
+    return df
+
+
+def read_weather(cycles_path, weather, start_year=0, end_year=9999):
+    NUM_HEADER_LINES = 4
+    columns = {
+        'YEAR': int,
+        'DOY': int,
+        'PP': float,
+        'TX': float,
+        'TN': float,
+        'SOLAR': float,
+        'RHX': float,
+        'RHN': float,
+        'WIND': float,
+    }
+    df = pd.read_csv(
+        f,
+        usecols=list(range(len(columns))),
+        names=columns.keys(),
+        comment='#',
+        sep='\s+',
+        na_values=[-999],
+    )
+    df = df.iloc[NUM_HEADER_LINES:, :]
+    df = df.astype(columns)
+
+    return df[(df['YEAR'] <= end_year) & (df['YEAR'] >= start_year)]

Cycles-utils-1.0.0/cycles/gadm/__init__.py

@@ -0,0 +1,2 @@
+from . gadm import STATE_ABBREVIATIONS
+from . gadm import read_gadm

Cycles-utils-1.0.0/cycles/gadm/gadm.py

@@ -0,0 +1,74 @@
+import geopandas as gpd
+
+GADM = lambda path, country, level: f'{path}/gadm41_{country}_{level}.shp'
+GADM_LEVELS = {
+    'country': 0,
+    'state': 1,
+    'county': 2,
+}
+
+# For USA
+STATE_ABBREVIATIONS = {
+    'USA.1_1': 'AL',
+    'USA.2_1': 'AK',
+    'USA.3_1': 'AZ',
+    'USA.4_1': 'AR',
+    'USA.5_1': 'CA',
+    'USA.6_1': 'CO',
+    'USA.7_1': 'CT',
+    'USA.8_1': 'DE',
+    'USA.9_1': 'DC',
+    'USA.10_1': 'FL',
+    'USA.11_1': 'GA',
+    'USA.12_1': 'HI',
+    'USA.13_1': 'ID',
+    'USA.14_1': 'IL',
+    'USA.15_1': 'IN',
+    'USA.16_1': 'IA',
+    'USA.17_1': 'KS',
+    'USA.18_1': 'KY',
+    'USA.19_1': 'LA',
+    'USA.20_1': 'ME',
+    'USA.21_1': 'MD',
+    'USA.22_1': 'MA',
+    'USA.23_1': 'MI',
+    'USA.24_1': 'MN',
+    'USA.25_1': 'MS',
+    'USA.26_1': 'MO',
+    'USA.27_1': 'MT',
+    'USA.28_1': 'NE',
+    'USA.29_1': 'NV',
+    'USA.30_1': 'NH',
+    'USA.31_1': 'NJ',
+    'USA.32_1': 'NM',
+    'USA.33_1': 'NY',
+    'USA.34_1': 'NC',
+    'USA.35_1': 'ND',
+    'USA.36_1': 'OH',
+    'USA.37_1': 'OK',
+    'USA.38_1': 'OR',
+    'USA.39_1': 'PA',
+    'USA.40_1': 'RI',
+    'USA.41_1': 'SC',
+    'USA.42_1': 'SD',
+    'USA.43_1': 'TN',
+    'USA.44_1': 'TX',
+    'USA.45_1': 'UT',
+    'USA.46_1': 'VT',
+    'USA.47_1': 'VA',
+    'USA.48_1': 'WA',
+    'USA.49_1': 'WV',
+    'USA.50_1': 'WI',
+    'USA.51_1': 'WY',
+}
+
+
+def read_gadm(path, country, level, conus=True):
+    level = GADM_LEVELS[level.lower()]
+    gdf = gpd.read_file(GADM(path, country, level))
+    gdf.set_index(f'GID_{level}', inplace=True)
+    gdf['GID'] = gdf.index
+
+
+        # Generate a CONUS GeoDataFrame by removing Alaska and Hawaii
+    return gdf[~gdf['NAME_1'].isin(['Alaska', 'Hawaii'])] if country == 'USA' and conus else gdf

Cycles-utils-1.0.0/cycles/gssurgo/__init__.py

@@ -0,0 +1,7 @@
+from . gssurgo import GSSURGO_NON_SOIL_TYPES
+from . gssurgo import GSSURGO_PARAMETERS
+from . gssurgo import GSSURGO_URBAN_TYPES
+from . gssurgo import NAD83
+from . gssurgo import get_soil_profile_parameters
+from . gssurgo import read_state_gssurgo
+from . gssurgo import read_state_luts

Cycles-utils-1.0.0/cycles/gssurgo/gssurgo.py

@@ -0,0 +1,85 @@
+import geopandas as gpd
+import pandas as pd
+
+GSSURGO = lambda path, state: f'{path}/gSSURGO_{state}.gdb/'
+GSSURGO_LUT = lambda path, lut, state: f'{path}/{lut}_{state}.csv'
+GSSURGO_PARAMETERS = {
+    'clay': {'variable': 'claytotal_r', 'multiplier': 1.0}, # %
+    'sand': {'variable': 'sandtotal_r', 'multiplier': 1.0}, # %
+    'soc': {'variable': 'om_r', 'multiplier': 0.58},    # %
+    'bulk_density': {'variable': 'dbthirdbar_r', 'multiplier': 1.0},    # Mg/m3
+    'top': {'variable': 'hzdept_r', 'multiplier': 0.01},    # m
+    'bottom': {'variable': 'hzdepb_r', 'multiplier': 0.01}, # m
+}
+GSSURGO_NON_SOIL_TYPES = [
+    'Acidic rock land',
+    'Area not surveyed',
+    'Dam',
+    'Dumps',
+    'Levee',
+    'No Digital Data Available',
+    'Pits',
+    'Water',
+]
+GSSURGO_URBAN_TYPES = [
+    'Udorthents',
+    'Urban land',
+]
+NAD83 = 'epsg:5070'     # NAD83 / Conus Albers, CRS of gSSURGO
+
+
+def read_state_luts(path, state_abbreviation, group=False):
+    tables = {
+        'component': ['mukey', 'cokey', 'majcompflag'],
+        'chorizon': ['hzname', 'hzdept_r', 'hzdepb_r', 'sandtotal_r', 'silttotal_r', 'claytotal_r', 'om_r', 'dbthirdbar_r', 'cokey'],
+        'muaggatt': ['hydgrpdcd', 'muname', 'slopegradwta', 'mukey'],
+    }
+
+    gssurgo_luts = {}
+    for t in tables:
+        gssurgo_luts[t] = pd.read_csv(
+            GSSURGO_LUT(path, t, state_abbreviation),
+            usecols=tables[t],
+        )
+
+    # Rename table columns
+    gssurgo_luts['chorizon'] = gssurgo_luts['chorizon'].rename(
+        columns={GSSURGO_PARAMETERS[v]['variable']: v for v in GSSURGO_PARAMETERS}
+    )
+    # Convert units (note that organic matter is also converted to soil organic carbon in this case)
+    for v in GSSURGO_PARAMETERS: gssurgo_luts['chorizon'][v] *= GSSURGO_PARAMETERS[v]['multiplier']
+
+    # In the gSSURGO database many map units are the same soil texture with different slopes, etc. To find the dominant
+    # soil series, same soil texture with different slopes should be aggregated together. Therefore we use the map unit
+    # names to identify the same soil textures among different soil map units.
+    if group:
+        gssurgo_luts['muaggatt']['muname'] = gssurgo_luts['muaggatt']['muname'].map(lambda name: name.split(',')[0])
+
+    return gssurgo_luts
+
+
+def read_state_gssurgo(path, state_abbreviation, group=False):
+    gdf = gpd.read_file(
+            GSSURGO(path, state_abbreviation),
+            layer='MUPOLYGON',
+        )
+    gdf.columns = [x.lower() for x in gdf.columns]
+    gdf.mukey = gdf.mukey.astype(int)
+
+    luts = read_state_luts(path, state_abbreviation, group=group)
+
+    # Merge the mapunit polygon table with the mapunit aggregated attribute table
+    gdf = gdf.merge(luts['muaggatt'], on='mukey')
+
+    return gdf, luts
+
+
+def get_soil_profile_parameters(luts, mukey):
+    df = luts['component'][luts['component'].mukey == int(mukey)].merge(luts['chorizon'], on='cokey')
+    if not df[df['majcompflag'] == 'Yes'].empty:
+        df = df[df['majcompflag'] == 'Yes'].sort_values(by='top')
+    else:
+        print(f'{index} {t} no major component')
+        df = df.sort_values(by='top')
+
+    return df[df['hzname'] != 'R']

Cycles-utils-1.0.0/cycles/soil/__init__.py

@@ -0,0 +1,4 @@
+from . soil import CURVE_NUMBERS
+from . soil import SOIL_LAYERS
+from . soil import SOIL_PARAMETERS
+from . soil import generate_soil_file

Cycles-utils-1.0.0/cycles/soil/soil.py

@@ -0,0 +1,76 @@
+import numpy as np
+import pandas as pd
+
+SOIL_PARAMETERS = ['clay', 'sand', 'soc', 'bulk_density']
+SOIL_LAYERS = [
+    # units: top (m), bottom (m), thickness (m), NO3 (kg/ha), NH4 (Kg/ha)
+    {'top': 0, 'bottom': 0.05, 'thickness': 0.05, 'no3': 10, 'nh4': 1},
+    {'top': 0.05, 'bottom': 0.1, 'thickness': 0.05, 'no3': 10, 'nh4': 1},
+    {'top': 0.1, 'bottom': 0.2, 'thickness': 0.1, 'no3': 7, 'nh4': 1},
+    {'top': 0.2, 'bottom': 0.4, 'thickness': 0.2, 'no3': 4, 'nh4': 1},
+    {'top': 0.4, 'bottom': 0.6, 'thickness': 0.2, 'no3': 2, 'nh4': 1},
+    {'top': 0.6, 'bottom': 0.8, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 0.8, 'bottom': 1.0, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 1.0, 'bottom': 1.2, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 1.2, 'bottom': 1.4, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 1.4, 'bottom': 1.6, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 1.6, 'bottom': 1.8, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+    {'top': 1.8, 'bottom': 2.0, 'thickness': 0.2, 'no3': 1, 'nh4': 1},
+]
+CURVE_NUMBERS = {
+    #row crops, SR, Good
+    'A': 67,
+    'B': 78,
+    'C': 85,
+    'D': 89,
+}
+
+
+def overlapping_depth(top1, bottom1, top2, bottom2):
+    return max(0.0, min(bottom1, bottom2) - max(top1, top2))
+
+
+def calculate_parameter(soil_df, parameter, top, bottom):
+    soil_df['weight'] = soil_df.apply(lambda x: overlapping_depth(x['top'], x['bottom'], top, bottom) / (bottom - top), axis=1)
+    soil_df = soil_df[soil_df['weight'] > 0]
+
+    return np.sum(np.array(soil_df[parameter] * soil_df['weight'])) / sum(soil_df['weight'])
+
+
+def generate_soil_file(fn, desc, hsg, slope, soil_depth, soil_df):
+    df = pd.DataFrame.from_dict(
+        {v: [layer[v] for layer in SOIL_LAYERS if layer['bottom'] <= soil_depth] for v in SOIL_LAYERS[0]}
+    )
+
+    df['layer'] = range(1, len(df) + 1)
+
+    for v in SOIL_PARAMETERS:
+        df[v] = df.apply(lambda x: calculate_parameter(soil_df, v, x['top'], x['bottom']), axis=1)
+
+    cn = -999 if not hsg else CURVE_NUMBERS[hsg[0]]
+
+    with open(fn, 'w') as f:
+        f.write(desc)
+
+        f.write("%-15s\t%d\n" % ("CURVE_NUMBER", cn))
+        f.write("%-15s\t%.2f\n" % ("SLOPE", slope))
+
+        f.write("%-15s\t%d\n" % ("TOTAL_LAYERS", len(df)))
+        f.write(('%-7s\t'*12 + '%s\n') % (
+            "LAYER", "THICK", "CLAY", "SAND", "SOC", "BD", "FC", "PWP", "SON", "NO3", "NH4", "BYP_H", "BYP_V"
+        ))
+
+        f.write(('%-7s\t'*12 + '%s\n') % (
+            "#", "m", "%", "%", "%", "Mg/m3", "m3/m3", "m3/m3", "kg/ha", "kg/ha", "kg/ha", "-", "-"
+        ))
+
+        for _, row in df.iterrows():
+            f.write('%-7d\t' % row['layer'])
+            f.write('%-7.2f\t' % float(row['thickness']))
+            f.write('%-7s\t' % '-999' if np.isnan(row['clay']) else '%-7.1f\t' % float(row['clay']))
+            f.write('%-7s\t' % '-999' if np.isnan(row['sand']) else '%-7.1f\t' % float(row['sand']))
+            f.write('%-7s\t' % '-999' if np.isnan(row['soc']) else '%-7.2f\t' % float(row['soc']))
+            f.write('%-7s\t' % '-999' if np.isnan(row['bulk_density']) else '%-7.2f\t' % float(row['bulk_density']))
+            f.write(('%-7d\t'*3 + '%-7.1f\t'*2 + '%-7.1f\t%.1f\n') % (
+                -999, -999, -999, float(row['no3']), float(row['nh4']), 0.0, 0.0
+            ))

Cycles-utils-1.0.0/cycles/soilgrids/__init__.py

@@ -0,0 +1,6 @@
+from . soilgrids import HOMOLOSINE
+from . soilgrids import SOILGRIDS_LAYERS
+from . soilgrids import SOILGRIDS_PROPERTIES
+from . soilgrids import download_soilgrids_data
+from . soilgrids import read_soilgrids_maps
+from . soilgrids import reproject_match_soilgrids_maps

Cycles-utils-1.0.0/cycles/soilgrids/soilgrids.py

@@ -0,0 +1,89 @@
+import geopandas as gpd
+import pandas as pd
+import rioxarray
+from owslib.wcs import WebCoverageService
+from rasterio.enums import Resampling
+from shapely.geometry import Point
+
+SOILGRIDS_PROPERTIES = {
+    'clay': {'name': 'clay', 'multiplier': 0.1},    # %
+    'sand': {'name': 'sand', 'multiplier': 0.1},    # %
+    'soc': {'name': 'soc', 'multiplier': 0.01},     # %
+    'bulk_density': {'name': 'bdod', 'multiplier': 0.01},   # Mg/m3
+}
+SOILGRIDS_LAYERS = {
+    # units: m
+    '0-5cm': {'top': 0, 'bottom': 0.05, 'thickness': 0.05},
+    '5-15cm': {'top': 0.05, 'bottom': 0.15, 'thickness': 0.10},
+    '15-30cm': {'top': 0.15, 'bottom': 0.3, 'thickness': 0.15},
+    '30-60cm': {'top': 0.3, 'bottom': 0.6, 'thickness': 0.3},
+    '60-100cm': {'top': 0.6, 'bottom': 1.0, 'thickness': 0.4},
+    '100-200cm': {'top': 1.0, 'bottom': 2.0, 'thickness': 1.0},
+}
+HOMOLOSINE = 'urn:ogc:def:crs:EPSG::152160' # Interrupted Goode Homolosine, CRS of SoilGrids
+
+
+# Read state SoilGrids data
+def read_soilgrids_maps(path, state_id, layers, parameters, crs=HOMOLOSINE):
+    soilgrids_xds = {}
+    for layer in layers:
+        for v in parameters:
+            soilgrids_xds[f'{v}_{layer}'] = rioxarray.open_rasterio(f'{path}/{state_id}/{SOILGRIDS_PROPERTIES[v]["name"]}_{layer}.tif', masked=True).rio.reproject(crs)
+
+    return soilgrids_xds
+
+
+def reproject_match_soilgrids_maps(soilgrids_xds, reference_xds, reference_name, boundary, layers, parameters):
+    reference_xds = reference_xds.rio.clip([boundary], from_disk=True)
+    df = pd.DataFrame(reference_xds[0].to_series().rename(reference_name))
+
+    for v in parameters:
+        for layer in layers:
+            soil_xds = soilgrids_xds[f'{v}_{layer}'].rio.reproject_match(reference_xds, resampling=Resampling.nearest)
+            soil_xds = soil_xds.rio.clip([boundary], from_disk=True)
+
+            soil_df = pd.DataFrame(soil_xds[0].to_series().rename(f'{v}_{layer}')) * SOILGRIDS_PROPERTIES[v]['multiplier']
+            df = pd.concat([df, soil_df], axis=1)
+
+    return df
+
+
+"""Convert bounding boxes to SoilGrids CRS
+"""
+def get_bounding_box(reference_shp, bbox, crs):
+    d = {'col1': ['NW', 'SE'], 'geometry': [Point(bbox[0], bbox[3]), Point(bbox[2], bbox[1])]}
+    gdf = gpd.GeoDataFrame(d, crs=crs).set_index('col1')
+
+    converted = gdf.to_crs(gpd.read_file(reference_shp).crs)
+
+    return [
+        converted.loc['NW', 'geometry'].xy[0][0],
+        converted.loc['SE', 'geometry'].xy[1][0],
+        converted.loc['SE', 'geometry'].xy[0][0],
+        converted.loc['NW', 'geometry'].xy[1][0],
+    ]
+
+
+"""Use WebCoverageService to get SoilGrids data
+bbox should be in the order of [west, south, east, north]
+"""
+def download_soilgrids_data(layers, parameters, path, bbox, crs):
+    # Convert bounding box to SoilGrids CRS
+    bbox = get_bounding_box(bbox, crs)
+
+    for v in [SOILGRIDS_PROPERTIES[param]['name'] for param in parameters]:
+        for layer in layers:
+            wcs = WebCoverageService(f'http://maps.isric.org/mapserv?map=/map/{v}.map', version='1.0.0')
+            while True:
+                try:
+                    response = wcs.getCoverage(
+                        identifier=f'{v}_{layer}_mean',
+                        crs=HOMOLOSINE,
+                        bbox=bbox,
+                        resx=250, resy=250,
+                        format='GEOTIFF_INT16')
+
+                    with open(f'{path}/{v}_{layer}.tif', 'wb') as file: file.write(response.read())
+                    break
+                except:
+                    continue

Cycles-utils-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

Cycles-utils-1.0.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+with open('README.md', 'r') as f:
+    long_description = f.read()
+
+setup(
+    name='Cycles-utils',
+    version='1.0.0',
+    author='Yuning Shi',
+    author_email="shiyuning@gmail.com",
+    packages=find_packages(),
+    description='Python scripts to build Cycles input files and post-process Cycles output files',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/PSUmodeling/Cycles-utils',
+    license='MIT',
+    python_requires='>=3.6',
+    install_requires=['numpy>=1.19.5', 'geopandas>=0.9.0', 'pandas>=1.2.4'],
+    extras_require = {
+        'soilgrids':  ['rioxarray>=0.5.0', 'owslib>=0.24.1', 'rasterio>=1.2.3', 'shapely>=1.7.1'],
+    }
+)