def startup():
"""
Parse command line arguments and call the :func:`main` function.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--config_file',
help='Path to configuration file')
parser.add_argument('-v',
'--verbose',
help='Verbose output',
action='store_true')
parser.add_argument('-d',
'--debug',
help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
configFile = args.config_file
config = ConfigParser()
config.read(configFile)
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'processMultipliers.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
debug = False
if args.verbose:
verbose = True
if args.debug:
debug = True
flStartLog(logfile, logLevel, verbose, datestamp)
if debug:
main(configFile)
else:
try:
modified_main(configFile)
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
def startup():
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config_file',
help='Path to configuration file')
parser.add_argument('-v', '--verbose', help='Verbose output',
action='store_true')
parser.add_argument('-d', '--debug', help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
configFile = args.config_file
config = ConfigParser()
config.read(configFile)
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
logfile = config.get('Logging','LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tcrm.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
debug = False
if args.verbose:
verbose = True
if args.debug:
debug = True
flStartLog(logfile, logLevel, verbose)
# Switch off minor warning messages
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="pytz")
warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
warnings.filterwarnings("ignore", category=UserWarning,
module="matplotlib")
warnings.filterwarnings("ignore", category=RuntimeWarning)
if debug:
main(configFile)
else:
try:
main(configFile)
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
def main(argv):
"""
Main part of the program
:param list argv: List of command line arguments.
"""
gConfigFile = flConfigFile()
#logFile = flConfigFile(".log")
#verbose = False
logger = logging.getLogger()
try:
opts, args = getopt.getopt(argv, "hc:l:v",
["help", "config=", "logfile=", "verbose"])
except getopt.GetoptError:
ShowSyntax(2)
for opt, arg in opts:
if opt in ("-h", "--help"):
ShowSyntax()
sys.exit(2)
elif opt in ("-c", "--config"):
gConfigFile = arg
elif opt in ("-l", "--logfile"):
logFile = arg
elif opt in ("-v", "--verbose"):
verbose = True
flStartLog(
cnfGetIniValue(gConfigFile, 'Logging', 'LogFile',
flConfigFile('.log')),
cnfGetIniValue(gConfigFile, 'Logging', 'LogLevel', 'INFO'),
cnfGetIniValue(gConfigFile, 'Logging', 'Verbose', False))
inputFile = cnfGetIniValue(gConfigFile, 'Input', 'File')
logger.info("Processing {0}".format(inputFile))
source = cnfGetIniValue(gConfigFile, 'Input', 'Source')
delta = cnfGetIniValue(gConfigFile, 'Output', 'Delta', 0.1)
nid, newtime, newdates, nLon, nLat, nthetaFm, \
nvFm, npCentre, npEnv, nrMax = \
interpolateTrack(gConfigFile, inputFile, source, delta)
#header = ''
outputFile = cnfGetIniValue(gConfigFile, 'Output', 'File')
logger.info("Saving interpolated data to {0}".format(outputFile))
fh = open(outputFile, 'w')
for i in xrange(len(newtime)):
fh.write("%d,%5.1f,%s,%6.2f,%6.2f,%6.2f,%6.2f,%7.2f,%7.2f,%5.1f\n" %
(nid[i], newtime[i], newdates[i].strftime("%Y-%m-%d %H:%M"),
nLon[i], nLat[i], nthetaFm[i], nvFm[i], npCentre[i],
npEnv[i], nrMax[i]))
fh.close()
logger.info("Completed {0}".format(sys.argv[0]))
def startup():
"""
Parse command line arguments and call the :func:`main` function.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config_file',
help='Path to configuration file')
parser.add_argument('-v', '--verbose', help='Verbose output',
action='store_true')
parser.add_argument('-d', '--debug', help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
config_file = args.config_file
config = ConfigParser()
config.read(config_file)
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tsmultipliers.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
debug = False
if args.verbose:
verbose = True
if args.debug:
debug = True
flStartLog(logfile, logLevel, verbose, datestamp)
if debug:
process_timeseries(config_file)
else:
try:
process_timeseries(config_file)
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
log.info("Completed {0}".format(sys.argv[0]))
if __name__ == "__main__":
try:
configFile = sys.argv[1]
except IndexError:
# Try loading config file with same name as python script
configFile = __file__.rstrip('.py') + '.ini'
# If no filename is specified and default filename does not exist =>
# raise error
if not os.path.exists(configFile):
error_msg = ("No configuration file specified, please type: "
"python tcrm.py -c {config filename}.ini")
raise IOError, error_msg
# If config file does not exist => raise error
if not os.path.exists(configFile):
error_msg = "Configuration file '" + configFile + "' not found"
raise IOError, error_msg
config = ConfigParser()
config.read(configFile)
logFile = config.read('Logging', 'LogFile')
logLevel = config.read('Logging', 'LogLevel')
verbose = config.read('Logging', 'Verbose')
flStartLog(logFile, logLevel, verbose)
dp = DataProcess(configFile)
dp.processData()
logging.shutdown()
def startup():
"""
Parse command line arguments, set up logging and attempt
to execute the main TCRM functions.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config_file', help='The configuration file')
parser.add_argument('-v', '--verbose', help='Verbose output',
action='store_true')
parser.add_argument('-d', '--debug', help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
configFile = args.config_file
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
config = ConfigParser()
config.read(configFile)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tcrm.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
debug = False
if args.verbose:
verbose = True
if args.debug:
debug = True
global MPI, comm
MPI = attemptParallel()
import atexit
atexit.register(MPI.Finalize)
comm = MPI.COMM_WORLD
if comm.size > 1 and comm.rank > 0:
logfile += '-' + str(comm.rank)
verbose = False # to stop output to console
else:
pass
#codeStatus = status()
#print __doc__ + codeStatus
flStartLog(logfile, logLevel, verbose, datestamp)
# Switch off minor warning messages
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="pytz")
warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
warnings.filterwarnings("ignore", category=UserWarning,
module="matplotlib")
warnings.filterwarnings("ignore", category=RuntimeWarning)
checkModules()
if debug:
main(configFile)
else:
try:
main(configFile)
except ImportError as e:
log.critical("Missing module: {0}".format(e))
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
def test_GetMaxRange(self):
"""Testing getMaxRange"""
knownValues = ((10, 20, 3, 22), (10, 200, 9, 208))
for minVal, maxVal, step, maxRange in knownValues:
result = statutils.statMaxRange(minVal, maxVal, step)
self.assertEqual(maxRange, result)
def test_GetMinRange(self):
"""Testing getMinRange"""
knownValues = ((10, 20, 9, 2), (-123, 2002, 3, -125))
for minVal, maxVal, step, minRange in knownValues:
result = statutils.statMinRange(minVal, maxVal, step)
self.assertEqual(minRange, result)
def test_BandWidth(self):
"""Testing bandwidth function"""
self.assertRaises(TypeError, statutils.bandwidth, 'string')
self.assertRaises(TypeError, statutils.bandwidth, 0.5)
data = pickle.load(
open(
os.path.join(unittest_dir, 'test_data',
'kde_parameters_pressure_rate.pkl'), 'rb'))
result = statutils.bandwidth(data)
self.assertAlmostEqual(result, 0.116510487, places=7)
if __name__ == "__main__":
flStartLog('', 'CRITICAL', False)
testSuite = unittest.makeSuite(TestStats, 'test')
unittest.TextTestRunner(verbosity=2).run(testSuite)
names=names,
index_col=False,
dtype=dtype) #, skiprows=1)
log.info("Loaded details of {0} stations".format(len(stndf.index)))
return stndf
#------------------------------------------------
# Main execution code:
input_path = "C:/WorkSpace/data/daily/input/"
output_path = "C:/WorkSpace/data/daily/output/2006"
logfile = pjoin(output_path, "estimate_return_period.log")
loglevel = "INFO"
log = flStartLog(logfile, loglevel, True, True)
stationFile = pjoin(input_path, "DC02D_StnDet_99999999720437.txt")
stndf = readStationFile(stationFile)
basefile = "DC02D_Data_{0}_99999999720437.txt"
gpdfile = open(pjoin(output_path, "gpdtable_ms.csv"), 'w')
gpdfile.write("Station, Name, shape, scale, threshold, rate\n")
rp = np.array([1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000])
rpfile = open(pjoin(output_path, "rptable_ms.csv"), 'w')
rpfile.write("Station, Name," + ", ".join(rp.astype(str)) + "\n")
for i in stndf.index:
stnNum = stndf['stnNum'][i]
header='Day', fmt='%d')
if __name__ == "__main__":
try:
configFile = sys.argv[1]
except IndexError:
# Try loading config file with same name as python script
configFile = __file__.rstrip('.py') + '.ini'
# If no filename is specified and default filename does not exist =>
# raise error
if not os.path.exists(configFile):
error_msg = "No configuration file specified, please type: python main.py {config filename}.ini"
raise IOError, error_msg
# If config file does not exist => raise error
if not os.path.exists(configFile):
error_msg = "Configuration file '" + configFile + "' not found"
raise IOError, error_msg
config = ConfigParser()
config.read(configFile)
logFile = config.read('Logging', 'LogFile')
logLevel = config.read('Logging', 'LogLevel')
verbose = config.read('Logging', 'Verbose')
flStartLog(logFile, logLevel, verbose)
dp = DataProcess(configFile)
dp.processData()
logging.shutdown()
configFile = sys.argv[1]
except IndexError:
# Try loading config file with same name as python script
configfile = __file__.rstrip('.py') + '.ini'
# If no filename is specified and default filename doesn't exist => raise error
if not os.path.exists(configFile):
error_msg = ("No configuration file specified. "
"please type: python main.py {config filename}.ini")
raise IOError(error_msg)
# If config file doesn't exist => raise error
if not os.path.exists(configFile):
error_msg = "Configuration file '" + configFile +"' not found"
raise IOError(error_msg)
flStartLog(cnfGetIniValue(configFile, 'Logging',
'LogFile', __file__.rstrip('.py') + '.log'),
cnfGetIniValue(configFile, 'Logging', 'LogLevel', 'DEBUG'),
cnfGetIniValue(configFile, 'Logging', 'Verbose', True))
path = cnfGetIniValue(configFile, 'Output', 'Path')
gridLim = eval(cnfGetIniValue(configFile, 'Region', 'gridLimit'))
gridSp = eval(cnfGetIniValue(configFile, 'Region', 'gridSpace'))
gridinc = eval(cnfGetIniValue(configFile, 'Region', 'gridInc'))
kdetype = cnfGetIniValue(configFile, 'StatInterface', 'kdeType')
kdestep = cnfGetIniValue(configFile, 'StatInterface', 'kdeStep', 0.1)
minSamples = cnfGetIniValue(configFile, 'StatInterface',
'minSamplesCell', 100)
mv = cnfGetIniValue(configFile, 'StatInterface',
'MissingValue', sys.maxsize)
gDist = GenerateDistributions(configFile, gridLim, gridSp,
gridinc, kdetype,
minSamples, mv)
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tracks2shp.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
if args.verbose:
verbose = True
flStartLog(logfile, logLevel, verbose, datestamp)
if args.file:
track_file = args.file
else:
track_file = config.get('DataProcess', 'InputFile')
if args.source:
source = args.source
else:
source = config.get('DataProcess', 'Source')
output_path = dirname(realpath(track_file))
filename, ext = splitext(track_file)
pt_output_file = filename + '_pt.shp'
line_output_file = filename + '_line.shp'
def test_findnearest(self):
"""Test find_nearest function"""
for pt, val in zip(self.findpts, self.nearvals):
v = maputils.find_nearest(self.lon, pt)
self.assertEqual(v, val)
def test_findnearest_Err(self):
"""Test that find_nearest raises ValueError if second arg is an array"""
self.assertRaises(ValueError, maputils.find_nearest, self.lon, self.findpts)
# class TestInput(unittest.TestCase):
# xx=[1, 3, 5, 9, 11]
# yy=[1, 4, 12, 40, 60]
# lat=range(-20,0)
# lon=range(120,140)
# def testInputxy2r(self):
# self.assertRaises(maputils.ArrayMismatch, maputils.xy2r, xx, yy[0:len(y)-1])
# def testInputll2xy(self):
# self.assertRaises(maputils.ArrayMismatch, maputils.latLon2XY, lat, lon[0:len(lon)-1])
# def testInputll2azi(self):
# self.assertRaises(maputils.ArrayMismatch, maputils.latLon2Azi, lat, lon[0:len(lon)-1])
if __name__ == "__main__":
flStartLog("", "CRITICAL", False)
testSuite = unittest.makeSuite(TestMapUtils, "test")
unittest.TextTestRunner(verbosity=2).run(testSuite)
def startup():
"""
Parse command line arguments, set up logging and attempt
to execute the main TCRM functions.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c', '--config_file', help='The configuration file')
parser.add_argument('-v', '--verbose', help='Verbose output',
action='store_true')
parser.add_argument('-d', '--debug', help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
configFile = args.config_file
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
config = ConfigParser()
config.read(configFile)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tcrm.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
debug = False
if args.verbose:
verbose = True
#if not verbose:
# logLevel = 'ERROR'
# verbose = True
if args.debug:
debug = True
global pp
pp = attemptParallel()
import atexit
atexit.register(pp.finalize)
if pp.size() > 1 and pp.rank() > 0:
logfile += '-' + str(pp.rank())
verbose = False # to stop output to console
else:
pass
#codeStatus = status()
#print __doc__ + codeStatus
flStartLog(logfile, logLevel, verbose, datestamp)
# Switch off minor warning messages
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="pytz")
warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
warnings.filterwarnings("ignore", category=UserWarning,
module="matplotlib")
warnings.filterwarnings("ignore", category=RuntimeWarning)
if debug:
main(configFile)
else:
try:
main(configFile)
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
def __init__(self):
"""
Parse command line arguments and call the :func:`main` function.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--config_file',
help='Path to configuration file')
parser.add_argument('-v',
'--verbose',
help='Verbose output',
action='store_true')
parser.add_argument('-d',
'--debug',
help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
self.configFile = args.config_file
config = ConfigParser()
config.read(self.configFile)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'processMultipliers.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
if args.verbose:
verbose = True
flStartLog(logfile, logLevel, verbose, datestamp)
# Switch off minor warning messages
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="pytz")
warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
warnings.filterwarnings("ignore",
category=UserWarning,
module="matplotlib")
warnings.filterwarnings("ignore", category=RuntimeWarning)
self.working_dir = config.get('Output', 'Working_dir')
self.gust_file = config.get('Input', 'Gust_file')
tiles = config.get('Input', 'Tiles')
self.tiles = [item.strip() for item in tiles.split(',')]
log.debug('List of tiles to be processed: {0}'.format(self.tiles))
log.info('Multipliers will be written out to %s', self.working_dir)
# Get the multipliers, and process them if need be
self.type_mapping = {
'shielding': 'Ms',
'terrain': 'Mz',
'topographic': 'Mt'
}
self.dirns = ['e', 'n', 'ne', 'nw', 's', 'se', 'sw', 'w']
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
try:
self.main()
except ImportError as e:
log.critical("Missing module: {0}".format(e.strerror))
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
try:
configFile = sys.argv[1]
except IndexError:
# Try loading config file with same name as python script
configFile = __file__.rstrip('.py') + '.ini'
# If no filename is specified and default filename doesn't exist => raise error
if not os.path.exists(configFile):
error_msg = "No configuration file specified, please type: python main.py {config filename}.ini"
raise IOError, error_msg
# If config file doesn't exist => raise error
if not os.path.exists(configFile):
error_msg = "Configuration file '" + configFile +"' not found"
raise IOError, error_msg
flStartLog(cnfGetIniValue(configFile, 'Logging', 'LogFile', __file__.rstrip('.py') + '.log'),
cnfGetIniValue(configFile, 'Logging', 'LogLevel', 'DEBUG'),
cnfGetIniValue(configFile, 'Logging', 'Verbose', True))
path = cnfGetIniValue(configFile, 'Output', 'Path')
gridLimit = eval(cnfGetIniValue(configFile, 'Region', 'gridLimit'))
gridSpace = eval(cnfGetIniValue(configFile, 'Region', 'gridSpace'))
gridInc = eval(cnfGetIniValue(configFile, 'Region', 'gridInc'))
kdeType = cnfGetIniValue(configFile, 'StatInterface', 'kdeType')
kdeStep = cnfGetIniValue(configFile, 'StatInterface', 'kdeStep', 0.1)
minSamplesCell = cnfGetIniValue(configFile, 'StatInterface',
'minSamplesCell', 100)
missingValue = cnfGetIniValue(configFile, 'StatInterface',
'MissingValue', sys.maxint)
gDist = GenerateDistributions(configFile, gridLimit, gridSpace, gridInc, kdeType,
minSamplesCell, missingValue)
def startup():
"""
Parse the command line arguments and call the :func:`main`
function.
"""
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--config_file',
help='Path to configuration file')
parser.add_argument('-v',
'--verbose',
help='Verbose output',
action='store_true')
parser.add_argument('-d',
'--debug',
help='Allow pdb traces',
action='store_true')
args = parser.parse_args()
configFile = args.config_file
config = ConfigParser()
config.read(configFile)
rootdir = pathLocator.getRootDirectory()
os.chdir(rootdir)
logfile = config.get('Logging', 'LogFile')
logdir = dirname(realpath(logfile))
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tcrm.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
debug = False
if args.verbose:
verbose = True
if args.debug:
debug = True
flStartLog(logfile, logLevel, verbose, datestamp)
# Switch off minor warning messages
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="pytz")
warnings.filterwarnings("ignore", category=UserWarning, module="numpy")
warnings.filterwarnings("ignore",
category=UserWarning,
module="matplotlib")
warnings.filterwarnings("ignore", category=RuntimeWarning)
if debug:
main(configFile)
else:
try:
main(configFile)
except ImportError as e:
log.critical("Missing module: {0}".format(e.strerror))
except Exception: # pylint: disable=W0703
# Catch any exceptions that occur and log them (nicely):
tblines = traceback.format_exc().splitlines()
for line in tblines:
log.critical(line.lstrip())
# If log file directory does not exist, create it
if not isdir(logdir):
try:
os.makedirs(logdir)
except OSError:
logfile = pjoin(os.getcwd(), 'tracks2shp.log')
logLevel = config.get('Logging', 'LogLevel')
verbose = config.getboolean('Logging', 'Verbose')
datestamp = config.getboolean('Logging', 'Datestamp')
if args.verbose:
verbose = True
flStartLog(logfile, logLevel, verbose, datestamp)
if args.file:
track_file = args.file
else:
track_file = config.get('DataProcess', 'InputFile')
if args.source:
source = args.source
else:
source = config.get('DataProcess', 'Source')
output_path = dirname(realpath(track_file))
filename, ext = splitext(track_file)
pt_output_file = filename + '_pt.shp'
line_output_file = filename + '_line.shp'
'testinterp3d.pck'), 'r')
self.xlon = cPickle.load(pfile)
self.ylat = cPickle.load(pfile)
self.ztime = cPickle.load(pfile)
self.values = cPickle.load(pfile)
pfile.close()
self.coords = numpy.array([self.ztime, self.ylat, self.xlon])
def test_interp3d(self):
"""Test interp3d returns expected values"""
output = interp3d.interp3d(self.data, self.coords,
self.scale, self.offset)
self.numpyAssertAlmostEqual(output, self.values)
def test_interp3d_2dinput(self):
"""Test interp3d raises ValueError if input_array is 2D"""
self.assertRaises(ValueError,
interp3d.interp3d,
self.data[1, :, :],
self.coords,
self.scale,
self.offset)
if __name__ == "__main__":
flStartLog('', 'CRITICAL', False)
testSuite = unittest.makeSuite(TestInterp3d,'test')
unittest.TextTestRunner(verbosity=2).run(testSuite)
dtype = {"stnNum":str}
stndf = pd.read_csv(stnFile, skipinitialspace=True, names=names,
index_col=False, dtype=dtype) #, skiprows=1)
log.info("Loaded details of {0} stations".format(len(stndf.index)))
return stndf
#------------------------------------------------
# Main execution code:
input_path = "C:/WorkSpace/data/daily/input/"
output_path = "C:/WorkSpace/data/daily/output/2006"
logfile = pjoin(output_path, "estimate_return_period.log")
loglevel = "INFO"
log = flStartLog(logfile, loglevel, True, True)
stationFile = pjoin(input_path, "DC02D_StnDet_99999999720437.txt")
stndf = readStationFile(stationFile)
basefile = "DC02D_Data_{0}_99999999720437.txt"
gpdfile = open(pjoin(output_path, "gpdtable_ms.csv"), 'w')
gpdfile.write("Station, Name, shape, scale, threshold, rate\n")
rp = np.array([1, 2, 5, 10, 20, 50, 100, 200,
500, 1000, 2000, 5000, 10000])
rpfile = open(pjoin(output_path, "rptable_ms.csv"), 'w')
rpfile.write("Station, Name," + ", ".join(rp.astype(str)) + "\n")
