Thermal Deratings

The thermal deratings modules includes all functions used to simulate capacity deratings of thermal generators (existing or hypothetical).

This modules uses data from climate models (in netcdf format); hydrological simulations from the VIC, RBM, and MOSART-WM models (netcdf format); and the pre-defined parameters of the operating response functions of thermal generators to ambient conditions (in json format).

While these functions were implemented within the CE/UCED simulation models, they can be called separately from the main model in order to just compute spatially- and temporally differentiated thermal deratings of existing or hypothetical thermal power plants.

calculateHourlyCapacsWithCurtailments(genFleet, hrlyCurtailmentsAllGensInTgtYr, currYear)

Compute hourly available capacity in MW after deratings for existing fleet

This function uses the capacity deratings in % of capacity computed by function determineHrlyCurtailmentsForExistingGens() and computes time series of available capacity (in MW) for all generators in the fleet.

Parameters

  • genFleet – 2d list with Generation Fleet data matrix

  • hrlyCurtailmentsAllGensInTgtYr – dict mapping each gen to 2d list of datetime for year of run to hourly net capacity curtailments (fraction of total capacity)

  • currYear – integer representing year being simulated

Returns

(dict) a dictionary {gcm: {gen symbol: [hourly available capacity in MW]}}

subtractCurtailmentsFromCapac(hrlyCurtailments, capac, genSymbol)

Computes net available capacity (in MW) of individual generator

Parameters

  • hrlyCurtailments – list with hourly curtailments for generator in current year (fraction of total capacity)

  • capac – capacity with generator (MW)

  • genSymbol – string with generator symbol (ORIS+UNIT)

Returns

list of Hourly curtailments in MW

calculateHourlyTechCapacsWithCurtailments(newTechsCE, hrlyCurtailmentsAllTechsInTgtYr, currYear, ptCurtailedAll)

Compute hourly available capacity of new thermal generators

This function uses the capacity deratings in % of capacity computed by function ModifyNewTechCapacityWithWaterTData.determineHrlyCurtailmentsForNewTechs() and computes time series of available capacity (in MW) for all candidate technologies.

Parameters

  • newTechsCE – (2d list) list with data for new technologies

  • hrlyCurtailmentsAllTechsInTgtYr – (dict) a dictionary {gcm: {(techSymbol, cell): [hourly deratings as fraction of capacity]}}

  • currYear – (int) current year

  • ptCurtailedAll – (list) list with names of types of plants that are curtailed

Returns

(dict) a dictionary {gcm: {(techSymbol, cell): [hourly available capacity in MW]}}

determineHrlyCurtailmentsForExistingGens(genFleet, currYear, genparam, curtailparam)

Computes times series of hourly curtailments for all EXISTING generators

This is a wrapper function to do the computation using multiprocessing in python

Parameters

  • genFleet – (list) 2d list with generator fleet data

  • currYear – (integer) current year

  • genparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

Returns

tuple with: * nested dictionary with {gcm: {orisId: [1d np array with hourly curtailments]}} * list of (ORIS+UNIT,gen lat long, cell lat long)

worker_generator_curtailments(list_args)

Worker function for using multiprocessing with function calculateGeneratorCurtailments()

list_args:

  • (dict) dict of (cell lat, cell long):gen ID for all gens w/ lat/lon coords in genFleet

  • (int) current year

  • (2d list) generator fleet data

  • object of type Generalparameters

  • object of type Curtailmentparameters

  • (string) name of gcm

Parameters

list_args – list with arguments for function

Returns

dictionary with {orisId: [1d np array with hourly curtailments]}

getGenToCellAndCellToGenDictionaries(genFleet)

Map generators to and from VIC/RBM grid cells

Takes the 2d list with generator fleet data and creates dictionaries mapping individual plants to grid cells lat and long

Parameters

genFleet – (list) 2d list with generator fleet data

Returns

tuple with three elements: * genToCellLatLongsDict: dictionary {gen:[gen,(gen lat, gen long), (cell lat, cell long)]} * cellLatLongToGenDict: dictionary {(cell lat, cell long):genID} * genToCellLatLongsList: 2d list [[genID,(genlat,genlong),(celllat,celllong)]]

