def run_simulation(self):
if not isinstance(self.weather_data, dict):
print("Fetching NASA weather...")
self.wdp = NASAPowerWeatherDataProvider(self.location.lat, self.location.lon)
else:
print("Weather data is cached...")
if (self.location.lat != self.weather_data['latitude']) or (self.location.lon != self.weather_data['longitude']):
print("Location changed, fetching NASA weather again")
self.wdp = NASAPowerWeatherDataProvider(self.location.lat, self.location.lon)
else:
self.wdp = WeatherDataProvider()
self.wdp.store = self.weather_data['store']
self.wdp.elevation = self.weather_data['elevation']
self.wdp.longitude = self.weather_data['longitude']
self.wdp.latitude = self.weather_data['latitude']
self.wdp.description = self.weather_data['description']
self.wdp.ETmodel = self.weather_data['ETmodel']
print(self.wdp)
amgt = default_amgt
soil = default_soil
site = default_site
crop = default_crop
amgt[0][self.start_date] = amgt[0].pop(amgt[0].keys()[0])
amgt[0][self.start_date]['CropCalendar']['crop_start_date'] = self.sowing_date
amgt[0][self.start_date]['CropCalendar']['crop_end_date'] = self.end_date
parvalues = ParameterProvider(sitedata=site, soildata=soil, cropdata=crop)
crop['TSUM1'] = self.tsum1
crop['TSUM2'] = self.tsum2
soil.update(self.soil_attributes)
wofsim = Wofost71_WLP_FD(parvalues, self.wdp, agromanagement=amgt)
wofsim.run_till_terminate()
output = wofsim.get_output()
results_dict = {}
for a in output:
results_dict[a.pop('day').isoformat()] = a
self.simulation_dict = results_dict
return results_dict
def run(crop: str, soil: str, agro: str, day: int, weather_filename: str,
saved_name="output"):
# load argo from directory
agromanagement = YAMLAgroManagementReader(f"{base_dir}/{agro}")
sitedata = WOFOST71SiteDataProvider(WAV=100, CO2=360)
# load soil from directory
soildata = CABOFileReader(f"{base_dir}/{soil}")
# load crop from directory
cropdata = CABOFileReader(f"{base_dir}/{crop}")
# load weather data from directory
wdp = CABOWeatherDataProvider(fname=weather_filename, fpath=base_dir)
# packaing parameters
parameters = ParameterProvider(cropdata=cropdata, soildata=soildata,
sitedata=sitedata)
# create model
wofost = Wofost71_WLP_FD(parameters, wdp, agromanagement)
# run till [day]
wofost.run(day)
# save output az a csv in OUT directory
model_out_put = wofost.get_output()
df = pd.DataFrame(model_out_put)
df.to_csv(f"{out_dir}/{saved_name}.csv")
print(cropdata)
# read soil file
from pcse.fileinput import CABOFileReader
soildata = CABOFileReader("soildata.soil")
print(soildata)
#site parameters
from pcse.util import WOFOST71SiteDataProvider
sitedata = WOFOST71SiteDataProvider(WAV=100, CO2=360)
print(sitedata)
#pack the different sets of parameters
from pcse.base_classes import ParameterProvider
parameters = ParameterProvider(cropdata=cropdata,
soildata=soildata,
sitedata=sitedata) #cropdata = cropd
#agromanagement control the start date and end date
#there are two files, one is defalut, the other one is for excel weather data
from pcse.fileinput import YAMLAgroManagementReader
agromanagement = YAMLAgroManagementReader("sugarbeet_c.agro")
print(agromanagement)
#using modeul to read weather data
from pcse.db import NASAPowerWeatherDataProvider
wdp = NASAPowerWeatherDataProvider(latitude=52, longitude=5)
print(wdp)
#from pcse.fileinput import ExcelWeatherDataProvider
#wdp = ExcelWeatherDataProvider ("weather04.xlsx")
def main():
parser = create_parser()
args = parser.parse_args()
if None in [args.crop, args.year, args.dsn, args.db_version]:
parser.print_help()
return
db.version = args.db_version
# labels for soil columns which differ across database versions
lbl_smu, lbl_smu_area, lbl_stu, lbl_stu_perc = soil_identifiers[
args.db_version]
engine = sa.create_engine(args.dsn)
if args.grid is None:
grids = dp.get_grids(engine, args.cropd, args.year)
else:
grids = [
args.grid,
]
for grid in grids:
agro = dp.get_agromanagement(engine, grid, args.crop, args.year)
# Fix the campaign start/end onto dekad boundaries
start_dekad = get_preceeding_dekad(agro.campaign_start_date)
end_dekad = get_preceeding_dekad(agro.campaign_end_date)
agro.set_campaign_start_date(start_dekad)
agro.campaign_end_date = end_dekad
# We want to pull 180 days of additional weather data to allow water balance initialization
# with the --use-isw option
start_date_weather = start_dekad - dt.timedelta(days=180)
weatherdata = dp.get_weatherdata(engine,
grid,
start=start_date_weather,
end=end_dekad)
# Fetch or define crop, soil and site data
cropd = dp.get_cropdata(engine, grid, args.crop, args.year)
sited = WOFOST71SiteDataProvider(WAV=100)
soild = DummySoilDataProvider()
parameters = ParameterProvider(cropdata=cropd,
soildata=soild,
sitedata=sited)
# Run WOFOST potential production and convert output to Pandas DataFrame
mconf = os.path.join(os.path.dirname(__file__), "Wofost71_PP.conf")
wofost = CGMSEngine(parameters, weatherdata, agro, config=mconf)
# Run till end of the campaign year or date provided by --run_until
if args.run_till is not None:
wofost.run_till(args.run_till)
else:
wofost.run_till(agro.campaign_end_date)
df_simyield_pp = pd.DataFrame(wofost.get_output())
df_simyield_pp_summary = pd.DataFrame(wofost.get_summary_output())
# First add grid number and simulation type to the dataframe
df_simyield_pp_summary["grid"] = grid
df_simyield_pp["grid"] = grid
df_simyield_pp_summary["sim_type"] = "pp"
df_simyield_pp["sim_type"] = "pp"
# Pull in soil data for water-limited run
soil_iterator = dp.get_soiliterator(engine, grid)
suitable_stu = dp.get_suitability(engine, args.crop)
# Placeholders for simulation_results at stu level
df_simyield_wlp = None
df_simyield_wlp_summary = None
# Run water-limited simulation results
for smu_no, area, stu_no, percentage, soild in soil_iterator:
# Check if this is a suitable STU
if stu_no not in suitable_stu:
print("Skipping stu: %s" % stu_no)
continue
print("Processing grid: %i, smu: %i, stu: %i" %
(grid, smu_no, stu_no))
sited = dp.get_sitedata(engine, grid, args.crop, args.year, stu_no)
if args.use_isw_date:
agro.set_campaign_start_date(sited.start_date_waterbalance)
parameters = ParameterProvider(cropdata=cropd,
soildata=soild,
sitedata=sited)
mconf = os.path.join(os.path.dirname(__file__),
"Wofost71_WLP_FD.conf")
wofost = CGMSEngine(parameters, weatherdata, agro, config=mconf)
# Run till end of the campaign year or date provided by --run_until
if args.run_till is not None:
wofost.run_till(args.run_till)
else:
wofost.run_till(agro.campaign_end_date)
# Get output
df = pd.DataFrame(wofost.get_output())
# remove simulation days before start_dekad due to soil moisture initialization
ix = df.day >= start_dekad
df = df[ix]
# Add soil identifiers for weighted averaging
df[lbl_smu] = smu_no
df[lbl_stu] = stu_no
df[lbl_smu_area] = area
df[lbl_stu_perc] = percentage
if df_simyield_wlp is None:
df_simyield_wlp = df
else:
df_simyield_wlp = pd.concat([df_simyield_wlp, df])
# Get summary output
df_summary = pd.DataFrame(wofost.get_summary_output())
df_summary[lbl_smu] = smu_no
df_summary[lbl_stu] = stu_no
df_summary[lbl_smu_area] = area
df_summary[lbl_stu_perc] = percentage
if df_simyield_wlp_summary is None:
df_simyield_wlp_summary = df_summary
else:
df_simyield_wlp_summary = pd.concat(
[df_simyield_wlp_summary, df_summary])
# Start aggregating simulation results
# First add grid number and simulation type to the dataframes
df_simyield_wlp_summary["grid"] = grid
df_simyield_wlp["grid"] = grid
# First aggregate all STU's into SMU's by using the 'stu_perc' percentages as weights
if args.aggr_level in ("smu", "grid"):
df_simyield_wlp = \
group_dataframe(df_simyield_wlp, groupby=["grid", "day", lbl_smu], weightby=lbl_stu_perc,
excluding=["grid", "day", lbl_smu, lbl_stu, lbl_stu_perc])
df_simyield_wlp_summary = \
group_dataframe(df_simyield_wlp_summary, groupby=["grid", lbl_smu], weightby=lbl_stu_perc,
excluding=["grid", lbl_smu, lbl_stu, lbl_stu_perc] + date_type_variables)
# Next aggregate all SMU's to the grid level by using the 'smu_area' as weights
if args.aggr_level == 'grid':
df_simyield_wlp = \
group_dataframe(df_simyield_wlp, groupby=["grid", "day"], weightby=lbl_smu_area,
excluding=["grid", "day", lbl_smu, lbl_smu_area])
df_simyield_wlp_summary = \
group_dataframe(df_simyield_wlp_summary, groupby=["grid"], weightby=lbl_smu_area,
excluding=["grid", lbl_smu, lbl_smu_area])
df_simyield_wlp_summary["sim_type"] = "wlp"
df_simyield_wlp["sim_type"] = "wlp"
# combine potential (pp) and water-limited production (wlp) in a single dataframe
df_simyield = pd.concat([df_simyield_pp, df_simyield_wlp], sort=True)
df_simyield_summary = pd.concat(
[df_simyield_pp_summary, df_simyield_wlp_summary], sort=True)
# Write timeseries output file
fname_ts = "{grid}_{crop}_{year}.{type}".format(grid=grid,
crop=args.crop,
year=args.year,
type=args.output_type)
fname_sum = "{grid}_{crop}_{year}_summary.{type}".format(
grid=grid, crop=args.crop, year=args.year, type=args.output_type)
fname_ts = os.path.join(args.output, fname_ts)
fname_sum = os.path.join(args.output, fname_sum)
if args.output_type == "csv":
df_simyield.to_csv(fname_ts, header=True, index=False)
df_simyield_summary.to_csv(fname_sum, header=True, index=False)
elif args.output_type == "xls":
df_simyield.to_excel(fname_ts, index=False)
df_simyield_summary.to_excel(fname_sum, index=False)
elif args.output_type == "hdf5":
df_simyield.to_hdf(fname_ts,
mode="w",
complevel=9,
complib="blosc")
df_simyield_summary.to_hdf(fname_sum,
mode="w",
complevel=9,
complib="blosc")
elif args.output_type == "json":
df_simyield.to_json(fname_ts,
orient="records",
date_format="iso",
lines=True)
df_simyield_summary.to_json(fname_sum,
orient="records",
date_format="iso",
lines=True)
db_location = os.path.join(settings.PCSE_USER_HOME, "pcse.db")
db_location = os.path.normpath(db_location)
dsn = "sqlite:///" + db_location
db_engine = sa.create_engine(dsn)
db_metadata = sa.MetaData(db_engine)
grid = 31031
crop = 1
year = 2000
# Get input parameters from database
with warnings.catch_warnings():
warnings.simplefilter("ignore")
sited = fetch_sitedata(db_metadata, grid, year)
cropd = fetch_cropdata(db_metadata, grid, year, crop)
soild = fetch_soildata(db_metadata, grid)
parameters = ParameterProvider(sitedata=sited,
cropdata=cropd,
soildata=soild)
# Get Agromanagement
agromanagement = AgroManagementDataProvider(db_engine, grid, crop, year)
start_date = list(agromanagement[0].keys())[0]
end_date = start_date + dt.timedelta(days=365)
weather = GridWeatherDataProvider(db_engine,
grid_no=grid,
start_date=start_date,
end_date=end_date)