def __init__(self, parameter, lonLat, gridLimit, gridSpace, gridInc, minSample=100, angular=False, missingValue=sys.maxsize, progressbar=None, prgStartValue=0, prgEndValue=1, calculateLater=False): self.logger = logging.getLogger() self.logger.debug('Initialising GenerateStats') self.gridLimit = gridLimit self.gridSpace = gridSpace self.gridInc = gridInc self.maxCell = stats.maxCellNum(self.gridLimit, self.gridSpace) self.minSample = minSample self.coeffs = parameters(self.maxCell+1) self.angular = angular self.missingValue = missingValue self.domain_warning_raised = False self.progressbar = progressbar self.prgStartValue = prgStartValue self.prgEndValue = prgEndValue if not calculateLater: if type(lonLat) is str: self.lonLat = np.array(flLoadFile(lonLat, delimiter=',')) else: self.lonLat = lonLat if type(parameter) is str: self.param = np.array(flLoadFile(parameter)) else: self.param = parameter self.calculateStatistics()
def setKDEOrigins(self, kdeOriginX=None, kdeOriginY=None, kdeOriginZ=None, outputPath=None): """set kde origin parameters """ if outputPath: try: self.x, self.y. self.z = grdRead(os.path.join(self.outputPath, 'originPDF.txt')) except IOError: self.logger.critical('Error! Files relating to KDE of cyclone origins does not exist. Execute KDE of cyclone origins first.') raise self._calculateCDF() #calculate CDF of (x,Px) and (y,Py) elif type(kdeOriginZ) == str: try: self.x = flLoadFile(kdeOriginX) self.y = flLoadFile(kdeOriginY) self.z = flLoadFile(kdeOriginZ) except IOError: self.logger.critical('Error! Files relating to CDF of cyclone parameters do not exist. Generate KDE of cyclone parameters first.') raise self._calculateCDF() # calculate CDF of (x,Px) and (y,Py) elif type(kdeOriginZ) == ndarray: self.x, self.y, self.z = grdRead(kdeOriginZ) self._calculateCDF() # calculate CDF of (x,Px) and (y,Py) else: self.logger.error("No input arguments") raise
def __init__(self, parameter, lonLat, gridLimit, gridSpace, gridInc, minSample=100, angular=False, missingValue=sys.maxint, progressbar=None, prgStartValue=0, prgEndValue=1, calculateLater=False): self.logger = logging.getLogger() self.logger.debug('Initialising GenerateStats') self.gridLimit = gridLimit self.gridSpace = gridSpace self.gridInc = gridInc self.maxCell = stats.maxCellNum(self.gridLimit, self.gridSpace) self.minSample = minSample self.coeffs = parameters(self.maxCell+1) self.angular = angular self.missingValue = missingValue self.domain_warning_raised = False self.progressbar = progressbar self.prgStartValue = prgStartValue self.prgEndValue = prgEndValue if not calculateLater: if type(lonLat) is str: self.lonLat = np.array(flLoadFile(lonLat, delimiter=',')) else: self.lonLat = lonLat if type(parameter) is str: self.param = np.array(flLoadFile(parameter)) else: self.param = parameter self.calculateStatistics()
def setKDEOrigins(self, kdeOriginX=None, kdeOriginY=None, kdeOriginZ=None, outputPath=None): """ Set kernel density estimation origin parameters. :param kdeOriginX: x coordinates of kde result generated from :class:`KDEOrigin` :param kdeOriginY: y coordinates of kde result generated from :class:`KDEOrigin` :param kdeOriginZ: z coordinates of kde result generated from :class:`KDEOrigin` :param outputPath: Path to output folder to load PDF file. :type kdeOriginX: str or :class:`numpy.ndarray` :type kdeOriginY: str or :class:`numpy.ndarray` :type kdeOriginZ: str or :class:`numpy.ndarray` :type outputPath: str """ if outputPath: try: self.x, self.y, self.z = grdRead( pjoin(self.outputPath, 'originPDF.txt')) except IOError: LOG.critical(('Error! Files relating to KDE of cyclone ' 'origins does not exist. Execute KDE of ' 'cyclone origins first.')) raise self._calculateCDF() elif isinstance(kdeOriginZ, str): try: self.x = flLoadFile(kdeOriginX) self.y = flLoadFile(kdeOriginY) self.z = flLoadFile(kdeOriginZ) except IOError: LOG.critical(('Error! Files relating to CDF of cyclone ' 'parameters do not exist. Generate KDE of ' 'cyclone parameters first.')) raise self._calculateCDF() elif isinstance(kdeOriginZ, np.ndarray): self.x, self.y, self.z = grdRead(kdeOriginZ) self._calculateCDF() else: LOG.error("No input arguments") raise
def generateGenesisDateCDF(self, genDays, lonLat, bw=None, genesisKDE=None): """ Calculate the PDF of genesis day using KDEs. Since the data is periodic, we use a simple method to include the periodicity in estimating the PDF. We prepend and append the data to itself, then use the central third of the PDF and multiply by three to obtain the required PDF. Probably notquite exact, but it should be sufficient for our purposes. """ data = flLoadFile( genDays ) days = np.arange( 1, 366 ) ndays = np.concatenate( [days - 365, days, days + 365] ) ndata = np.concatenate( [data - 365, data, data + 365] ) if bw is None: bw = KPDF.UPDFOptimumBandwidth( ndata ) try: kdeMethod = getattr(KPDF, "UPDF%s" %self.kdeType) except AttributeError: self.logger.exception("Invalid input on option: KDE method UPDF%s does not exist"%self.kdeType) raise pdf = kdeMethod( ndata, ndays, bw ) # Actual PDF to return apdf = 3.0*pdf[365:730] cy = stats.cdf(days, apdf) if genesisKDE is None: return np.transpose(np.array(np.concatenate( [days, apdf, cy] ) )) else: # Assume both kdeParameters and cdfParameters are defined as files: self.logger.debug("Saving KDE and CDF data to files") #flSaveFile(genesisKDE, transpose(numpy.concatenate([days, pdf]))) flSaveFile(genesisKDE, np.transpose(np.array([days, cy])))
def __init__(self, configFile, kdeType, gridLimit, kdeStep, lonLat=None, progressbar=None): """ """ self.logger = logging.getLogger() self.progressbar = progressbar if self.progressbar: KPDF.set_callback(self.updateProgressBar) self.logger.info("Initialising KDEOrigins") self.configFile = configFile self.x = numpy.arange(gridLimit['xMin'], gridLimit['xMax'], kdeStep) self.y = numpy.arange(gridLimit['yMax'], gridLimit['yMin'], -kdeStep) self.kdeType = kdeType self.kdeStep = kdeStep config = ConfigParser() config.read(configFile) if lonLat is None: self.outputPath = config.get('Output', 'Path') self.processPath = os.path.join(self.outputPath, 'process') self.logger.debug("Loading "+os.path.join(self.processPath, 'init_lon_lat')) ll = flLoadFile(os.path.join(self.processPath, 'init_lon_lat'), '%', ',') self.lonLat = ll[:,0:2] else: self.lonLat = lonLat[:,0:2] self.bw = KPDF.MPDFOptimumBandwidth(self.lonLat) self.logger.debug("Optimal bandwidth: %f"%self.bw)
def generateGenesisDateCDF(self, genDays, lonLat, bw=None, genesisKDE=None): """ Calculate the PDF of genesis day using KDEs. Since the data is periodic, we use a simple method to include the periodicity in estimating the PDF. We prepend and append the data to itself, then use the central third of the PDF and multiply by three to obtain the required PDF. Probably not quite exact, but it should be sufficient for our purposes. :param str genDays: Name of file containing genesis days (as day of year). :param lonLat: Array of genesis longitudes and latitudes. :param float bw: Optional. Bandwidth of the KDE to use. :param str genesisKDE: Optional. File name to save resulting CDF to. :type lonLat: :class:`numpy.ndarray` :returns: :class:`numpy.ndarray` containing the days, the PDF and CDF of the genesis days. """ data = flLoadFile(genDays) days = np.arange(1, 366) ndays = np.concatenate([days - 365, days, days + 365]) ndata = np.concatenate([data - 365, data, data + 365]) if bw is None: bw = stats.bandwidth(self.parameters) kde = sm.nonparametric.KDEUnivariate(self.parameters) kde.fit(kernel=self.kdeType, bw=bw, fft=False, gridsize=len(grid), clip=(min(grid), max(grid)), cut=0) #try: # kdeMethod = getattr(KPDF, "UPDF%s" % self.kdeType) #except AttributeError: # LOG.exception(("Invalid input on option: " # "KDE method UPDF%s does not exist"), # self.kdeType) # raise veceval = np.vectorize(kde.evaluate) pdf = np.nan_to_num(veceval(grid)) # Actual PDF to return apdf = 3.0 * pdf[365:730] cy = stats.cdf(days, apdf) if genesisKDE is None: return np.transpose(np.array(np.concatenate([days, apdf, cy]))) else: # Assume both kdeParameters and cdfParameters are defined as files: LOG.debug("Saving KDE and CDF data to files") flSaveFile(genesisKDE, np.transpose(np.array([days, cy])))
def __init__(self, lon_lat, bearing_list, speed_list, pressure_list, bearing_rate_list, speed_rate_list, pressure_rate_list, cellNum, gridLimit, gridSpace): """ initialize the data needed for the plots including longitudes & latitudes of cyclone origins, cyclone bearings, cyclone speeds, cyclone pressures, as well as calculating and storing the cyclone index counts for a specific inputted cell number """ self.gridLimit = gridLimit self.gridSpace = gridSpace self.lonlat = files.flLoadFile(lon_lat, '%', ',') self.bearing_list = files.flLoadFile(bearing_list) self.speed_list = files.flLoadFile(speed_list) self.pressure_list = files.flLoadFile(pressure_list) self.bearingRate_list = files.flLoadFile(bearing_rate_list) self.speedRate_list = files.flLoadFile(speed_rate_list) self.pressureRate_list = files.flLoadFile(pressure_rate_list) self.cellNum = cellNum self.extractParameters(cellNum)
def calc(self): """ Calculate the frequency of TC events in a pre-defined domain, based on the input dataset and the full range of years contained in the :attr:`origin_year` file. The :attr:`origin_year` file is created in :class:`DataProcess.processData` and restricts the range to a user-selected range of years. """ logger.info("Calculating annual frequency of TC events") origin_year = np.array(flLoadFile( pjoin(self.outputPath, 'process', 'origin_year'), '%', ','), dtype='int') origin_lon_lat = flLoadFile( pjoin(self.outputPath, 'process', 'origin_lon_lat'), '%', ',') origin_lon = origin_lon_lat[:, 0] origin_lat = origin_lon_lat[:, 1] min_year = origin_year.min() # Skip last year from average since may contain only partial year record max_year = origin_year.max() - 1 freq_count = np.zeros(3000) for year in range(min_year, max_year + 1): freq_count[year] = sum((origin_year == year) & \ (origin_lon > self.tg_domain['xMin']) & \ (origin_lon < self.tg_domain['xMax']) & \ (origin_lat > self.tg_domain['yMin']) & \ (origin_lat < self.tg_domain['yMax'])) freq = np.mean(freq_count[min_year:max_year + 1]) freq = np.round(freq * 100) / 100 fname = pjoin(self.outputPath, 'process', 'region_frequency') data = np.array([ np.arange(min_year, max_year + 1), freq_count[min_year:max_year + 1] ]) header = "Year,count" np.savetxt(fname, data.T, fmt="%d", delimiter=",", header=header) return freq
def calc(self): """ Calculate the frequency of TC events in a pre-defined domain, based on the input dataset and the full range of years contained in the :attr:`origin_year` file. The :attr:`origin_year` file is created in :class:`DataProcess.processData` and restricts the range to a user-selected range of years. """ logger.info("Calculating annual frequency of TC events") origin_year = np.array(flLoadFile(pjoin(self.outputPath, 'process', 'origin_year'), '%', ','), dtype='int') origin_lon_lat = flLoadFile(pjoin(self.outputPath, 'process', 'origin_lon_lat'), '%', ',') origin_lon = origin_lon_lat[:, 0] origin_lat = origin_lon_lat[:, 1] min_year = origin_year.min() # Skip last year from average since may contain only partial year record max_year = origin_year.max() - 1 freq_count = np.zeros(3000) for year in range(min_year, max_year + 1): freq_count[year] = sum((origin_year == year) & \ (origin_lon > self.tg_domain['xMin']) & \ (origin_lon < self.tg_domain['xMax']) & \ (origin_lat > self.tg_domain['yMin']) & \ (origin_lat < self.tg_domain['yMax'])) freq = np.mean(freq_count[min_year:max_year + 1]) freq = np.round(freq*100)/100 fname = pjoin(self.outputPath, 'process', 'region_frequency') X = np.array([np.arange(min_year,max_year + 1), freq_count[min_year:max_year + 1]]) header = "Year,count" np.savetxt(fname, X.T, fmt="%d", delimiter=",", header=header) return freq
def setKDEOrigins(self, kdeOriginX=None, kdeOriginY=None, kdeOriginZ=None, outputPath=None): """ Set kernel density estimation origin parameters. :param kdeOriginX: x coordinates of kde result generated from :class:`KDEOrigin` :param kdeOriginY: y coordinates of kde result generated from :class:`KDEOrigin` :param kdeOriginZ: z coordinates of kde result generated from :class:`KDEOrigin` :param outputPath: Path to output folder to load PDF file. :type kdeOriginX: str or :class:`numpy.ndarray` :type kdeOriginY: str or :class:`numpy.ndarray` :type kdeOriginZ: str or :class:`numpy.ndarray` :type outputPath: str """ if outputPath: try: self.x, self.y. self.z = grdRead(os.path.join(self.outputPath, 'originPDF.txt')) except IOError: self.logger.critical('Error! Files relating to KDE of cyclone origins does not exist. Execute KDE of cyclone origins first.') raise self._calculateCDF() #calculate CDF of (x,Px) and (y,Py) elif type(kdeOriginZ) == str: try: self.x = flLoadFile(kdeOriginX) self.y = flLoadFile(kdeOriginY) self.z = flLoadFile(kdeOriginZ) except IOError: self.logger.critical('Error! Files relating to CDF of cyclone parameters do not exist. Generate KDE of cyclone parameters first.') raise self._calculateCDF() # calculate CDF of (x,Px) and (y,Py) elif type(kdeOriginZ) == np.ndarray: self.x, self.y, self.z = grdRead(kdeOriginZ) self._calculateCDF() # calculate CDF of (x,Px) and (y,Py) else: self.logger.error("No input arguments") raise
def __init__(self, configFile): """ Read configuration settings, load station data and set up output recarrays. :param str configFile: path to a configuration file. """ config = ConfigParser() config.read(configFile) self.meta = False stnFile = config.get('Timeseries', 'LocationFile') self.outputPath = pjoin(config.get('Output', 'Path'), 'process', 'timeseries') self.maxfile = pjoin(config.get('Output', 'Path'), 'process', 'maxima.csv') self.minfile = pjoin(config.get('Output', 'Path'), 'process', 'minima.csv') log.info(f"Loading timeseries stations from {stnFile}") log.debug(f"Timeseries data will be written into {self.outputPath}") self.stations = [] if stnFile.endswith("shp"): try: key_name = config.get('Timeseries', 'StationID') except NoOptionError: key_name = None vertices = shpGetVertices(stnFile, key_name=key_name) for stn in list(vertices.keys()): lat = vertices[stn][0][1] lon = vertices[stn][0][0] lon = np.where(lon < 0., lon + 360., lon) self.stations.append(Station(stn, lon, lat)) else: stndata = flLoadFile(stnFile, delimiter=',') # If there are more than 3 columns, save the additional # columns as 'metadata' if stndata.shape[1] > 3: self.metadata = stndata[:, 3:] self.meta = True stnid = stndata[:, 0] stnlon = stndata[:, 1].astype(float) stnlat = stndata[:, 2].astype(float) for sid, lon, lat in zip(stnid, stnlon, stnlat): self.stations.append(Station(sid, lon, lat)) log.info(f"There are {len(self.stations)} stations that will collect timeseries data")
def __init__(self, configFile): """ Read configuration settings, load station data and set up output recarrays. :param str configFile: path to a configuration file. """ config = ConfigParser() config.read(configFile) self.meta = False stnFile = config.get('Timeseries', 'StationFile') self.outputPath = pjoin(config.get('Output', 'Path'), 'process', 'timeseries') self.maxfile = pjoin(config.get('Output', 'Path'), 'process', 'maxima.csv') self.minfile = pjoin(config.get('Output', 'Path'), 'process', 'minima.csv') log.debug("Loading stations from %s"%stnFile) log.debug("Timeseries data will be written into %s"%self.outputPath) self.stations = [] if stnFile.endswith("shp"): try: key_name = config.get('Timeseries', 'StationID') except NoOptionError: key_name = None vertices = shpGetVertices(stnFile, key_name=key_name) for stn in vertices.keys(): self.stations.append(Station(stn, vertices[stn][0][0], vertices[stn][0][1])) else: stndata = flLoadFile(stnFile, delimiter=',') # If there are more than 3 columns, save the additional # columns as 'metadata' if stndata.shape[1] > 3: self.metadata = stndata[:, 3:] self.meta = True stnid = stndata[:, 0] stnlon = stndata[:, 1].astype(float) stnlat = stndata[:, 2].astype(float) for sid, lon, lat in zip(stnid, stnlon, stnlat): self.stations.append(Station(sid, lon, lat))
def setParameters(self, cdfParameters): """Set parameters """ if type(cdfParameters) == str: try: self.xacy = flLoadFile(cdfParameters) except IOError: self.logger.exception('Error! Files relating to cdf of cyclone parameters does not exist, please generate KDE of cyclone parameters first.') raise else: self.xacy = cdfParameters return self
def generateGenesisDateCDF(self, genDays, lonLat, bw=None, genesisKDE=None): """ Calculate the PDF of genesis day using KDEs. Since the data is periodic, we use a simple method to include the periodicity in estimating the PDF. We prepend and append the data to itself, then use the central third of the PDF and multiply by three to obtain the required PDF. Probably not quite exact, but it should be sufficient for our purposes. :param str genDays: Name of file containing genesis days (as day of year). :param lonLat: Array of genesis longitudes and latitudes. :param float bw: Optional. Bandwidth of the KDE to use. :param str genesisKDE: Optional. File name to save resulting CDF to. :type lonLat: :class:`numpy.ndarray` :returns: :class:`numpy.ndarray` containing the days, the PDF and CDF of the genesis days. """ data = flLoadFile(genDays) days = np.arange(1, 366) ndays = np.concatenate([days - 365, days, days + 365]) ndata = np.concatenate([data - 365, data, data + 365]) if bw is None: bw = KPDF.UPDFOptimumBandwidth(ndata) try: kdeMethod = getattr(KPDF, "UPDF%s" % self.kdeType) except AttributeError: LOG.exception(("Invalid input on option: " "KDE method UPDF%s does not exist"), self.kdeType) raise pdf = kdeMethod(ndata, ndays, bw) # Actual PDF to return apdf = 3.0 * pdf[365:730] cy = stats.cdf(days, apdf) if genesisKDE is None: return np.transpose(np.array(np.concatenate([days, apdf, cy]))) else: # Assume both kdeParameters and cdfParameters are defined as files: LOG.debug("Saving KDE and CDF data to files") flSaveFile(genesisKDE, np.transpose(np.array([days, cy])))
def __init__(self, cdfParameters=None): """Initialize the data needed for the plots including CDF of cyclone parameters """ self.logger = logging.getLogger() if type(cdfParameters) == str: try: self.xacy = flLoadFile(cdfParameters) except IOError: self.logger.exception('Error! Files relating to cdf of cyclone parameters does not exist, please generate KDE of cyclone parameters first.') raise elif type(cdfParameters) == ndarray: self.xacy = cdfParameters else: self.xacy = array([])
def __init__(self, cdfParameters=None): """Initialize the data needed for the plots including CDF of cyclone parameters """ self.logger = logging.getLogger() if type(cdfParameters) == str: try: self.xacy = flLoadFile(cdfParameters) except IOError: self.logger.exception('Error! Files relating to cdf of cyclone parameters does not exist, please generate KDE of cyclone parameters first.') raise elif type(cdfParameters) == np.ndarray: self.xacy = cdfParameters else: self.xacy = np.array([])
def __init__(self, configFile, gridLimit, kdeStep, lonLat=None, progressbar=None): """ """ self.progressbar = progressbar LOGGER.info("Initialising KDEOrigin") self.x = np.arange(gridLimit['xMin'], gridLimit['xMax'], kdeStep) self.y = np.arange(gridLimit['yMax'], gridLimit['yMin'], -kdeStep) self.kdeStep = kdeStep self.kde = None self.pdf = None self.cz = None self.configFile = configFile self.config = ConfigParser() self.config.read(configFile) if lonLat is None: # Load the data from file: self.outputPath = self.config.get('Output', 'Path') self.processPath = pjoin(self.outputPath, 'process') LOGGER.debug("Loading " + pjoin(self.processPath, 'init_lon_lat')) ll = flLoadFile(pjoin(self.processPath, 'init_lon_lat'), '%', ',') self.lonLat = ll[:, 0:2] else: self.lonLat = lonLat[:, 0:2] ii = np.where((self.lonLat[:, 0] >= gridLimit['xMin']) & (self.lonLat[:, 0] <= gridLimit['xMax']) & (self.lonLat[:, 1] >= gridLimit['yMin']) & (self.lonLat[:, 1] <= gridLimit['yMax'])) self.lonLat = self.lonLat[ii] self.bw = getOriginBandwidth(self.lonLat) LOGGER.info("Bandwidth: %s", repr(self.bw))
def calcDomainFromFile(self): """ Calculate track generation domain, using a file as the input source :rtype: dict :returns: the domain where the tracks will be generated. The :class:`dict` should contain the keys :attr:`xMin`, :attr:`xMax`, :attr:`yMin` and :attr:`yMax`. The *x* variable bounds the longitude and the *y* variable bounds the latitude. """ # Load tracks from file cyclone_tracks = flLoadFile( pjoin(self.outputPath, 'process', 'cyclone_tracks'), '%', ',') tg_domain = self.calc(cyclone_tracks[:, 0], cyclone_tracks[:, 1], cyclone_tracks[:, 2]) return tg_domain
def calcDomainFromFile(self): """ Calculate track generation domain, using a file as the input source :rtype tg_domain: :class:`dict` :return tg_domain: the domain where the tracks will be generated. The :class:`dict` should contain the keys :attr:`xMin`, :attr:`xMax`, :attr:`yMin` and :attr:`yMax`. The *x* variable bounds the longitude and the *y* variable bounds the latitude. """ # Load tracks from file cyclone_tracks = flLoadFile(pjoin(self.outputPath, 'process', 'cyclone_tracks'), '%', ',') tg_domain = self._calc(cyclone_tracks[:, 0], cyclone_tracks[:, 1], cyclone_tracks[:, 2]) return tg_domain
def setParameters(self, cdfParameters): """ Set parameters. :param cdfParameters: Name of a file containing the CDF of a parameter, or the actual CDF values. :type cdfParamters: str or :class:`numpy.ndarray` :raises IOError: If the CDF files do not exist. """ if type(cdfParameters) == str: try: self.xacy = flLoadFile(cdfParameters) except IOError: self.logger.exception('Error! Files relating to cdf of cyclone parameters does not exist, please generate KDE of cyclone parameters first.') raise else: self.xacy = cdfParameters return self
def setParameters(self, cdfParameters): """ Set parameters. :param cdfParameters: Name of a file containing the CDF of a parameter, or the actual CDF values. :type cdfParamters: str or :class:`numpy.ndarray` :raises IOError: If the CDF files do not exist. """ if type(cdfParameters) == str: try: self.xacy = flLoadFile(cdfParameters) except IOError: self.logger.exception( "Error! Files relating to cdf of cyclone parameters does not exist, please generate KDE of cyclone parameters first." ) raise else: self.xacy = cdfParameters return self
def main(): import Utilities.files as files from os.path import join as pjoin, dirname, normpath baseDir = normpath(pjoin(dirname(__file__), '..')) inputPath = pjoin(baseDir, 'output', 'process') saveWindProfilesFigure(-12., 130., 100700., 95000., 30., 1.6) pressureRates = files.flLoadFile(pjoin(inputPath, 'pressure_rate')) pressures = files.flLoadFile(pjoin(inputPath, 'all_pressure')) savePressureFigure(pressures, pressureRates) speedRates = files.flLoadFile(pjoin(inputPath, 'speed_rate')) speeds = files.flLoadFile(pjoin(inputPath, 'all_speed')) saveSpeedFigures(speeds, speedRates) bearingRates = files.flLoadFile(pjoin(inputPath, 'bearing_rate')) bearings = files.flLoadFile(pjoin(inputPath, 'all_bearing')) saveBearingFigure(bearings, bearingRates) freq = files.flLoadFile(pjoin(inputPath, 'frequency')) saveFrequencyFigure(np.array(freq[:,0],int), freq[:,1])
def main(): import Utilities.files as files from os.path import join as pjoin, dirname, normpath baseDir = normpath(pjoin(dirname(__file__), '..')) inputPath = pjoin(baseDir, 'output', 'process') saveWindProfilesFigure(-12., 130., 100700., 95000., 30., 1.6) pressureRates = files.flLoadFile(pjoin(inputPath, 'pressure_rate')) pressures = files.flLoadFile(pjoin(inputPath, 'all_pressure')) savePressureFigure(pressures, pressureRates) speedRates = files.flLoadFile(pjoin(inputPath, 'speed_rate')) speeds = files.flLoadFile(pjoin(inputPath, 'all_speed')) saveSpeedFigures(speeds, speedRates) bearingRates = files.flLoadFile(pjoin(inputPath, 'bearing_rate')) bearings = files.flLoadFile(pjoin(inputPath, 'all_bearing')) saveBearingFigure(bearings, bearingRates) freq = files.flLoadFile(pjoin(inputPath, 'frequency')) saveFrequencyFigure(np.array(freq[:, 0], int), freq[:, 1])
def allDistributions(self, lonLat, parameterList, parameterName=None, kdeStep=0.1, angular=False, periodic=False, plotParam=False): """ Calculate a distribution for each individual cell and store in a file or return the distribution. :param lonLat: The longitude/latitude of all observations in the model domain. If a string is given, then it is the path to a file containing the longitude/latitude information. If an array is given, then it should be a 2-d array containing the data values. :type lonLat: str or :class:`numpy.ndarray` :param parameterList: Parameter values. If a string is given, then it is the path to a file containing the values. If an array is passed, then it should hold the parameter values. :type parameterList: str or :class:`numpy.ndarray` :param str parameterName: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param kdeStep: Increment of the ordinate values at which the distributions will be calculated. :type kdeStep: float, default=`0.1` :param angular: Does the data represent an angular measure (e.g. bearing). :type angular: boolean, default=``False`` :param periodic: Does the data represent some form of periodic data (e.g. day of year). If given, it should be the period of the data (e.g. for annual data, ``periodic=365``). :type periodic: boolean or float, default=``False`` :param boolean plotParam: Plot the parameters. Default is ``False``. :returns: If no ``parameterName`` is given returns ``None`` (data are saved to file), otherwise :class:`numpy.ndarray`. """ if parameterName: self.logger.debug("Running allDistributions for %s", parameterName) else: self.logger.debug("Running allDistributions") if isinstance(lonLat, str): self.logger.debug("Loading lat/lon data from file") self.lonLat = np.array(flLoadFile(lonLat, delimiter=',')) else: self.lonLat = lonLat if isinstance(parameterList, str): self.logger.debug("Loading parameter data from file: %s", parameterList) self.pList = np.array(flLoadFile(parameterList)) else: self.pList = parameterList self.pName = parameterName if len(self.pList) != len(self.lonLat): errmsg = ("Parameter data and " "Lon/Lat data are not the same length " "for {}.".format(parameterName)) self.logger.critical(errmsg) raise IndexError(errmsg) maxCellNum = stats.maxCellNum(self.gridLimit, self.gridSpace) # Writing CDF dataset for all individual cell number into files self.logger.debug(("Writing CDF dataset for all individual " "cells into files")) for cellNum in range(0, maxCellNum + 1): self.logger.debug("Processing cell number %i", cellNum) # Generate cyclone parameter data for the cell number self.extractParameter(cellNum) # Estimate cyclone parameter data using KDE # The returned array contains the grid, the PDF and the CDF cdf = self.kdeParameter.generateKDE(self.parameter, kdeStep, angular=angular, periodic=periodic) if plotParam: self._plotParameter(cellNum, kdeStep) self.logger.debug(('size of parameter array = %d: ' 'size of cdf array = %d'), self.parameter.size, cdf.size) cellNumlist = [] for i in range(len(cdf)): cellNumlist.append(cellNum) if cellNum == 0: results = np.transpose(np.array([cellNumlist, cdf[:, 0], cdf[:, 2]])) else: self.logger.debug('size of results = %s', str(results.size)) results = np.concatenate((results, np.transpose(np.array([cellNumlist, cdf[:, 0], cdf[:, 2]])))) if parameterName == None: self.logger.debug(("Returning CDF dataset for all " "individual cell numbers")) return results else: cdfHeader = "Cell_Number, CDF_" + self.pName + "_x, CDF_" + \ self.pName + "_y" allCellCdfOutput = pjoin(self.outputPath, 'process', 'all_cell_cdf_' + self.pName) args = {"filename":allCellCdfOutput, "data":results, "header":cdfHeader, "delimiter":",", "fmt":"%f"} self.logger.debug(("Writing CDF dataset for all individual " "cell numbers into files")) flSaveFile(**args) # Save to netcdf too filename = allCellCdfOutput + '.nc' ncdf = Dataset(filename, 'w') ncdf.createDimension('cell', len(results[:, 0])) cell = ncdf.createVariable('cell', 'i', ('cell',)) cell[:] = results[:, 0] x = ncdf.createVariable('x', 'f', ('cell',)) x[:] = results[:, 1] y = ncdf.createVariable('CDF', 'f', ('cell',)) y[:] = results[:, 2] ncdf.close()
def allDistributions(self, lonLat, parameterList, parameterName=None, kdeStep=0.1, angular=False, periodic=False, plotParam=False): """ Calculate a distribution for each individual cell and store in a file or return """ if parameterName: self.logger.debug("Running allDistributions for %s"%parameterName) else: self.logger.debug("Running allDistributions") if type(lonLat) is str: self.logger.debug("Loading lat/lon data from file") self.lonLat = np.array(flLoadFile(lonLat, delimiter=',')) else: self.lonLat = lonLat if type(parameterList) is str: self.logger.debug("Loading parameter data from file: %s" % parameterList) self.pList = np.array(flLoadFile(parameterList)) else: self.pList = parameterList self.pName = parameterName maxCellNum = stats.maxCellNum(self.gridLimit, self.gridSpace) # Writing CDF dataset for all individual cell number into files self.logger.debug("Writing CDF dataset for all individual cells into files") for cellNum in xrange(0, maxCellNum + 1): self.logger.debug("Processing cell number %i"%cellNum) # Generate cyclone parameter data for the cell number self.extractParameter(cellNum) # Estimate cyclone parameter data using KDE # The returned array contains the grid, the PDF and the CDF cdf = self.kdeParameter.generateKDE(self.parameter, kdeStep, angular=angular, periodic=periodic) if plotParam: self._plotParameter(cellNum, kdeStep) self.logger.debug('size of parameter array = %d: size of cdf array = %d' % (self.parameter.size,cdf.size)) cellNumlist = [] for i in range(len(cdf)): cellNumlist.append(cellNum) if cellNum == 0: results = np.transpose(np.array([cellNumlist, cdf[:,0], cdf[:,2]])) else: self.logger.debug('size of results array = %s'%str(results.size)) results = np.concatenate((results, np.transpose(np.array([cellNumlist, cdf[:,0], cdf[:,2]])))) if parameterName == None: self.logger.debug("Returning CDF dataset for all individual cell numbers") return results else: cdfHeader = "Cell_Number, CDF_" + self.pName + "_x, CDF_" + \ self.pName + "_y" allCellCdfOutput = pjoin(self.outputPath, 'process', 'all_cell_cdf_' + self.pName) args = {"filename":allCellCdfOutput, "data":results, "header":cdfHeader, "delimiter":",", "fmt":"%f"} self.logger.debug("Writing CDF dataset for all individual cell numbers into files") flSaveFile(**args) # Save to netcdf too filename = allCellCdfOutput + '.nc' ncdf = Dataset(filename, 'w') ncdf.createDimension('cell', len(results[:,0])) cell = ncdf.createVariable('cell', 'i', ('cell',)) cell[:] = results[:,0] x = ncdf.createVariable('x', 'f', ('cell',)) x[:] = results[:,1] y = ncdf.createVariable('CDF', 'f', ('cell',)) y[:] = results[:,2] ncdf.close()
def generateKDE(self, parameters, kdeStep, kdeParameters=None, cdfParameters=None, angular=False, periodic=False, missingValue=sys.maxint): """ Generate a PDF and CDF for a given parameter set using the method of kernel density estimators. Optionally return the PDF and CDF as an array, or write both to separate files. """ self.logger.debug("Running generateKDE") if type(parameters) is str: self.parameters = stats.statRemoveNum(flLoadFile(parameters, '%', ','), missingValue) else: if parameters.size <= 1: self.logger.error("Insufficient members in parameter list") raise IndexError, "Insufficient members in parameter list" self.parameters = stats.statRemoveNum(parameters, missingValue) if angular: xmin = 0.0 xmax = 360.0 elif periodic: xmin = 0.0 xmax = periodic else: xmin = self.parameters.min() xmax = self.parameters.max() self.logger.debug("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f" % (xmin, xmax, kdeStep)) if periodic: x = np.arange(1, periodic + 1, kdeStep) self.grid = np.concatenate( [x - periodic, x, x + periodic] ) self.parameters = np.concatenate([self.parameters - periodic, self.parameters, self.parameters + periodic]) else: self.grid = np.arange(xmin, xmax, kdeStep) if self.grid.size<2: self.logger.critical("Grid for CDF generation is a single value") self.logger.critical("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f" % (xmin, xmax,kdeStep)) raise ValueError bw = KPDF.UPDFOptimumBandwidth(self.parameters) self.pdf = self._generatePDF(self.grid, bw, self.parameters) if periodic: self.pdf = 3.0*self.pdf[(periodic/kdeStep):2*(periodic/kdeStep)] self.grid = self.grid[(periodic/kdeStep):2*(periodic/kdeStep)] self.cy = stats.cdf(self.grid, self.pdf) if kdeParameters is None: return np.transpose(np.array([self.grid, self.pdf, self.cy])) else: # Assume both kdeParameters and cdfParameters are defined as files: self.logger.debug("Saving KDE and CDF data to files") flSaveFile(kdeParameters, np.transpose(np.array([self.grid, self.pdf]))) flSaveFile(cdfParameters, np.transpose(np.array([self.grid, self.cy])))
def testLoadFile(self): """Test flLoadFile loads data correctly""" data = files.flLoadFile(self.testfile, comments='%', delimiter=',') assert_almost_equal(self.lon, data[:, 0]) assert_almost_equal(self.lat, data[:, 1])
def generateKDE(self, parameters, kdeStep, kdeParameters=None, cdfParameters=None, angular=False, periodic=False, missingValue=sys.maxsize): """ Generate a PDF and CDF for a given parameter set using the method of kernel density estimators. Optionally return the PDF and CDF as an array, or write both to separate files. :param parameters: Parameter values. If a string is given, then it is the path to a file containing the values. If an array is passed, then it should hold the parameter values. :param kdeStep: Increment of the ordinate values at which the distributions will be calculated. :type kdeStep: float, default=`0.1` :param str kdeParameters: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param str cdfParameters: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param angular: Does the data represent an angular measure (e.g. bearing). :type angular: boolean, default=``False`` :param periodic: Does the data represent some form of periodic data (e.g. day of year). If given, it should be the period of the data (e.g. for annual data, ``periodic=365``). :type periodic: boolean or int, default=``False`` :param missingValue: Missing values have this value (default :attr:`sys.maxint`). returns: If ``kdeParameters`` is given, returns ``None`` (data are saved to file), otherwise :class:`numpy.ndarray` of the parameter grid, the PDF and CDF. """ LOG.debug("Running generateKDE") if type(parameters) is str: self.parameters = stats.statRemoveNum( flLoadFile(parameters, '%', ','), missingValue) else: if parameters.size <= 1: LOG.error("Insufficient members in parameter list") raise IndexError("Insufficient members in parameter list") self.parameters = stats.statRemoveNum(parameters, missingValue) if angular: xmin = 0.0 xmax = 360.0 elif periodic: xmin = 0.0 xmax = periodic else: xmin = self.parameters.min() xmax = self.parameters.max() LOG.debug("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f" % (xmin, xmax, kdeStep)) if periodic: x = np.arange(1, periodic + 1, kdeStep) self.grid = np.concatenate([x - periodic, x, x + periodic]) self.parameters = np.concatenate([ self.parameters - periodic, self.parameters, self.parameters + periodic ]) else: self.grid = np.arange(xmin, xmax, kdeStep) if self.grid.size < 2: LOG.critical("Grid for CDF generation is a single value") LOG.critical("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f", xmin, xmax, kdeStep) raise ValueError #bw = KPDF.UPDFOptimumBandwidth(self.parameters) bw = stats.bandwidth(self.parameters) self.pdf = self._generatePDF(self.grid, bw, self.parameters) if periodic: idx = int(periodic / kdeStep) self.pdf = 3.0 * self.pdf[idx:2 * idx] self.grid = self.grid[idx:2 * idx] self.cy = stats.cdf(self.grid, self.pdf) if kdeParameters is None: return np.transpose(np.array([self.grid, self.pdf, self.cy])) else: # Assume both kdeParameters and cdfParameters are defined as files: LOG.debug("Saving KDE and CDF data to files") flSaveFile(kdeParameters, np.transpose(np.array([self.grid, self.pdf]))) flSaveFile(cdfParameters, np.transpose(np.array([self.grid, self.cy])))
def allDistributions(self, lonLat, parameterList, parameterName=None, kdeStep=0.1, angular=False, periodic=False, plotParam=False): """ Calculate a distribution for each individual cell and store in a file or return the distribution. :param lonLat: The longitude/latitude of all observations in the model domain. If a string is given, then it is the path to a file containing the longitude/latitude information. If an array is given, then it should be a 2-d array containing the data values. :type lonLat: str or :class:`numpy.ndarray` :param parameterList: Parameter values. If a string is given, then it is the path to a file containing the values. If an array is passed, then it should hold the parameter values. :type parameterList: str or :class:`numpy.ndarray` :param str parameterName: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param kdeStep: Increment of the ordinate values at which the distributions will be calculated. :type kdeStep: float, default=`0.1` :param angular: Does the data represent an angular measure (e.g. bearing). :type angular: boolean, default=``False`` :param periodic: Does the data represent some form of periodic data (e.g. day of year). If given, it should be the period of the data (e.g. for annual data, ``periodic=365``). :type periodic: boolean or float, default=``False`` :param boolean plotParam: Plot the parameters. Default is ``False``. :returns: If no ``parameterName`` is given returns ``None`` (data are saved to file), otherwise :class:`numpy.ndarray`. """ if parameterName: self.logger.debug("Running allDistributions for %s"%parameterName) else: self.logger.debug("Running allDistributions") if type(lonLat) is str: self.logger.debug("Loading lat/lon data from file") self.lonLat = np.array(flLoadFile(lonLat, delimiter=',')) else: self.lonLat = lonLat if type(parameterList) is str: self.logger.debug("Loading parameter data from file: %s" % parameterList) self.pList = np.array(flLoadFile(parameterList)) else: self.pList = parameterList self.pName = parameterName maxCellNum = stats.maxCellNum(self.gridLimit, self.gridSpace) # Writing CDF dataset for all individual cell number into files self.logger.debug("Writing CDF dataset for all individual cells into files") for cellNum in xrange(0, maxCellNum + 1): self.logger.debug("Processing cell number %i"%cellNum) # Generate cyclone parameter data for the cell number self.extractParameter(cellNum) # Estimate cyclone parameter data using KDE # The returned array contains the grid, the PDF and the CDF cdf = self.kdeParameter.generateKDE(self.parameter, kdeStep, angular=angular, periodic=periodic) if plotParam: self._plotParameter(cellNum, kdeStep) self.logger.debug('size of parameter array = %d: size of cdf array = %d' % (self.parameter.size,cdf.size)) cellNumlist = [] for i in range(len(cdf)): cellNumlist.append(cellNum) if cellNum == 0: results = np.transpose(np.array([cellNumlist, cdf[:,0], cdf[:,2]])) else: self.logger.debug('size of results array = %s'%str(results.size)) results = np.concatenate((results, np.transpose(np.array([cellNumlist, cdf[:,0], cdf[:,2]])))) if parameterName == None: self.logger.debug("Returning CDF dataset for all individual cell numbers") return results else: cdfHeader = "Cell_Number, CDF_" + self.pName + "_x, CDF_" + \ self.pName + "_y" allCellCdfOutput = pjoin(self.outputPath, 'process', 'all_cell_cdf_' + self.pName) args = {"filename":allCellCdfOutput, "data":results, "header":cdfHeader, "delimiter":",", "fmt":"%f"} self.logger.debug("Writing CDF dataset for all individual cell numbers into files") flSaveFile(**args) # Save to netcdf too filename = allCellCdfOutput + '.nc' ncdf = Dataset(filename, 'w') ncdf.createDimension('cell', len(results[:,0])) cell = ncdf.createVariable('cell', 'i', ('cell',)) cell[:] = results[:,0] x = ncdf.createVariable('x', 'f', ('cell',)) x[:] = results[:,1] y = ncdf.createVariable('CDF', 'f', ('cell',)) y[:] = results[:,2] ncdf.close()
def generateKDE(self, parameters, kdeStep, kdeParameters=None, cdfParameters=None, angular=False, periodic=False, missingValue=sys.maxint): """ Generate a PDF and CDF for a given parameter set using the method of kernel density estimators. Optionally return the PDF and CDF as an array, or write both to separate files. :param parameters: Parameter values. If a string is given, then it is the path to a file containing the values. If an array is passed, then it should hold the parameter values. :param kdeStep: Increment of the ordinate values at which the distributions will be calculated. :type kdeStep: float, default=`0.1` :param str kdeParameters: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param str cdfParameters: Optional. If given, then the cell distributions will be saved to a file with this name. If absent, the distribution values are returned. :param angular: Does the data represent an angular measure (e.g. bearing). :type angular: boolean, default=``False`` :param periodic: Does the data represent some form of periodic data (e.g. day of year). If given, it should be the period of the data (e.g. for annual data, ``periodic=365``). :type periodic: boolean or float, default=``False`` :param missingValue: Missing values have this value (default :attr:`sys.maxint`). returns: If ``kdeParameters`` is given, returns ``None`` (data are saved to file), otherwise :class:`numpy.ndarray` of the parameter grid, the PDF and CDF. """ self.logger.debug("Running generateKDE") if type(parameters) is str: self.parameters = stats.statRemoveNum(flLoadFile(parameters, '%', ','), missingValue) else: if parameters.size <= 1: self.logger.error("Insufficient members in parameter list") raise IndexError, "Insufficient members in parameter list" self.parameters = stats.statRemoveNum(parameters, missingValue) if angular: xmin = 0.0 xmax = 360.0 elif periodic: xmin = 0.0 xmax = periodic else: xmin = self.parameters.min() xmax = self.parameters.max() self.logger.debug("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f" % (xmin, xmax, kdeStep)) if periodic: x = np.arange(1, periodic + 1, kdeStep) self.grid = np.concatenate( [x - periodic, x, x + periodic] ) self.parameters = np.concatenate([self.parameters - periodic, self.parameters, self.parameters + periodic]) else: self.grid = np.arange(xmin, xmax, kdeStep) if self.grid.size<2: self.logger.critical("Grid for CDF generation is a single value") self.logger.critical("xmin=%7.3f, xmax=%7.3f, kdeStep=%7.3f" % (xmin, xmax,kdeStep)) raise ValueError bw = KPDF.UPDFOptimumBandwidth(self.parameters) self.pdf = self._generatePDF(self.grid, bw, self.parameters) if periodic: self.pdf = 3.0*self.pdf[(periodic/kdeStep):2*(periodic/kdeStep)] self.grid = self.grid[(periodic/kdeStep):2*(periodic/kdeStep)] self.cy = stats.cdf(self.grid, self.pdf) if kdeParameters is None: return np.transpose(np.array([self.grid, self.pdf, self.cy])) else: # Assume both kdeParameters and cdfParameters are defined as files: self.logger.debug("Saving KDE and CDF data to files") flSaveFile(kdeParameters, np.transpose(np.array([self.grid, self.pdf]))) flSaveFile(cdfParameters, np.transpose(np.array([self.grid, self.cy])))
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)
def doDataPlotting(configFile): """ Plot the data. :param str configFile: Name of configuration file. """ import matplotlib matplotlib.use('Agg') # Use matplotlib backend 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')) indLonLat = flLoadFile(pjoin(processPath, 'cyclone_tracks'), delimiter=',') indicator = indLonLat[:, 0] lonData = indLonLat[:, 1] latData = indLonLat[:, 2] from PlotInterface.plotStats import PlotData plotting = PlotData(statsPlotPath, "png") log.info('Plotting pressure data') pbar.update(0.05) plotting.plotPressure(pAllData, pRateData) plotting.scatterHistogram( pAllData[1:], pAllData[:-1], 'prs_scatterHist', allpos=True) plotting.scatterHistogram( pRateData[1:], pRateData[:-1], 'prsRate_scatterHist') plotting.minPressureHist(indicator, pAllData) plotting.minPressureLat(pAllData, latData) log.info('Plotting bearing data') pbar.update(0.15) plotting.plotBearing(bAllData, bRateData) log.info('Plotting speed data') pbar.update(0.25) plotting.plotSpeed(sAllData, sRateData) log.info('Plotting longitude and lattitude data') pbar.update(0.45) plotting.plotLonLat(lonData, latData, indicator) log.info('Plotting quantiles for pressure, bearing, and speed') pbar.update(0.65) plotting.quantile(pRateData, "Pressure", "logistic") plotting.quantile(bRateData, "Bearing", "logistic") plotting.quantile(sRateData, "Speed", "logistic") log.info('Plotting frequency data') pbar.update(0.85) try: freq = flLoadFile(pjoin(processPath, 'frequency')) years = freq[:, 0] frequency = freq[:, 1] plotting.plotFrequency(years, frequency) except IOError: log.warning("No frequency file available - skipping this stage") pbar.update(1.0)
pos = (2, -4.8) pyplot.text(2, -4.9, r"$r^2=%1.4f$" % r, fontsize=12) self.savefig('qqplot_%s' % parameterName) #pyplot.rcdefaults() if __name__=="__main__": from os.path import join as pjoin configFile = sys.argv[1] dataPath = config.cnfGetIniValue(configFile, 'Output', 'Path', os.getcwd()) inputPath = pjoin(dataPath, 'process') outputPath = pjoin(dataPath, 'plots') pyplot.rcParams['figure.figsize'] = (7, 12) pRateData = files.flLoadFile(pjoin(inputPath, 'pressure_rate')) pAllData = files.flLoadFile(pjoin(inputPath, 'all_pressure')) bRateData = files.flLoadFile(pjoin(inputPath, 'bearing_rate')) bAllData = files.flLoadFile(pjoin(inputPath, 'all_bearing')) sRateData = files.flLoadFile(pjoin(inputPath, 'speed_rate')) sAllData = files.flLoadFile(pjoin(inputPath, 'all_speed')) freq = files.flLoadFile(pjoin(inputPath, 'frequency')) years = freq[:, 0] frequency = freq[:, 1] plotting = PlotData(outputPath, "png") plotting.plotPressure(pAllData, pRateData) plotting.plotBearing(bAllData, bRateData) plotting.plotSpeed(sAllData, sRateData) plotting.plotFrequency(years, frequency) plotting.plotSpeedBear(sAllData, bAllData)