def doHazardPlotting(configFile):
"""
Do the hazard plots (hazard maps and curves for all locations within
the model domain). Plotting is performed by the
:mod:`PlotInterface.AutoPlotHazard` module.
:param str configFile: Name of configuration file.
"""
config = ConfigParser()
config.read(configFile)
log.info('Plotting Hazard Maps')
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Plotting hazard maps: ', showProgressBar)
pbar.update(0.0)
from PlotInterface.AutoPlotHazard import AutoPlotHazard
plotter = AutoPlotHazard(configFile, progressbar=pbar)
plotter.plotMap()
plotter.plotCurves()
pbar.update(1.0)
def doWindfieldCalculations(configFile):
"""
Do the wind field calculations, using :mod:`wind`. The wind
field settings are read from *configFile*.
:param str configFile: Name of configuration file.
"""
log.info('Starting wind field calculations')
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Calculating wind fields: ', showProgressBar)
def status(done, total):
pbar.update(float(done)/total)
import wind
wind.run(configFile, status)
pbar.update(1.0)
log.info('Completed wind field calculations')
def doHazard(configFile):
"""
Do the hazard calculations (extreme value distribution fitting)
using the :mod:`hazard` module.
:param str configFile: Name of configuration file.
"""
log.info('Running HazardInterface')
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Performing hazard calculations: ', showProgressBar)
def status(done, total):
pbar.update(float(done)/total)
import hazard
hazard.run(configFile)
log.info('Completed HazardInterface')
pbar.update(1.0)
def doTrackGeneration(configFile):
"""
Do the tropical cyclone track generation in :mod:`TrackGenerator`.
The track generation settings are read from *configFile*.
:param str configFile: Name of configuration file.
"""
log.info('Starting track generation')
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Simulating cyclone tracks: ', showProgressBar)
def status(done, total):
pbar.update(float(done)/total)
import TrackGenerator
TrackGenerator.run(configFile, status)
pbar.update(1.0)
log.info('Completed track generation')
def doDataDownload(configFile):
"""
Check and download the data files listed in the configuration file.
Datasets are listed in the `Input` section of the configuration
file, with the option `Datasets`. There must also be a corresponding
section in the configuration file that inlcudes the url, path where
the dataset will be stored and the filename that will be stored, e.g.::
[Input]
Datasets=IBTRACS
[IBTRACS]
URL=ftp://eclipse.ncdc.noaa.gov/pub/ibtracs/v03r05/wmo/csv/Allstorms.ibtracs_wmo.v03r05.csv.gz
filename=Allstorms.ibtracs_wmo.v03r05.csv
path=input
This will attempt to download the gzipped csv file from the given URL
and save it to the given filename, in the 'input' folder under the current
directory. Gzipped files are automatically unzipped.
:param str configFile: Name of configuration file.
:raises IOError: If the data cannot be downloaded.
"""
log.info('Checking availability of input data sets')
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
datasets.loadDatasets(configFile)
for dataset in datasets.DATASETS:
if not dataset.isDownloaded():
log.info('Input file %s is not available', dataset.filename)
try:
log.info('Attempting to download %s', dataset.filename)
pbar = ProgressBar('Downloading file %s: ' % dataset.filename,
showProgressBar)
def status(fn, done, size):
pbar.update(float(done)/size)
dataset.download(status)
log.info('Download successful')
except IOError:
log.error('Unable to download %s. Maybe a proxy problem?',
dataset.filename)
sys.exit(1)
def doStatistics(configFile):
"""
Calibrate the model with the :mod:`StatInterface` module.
:param str configFile: Name of configuration file.
"""
from DataProcess.CalcTrackDomain import CalcTrackDomain
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
getRMWDistFromInputData = config.getboolean('RMW',
'GetRMWDistFromInputData')
log.info('Running StatInterface')
pbar = ProgressBar('Calibrating model: ', showProgressBar)
# Auto-calculate track generator domain
CalcTD = CalcTrackDomain(configFile)
domain = CalcTD.calcDomainFromFile()
pbar.update(0.05)
from StatInterface import StatInterface
statInterface = StatInterface.StatInterface(configFile,
autoCalc_gridLimit=domain)
statInterface.kdeGenesisDate()
pbar.update(0.4)
statInterface.kdeOrigin()
pbar.update(0.5)
statInterface.cdfCellBearing()
pbar.update(0.6)
statInterface.cdfCellSpeed()
pbar.update(0.7)
statInterface.cdfCellPressure()
pbar.update(0.8)
statInterface.calcCellStatistics()
if getRMWDistFromInputData:
statInterface.cdfCellSize()
pbar.update(1.0)
log.info('Completed StatInterface')
def main(configFile):
"""
Main function to execute the :mod:`wind`.
:param str configFile: Path to configuration file.
"""
config = ConfigParser()
config.read(configFile)
doOutputDirectoryCreation(configFile)
trackFile = config.get('DataProcess', 'InputFile')
source = config.get('DataProcess', 'Source')
delta = 1/12.
outputPath = pjoin(config.get('Output','Path'), 'tracks')
outputTrackFile = pjoin(outputPath, "tracks.interp.nc")
# This will save interpolated track data in TCRM format:
interpTrack = interpolateTracks.parseTracks(configFile, trackFile,
source, delta,
outputTrackFile,
interpolation_type='akima')
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Calculating wind fields: ', showProgressBar)
def status(done, total):
pbar.update(float(done)/total)
import wind
wind.run(configFile, status)
import impact
impact.run_optional(config)
if config.getboolean('WindfieldInterface', 'PlotOutput'):
doWindfieldPlotting(configFile)
if config.getboolean('Timeseries', 'Extract'):
doTimeseriesPlotting(configFile)
def doDataProcessing(configFile):
"""
Parse the input data and turn it into the necessary format
for the model calibration step, using the :mod:`DataProcess` module.
:param str configFile: Name of configuration file.
"""
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Processing data files: ', showProgressBar)
log.info('Running Data Processing')
from DataProcess.DataProcess import DataProcess
dataProcess = DataProcess(configFile, progressbar=pbar)
dataProcess.processData()
log.info('Completed Data Processing')
pbar.update(1.0)
def doDataPlotting(configFile):
"""
Plot the pre-processed input data. Requires the Data Processing step to have
been executed first (``Actions -- DataProcess = True``)
:param str configFile: Name of configuration file.
"""
config = ConfigParser()
config.read(configFile)
showProgressBar = config.get('Logging', 'ProgressBar')
pbar = ProgressBar('Plotting results: ', showProgressBar)
outputPath = config.get('Output', 'Path')
statsPlotPath = pjoin(outputPath, 'plots', 'stats')
processPath = pjoin(outputPath, 'process')
pRateData = flLoadFile(pjoin(processPath, 'pressure_rate'))
pAllData = flLoadFile(pjoin(processPath, 'all_pressure'))
bRateData = flLoadFile(pjoin(processPath, 'bearing_rate'))
bAllData = flLoadFile(pjoin(processPath, 'all_bearing'))
sRateData = flLoadFile(pjoin(processPath, 'speed_rate'))
sAllData = flLoadFile(pjoin(processPath, 'all_speed'))
freq = flLoadFile(pjoin(processPath, 'frequency'))
indLonLat = flLoadFile(pjoin(processPath, 'cyclone_tracks'),
delimiter=',')
indicator = indLonLat[:, 0]
lonData = indLonLat[:, 1]
latData = indLonLat[:, 2]
jdayobs = flLoadFile(pjoin(processPath, 'jday_obs'), delimiter=',')
jdaygenesis = flLoadFile(pjoin(processPath, 'jday_genesis'), delimiter=',')
from PlotInterface.plotStats import PlotPressure, PlotBearing, \
PlotSpeed, PlotFrequency, PlotDays, PlotLonLat
log.info('Plotting pressure data')
pbar.update(0.05)
PrsPlot = PlotPressure(statsPlotPath, "png")
PrsPlot.plotPressure(pAllData)
PrsPlot.plotPressureRate(pRateData)
PrsPlot.plotMinPressure(indicator, pAllData)
#FIXME: To be moved into `PlotPressure` class.
#plotting.minPressureLat(pAllData, latData)
log.info('Plotting bearing data')
pbar.update(0.15)
BearPlot = PlotBearing(statsPlotPath, "png")
BearPlot.plotBearing(bAllData)
BearPlot.plotBearingRate(bRateData)
log.info('Plotting speed data')
pbar.update(0.25)
SpeedPlot = PlotSpeed(statsPlotPath, "png")
SpeedPlot.plotSpeed(sAllData)
SpeedPlot.plotSpeedRate(sRateData)
log.info('Plotting longitude and latitude data')
pbar.update(0.45)
# FIXME: To be moved to it's own class in PlotStats
LLPlot = PlotLonLat(statsPlotPath, "png")
LLPlot.plotLonLat(lonData, latData, indicator)
pbar.update(0.65)
log.info('Plotting frequency data')
pbar.update(0.85)
FreqPlot = PlotFrequency(statsPlotPath, "png")
FreqPlot.plotFrequency(freq[:, 0], freq[:, 1])
DayPlot = PlotDays(statsPlotPath, "png")
DayPlot.plotJulianDays(jdayobs, jdaygenesis)
pbar.update(1.0)
