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

« back to all changes in this revision

Viewing changes to libcdi/src/vlist_var.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.

files added:
cdo.settings.in

config/compile

config/ltmain.sh

libcdi

libcdi/AUTHORS

libcdi/COPYING

libcdi/ChangeLog

libcdi/INSTALL

libcdi/Makefile.am

libcdi/Makefile.in

libcdi/NEWS

libcdi/README

libcdi/acinclude.m4

libcdi/aclocal.m4

libcdi/app

libcdi/app/Makefile.am

libcdi/app/Makefile.in

libcdi/app/cdi.c

libcdi/app/createtable.c

libcdi/app/printinfo.h

libcdi/cdi.settings.in

libcdi/config

libcdi/config/compile

libcdi/config/config.guess

libcdi/config/config.sub

libcdi/config/default

libcdi/config/depcomp

libcdi/config/install-sh

libcdi/config/ltmain.sh

libcdi/config/missing

libcdi/config/mkinstalldirs

libcdi/configure

libcdi/configure.ac

libcdi/doc

libcdi/examples

libcdi/examples/Makefile.am

libcdi/examples/Makefile.in

libcdi/examples/cdi_copy.c

libcdi/examples/cdi_read.c

libcdi/examples/cdi_read_f2003.f90

libcdi/examples/cdi_write.c

libcdi/examples/cdi_write_f2003.f90

libcdi/interfaces

libcdi/interfaces/CdiInfo.cpp

libcdi/interfaces/Makefile.am

libcdi/interfaces/Makefile.in

libcdi/interfaces/cdi.cpp

libcdi/interfaces/cdi.hpp

libcdi/interfaces/cdilib.i

libcdi/interfaces/cdiobj.i

libcdi/interfaces/python

libcdi/interfaces/python/cdilib_wrap.c

libcdi/interfaces/python/cdiobj_wrap.cpp

libcdi/interfaces/python/testLib.py

libcdi/interfaces/python/testObj.py

libcdi/interfaces/ruby

libcdi/interfaces/ruby/cdilib_wrap.c

libcdi/interfaces/ruby/cdiobj_wrap.cpp

libcdi/interfaces/ruby/testLib.rb

libcdi/interfaces/ruby/testObj.rb

libcdi/m4

libcdi/m4/acx_options.m4

libcdi/m4/acx_sl_mod_suffix.m4

libcdi/m4/libtool.m4

libcdi/m4/ltoptions.m4

libcdi/m4/ltsugar.m4

libcdi/m4/ltversion.m4

libcdi/m4/lt~obsolete.m4

libcdi/src

libcdi/src/Makefile.am

libcdi/src/Makefile.in

libcdi/src/basetime.c

libcdi/src/basetime.h

libcdi/src/binary.c

libcdi/src/binary.h

libcdi/src/calendar.c

libcdi/src/calendar.h

libcdi/src/cdf.c

libcdi/src/cdf.h

libcdi/src/cdf_int.c

libcdi/src/cdf_int.h

libcdi/src/cdi.h

libcdi/src/cdi.inc

libcdi/src/cdiFortran.c

libcdi/src/cdi_error.c

libcdi/src/cdi_limits.h

libcdi/src/cdi_util.c

libcdi/src/cfortran.doc

libcdi/src/cfortran.h

libcdi/src/cgribex.h

libcdi/src/cgribexlib.c

libcdi/src/config.h.in

libcdi/src/datetime.h

libcdi/src/dmemory.c

libcdi/src/dmemory.h

libcdi/src/dtypes.h

libcdi/src/error.c

libcdi/src/error.h

libcdi/src/extra.h

libcdi/src/extralib.c

libcdi/src/file.c

libcdi/src/file.h

libcdi/src/gaussgrid.c

libcdi/src/gaussgrid.h

libcdi/src/gribapi.c

libcdi/src/gribapi.h

libcdi/src/grid.c

libcdi/src/grid.h

libcdi/src/ieg.h

libcdi/src/ieglib.c

libcdi/src/institution.c

libcdi/src/make_cdilib

libcdi/src/mo_cdi.f90

libcdi/src/model.c

libcdi/src/service.h

libcdi/src/servicelib.c

libcdi/src/stream.c

libcdi/src/stream_cdf.c

libcdi/src/stream_cdf.h

libcdi/src/stream_cgribex.c

libcdi/src/stream_cgribex.h

libcdi/src/stream_ext.c

libcdi/src/stream_ext.h

libcdi/src/stream_grb.c

libcdi/src/stream_grb.h

libcdi/src/stream_gribapi.c

libcdi/src/stream_gribapi.h

libcdi/src/stream_history.c

libcdi/src/stream_ieg.c

libcdi/src/stream_ieg.h

libcdi/src/stream_int.c

libcdi/src/stream_int.h

libcdi/src/stream_record.c

libcdi/src/stream_srv.c

libcdi/src/stream_srv.h

libcdi/src/stream_var.c

libcdi/src/swap.c

libcdi/src/swap.h

libcdi/src/table.c

libcdi/src/table.h

libcdi/src/tablepar.h

libcdi/src/taxis.c

libcdi/src/taxis.h

libcdi/src/timebase.c

libcdi/src/timebase.h

libcdi/src/tsteps.c

libcdi/src/util.c

libcdi/src/varscan.c

libcdi/src/varscan.h

libcdi/src/version.c

libcdi/src/vlist.c

libcdi/src/vlist.h

libcdi/src/vlist_att.c

libcdi/src/vlist_var.c

libcdi/src/zaxis.c

libcdi/tests

libcdi/tests/Makefile.am

libcdi/tests/Makefile.in

libcdi/tests/test_grib.c

libcdi/tests/test_grib.sh

m4/acx_options.m4

m4/libtool.m4

m4/ltoptions.m4

m4/ltsugar.m4

m4/ltversion.m4

m4/lt~obsolete.m4

src/IFS2ICON.c

src/Ydayarith.c

files removed:
m4/ac_fc_freeform.m4

m4/ac_lang_program_fortran.m4

m4/acx_c_package.m4

m4/acx_fc_library_ldflags.m4

m4/acx_lang_c_check_include.m4

m4/acx_lang_check_include.m4

m4/acx_lang_fortran_check_include.m4

m4/acx_lang_package.m4

m4/acx_m4_generate_subsets.m4

m4/acx_option_search_libs.m4

m4/asx_tr_arg.m4

m4/asx_unset.m4

src/cdi.h

src/cdilib.c

files modified:
ChangeLog

Makefile.am

Makefile.in

NEWS

OPERATORS

acinclude.m4

aclocal.m4

cdo.spec

config/config.guess

config/config.sub

config/default

config/depcomp

config/install-sh

config/missing

configure

configure.ac

contrib/Makefile.am

contrib/Makefile.in

contrib/makecompl.rb

debian/changelog

debian/control

src/Arith.c

src/Arithc.c

src/Arithdays.c

src/Arithlat.c

src/CDItest.c

src/Cat.c

src/Change.c

src/Change_e5slm.c

src/Cloudlayer.c

src/Command.c

src/Comp.c

src/Compc.c

src/Complextorect.c

src/Cond.c

src/Cond2.c

src/Condc.c

src/Consecstat.c

src/Copy.c

src/Deltime.c

src/Detrend.c

src/Diff.c

src/EOFs.c

src/EcaIndices.c

src/Echam5ini.c

src/Enlarge.c

src/Enlargegrid.c

src/Ensstat.c

src/Eofcoeff.c

src/Exprf.c

src/Filedes.c

src/Fillmiss.c

src/Filter.c

src/Fldrms.c

src/Fldstat.c