calculateGeneratorCurtailments(cellLatLongToGenDict, currYear, genFleet, genparam, curtailparam, gcm, netcdf=True, pbar=True)

Simulate capacity deratings of existing generators

This is the actual function that performs the computation of capacity deratings for existing generators. It performs the computation for a climate conditions under a single climate simulation (defined by the parameter gcm). If generator isn’t curtailed (not right plant type, cell data not avaialble, etc.), ignored here. CalculateHourlyCapacs() script handles those cases (assume curtailment = 0).

Parameters

  • cellLatLongToGenDict – (dict) dict of (cell lat, cell long):gen ID for all gens w/ lat/lon coords in genFleet, including gens that should nto be curtailed.

  • currYear – (integer) current year

  • genFleet – (list) 2d list with generator fleet

  • genparam – object of type Generalparameter

  • curtailparam – object of type Curtailmentoparameter

  • gcm –

  • netcdf – (boolean) True if data comes in netcdf format

  • pbar – (boolean) True to show progress bar

Returns

(dict) dictionary with {orisId: [1d np array with hourly curtailments]}

find125GridMaurerLatLong(lat, lon)

Get (lat,lon) of 1/8 grid cell that a (lat, lon) point falls in

Parameters

  • lat – (float) latitude value

  • lon – (float) longitude value

Returns

tuple (lat_grid, long_grid) of grid cell that contains the point (lat,lon)

determineHrlyCurtailmentsForNewTechs(eligibleCellWaterTs, newTechsCE, currYear, genparam, curtailparam, pbar=True)

Main wrapper function to compute deratings of candidate thermal technologies for capacity expansion simulation.

This function computes thermal deratings of candidate techs using parallel multiprocessing. It combines results from all different GCMs into a single nested dictionary.

Parameters

  • eligibleCellWaterTs – (dict) dictionary with time-series of water temperatures in each cell

  • newTechsCE – (2d list) table of parameters of new techs

  • currYear – (integer) current year of simulation

  • genparam – object of class Generalparameters

  • curtailparam – object of class Curtailmentparameters

  • pbar – (boolean) If True show progress bar

Returns

nested dict of {gcm: {(plant+cooltype,cell): [hrly tech curtailments]}}

worker_new_tech_curtailments(list_args)

Worker function for using multiprocessing with function calculateGeneratorCurtailments.

Parameters

list_args – list with arguments for function (see calculateTechsCurtailments())

Returns

dict of {(plant+cooltype,cell): [hrly tech curtailments]} (see function calculateGeneratorCurtailments)

calculateTechsCurtailments(cellWaterTsForNewTechs, newTechsCE, currYear, genparam, curtailparam, gcm, pbar=True)

Computes deratings of candidate thermal technologies for capacity expansion simulation

Parameters

  • cellWaterTsForNewTechs – dictionary with time-series of water temperatures in each cell

  • newTechsCE – (2d list) table of parameters of new techs

  • currYear – (integer) current year of simulation

  • genparam – object of class Generalparameters

  • curtailparam – object of class Curtailmentparameters

  • gcm – (string) name of GCM being simulated

  • pbar – (boolean) show progress bar on standard output?

Returns

dict of {(plant+cooltype,cell): [hrly tech curtailments]}

getWaterTsInCurrYear(currYear, eligibleCellWaterTs)

Isolate average water temps for current year for each cell

Parameters

  • currYear – (integer) current year

  • eligibleCellWaterTs – dictionary with time-series of water temperatures in each cell

Returns

(dict) { cell folder name : [[Datetime],[AverageWaterT(degC)]]} filtered to current year only

selectCells(eligibleCellWaterTsCurrYear, cellNewTechCriteria, fipsToZones, fipsToPolys)

Filter list of grid cells that can host new techs

This function filters the list of eligible cells and chooses only the ones with maximum water temperature in each zone if the criteria is ‘maxWaterT’

The parameter cellNewTechCriteria is defined in the Generalparameters object. It accepts two options:

  • ‘all’: no filtering is applied. All eligible cells are considered

  • ‘maxWaterT’: only the cell with maximum water temeprature in each zone is considered

Parameters

  • eligibleCellWaterTsCurrYear – dictionary with time-series of water temperatures in each cell

  • cellNewTechCriteria – (string) cell filtering criteria

  • fipsToZones – (dict) {fips: ipm zone name}

  • fipsToPolys – (dict) {fips: polys object of each zone}

