void f2fGrid::fParse() {
if (gridLineOrder == 1) {
setPointX = -(gridLineStartX+gridLineStep);
} else {
setPointX = gridLineStartX+gridLineStep;
}
setPointMinX = gridLineStartX;
setPointY = gridLineY;
setPointStep = gridLineStep;
setGraphCeil = 1;
fSet();
if (gridLineOrder == 1) {
swap = pointX;
pointX = pointY;
pointY = -swap;
}
fTranslate();
if (gridLineOrder == 1) {
setPointX = -pointY;
} else {
setPointX = pointX;
}
setGraphCeil = 2;
fSet();
if (gridLineOrder == 1) {
swap = pointX;
pointX = pointY;
pointY = -swap;
}
fTranslate();
fCentral();
}
static ncio *
ncio_new(const char *path, int ioflags)
{
size_t sz_ncio = M_RNDUP(sizeof(ncio));
size_t sz_path = M_RNDUP(strlen(path) +1);
size_t sz_ncio_pvt;
ncio *nciop;
#if ALWAYS_NC_SHARE /* DEBUG */
fSet(ioflags, NC_SHARE);
#endif
if(fIsSet(ioflags, NC_SHARE))
fprintf(stderr, "NC_SHARE not implemented for fileio\n");
sz_ncio_pvt = sizeof(ncio_ffio);
nciop = (ncio *) malloc(sz_ncio + sz_path + sz_ncio_pvt);
if(nciop == NULL)
return NULL;
nciop->ioflags = ioflags;
*((int *)&nciop->fd) = -1; /* cast away const */
nciop->path = (char *) ((char *)nciop + sz_ncio);
(void) strcpy((char *)nciop->path, path); /* cast away const */
/* cast away const */
*((void **)&nciop->pvt) = (void *)(nciop->path + sz_path);
ncio_fileio_init(nciop);
return nciop;
}
int
nc_redef(int ncid)
{
int status;
NC *ncp;
status = NC_check_id(ncid, &ncp);
if(status != NC_NOERR)
return status;
if(NC_readonly(ncp))
return NC_EPERM;
if(NC_indef(ncp))
return NC_EINDEFINE;
if(fIsSet(ncp->nciop->ioflags, NC_SHARE))
{
/* read in from disk */
status = read_NC(ncp);
if(status != NC_NOERR)
return status;
}
ncp->old = dup_NC(ncp);
if(ncp->old == NULL)
return NC_ENOMEM;
fSet(ncp->flags, NC_INDEF);
return NC_NOERR;
}
int main(int argc, char *argv[]){
float x0, y0, h;
int m, entrada, id;
// escolha da funcao
printf("Digite a funcao que deseja usar: (ex: x + 2 * y)\n");
printf("(1) - (1 - x + 4*y) \n");
printf("(2) - (1 - y/x) \n");
printf("(3) - (x - y + 2) \n");
printf("(4) - (-10 * y) \n");
printf("(5) - (0.04 * y) \n");
scanf("%d", &id);
char funcao[80];
gets(funcao);
fSet(funcao);
// entrada de dados
printf("Digite o valor de x inicial: \n");
scanf("%f", &x0);
printf("Digite o valor de y inicial: \n");
scanf("%f", &y0);
printf("Digite o valor do espacamento h: \n");
scanf("%f", &h);
printf("Informe o numero de subintervalos : \n");
scanf("%d", &m);
printf("Informe o metodo que deseja usar: \n");
printf("(1) - Metodo de Euler \n");
printf("(2) - Runge Kutta Segunda Ordem \n");
printf("(3) - Runge Kutta Terceira Ordem \n");
printf("(4) - Runge Kutta Quarta Ordem \n");
printf("(5) - Preditor Corretor \n");
scanf("%d", &entrada);
switch (entrada)
{
case 1:
metodoEuler(x0,y0,h,m,id);
break;
case 2:
rungeKuttaSegundaOrdem(x0,y0,h,m,id);
break;
case 3:
rungeKuttaTerceiraOrdem(x0,y0,h,m,id);
break;
case 4:
rungeKuttaQuartaOrdem(x0,y0,h,m,id);
break;
case 5:
preditorCorretor(x0,y0,h,m,id);
break;
default:
break;
}
system("PAUSE");
return 0;
}
/* Create a file, and the ncio struct to go with it.
path - path of file to create.
ioflags - flags from nc_create
initialsz - From the netcdf man page: "The argument
initialsize sets the initial size of the file at creation time."
igeto -
igetsz -
sizehintp - the size of a page of data for buffered reads and writes.
parameters - arbitrary data
nciopp - pointer to a pointer that will get location of newly
created and inited ncio struct.
mempp - pointer to pointer to the initial memory read.
*/
int
memio_create(const char* path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t* sizehintp,
void* parameters /*ignored*/,
ncio* *nciopp, void** const mempp)
{
ncio* nciop;
int fd;
int status;
NCMEMIO* memio = NULL;
if(path == NULL ||* path == 0)
return NC_EINVAL;
status = memio_new(path, ioflags, initialsz, &nciop, &memio);
if(status != NC_NOERR)
return status;
if(memio->persist) {
/* Verify the file is writeable or does not exist*/
if(fileexists(path) && !fileiswriteable(path))
{status = EPERM; goto unwind_open;}
}
/* Allocate the memory for this file */
memio->memory = (char*)malloc((size_t)memio->alloc);
if(memio->memory == NULL) {status = NC_ENOMEM; goto unwind_open;}
memio->locked = 0;
#ifdef DEBUG
fprintf(stderr,"memio_create: initial memory: %lu/%lu\n",(unsigned long)memio->memory,(unsigned long)memio->alloc);
#endif
fd = nc__pseudofd();
*((int* )&nciop->fd) = fd;
fSet(nciop->ioflags, NC_WRITE); /* Always writeable */
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
mempp);
if(status != NC_NOERR)
goto unwind_open;
}
/* Pick a default sizehint */
if(sizehintp) *sizehintp = (size_t)pagesize;
*nciopp = nciop;
return NC_NOERR;
unwind_open:
memio_close(nciop,1);
return status;
}
//Inicia a variável do interpretador e uma função padrão "x + y e a variável 'e'"
void luaStart(){
L = luaL_newstate();
luaL_openlibs(L);
math_replacement(); // bibliotecas de lua
lua_pushnumber(L,2.71828182846);
lua_setglobal(L,"e"); // numero de 'e'
lua_pcall(L, 0, 0, 0);
fSet("sin(e * pi * x)"); // função padrão
}
void Foam::setAndNormalToFaceZone::applyToSet
(
const topoSetSource::setAction action,
topoSet& set
) const
{
if (!isA<faceZoneSet>(set))
{
WarningInFunction
<< "Operation only allowed on a faceZoneSet." << endl;
}
else
{
faceZoneSet& fzSet = refCast<faceZoneSet>(set);
if ((action == topoSetSource::NEW) || (action == topoSetSource::ADD))
{
Info<< " Adding all faces from faceSet " << setName_
<< " ..." << endl;
// Load the sets
faceSet fSet(mesh_, setName_);
// Start off from copy
DynamicList<label> newAddressing(fzSet.addressing());
DynamicList<bool> newFlipMap(fzSet.flipMap());
const faceList& faces = mesh_.faces();
const pointField& points = mesh_.points();
forAllConstIter(faceSet, fSet, iter)
{
label faceI = iter.key();
if (!fzSet.found(faceI))
{
newAddressing.append(faceI);
vector n = faces[faceI].normal(points);
if ((n & normal_) > 0)
{
newFlipMap.append(false);
}
else
{
newFlipMap.append(true);
}
}
}
fzSet.addressing().transfer(newAddressing);
fzSet.flipMap().transfer(newFlipMap);
fzSet.updateSet();
}
/* This function indicates the file region starting at offset may be
released.
This is for POSIX, without NC_SHARE. If called with RGN_MODIFIED
flag, sets the modified flag in pxp->bf_rflags and decrements the
reference count.
pxp - pointer to posix non-share ncio_px struct.
offset - file offset for beginning of to region to be
released.
rflags - only RGN_MODIFIED is relevent to this function, others ignored
*/
static int
px_rel(ncio_px *const pxp, off_t offset, int rflags)
{
assert(pxp->bf_offset <= offset
&& offset < pxp->bf_offset + (off_t) pxp->bf_extent);
assert(pIf(fIsSet(rflags, RGN_MODIFIED),
fIsSet(pxp->bf_rflags, RGN_WRITE)));
if(fIsSet(rflags, RGN_MODIFIED))
{
fSet(pxp->bf_rflags, RGN_MODIFIED);
}
pxp->bf_refcount--;
return ENOERR;
}
static int
memio_close(ncio* nciop, int doUnlink)
{
int status = NC_NOERR;
NCMEMIO* memio;
int fd = -1;
if(nciop == NULL || nciop->pvt == NULL) return NC_NOERR;
memio = (NCMEMIO*)nciop->pvt;
assert(memio != NULL);
/* See if the user wants the contents persisted to a file */
if(memio->persist) {
/* Try to open the file for writing */
int oflags = O_WRONLY|O_CREAT|O_TRUNC;
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
fd = open(nciop->path, oflags, OPENMODE);
if(fd >= 0) {
/* We need to do multiple writes because there is no
guarantee that the amount written will be the full amount */
off_t written = memio->size;
char* pos = memio->memory;
while(written > 0) {
ssize_t count = write(fd, pos, written);
if(count < 0)
{status = errno; goto done;}
if(count == 0)
{status = NC_ENOTNC; goto done;}
written -= count;
pos += count;
}
} else
status = errno;
/* Free up things */
if(memio->memory != NULL) free(memio->memory);
}
done:
/* do cleanup */
if(fd >= 0) (void)close(fd);
if(memio != NULL) free(memio);
if(nciop->path != NULL) free((char*)nciop->path);
free(nciop);
return status;
}
int
nc_set_fill(int ncid,
int fillmode, int *old_mode_ptr)
{
int status;
NC *ncp;
int oldmode;
status = NC_check_id(ncid, &ncp);
if(status != NC_NOERR)
return status;
if(NC_readonly(ncp))
return NC_EPERM;
oldmode = fIsSet(ncp->flags, NC_NOFILL) ? NC_NOFILL : NC_FILL;
if(fillmode == NC_NOFILL)
{
fSet(ncp->flags, NC_NOFILL);
}
else if(fillmode == NC_FILL)
{
if(fIsSet(ncp->flags, NC_NOFILL))
{
/*
* We are changing back to fill mode
* so do a sync
*/
status = NC_sync(ncp);
if(status != NC_NOERR)
return status;
}
fClr(ncp->flags, NC_NOFILL);
}
else
{
return NC_EINVAL; /* Invalid fillmode */
}
if(old_mode_ptr != NULL)
*old_mode_ptr = oldmode;
return NC_NOERR;
}
void Foam::setToPointZone::applyToSet
(
const topoSetSource::setAction action,
topoSet& set
) const
{
if (!isA<pointZoneSet>(set))
{
WarningIn
(
"setToPointZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a pointZoneSet." << endl;
}
else
{
pointZoneSet& fzSet = refCast<pointZoneSet>(set);
if ((action == topoSetSource::NEW) || (action == topoSetSource::ADD))
{
Info<< " Adding all points from pointSet " << setName_
<< " ..." << endl;
// Load the sets
pointSet fSet(mesh_, setName_);
// Start off from copy
DynamicList<label> newAddressing(fzSet.addressing());
forAllConstIter(pointSet, fSet, iter)
{
label pointI = iter.key();
if (!fzSet.found(pointI))
{
newAddressing.append(pointI);
}
}
fzSet.addressing().transfer(newAddressing);
fzSet.updateSet();
}
/* Create a file, and the ncio struct to go with it. This function is
only called from nc__create_mp.
path - path of file to create.
ioflags - flags from nc_create
initialsz - From the netcdf man page: "The argument
Iinitialsize sets the initial size of the file at creation time."
igeto -
igetsz -
sizehintp - the size of a page of data for buffered reads and writes.
nciopp - pointer to a pointer that will get location of newly
created and inited ncio struct.
mempp - pointer to pointer to the initial memory read.
*/
int
mmapio_create(const char* path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t* sizehintp,
void* parameters,
ncio* *nciopp, void** const mempp)
{
ncio* nciop;
int fd;
int status;
NCMMAPIO* mmapio = NULL;
int persist = (ioflags & NC_WRITE?1:0);
int oflags;
if(path == NULL ||* path == 0)
return NC_EINVAL;
/* For diskless open has, the file must be classic version 1 or 2.*/
if(fIsSet(ioflags,NC_NETCDF4))
return NC_EDISKLESS; /* violates constraints */
status = mmapio_new(path, ioflags, initialsz, &nciop, &mmapio);
if(status != NC_NOERR)
return status;
mmapio->size = 0;
if(!persist) {
mmapio->mapfd = -1;
mmapio->memory = (char*)mmap(NULL,mmapio->alloc,
PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS,
mmapio->mapfd,0);
{mmapio->memory[0] = 0;} /* test writing of the mmap'd memory */
} else { /*persist */
/* Open the file, but make sure we can write it if needed */
oflags = (persist ? O_RDWR : O_RDONLY);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
oflags |= (O_CREAT|O_TRUNC);
if(fIsSet(ioflags,NC_NOCLOBBER))
oflags |= O_EXCL;
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, OPENMODE);
#endif
if(fd < 0) {status = errno; goto unwind_open;}
mmapio->mapfd = fd;
{ /* Cause the output file to have enough allocated space */
lseek(fd,mmapio->alloc-1,SEEK_SET); /* cause file to appear */
write(fd,"",mmapio->alloc);
lseek(fd,0,SEEK_SET); /* rewind */
}
mmapio->memory = (char*)mmap(NULL,mmapio->alloc,
PROT_READ|PROT_WRITE,
MAP_SHARED,
mmapio->mapfd,0);
if(mmapio->memory == NULL) {
return NC_EDISKLESS;
}
} /*!persist*/
#ifdef DEBUG
fprintf(stderr,"mmap_create: initial memory: %lu/%lu\n",(unsigned long)mmapio->memory,(unsigned long)mmapio->alloc);
#endif
fd = nc__pseudofd();
*((int* )&nciop->fd) = fd;
fSet(nciop->ioflags, NC_WRITE);
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
mempp);
if(status != NC_NOERR)
goto unwind_open;
}
/* Pick a default sizehint */
if(sizehintp) *sizehintp = pagesize;
*nciopp = nciop;
return NC_NOERR;
unwind_open:
mmapio_close(nciop,1);
return status;
}
/* This function opens the data file. It is only called from nc.c,
from nc__open_mp and nc_delete_mp.
path - path of data file.
ioflags - flags passed into nc_open.
igeto - looks like this function can do an initial page get, and
igeto is going to be the offset for that. But it appears to be
unused
igetsz - the size in bytes of initial page get (a.k.a. extent). Not
ever used in the library.
sizehintp - the size of a page of data for buffered reads and writes.
nciopp - pointer to pointer that will get address of newly created
and inited ncio struct.
mempp - pointer to pointer to the initial memory read.
*/
int
memio_open(const char* path,
int ioflags,
off_t igeto, size_t igetsz, size_t* sizehintp,
ncio* *nciopp, void** const mempp)
{
ncio* nciop;
int fd;
int status;
int persist = (fIsSet(ioflags,NC_WRITE)?1:0);
int oflags;
NCMEMIO* memio = NULL;
size_t sizehint;
off_t filesize;
if(path == NULL ||* path == 0)
return EINVAL;
assert(sizehintp != NULL);
sizehint = *sizehintp;
/* Open the file, but make sure we can write it if needed */
oflags = (persist ? O_RDWR : O_RDONLY);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
oflags |= O_EXCL;
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, OPENMODE);
#endif
#ifdef DEBUG
if(fd < 0) {
fprintf(stderr,"open failed: file=%s err=",path);
perror("");
}
#endif
if(fd < 0) {status = errno; goto unwind_open;}
/* get current filesize = max(|file|,initialize)*/
filesize = lseek(fd,0,SEEK_END);
if(filesize < 0) {status = errno; goto unwind_open;}
/* move pointer back to beginning of file */
(void)lseek(fd,0,SEEK_SET);
if(filesize < (off_t)sizehint)
filesize = (off_t)sizehint;
status = memio_new(path, ioflags, filesize, &nciop, &memio);
if(status != NC_NOERR)
return status;
memio->size = filesize;
memio->memory = (char*)malloc(memio->alloc);
if(memio->memory == NULL) {status = NC_ENOMEM; goto unwind_open;}
#ifdef DEBUG
fprintf(stderr,"memio_open: initial memory: %lu/%lu\n",(unsigned long)memio->memory,(unsigned long)memio->alloc);
#endif
/* Read the file into the memio memory */
/* We need to do multiple reads because there is no
guarantee that the amount read will be the full amount */
{
off_t red = memio->size;
char* pos = memio->memory;
while(red > 0) {
ssize_t count = read(fd, pos, red);
if(count < 0)
{close(fd); status = errno; goto unwind_open;}
if(count == 0)
{close(fd); status = NC_ENOTNC; goto unwind_open;}
red -= count;
pos += count;
}
}
(void)close(fd); /* until memio_close() */
/* Use half the filesize as the blocksize */
sizehint = filesize/2;
fd = nc__pseudofd();
*((int* )&nciop->fd) = fd;
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
0,
mempp);
if(status != NC_NOERR)
goto unwind_open;
}
*sizehintp = sizehint;
*nciopp = nciop;
return NC_NOERR;
unwind_open:
memio_close(nciop,0);
return status;
}
/* Create a file, and the ncio struct to go with it. This function is
only called from nc__create_mp.
path - path of file to create.
ioflags - flags from nc_create
initialsz - From the netcdf man page: "The argument
Iinitialsize sets the initial size of the file at creation time."
igeto -
igetsz -
sizehintp - the size of a page of data for buffered reads and writes.
nciopp - pointer to a pointer that will get location of newly
created and inited ncio struct.
mempp - pointer to pointer to the initial memory read.
*/
int
memio_create(const char* path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t* sizehintp,
ncio* *nciopp, void** const mempp)
{
ncio* nciop;
int fd;
int status;
NCMEMIO* memio = NULL;
int persist = (ioflags & NC_WRITE?1:0);
int oflags;
if(path == NULL ||* path == 0)
return NC_EINVAL;
/* For diskless open has, the file must be classic version 1 or 2.*/
if(fIsSet(ioflags,NC_NETCDF4))
return NC_EDISKLESS; /* violates constraints */
status = memio_new(path, ioflags, initialsz, &nciop, &memio);
if(status != NC_NOERR)
return status;
memio->size = 0;
if(!persist) {
memio->memory = (char*)malloc(memio->alloc);
if(memio->memory == NULL) {status = NC_ENOMEM; goto unwind_open;}
} else { /*persist */
/* Open the file, but make sure we can write it if needed */
oflags = (persist ? O_RDWR : O_RDONLY);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
oflags |= (O_CREAT|O_TRUNC);
if(fIsSet(ioflags,NC_NOCLOBBER))
oflags |= O_EXCL;
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, OPENMODE);
#endif
if(fd < 0) {status = errno; goto unwind_open;}
(void)close(fd); /* will reopen at nc_close */
/* malloc memory */
memio->memory = (char*)malloc(memio->alloc);
if(memio->memory == NULL) {status = NC_ENOMEM; goto unwind_open;}
} /*!persist*/
#ifdef DEBUG
fprintf(stderr,"memio_create: initial memory: %lu/%lu\n",(unsigned long)memio->memory,(unsigned long)memio->alloc);
#endif
fd = nc__pseudofd();
*((int* )&nciop->fd) = fd;
fSet(nciop->ioflags, NC_WRITE);
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
mempp);
if(status != NC_NOERR)
goto unwind_open;
}
/* Pick a default sizehint */
if(sizehintp) *sizehintp = pagesize;
*nciopp = nciop;
return NC_NOERR;
unwind_open:
memio_close(nciop,1);
return status;
}
/* Make the in-memory NC structure from reading the file header */
int
nc_get_NC(NC3_INFO* ncp)
{
int status;
v1hs gs; /* the get stream */
assert(ncp != NULL);
/* Initialize stream gs */
gs.nciop = ncp->nciop;
gs.offset = 0; /* beginning of file */
gs.extent = 0;
gs.flags = 0;
gs.version = 0;
gs.base = NULL;
gs.pos = gs.base;
{
/*
* Come up with a reasonable stream read size.
*/
off_t filesize;
size_t extent = ncp->xsz;
if(extent <= ((fIsSet(ncp->flags, NC_64BIT_DATA))?MIN_NC5_XSZ:MIN_NC3_XSZ))
{
status = ncio_filesize(ncp->nciop, &filesize);
if(status)
return status;
if(filesize < sizeof(ncmagic)) { /* too small, not netcdf */
status = NC_ENOTNC;
return status;
}
/* first time read */
extent = ncp->chunk;
/* Protection for when ncp->chunk is huge;
* no need to read hugely. */
if(extent > 4096)
extent = 4096;
if(extent > filesize)
extent = filesize;
}
else if(extent > ncp->chunk)
extent = ncp->chunk;
/*
* Invalidate the I/O buffers to force a read of the header
* region.
*/
status = ncio_sync(gs.nciop);
if(status)
return status;
status = fault_v1hs(&gs, extent);
if(status)
return status;
}
/* get the header from the stream gs */
{
/* Get & check magic number */
schar magic[sizeof(ncmagic)];
(void) memset(magic, 0, sizeof(magic));
status = ncx_getn_schar_schar(
(const void **)(&gs.pos), sizeof(magic), magic);
if(status != ENOERR)
goto unwind_get;
if(memcmp(magic, ncmagic, sizeof(ncmagic)-1) != 0)
{
status = NC_ENOTNC;
goto unwind_get;
}
/* Check version number in last byte of magic */
if (magic[sizeof(ncmagic)-1] == 0x1) {
gs.version = 1;
} else if (magic[sizeof(ncmagic)-1] == 0x2) {
gs.version = 2;
fSet(ncp->flags, NC_64BIT_OFFSET);
/* Now we support version 2 file access on non-LFS systems -- rkr */
#if 0
if (sizeof(off_t) != 8) {
fprintf(stderr, "NETCDF WARNING: Version 2 file on 32-bit system.\n");
}
#endif
} else if (magic[sizeof(ncmagic)-1] == 0x5) {
gs.version = 5;
fSet(ncp->flags, NC_64BIT_DATA);
} else {
status = NC_ENOTNC;
goto unwind_get;
}
}
{
size_t nrecs = 0;
if (gs.version == 5) {
long long tmp = 0;
status = ncx_get_int64((const void **)(&gs.pos), &tmp);
nrecs = (size_t)tmp;
}
else
status = ncx_get_size_t((const void **)(&gs.pos), &nrecs);
if(status != ENOERR)
goto unwind_get;
NC_set_numrecs(ncp, nrecs);
}
assert((char *)gs.pos < (char *)gs.end);
status = v1h_get_NC_dimarray(&gs, &ncp->dims);
if(status != ENOERR)
goto unwind_get;
status = v1h_get_NC_attrarray(&gs, &ncp->attrs);
if(status != ENOERR)
goto unwind_get;
status = v1h_get_NC_vararray(&gs, &ncp->vars);
if(status != ENOERR)
goto unwind_get;
ncp->xsz = ncx_len_NC(ncp, (gs.version == 1) ? 4 : 8);
status = NC_computeshapes(ncp);
if(status != ENOERR)
goto unwind_get;
unwind_get:
(void) rel_v1hs(&gs);
return status;
}
int
ncio_create(const char *path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t *sizehintp,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
#ifdef _WIN32_WCE
char* oflags = "bw+"; /*==?(O_RDWR|O_CREAT|O_TRUNC) && binary*/
#else
char* oflags = "w+"; /*==?(O_RDWR|O_CREAT|O_TRUNC);*/
#endif
FILE* f;
int i,fd;
int status = ENOERR;
if(initialsz < (size_t)igeto + igetsz)
initialsz = (size_t)igeto + igetsz;
fSet(ioflags, NC_WRITE);
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
if(fIsSet(ioflags, NC_NOCLOBBER)) {
/* Since we do not have use of the O_EXCL flag,
we need to fake it */
#ifdef WINCE
f = fopen(path,"rb");
#else
f = fopen(path,"r");
#endif
if(f != NULL) { /* do not overwrite */
(void)fclose(f);
return EEXIST;
}
}
f = fopen(path, oflags);
if(f == NULL)
{
status = errno;
goto unwind_new;
}
/* Locate an open pseudo file descriptor */
fd = -1;
for(i=1;i<fdmax;i++) {if(descriptors[i] == NULL) {fd=i;break;}}
if(fd < 0) {fd = fdmax; fdmax++;}
descriptors[fd] = f;
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE || *sizehintp > NCIO_MAXBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
status = ncio_fileio_init2(nciop, sizehintp);
if(status != ENOERR)
goto unwind_open;
if(initialsz != 0)
{
status = fgrow(f, (off_t)initialsz);
if(status != ENOERR)
goto unwind_open;
}
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
igetvpp);
if(status != ENOERR)
goto unwind_open;
}
*nciopp = nciop;
return ENOERR;
unwind_open:
(void) fclose(descriptors[fd]);
descriptors[fd] = NULL;
/* ?? unlink */
/*FALLTHRU*/
unwind_new:
ncio_free(nciop);
return status;
}
int
nc__create_mp(const char * path, int ioflags, size_t initialsz, int basepe,
size_t *chunksizehintp, int *ncid_ptr)
{
NC *ncp;
int status;
void *xp = NULL;
int sizeof_off_t = 0;
#if ALWAYS_NC_SHARE /* DEBUG */
fSet(ioflags, NC_SHARE);
#endif
ncp = new_NC(chunksizehintp);
if(ncp == NULL)
return NC_ENOMEM;
#if defined(LOCKNUMREC) /* && _CRAYMPP */
if (status = NC_init_pe(ncp, basepe)) {
return status;
}
#else
/*
* !_CRAYMPP, only pe 0 is valid
*/
if(basepe != 0)
return NC_EINVAL;
#endif
assert(ncp->flags == 0);
/* Apply default create format. */
if (default_create_format == NC_FORMAT_64BIT)
ioflags |= NC_64BIT_OFFSET;
if (fIsSet(ioflags, NC_64BIT_OFFSET)) {
fSet(ncp->flags, NC_64BIT_OFFSET);
sizeof_off_t = 8;
} else {
sizeof_off_t = 4;
}
assert(ncp->xsz == ncx_len_NC(ncp,sizeof_off_t));
status = ncio_create(path, ioflags,
initialsz,
0, ncp->xsz, &ncp->chunk,
&ncp->nciop, &xp);
if(status != NC_NOERR)
{
/* translate error status */
if(status == EEXIST)
status = NC_EEXIST;
goto unwind_alloc;
}
fSet(ncp->flags, NC_CREAT);
if(fIsSet(ncp->nciop->ioflags, NC_SHARE))
{
/*
* NC_SHARE implies sync up the number of records as well.
* (File format version one.)
* Note that other header changes are not shared
* automatically. Some sort of IPC (external to this package)
* would be used to trigger a call to nc_sync().
*/
fSet(ncp->flags, NC_NSYNC);
}
status = ncx_put_NC(ncp, &xp, sizeof_off_t, ncp->xsz);
if(status != NC_NOERR)
goto unwind_ioc;
add_to_NCList(ncp);
if(chunksizehintp != NULL)
*chunksizehintp = ncp->chunk;
*ncid_ptr = ncp->nciop->fd;
return NC_NOERR;
unwind_ioc:
(void) ncio_close(ncp->nciop, 1); /* N.B.: unlink */
ncp->nciop = NULL;
/*FALLTHRU*/
unwind_alloc:
free_NC(ncp);
return status;
}
/* This function opens the data file. It is only called from nc.c,
from nc__open_mp and nc_delete_mp.
path - path of data file.
ioflags - flags passed into nc_open.
igeto - looks like this function can do an initial page get, and
igeto is going to be the offset for that. But it appears to be
unused
igetsz - the size in bytes of initial page get (a.k.a. extent). Not
ever used in the library.
sizehintp - pointer to sizehint parameter from nc__open or
nc__create. This is used to set pxp->blksz.
Here's what the man page has to say:
"The argument referenced by chunksize controls a space versus time
tradeoff, memory allocated in the netcdf library versus number of
system calls.
Because of internal requirements, the value may not be set to
exactly the value requested. The actual value chosen is returned by reference.
Using the value NC_SIZEHINT_DEFAULT causes the library to choose a
default. How the system choses the default depends on the
system. On many systems, the "preferred I/O block size" is
available from the stat() system call, struct stat member
st_blksize. If this is available it is used. Lacking that, twice
the system pagesize is used. Lacking a call to discover the system
pagesize, we just set default chunksize to 8192.
The chunksize is a property of a given open netcdf descriptor ncid,
it is not a persistent property of the netcdf dataset."
nciopp - pointer to pointer that will get address of newly created
and inited ncio struct.
igetvpp - handle to pass back pointer to data from inital page
read, if this were ever used, which it isn't.
*/
int
posixio_open(const char *path,
int ioflags,
off_t igeto, size_t igetsz, size_t *sizehintp,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
int oflags = fIsSet(ioflags, NC_WRITE) ? O_RDWR : O_RDONLY;
int fd = -1;
int status = 0;
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_px_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
//#ifdef O_BINARY
#if _MSC_VER
fSet(oflags, O_BINARY);
#endif
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, 0);
#endif
if(fd < 0)
{
status = errno;
goto unwind_new;
}
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else if(*sizehintp >= NCIO_MAXBLOCKSIZE)
{
/* Use maximum allowed value */
*sizehintp = NCIO_MAXBLOCKSIZE;
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
if(fIsSet(nciop->ioflags, NC_SHARE))
status = ncio_spx_init2(nciop, sizehintp);
else
status = ncio_px_init2(nciop, sizehintp, 0);
if(status != ENOERR)
goto unwind_open;
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
0,
igetvpp);
if(status != ENOERR)
goto unwind_open;
}
*nciopp = nciop;
return ENOERR;
unwind_open:
(void) close(fd); /* assert fd >= 0 */
/*FALLTHRU*/
unwind_new:
ncio_close(nciop,0);
return status;
}
/* Create a file, and the ncio struct to go with it. This funtion is
only called from nc__create_mp.
path - path of file to create.
ioflags - flags from nc_create
initialsz - From the netcdf man page: "The argument
Iinitialsize sets the initial size of the file at creation time."
igeto -
igetsz -
sizehintp - this eventually goes into pxp->blksz and is the size of
a page of data for buffered reads and writes.
nciopp - pointer to a pointer that will get location of newly
created and inited ncio struct.
igetvpp - pointer to pointer which will get the location of ?
*/
int
posixio_create(const char *path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t *sizehintp,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
int oflags = (O_RDWR|O_CREAT);
int fd;
int status;
if(initialsz < (size_t)igeto + igetsz)
initialsz = (size_t)igeto + igetsz;
fSet(ioflags, NC_WRITE);
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_px_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
if(fIsSet(ioflags, NC_NOCLOBBER))
fSet(oflags, O_EXCL);
else
fSet(oflags, O_TRUNC);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
#ifdef vms
fd = open(path, oflags, NC_DEFAULT_CREAT_MODE, "ctx=stm");
#else
/* Should we mess with the mode based on NC_SHARE ?? */
fd = open(path, oflags, NC_DEFAULT_CREAT_MODE);
#endif
#if 0
(void) fprintf(stderr, "ncio_create(): path=\"%s\"\n", path);
(void) fprintf(stderr, "ncio_create(): oflags=0x%x\n", oflags);
#endif
if(fd < 0)
{
status = errno;
goto unwind_new;
}
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else if(*sizehintp >= NCIO_MAXBLOCKSIZE)
{
/* Use maximum allowed value */
*sizehintp = NCIO_MAXBLOCKSIZE;
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
if(fIsSet(nciop->ioflags, NC_SHARE))
status = ncio_spx_init2(nciop, sizehintp);
else
status = ncio_px_init2(nciop, sizehintp, 1);
if(status != ENOERR)
goto unwind_open;
if(initialsz != 0)
{
status = fgrow(fd, (off_t)initialsz);
if(status != ENOERR)
goto unwind_open;
}
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
igetvpp);
if(status != ENOERR)
goto unwind_open;
}
*nciopp = nciop;
return ENOERR;
unwind_open:
(void) close(fd);
/* ?? unlink */
/*FALLTHRU*/
unwind_new:
ncio_close(nciop,!fIsSet(ioflags, NC_NOCLOBBER));
return status;
}
void Foam::setsToFaceZone::applyToSet
(
const topoSetSource::setAction action,
topoSet& set
) const
{
if (!isA<faceZoneSet>(set))
{
WarningIn
(
"setsToFaceZone::applyToSet(const topoSetSource::setAction"
", topoSet"
) << "Operation only allowed on a faceZoneSet." << endl;
}
else
{
faceZoneSet& fzSet = refCast<faceZoneSet>(set);
if ((action == topoSetSource::NEW) || (action == topoSetSource::ADD))
{
Info<< " Adding all faces from faceSet " << faceSetName_
<< " ..." << endl;
// Load the sets
faceSet fSet(mesh_, faceSetName_);
cellSet cSet(mesh_, cellSetName_);
// Start off from copy
DynamicList<label> newAddressing(fzSet.addressing());
DynamicList<bool> newFlipMap(fzSet.flipMap());
forAllConstIter(faceSet, fSet, iter)
{
label faceI = iter.key();
if (!fzSet.found(faceI))
{
bool flip = false;
label own = mesh_.faceOwner()[faceI];
bool ownFound = cSet.found(own);
if (mesh_.isInternalFace(faceI))
{
label nei = mesh_.faceNeighbour()[faceI];
bool neiFound = cSet.found(nei);
if (ownFound && !neiFound)
{
flip = false;
}
else if (!ownFound && neiFound)
{
flip = true;
}
else
{
WarningIn
(
"setsToFaceZone::applyToSet"
"(const topoSetSource::setAction, topoSet)"
) << "One of owner or neighbour of internal face "
<< faceI << " should be in cellSet "
<< cSet.name()
<< " to be able to determine orientation."
<< endl
<< "Face:" << faceI << " own:" << own
<< " OwnInCellSet:" << ownFound
<< " nei:" << nei
<< " NeiInCellSet:" << neiFound
<< endl;
}
}
else
{
flip = !ownFound;
}
newAddressing.append(faceI);
newFlipMap.append(flip);
}
}
fzSet.addressing().transfer(newAddressing);
fzSet.flipMap().transfer(newFlipMap);
fzSet.updateSet();
}
int
nc__open_mp(const char * path, int ioflags, int basepe,
size_t *chunksizehintp, int *ncid_ptr)
{
NC *ncp;
int status;
#if ALWAYS_NC_SHARE /* DEBUG */
fSet(ioflags, NC_SHARE);
#endif
ncp = new_NC(chunksizehintp);
if(ncp == NULL)
return NC_ENOMEM;
#if defined(LOCKNUMREC) /* && _CRAYMPP */
if (status = NC_init_pe(ncp, basepe)) {
return status;
}
#else
/*
* !_CRAYMPP, only pe 0 is valid
*/
if(basepe != 0)
return NC_EINVAL;
#endif
status = ncio_open(path, ioflags,
0, 0, &ncp->chunk,
&ncp->nciop, 0);
if(status)
goto unwind_alloc;
assert(ncp->flags == 0);
if(fIsSet(ncp->nciop->ioflags, NC_SHARE))
{
/*
* NC_SHARE implies sync up the number of records as well.
* (File format version one.)
* Note that other header changes are not shared
* automatically. Some sort of IPC (external to this package)
* would be used to trigger a call to nc_sync().
*/
fSet(ncp->flags, NC_NSYNC);
}
status = nc_get_NC(ncp);
if(status != NC_NOERR)
goto unwind_ioc;
add_to_NCList(ncp);
if(chunksizehintp != NULL)
*chunksizehintp = ncp->chunk;
*ncid_ptr = ncp->nciop->fd;
return NC_NOERR;
unwind_ioc:
(void) ncio_close(ncp->nciop, 0);
ncp->nciop = NULL;
/*FALLTHRU*/
unwind_alloc:
free_NC(ncp);
return status;
}
int
ffio_create(const char *path, int ioflags,
size_t initialsz,
off_t igeto, size_t igetsz, size_t *sizehintp,
ncio **nciopp, void **const igetvpp)
{
ncio *nciop;
const char *ControlString;
int oflags = (O_RDWR|O_CREAT|O_TRUNC);
int fd;
int status;
struct ffsw stat;
if(initialsz < (size_t)igeto + igetsz)
initialsz = (size_t)igeto + igetsz;
fSet(ioflags, NC_WRITE);
if(path == NULL || *path == 0)
return EINVAL;
nciop = ncio_ffio_new(path, ioflags);
if(nciop == NULL)
return ENOMEM;
if ((ControlString = ncio_ffio_assign(path)) == (const char *)NULL) {
/* an error occured - just punt */
status = errno;
goto unwind_new;
}
#ifdef NOFFFLUSH
/* test whether the global layer is being called for
* this file ... if so then can't call FFIO ffflush()
* RKO 06/26/98
*/
if (strstr(ControlString,"global") != (char *) NULL) {
/* use no ffflush version */
*((ncio_syncfunc **)&nciop->sync)
= ncio_ffio_sync_noffflush;
}
#endif
if(fIsSet(ioflags, NC_NOCLOBBER))
fSet(oflags, O_EXCL);
/* Orig: fd = ffopens(path, oflags, 0666, 0, &stat, ControlString); */
fd = ffopen(path, oflags, 0666, 0, &stat);
if(fd < 0)
{
status = errno;
goto unwind_new;
}
*((int *)&nciop->fd) = fd; /* cast away const */
if(*sizehintp < NCIO_MINBLOCKSIZE || *sizehintp > NCIO_MAXBLOCKSIZE)
{
/* Use default */
*sizehintp = blksize(fd);
}
else
{
*sizehintp = M_RNDUP(*sizehintp);
}
status = ncio_ffio_init2(nciop, sizehintp);
if(status != ENOERR)
goto unwind_open;
if(initialsz != 0)
{
status = fgrow(fd, (off_t)initialsz);
if(status != ENOERR)
goto unwind_open;
}
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
RGN_WRITE,
igetvpp);
if(status != ENOERR)
goto unwind_open;
}
*nciopp = nciop;
return ENOERR;
unwind_open:
(void) ffclose(fd);
/* ?? unlink */
/*FALLTHRU*/
unwind_new:
ncio_close(nciop,!fIsSet(ioflags, NC_NOCLOBBER));
return status;
}
/*! Create a new ncio struct to hold info about the file. */
static int
memio_new(const char* path, int ioflags, off_t initialsize, ncio** nciopp, NCMEMIO** memiop)
{
int status = NC_NOERR;
ncio* nciop = NULL;
NCMEMIO* memio = NULL;
size_t minsize = (size_t)initialsize;
/* Unlike netcdf-4, INMEMORY and DISKLESS share code */
if(fIsSet(ioflags,NC_DISKLESS))
fSet(ioflags,NC_INMEMORY);
/* use asserts because this is an internal function */
assert(fIsSet(ioflags,NC_INMEMORY));
assert(memiop != NULL && nciopp != NULL);
assert(path != NULL);
if(pagesize == 0) {
#if defined (_WIN32) || defined(_WIN64)
SYSTEM_INFO info;
GetSystemInfo (&info);
pagesize = info.dwPageSize;
#elif defined HAVE_SYSCONF
long pgval = -1;
pgval = sysconf(_SC_PAGE_SIZE);
if(pgval < 0) {
status = NC_EIO;
goto fail;
}
pagesize = (size_t)pgval;
#elif defined HAVE_GETPAGESIZE
pagesize = (size_t)getpagesize();
#else
pagesize = 4096; /* good guess */
#endif
}
errno = 0;
/* Always force the allocated size to be a multiple of pagesize */
if(initialsize == 0) initialsize = pagesize;
if((initialsize % pagesize) != 0)
initialsize += (pagesize - (initialsize % pagesize));
nciop = (ncio* )calloc(1,sizeof(ncio));
if(nciop == NULL) {status = NC_ENOMEM; goto fail;}
nciop->ioflags = ioflags;
*((int*)&nciop->fd) = -1; /* caller will fix */
*((ncio_relfunc**)&nciop->rel) = memio_rel;
*((ncio_getfunc**)&nciop->get) = memio_get;
*((ncio_movefunc**)&nciop->move) = memio_move;
*((ncio_syncfunc**)&nciop->sync) = memio_sync;
*((ncio_filesizefunc**)&nciop->filesize) = memio_filesize;
*((ncio_pad_lengthfunc**)&nciop->pad_length) = memio_pad_length;
*((ncio_closefunc**)&nciop->close) = memio_close;
memio = (NCMEMIO*)calloc(1,sizeof(NCMEMIO));
if(memio == NULL) {status = NC_ENOMEM; goto fail;}
*((void* *)&nciop->pvt) = memio;
*((char**)&nciop->path) = strdup(path);
if(nciop->path == NULL) {status = NC_ENOMEM; goto fail;}
if(memiop && memio) *memiop = memio; else free(memio);
if(nciopp && nciop) *nciopp = nciop;
else {
if(nciop->path != NULL) free((char*)nciop->path);
free(nciop);
}
memio->alloc = (size_t)initialsize;
memio->pos = 0;
memio->size = minsize;
memio->memory = NULL; /* filled in by caller */
if(fIsSet(ioflags,NC_DISKLESS))
memio->diskless = 1;
if(fIsSet(ioflags,NC_INMEMORY))
memio->inmemory = 1;
if(fIsSet(ioflags,NC_PERSIST))
memio->persist = 1;
done:
return status;
fail:
if(memio != NULL) free(memio);
if(nciop != NULL) {
if(nciop->path != NULL) free((char*)nciop->path);
free(nciop);
}
goto done;
}
/* See ncd3dispatch.c for other version */
int
NCD3_open(const char * path, int mode,
int basepe, size_t *chunksizehintp,
int useparallel, void* mpidata,
NC_Dispatch* dispatch, NC** ncpp)
{
NCerror ncstat = NC_NOERR;
OCerror ocstat = OC_NOERR;
NC* drno = NULL;
NCDAPCOMMON* dapcomm = NULL;
const char* value;
char* tmpname = NULL;
if(!nc3dinitialized) nc3dinitialize();
if(path == NULL)
return NC_EDAPURL;
if(dispatch == NULL) PANIC("NC3D_open: no dispatch table");
/* Setup our NC and NCDAPCOMMON state*/
drno = (NC*)calloc(1,sizeof(NC));
if(drno == NULL) {ncstat = NC_ENOMEM; goto done;}
/* compute an ncid */
ncstat = add_to_NCList(drno);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
dapcomm = (NCDAPCOMMON*)calloc(1,sizeof(NCDAPCOMMON));
if(dapcomm == NULL) {ncstat = NC_ENOMEM; goto done;}
drno->dispatch = dispatch;
drno->dispatchdata = dapcomm;
dapcomm->controller = (NC*)drno;
dapcomm->cdf.separator = ".";
dapcomm->cdf.smallsizelimit = DFALTSMALLLIMIT;
dapcomm->cdf.cache = createnccache();
#ifdef HAVE_GETRLIMIT
{ struct rlimit rl;
if(getrlimit(RLIMIT_NOFILE, &rl) >= 0) {
dapcomm->cdf.cache->cachecount = (size_t)(rl.rlim_cur / 2);
}
}
#endif
#ifdef OCCOMPILEBYDEFAULT
/* set the compile flag by default */
dapcomm->oc.rawurltext = (char*)emalloc(strlen(path)+strlen("[compile]")+1);
strcpy(dapcomm->oc.rawurltext,"[compile]");
strcat(dapcomm->oc.rawurltext, path);
#else
dapcomm->oc.rawurltext = strdup(path);
#endif
nc_uriparse(dapcomm->oc.rawurltext,&dapcomm->oc.url);
/* parse the client parameters */
nc_uridecodeparams(dapcomm->oc.url);
if(!constrainable34(dapcomm->oc.url))
SETFLAG(dapcomm->controls,NCF_UNCONSTRAINABLE);
/* Use libsrc code for storing metadata */
tmpname = nulldup(PSEUDOFILE);
/* Now, use the file to create the netcdf file */
if(sizeof(size_t) == sizeof(unsigned int))
ncstat = nc_create(tmpname,NC_CLOBBER,&drno->substrate);
else
ncstat = nc_create(tmpname,NC_CLOBBER|NC_64BIT_OFFSET,&drno->substrate);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* free the filename so it will automatically go away*/
unlink(tmpname);
nullfree(tmpname);
/* Avoid fill */
nc_set_fill(drno->substrate,NC_NOFILL,NULL);
dapcomm->oc.dapconstraint = (DCEconstraint*)dcecreate(CES_CONSTRAINT);
dapcomm->oc.dapconstraint->projections = nclistnew();
dapcomm->oc.dapconstraint->selections = nclistnew();
/* Parse constraints to make sure they are syntactically correct */
ncstat = parsedapconstraints(dapcomm,dapcomm->oc.url->constraint,dapcomm->oc.dapconstraint);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Complain if we are unconstrainable but have constraints */
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) {
if(dapcomm->oc.url->constraint != NULL
&& strlen(dapcomm->oc.url->constraint) > 0) {
nclog(NCLOGWARN,"Attempt to constrain an unconstrainable data source: %s",
dapcomm->oc.url->constraint);
}
}
/* Construct a url for oc minus any parameters */
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,
(NC_URIALL ^ NC_URICONSTRAINTS));
/* Pass to OC */
ocstat = oc_open(dapcomm->oc.urltext,&dapcomm->oc.conn);
if(ocstat != OC_NOERR) {THROWCHK(ocstat); goto done;}
nullfree(dapcomm->oc.urltext); /* clean up */
dapcomm->oc.urltext = NULL;
/* process control client parameters */
applyclientparamcontrols3(dapcomm);
/* Turn on logging; only do this after oc_open*/
if((value = paramvalue34(dapcomm,"log")) != NULL) {
ncloginit();
ncsetlogging(1);
nclogopen(value);
oc_loginit();
oc_setlogging(1);
oc_logopen(value);
}
/* fetch and build the (almost) unconstrained DDS for use as
template */
ncstat = fetchtemplatemetadata3(dapcomm);
if(ncstat != NC_NOERR) goto done;
/* fetch and build the constrained DDS */
ncstat = fetchconstrainedmetadata3(dapcomm);
if(ncstat != NC_NOERR) goto done;
#ifdef DEBUG2
fprintf(stderr,"constrained dds: %s\n",dumptree(dapcomm->cdf.ddsroot));
#endif
/* The following actions are (mostly) WRT to the constrained tree */
/* Accumulate useful nodes sets */
ncstat = computecdfnodesets3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Fix grids */
ncstat = fixgrids3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Locate and mark usable sequences */
ncstat = sequencecheck3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* suppress variables not in usable sequences */
ncstat = suppressunusablevars3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* apply client parameters */
ncstat = applyclientparams34(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Add (as needed) string dimensions*/
ncstat = addstringdims(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
if(nclistlength(dapcomm->cdf.seqnodes) > 0) {
/* Build the sequence related dimensions */
ncstat = defseqdims(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
}
/* Define the dimsetplus and dimsetall lists */
ncstat = definedimsets3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Re-compute the dimension names*/
ncstat = computecdfdimnames34(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Deal with zero size dimensions */
ncstat = fixzerodims3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Attempt to use the DODS_EXTRA info to turn
one of the dimensions into unlimited.
Assume computecdfdimnames34 has already been called.
*/
ncstat = defrecorddim3(dapcomm);
if(ncstat) {THROWCHK(ncstat); goto done;}
if(dapcomm->cdf.recorddimname != NULL
&& nclistlength(dapcomm->cdf.seqnodes) > 0) {
/*nclog(NCLOGWARN,"unlimited dimension specified, but sequences exist in DDS");*/
PANIC("unlimited dimension specified, but sequences exist in DDS");
}
/* Re-compute the var names*/
ncstat = computecdfvarnames3(dapcomm,dapcomm->cdf.ddsroot,dapcomm->cdf.varnodes);
if(ncstat) {THROWCHK(ncstat); goto done;}
/* Transfer data from the unconstrained DDS data to the unconstrained DDS */
ncstat = dimimprint3(dapcomm);
if(ncstat) goto done;
/* Process the constraints to map to the constrained CDF tree */
/* (must follow fixgrids3 */
ncstat = mapconstraints3(dapcomm->oc.dapconstraint,dapcomm->cdf.ddsroot);
if(ncstat != NC_NOERR) goto done;
/* Canonicalize the constraint */
ncstat = fixprojections(dapcomm->oc.dapconstraint->projections);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Fill in segment information */
ncstat = qualifyconstraints3(dapcomm->oc.dapconstraint);
if(ncstat != NC_NOERR) goto done;
/* using the modified constraint, rebuild the constraint string */
if(FLAGSET(dapcomm->controls,NCF_UNCONSTRAINABLE)) {
/* ignore all constraints */
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,0);
} else {
char* constraintstring = buildconstraintstring3(dapcomm->oc.dapconstraint);
nc_urisetconstraints(dapcomm->oc.url,constraintstring);
nullfree(constraintstring);
dapcomm->oc.urltext = nc_uribuild(dapcomm->oc.url,NULL,NULL,NC_URICONSTRAINTS);
}
#ifdef DEBUG
fprintf(stderr,"ncdap3: final constraint: %s\n",dapcomm->oc.url->constraint);
#endif
/* Estimate the variable sizes */
estimatevarsizes3(dapcomm);
/* Build the meta data */
ncstat = buildncstructures3(dapcomm);
if(ncstat != NC_NOERR) {THROWCHK(ncstat); goto done;}
/* Do any necessary data prefetch */
if(FLAGSET(dapcomm->controls,NCF_PREFETCH)) {
ncstat = prefetchdata3(dapcomm);
if(ncstat != NC_NOERR) {
del_from_NCList((NC*)drno); /* undefine here */
{THROWCHK(ncstat); goto done;}
}
}
{
/* Mark as no longer writable and no longer indef;
requires breaking abstraction */
NC* nc;
ncstat = NC_check_id(drno->substrate, &nc);
/* Mark as no longer writeable */
fClr(nc->nciop->ioflags, NC_WRITE);
/* Mark as no longer indef;
(do NOT use nc_enddef until diskless is working)*/
fSet(nc->flags, NC_INDEF);
}
if(ncpp) *ncpp = (NC*)drno;
return ncstat;
done:
if(drno != NULL) NCD3_abort(drno->ext_ncid);
if(ocstat != OC_NOERR) ncstat = ocerrtoncerr(ocstat);
return THROW(ncstat);
}
/* This function opens the data file. It is only called from nc.c,
from nc__open_mp and nc_delete_mp.
path - path of data file.
ioflags - flags passed into nc_open.
igeto - looks like this function can do an initial page get, and
igeto is going to be the offset for that. But it appears to be
unused
igetsz - the size in bytes of initial page get (a.k.a. extent). Not
ever used in the library.
sizehintp - the size of a page of data for buffered reads and writes.
nciopp - pointer to pointer that will get address of newly created
and inited ncio struct.
mempp - pointer to pointer to the initial memory read.
*/
int
mmapio_open(const char* path,
int ioflags,
off_t igeto, size_t igetsz, size_t* sizehintp,
void* parameters,
ncio* *nciopp, void** const mempp)
{
ncio* nciop;
int fd;
int status;
int persist = (fIsSet(ioflags,NC_WRITE)?1:0);
int oflags;
NCMMAPIO* mmapio = NULL;
size_t sizehint;
off_t filesize;
if(path == NULL ||* path == 0)
return EINVAL;
assert(sizehintp != NULL);
sizehint = *sizehintp;
/* Open the file, but make sure we can write it if needed */
oflags = (persist ? O_RDWR : O_RDONLY);
#ifdef O_BINARY
fSet(oflags, O_BINARY);
#endif
oflags |= O_EXCL;
#ifdef vms
fd = open(path, oflags, 0, "ctx=stm");
#else
fd = open(path, oflags, OPENMODE);
#endif
if(fd < 0) {status = errno; goto unwind_open;}
/* get current filesize = max(|file|,initialize)*/
filesize = lseek(fd,0,SEEK_END);
if(filesize < 0) {status = errno; goto unwind_open;}
/* move pointer back to beginning of file */
(void)lseek(fd,0,SEEK_SET);
if(filesize < (off_t)sizehint)
filesize = (off_t)sizehint;
status = mmapio_new(path, ioflags, filesize, &nciop, &mmapio);
if(status != NC_NOERR)
return status;
mmapio->size = filesize;
mmapio->mapfd = fd;
mmapio->memory = (char*)mmap(NULL,mmapio->alloc,
persist?(PROT_READ|PROT_WRITE):(PROT_READ),
MAP_SHARED,
mmapio->mapfd,0);
#ifdef DEBUG
fprintf(stderr,"mmapio_open: initial memory: %lu/%lu\n",(unsigned long)mmapio->memory,(unsigned long)mmapio->alloc);
#endif
/* Use half the filesize as the blocksize */
sizehint = filesize/2;
/* sizehint must be multiple of 8 */
sizehint = (sizehint / 8) * 8;
if(sizehint < 8) sizehint = 8;
fd = nc__pseudofd();
*((int* )&nciop->fd) = fd;
if(igetsz != 0)
{
status = nciop->get(nciop,
igeto, igetsz,
0,
mempp);
if(status != NC_NOERR)
goto unwind_open;
}
*sizehintp = sizehint;
*nciopp = nciop;
return NC_NOERR;
unwind_open:
mmapio_close(nciop,0);
return status;
}