src/Fldstat2.c

src/Fourier.c

src/Gather.c

src/Gengrid.c

src/Gradsdes.c

src/Gridboxstat.c

src/Gridcell.c

src/Harmonic.c

src/Hi.c

src/Histogram.c

src/Importamsr.c

src/Importbinary.c

src/Importcmsaf.c

src/Importobs.c

src/Info.c

src/Input.c

src/Intgrid.c

src/Intgridtraj.c

src/Intlevel.c

src/Intntime.c

src/Inttime.c

src/Intyear.c

src/Invert.c

src/Invertlev.c

src/Log.c

src/Makefile.am

src/Makefile.in

src/Maskbox.c

src/Mastrfu.c

src/Math.c

src/Merge.c

src/Mergegrid.c

src/Mergetime.c

src/Merstat.c

src/Monarith.c

src/Mrotuv.c

src/Mrotuvb.c

src/Ninfo.c

src/Nmltest.c

src/Output.c

src/Outputgmt.c

src/Pinfo.c

src/Pressure.c

src/Regres.c

src/Remap.c

src/Remapeta.c

src/Replace.c

src/Replacevalues.c

src/Rotuv.c

src/Runpctl.c

src/Runstat.c

src/Scatter.c

src/Seascount.c

src/Seaspctl.c

src/Seasstat.c

src/Selbox.c

src/Select.c

src/Seloperator.c

src/Selrec.c

src/Seltime.c

src/Selvar.c

src/Set.c

src/Setbox.c

src/Setgatt.c

src/Setgrid.c

src/Sethalo.c

src/Setmiss.c

src/Setrcaname.c

src/Settime.c

src/Setzaxis.c

src/Showinfo.c

src/Sinfo.c

src/Smooth9.c

src/Sort.c

src/Sorttimestamp.c

src/Specinfo.c

src/Spectral.c

src/Spectrum.c

src/Split.c

src/Splitrec.c

src/Splitsel.c

src/Splittime.c

src/Splityear.c

src/Subtrend.c

src/Templates.c

src/Test.c

src/Tests.c

src/Timcount.c

src/Timpctl.c

src/Timselpctl.c

src/Timselstat.c

src/Timsort.c

src/Timstat.c

src/Timstat2.c

src/Timstat3.c

src/Tinfo.c

src/Tocomplex.c

src/Transpose.c

src/Trend.c

src/Trms.c

src/Tstepcount.c

src/Vardup.c

src/Vargen.c

src/Varrms.c

src/Vertint.c

src/Vertstat.c

src/Vertwind.c

src/Wct.c

src/Wind.c

src/Writegrid.c

src/Writerandom.c

src/Ydaypctl.c

src/Ydaystat.c

src/Ydrunpctl.c

src/Ydrunstat.c

src/Yhourstat.c

src/Ymonarith.c

src/Ymonpctl.c

src/Ymonstat.c

src/Yseaspctl.c

src/Yseasstat.c

src/Zonstat.c

src/cdo.c

src/cdo.h

src/cdo_int.h

src/cdo_vlist.c

src/cdotest.c

src/color.c

src/config.h.in

src/ecacore.c

src/ecautil.c

src/ecautil.h

src/exception.c

src/expr.c

src/field.c

src/field.h

src/field2.c

src/fieldc.c

src/fieldmem.c

src/fieldmer.c

src/fieldzon.c

src/fouriertrans.c

src/functs.h

src/gradsdeslib.c

src/grid.c

src/grid.h

src/grid_gme.c

src/grid_lcc.c

src/griddes.c

src/griddes.h

src/griddes_h5.c

src/griddes_nc.c

src/hetaeta.c

src/history.c

src/institution.c

src/interpol.c

src/job.c

src/juldate.c

src/list.c

src/modules.c

src/namelist.c

src/namelist.h

src/normal.c

src/operator_help.h

src/percentiles.c

src/percentiles.h

src/pipe.c

src/printinfo.h

src/process.c

src/pstream.c

src/pthread_debug.c

src/remap.h

src/remaplib.c

src/specspace.c

src/statistic.c

src/statistic.h

src/table.c

src/userlog.c

src/util.c

src/util.h

src/zaxis.c

Show diffs side-by-side

added added

removed removed

libcdi/src/vlist_var.c

#if defined (HAVE_CONFIG_H)

# include "config.h"

#endif

#include <limits.h>

#include "dmemory.h"

#include "cdi.h"

#include "stream_int.h"

#include "vlist.h"

static void vlistvarInitEntry(int vlistID, int varID)

{

vlist_t *vlistptr;

vlistptr = vlist_to_pointer(vlistID);

vlistptr->vars[varID].fvarID = varID;

vlistptr->vars[varID].mvarID = varID;

vlistptr->vars[varID].flag = 0;

vlistptr->vars[varID].param = 0;

vlistptr->vars[varID].timeID = CDI_UNDEFID;

vlistptr->vars[varID].datatype = CDI_UNDEFID;

vlistptr->vars[varID].tsteptype = TSTEP_INSTANT;

vlistptr->vars[varID].timave = 0;

vlistptr->vars[varID].timaccu = 0;

vlistptr->vars[varID].gridID = CDI_UNDEFID;

vlistptr->vars[varID].zaxisID = CDI_UNDEFID;

vlistptr->vars[varID].instID = CDI_UNDEFID;

vlistptr->vars[varID].modelID = CDI_UNDEFID;

vlistptr->vars[varID].tableID = CDI_UNDEFID;

vlistptr->vars[varID].missvalused = FALSE;

vlistptr->vars[varID].missval = cdiDefaultMissval;

vlistptr->vars[varID].addoffset = 0.0;

vlistptr->vars[varID].scalefactor = 1.0;

vlistptr->vars[varID].name = NULL;

vlistptr->vars[varID].longname = NULL;

vlistptr->vars[varID].stdname = NULL;

vlistptr->vars[varID].units = NULL;

vlistptr->vars[varID].nlevs = 0;

vlistptr->vars[varID].levinfo = NULL;

vlistptr->vars[varID].ztype = COMPRESS_NONE;

vlistptr->vars[varID].zlevel = 1;

vlistptr->vars[varID].atts.nalloc = MAX_ATTRIBUTES;

vlistptr->vars[varID].atts.nelems = 0;

}

static int vlistvarNewEntry(int vlistID)