Returns

dictionary with time-series of water temperatures in each cell (subset of cells)

getCellsInEachZone(eligibleCellWaterTsCurrYear, fipsToZones, fipsToPolys)

Takes in dict of cell:waterTs, and returns dict of zone:all cells in that zone

Parameters

  • eligibleCellWaterTsCurrYear –

  • fipsToZones – (dict) {fips: ipm zone name}

  • fipsToPolys – (dict) {fips: polys object of each zone}

Returns

dict of zone:all cells in that zone

loadEligibleCellWaterTs(genFleet, currYear, genparam, curtailparam, netcdf=True, n_cells=100)

Load daily average water temperatures for grid cells for current simulation year

This function selects the eligible grid cells that will be used in the analysis and loads the water data of current simulation year.

Current options for which cells can host new plants:

  • ‘All’ (get all cell data)

  • ‘WithGen’ (get data for cells that have generator inside at beginning of CE runs).

  • ‘max_flow’ (get data for the first n_cells cells with max average flow in current year.).

  • ‘macrocell’ (get data for cells defined in a file ‘macrocells.csv’ that defines the centers of spatial clusters of cells. This was done to decrease computational burden.).

This option must be defined in the object curtailparam in the field cellsEligibleForNewPlants

Parameters

  • genFleet – (list) 2d list with generator fleet

  • currYear – (integer) current year of simulation

  • genparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

  • netcdf – (boolean) True if files are in netcdf format

  • n_cells – (integer) number of cells to consider in ‘max_flow’ option

Returns

dict of {cell folder name : [[Datetime],[AverageWaterT(degC)], [AirT], [flow]]}

setCellFolders(genFleet, currYear, genparam, curtailparam, netcdf=True, n_cells=100)

Get list of eligible cells with future data in each ipm zone

Current options for which cells can host new plants:

  • ‘All’ (get all cell data)

  • ‘WithGen’ (get data for cells that have generator inside at beginning of CE runs).

  • ‘max_flow’ (get data for the first n_cells cells with max average flow in current year.).

  • ‘macrocell’ (get data for cells defined in a file ‘macrocells.csv’ that defines the centers of spatial clusters of cells. This was done to decrease computational burden.).

This option must be defined in the object curtailparam in the field cellsEligibleForNewPlants

Parameters

  • genFleet – 2d list with generator fleet

  • currYear – (integer) current year of simulation

  • genparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

  • netcdf – (boolean) if true reads water data from NETCDF files (new format from August 2018)

  • n_cells – (integer) number of cells to consider in ‘max_flow’ option

Returns

setEnvRegCurtailments(coolType, capac, pt, ppDeltaT, metAndWaterData, maxT, streamAvailFrac, genparam)

Calculate environmental regulatory curtailments for an individual plant

Calculate environmental regulatory curtailments for given time series of water temperatures and flows for a single generator. Curtailment values are later multiplied by capacity in other functions to get available capacity (so value output by this function of 0 means full curtailment).

This function is currently only used for plants with once through cooling since other types do not have substantial amounts of water discharge.

Parameters

  • coolType – (string) cooling type

  • capac – (numeric) capacity (MW)

  • pt – (string) plant type

  • ppDeltaT – (numeric) increase in temperature of power plants cooling system (design parameter of cooling system)

  • metAndWaterData – (pandas data frame) water T data and water flow data (pd series of hourly data)

  • maxT – (numeric) regulatory stream temperature threshold

  • streamAvailFrac – (numeric) Maximum share of stream flow that can be used by power plant

  • genparam – object of class General Parameters

Returns

(list) a 1-d list with capacity derating simulations (% of capacity)

calculateMixedTemperature(inputs)

Computes final stream temperature after water discharge by power plant

Parameters

inputs – a list with stream T, stream flow, temperature rise through power plant cooling system, power plant discharge flow.

Returns

1d list with time series of final mixed stream T

calculateGeneratorDischargeFlow(coeffs, metAndWaterData, capacs, streamAvailFrac)

Computes Generator discharge flow using Aviva’s regression

