@@ -834,11 +842,14 @@ def head(self):
class HtmlLayout():
def __init__(self,pages,cname,years=None):
-
+
self.pages = pages
self.cname = cname.replace("/"," / ")
if years is not None:
- self.cname += " / %d-%d" % (years)
+ try:
+ self.cname += " / %d-%d" % (years)
+ except:
+ pass
for page in self.pages:
page.pages = self.pages
page.cname = self.cname
@@ -1048,7 +1059,7 @@ def BenchmarkSummaryFigure(models,variables,data,figname,vcolor=None,rel_only=Fa
nvariables = len(variables)
maxV = max([len(v) for v in variables])
maxM = max([len(m) for m in models])
- wpchar = 0.1
+ wpchar = 0.15
wpcell = 0.19
hpcell = 0.25
w = maxV*wpchar + max(4,nmodels)*wpcell
@@ -1085,6 +1096,8 @@ def BenchmarkSummaryFigure(models,variables,data,figname,vcolor=None,rel_only=Fa
ax[0].set_yticklabels(variables[::-1])
ax[0].tick_params('both',length=0,width=0,which='major')
ax[0].tick_params(axis='y',pad=10)
+ ax[0].set_xlim(0,nmodels)
+ ax[0].set_ylim(0,nvariables)
if vcolor is not None:
for i,t in enumerate(ax[0].yaxis.get_ticklabels()):
t.set_backgroundcolor(vcolor[::-1][i])
@@ -1117,6 +1130,7 @@ def BenchmarkSummaryFigure(models,variables,data,figname,vcolor=None,rel_only=Fa
ax[i].set_xticklabels(models,rotation=90)
ax[i].tick_params('both',length=0,width=0,which='major')
ax[i].set_yticks([])
+ ax[i].set_xlim(0,nmodels)
ax[i].set_ylim(0,nvariables)
if rel_only:
ax[i].set_yticks (np.arange(nvariables)+0.5)
diff --git a/ilamb/ilamb/src/ILAMB/Scoreboard.py b/ilamb/ilamb/src/ILAMB/Scoreboard.py
index ba0b2cfb..5fceb929 100644
--- a/ilamb/ilamb/src/ILAMB/Scoreboard.py
+++ b/ilamb/ilamb/src/ILAMB/Scoreboard.py
@@ -5,6 +5,7 @@
from ConfEvapFraction import ConfEvapFraction
from ConfIOMB import ConfIOMB
from ConfDiurnal import ConfDiurnal
+from ConfPermafrost import ConfPermafrost
import os,re
from netCDF4 import Dataset
import numpy as np
@@ -179,17 +180,19 @@ def ParseScoreboardConfigureFile(filename):
"ConfRunoff" : ConfRunoff,
"ConfEvapFraction": ConfEvapFraction,
"ConfIOMB" : ConfIOMB,
- "ConfDiurnal" : ConfDiurnal}
+ "ConfDiurnal" : ConfDiurnal,
+ "ConfPermafrost" : ConfPermafrost}
class Scoreboard():
"""
A class for managing confrontations
"""
- def __init__(self,filename,regions=["global"],verbose=False,master=True,build_dir="./_build",extents=None):
+ def __init__(self,filename,regions=["global"],verbose=False,master=True,build_dir="./_build",extents=None,rel_only=False):
if not os.environ.has_key('ILAMB_ROOT'):
raise ValueError("You must set the environment variable 'ILAMB_ROOT'")
self.build_dir = build_dir
+ self.rel_only = rel_only
if (master and not os.path.isdir(self.build_dir)): os.mkdir(self.build_dir)
@@ -272,7 +275,7 @@ def createHtml(self,M,filename="index.html"):
has_rel = np.asarray([len(rel.children) for rel in rel_tree.children]).sum() > 0
nav = ""
if has_rel:
- GenerateRelSummaryFigure(self,M,"%s/overview_rel.png" % self.build_dir)
+ GenerateRelSummaryFigure(rel_tree,M,"%s/overview_rel.png" % self.build_dir,rel_only=self.rel_only)
nav = """
Relationship"""
#global global_print_node_string
@@ -453,7 +456,7 @@ def createBarCharts(self,M):
html = GenerateBarCharts(self.tree,M)
def createSummaryFigure(self,M):
- GenerateSummaryFigure(self.tree,M,"%s/overview.png" % self.build_dir)
+ GenerateSummaryFigure(self.tree,M,"%s/overview.png" % self.build_dir,rel_only=self.rel_only)
def dumpScores(self,M,filename):
out = file("%s/%s" % (self.build_dir,filename),"w")
@@ -582,7 +585,7 @@ def GenerateTable(tree,M,S,composite=True):
BuildHTMLTable(tree,M,S.build_dir)
return global_html
-def GenerateSummaryFigure(tree,M,filename):
+def GenerateSummaryFigure(tree,M,filename,rel_only=False):
models = [m.name for m in M]
variables = []
@@ -602,96 +605,34 @@ def GenerateSummaryFigure(tree,M,filename):
else:
data[row,:] = var.score
- BenchmarkSummaryFigure(models,variables,data,filename,vcolor=vcolors)
-
-def GenerateRelSummaryFigure(S,M,figname):
-
- def _parse(node):
- global score,count,rows
- if node.level != 5: return
- row = "%s vs. %s" % (node.parent.parent.parent.name,node.parent.name)
- col = node.name
- if row not in rows: rows.append(row)
- if not score .has_key(row): score[row] = {}
- if not count .has_key(row): count[row] = {}
- if not score[row].has_key(col): score[row][col] = 0.
- if not count[row].has_key(col): count[row][col] = 0.
- score[row][col] += node.score
- count[row][col] += 1.
-
- class rnode():
- def __init__(self,name,level):
- self.name = name
- self.level = level
- self.parent = None
- self.score = None
- self.children = []
-
-
- root = S.build_dir
- tree = rnode("root",0)
- previous_node = tree
- current_level = 0
-
- for subdir, dirs, files in os.walk(root):
- if subdir == root: continue
- flat = subdir.replace(root,"").lstrip("/").split("/")
- level = len(flat)
- name = flat[-1]
- child = rnode(name,level)
- if level == current_level:
- child.parent = previous_node.parent
- previous_node.parent.children.append(child)
- if level == 3:
- for fname in [f for f in files if f.endswith(".nc") and "Benchmark" not in f]:
- with Dataset(os.path.join(subdir,fname)) as dset:
- if "Relationships" not in dset.groups: continue
- grp = dset.groups["Relationships"]["scalars"]
- model = dset.name
- for var in [var for var in grp.variables.keys() if ("Overall" not in var and
- "global" in var)]:
- rname = var.split(" ")[0]
- hadrel = False
- for c in child.children:
- if c.name == rname:
- rel = c
- hadrel = True
- if not hadrel: rel = rnode(rname,level+1)
- mod = rnode(model,level+2)
- mod.score = grp.variables[var][...]
- mod.parent = rel
- rel.children.append(mod)
- rel.parent = child
- if not hadrel: child.children.append(rel)
- elif level > current_level:
- child.parent = previous_node
- previous_node.children.append(child)
- current_level = level
- else:
- addto = tree
- for i in range(level-1): addto = addto.children[-1]
- child.parent = addto
- addto.children.append(child)
- current_level = level
- previous_node = child
-
- global score,count,rows
- score = {}
- count = {}
- rows = []
- TraversePreorder(tree,_parse)
- models = []
- for row in rows:
- for key in score[row].keys():
- if key not in models: models.append(key)
- data = np.zeros((len(rows),len(models)))
+ BenchmarkSummaryFigure(models,variables,data,filename,vcolor=vcolors,rel_only=rel_only)
+
+def GenerateRelSummaryFigure(S,M,figname,rel_only=False):
+
+ # reorganize the relationship data
+ scores = {}
+ counts = {}
+ rows = []
+ vcolors = []
+ for h1 in S.children:
+ for dep in h1.children:
+ dname = dep.name.split("/")[0]
+ for ind in dep.children:
+ iname = ind.name.split("/")[0]
+ key = "%s/%s" % (dname,iname)
+ if scores.has_key(key):
+ scores[key] += ind.score
+ counts[key] += 1.
+ else:
+ scores[key] = np.copy(ind.score)
+ counts[key] = 1.
+ rows .append(key)
+ vcolors.append(h1.bgcolor)
+ if len(rows) == 0: return
+ data = np.ma.zeros((len(rows),len(M)))
for i,row in enumerate(rows):
- for j,col in enumerate(models):
- try:
- data[i,j] = score[row][col] / count[row][col]
- except:
- data[i,j] = np.nan
- BenchmarkSummaryFigure(models,rows,data,figname,rel_only=False)
+ data[i,:] = scores[row] / counts[row]
+ BenchmarkSummaryFigure([m.name for m in M],rows,data,figname,rel_only=rel_only,vcolor=vcolors)
def GenerateRelationshipTree(S,M):
@@ -753,7 +694,6 @@ def GenerateRelationshipTree(S,M):
if "Overall Score global" not in grp.variables.keys(): continue
h2.score[i] = grp.variables["Overall Score global"][...]
-
return rel_tree
diff --git a/ilamb/ilamb/src/ILAMB/Variable.py b/ilamb/ilamb/src/ILAMB/Variable.py
index 7d1f48b8..fcfa33f9 100644
--- a/ilamb/ilamb/src/ILAMB/Variable.py
+++ b/ilamb/ilamb/src/ILAMB/Variable.py
@@ -3,7 +3,7 @@
from mpl_toolkits.basemap import Basemap
import matplotlib.colors as colors
from pylab import get_cmap
-from cfunits import Units
+from cf_units import Unit
import ilamblib as il
import Post as post
import numpy as np
@@ -220,6 +220,17 @@ def __str__(self):
return s
+ def nbytes(self):
+ r"""Estimate the memory usage of a variable in bytes.
+ """
+ nbytes = 0.
+ for key in self.__dict__.keys():
+ try:
+ nbytes += self.__dict__[key].nbytes
+ except:
+ pass
+ return nbytes
+
def integrateInTime(self,**keywords):
r"""Integrates the variable over a given time period.
@@ -286,7 +297,7 @@ def integrateInTime(self,**keywords):
integral = np.ma.masked_array(integral,mask=mask,copy=False)
# handle units
- unit = Units(self.unit)
+ unit = Unit(self.unit)
name = self.name + "_integrated_over_time"
if mean:
@@ -300,18 +311,18 @@ def integrateInTime(self,**keywords):
else:
dt = dt.sum(axis=0)
np.seterr(over='ignore',under='ignore')
- integral /= dt
+ integral = integral / dt
np.seterr(over='raise' ,under='raise' )
else:
# if not a mean, we need to potentially handle unit conversions
- unit0 = Units("d")*unit
- unit = Units(unit0.formatted().split()[-1])
- integral = Units.conform(integral,unit0,unit)
+ unit0 = Unit("d")*unit
+ unit = Unit(unit0.format().split()[-1])
+ integral = unit0.convert(integral,unit)
return Variable(data = integral,
- unit = unit.units,
+ unit = "%s" % unit,
name = name,
lat = self.lat,
lat_bnds = self.lat_bnds,
@@ -403,7 +414,7 @@ def integrateInDepth(self,**keywords):
integral = np.ma.masked_array(integral,mask=mask,copy=False)
# handle units
- unit = Units(self.unit)
+ unit = Unit(self.unit)
name = self.name + "_integrated_over_depth"
if mean:
@@ -417,18 +428,18 @@ def integrateInDepth(self,**keywords):
else:
dz = dz.sum(axis=axis)
np.seterr(over='ignore',under='ignore')
- integral /= dz
+ integral = integral / dz
np.seterr(over='raise' ,under='raise' )
else:
# if not a mean, we need to potentially handle unit conversions
- unit0 = Units("m")*unit
- unit = Units(unit0.formatted().split()[-1])
- integral = Units.conform(integral,unit0,unit)
+ unit0 = Unit("m")*unit
+ unit = Unit(unit0.format().split()[-1])
+ integral = unit0.convert(integral,unit)
return Variable(data = integral,
- unit = unit.units,
+ unit = "%s" % unit,
name = name,
time = self.time,
time_bnds = self.time_bnds,
@@ -521,13 +532,13 @@ def _integrate(var,areas):
integral = _integrate(self.data,measure)
if mean:
np.seterr(under='ignore')
- integral /= measure.sum()
+ integral = integral / measure.sum()
np.seterr(under='raise')
# handle the name and unit
name = self.name + "_integrated_over_space"
if region is not None: name = name.replace("space",region)
- unit = Units(self.unit)
+ unit = Unit(self.unit)
if mean:
# we have already divided thru by the non-masked area in
@@ -536,12 +547,12 @@ def _integrate(var,areas):
else:
# if not a mean, we need to potentially handle unit conversions
- unit0 = Units("m2")*unit
- unit = Units(unit0.formatted().split()[-1])
- integral = Units.conform(integral,unit0,unit)
+ unit0 = Unit("m2")*unit
+ unit = Unit(unit0.format().split()[-1])
+ integral = unit0.convert(integral,unit)
return Variable(data = np.ma.masked_array(integral),
- unit = unit.units,
+ unit = "%s" % unit,
time = self.time,
time_bnds = self.time_bnds,
depth = self.depth,
@@ -710,7 +721,7 @@ def _make_bnds(x):
bnds[0] = max(x[0] -0.5*(x[ 1]-x[ 0]),-180)
bnds[-1] = min(x[-1]+0.5*(x[-1]-x[-2]),+180)
return bnds
- assert Units(var.unit) == Units(self.unit)
+ assert Unit(var.unit) == Unit(self.unit)
assert self.temporal == False
assert self.ndata == var.ndata
assert self.layered == False
@@ -752,7 +763,7 @@ def _make_bnds(x):
def convert(self,unit,density=998.2):
"""Convert the variable to a given unit.
- We use the UDUNITS library via the cfunits python interface to
+ We use the UDUNITS library via the cf_units python interface to
convert the variable's unit. Additional support is provided
for unit conversions in which substance information is
required. For example, in quantities such as precipitation it
@@ -777,53 +788,53 @@ def convert(self,unit,density=998.2):
this object with its unit converted
"""
- src_unit = Units(self.unit)
- tar_unit = Units( unit)
+ if unit is None: return self
+ src_unit = Unit(self.unit)
+ tar_unit = Unit( unit)
mask = self.data.mask
# Define some generic quantities
- linear = Units("m")
- linear_rate = Units("m s-1")
- area_density = Units("kg m-2")
- area_density_rate = Units("kg m-2 s-1")
- mass_density = Units("kg m-3")
- volume_conc = Units("mol m-3")
- mass_conc = Units("mol kg-1")
-
- # cfunits doesn't handle frequently found temperature expressions
+ linear = Unit("m")
+ linear_rate = Unit("m s-1")
+ area_density = Unit("kg m-2")
+ area_density_rate = Unit("kg m-2 s-1")
+ mass_density = Unit("kg m-3")
+ volume_conc = Unit("mol m-3")
+ mass_conc = Unit("mol kg-1")
+
+ # UDUNITS doesn't handle frequently found temperature expressions
synonyms = {"K":"degK",
"R":"degR",
"C":"degC",
"F":"degF"}
for syn in synonyms.keys():
- if src_unit.units == syn: src_unit = Units(synonyms[syn])
- if tar_unit.units == syn: tar_unit = Units(synonyms[syn])
+ if src_unit.format() == syn: src_unit = Unit(synonyms[syn])
+ if tar_unit.format() == syn: tar_unit = Unit(synonyms[syn])
# Do we need to multiply by density?
- if ( (src_unit.equivalent(linear_rate) and tar_unit.equivalent(area_density_rate)) or
- (src_unit.equivalent(linear ) and tar_unit.equivalent(area_density )) or
- (src_unit.equivalent(mass_conc ) and tar_unit.equivalent(volume_conc )) ):
+ if ( (src_unit.is_convertible(linear_rate) and tar_unit.is_convertible(area_density_rate)) or
+ (src_unit.is_convertible(linear ) and tar_unit.is_convertible(area_density )) or
+ (src_unit.is_convertible(mass_conc ) and tar_unit.is_convertible(volume_conc )) ):
np.seterr(over='ignore',under='ignore')
self.data *= density
np.seterr(over='raise',under='raise')
src_unit *= mass_density
# Do we need to divide by density?
- if ( (tar_unit.equivalent(linear_rate) and src_unit.equivalent(area_density_rate)) or
- (tar_unit.equivalent(linear ) and src_unit.equivalent(area_density )) or
- (tar_unit.equivalent(mass_conc ) and src_unit.equivalent(volume_conc )) ):
+ if ( (tar_unit.is_convertible(linear_rate) and src_unit.is_convertible(area_density_rate)) or
+ (tar_unit.is_convertible(linear ) and src_unit.is_convertible(area_density )) or
+ (tar_unit.is_convertible(mass_conc ) and src_unit.is_convertible(volume_conc )) ):
np.seterr(over='ignore',under='ignore')
- self.data /= density
+ self.data = self.data / density
np.seterr(over='raise',under='raise')
- src_unit /= mass_density
+ src_unit = src_unit / mass_density
# Convert units
try:
- self.data = Units.conform(self.data,src_unit,tar_unit)
+ self.data = src_unit.convert(self.data,tar_unit)
self.data = np.ma.masked_array(self.data,mask=mask)
self.unit = unit
except:
- print "var_name = %s, src_unit = %s, target_unit = %s " % (self.name,src_unit,tar_unit)
raise il.UnitConversionError()
return self
@@ -1599,7 +1610,7 @@ def spatialDistribution(self,var,region="global"):
R0 = 1.0
std0 = std0.clip(1e-12)
std = std .clip(1e-12)
- std /= std0
+ std = std/std0
score = 4.0*(1.0+R.data)/((std+1.0/std)**2 *(1.0+R0))
except:
std = np.asarray([0.0])
diff --git a/ilamb/ilamb/src/ILAMB/__init__.py b/ilamb/ilamb/src/ILAMB/__init__.py
index f8ea82b9..3bb5124a 100644
--- a/ilamb/ilamb/src/ILAMB/__init__.py
+++ b/ilamb/ilamb/src/ILAMB/__init__.py
@@ -1,6 +1,6 @@
__author__ = 'Nathan Collier'
-__date__ = 'Nov 2017'
-__version__ = '2.2'
+__date__ = 'Jun 2018'
+__version__ = '2.3'
from distutils.version import LooseVersion
import platform
@@ -10,7 +10,7 @@
"numpy" : "1.9.2",
"matplotlib" : "1.4.3",
"netCDF4" : "1.1.4",
- "cfunits" : "1.1.4",
+ "cf_units" : "2.0.0",
"mpl_toolkits.basemap" : "1.0.7",
"sympy" : "0.7.6",
"mpi4py" : "1.3.1"
diff --git a/ilamb/ilamb/src/ILAMB/constants.py b/ilamb/ilamb/src/ILAMB/constants.py
index 714209d8..8d77b8f6 100644
--- a/ilamb/ilamb/src/ILAMB/constants.py
+++ b/ilamb/ilamb/src/ILAMB/constants.py
@@ -130,6 +130,28 @@
"sidelbl" :"RMSE SCORE",
"haslegend" :True }
+space_opts["iav"] = { "name" :"Interannual variability",
+ "cmap" :"Reds",
+ "sym" :False,
+ "ticks" :None,
+ "ticklabels":None,
+ "label" :"unit" ,
+ "section" :"Temporally integrated period mean",
+ "pattern" :"MNAME_RNAME_iav.png",
+ "sidelbl" :"MODEL INTERANNUAL VARIABILITY",
+ "haslegend" :True }
+
+space_opts["iavscore"] = { "name" :"Interannual variability score",
+ "cmap" :"RdYlGn",
+ "sym" :False,
+ "ticks" :None,
+ "ticklabels":None,
+ "label" :"unit" ,
+ "section" :"Temporally integrated period mean",
+ "pattern" :"MNAME_RNAME_iavscore.png",
+ "sidelbl" :"INTERANNUAL VARIABILITY SCORE",
+ "haslegend" :True }
+
space_opts["shift"] = { "name" :"Temporally integrated mean phase shift",
"cmap" :"PRGn",
"sym" :True,
diff --git a/ilamb/ilamb/src/ILAMB/ilamblib.py b/ilamb/ilamb/src/ILAMB/ilamblib.py
index 1304be6a..b7cff096 100644
--- a/ilamb/ilamb/src/ILAMB/ilamblib.py
+++ b/ilamb/ilamb/src/ILAMB/ilamblib.py
@@ -3,11 +3,11 @@
from Regions import Regions
from netCDF4 import Dataset,num2date,date2num
from datetime import datetime
-from cfunits import Units
+from cf_units import Unit
from copy import deepcopy
from mpi4py import MPI
import numpy as np
-import logging
+import logging,re
logger = logging.getLogger("%i" % MPI.COMM_WORLD.rank)
@@ -53,7 +53,30 @@ def __str__(self): return "NotLayeredVariable"
class NotDatasiteVariable(Exception):
def __str__(self): return "NotDatasiteVariable"
+def FixDumbUnits(unit):
+ r"""Try to fix the dumb units people insist on using.
+ Parameters
+ ----------
+ unit : str
+ the trial unit
+
+ Returns
+ -------
+ unit : str
+ the fixed unit
+ """
+ # Various synonyms for 1
+ if unit.lower().strip() in ["unitless",
+ "n/a",
+ "none"]: unit = "1"
+ # Remove the C which so often is used to mean carbon but actually means coulomb
+ tokens = re.findall(r"[\w']+", unit)
+ for token in tokens:
+ if token.endswith("C") and Unit(token[:-1]).is_convertible(Unit("g")):
+ unit = unit.replace(token,token[:-1])
+ return unit
+
def GenerateDistinctColors(N,saturation=0.67,value=0.67):
r"""Generates a series of distinct colors.
@@ -86,7 +109,7 @@ def ConvertCalendar(t,tbnd=None):
This routine converts the representation of time to the ILAMB
default: days since 1850-1-1 00:00:00 on a 365-day calendar. This
is so we can make comparisons with data from other models and
- benchmarks. We use cfunits time conversion capability.
+ benchmarks.
Parameters
----------
@@ -343,71 +366,51 @@ def SympifyWithArgsUnits(expression,args,units):
"""
from sympy import sympify,postorder_traversal
- # The traversal needs that we make units commensurate when
- # possible
- keys = args.keys()
- for i in range(len(keys)):
- ikey = keys[i]
- for j in range(i+1,len(keys)):
- jkey = keys[j]
- if Units(units[jkey]).equivalent(Units(units[ikey])):
- args [jkey] = Units.conform(args[jkey],
- Units(units[jkey]),
- Units(units[ikey]),
- inplace=True)
- units[jkey] = units[ikey]
-
- # We need to do what sympify does but also with unit
- # conversions. So we traverse the expression tree in post order
- # and take actions based on the kind of operation being performed.
expression = sympify(expression)
+
+ # try to convert all arguments to same units if possible, it
+ # catches most use cases
+ keys = args.keys()
+ for i,key0 in enumerate(keys):
+ for key in keys[(i+1):]:
+ try:
+ Unit(units[key]).convert(args[key],Unit(units[key0]),inplace=True)
+ units[key] = units[key0]
+ except:
+ pass
+
for expr in postorder_traversal(expression):
-
- if expr.is_Atom: continue
- ekey = str(expr) # expression key
-
+ ekey = str(expr)
if expr.is_Add:
- # Addition will require that all args should be the same
- # unit. As a convention, we will try to conform all units
- # to the first variable's units.
- key0 = None
- for arg in expr.args:
- key = str(arg)
- if not args.has_key(key): continue
- if key0 is None:
- key0 = key
- else:
- # Conform these units to the units of the first arg
- Units.conform(args[key],
- Units(units[key]),
- Units(units[key0]),
- inplace=True)
- units[key] = units[key0]
-
- args [ekey] = sympify(str(expr),locals=args)
- units[ekey] = units[key0]
+ # if there are scalars in the expression, these will not
+ # be in the units dictionary. Add them and give them an
+ # implicit unit of 1
+ keys = [str(arg) for arg in expr.args]
+ for key in keys:
+ if not units.has_key(key): units[key] = "1"
- elif expr.is_Pow:
+ # if we are adding, all arguments must have the same unit.
+ key0 = keys[0]
+ for key in keys:
+ Unit(units[key]).convert(np.ones(1),Unit(units[key0]))
+ units[key] = units[key0]
+ units[ekey] = "%s" % (units[key0])
- assert len(expr.args) == 2 # check on an assumption
- power = float(expr.args[1])
- args [ekey] = args[str(expr.args[0])]**power
- units[ekey] = Units(units[str(expr.args[0])])
- units[ekey] = units[ekey]**power
-
- elif expr.is_Mul:
+ elif expr.is_Pow:
- unit = Units("1")
- for arg in expr.args:
- key = str(arg)
- if units.has_key(key): unit *= Units(units[key])
-
- args [ekey] = sympify(str(expr),locals=args)
- units[ekey] = Units(unit).formatted()
+ # if raising to a power, just create the new unit
+ keys = [str(arg) for arg in expr.args]
+ units[ekey] = "(%s)%s" % (units[keys[0]],keys[1])
- return args[ekey],units[ekey]
+ elif expr.is_Mul:
+
+ # just create the new unit
+ keys = [str(arg) for arg in expr.args]
+ units[ekey] = " ".join(["(%s)" % units[key] for key in keys if units.has_key(key)])
+ return sympify(str(expression),locals=args),units[ekey]
+
def ComputeIndexingArrays(lat2d,lon2d,lat,lon):
"""Blah.
@@ -635,11 +638,11 @@ def FromNetCDF4(filename,variable_name,alternate_vars=[],t0=None,tf=None,group=N
if depth_bnd_name is not None:
depth_bnd = grp.variables[depth_bnd_name][...]
if dunit is not None:
- if not Units(dunit).equivalent(Units("m")):
+ if not Unit(dunit).is_convertible(Unit("m")):
raise ValueError("Non-linear units [%s] of the layered dimension [%s] in %s" % (dunit,depth_name,filename))
- depth = Units.conform(depth,Units(dunit),Units("m"),inplace=True)
+ depth = Unit(dunit).convert(depth,Unit("m"),inplace=True)
if depth_bnd is not None:
- depth_bnd = Units.conform(depth_bnd,Units(dunit),Units("m"),inplace=True)
+ depth_bnd = Unit(dunit).convert(depth_bnd,Unit("m"),inplace=True)
if data_name is not None:
data = len(grp.dimensions[data_name])
@@ -701,16 +704,15 @@ def FromNetCDF4(filename,variable_name,alternate_vars=[],t0=None,tf=None,group=N
if "missing_value" in var.ncattrs(): mask += (np.abs(v-var.missing_value)<1e-12)
v = np.ma.masked_array(v,mask=mask,copy=False)
- # handle units problems that cfunits doesn't
if "units" in var.ncattrs():
- units = var.units.replace("unitless","1")
+ units = FixDumbUnits(var.units)
else:
units = "1"
dset.close()
return v,units,variable_name,t,t_bnd,lat,lat_bnd,lon,lon_bnd,depth,depth_bnd,cbounds,data
-def Score(var,normalizer,FC=0.999999):
+def Score(var,normalizer):
"""Remaps a normalized variable to the interval [0,1].
Parameters
@@ -726,16 +728,7 @@ def Score(var,normalizer,FC=0.999999):
name = name.replace("rmse","rmse_score")
name = name.replace("iav" ,"iav_score")
np.seterr(over='ignore',under='ignore')
-
- data = None
- if "bias" in var.name or "diff" in var.name:
- deno = np.ma.copy(normalizer.data)
- if (deno.size - deno.mask.sum()) > 1: deno -= deno.min()*FC
- data = np.exp(-np.abs(var.data/deno))
- elif "rmse" in var.name:
- data = np.exp(-var.data/normalizer.data)
- elif "iav" in var.name:
- data = np.exp(-np.abs(var.data/normalizer.data))
+ data = np.exp(-np.abs(var.data/normalizer.data))
data[data<1e-16] = 0.
np.seterr(over='raise',under='raise')
return Variable(name = name,
@@ -810,7 +803,7 @@ def _composeGrids(v1,v2):
lon = lon_bnds.mean(axis=1)
return lat,lon,lat_bnds,lon_bnds
-def AnalysisMeanState(ref,com,**keywords):
+def AnalysisMeanStateSites(ref,com,**keywords):
"""Perform a mean state analysis.
This mean state analysis examines the model mean state in space
@@ -848,6 +841,7 @@ def AnalysisMeanState(ref,com,**keywords):
the unit to use when displaying output on plots on the HTML page
"""
+
from Variable import Variable
regions = keywords.get("regions" ,["global"])
dataset = keywords.get("dataset" ,None)
@@ -860,14 +854,14 @@ def AnalysisMeanState(ref,com,**keywords):
skip_iav = keywords.get("skip_iav" ,False)
skip_cycle = keywords.get("skip_cycle" ,False)
ILAMBregions = Regions()
- spatial = ref.spatial
+ spatial = False
normalizer = None
# Only study the annual cycle if it makes sense
if not ref.monthly: skip_cycle = True
if ref.time.size < 12: skip_cycle = True
-
- # We find
+ if skip_rmse : skip_iav = True
+
if spatial:
lat,lon,lat_bnds,lon_bnds = _composeGrids(ref,com)
REF = ref.interpolate(lat=lat,lon=lon,lat_bnds=lat_bnds,lon_bnds=lon_bnds)
@@ -926,14 +920,58 @@ def AnalysisMeanState(ref,com,**keywords):
# Compute the bias, RMSE, and RMS maps using the interpolated
# quantities
bias = REF_timeint.bias(COM_timeint)
- bias_score_map = Score(bias,REF_timeint)
+ cREF = Variable(name = "centralized %s" % REF.name, unit = REF.unit,
+ data = np.ma.masked_array(REF.data-REF_timeint.data[np.newaxis,...],mask=REF.data.mask),
+ time = REF.time, time_bnds = REF.time_bnds,
+ lat = REF.lat , lat_bnds = REF.lat_bnds,
+ lon = REF.lon , lon_bnds = REF.lon_bnds,
+ area = REF.area, ndata = REF.ndata)
+ crms = cREF.rms ()
+ bias_score_map = Score(bias,crms)
if spatial:
bias_score_map.data.mask = (ref_and_com==False) # for some reason I need to explicitly force the mask
if not skip_rmse:
- rmse = REF.rmse(COM)
- rms = REF.rms ()
- rmse_score_map = Score(rmse,rms)
-
+ cCOM = Variable(name = "centralized %s" % COM.name, unit = COM.unit,
+ data = np.ma.masked_array(COM.data-COM_timeint.data[np.newaxis,...],mask=COM.data.mask),
+ time = COM.time, time_bnds = COM.time_bnds,
+ lat = COM.lat , lat_bnds = COM.lat_bnds,
+ lon = COM.lon , lon_bnds = COM.lon_bnds,
+ area = COM.area, ndata = COM.ndata)
+ rmse = REF.rmse( COM)
+ crmse = cREF.rmse(cCOM)
+ rmse_score_map = Score(crmse,crms)
+ if not skip_iav:
+ ref_iav = Variable(name = "centralized %s" % ref.name, unit = ref.unit,
+ data = np.ma.masked_array(ref.data-ref_timeint.data[np.newaxis,...],mask=ref.data.mask),
+ time = ref.time, time_bnds = ref.time_bnds,
+ lat = ref.lat , lat_bnds = ref.lat_bnds,
+ lon = ref.lon , lon_bnds = ref.lon_bnds,
+ area = ref.area, ndata = ref.ndata).rms()
+ com_iav = Variable(name = "centralized %s" % com.name, unit = com.unit,
+ data = np.ma.masked_array(com.data-com_timeint.data[np.newaxis,...],mask=com.data.mask),
+ time = com.time, time_bnds = com.time_bnds,
+ lat = com.lat , lat_bnds = com.lat_bnds,
+ lon = com.lon , lon_bnds = com.lon_bnds,
+ area = com.area, ndata = com.ndata).rms()
+ REF_iav = Variable(name = "centralized %s" % REF.name, unit = REF.unit,
+ data = np.ma.masked_array(REF.data-REF_timeint.data[np.newaxis,...],mask=REF.data.mask),
+ time = REF.time, time_bnds = REF.time_bnds,
+ lat = REF.lat , lat_bnds = REF.lat_bnds,
+ lon = REF.lon , lon_bnds = REF.lon_bnds,
+ area = REF.area, ndata = REF.ndata).rms()
+ COM_iav = Variable(name = "centralized %s" % COM.name, unit = COM.unit,
+ data = np.ma.masked_array(COM.data-COM_timeint.data[np.newaxis,...],mask=COM.data.mask),
+ time = COM.time, time_bnds = COM.time_bnds,
+ lat = COM.lat , lat_bnds = COM.lat_bnds,
+ lon = COM.lon , lon_bnds = COM.lon_bnds,
+ area = COM.area, ndata = COM.ndata).rms()
+ iav_score_map = Score(Variable(name = "diff %s" % REF.name, unit = REF.unit,
+ data = (COM_iav.data-REF_iav.data),
+ lat = REF.lat , lat_bnds = REF.lat_bnds,
+ lon = REF.lon , lon_bnds = REF.lon_bnds,
+ area = REF.area, ndata = REF.ndata),
+ REF_iav)
+
# The phase shift comes from the interpolated quantities
if not skip_cycle:
ref_cycle = REF.annualCycle()
@@ -948,7 +986,7 @@ def AnalysisMeanState(ref,com,**keywords):
ref_period_mean = {}; ref_spaceint = {}; ref_mean_cycle = {}; ref_dtcycle = {}
com_period_mean = {}; com_spaceint = {}; com_mean_cycle = {}; com_dtcycle = {}
bias_val = {}; bias_score = {}; rmse_val = {}; rmse_score = {}
- space_std = {}; space_cor = {}; sd_score = {}; shift = {}; shift_score = {}
+ space_std = {}; space_cor = {}; sd_score = {}; shift = {}; shift_score = {}; iav_score = {}
ref_union_mean = {}; ref_comp_mean = {}
com_union_mean = {}; com_comp_mean = {}
for region in regions:
@@ -975,6 +1013,8 @@ def AnalysisMeanState(ref,com,**keywords):
if not skip_rmse:
rmse_val [region] = rmse .integrateInSpace(region=region,mean=True)
rmse_score [region] = rmse_score_map .integrateInSpace(region=region,mean=True,weight=normalizer)
+ if not skip_iav:
+ iav_score [region] = iav_score_map .integrateInSpace(region=region,mean=True,weight=normalizer)
space_std[region],space_cor[region],sd_score[region] = REF_timeint.spatialDistribution(COM_timeint,region=region)
else:
ref_period_mean[region] = ref_timeint .siteStats(region=region)
@@ -995,6 +1035,8 @@ def AnalysisMeanState(ref,com,**keywords):
if not skip_rmse:
rmse_val [region] = rmse .siteStats(region=region)
rmse_score [region] = rmse_score_map .siteStats(region=region,weight=normalizer)
+ if not skip_iav:
+ iav_score [region] = iav_score_map .siteStats(region=region,weight=normalizer)
ref_period_mean[region].name = "Period Mean (original grids) %s" % (region)
ref_spaceint [region].name = "spaceint_of_%s_over_%s" % (ref.name,region)
@@ -1005,6 +1047,8 @@ def AnalysisMeanState(ref,com,**keywords):
if not skip_rmse:
rmse_val [region].name = "RMSE %s" % (region)
rmse_score [region].name = "RMSE Score %s" % (region)
+ if not skip_iav:
+ iav_score [region].name = "Interannual Variability Score %s" % (region)
if not skip_cycle:
ref_mean_cycle[region].name = "cycle_of_%s_over_%s" % (ref.name,region)
ref_dtcycle [region].name = "dtcycle_of_%s_over_%s" % (ref.name,region)
@@ -1033,6 +1077,7 @@ def _convert(var,unit):
plot_vars = [com_timeint,ref_timeint,bias,com_spaceint,ref_spaceint,bias_val]
if not skip_rmse: plot_vars += [rmse,rmse_val]
if not skip_cycle: plot_vars += [com_mean_cycle,ref_mean_cycle,com_dtcycle,ref_dtcycle]
+ if not skip_iav: plot_vars += [com_iav]
for var in plot_vars: _convert(var,plot_unit)
# Rename and optionally dump out information to netCDF4 files
@@ -1064,13 +1109,17 @@ def _convert(var,unit):
out_vars.append(shift_score_map)
if not skip_rmse:
rmse .name = "rmse_map_of_%s" % ref.name
- rms .name = "rms_map_of_%s" % ref.name
rmse_score_map.name = "rmsescore_map_of_%s" % ref.name
out_vars.append(rmse)
- out_vars.append(rms )
out_vars.append(rmse_score_map)
out_vars.append(rmse_val)
out_vars.append(rmse_score)
+ if not skip_iav:
+ com_iav.name = "iav_map_of_%s" % ref.name
+ iav_score_map.name = "iavscore_map_of_%s" % ref.name
+ out_vars.append(com_iav)
+ out_vars.append(iav_score_map)
+ out_vars.append(iav_score)
if dataset is not None:
for var in out_vars:
if type(var) == type({}):
@@ -1089,6 +1138,9 @@ def _convert(var,unit):
if not skip_cycle:
ref_maxt_map.name = "phase_map_of_%s" % ref.name
out_vars += [ref_maxt_map,ref_mean_cycle,ref_dtcycle]
+ if not skip_iav:
+ ref_iav.name = "iav_map_of_%s" % ref.name
+ out_vars.append(ref_iav)
if benchmark_dataset is not None:
for var in out_vars:
if type(var) == type({}):
@@ -1097,124 +1149,303 @@ def _convert(var,unit):
var.toNetCDF4(benchmark_dataset,group="MeanState")
return
-
-def AnalysisRelationship(dep_var,ind_var,dataset,rname,**keywords):
- """Perform a relationship analysis.
-
- Expand to provide details of what exactly is done.
+
+def AnalysisMeanStateSpace(ref,com,**keywords):
+ """Perform a mean state analysis.
+
+ This mean state analysis examines the model mean state in space
+ and time. We compute the mean variable value over the time period
+ at each spatial cell or data site as appropriate, as well as the
+ bias and RMSE relative to the observational variable. We will
+ output maps of the period mean values and bias. For each spatial
+ cell or data site we also estimate the phase of the variable by
+ finding the mean time of year when the maximum occurs and the
+ phase shift by computing the difference in phase with respect to
+ the observational variable. In the spatial dimension, we compute a
+ spatial mean for each of the desired regions and an average annual
+ cycle.
Parameters
----------
- dep_var : ILAMB.Variable.Variable
- the dependent variable
- ind_var : ILAMB.Variable.Variable
- the independent variable
- dataset : netCDF4.Dataset
+ obs : ILAMB.Variable.Variable
+ the observational (reference) variable
+ mod : ILAMB.Variable.Variable
+ the model (comparison) variable
+ regions : list of str, optional
+ the regions overwhich to apply the analysis
+ dataset : netCDF4.Dataset, optional
a open dataset in write mode for caching the results of the
analysis which pertain to the model
- rname : str
- the name of the relationship under study
- regions : list of str, optional
- a list of units over which to apply the analysis
- dep_plot_unit,ind_plot_unit : str, optional
- the name of the unit to use in the plots found on the HTML output
-
- """
- def _extractMaxTemporalOverlap(v1,v2): # should move?
- t0 = max(v1.time.min(),v2.time.min())
- tf = min(v1.time.max(),v2.time.max())
- for v in [v1,v2]:
- begin = np.argmin(np.abs(v.time-t0))
- end = np.argmin(np.abs(v.time-tf))+1
- v.time = v.time[begin:end]
- v.data = v.data[begin:end,...]
- mask = v1.data.mask + v2.data.mask
- v1 = v1.data[mask==0].flatten()
- v2 = v2.data[mask==0].flatten()
- return v1,v2
-
- # grab regions
- regions = keywords.get("regions",["global"])
+ benchmark_dataset : netCDF4.Dataset, optional
+ a open dataset in write mode for caching the results of the
+ analysis which pertain to the observations
+ space_mean : bool, optional
+ disable to compute sums of the variable over space instead of
+ mean values
+ table_unit : str, optional
+ the unit to use when displaying output in tables on the HTML page
+ plots_unit : str, optional
+ the unit to use when displaying output on plots on the HTML page
+
+ """
+ from Variable import Variable
+ regions = keywords.get("regions" ,["global"])
+ dataset = keywords.get("dataset" ,None)
+ benchmark_dataset = keywords.get("benchmark_dataset",None)
+ space_mean = keywords.get("space_mean" ,True)
+ table_unit = keywords.get("table_unit" ,None)
+ plot_unit = keywords.get("plot_unit" ,None)
+ mass_weighting = keywords.get("mass_weighting" ,False)
+ skip_rmse = keywords.get("skip_rmse" ,False)
+ skip_iav = keywords.get("skip_iav" ,False)
+ skip_cycle = keywords.get("skip_cycle" ,False)
+ ILAMBregions = Regions()
+ spatial = ref.spatial
+
+ # Convert str types to booleans
+ if type(skip_rmse) == type(""):
+ skip_rmse = (skip_rmse.lower() == "true")
+ if type(skip_iav ) == type(""):
+ skip_iav = (skip_iav .lower() == "true")
+ if type(skip_cycle) == type(""):
+ skip_cycle = (skip_cycle.lower() == "true")
- # convert to plot units
- dep_plot_unit = keywords.get("dep_plot_unit",dep_var.unit)
- ind_plot_unit = keywords.get("ind_plot_unit",ind_var.unit)
- if dep_plot_unit is not None: dep_var.convert(dep_plot_unit)
- if ind_plot_unit is not None: ind_var.convert(ind_plot_unit)
-
- # if the variables are temporal, we need to get period means
- if dep_var.temporal: dep_var = dep_var.integrateInTime(mean=True)
- if ind_var.temporal: ind_var = ind_var.integrateInTime(mean=True)
- mask = dep_var.data.mask + ind_var.data.mask
-
- # analysis over regions
- for region in regions:
+ # Check if we need to skip parts of the analysis
+ if not ref.monthly : skip_cycle = True
+ if ref.time.size < 12: skip_cycle = True
+ if ref.time.size == 1: skip_rmse = True
+ if skip_rmse : skip_iav = True
+ name = ref.name
+
+ # Interpolate both reference and comparison to a grid composed of
+ # their cell breaks
+ ref.convert(plot_unit)
+ com.convert(plot_unit)
+ lat,lon,lat_bnds,lon_bnds = _composeGrids(ref,com)
+ REF = ref.interpolate(lat=lat,lon=lon,lat_bnds=lat_bnds,lon_bnds=lon_bnds)
+ COM = com.interpolate(lat=lat,lon=lon,lat_bnds=lat_bnds,lon_bnds=lon_bnds)
+ unit = REF.unit
+ area = REF.area
+ ndata = REF.ndata
+
+ # Find the mean values over the time period
+ ref_timeint = ref.integrateInTime(mean=True).convert(plot_unit)
+ com_timeint = com.integrateInTime(mean=True).convert(plot_unit)
+ REF_timeint = REF.integrateInTime(mean=True).convert(plot_unit)
+ COM_timeint = COM.integrateInTime(mean=True).convert(plot_unit)
+ normalizer = REF_timeint.data if mass_weighting else None
+
+ # Report period mean values over all possible representations of
+ # land
+ ref_and_com = (REF_timeint.data.mask == False) * (COM_timeint.data.mask == False)
+ ref_not_com = (REF_timeint.data.mask == False) * (COM_timeint.data.mask == True )
+ com_not_ref = (REF_timeint.data.mask == True ) * (COM_timeint.data.mask == False)
+ if benchmark_dataset is not None:
- lats,lons = ILAMBregions[region]
- rmask = (np.outer((dep_var.lat>lats[0])*(dep_var.lat
lons[0])*(dep_var.lon 1 else REF_timeint)
+ bias_score_map.data.mask = (ref_and_com==False) # for some reason I need to explicitly force the mask
+ if dataset is not None:
+ bias.name = "bias_map_of_%s" % name
+ bias.toNetCDF4(dataset,group="MeanState")
+ bias_score_map.name = "biasscore_map_of_%s" % name
+ bias_score_map.toNetCDF4(dataset,group="MeanState")
+ for region in regions:
+ bias_val = bias.integrateInSpace(region=region,mean=True).convert(plot_unit)
+ bias_val.name = "Bias %s" % region
+ bias_val.toNetCDF4(dataset,group="MeanState")
+ bias_score = bias_score_map.integrateInSpace(region=region,mean=True,weight=normalizer)
+ bias_score.name = "Bias Score %s" % region
+ bias_score.toNetCDF4(dataset,group="MeanState")
+ del bias,bias_score_map
+
+ # Spatial mean: plots
+ if REF.time.size > 1:
+ if benchmark_dataset is not None:
+ for region in regions:
+ ref_spaceint = REF.integrateInSpace(region=region,mean=True)
+ ref_spaceint.name = "spaceint_of_%s_over_%s" % (name,region)
+ ref_spaceint.toNetCDF4(benchmark_dataset,group="MeanState")
+ if dataset is not None:
+ for region in regions:
+ com_spaceint = COM.integrateInSpace(region=region,mean=True)
+ com_spaceint.name = "spaceint_of_%s_over_%s" % (name,region)
+ com_spaceint.toNetCDF4(dataset,group="MeanState")
+
+ # RMSE: maps, scalars, and scores
+ if not skip_rmse:
+ rmse = REF.rmse(COM).convert(plot_unit)
+ del REF
+ cCOM = Variable(name = "centralized %s" % name, unit = unit,
+ data = np.ma.masked_array(COM.data-COM_timeint.data[np.newaxis,...],mask=COM.data.mask),
+ time = COM.time, time_bnds = COM.time_bnds,
+ lat = lat, lat_bnds = lat_bnds, lon = lon, lon_bnds = lon_bnds,
+ area = COM.area, ndata = COM.ndata).convert(plot_unit)
+ del COM
+ crmse = cREF.rmse(cCOM).convert(plot_unit)
+ del cREF
+ if skip_iav: del cCOM
+ rmse_score_map = Score(crmse,REF_iav)
+ if dataset is not None:
+ rmse.name = "rmse_map_of_%s" % name
+ rmse.toNetCDF4(dataset,group="MeanState")
+ rmse_score_map.name = "rmsescore_map_of_%s" % name
+ rmse_score_map.toNetCDF4(dataset,group="MeanState")
+ for region in regions:
+ rmse_val = rmse.integrateInSpace(region=region,mean=True).convert(plot_unit)
+ rmse_val.name = "RMSE %s" % region
+ rmse_val.toNetCDF4(dataset,group="MeanState")
+ rmse_score = rmse_score_map.integrateInSpace(region=region,mean=True,weight=normalizer)
+ rmse_score.name = "RMSE Score %s" % region
+ rmse_score.toNetCDF4(dataset,group="MeanState")
+ del rmse,crmse,rmse_score_map
+
+ # IAV: maps, scalars, scores
+ if not skip_iav:
+ COM_iav = cCOM.rms()
+ del cCOM
+ iav_score_map = Score(Variable(name = "diff %s" % name, unit = unit,
+ data = (COM_iav.data-REF_iav.data),
+ lat = lat, lat_bnds = lat_bnds, lon = lon, lon_bnds = lon_bnds,
+ area = area, ndata = ndata),
+ REF_iav)
+ if benchmark_dataset is not None:
+ REF_iav.name = "iav_map_of_%s" % name
+ REF_iav.toNetCDF4(benchmark_dataset,group="MeanState")
+ if dataset is not None:
+ COM_iav.name = "iav_map_of_%s" % name
+ COM_iav.toNetCDF4(dataset,group="MeanState")
+ iav_score_map.name = "iavscore_map_of_%s" % name
+ iav_score_map.toNetCDF4(dataset,group="MeanState")
+ for region in regions:
+ iav_score = iav_score_map.integrateInSpace(region=region,mean=True,weight=normalizer)
+ iav_score.name = "Interannual Variability Score %s" % region
+ iav_score.toNetCDF4(dataset,group="MeanState")
+ del COM_iav,iav_score_map
+ del REF_iav
+
+ return
def ClipTime(v,t0,tf):
"""Remove time from a variable based on input bounds.
@@ -1300,10 +1531,10 @@ def MakeComparable(ref,com,**keywords):
# If the reference is spatial, the comparison must be
if ref.spatial and not com.spatial:
- msg = "%s Datasets are not uniformly spatial: " % logstring
- msg += "reference = %s, comparison = %s" % (ref.spatial,com.spatial)
- logger.debug(msg)
- raise VarsNotComparable()
+ ref = ref.extractDatasites(com.lat,com.lon)
+ msg = "%s The reference dataset is spatial but the comparison is site-based. " % logstring
+ msg += "Extracted %s sites from the reference to match the comparison." % ref.ndata
+ logger.info(msg)
# If the reference is layered, the comparison must be
if ref.layered and not com.layered:
@@ -1383,7 +1614,7 @@ def MakeComparable(ref,com,**keywords):
# comparison, coarsen the comparison
if np.log10(ref.dt/com.dt) > 0.5:
com = com.coarsenInTime(ref.time_bnds,window=window)
-
+
# Time bounds of the reference dataset
t0 = ref.time_bnds[ 0,0]
tf = ref.time_bnds[-1,1]
diff --git a/ilamb/ilamb/test/scores_test.csv.gold b/ilamb/ilamb/test/scores_test.csv.gold
index 6d65ab7b..6fccfb93 100644
--- a/ilamb/ilamb/test/scores_test.csv.gold
+++ b/ilamb/ilamb/test/scores_test.csv.gold
@@ -1,9 +1,9 @@
Variables,CLM50r243CRUNCEP,CLM50r243GSWP3
-Biomass,0.595710463937,0.678304573522
-Gross Primary Productivity,0.753476728464,0.741270301037
-Global Net Ecosystem Carbon Balance,0.705400063727,0.863669079462
-Net Ecosystem Exchange,0.524058275106,0.504338904659
-Terrestrial Water Storage Anomaly,0.484015616221,0.470205924215
-Albedo,0.771776381299,0.774604472682
-Surface Air Temperature,0.988457088529,0.990624010352
-Precipitation,0.812343937554,0.824581872315
+Biomass,0.5957104653413856,0.6783045750117078
+Gross Primary Productivity,0.6217211297637607,0.6126273585798891
+Global Net Ecosystem Carbon Balance,0.7054000637266042,0.8636690794621101
+Net Ecosystem Exchange,0.3941918077804778,0.38120476926634617
+Terrestrial Water Storage Anomaly,0.7000653021257858,0.7269702240175762
+Albedo,0.5434663466148166,0.544587485316599
+Surface Air Temperature,0.9256731031865132,0.9314748385926337
+Precipitation,0.7555153501937276,0.7679655805094326