[330] | 1 | |
---|
| 2 | # L. Fita, LMD-Jussieu. February 2015 |
---|
| 3 | ## e.g. # validation_sim.py -d X@west_east@None,Y@south_north@None,T@Time@time -D X@XLONG@longitude,Y@XLAT@latitude,T@time@time -k single-station -l 4.878773,43.915876,12. -o /home/lluis/DATA/obs/HyMeX/IOP15/sfcEnergyBalance_Avignon/OBSnetcdf.nc -s /home/lluis/PY/wrfout_d01_2012-10-18_00:00:00.tests -v HFX@H |
---|
| 4 | import numpy as np |
---|
| 5 | import os |
---|
| 6 | import re |
---|
| 7 | from optparse import OptionParser |
---|
| 8 | from netCDF4 import Dataset as NetCDFFile |
---|
| 9 | |
---|
| 10 | main = 'validarion_sim.py' |
---|
| 11 | errormsg = 'ERROR -- errror -- ERROR -- error' |
---|
| 12 | warnmsg = 'WARNING -- warning -- WARNING -- warning' |
---|
| 13 | |
---|
| 14 | # version |
---|
| 15 | version=1.0 |
---|
| 16 | |
---|
| 17 | # Filling values for floats, integer and string |
---|
| 18 | fillValueF = 1.e20 |
---|
| 19 | fillValueI = -99999 |
---|
| 20 | fillValueS = '---' |
---|
| 21 | |
---|
| 22 | def index_3mat(matA,matB,matC,val): |
---|
| 23 | """ Function to provide the coordinates of a given value inside three matrix simultaneously |
---|
| 24 | index_mat(matA,matB,matC,val) |
---|
| 25 | matA= matrix with one set of values |
---|
| 26 | matB= matrix with the other set of values |
---|
| 27 | matB= matrix with the third set of values |
---|
| 28 | val= triplet of values to search |
---|
| 29 | >>> index_mat(np.arange(27).reshape(3,3,3),np.arange(100,127).reshape(3,3,3),np.arange(200,227).reshape(3,3,3),[22,122,222]) |
---|
| 30 | [2 1 1] |
---|
| 31 | """ |
---|
| 32 | fname = 'index_3mat' |
---|
| 33 | |
---|
| 34 | matAshape = matA.shape |
---|
| 35 | matBshape = matB.shape |
---|
| 36 | matCshape = matC.shape |
---|
| 37 | |
---|
| 38 | for idv in range(len(matAshape)): |
---|
| 39 | if matAshape[idv] != matBshape[idv]: |
---|
| 40 | print errormsg |
---|
| 41 | print ' ' + fname + ': Dimension',idv,'of matrices A:',matAshape[idv], \ |
---|
| 42 | 'and B:',matBshape[idv],'does not coincide!!' |
---|
| 43 | quit(-1) |
---|
| 44 | if matAshape[idv] != matCshape[idv]: |
---|
| 45 | print errormsg |
---|
| 46 | print ' ' + fname + ': Dimension',idv,'of matrices A:',matAshape[idv], \ |
---|
| 47 | 'and C:',matCshape[idv],'does not coincide!!' |
---|
| 48 | quit(-1) |
---|
| 49 | |
---|
| 50 | minA = np.min(matA) |
---|
| 51 | maxA = np.max(matA) |
---|
| 52 | minB = np.min(matB) |
---|
| 53 | maxB = np.max(matB) |
---|
| 54 | minC = np.min(matC) |
---|
| 55 | maxC = np.max(matC) |
---|
| 56 | |
---|
| 57 | if val[0] < minA or val[0] > maxA: |
---|
| 58 | print warnmsg |
---|
| 59 | print ' ' + fname + ': first value:',val[0],'outside matA range',minA,',', \ |
---|
| 60 | maxA,'!!' |
---|
| 61 | if val[1] < minB or val[1] > maxB: |
---|
| 62 | print warnmsg |
---|
| 63 | print ' ' + fname + ': second value:',val[1],'outside matB range',minB,',', \ |
---|
| 64 | maxB,'!!' |
---|
| 65 | if val[2] < minC or val[2] > maxC: |
---|
| 66 | print warnmsg |
---|
| 67 | print ' ' + fname + ': second value:',val[2],'outside matC range',minC,',', \ |
---|
| 68 | maxC,'!!' |
---|
| 69 | |
---|
| 70 | dist = np.zeros(tuple(matAshape), dtype=np.float) |
---|
| 71 | dist = np.sqrt((matA - np.float(val[0]))**2 + (matB - np.float(val[1]))**2 + \ |
---|
| 72 | (matC - np.float(val[2]))**2) |
---|
| 73 | |
---|
| 74 | mindist = np.min(dist) |
---|
| 75 | |
---|
| 76 | matlist = list(dist.flatten()) |
---|
| 77 | ifound = matlist.index(mindist) |
---|
| 78 | |
---|
| 79 | Ndims = len(matAshape) |
---|
| 80 | valpos = np.zeros((Ndims), dtype=int) |
---|
| 81 | baseprevdims = np.zeros((Ndims), dtype=int) |
---|
| 82 | |
---|
| 83 | for dimid in range(Ndims): |
---|
| 84 | baseprevdims[dimid] = np.product(matAshape[dimid+1:Ndims]) |
---|
| 85 | if dimid == 0: |
---|
| 86 | alreadyplaced = 0 |
---|
| 87 | else: |
---|
| 88 | alreadyplaced = np.sum(baseprevdims[0:dimid]*valpos[0:dimid]) |
---|
| 89 | valpos[dimid] = int((ifound - alreadyplaced )/ baseprevdims[dimid]) |
---|
| 90 | |
---|
| 91 | return valpos |
---|
| 92 | |
---|
| 93 | def index_2mat(matA,matB,val): |
---|
| 94 | """ Function to provide the coordinates of a given value inside two matrix simultaneously |
---|
| 95 | index_mat(matA,matB,val) |
---|
| 96 | matA= matrix with one set of values |
---|
| 97 | matB= matrix with the pother set of values |
---|
| 98 | val= couple of values to search |
---|
| 99 | >>> index_mat(np.arange(27).reshape(3,3,3),np.arange(100,127).reshape(3,3,3),[22,111]) |
---|
| 100 | [2 1 1] |
---|
| 101 | """ |
---|
| 102 | fname = 'index_2mat' |
---|
| 103 | |
---|
| 104 | matAshape = matA.shape |
---|
| 105 | matBshape = matB.shape |
---|
| 106 | |
---|
| 107 | for idv in range(len(matAshape)): |
---|
| 108 | if matAshape[idv] != matBshape[idv]: |
---|
| 109 | print errormsg |
---|
| 110 | print ' ' + fname + ': Dimension',idv,'of matrices A:',matAshape[idv], \ |
---|
| 111 | 'and B:',matBshape[idv],'does not coincide!!' |
---|
| 112 | quit(-1) |
---|
| 113 | |
---|
| 114 | minA = np.min(matA) |
---|
| 115 | maxA = np.max(matA) |
---|
| 116 | minB = np.min(matB) |
---|
| 117 | maxB = np.max(matB) |
---|
| 118 | |
---|
| 119 | if val[0] < minA or val[0] > maxA: |
---|
| 120 | print warnmsg |
---|
| 121 | print ' ' + fname + ': first value:',val[0],'outside matA range',minA,',', \ |
---|
| 122 | maxA,'!!' |
---|
| 123 | if val[1] < minB or val[1] > maxB: |
---|
| 124 | print warnmsg |
---|
| 125 | print ' ' + fname + ': second value:',val[1],'outside matB range',minB,',', \ |
---|
| 126 | maxB,'!!' |
---|
| 127 | |
---|
| 128 | dist = np.zeros(tuple(matAshape), dtype=np.float) |
---|
| 129 | dist = np.sqrt((matA - np.float(val[0]))**2 + (matB - np.float(val[1]))**2) |
---|
| 130 | |
---|
| 131 | mindist = np.min(dist) |
---|
| 132 | |
---|
| 133 | matlist = list(dist.flatten()) |
---|
| 134 | ifound = matlist.index(mindist) |
---|
| 135 | |
---|
| 136 | Ndims = len(matAshape) |
---|
| 137 | valpos = np.zeros((Ndims), dtype=int) |
---|
| 138 | baseprevdims = np.zeros((Ndims), dtype=int) |
---|
| 139 | |
---|
| 140 | for dimid in range(Ndims): |
---|
| 141 | baseprevdims[dimid] = np.product(matAshape[dimid+1:Ndims]) |
---|
| 142 | if dimid == 0: |
---|
| 143 | alreadyplaced = 0 |
---|
| 144 | else: |
---|
| 145 | alreadyplaced = np.sum(baseprevdims[0:dimid]*valpos[0:dimid]) |
---|
| 146 | valpos[dimid] = int((ifound - alreadyplaced )/ baseprevdims[dimid]) |
---|
| 147 | |
---|
| 148 | return valpos |
---|
| 149 | |
---|
| 150 | def index_mat(mat,val): |
---|
| 151 | """ Function to provide the coordinates of a given value inside a matrix |
---|
| 152 | index_mat(mat,val) |
---|
| 153 | mat= matrix with values |
---|
| 154 | val= value to search |
---|
| 155 | >>> index_mat(np.arange(27).reshape(3,3,3),22) |
---|
| 156 | [2 1 1] |
---|
| 157 | """ |
---|
| 158 | |
---|
| 159 | fname = 'index_mat' |
---|
| 160 | |
---|
| 161 | matshape = mat.shape |
---|
| 162 | |
---|
| 163 | matlist = list(mat.flatten()) |
---|
| 164 | ifound = matlist.index(val) |
---|
| 165 | |
---|
| 166 | Ndims = len(matshape) |
---|
| 167 | valpos = np.zeros((Ndims), dtype=int) |
---|
| 168 | baseprevdims = np.zeros((Ndims), dtype=int) |
---|
| 169 | |
---|
| 170 | for dimid in range(Ndims): |
---|
| 171 | baseprevdims[dimid] = np.product(matshape[dimid+1:Ndims]) |
---|
| 172 | if dimid == 0: |
---|
| 173 | alreadyplaced = 0 |
---|
| 174 | else: |
---|
| 175 | alreadyplaced = np.sum(baseprevdims[0:dimid]*valpos[0:dimid]) |
---|
| 176 | valpos[dimid] = int((ifound - alreadyplaced )/ baseprevdims[dimid]) |
---|
| 177 | |
---|
| 178 | return valpos |
---|
| 179 | |
---|
| 180 | def coincident_CFtimes(tvalB, tunitA, tunitB): |
---|
| 181 | """ Function to make coincident times for two different sets of CFtimes |
---|
| 182 | tvalB= time values B |
---|
| 183 | tunitA= time units times A to which we want to make coincidence |
---|
| 184 | tunitB= time units times B |
---|
| 185 | >>> coincident_CFtimes(np.arange(10),'seconds since 1949-12-01 00:00:00', |
---|
| 186 | 'hours since 1949-12-01 00:00:00') |
---|
| 187 | [ 0. 3600. 7200. 10800. 14400. 18000. 21600. 25200. 28800. 32400.] |
---|
| 188 | >>> coincident_CFtimes(np.arange(10),'seconds since 1949-12-01 00:00:00', |
---|
| 189 | 'hours since 1979-12-01 00:00:00') |
---|
| 190 | [ 9.46684800e+08 9.46688400e+08 9.46692000e+08 9.46695600e+08 |
---|
| 191 | 9.46699200e+08 9.46702800e+08 9.46706400e+08 9.46710000e+08 |
---|
| 192 | 9.46713600e+08 9.46717200e+08] |
---|
| 193 | """ |
---|
| 194 | import datetime as dt |
---|
| 195 | fname = 'coincident_CFtimes' |
---|
| 196 | |
---|
| 197 | trefA = tunitA.split(' ')[2] + ' ' + tunitA.split(' ')[3] |
---|
| 198 | trefB = tunitB.split(' ')[2] + ' ' + tunitB.split(' ')[3] |
---|
| 199 | tuA = tunitA.split(' ')[0] |
---|
| 200 | tuB = tunitB.split(' ')[0] |
---|
| 201 | |
---|
| 202 | if tuA != tuB: |
---|
| 203 | if tuA == 'microseconds': |
---|
| 204 | if tuB == 'microseconds': |
---|
| 205 | tB = tvalB*1. |
---|
| 206 | elif tuB == 'seconds': |
---|
| 207 | tB = tvalB*10.e6 |
---|
| 208 | elif tuB == 'minutes': |
---|
| 209 | tB = tvalB*60.*10.e6 |
---|
| 210 | elif tuB == 'hours': |
---|
| 211 | tB = tvalB*3600.*10.e6 |
---|
| 212 | elif tuB == 'days': |
---|
| 213 | tB = tvalB*3600.*24.*10.e6 |
---|
| 214 | else: |
---|
| 215 | print errormsg |
---|
| 216 | print ' ' + fname + ": combination of time untis: '" + tuA + \ |
---|
| 217 | "' & '" + tuB + "' not ready !!" |
---|
| 218 | quit(-1) |
---|
| 219 | elif tuA == 'seconds': |
---|
| 220 | if tuB == 'microseconds': |
---|
| 221 | tB = tvalB/10.e6 |
---|
| 222 | elif tuB == 'seconds': |
---|
| 223 | tB = tvalB*1. |
---|
| 224 | elif tuB == 'minutes': |
---|
| 225 | tB = tvalB*60. |
---|
| 226 | elif tuB == 'hours': |
---|
| 227 | tB = tvalB*3600. |
---|
| 228 | elif tuB == 'days': |
---|
| 229 | tB = tvalB*3600.*24. |
---|
| 230 | else: |
---|
| 231 | print errormsg |
---|
| 232 | print ' ' + fname + ": combination of time untis: '" + tuA + \ |
---|
| 233 | "' & '" + tuB + "' not ready !!" |
---|
| 234 | quit(-1) |
---|
| 235 | elif tuA == 'minutes': |
---|
| 236 | if tuB == 'microseconds': |
---|
| 237 | tB = tvalB/(60.*10.e6) |
---|
| 238 | elif tuB == 'seconds': |
---|
| 239 | tB = tvalB/60. |
---|
| 240 | elif tuB == 'minutes': |
---|
| 241 | tB = tvalB*1. |
---|
| 242 | elif tuB == 'hours': |
---|
| 243 | tB = tvalB*60. |
---|
| 244 | elif tuB == 'days': |
---|
| 245 | tB = tvalB*60.*24. |
---|
| 246 | else: |
---|
| 247 | print errormsg |
---|
| 248 | print ' ' + fname + ": combination of time untis: '" + tuA + \ |
---|
| 249 | "' & '" + tuB + "' not ready !!" |
---|
| 250 | quit(-1) |
---|
| 251 | elif tuA == 'hours': |
---|
| 252 | if tuB == 'microseconds': |
---|
| 253 | tB = tvalB/(3600.*10.e6) |
---|
| 254 | elif tuB == 'seconds': |
---|
| 255 | tB = tvalB/3600. |
---|
| 256 | elif tuB == 'minutes': |
---|
| 257 | tB = tvalB/60. |
---|
| 258 | elif tuB == 'hours': |
---|
| 259 | tB = tvalB*1. |
---|
| 260 | elif tuB == 'days': |
---|
| 261 | tB = tvalB*24. |
---|
| 262 | else: |
---|
| 263 | print errormsg |
---|
| 264 | print ' ' + fname + ": combination of time untis: '" + tuA + \ |
---|
| 265 | "' & '" + tuB + "' not ready !!" |
---|
| 266 | quit(-1) |
---|
| 267 | elif tuA == 'days': |
---|
| 268 | if tuB == 'microseconds': |
---|
| 269 | tB = tvalB/(24.*3600.*10.e6) |
---|
| 270 | elif tuB == 'seconds': |
---|
| 271 | tB = tvalB/(24.*3600.) |
---|
| 272 | elif tuB == 'minutes': |
---|
| 273 | tB = tvalB/(24.*60.) |
---|
| 274 | elif tuB == 'hours': |
---|
| 275 | tB = tvalB/24. |
---|
| 276 | elif tuB == 'days': |
---|
| 277 | tB = tvalB*1. |
---|
| 278 | else: |
---|
| 279 | print errormsg |
---|
| 280 | print ' ' + fname + ": combination of time untis: '" + tuA + \ |
---|
| 281 | "' & '" + tuB + "' not ready !!" |
---|
| 282 | quit(-1) |
---|
| 283 | else: |
---|
| 284 | print errormsg |
---|
| 285 | print ' ' + fname + ": time untis: '" + tuA + "' not ready !!" |
---|
| 286 | quit(-1) |
---|
| 287 | else: |
---|
| 288 | tB = tvalB*1. |
---|
| 289 | |
---|
| 290 | if trefA != trefB: |
---|
| 291 | trefTA = dt.datetime.strptime(trefA, '%Y-%m-%d %H:%M:%S') |
---|
| 292 | trefTB = dt.datetime.strptime(trefB, '%Y-%m-%d %H:%M:%S') |
---|
| 293 | |
---|
| 294 | difft = trefTB - trefTA |
---|
| 295 | diffv = difft.days*24.*3600.*10.e6 + difft.seconds*10.e6 + difft.microseconds |
---|
| 296 | print ' ' + fname + ': different reference refA:',trefTA,'refB',trefTB |
---|
| 297 | print ' difference:',difft,':',diffv,'microseconds' |
---|
| 298 | |
---|
| 299 | if tuA == 'microseconds': |
---|
| 300 | tB = tB + diffv |
---|
| 301 | elif tuA == 'seconds': |
---|
| 302 | tB = tB + diffv/10.e6 |
---|
| 303 | elif tuA == 'minutes': |
---|
| 304 | tB = tB + diffv/(60.*10.e6) |
---|
| 305 | elif tuA == 'hours': |
---|
| 306 | tB = tB + diffv/(3600.*10.e6) |
---|
| 307 | elif tuA == 'dayss': |
---|
| 308 | tB = tB + diffv/(24.*3600.*10.e6) |
---|
| 309 | else: |
---|
| 310 | print errormsg |
---|
| 311 | print ' ' + fname + ": time untis: '" + tuA + "' not ready !!" |
---|
| 312 | quit(-1) |
---|
| 313 | |
---|
| 314 | return tB |
---|
| 315 | |
---|
| 316 | ####### ###### ##### #### ### ## # |
---|
| 317 | |
---|
| 318 | strCFt="Refdate,tunits (CF reference date [YYYY][MM][DD][HH][MI][SS] format and " + \ |
---|
| 319 | " and time units: 'weeks', 'days', 'hours', 'miuntes', 'seconds')" |
---|
| 320 | |
---|
| 321 | kindobs=['multi-points', 'single-station', 'trajectory'] |
---|
| 322 | strkObs="kind of observations; 'multi-points': multiple individual punctual obs " + \ |
---|
| 323 | "(e.g., lightning strikes), 'single-station': single station on a fixed position,"+\ |
---|
| 324 | "'trajectory': following a trajectory" |
---|
| 325 | #sumc,[constant]: add [constant] to variables values |
---|
| 326 | #subc,[constant]: substract [constant] to variables values |
---|
| 327 | #mulc,[constant]: multipy by [constant] to variables values |
---|
| 328 | #divc,[constant]: divide by [constant] to variables values |
---|
| 329 | |
---|
| 330 | parser = OptionParser() |
---|
| 331 | parser.add_option("-d", "--dimensions", dest="dims", |
---|
| 332 | help="[DIM]@[simdim]@[obsdim] ',' list of couples of dimensions names from each source ([DIM]='X','Y','Z','T'; None, no value)", |
---|
| 333 | metavar="VALUES") |
---|
| 334 | parser.add_option("-D", "--vardimensions", dest="vardims", |
---|
| 335 | help="[DIM]@[simvardim]@[obsvardim] ',' list of couples of variables names with dimensions values from each source ([DIM]='X','Y','Z','T'; None, no value)", metavar="VALUES") |
---|
| 336 | parser.add_option("-k", "--kindObs", dest="obskind", type='choice', choices=kindobs, |
---|
| 337 | help=strkObs, metavar="FILE") |
---|
| 338 | parser.add_option("-l", "--stationLocation", dest="stloc", |
---|
| 339 | help="longitude, latitude and height of the station (only for 'single-station')", |
---|
| 340 | metavar="FILE") |
---|
| 341 | parser.add_option("-o", "--observation", dest="fobs", |
---|
| 342 | help="observations file to validate", metavar="FILE") |
---|
| 343 | parser.add_option("-s", "--simulation", dest="fsim", |
---|
| 344 | help="simulation file to validate", metavar="FILE") |
---|
| 345 | parser.add_option("-v", "--variables", dest="vars", |
---|
| 346 | help="[simvar]@[obsvar]@[[oper]@[val]] ',' list of couples of variables to validate and if necessary operation and value", metavar="VALUES") |
---|
| 347 | |
---|
| 348 | (opts, args) = parser.parse_args() |
---|
| 349 | |
---|
| 350 | ####### ####### |
---|
| 351 | ## MAIN |
---|
| 352 | ####### |
---|
| 353 | |
---|
| 354 | ofile='validation_sim.nc' |
---|
| 355 | |
---|
| 356 | if opts.dims is None: |
---|
| 357 | print errormsg |
---|
| 358 | print ' ' + main + ': No list of dimensions are provided!!' |
---|
| 359 | print ' a ',' list of values X@[dimxsim]@[dimxobs],...,T@[dimtsim]@[dimtobs]'+\ |
---|
| 360 | ' is needed' |
---|
| 361 | quit(-1) |
---|
| 362 | else: |
---|
| 363 | print main +': couple of dimensions _______' |
---|
| 364 | dims = {} |
---|
| 365 | ds = opts.dims.split(',') |
---|
| 366 | for d in ds: |
---|
| 367 | dsecs = d.split('@') |
---|
| 368 | if len(dsecs) != 3: |
---|
| 369 | print errormsg |
---|
| 370 | print ' ' + main + ': wrong number of values in:',dsecs,' 3 are needed !!' |
---|
| 371 | print ' [DIM]@[dimnsim]@[dimnobs]' |
---|
| 372 | quit(-1) |
---|
| 373 | dims[dsecs[0]] = [dsecs[1], dsecs[2]] |
---|
| 374 | print dsecs[0],':',dsecs[1],',',dsecs[2] |
---|
| 375 | |
---|
| 376 | |
---|
| 377 | if opts.vardims is None: |
---|
| 378 | print errormsg |
---|
| 379 | print ' ' + main + ': No list of variables with dimension values are provided!!' |
---|
| 380 | print ' a ',' list of values X@[vardimxsim]@[vardimxobs],...,T@' + \ |
---|
| 381 | '[vardimtsim]@[vardimtobs] is needed' |
---|
| 382 | quit(-1) |
---|
| 383 | else: |
---|
| 384 | print main +': couple of variable dimensions _______' |
---|
| 385 | vardims = {} |
---|
| 386 | ds = opts.vardims.split(',') |
---|
| 387 | for d in ds: |
---|
| 388 | dsecs = d.split('@') |
---|
| 389 | if len(dsecs) != 3: |
---|
| 390 | print errormsg |
---|
| 391 | print ' ' + main + ': wrong number of values in:',dsecs,' 3 are needed !!' |
---|
| 392 | print ' [DIM]@[vardimnsim]@[vardimnobs]' |
---|
| 393 | quit(-1) |
---|
| 394 | vardims[dsecs[0]] = [dsecs[1], dsecs[2]] |
---|
| 395 | print dsecs[0],':',dsecs[1],',',dsecs[2] |
---|
| 396 | |
---|
| 397 | if opts.obskind is None: |
---|
| 398 | print errormsg |
---|
| 399 | print ' ' + main + ': No kind of observations provided !!' |
---|
| 400 | quit(-1) |
---|
| 401 | else: |
---|
| 402 | obskind = opts.obskind |
---|
| 403 | if obskind == 'single-station': |
---|
| 404 | if opts.stloc is None: |
---|
| 405 | print errormsg |
---|
| 406 | print ' ' + main + ': No station location provided !!' |
---|
| 407 | quit(-1) |
---|
| 408 | else: |
---|
| 409 | stationdesc = [np.float(opts.stloc.split(',')[0]), \ |
---|
| 410 | np.float(opts.stloc.split(',')[1]), np.float(opts.stloc.split(',')[2])] |
---|
| 411 | |
---|
| 412 | if opts.fobs is None: |
---|
| 413 | print errormsg |
---|
| 414 | print ' ' + main + ': No observations file is provided!!' |
---|
| 415 | quit(-1) |
---|
| 416 | else: |
---|
| 417 | if not os.path.isfile(opts.fobs): |
---|
| 418 | print errormsg |
---|
| 419 | print ' ' + main + ": observations file '" + opts.fobs + "' does not exist !!" |
---|
| 420 | quit(-1) |
---|
| 421 | |
---|
| 422 | if opts.fsim is None: |
---|
| 423 | print errormsg |
---|
| 424 | print ' ' + main + ': No simulation file is provided!!' |
---|
| 425 | quit(-1) |
---|
| 426 | else: |
---|
| 427 | if not os.path.isfile(opts.fsim): |
---|
| 428 | print errormsg |
---|
| 429 | print ' ' + main + ": simulation file '" + opts.fsim + "' does not exist !!" |
---|
| 430 | quit(-1) |
---|
| 431 | |
---|
| 432 | if opts.vars is None: |
---|
| 433 | print errormsg |
---|
| 434 | print ' ' + main + ': No list of couples of variables is provided!!' |
---|
| 435 | print ' a ',' list of values [varsim]@[varobs],... is needed' |
---|
| 436 | quit(-1) |
---|
| 437 | else: |
---|
| 438 | valvars = [] |
---|
| 439 | vs = opts.dims.split(',') |
---|
| 440 | for v in vs: |
---|
| 441 | vsecs = v.split('@') |
---|
| 442 | if len(dsecs) < 2: |
---|
| 443 | print errormsg |
---|
| 444 | print ' ' + main + ': wrong number of values in:',vsecs, \ |
---|
| 445 | ' at least 2 are needed !!' |
---|
| 446 | print ' [varsim]@[varobs]@[[oper][val]]' |
---|
| 447 | quit(-1) |
---|
| 448 | valvars.append(vsecs) |
---|
| 449 | |
---|
| 450 | # Openning observations trajectory |
---|
| 451 | ## |
---|
| 452 | oobs = NetCDFFile(opts.fobs, 'r') |
---|
| 453 | |
---|
| 454 | valdimobs = {} |
---|
| 455 | for dn in dims: |
---|
| 456 | print dn,':',dims[dn] |
---|
| 457 | if dims[dn][1] != 'None': |
---|
| 458 | if not oobs.dimensions.has_key(dims[dn][1]): |
---|
| 459 | print errormsg |
---|
| 460 | print ' ' + main + ": observations file does not have dimension '" + \ |
---|
| 461 | dims[dn][1] + "' !!" |
---|
| 462 | quit(-1) |
---|
| 463 | if vardims[dn][1] != 'None': |
---|
| 464 | if not oobs.variables.has_key(vardims[dn][1]): |
---|
| 465 | print errormsg |
---|
| 466 | print ' ' + main + ": observations file does not have varibale " + \ |
---|
| 467 | "dimension '" + vardims[dn][1] + "' !!" |
---|
| 468 | quit(-1) |
---|
| 469 | valdimobs[dn] = oobs.variables[vardims[dn][1]][:] |
---|
| 470 | else: |
---|
| 471 | if dn == 'X': |
---|
| 472 | valdimobs[dn] = stationdesc[0] |
---|
| 473 | elif dn == 'Y': |
---|
| 474 | valdimobs[dn] = stationdesc[1] |
---|
| 475 | elif dn == 'Z': |
---|
| 476 | valdimobs[dn] = stationdesc[2] |
---|
| 477 | |
---|
| 478 | osim = NetCDFFile(opts.fsim, 'r') |
---|
| 479 | |
---|
| 480 | valdimsim = {} |
---|
| 481 | for dn in dims: |
---|
| 482 | if not osim.dimensions.has_key(dims[dn][0]): |
---|
| 483 | print errormsg |
---|
| 484 | print ' ' + main + ": simulation file does not have dimension '" + \ |
---|
| 485 | dims[dn][0] + "' !!" |
---|
| 486 | quit(-1) |
---|
| 487 | if not osim.variables.has_key(vardims[dn][0]): |
---|
| 488 | print errormsg |
---|
| 489 | print ' ' + main + ": simulation file does not have varibale dimension '" + \ |
---|
| 490 | vardims[dn][0] + "' !!" |
---|
| 491 | quit(-1) |
---|
| 492 | valdimsim[dn] = osim.variables[vardims[dn][0]][:] |
---|
| 493 | |
---|
| 494 | # General characteristics |
---|
| 495 | dimtobs = len(valdimobs['T']) |
---|
| 496 | dimtsim = len(valdimsim['T']) |
---|
| 497 | |
---|
| 498 | print main +': observational time-steps:',dimtobs,'simulation:',dimtsim |
---|
| 499 | |
---|
| 500 | if obskind == 'multi-points': |
---|
| 501 | trajpos = np.zeros((2,dimt),dtype=int) |
---|
| 502 | for it in dimtobs: |
---|
| 503 | trajpos[:,it] = index_2mat(valdimsim['X'],valdimsim['Y'], \ |
---|
| 504 | [valdimobs['X'][it],valdimobss['Y'][it]]) |
---|
| 505 | |
---|
| 506 | elif obskind == 'single-station': |
---|
| 507 | stsimpos = index_2mat(valdimsim['Y'],valdimsim['X'],[valdimobs['Y'], \ |
---|
| 508 | valdimobs['X']]) |
---|
| 509 | print main + ': station point in simulation:', stsimpos |
---|
| 510 | print ' station position:',valdimobs['X'],',',valdimobs['Y'] |
---|
| 511 | print ' simulation coord.:',valdimsim['X'][tuple(stsimpos)],',', \ |
---|
| 512 | valdimsim['Y'][tuple(stsimpos)] |
---|
| 513 | elif obskind == 'trajectory': |
---|
| 514 | if dims.has_key('Z'): |
---|
| 515 | trajpos = np.zeros((3,dimt),dtype=int) |
---|
| 516 | for it in dimtobs: |
---|
| 517 | trajpos[0:1,it] = index_2mat(valdimsim['X'],valdimsim['Y'], \ |
---|
| 518 | [valdimobs['X'][it],valdimobss['Y'][it]]) |
---|
| 519 | trajpos[2,it] = index_mat(valdimsim['Z'],valdimobs['Z'][it]) |
---|
| 520 | else: |
---|
| 521 | trajpos = np.zeros((2,dimt),dtype=int) |
---|
| 522 | for it in dimtobs: |
---|
| 523 | trajpos[:,it] = index_2mat(valdimsim['X'],valdimsim['Y'], \ |
---|
| 524 | [valdimobs['X'][it],valdimobss['Y'][it]]) |
---|
| 525 | |
---|
| 526 | # Getting times |
---|
| 527 | tobj = oobs.variables[vardims['T'][1]] |
---|
| 528 | obstunits = tobj.getncattr('units') |
---|
| 529 | tobj = osim.variables[vardims['T'][0]] |
---|
| 530 | simtunits = tobj.getncattr('units') |
---|
| 531 | |
---|
| 532 | simobstimes = coincident_CFtimes(valdimsim['T'], obstunits, simtunits) |
---|
| 533 | |
---|
| 534 | print 'Lluis:',simobstimes |
---|
| 535 | |
---|