Parameters

  • coeffs – dictionary with regression coefficients for this power plant

  • metAndWaterData – pandas data frame with meteo and water data for each period

  • capacs – list of numpy arrays with capacity levels in MW for each period

  • streamAvailFrac – Max share of stream flow that can be used by power plant (1d numpy array length n_hours)

Returns

2-d numpy array with water discharge in (gal) for each capacity level (num_per vs num_capacs)

calcCurtailmentForGenOrTech(plantType, fuelAndCoalType, coolType, state, capac, coolDesignT, metAndWaterData, coeffs, genparam, curtailparam)

Calculate overall curtailment for a single generator

This function combines capacity deratings with environmental curtailments to compute final hourly curtailment values of a thermal generator.

Output 1d list of hourly final curtailments for year for given generator (or generator type) with or without curtailments and/or environmental regulations.

Parameters

  • plantType – (string) plant type

  • fuelAndCoalType – (string) fuel type

  • coolType – (string) cooling type

  • state – (string) state where plant is located

  • capac – (number) capacity of plant

  • coolDesignT –

  • metAndWaterData – (pd data frame) data frame with meteo and water data

  • coeffs – (dict) dictionary with curtailment regression coefficients (plantType,coolType,coolDesignT)

  • genparam – object of class Generalparameters

  • curtailparam – object of class Curtailmentparameters

Returns

1d numpy array with final curtailments as percentage of capacity

runCurtailRegression(metAndWaterData, coeffs, incCurtailments, pt, coolType, ptCurtailed)

Compute list with hourly thermal deratings for given plant

Output 1d list w/ hourly curtailment (% of capacity) for individual generator. It uses the results from setAvivaCurtailments() and returns a 1-d list. This function controls if simulation is considering this type of derating simulation (incCurtailments) and if the plant type is included in the list of plants that should have derating simulation (ptCurtailed)

Parameters

  • metAndWaterData – (pd data frame) data frame with meteo and water data

  • coeffs – (dict) dictionary with curtailment regression coefficients (plantType,coolType,coolDesignT)

  • incCurtailments – (boolean) if true thermal curtailments are simulated

  • pt – (string) type of power plant

  • coolType –

  • ptCurtailed – list with types of power plants for which curtailment is simulated

Returns

list with hourly curtailment values (fraction of total capacity)

setAvivaCurtailments(coeffs, metAndWaterData)

Compute thermal deratings using Aviva’s regression coefficients

Use Aviva’s regressions to curtail generation. Note that curtailment values are fraction of total capacity (val of 0.3 means max capac is 30% of total capac).

see: http://link.springer.com/10.1007/s10584-020-02834-y

Parameters

  • coeffs – dictionary with regression coefficients for this power plant

  • metAndWaterData – pandas data frame with meteo and water data

Returns

array with hourly curtailment values (fraction of total capacity)

loadRegCoeffs(dataRoot, fname)

Load regression coefficients from JSON file.

This function works for both available capacity (%) and water intensity (gal/MWh) files. These files are assumed to be inside the folder /dataRoot/Curtailment/.

Parameters

  • dataRoot – root of data folder (see pdf ‘structure of data folder’ for more details on folder structure)

  • fname – name of JSON file (with extension)

Returns

nested dictionary of cooling type: reg coeffs

getCoeffsForGenOrTech(plantType, coolType, plantTypesCurtailed, regCoeffs, coolDesignT)

Get coefficients for a particular generator or technology

If plant not eligible for curtailment or cool type not included in reg coeffs (e.g., wind), assume no curtailment. See :func:loadRegCoeffs for structure of coeffs.

Inputs: parameters for getting reg coeffs, and regCoeffs (dict of cool type: cool design T: parameter:coefficient)

Parameters

  • plantType – (string) with type of plant (‘Coal Steam’, ‘Hydro’, ‘Combined Cycle’, …)

  • coolType – (string) cooling technology type

  • plantTypesCurtailed – (list) list with plant types that are curtailed

  • regCoeffs – (dict) nested dictionary with regression coefficient for all (plantType,coolType,coolDesignT)

  • coolDesignT – (string) cooling technology design temperature

Returns

(dict) dictionary with regression coeffs for this specific combination of (plantType,coolType,coolDesignT)

getKeyCurtailParams(gen, genFleet)

Get key parameters of individual generator

