← Back to branch summary

~javier-lopez/ubuntu/quantal/cdo/sru-1023329

« back to all changes in this revision

Viewing changes to src/griddes.c

  • Committer: Bazaar Package Importer
  • Author(s): Alastair McKinstry
  • Date: 2010-09-22 15:58:09 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20100922155809-u1d3vlmlqj02uxjt
Tags: 1.4.6.dfsg.1-1
New upstream release. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/griddes.c
29
29
#include <ctype.h>
30
30
#include <math.h>
31
31
 
32
 
#include "cdi.h"
 
32
#include <cdi.h>
33
33
#include "cdo.h"
34
34
#include "cdo_int.h"
35
35
#include "grid.h"
58
58
 
59
59
void gridInit(grid_t *grid)
60
60
{
 
61
  grid->mask          = NULL;
61
62
  grid->xvals         = NULL;
62
63
  grid->yvals         = NULL;
63
64
  grid->xbounds       = NULL;
162
163
 
163
164
int gridDefine(grid_t grid)
164
165
{
165
 
  static char func[] = "gridDefine";
 
166
  static const char *func = "gridDefine";
166
167
  int gridID = UNDEFID;
167
168
  int i;
168
169
 
270
271
            gridDefXpole(gridID, grid.xpole);
271
272
            gridDefYpole(gridID, grid.ypole);
272
273
          }
 
274
 
 
275
        if ( grid.mask )
 
276
          {
 
277
            gridDefMask(gridID, grid.mask);
 
278
            free(grid.mask);
 
279
          }
 
280
 
273
281
        break;
274
282
      }
275
283
    case GRID_CURVILINEAR:
323
331
            free(grid.ybounds);
324
332
          }
325
333
 
 
334
        if ( grid.mask )
 
335
          {
 
336
            gridDefMask(gridID, grid.mask);
 
337
            free(grid.mask);
 
338
          }
 
339
 
326
340
        break;
327
341
      }
328
342
    case GRID_LCC:
350
364
        gridDefLCC(gridID, grid.originLon, grid.originLat, grid.lonParY,
351
365
                   grid.lat1, grid.lat2, grid.xinc, grid.yinc, grid.projflag, grid.scanflag);
352
366
 
 
367
        if ( grid.mask )
 
368
          {
 
369
            gridDefMask(gridID, grid.mask);
 
370
            free(grid.mask);
 
371
          }
 
372
 
353
373
        break;
354
374
      }
355
375
    case GRID_LCC2:
399
419
 
400
420
        gridDefLcc2(gridID, grid.a, grid.lon_0, grid.lat_0, grid.lat_1, grid.lat_2);
401
421
 
 
422
        if ( grid.mask )
 
423
          {
 
424
            gridDefMask(gridID, grid.mask);
 
425
            free(grid.mask);
 
426
          }
 
427
 
402
428
        break;
403
429
      }
404
430
    case GRID_SPECTRAL:
415
441
        gridDefTrunc(gridID, grid.ntr);
416
442
 
417
443
        gridDefComplexPacking(gridID, grid.lcomplex);
418
 
        
 
444
 
419
445
        break;
420
446
      }
421
447
    case GRID_GME:
422
448
      {
423
 
        if ( grid.nd == 0 ) Error(func, "nd undefined!");
424
 
        if ( grid.ni == 0 ) Error(func, "ni undefined!");
 
449
        if ( grid.nd   == 0 ) Error(func, "nd undefined!");
 
450
        if ( grid.ni   == 0 ) Error(func, "ni undefined!");
425
451
        if ( grid.size == 0 ) Error(func, "size undefined!");
426
452
 
427
453
        gridID = gridCreate(grid.type, grid.size);
433
459
        gridDefGMEni2(gridID, grid.ni2);
434
460
        gridDefGMEni3(gridID, grid.ni3);
435
461
        
 
462
        if ( grid.mask )
 
463
          {
 
464
            gridDefMask(gridID, grid.mask);
 
465
            free(grid.mask);
 
466
          }
 
467
 
436
468
        break;
437
469
      }
438
470
    default:
454
486
  return (gridID);
455
487
}
456
488
 
457
 
static char *skipSeparator(char *pline)
 
489
static
 
490
char *skipSeparator(char *pline)
458
491
{
459
492
  while ( isspace((int) *pline) ) pline++;
460
493
  if ( *pline == '=' || *pline == ':' ) pline++;
463
496
  return (pline);
464
497
}
465
498
 
 
499
 