{

static const char *func = "vlistvarNewEntry";

int varID = 0;

int vlistvarSize;

var_t *vlistvar;

vlist_t *vlistptr;

vlistptr = vlist_to_pointer(vlistID);

vlistvarSize = vlistptr->varsAllocated;

vlistvar = vlistptr->vars;

Look for a free slot in vlistvar.

(Create the table the first time through).

if ( ! vlistvarSize )

{

int i;

vlistvarSize = 2;

vlistvar = (var_t *) malloc(vlistvarSize*sizeof(var_t));

if ( vlistvar == NULL )

{

Message(func, "vlistvarSize = %d", vlistvarSize);

SysError(func, "Allocation of var_t failed");

}

for ( i = 0; i < vlistvarSize; i++ )

vlistvar[i].isUsed = FALSE;

}

else

{

while ( varID < vlistvarSize )

{

if ( ! vlistvar[varID].isUsed ) break;

varID++;

}

If the table overflows, double its size.

if ( varID == vlistvarSize )

{

int i;

vlistvarSize = 2*vlistvarSize;

vlistvar = (var_t *) realloc(vlistvar, vlistvarSize*sizeof(var_t));

if ( vlistvar == NULL )

{

Message(func, "vlistvarSize = %d", vlistvarSize);

100

SysError(func, "Reallocation of var_t failed");

101

}

102

varID = vlistvarSize/2;

103

104

for ( i = varID; i < vlistvarSize; i++ )

105

vlistvar[i].isUsed = FALSE;

106

}

107

108

vlistptr->varsAllocated = vlistvarSize;

109

vlistptr->vars = vlistvar;

110

111

vlistvarInitEntry(vlistID, varID);

112

113

vlistptr->vars[varID].isUsed = TRUE;

114

115

return (varID);

116

}

117

118

void vlistCheckVarID(const char *func, int vlistID, int varID)

119

{

120

vlist_t *vlistptr;

121

122

vlistptr = vlist_to_pointer(vlistID);

123

124

if ( vlistptr == NULL )

125

Error(func, "vlist undefined!");

126

127

if ( varID < 0 || varID >= vlistptr->nvars )

128

Error(func, "varID %d undefined!", varID);

129

130

if ( ! vlistptr->vars[varID].isUsed )

131

Error(func, "varID %d undefined!", varID);

132

}

133

134

135

136

@Function vlistDefVar

137

@Title Define a Variable

138

139

@Prototype int vlistDefVar(int vlistID, int gridID, int zaxisID, int timeID)

140

@Parameter

141

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

142

@Item gridID Grid ID, from a previous call to @fref{gridCreate}

143

@Item zaxisID Z-axis ID, from a previous call to @fref{zaxisCreate}

144

@Item timeID One of the set of predefined CDI time identifiers.

145

The valid CDI time identifiers are @func{TIME_CONSTANT} and @func{TIME_VARIABLE}.

146

147

@Description

148

The function @func{vlistDefVar} adds a new variable to vlistID.

149

150

@Result

151

@func{vlistDefVar} returns an identifier to the new variable.

152

153

@Example

154

Here is an example using @func{vlistCreate} to create a variable list

155

and add a variable with @func{vlistDefVar}.

156

157

@Source

158

#include "cdi.h"

159

...

160

int vlistID, varID;

161

...

162

vlistID = vlistCreate();

163

varID = vlistDefVar(vlistID, gridID, zaxisID, TIME_VARIABLE);

164

...

165

streamDefVlist(streamID, vlistID);

166

...

167

vlistDestroy(vlistID);

168

...

169

@EndSource

170

@EndFunction

171

172

int vlistDefVar(int vlistID, int gridID, int zaxisID, int timeID)

173

{

174

static const char *func = "vlistDefVar";

175

int varID;

176

int nlevs;

177

int levID;

178

int index;

179

vlist_t *vlistptr;

180

181

vlistptr = vlist_to_pointer(vlistID);

182

183

if ( CDI_Debug )

184

Message(func, "gridID = %d zaxisID = %d timeID = %d", gridID, zaxisID, timeID);

185

186

varID = vlistvarNewEntry(vlistID);

187

188

vlistptr->nvars++;

189

190

vlistptr->vars[varID].gridID = gridID;

191

vlistptr->vars[varID].zaxisID = zaxisID;

192

vlistptr->vars[varID].timeID = timeID;

193

194

if ( timeID != TIME_VARIABLE && timeID != TIME_CONSTANT )

195

{

196

Message(func, "unexpected timeID %d. Set to TIME_VARIABLE", timeID);

197

vlistptr->vars[varID].timeID = TIME_VARIABLE;

198

}

199

200

nlevs = zaxisInqSize(zaxisID);

201

202

vlistptr->vars[varID].levinfo = (levinfo_t *) malloc(nlevs*sizeof(levinfo_t));

203

204

for ( levID = 0; levID < nlevs; levID++ )

205

{

206

vlistptr->vars[varID].levinfo[levID].flag = 0;

207

vlistptr->vars[varID].levinfo[levID].index = -1;

208

vlistptr->vars[varID].levinfo[levID].flevelID = levID;

209

vlistptr->vars[varID].levinfo[levID].mlevelID = levID;

210

}

211

212

vlistptr->vars[varID].nlevs = nlevs;

213

214

for ( index = 0; index < vlistptr->ngrids; index++ )

215

if ( gridID == vlistptr->gridIDs[index] ) break;

216

217

if ( index == vlistptr->ngrids )

218

{

219

if ( vlistptr->ngrids + 1 >= MAX_GRIDS_PS )

220

Error(func, "Maximum of %d grids reached", MAX_GRIDS_PS);

221

222

vlistptr->gridIDs[vlistptr->ngrids] = gridID;

223

vlistptr->ngrids++;

224

}

225

226

for ( index = 0; index < vlistptr->nzaxis; index++ )

227

if ( zaxisID == vlistptr->zaxisIDs[index] ) break;

228

229

if ( index == vlistptr->nzaxis )

230

{

231

if ( vlistptr->nzaxis + 1 >= MAX_ZAXES_PS )

232

Error(func, "Maximum of %d zaxis reached", MAX_ZAXES_PS);

233

234

vlistptr->zaxisIDs[vlistptr->nzaxis] = zaxisID;

235

vlistptr->nzaxis++;

236

}

237

238

vlistptr->vars[varID].param = cdiEncodeParam(-(varID + 1), 255, 255);

239

240

return (varID);

241

}

242

243

244

245

@Function vlistDefVarParam

246

@Title Define the parameter number of a Variable

247

248

@Prototype void vlistDefVarParam(int vlistID, int varID, int param)

249

@Parameter

250

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

251

@Item varID Variable identifier

252

@Item param Parameter number

253

254

@Description

255

The function @func{vlistDefVarParam} defines the parameter number of a variable.

256

257

@EndFunction

258

259

void vlistDefVarParam(int vlistID, int varID, int param)

260

{

261

static const char *func = "vlistDefVarParam";

262

vlist_t *vlistptr;

263

264

vlistptr = vlist_to_pointer(vlistID);

265

266

vlistCheckVarID(func, vlistID, varID);

267

268

vlistptr->vars[varID].param = param;

269

}

270

271

272

273

@Function vlistDefVarCode

274

@Title Define the code number of a Variable

275

276

@Prototype void vlistDefVarCode(int vlistID, int varID, int code)

277

@Parameter

278

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

279

@Item varID Variable identifier

280

@Item code Code number

281

282

@Description

283

The function @func{vlistDefVarCode} defines the code number of a variable.

284

285

@EndFunction

286

287

void vlistDefVarCode(int vlistID, int varID, int code)

288

{

289

static const char *func = "vlistDefVarCode";

290

vlist_t *vlistptr;

291

int param, pnum, pcat, pdis;

292

293

vlistptr = vlist_to_pointer(vlistID);

294

295

vlistCheckVarID(func, vlistID, varID);

296

297

param = vlistptr->vars[varID].param;

298

299

cdiDecodeParam(param, &pnum, &pcat, &pdis);

300

301

vlistptr->vars[varID].param = cdiEncodeParam(code, pcat, pdis);

302

}

303

304

305

void vlistInqVar(int vlistID, int varID, int *gridID, int *zaxisID, int *timeID)

306

{

307

static const char *func = "vlistInqVar";

308

vlist_t *vlistptr;

309

310

vlistptr = vlist_to_pointer(vlistID);

311

312

vlistCheckVarID(func, vlistID, varID);

313

314

*gridID = vlistptr->vars[varID].gridID;

315

*zaxisID = vlistptr->vars[varID].zaxisID;

316

*timeID = vlistptr->vars[varID].timeID;

317

318

return;

319

}

320

321

322

323

@Function vlistInqVarGrid

324

@Title Get the Grid ID of a Variable

325

326

@Prototype int vlistInqVarGrid(int vlistID, int varID)

327

@Parameter

328

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

329

@Item varID Variable identifier

330

331

@Description

332

The function @func{vlistInqVarGrid} returns the grid ID of a variable.

333

334

@Result

335

@func{vlistInqVarGrid} returns the grid ID of the variable.

336

337

@EndFunction

338

339

int vlistInqVarGrid(int vlistID, int varID)

340

{

341

static const char *func = "vlistInqVarGrid";

342

vlist_t *vlistptr;

343

344

vlistptr = vlist_to_pointer(vlistID);

345

346

vlistCheckVarID(func, vlistID, varID);

347

348

return (vlistptr->vars[varID].gridID);

349

}

350

351

352

353

@Function vlistInqVarZaxis

354

@Title Get the Zaxis ID of a Variable

355

356

@Prototype int vlistInqVarZaxis(int vlistID, int varID)

357

@Parameter

358

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

359

@Item varID Variable identifier

360

361

@Description

362

The function @func{vlistInqVarZaxis} returns the zaxis ID of a variable.

363

364

@Result

365

@func{vlistInqVarZaxis} returns the zaxis ID of the variable.

366

367

@EndFunction

368

369

int vlistInqVarZaxis(int vlistID, int varID)

370

{

371

static const char *func = "vlistInqVarZaxis";

372

vlist_t *vlistptr;

373

374

vlistptr = vlist_to_pointer(vlistID);

375

376

vlistCheckVarID(func, vlistID, varID);

377

378

return (vlistptr->vars[varID].zaxisID);

379

}

380

381

int vlistInqVarTime(int vlistID, int varID)

382

{

383

static const char *func = "vlistInqVarTime";

384

vlist_t *vlistptr;

385

386

vlistptr = vlist_to_pointer(vlistID);

387

388

vlistCheckVarID(func, vlistID, varID);

389

390

return (vlistptr->vars[varID].timeID);

391

}

392

393

394

395

@Function vlistInqVarParam

396

@Title Get the parameter number of a Variable

397

398

@Prototype int vlistInqVarParam(int vlistID, int varID)

399

@Parameter

400

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

401

@Item varID Variable identifier

402

403

@Description

404

The function @func{vlistInqVarParam} returns the parameter number of a variable.

405

406

@Result

407

@func{vlistInqVarParam} returns the parameter number of the variable.

408

409

@EndFunction

410

411

int vlistInqVarParam(int vlistID, int varID)

412

{

413

static const char *func = "vlistInqVarParam";

414

vlist_t *vlistptr;

415

int param;

416

417

vlistptr = vlist_to_pointer(vlistID);

418

419

vlistCheckVarID(func, vlistID, varID);

420

421

param = vlistptr->vars[varID].param;

422

423

return (param);

424

}

425

426

427

428

@Function vlistInqVarCode

429

@Title Get the Code number of a Variable

430

431

@Prototype int vlistInqVarCode(int vlistID, int varID)

432

@Parameter

433

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

434

@Item varID Variable identifier

435

436

@Description

437

The function @func{vlistInqVarCode} returns the code number of a variable.

438

439

@Result

440

@func{vlistInqVarCode} returns the code number of the variable.

441

442

@EndFunction

443

444

int vlistInqVarCode(int vlistID, int varID)

445

{

446

static const char *func = "vlistInqVarCode";

447

vlist_t *vlistptr;

448

int param, code;

449

int pdis, pcat, pnum;

450

451

vlistptr = vlist_to_pointer(vlistID);

452

453

vlistCheckVarID(func, vlistID, varID);

454

455

param = vlistptr->vars[varID].param;

456

cdiDecodeParam(param, &pnum, &pcat, &pdis);

457

code = pnum;

458

459

if ( code < 0 && vlistptr->vars[varID].tableID != -1 && vlistptr->vars[varID].name != NULL )

460

{

461

tableInqParCode(vlistptr->vars[varID].tableID, vlistptr->vars[varID].name, &code);

462

}

463

464

return (code);

465

}

466

467

468

char *vlistInqVarNamePtr(int vlistID, int varID)

469

{

470

static const char *func = "vlistInqVarNamePtr";

471

vlist_t *vlistptr;

472

473

vlistptr = vlist_to_pointer(vlistID);

474

475

vlistCheckVarID(func, vlistID, varID);

476

477

return (vlistptr->vars[varID].name);

478

}

479

480

char *vlistInqVarLongnamePtr(int vlistID, int varID)

481

{

482

static const char *func = "vlistInqVarLongnamePtr";

483

vlist_t *vlistptr;

484

485

vlistptr = vlist_to_pointer(vlistID);

486

487

vlistCheckVarID(func, vlistID, varID);

488

489

return (vlistptr->vars[varID].longname);

490

}

491

492

char *vlistInqVarStdnamePtr(int vlistID, int varID)

493

{

494

static const char *func = "vlistInqVarStdnamePtr";

495

vlist_t *vlistptr;

496

497

vlistptr = vlist_to_pointer(vlistID);

498

499

vlistCheckVarID(func, vlistID, varID);

500

501

return (vlistptr->vars[varID].stdname);

502

}

503

504

char *vlistInqVarUnitsPtr(int vlistID, int varID)

505

{

506

static const char *func = "vlistInqVarUnitsPtr";

507

vlist_t *vlistptr;

508

509

vlistptr = vlist_to_pointer(vlistID);

510

511

vlistCheckVarID(func, vlistID, varID);

512

513

return (vlistptr->vars[varID].units);

514

}

515

516

517

518

@Function vlistInqVarName

519

@Title Get the name of a Variable

520

521

@Prototype void vlistInqVarName(int vlistID, int varID, char *name)

522

@Parameter

523

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

524

@Item varID Variable identifier

525

@Item name Variable name

526

527

@Description

528

The function @func{vlistInqVarName} returns the name of a variable.

529

530

@Result

531

@func{vlistInqVarName} returns the name of the variable to the parameter name.

532

533

@EndFunction

534

535

void vlistInqVarName(int vlistID, int varID, char *name)

536

{

537

static const char *func = "vlistInqVarName";

538

int tableID;

539

int param, code;

540

int pdis, pcat, pnum;

541

vlist_t *vlistptr;

542

543

vlistptr = vlist_to_pointer(vlistID);

544

545

vlistCheckVarID(func, vlistID, varID);

546

547

if ( vlistptr->vars[varID].name == NULL )

548

{

549

param = vlistptr->vars[varID].param;

550

cdiDecodeParam(param, &pnum, &pcat, &pdis);

551

code = pnum;

552

tableID = vlistptr->vars[varID].tableID;

553

if ( tableInqParName(tableID, code, name) != 0 )

554

sprintf(name, "var%d", code);

555

}

556

else

557

strcpy(name, vlistptr->vars[varID].name);

558

559

return;

560

}

561

562

563

564

@Function vlistInqVarLongname

565

@Title Get the longname of a Variable

566

567

@Prototype void vlistInqVarLongname(int vlistID, int varID, char *longname)

568

@Parameter

569

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

570

@Item varID Variable identifier

571

@Item longname Variable description

572

573

@Description

574

The function @func{vlistInqVarLongname} returns the longname of a variable.

575

576

@Result

577

@func{vlistInqVaeLongname} returns the longname of the variable to the parameter longname.

578

579

@EndFunction

580

581

void vlistInqVarLongname(int vlistID, int varID, char *longname)

582

{

583

static const char *func = "vlistInqVarLongname";

584

int tableID;

585

int param, code;

586

int pdis, pcat, pnum;

587

vlist_t *vlistptr;

588

589

vlistptr = vlist_to_pointer(vlistID);

590

591

vlistCheckVarID(func, vlistID, varID);

592

593

if ( vlistptr->vars[varID].longname == NULL )

594

{

595

param = vlistptr->vars[varID].param;

596

cdiDecodeParam(param, &pnum, &pcat, &pdis);

597

code = pnum;

598

tableID = vlistptr->vars[varID].tableID;

599

if ( tableInqParLongname(tableID, code, longname) != 0 )

600

longname[0] = '\0';

601

}

602

else

603

strcpy(longname, vlistptr->vars[varID].longname);

604

605

return;

606

}

607

608

609

610

@Function vlistInqVarStdname

611

@Title Get the standard name of a Variable

612

613

@Prototype void vlistInqVarStdname(int vlistID, int varID, char *stdname)

614

@Parameter

615

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

616

@Item varID Variable identifier

617

@Item stdname Variable standard name

618

619

@Description

620

The function @func{vlistInqVarStdname} returns the standard name of a variable.

621

622

@Result

623

@func{vlistInqVarName} returns the standard name of the variable to the parameter stdname.

624

625

@EndFunction

626

627

void vlistInqVarStdname(int vlistID, int varID, char *stdname)

628

{

629

static const char *func = "vlistInqVarStdname";

630

vlist_t *vlistptr;

631

632

vlistptr = vlist_to_pointer(vlistID);

633

634

vlistCheckVarID(func, vlistID, varID);

635

636

if ( vlistptr->vars[varID].stdname == NULL )

637

{

638

stdname[0] = '\0';

639

}

640

else

641

strcpy(stdname, vlistptr->vars[varID].stdname);

642

643

return;

644

}

645

646

647

648

@Function vlistInqVarUnits

649

@Title Get the units of a Variable

650

651

@Prototype void vlistInqVarUnits(int vlistID, int varID, char *units)

652

@Parameter

653

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

654

@Item varID Variable identifier

655

@Item units Variable units

656

657

@Description

658

The function @func{vlistInqVarUnits} returns the units of a variable.

659

660

@Result

661

@func{vlistInqVarUnits} returns the units of the variable to the parameter units.

662

663

@EndFunction

664

665

void vlistInqVarUnits(int vlistID, int varID, char *units)

666

{

667

static const char *func = "vlistInqVarUnits";

668

int tableID;

669

int param, code;

670

int pdis, pcat, pnum;

671

vlist_t *vlistptr;

672

673

vlistptr = vlist_to_pointer(vlistID);

674

675

vlistCheckVarID(func, vlistID, varID);

676

677

if ( vlistptr->vars[varID].units == NULL )

678

{

679

param = vlistptr->vars[varID].param;

680

cdiDecodeParam(param, &pnum, &pcat, &pdis);

681

code = pnum;

682

tableID = vlistptr->vars[varID].tableID;

683

if ( tableInqParUnits(tableID, code, units) != 0 )

684

units[0] = '\0';

685

}

686

else

687

strcpy(units, vlistptr->vars[varID].units);

688

689

return;

690

}

691

692

693

int vlistInqVarID(int vlistID, int code)

694

{

695

int varID;

696

vlist_t *vlistptr;

697

int param, pdis, pcat, pnum;

698

699

vlistptr = vlist_to_pointer(vlistID);

700

701

for ( varID = 0; varID < vlistptr->nvars; varID++ )

702

{

703

param = vlistptr->vars[varID].param;

704

cdiDecodeParam(param, &pnum, &pcat, &pdis);

705

if ( pnum == code ) break;

706

}

707

708

if ( varID == vlistptr->nvars )

709

{

710

711

Warning(func, "varID not found for param %d\n", param);

712

713

varID = CDI_UNDEFID;

714

}

715

716

return (varID);

717

}

718

719

720

int vlistInqVarSize(int vlistID, int varID)

721

{

722

static const char *func = "vlistInqVarSize";

723

int size;

724

int zaxisID, gridID;

725

int nlevs, gridsize;

726

int timeID;

727

vlist_t *vlistptr;

728

729

vlistptr = vlist_to_pointer(vlistID);

730

731

vlistCheckVarID(func, vlistID, varID);

732

733

vlistInqVar(vlistID, varID, &gridID, &zaxisID, &timeID);

734

735

nlevs = zaxisInqSize(zaxisID);

736

737

gridsize = gridInqSize(gridID);

738

739

size = gridsize*nlevs;

740

741

return (size);

742

}

743

744

745

746

@Function vlistInqVarDatatype

747

@Title Get the data type of a Variable

748

749

@Prototype int vlistInqVarDatatype(int vlistID, int varID)

750

@Parameter

751

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

752

@Item varID Variable identifier

753

754

@Description

755

The function @func{vlistInqVarDatatype} returns the data type of a variable.

756

757

@Result

758

@func{vlistInqVarDatatype} returns an identifier to the data type of the variable.

759

The valid CDI data types are @func{DATATYPE_PACK8}, @func{DATATYPE_PACK16}, @func{DATATYPE_PACK24},

760

@func{DATATYPE_FLT32} and @func{DATATYPE_FLT64}.

761

762

@EndFunction

763

764

int vlistInqVarDatatype(int vlistID, int varID)

765

{

766

static const char *func = "vlistInqVarDatatype";

767

vlist_t *vlistptr;

768

769

vlistptr = vlist_to_pointer(vlistID);

770

771

vlistCheckVarID(func, vlistID, varID);

772

773

return (vlistptr->vars[varID].datatype);

774

}

775

776

777

int vlistInqVarNumber(int vlistID, int varID)

778

{

779

static const char *func = "vlistInqVarNumber";

780

vlist_t *vlistptr;

781

int number = CDI_REAL;

782

783

vlistptr = vlist_to_pointer(vlistID);

784

785

vlistCheckVarID(func, vlistID, varID);

786

787

if ( vlistptr->vars[varID].datatype == DATATYPE_CPX32 || vlistptr->vars[varID].datatype == DATATYPE_CPX64 )

788

number = CDI_COMP;

789

790

return (number);

791

}

792

793

794

795

@Function vlistDefVarDatatype

796

@Title Define the data type of a Variable

797

798

@Prototype void vlistDefVarDatatype(int vlistID, int varID, int datatype)

799

@Parameter

800

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

801

@Item varID Variable identifier

802

@Item datatype The data type identifier.

803

The valid CDI data types are @func{DATATYPE_PACK8}, @func{DATATYPE_PACK16},

804

@func{DATATYPE_PACK24}, @func{DATATYPE_FLT32} and @func{DATATYPE_FLT64}.

805

806

807

@Description

808

The function @func{vlistDefVarDatatype} defines the data type of a variable.

809

810

@EndFunction

811

812

void vlistDefVarDatatype(int vlistID, int varID, int datatype)

813

{

814

static const char *func = "vlistDefVarDatatype";

815

vlist_t *vlistptr;

816

817

vlistptr = vlist_to_pointer(vlistID);

818

819

vlistCheckVarID(func, vlistID, varID);

820

821

vlistptr->vars[varID].datatype = datatype;

822

823

if ( vlistptr->vars[varID].missvalused == FALSE )

824

{

825

switch (datatype)

826

{

827

case DATATYPE_INT8:

828

vlistptr->vars[varID].missval = SCHAR_MIN;

829

break;

830

case DATATYPE_UINT8:

831

vlistptr->vars[varID].missval = UCHAR_MAX;

832

break;

833

case DATATYPE_INT16:

834

vlistptr->vars[varID].missval = SHRT_MIN;

835

break;

836

case DATATYPE_UINT16:

837

vlistptr->vars[varID].missval = USHRT_MAX;

838

break;

839

case DATATYPE_INT32:

840

vlistptr->vars[varID].missval = INT_MIN;

841

break;

842

case DATATYPE_UINT32:

843

vlistptr->vars[varID].missval = UINT_MAX;

844

break;

845

}

846

}

847

}

848

849

850

void vlistDefVarInstitut(int vlistID, int varID, int instID)

851

{

852

vlist_t *vlistptr;

853

854

vlistptr = vlist_to_pointer(vlistID);

855

856

vlistptr->vars[varID].instID = instID;

857

}

858

859

860

int vlistInqVarInstitut(int vlistID, int varID)

861

{

862

vlist_t *vlistptr;

863

864

vlistptr = vlist_to_pointer(vlistID);

865

866

return (vlistptr->vars[varID].instID);

867

}

868

869

870

void vlistDefVarModel(int vlistID, int varID, int modelID)

871

{

872

vlist_t *vlistptr;

873

874

vlistptr = vlist_to_pointer(vlistID);

875

876

vlistptr->vars[varID].modelID = modelID;

877

}

878

879

880

int vlistInqVarModel(int vlistID, int varID)

881

{

882

vlist_t *vlistptr;

883

884

vlistptr = vlist_to_pointer(vlistID);

885

886

return (vlistptr->vars[varID].modelID);

887

}

888

889

890

void vlistDefVarTable(int vlistID, int varID, int tableID)

891

{

892

vlist_t *vlistptr;

893

894

vlistptr = vlist_to_pointer(vlistID);

895

896

vlistptr->vars[varID].tableID = tableID;

897

898

{

899

int param, pnum, pcat, pdis;

900

int tablenum;

901

tablenum = tableInqNum(tableID);

902

903

param = vlistptr->vars[varID].param;

904

905

cdiDecodeParam(param, &pnum, &pcat, &pdis);

906

907

vlistptr->vars[varID].param = cdiEncodeParam(pnum, tablenum, pdis);

908

}

909

}

910

911

912

int vlistInqVarTable(int vlistID, int varID)

913

{

914

int tableID;

915

vlist_t *vlistptr;

916

917

vlistptr = vlist_to_pointer(vlistID);

918

919

tableID = vlistptr->vars[varID].tableID;

920

921

return (tableID);

922

}

923

924

925

926

@Function vlistDefVarName

927

@Title Define the name of a Variable

928

929

@Prototype void vlistDefVarName(int vlistID, int varID, const char *name)

930

@Parameter

931

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

932

@Item varID Variable identifier

933

@Item name Name of the variable

934

935

@Description

936

The function @func{vlistDefVarName} defines the name of a variable.

937

938

@EndFunction

939

940

void vlistDefVarName(int vlistID, int varID, const char *name)

941

{

942

static const char *func = "vlistDefVarName";

943

vlist_t *vlistptr;

944

945

vlistptr = vlist_to_pointer(vlistID);

946

947

vlistCheckVarID(func, vlistID, varID);

948

949

if ( vlistptr->vars[varID].name )

950

{

951

free(vlistptr->vars[varID].name);

952

vlistptr->vars[varID].name = 0;

953

}

954

955

if ( name ) vlistptr->vars[varID].name = strdupx(name);

956

}

957

958

959

960

@Function vlistDefVarLongname

961

@Title Define the long name of a Variable

962

963

@Prototype void vlistDefVarLongname(int vlistID, int varID, const char *longname)

964

@Parameter

965

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

966

@Item varID Variable identifier

967

@Item longname Long name of the variable

968

969

@Description

970

The function @func{vlistDefVarLongname} defines the long name of a variable.

971

972

@EndFunction

973

974

void vlistDefVarLongname(int vlistID, int varID, const char *longname)

975

{

976

static const char *func = "vlistDefVarLongname";

977

vlist_t *vlistptr;

978

979

vlistptr = vlist_to_pointer(vlistID);

980

981

vlistCheckVarID(func, vlistID, varID);

982

983

if ( vlistptr->vars[varID].longname )

984

{

985

free(vlistptr->vars[varID].longname);

986

vlistptr->vars[varID].longname = 0;

987

}

988

989

if ( longname ) vlistptr->vars[varID].longname = strdupx(longname);

990

}

991

992

993

994

@Function vlistDefVarStdname

995

@Title Define the standard name of a Variable

996

997

@Prototype void vlistDefVarStdname(int vlistID, int varID, const char *stdname)

998

@Parameter

999

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

1000

@Item varID Variable identifier

1001

@Item stdname Standard name of the variable

1002

1003

@Description

1004

The function @func{vlistDefVarStdname} defines the standard name of a variable.

1005

1006

@EndFunction

1007

1008

void vlistDefVarStdname(int vlistID, int varID, const char *stdname)

1009

{

1010

static const char *func = "vlistDefVarStdname";

1011

vlist_t *vlistptr;

1012

1013

vlistptr = vlist_to_pointer(vlistID);

1014

1015

vlistCheckVarID(func, vlistID, varID);

1016

1017

if ( vlistptr->vars[varID].stdname )

1018

{

1019

free(vlistptr->vars[varID].stdname);

1020

vlistptr->vars[varID].stdname = 0;

1021

}

1022

1023

if ( stdname ) vlistptr->vars[varID].stdname = strdupx(stdname);

1024

}

1025

1026

1027

1028

@Function vlistDefVarUnits

1029

@Title Define the units of a Variable

1030

1031

@Prototype void vlistDefVarUnits(int vlistID, int varID, const char *units)

1032

@Parameter

1033

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

1034

@Item varID Variable identifier

1035

@Item units Units of the variable

1036

1037

@Description

1038

The function @func{vlistDefVarUnits} defines the units of a variable.

1039

1040

@EndFunction

1041

1042

void vlistDefVarUnits(int vlistID, int varID, const char *units)

1043

{

1044

static const char *func = "vlistDefVarUnits";

1045

vlist_t *vlistptr;

1046

1047

vlistptr = vlist_to_pointer(vlistID);

1048

1049

vlistCheckVarID(func, vlistID, varID);

1050

1051

if ( vlistptr->vars[varID].units )

1052

{

1053

free(vlistptr->vars[varID].units);

1054

vlistptr->vars[varID].units = 0;

1055

}

1056

1057

if ( units ) vlistptr->vars[varID].units = strdupx(units);

1058

}

1059

1060

1061

1062

@Function vlistInqVarMissval

1063

@Title Get the missing value of a Variable

1064

1065

@Prototype double vlistInqVarMissval(int vlistID, int varID)

1066

@Parameter

1067

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

1068

@Item varID Variable identifier

1069

1070

@Description

1071

The function @func{vlistInqVarMissval} returns the missing value of a variable.

1072

1073

@Result

1074

@func{vlistInqVarMissval} returns the missing value of the variable.

1075

1076

@EndFunction

1077

1078

double vlistInqVarMissval(int vlistID, int varID)

1079

{

1080

static const char *func = "vlistInqVarMissval";

1081

vlist_t *vlistptr;

1082

1083

vlistptr = vlist_to_pointer(vlistID);

1084

1085

vlistCheckVarID(func, vlistID, varID);

1086

1087

return (vlistptr->vars[varID].missval);

1088

}

1089

1090

1091

double vlistInqVarScalefactor(int vlistID, int varID)

1092

{

1093

static const char *func = "vlistInqVarScalefactor";

1094

vlist_t *vlistptr;

1095

1096

vlistptr = vlist_to_pointer(vlistID);

1097

1098

vlistCheckVarID(func, vlistID, varID);

1099

1100

return (vlistptr->vars[varID].scalefactor);

1101

}

1102

1103

double vlistInqVarAddoffset(int vlistID, int varID)

1104

{

1105

static const char *func = "vlistInqVarAddoffset";

1106

vlist_t *vlistptr;

1107

1108

vlistptr = vlist_to_pointer(vlistID);

1109

1110

vlistCheckVarID(func, vlistID, varID);

1111

1112

return (vlistptr->vars[varID].addoffset);

1113

}

1114

1115

1116

1117

@Function vlistDefVarMissval

1118

@Title Define the missing value of a Variable

1119

1120

@Prototype void vlistDefVarMissval(int vlistID, int varID, double missval)

1121

@Parameter

1122

@Item vlistID Variable list ID, from a previous call to @fref{vlistCreate}

1123

@Item varID Variable identifier

1124

@Item missval Missing value

1125

1126

@Description

1127

The function @func{vlistDefVarMissval} defines the missing value of a variable.

1128

1129

@EndFunction

1130

1131

void vlistDefVarMissval(int vlistID, int varID, double missval)

1132

{

1133

static const char *func = "vlistDefVarMissval";

1134

vlist_t *vlistptr;

1135

1136

vlistptr = vlist_to_pointer(vlistID);

1137

1138

vlistCheckVarID(func, vlistID, varID);

1139

1140

vlistptr->vars[varID].missval = missval;

1141

vlistptr->vars[varID].missvalused = TRUE;

1142

}

1143

1144

1145

void vlistDefVarScalefactor(int vlistID, int varID, double scalefactor)

1146

{

1147

static const char *func = "vlistDefVarScalefactor";

1148

vlist_t *vlistptr;

1149

1150

vlistptr = vlist_to_pointer(vlistID);

1151

1152

vlistCheckVarID(func, vlistID, varID);

1153

1154

vlistptr->vars[varID].scalefactor = scalefactor;

1155

}

1156

1157

1158

void vlistDefVarAddoffset(int vlistID, int varID, double addoffset)

1159

{

1160

static const char *func = "vlistDefVarAddoffset";

1161

vlist_t *vlistptr;

1162

1163

vlistptr = vlist_to_pointer(vlistID);

1164

1165

vlistCheckVarID(func, vlistID, varID);

1166

1167

vlistptr->vars[varID].addoffset = addoffset;

1168

}

1169

1170

1171

void vlistDefVarTsteptype(int vlistID, int varID, int tsteptype)

1172

{

1173

vlist_t *vlistptr;

1174

1175

vlistptr = vlist_to_pointer(vlistID);

1176

1177

vlistptr->vars[varID].tsteptype = tsteptype;

1178

}

1179

1180

1181

int vlistInqVarTsteptype(int vlistID, int varID)

1182

{

1183

vlist_t *vlistptr;

1184

1185

vlistptr = vlist_to_pointer(vlistID);

1186

1187

return (vlistptr->vars[varID].tsteptype);

1188

}

1189

1190

1191

void vlistDefVarTimave(int vlistID, int varID, int timave)

1192

{

1193

vlist_t *vlistptr;

1194

1195

vlistptr = vlist_to_pointer(vlistID);

1196

1197

vlistptr->vars[varID].timave = timave;

1198

}

1199

1200

1201

int vlistInqVarTimave(int vlistID, int varID)

1202

{

1203

vlist_t *vlistptr;

1204

1205

vlistptr = vlist_to_pointer(vlistID);

1206

1207

return (vlistptr->vars[varID].timave);

1208

}

1209

1210

1211

void vlistDefVarTimaccu(int vlistID, int varID, int timaccu)

1212

{

1213

vlist_t *vlistptr;

1214

1215

vlistptr = vlist_to_pointer(vlistID);

1216

1217

vlistptr->vars[varID].timaccu = timaccu;

1218

}

1219

1220

1221

int vlistInqVarTimaccu(int vlistID, int varID)

1222

{

1223

vlist_t *vlistptr;

1224

1225

vlistptr = vlist_to_pointer(vlistID);

1226

1227

return (vlistptr->vars[varID].timaccu);

1228

}

1229

1230

1231

void vlistDestroyVarName(int vlistID, int varID)

1232

{

1233

static const char *func = "vlistDestroyVarName";

1234

vlist_t *vlistptr;

1235

1236

vlistptr = vlist_to_pointer(vlistID);

1237

1238

if ( vlistptr->vars[varID].name )

1239

{

1240

free(vlistptr->vars[varID].name);

1241

vlistptr->vars[varID].name = NULL;

1242

}

1243

}

1244

1245

1246

void vlistDestroyVarLongname(int vlistID, int varID)

1247

{

1248

static const char *func = "vlistDestroyVarLongname";

1249

vlist_t *vlistptr;

1250

1251

vlistptr = vlist_to_pointer(vlistID);

1252

1253

if ( vlistptr->vars[varID].longname )

1254

{

1255

free(vlistptr->vars[varID].longname);

1256

vlistptr->vars[varID].longname = NULL;

1257

}

1258

}

1259

1260

1261

void vlistDestroyVarStdname(int vlistID, int varID)

1262

{

1263

static const char *func = "vlistDestroyVarStdname";

1264

vlist_t *vlistptr;

1265

1266

vlistptr = vlist_to_pointer(vlistID);

1267

1268

if ( vlistptr->vars[varID].stdname )

1269

{

1270

free(vlistptr->vars[varID].stdname);

1271

vlistptr->vars[varID].stdname = NULL;

1272

}

1273

}

1274

1275

1276

void vlistDestroyVarUnits(int vlistID, int varID)

1277

{

1278

static const char *func = "vlistDestroyVarUnits";

1279

vlist_t *vlistptr;

1280

1281

vlistptr = vlist_to_pointer(vlistID);

1282

1283

if ( vlistptr->vars[varID].units )

1284

{

1285

free(vlistptr->vars[varID].units);

1286

vlistptr->vars[varID].units = NULL;

1287

}

1288

}

1289

1290

1291

void vlistDefVarTime(int vlistID, int varID, int timeID)

1292

{

1293

vlist_t *vlistptr;

1294

1295

vlistptr = vlist_to_pointer(vlistID);

1296

1297

vlistptr->vars[varID].timeID = timeID;

1298

}

1299

1300

1301

int vlistInqVarMissvalUsed(int vlistID, int varID)

1302

{

1303

vlist_t *vlistptr;

1304

1305

vlistptr = vlist_to_pointer(vlistID);

1306

1307

return (vlistptr->vars[varID].missvalused);

1308

}

1309

1310

1311

void vlistDefFlag(int vlistID, int varID, int levID, int flag)

1312

{

1313

vlist_t *vlistptr;

1314

1315

vlistptr = vlist_to_pointer(vlistID);

1316

1317

vlistptr->vars[varID].flag = flag;

1318

vlistptr->vars[varID].levinfo[levID].flag = flag;

1319

}

1320

1321

1322

int vlistInqFlag(int vlistID, int varID, int levID)

1323

{

1324

vlist_t *vlistptr;

1325

1326

vlistptr = vlist_to_pointer(vlistID);

1327

1328

return (vlistptr->vars[varID].levinfo[levID].flag);

1329

}

1330

1331

1332

int vlistFindVar(int vlistID, int fvarID)

1333

{

1334

static const char *func = "vlistFindVar";

1335

int varID;

1336

vlist_t *vlistptr;

1337

1338

vlistptr = vlist_to_pointer(vlistID);

1339

1340

for ( varID = 0; varID < vlistptr->nvars; varID++ )

1341

{

1342

if ( vlistptr->vars[varID].fvarID == fvarID ) break;

1343

}

1344

1345

if ( varID == vlistptr->nvars )

1346

{

1347

varID = -1;

1348

Message(func, "varID not found for fvarID %d in vlistID %d!", fvarID, vlistID);

1349

}

1350

1351

return (varID);

1352

}

1353

1354

1355

int vlistFindLevel(int vlistID, int fvarID, int flevelID)

1356

{

1357

static const char *func = "vlistFindLevel";

1358

int varID;

1359

int levelID = -1;

1360

vlist_t *vlistptr;

1361

1362

vlistptr = vlist_to_pointer(vlistID);

1363

1364

varID = vlistFindVar(vlistID, fvarID);

1365

1366

if ( varID != -1 )

1367

{

1368

for ( levelID = 0; levelID < vlistptr->vars[varID].nlevs; levelID++ )

1369

{

1370

if ( vlistptr->vars[varID].levinfo[levelID].flevelID == flevelID ) break;

1371

}

1372

1373

if ( levelID == vlistptr->vars[varID].nlevs )

1374

{

1375

levelID = -1;

1376

Message(func, "levelID not found for fvarID %d and levelID %d in vlistID %d!",

1377

fvarID, flevelID, vlistID);

1378

}

1379

}

1380

1381

return (levelID);

1382

}

1383

1384

1385

int vlistMergedVar(int vlistID, int varID)

1386

{

1387

vlist_t *vlistptr;

1388

1389

vlistptr = vlist_to_pointer(vlistID);

1390

1391

return (vlistptr->vars[varID].mvarID);

1392

}

1393

1394

1395

int vlistMergedLevel(int vlistID, int varID, int levelID)

1396

{

1397

vlist_t *vlistptr;

1398

1399

vlistptr = vlist_to_pointer(vlistID);

1400

1401

return (vlistptr->vars[varID].levinfo[levelID].mlevelID);

1402

}

1403

1404

1405

void vlistDefIndex(int vlistID, int varID, int levelID, int index)

1406

{

1407

vlist_t *vlistptr;

1408

1409

vlistptr = vlist_to_pointer(vlistID);

1410

1411

vlistptr->vars[varID].levinfo[levelID].index = index;

1412

}

1413

1414

1415

int vlistInqIndex(int vlistID, int varID, int levelID)

1416

{

1417

vlist_t *vlistptr;

1418

1419

vlistptr = vlist_to_pointer(vlistID);

1420

1421

return (vlistptr->vars[varID].levinfo[levelID].index);

1422

}

1423

1424

1425

void vlistChangeVarZaxis(int vlistID, int varID, int zaxisID)

1426

{

1427

static const char *func = "vlistChangeVarZaxis";

1428

int nlevs1, nlevs2;

1429

int nvars, index;

1430

vlist_t *vlistptr;

1431

1432

vlistptr = vlist_to_pointer(vlistID);

1433

1434

vlistCheckVarID(func, vlistID, varID);

1435

1436

nlevs1 = zaxisInqSize(vlistptr->vars[varID].zaxisID);

1437

nlevs2 = zaxisInqSize(zaxisID);

1438

1439

if ( nlevs1 != nlevs2 ) Error(func, "Number of levels must not change!");

1440

1441

nvars = vlistptr->nvars;

1442

for ( index = 0; index < nvars; index++ )

1443

if ( index != varID )

1444

if ( vlistptr->vars[index].zaxisID == vlistptr->vars[varID].zaxisID ) break;

1445

1446

if ( index == nvars )

1447

{

1448

for ( index = 0; index < vlistptr->nzaxis; index++ )

1449

if ( vlistptr->zaxisIDs[index] == vlistptr->vars[varID].zaxisID )

1450

vlistptr->zaxisIDs[index] = zaxisID;

1451

}

1452

else

1453

{

1454

for ( index = 0; index < vlistptr->nzaxis; index++ )

1455

if ( vlistptr->zaxisIDs[index] == zaxisID ) break;

1456

1457

if ( index == vlistptr->nzaxis )

1458

{

1459

if ( vlistptr->nzaxis + 1 >= MAX_ZAXES_PS )

1460

Error(func, "Maximum of %d zaxis reached", MAX_ZAXES_PS);

1461

1462

vlistptr->zaxisIDs[vlistptr->nzaxis] = zaxisID;

1463

vlistptr->nzaxis++;

1464

}

1465

}

1466

1467

vlistptr->vars[varID].zaxisID = zaxisID;

1468

}

1469

1470

1471

void vlistChangeVarGrid(int vlistID, int varID, int gridID)

1472

{

1473

static const char *func = "vlistChangeVarGrid";

1474

int nvars, index;

1475

vlist_t *vlistptr;

1476

1477

vlistptr = vlist_to_pointer(vlistID);

1478

1479

vlistCheckVarID(func, vlistID, varID);

1480

1481

nvars = vlistptr->nvars;

1482

for ( index = 0; index < nvars; index++ )

1483

if ( index != varID )

1484

if ( vlistptr->vars[index].gridID == vlistptr->vars[varID].gridID ) break;

1485

1486

if ( index == nvars )

1487

{

1488

for ( index = 0; index < vlistptr->ngrids; index++ )

1489

if ( vlistptr->gridIDs[index] == vlistptr->vars[varID].gridID )

1490

vlistptr->gridIDs[index] = gridID;

1491

}

1492

else

1493

{

1494

for ( index = 0; index < vlistptr->ngrids; index++ )

1495

if ( vlistptr->gridIDs[index] == gridID ) break;

1496

1497

if ( index == vlistptr->ngrids )

1498

{

1499

if ( vlistptr->ngrids + 1 >= MAX_GRIDS_PS )

1500

Error(func, "Maximum of %d grids reached", MAX_GRIDS_PS);

1501

1502

vlistptr->gridIDs[vlistptr->ngrids] = gridID;

1503

vlistptr->ngrids++;

1504

}

1505

}

1506

1507

vlistptr->vars[varID].gridID = gridID;

1508

}

1509

1510

1511

void vlistDefVarZtype(int vlistID, int varID, int ztype)

1512

{

1513

static const char *func = "vlistDefVarZtype";

1514

int nvars, index;

1515

vlist_t *vlistptr;

1516

1517

vlistptr = vlist_to_pointer(vlistID);

1518

1519

vlistCheckVarID(func, vlistID, varID);

1520

1521

vlistptr->vars[varID].ztype = ztype;

1522

}

1523

1524

1525

int vlistInqVarZtype(int vlistID, int varID)

1526

{

1527

static const char *func = "vlistInqVarZtype";

1528

int nvars, index;

1529

vlist_t *vlistptr;

1530

1531

vlistptr = vlist_to_pointer(vlistID);

1532

1533

vlistCheckVarID(func, vlistID, varID);

1534

1535

return (vlistptr->vars[varID].ztype);

1536

}

1537

1538

1539

void vlistDefVarZlevel(int vlistID, int varID, int zlevel)

1540

{

1541

static const char *func = "vlistDefVarZlevel";

1542

int nvars, index;

1543

vlist_t *vlistptr;

1544

1545

vlistptr = vlist_to_pointer(vlistID);

1546

1547

vlistCheckVarID(func, vlistID, varID);

1548

1549

vlistptr->vars[varID].zlevel = zlevel;

1550

}

1551

1552

1553

int vlistInqVarZlevel(int vlistID, int varID)

1554

{

1555

static const char *func = "vlistInqVarZlevel";

1556

int nvars, index;

1557

vlist_t *vlistptr;

1558

1559

vlistptr = vlist_to_pointer(vlistID);

1560

1561

vlistCheckVarID(func, vlistID, varID);

1562

1563

return (vlistptr->vars[varID].zlevel);

1564

}

Older »