Reads data base of generators and returns Parameters that affect curtailment: coal steam vs NGCC, bit vs. subbit vs. lignite, HR, once through vs. recirc vs. dry cooling, wet FGD vs. lime spray dryer

Parameters

  • gen – (string) id of generator

  • genFleet – (2d list) generator fleet data

Returns

tuple with parameters of generator: (plantType, heat rate, fuel Type, cooling Type, scrubber type, state, capacity)

getGenRowInFleet(gen, genFleet)

Get row with individual generator data in fleet

Parameters

  • gen – (string) generator symbol

  • genFleet – (2-d list) generator fleet data

Returns

(1-d list) individual plant data

isolateFirstFuelType(fuel)

Isolate first fuel name

Some plants have multiple modeled fuels divided by & (e.g., Natural Gas & Oil). This function gets the first one.

Parameters

fuel – (string) fuel type name (possibly multiple fuel types)

Returns

(string) single fuel type name

getCoolType(coolingType)

Get standard cooling type name for simulation

This function get cooling type name in the generator fleet data and returns the cooling type using the convention for this simulation (‘once through’, ‘dry cooling’, ‘recirculating’)

Parameters

coolingType – (string) name of cooling type in generator fleet data

Returns

(string) cooling type name for simulation

getSO2Control(so2Control)

Get scrubber type

Parameters

so2Control – (string) name of so2 control tech

Returns

(string) scrubber type (wet or dry)

getKeyCurtailParamsNewTechs(newTechsCE, techRow)

Get key parameters of tech for regression

Function returns the key parameters of individual NEW generators needed to do the curtailment simulations

:param newTechsCE:(2d list) list with new tech data :param techRow: (1d list) row with individual plant type data :return: (tuple) (plantType, heat rate, fuel Type, cooling Type, scrubber type, capacity, cooling design temperature)

loadWaterAndMetData(curtailmentYear, cellLat, cellLong, genparam, curtailparam, gcm, metdatatot=None, waterDatatot=None, netcdf=True)

Load water and met data of a single cell (and a single gcm) on hourly basis for given year

This function can take dictionaries with previously loaded full gridded datasets of weather (metdatatot) and water data (waterDatatot) and it filters the data of a single grid cell. If these dictionaries have not been loaded previously, the function reads from the netcdf files.

Parameters

  • curtailmentYear – (int) year of simulation

  • cellLat – (float) latitude of grid cell

  • cellLong – (float) longitude of grid cell

  • genparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

  • gcm – (string) GCM name

  • metdatatot – dict with pre-loaded complete meteo data from the netcdf file (see read_netcdf_full()). If this is None the function loads the data directly from the netcdf file (read_netcdf())

  • waterDatatot – dict of {cell folder name : [[Datetime],[AverageWaterT(degC)], [AirT], [flow]]}. If value is None, it loads data from netcdf file (see read_waterdata_cell())

  • netcdf – (boolean) if true reads water data from NETCDF files (Old format does not work anymore)

Returns

panda data frame with hourly water and weather data for given year and given cell

loadCellWaterTs(eligibleCellFolders, allCellFoldersInZone, curtailparam, gcm, currYear=None, netcdf=True)

Load water and weather data for all eligible grid cells in study

Returns dict of {cell folder name : [[Datetime, AverageWaterT(degC), flow]]}. Each element in the dictionary is a 2d list.

Parameters

  • eligibleCellFolders – (list) list with names of eligible cells for study

  • allCellFoldersInZone – (list) list with names of cells inside zones included in study

  • curtailparam – object of type Curtailmentparameters

  • gcm – (string) name of gcm being imported

  • currYear – (integer) year of data being imported. If None, imports all years

  • netcdf – (boolean) if true reads water data from NETCDF files (new format from August 2018)

Returns

dict of {cell folder name : [[Datetime, AverageWaterT(degC), flow]]}

read_netcdf_full(currYear, fname, curtailparam)

Reads NETCDF file with meteo data for current year

This function reads the netcdf file and returns a dictionary with 1-d arrays of the dimension variables (time, lat, lon) and 3-d arrays of weather and water data (air temp, air pressure, relative humidity).

It reads data for all cells. Netcdf files have data for a single year.

Parameters

  • currYear – (integer) current year

  • fname – (string) full path to netcdf file

  • curtailparam – object of type Curtailmentparameters