466
500
void fnmexp2(char *out, char *in1, const char *in2)
467
501
{
468
502
  const char *pos, *ch;
522
556
/*
523
557
double *readfield(grid_t *grid, int record, char *format, char *filename)
524
558
{
525
 
  static char func[] = "readfield";
 
559
  static const char *func = "readfield";
526
560
  int fileID, rxysize, ierr, irec;
527
561
  double *vals;
528
562
 
558
592
/*
559
593
double *readfield4(grid_t *grid, int record, char *format, char *filename)
560
594
{
561
 
  static char func[] = "readfield4";
 
595
  static const char *func = "readfield4";
562
596
  int fileID, rxysize, ierr, irec;
563
597
  double *vals;
564
598
 
609
643
 
610
644
int gridFromFile(FILE *gfp, const char *dname)
611
645
{
612
 
  static char func[] = "gridFromFile";
 
646
  static const char *func = "gridFromFile";
613
647
  char line[MAX_LINE_LEN], *pline;
614
648
  int gridID = -1;
615
649
  int size;
893
927
              grid.xvals[i] = flon;
894
928
            }
895
929
        }
 
930
      else if ( cmpstr(pline, "mask", len)  == 0 )
 
931
        {
 
932
          int i = 0;
 
933
          long lval;
 
934
          char *endptr;
 
935
 
 
936
          size = grid.size;
 
937
 
 
938
          if ( size > 0 )
 
939
            {
 
940
              long count = 0;
 
941
              pline = skipSeparator(pline + len);
 
942
              grid.mask = (int *) malloc(size*sizeof(int));
 
943
 
 
944
              for ( i = 0; i < size; i++ )
 
945
                {
 
946
                  endptr = pline;
 
947
                  lval = strtol(pline, &endptr, 10);
 
948
                  if ( pline == endptr )
 
949
                    {
 
950
                      if ( ! readline(gfp, line, MAX_LINE_LEN) )
 
951
                        {
 
952
                          Warning(func, "Incomplete command: >mask<");
 
953
                          break;
 
954
                        }
 
955
                      pline = line;
 
956
                      lval = strtol(pline, &endptr, 10);
 
957
                    }
 
958
                  grid.mask[i] = (int)lval;
 
959
                  if ( grid.mask[i] == 1 ) count++;
 
960
                  pline = endptr;
 
961
                }
 
962
 
 
963
              if ( count == size )
 
964
                {
 
965
                  free(grid.mask);
 
966
                  grid.mask = NULL;
 
967
                }
 
968
            }
 
969
          else
 
970
            Warning(func, "gridsize undefined!");
 
971
        }
896
972
      else if ( cmpstr(pline, "xvals", len)  == 0 )
897
973
        {
898
974
          int i = 0;
1137
1213
 
1138
1214
int gridFromPingo(FILE *gfp, const char *dname)
1139
1215
{
1140
 
  static char func[] = "gridFromPingo";
 
1216
  static const char *func = "gridFromPingo";
1141
1217
  int gridID = -1;
1142
1218
  int i;
1143
1219
  int nlon, nlat;
1272
1348
 
1273
1349
int ntr2nlat(int ntr)
1274
1350
{
1275
 
  static char func[] = "ntr2nlat";
 
1351
  static const char *func = "ntr2nlat";
1276
1352
  int nlat, nlat2;
1277
1353
 
1278
1354
  nlat = NINT((ntr*3.+1.)/2.);
1292
1368
 
1293
1369
int ntr2nlat_linear(int ntr)
1294
1370
{
1295
 
  static char func[] = "ntr2nlat_linear";
 
1371
  static const char *func = "ntr2nlat_linear";
1296
1372
  int nlat, nlat2;
1297
1373
 
1298
1374
  nlat = NINT((ntr*2.+1.)/2.);
1345
1421
 
1346
1422
void gen_grid_lonlat(grid_t *grid, const char *pline, double inc, double lon1, double lon2, double lat1, double lat2)
1347
1423
{
1348
 
  static char func[] = "gen_grid_lonlat";
 
1424
  static const char *func = "gen_grid_lonlat";
1349
1425
  int nlon, nlat, i;
1350
1426
 
1351
1427
  grid->type = GRID_LONLAT;
1373
1449
 
1374
1450
int gridFromName(const char *gridname)
1375
1451
{
1376
 
  static char func[] = "gridFromName";
 
1452
  static const char *func = "gridFromName";
1377
1453
  const char *pline;
1378
1454
  int gridID = UNDEFID;
1379
1455
  grid_t grid;
1391
1467
          if      ( cmpstr(pline, "grid", len) == 0 ) grid.type = GRID_GAUSSIAN;
1392
1468
          else if ( cmpstr(pline, "zon",  len) == 0 ) grid.type = GRID_GAUSSIAN;
1393
1469
          else if ( cmpstr(pline, "spec", len) == 0 ) grid.type = GRID_SPECTRAL;
 
1470
          else                                        grid.type = GRID_SPECTRAL;
1394
1471
      
1395
 
          grid.ysize = ntr2nlat_linear(grid.ntr);
1396
 
          if ( cmpstr(pline, "zon",  len) == 0 )
1397
 
            grid.xsize = 1;
1398
 
          else
1399
 
            grid.xsize = compNlon(grid.ysize);
1400
 
 
1401
1472
          if ( grid.type == GRID_GAUSSIAN )
1402
1473
            {
 
1474
              grid.ysize = ntr2nlat_linear(grid.ntr);
 
1475
              if ( cmpstr(pline, "zon",  len) == 0 )
 
1476
                grid.xsize = 1;
 
1477
              else
 
1478
                grid.xsize = compNlon(grid.ysize);
 
1479
 
1403
1480
              grid.def_xfirst = TRUE;
1404
1481
              grid.def_yfirst = TRUE;         
1405
1482
            }
1415
1492
          if      ( cmpstr(pline, "grid", len) == 0 ) grid.type = GRID_GAUSSIAN;
1416
1493
          else if ( cmpstr(pline, "zon",  len) == 0 ) grid.type = GRID_GAUSSIAN;
1417
1494
          else if ( cmpstr(pline, "spec", len) == 0 ) grid.type = GRID_SPECTRAL;
 
1495
          else                                        grid.type = GRID_SPECTRAL;
1418
1496
      
1419
 
          grid.ysize = ntr2nlat(grid.ntr);
1420
 
          if ( cmpstr(pline, "zon",  len) == 0 )
1421
 
            grid.xsize = 1;
1422
 
          else
1423
 
            grid.xsize = compNlon(grid.ysize);
1424
 
 
1425
1497
          if ( grid.type == GRID_GAUSSIAN )
1426
1498
            {
 
1499
              grid.ysize = ntr2nlat(grid.ntr);
 
1500
              if ( cmpstr(pline, "zon",  len) == 0 )
 
1501
                grid.xsize = 1;
 
1502
              else
 
1503
                grid.xsize = compNlon(grid.ysize);
 
1504
 
1427
1505
              grid.def_xfirst = TRUE;
1428
1506
              grid.def_yfirst = TRUE;         
1429
1507
            }
1493
1571
          grid.size = (grid.ni+1)*(grid.ni+1)*10;
1494
1572
        }
1495
1573
    }
 
1574
  else if ( gridname[0] == 'n' ) /* n<N> */
 
1575
    {
 
1576
      pline = &gridname[1];
 
1577
      if ( isdigit((int) *pline) )
 
1578
        {
 
1579
          int n;
 
1580
          n = atoi(pline);
 
1581
          while ( isdigit((int) *pline) ) pline++;
 
1582
 
 
1583
          grid.type = GRID_GAUSSIAN;
 
1584
          grid.ysize = n*2;
 
1585
 
 
1586
          if ( cmpstr(pline, "zon",  len) == 0 )
 
1587
            grid.xsize = 1;
 
1588
          else
 
1589
            grid.xsize = compNlon(grid.ysize);
 
1590
 
 
1591
          grid.def_xfirst = TRUE;
 
1592
          grid.def_yfirst = TRUE;             
 
1593
        }
 
1594
    }
1496
1595
  else if ( gridname[0] == 'g' && isdigit(gridname[1])) /* g<LON>x<LAT> or g<SIZE> */
1497
1596
    {
1498
1597
      pline = &gridname[1];
1553
1652
 
1554
1653
int cdoDefineGrid(const char *gridfile)
1555
1654
{
1556
 
  static char func[] = "cdoDefineGrid";
 
1655
  static const char *func = "cdoDefineGrid";
1557
1656
  FILE *gfp;
1558
1657
  char buffer[4];
1559
1658
  int gridID = -1;