Returns

dictionary with arrays of data {‘var name’: array}

read_netcdf(cellLat, cellLon, currYear, curtailparam, gcm)

Reads NETCDF file with meteo data for current year and gets data for specified cell

Parameters

  • cellLat – (numeric) latitude of cell

  • cellLon – (numeric) longitude of cell

  • currYear – (integer) current year

  • curtailparam – object of type Curtailmentparameters

Returns

pandas data frame with hourly meteo data

read_dict_netcdf(cellLat, cellLon, meteoData)

Get meteorological data for cell stored in a dictionary with full dataset from the netcdf file

see function read_netcdf_full()

Parameters

  • cellLat – (numeric) latitude of cell

  • cellLon – (numeric) longitude of cell

  • meteoData – (dictionary) dictionary with complete meteo data from the netcdf file

Returns

pandas data frame with hourly meteo data

get_all_cells_from_netcdf(curtailparam, gcm)

Get all cells from netcdf file

This function reads a netcdf file for the given gcm and returns a list with cells lat and longs as strings

Parameters

  • curtailparam – object of type Curtailmentparameters

  • gcm – (string) name of gcm

Returns

list with cells lat and longs as strings

get_all_cells_in_zone(allCellFolders, genparam, curtailparam)

Compiles list of cells that are inside the ipm zones

Parameters

  • allCellFolders – list with all cells

  • curtailparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

Returns

allCellFoldersInZone: list with all cells that are inside the ipm zones

read_waterdata_cell(curtailparam, currYear, cellLat, cellLon, gcm)

Reads netcdf file with water data and returns panda data frame for data for given cell

Parameters

  • curtailparam – object of type Curtailmentparameters

  • currYear – (int) current year

Returns

data frame with following columns * date: 1d array with dates * lons: 1d array with longitude values * lats: 1d array with latitude values

read_waterdata_netcdf(fname, varname, curryear)

Reads netcdf file with water data and returns arrays with data, lats and longs for given year

Parameters

  • fname – (string) complete path fo netcdf file

  • varname – (string) name of variable to load from netcdf file

  • curryear – (int) current year

Returns

tuple with following elements * data_values: array with data values * date: 1d array with dates * lons: 1d array with longitude values * lats: 1d array with latitude values

order_cells_by_flow(genparam, curtailparam, currYear, n=100, output_list=True)

Order cells according to average annual water flow across all gcms

This function order cells in each zone according to annual average river flow. It returns the n cells with largest flow as an ordered list.

Parameters

  • genparam – object of type Generalparameters

  • curtailparam – object of type Curtailmentparameters

  • currYear – (int) current year in simulation

  • n – (int) number of cells to consider

  • output_list – (boolean) Type of output by zone. If True output is list of cells. If false, output is dataframe with cells and annual flows

Returns

dictionary with a list/dataframe for each zone (depending on output_list)

convert_2dList_netcdf(listcurtail, curtailparam, fnameuw, fnameout='~/test.nc')

This function converts a 2d list with new generator curtailments to a netcdf file

Parameters

  • listcurtail – (2d list) with curtailment data

  • curtailparam – object of type Curtailmentparameters

  • fnameuw – (string) name of netcdf file with original meteo data from UW (no path)

  • fnameout – (string) name of resulting netcdf file that will be created (full path)

expand_df_hourly(df)

utility function to expand a daily data frame to hourly

Parameters

df – (pandas data frame) data frame with daily data (check names of columns)

Returns

data frame with hourly data

createBaseFilenameToReadOrWrite(locPrecision, inputLat, inputLong)

Creates string with name of folder with cell data

This function creates a string with the formatted name of the folder that contains the data for the respective grid cell

Parameters

  • locPrecision – number of decimal digits in lat and long values

  • inputLat – latitude of grid cell

  • inputLong – longitude of grid cell

Returns

string with name of folder (e.g. 34.4375_-86.4375)

getCellLatAndLongFromFolderName(dummyFolder)

Get cell lat and long values from formatted string

This function splits a string with lat and long (format: ‘{lat}_{lon}’) into numeric lat and long values

See createBaseFilenameToReadOrWrite()

Parameters

dummyFolder – (string) string with lat an long values

Returns

tuple with numeric values of lat and long