bool_t
xdr_gd1_mgmt_friend_req (XDR *xdrs, gd1_mgmt_friend_req *objp)
{
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
if (!xdr_string (xdrs, &objp->hostname, ~0))
return FALSE;
if (!xdr_int (xdrs, &objp->port))
return FALSE;
if (!xdr_bytes (xdrs, (char **)&objp->vols.vols_val, (u_int *) &objp->vols.vols_len, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_voter_pack (XDR *xdrs, voter_pack *objp)
{
register int32_t *buf;
int i;
if (!xdr_char (xdrs, &objp->command))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->password, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->username, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->new_password, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->cname, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_int (xdrs, &objp->voter_id))
return FALSE;
return TRUE;
}
static bool_t xdr_AudioTuningParamInd_st(
void *xdrs, struct AudioTuningParamInd_st *rsp)
{
XDR_LOG(xdrs, "AudioTuningParamInd_st");
if (xdr_UInt32(xdrs, &rsp->audioModeApp) &&
xdr_UInt32(xdrs, &rsp->audioParamType) &&
xdr_UInt32(xdrs, &rsp->length) &&
xdr_vector(xdrs, (char *)(void *)&(rsp->param[0]),
256, sizeof(Int16), (xdrproc_t)xdr_int16_t)
)
return TRUE;
else
return FALSE;
}
bool_t
xdr_gd1_mgmt_friend_update_rsp (XDR *xdrs, gd1_mgmt_friend_update_rsp *objp)
{
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
if (!xdr_int (xdrs, &objp->op))
return FALSE;
if (!xdr_int (xdrs, &objp->op_ret))
return FALSE;
if (!xdr_int (xdrs, &objp->op_errno))
return FALSE;
return TRUE;
}
bool_t
xdr_gd1_mgmt_probe_rsp (XDR *xdrs, gd1_mgmt_probe_rsp *objp)
{
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
if (!xdr_string (xdrs, &objp->hostname, ~0))
return FALSE;
if (!xdr_int (xdrs, &objp->port))
return FALSE;
if (!xdr_int (xdrs, &objp->op_ret))
return FALSE;
if (!xdr_int (xdrs, &objp->op_errno))
return FALSE;
return TRUE;
}
bool_t
smb_quota_xdr(XDR *xdrs, smb_quota_t *objp)
{
if (!xdr_vector(xdrs, (char *)objp->q_sidstr, SMB_SID_STRSZ,
sizeof (char), (xdrproc_t)xdr_char))
return (FALSE);
if (!xdr_uint32_t(xdrs, &objp->q_sidtype))
return (FALSE);
if (!xdr_uint64_t(xdrs, &objp->q_used))
return (FALSE);
if (!xdr_uint64_t(xdrs, &objp->q_thresh))
return (FALSE);
if (!xdr_uint64_t(xdrs, &objp->q_limit))
return (FALSE);
return (TRUE);
}
void sf_complexwrite (sf_complex* arr, size_t size, sf_file file)
/*< write a complex array arr[size] to file >*/
{
char* buf;
size_t i, left, nbuf, bufsiz;
sf_complex c;
if (NULL != file->dataname) sf_fileflush (file,infiles[0]);
switch(file->form) {
case SF_ASCII:
for (left = size; left > 0; left-=nbuf) {
nbuf = (aline < left)? aline: left;
for (i=size-left; i < size-left+nbuf; i++) {
c = arr[i];
if (EOF==fprintf(file->stream,
(NULL != aformat)?
aformat:"%g %gi ",
crealf(c),cimagf(c)))
sf_error ("%s: trouble writing ascii",__FILE__);
}
if (EOF==fprintf(file->stream,"\n"))
sf_error ("%s: trouble writing ascii",__FILE__);
}
break;
case SF_XDR:
size *= sizeof(sf_complex);
buf = (char*)arr+size;
bufsiz = sf_bufsiz(file);
for (left = size; left > 0; left -= nbuf) {
nbuf = (bufsiz < left)? bufsiz : left;
(void) xdr_setpos(&(file->xdr),0);
if (!xdr_vector(&(file->xdr),buf-left,
nbuf/sizeof(float),sizeof(float),
(xdrproc_t) xdr_float))
sf_error ("sf_file: trouble writing xdr");
fwrite(file->buf,1,nbuf,file->stream);
}
break;
default:
fwrite(arr,sizeof(sf_complex),size,file->stream);
break;
}
}
static
int dataread(struct insegyinfo *iptr, segy *tp, cwp_Bool fixed_length)
{
unsigned int nsread = fixed_length?iptr->nsfirst:tp->ns;
unsigned int databytes = infoptr->bytesper*nsread;
int nread;
int itest = 1;
char *ctest = (char *) (&itest);
/* read trace data */
switch(tp->trid) {
case CHARPACK:
nread = efread((char *) (&((tp->data)[0])),1,databytes,
iptr->infp);
case SHORTPACK:
nread = efread((char *) (&((tp->data)[0])),1,databytes,
iptr->infp);
if(ctest[0]) swab((char *) (&((tp->data)[0])),
(char *) (&((tp->data)[0])),
databytes);
break;
default:
nread = efread(((char *) (iptr->buf))+HDRBYTES,1,databytes,
iptr->infp);
if(nread != databytes || FALSE == xdr_vector(iptr->segy_xdr,
(char *) (&((tp->data)[0])),
nsread,sizeof(float),(xdrproc_t) xdr_float))
nread = 0;
else
nread = databytes;
break;
}
if(nread > 0 && nread != databytes)
err("%s: on trace #%ld, tried to read %d bytes, "
"read %d bytes",
__FILE__, (infoptr->itr)+1, databytes, nread);
return(nread);
}
bool_t
xdr_spp_profiler_t (XDR *xdrs, spp_profiler_t *objp)
{
//register int32_t *buf;
//int i;
if (!xdr_uint64_t (xdrs, &objp->uptime))
return FALSE;
if (!xdr_uint64_t (xdrs, &objp->now))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->vers, 20,
sizeof (uint8_t), (xdrproc_t) xdr_uint8_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->stat, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->ports, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->remove, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->truncate, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_uint16_t (xdrs, &objp->nb_io_processes))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->io_process_ports, 32,
sizeof (uint16_t), (xdrproc_t) xdr_uint16_t))
return FALSE;
return TRUE;
}
bool_t
xdr_netconfig(XDR *xdrs, struct netconfig *objp)
{
if (!xdr_string(xdrs, &objp->nc_netid, ~0))
return (FALSE);
if (!xdr_u_int(xdrs, &objp->nc_semantics))
return (FALSE);
if (!xdr_u_int(xdrs, &objp->nc_flag))
return (FALSE);
if (!xdr_string(xdrs, &objp->nc_protofmly, ~0))
return (FALSE);
if (!xdr_string(xdrs, &objp->nc_proto, ~0))
return (FALSE);
if (!xdr_string(xdrs, &objp->nc_device, ~0))
return (FALSE);
if (!xdr_array(xdrs, (char **)&objp->nc_lookups,
(uint_t *)&objp->nc_nlookups, 100, sizeof (char *),
xdr_wrapstring))
return (FALSE);
return ((bool)xdr_vector(xdrs, (char *)objp->nc_unused,
8, sizeof (uint_t), xdr_u_int));
}
void sf_complexread (/*@out@*/ sf_complex* arr, size_t size, sf_file file)
/*< read a complex array arr[size] from file >*/
{
char* buf;
size_t i, left, nbuf, got, bufsiz;
float re, im;
switch (file->form) {
case SF_ASCII:
for (i = 0; i < size; i++) {
if (EOF==fscanf(file->stream,"%g %gi",&re,&im))
sf_error ("%s: trouble reading ascii:",__FILE__);
arr[i]=sf_cmplx(re,im);
}
break;
case SF_XDR:
size *= sizeof(sf_complex);
buf = (char*)arr+size;
bufsiz = sf_bufsiz(file);
for (left = size; left > 0; left -= nbuf) {
nbuf = (bufsiz < left)? bufsiz : left;
(void) xdr_setpos(&(file->xdr),0);
if (nbuf != fread(file->buf,1,nbuf,file->stream))
sf_error ("%s: trouble reading:",__FILE__);
if (!xdr_vector(&(file->xdr),buf-left,
nbuf/sizeof(float),sizeof(float),
(xdrproc_t) xdr_float))
sf_error ("%s: trouble reading xdr",__FILE__);
}
break;
default:
got = fread(arr,sizeof(sf_complex),size,file->stream);
if (got != size)
sf_error ("%s: trouble reading: %lu of %lu",__FILE__,got,size);
break;
}
}
static
int datawrite(struct outsegyinfo *iptr, segy *tp, cwp_Bool fixed_length)
{
int nwritten;
unsigned int nstobewritten = fixed_length?iptr->nsfirst:tp->ns;
unsigned int databytes = iptr->bytesper*nstobewritten;
int itest = 1;
char *ctest = (char *) (&itest);
/* write trace data */
switch(tp->trid) {
case CHARPACK:
nwritten = efwrite((char *) (&((tp->data)[0])),1,databytes,
iptr->outfp);
case SHORTPACK:
if(ctest[0]) swab((char *) (&((tp->data)[0])),
(char *) (&((tp->data)[0])),
databytes);
nwritten = efwrite((char *) (&((tp->data)[0])),1,databytes,
iptr->outfp);
break;
default:
if(FALSE == xdr_vector(iptr->segy_xdr,
(char *) (&((tp->data)[0])),
nstobewritten,sizeof(float),(xdrproc_t) xdr_float))
nwritten = 0;
else
nwritten = databytes;
if(nwritten > 0) nwritten =
efwrite(((char *) (iptr->buf))+HDRBYTES,1,databytes,iptr->outfp);
if(nwritten != databytes) nwritten = 0;
}
return(nwritten);
}
int
xdr_afsUUID(XDR * xdrs, afsUUID * objp)
{
if (!xdr_afs_uint32(xdrs, &objp->time_low)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &objp->time_mid)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &objp->time_hi_and_version)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->clock_seq_hi_and_reserved)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->clock_seq_low)) {
return (FALSE);
}
/* Cast needed here because xdrproc_t officially takes 3 args :-( */
if (!xdr_vector(xdrs, (char *)objp->node, 6, sizeof(char), (xdrproc_t)xdr_char)) {
return (FALSE);
}
return (TRUE);
}
static bool_t xdr_UlCompfilter_t(void *xdrs, EQUlCompfilter_t *rsp)
{
aTrace(LOG_AUDIO_DRIVER, "EQUlCompfilter_t");
if (xdr_vector(xdrs, (char *)(void *)&(rsp->ul_coef_fw_8k), 12 * 3,
sizeof(Int32), (xdrproc_t) xdr_Int32) &&
xdr_vector(xdrs, (char *)(void *)&(rsp->ul_coef_bw_8k), 12 * 2,
sizeof(Int32), (xdrproc_t) xdr_Int32) &&
xdr_vector(xdrs, (char *)(void *)&(rsp->ul_comp_filter_gain_8k),
12, sizeof(Int16), (xdrproc_t) xdr_int16_t)
&& xdr_Int32(xdrs, &rsp->ul_output_bit_select_8k)
&& xdr_vector(xdrs, (char *)(void *)&(rsp->ul_coef_fw_16k),
12 * 3, sizeof(Int32), (xdrproc_t) xdr_Int32)
&& xdr_vector(xdrs, (char *)(void *)&(rsp->ul_coef_bw_16k),
12 * 2, sizeof(Int32), (xdrproc_t) xdr_Int32)
&& xdr_vector(xdrs,
(char *)(void *)&(rsp->ul_comp_filter_gain_16k),
12, sizeof(Int16), (xdrproc_t) xdr_int16_t)
&& xdr_UInt16(xdrs, &rsp->ul_nstage_filter) && 1)
return TRUE;
else
return FALSE;
}
bool_t
xdr_gd1_mgmt_commit_op_rsp (XDR *xdrs, gd1_mgmt_commit_op_rsp *objp)
{
register int32_t *buf;
if (xdrs->x_op == XDR_ENCODE) {
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->op))
return FALSE;
if (!xdr_int (xdrs, &objp->op_ret))
return FALSE;
if (!xdr_int (xdrs, &objp->op_errno))
return FALSE;
} else {
IXDR_PUT_LONG(buf, objp->op);
IXDR_PUT_LONG(buf, objp->op_ret);
IXDR_PUT_LONG(buf, objp->op_errno);
}
if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0))
return FALSE;
if (!xdr_string (xdrs, &objp->op_errstr, ~0))
return FALSE;
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->op))
return FALSE;
if (!xdr_int (xdrs, &objp->op_ret))
return FALSE;
if (!xdr_int (xdrs, &objp->op_errno))
return FALSE;
} else {
objp->op = IXDR_GET_LONG(buf);
objp->op_ret = IXDR_GET_LONG(buf);
objp->op_errno = IXDR_GET_LONG(buf);
}
if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0))
return FALSE;
if (!xdr_string (xdrs, &objp->op_errstr, ~0))
return FALSE;
return TRUE;
}
if (!xdr_vector (xdrs, (char *)objp->uuid, 16,
sizeof (u_char), (xdrproc_t) xdr_u_char))
return FALSE;
if (!xdr_int (xdrs, &objp->op))
return FALSE;
if (!xdr_int (xdrs, &objp->op_ret))
return FALSE;
if (!xdr_int (xdrs, &objp->op_errno))
return FALSE;
if (!xdr_bytes (xdrs, (char **)&objp->dict.dict_val, (u_int *) &objp->dict.dict_len, ~0))
return FALSE;
if (!xdr_string (xdrs, &objp->op_errstr, ~0))
return FALSE;
return TRUE;
}
/* write fracture state */
static void fracture_state_write (DOM *dom)
{
char path [1024];
double R[3], r, (*disp) [3];
int i, n, dofs;
MESH *msh;
SET *item;
BODY *bod;
CON *con;
#if HDF5
int numbod;
PBF *f;
snprintf (path, 1024, "%s/fracture", dom->solfec->outpath);
ASSERT (f = PBF_Write (path, PBF_ON, PBF_ON), ERR_FILE_OPEN);
PBF_Time (f, &dom->time);
for (numbod = 0, bod = dom->bod; bod; bod = bod->next)
{
if (bod->fracture)
{
msh = bod->shape->data;
dofs = 3 * msh->nodes_count;
ERRMEM (disp = malloc (msh->nodes_count * sizeof (double [3])));
for (i = 0; i < msh->nodes_count; i ++)
{
SUB (msh->cur_nodes [i], msh->ref_nodes [i], disp [i]);
}
PBF_Uint (f, &bod->id, 1);
PBF_Int (f, &dofs, 1);
PBF_Double (f, (double*)disp, dofs);
n = SET_Size (bod->con);
PBF_Int (f, &n, 1);
for (item = SET_First (bod->con); item; item = SET_Next (item))
{
con = item->data;
r = sqrt (con->area/ALG_PI);
PBF_Double (f, &r, 1);
if (bod == con->master)
{
PBF_Double (f, con->mpnt, 3);
}
else
{
PBF_Double (f, con->spnt, 3);
}
NVMUL (con->base, con->R, R);
PBF_Double (f, R, 3);
}
bod->fracture = 0;
free (disp);
numbod ++;
}
PBF_Int2 (f, "numbod", &numbod, 1);
}
PBF_Close (f);
#else
FILE *f;
XDR x;
#if MPI
snprintf (path, 1024, "%s/fracture%d.dat", dom->solfec->outpath, dom->rank);
#else
snprintf (path, 1024, "%s/fracture.dat", dom->solfec->outpath);
#endif
ASSERT (f = fopen (path, "a"), ERR_FILE_OPEN);
xdrstdio_create (&x, f, XDR_ENCODE);
for (bod = dom->bod; bod; bod = bod->next)
{
if (bod->fracture)
{
msh = bod->shape->data;
dofs = 3 * msh->nodes_count;
ERRMEM (disp = malloc (msh->nodes_count * sizeof (double [3])));
for (i = 0; i < msh->nodes_count; i ++)
{
SUB (msh->cur_nodes [i], msh->ref_nodes [i], disp [i]);
}
ASSERT (xdr_u_int (&x, &bod->id), ERR_FILE_WRITE);
ASSERT (xdr_int (&x, &dofs), ERR_FILE_WRITE);
ASSERT (xdr_vector (&x, (char*)disp, dofs, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_WRITE);
n = SET_Size (bod->con);
ASSERT (xdr_int (&x, &n), ERR_FILE_WRITE);
for (item = SET_First (bod->con); item; item = SET_Next (item))
{
con = item->data;
r = sqrt (con->area/ALG_PI);
ASSERT (xdr_double (&x, &r), ERR_FILE_WRITE);
if (bod == con->master)
{
ASSERT (xdr_vector (&x, (char*)con->mpnt, 3, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_WRITE);
}
else
{
ASSERT (xdr_vector (&x, (char*)con->spnt, 3, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_WRITE);
}
NVMUL (con->base, con->R, R);
ASSERT (xdr_vector (&x, (char*)R, 3, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_WRITE);
}
bod->fracture = 0;
free (disp);
}
}
xdr_destroy (&x);
fclose (f);
#endif
}
/* read fracture state */
FS* fracture_state_read (BODY *bod)
{
FS *out = NULL, *item, *instance;
char path [1024];
unsigned int id;
int i, n, dofs;
double *disp;
#if HDF5
PBF *f, *g;
snprintf (path, 1024, "%s/fracture", bod->dom->solfec->outpath);
g = PBF_Read (path);
do
{
double time;
PBF_Time (g, &time); /* unused, but could be useful at some point */
for (f = g; f; f = f->next)
{
int numbod;
PBF_Int2 (f, "numbod", &numbod, 1);
while (numbod > 0)
{
PBF_Uint (f, &id, 1);
PBF_Int (f, &dofs, 1);
ERRMEM (disp = malloc (dofs * sizeof (double)));
PBF_Double (f, disp, dofs);
PBF_Int (f, &n, 1);
for (i = 0, instance = NULL; i < n; i ++)
{
ERRMEM (item = MEM_CALLOC (sizeof (FS)));
PBF_Double (f, &item->radius, 1);
PBF_Double (f, item->point, 3);
PBF_Double (f, item->force, 3);
if (id == bod->id)
{
item->inext = instance;
instance = item;
if (i == (n-1))
{
item->disp = disp; /* put displacements into first element of instance list */
item->next = out;
out = item;
}
}
else free (item);
}
if (!out || out->disp != disp) free (disp); /* not used */
numbod --;
}
}
} while (PBF_Forward (g, 1));
PBF_Close (g);
#else
FILE *f;
XDR x;
snprintf (path, 1024, "%s/fracture.dat", bod->dom->solfec->outpath);
f = fopen (path, "r");
/* TODO: read MPI mode data in case f == NULL but fractureRANK.dat exit */
if (f)
{
xdrstdio_create (&x, f, XDR_DECODE);
while (! feof (f))
{
if (xdr_u_int (&x, &id) == 0) break;
ASSERT (xdr_int (&x, &dofs), ERR_FILE_READ);
ERRMEM (disp = malloc (dofs * sizeof (double)));
ASSERT (xdr_vector (&x, (char*)disp, dofs, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_READ);
ASSERT (xdr_int (&x, &n), ERR_FILE_READ);
for (i = 0, instance = NULL; i < n; i ++)
{
ERRMEM (item = MEM_CALLOC (sizeof (FS)));
ASSERT (xdr_double (&x, &item->radius), ERR_FILE_READ);
ASSERT (xdr_vector (&x, (char*)item->point, 3, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_READ);
ASSERT (xdr_vector (&x, (char*)item->force, 3, sizeof (double), (xdrproc_t)xdr_double), ERR_FILE_READ);
if (id == bod->id)
{
item->inext = instance;
instance = item;
if (i == (n-1))
{
item->disp = disp; /* put displacements into first element of instance list */
item->next = out;
out = item;
}
}
else free (item);
}
if (!out || out->disp != disp) free (disp); /* not used */
}
xdr_destroy (&x);
fclose (f);
}
#endif
return out;
}
int main(int argc, char *argv[])
{
register int n, k;
char rayFileName[14], inputLine[MAX_LINE_SIZE];
bool_t result, exit_on_EOF, to_obs, initialize, crosscoupling,
analyze_output, equilibria_only;
int Nspect, Nread, Nrequired, checkPoint, *wave_index = NULL;
double muz, *S, *chi, *J;
FILE *fp_out, *fp_ray, *fp_stokes;
XDR xdrs;
ActiveSet *as;
setOptions(argc, argv);
getCPU(0, TIME_START, NULL);
SetFPEtraps();
/* --- Read input data and initialize -- -------------- */
readInput();
spectrum.updateJ = FALSE;
/* --- Read input data for atmosphere -- -------------- */
getCPU(1, TIME_START, NULL);
MULTIatmos(&atmos, &geometry);
/* --- Read direction cosine for ray -- -------------- */
if ((fp_ray = fopen(RAY_INPUT_FILE, "r")) == NULL) {
sprintf(messageStr, "Unable to open inputfile %s", RAY_INPUT_FILE);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
getLine(fp_ray, COMMENT_CHAR, inputLine, exit_on_EOF=TRUE);
Nread = sscanf(inputLine, "%lf", &muz);
checkNread(Nread, Nrequired=1, argv[0], checkPoint=1);
if (muz <= 0.0 || muz > 1.0) {
sprintf(messageStr,
"Value of muz = %f does not lie in interval <0.0, 1.0]\n", muz);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
if (input.StokesMode == FIELD_FREE ||
input.StokesMode == POLARIZATION_FREE) {
input.StokesMode = FULL_STOKES;
}
/* --- redefine geometry for just this one ray -- -------------- */
atmos.Nrays = geometry.Nrays = 1;
geometry.muz[0] = muz;
geometry.mux[0] = sqrt(1.0 - SQ(geometry.muz[0]));
geometry.muy[0] = 0.0;
geometry.wmu[0] = 1.0;
if (atmos.Stokes) Bproject();
input.startJ = OLD_J;
readAtomicModels();
readMolecularModels();
SortLambda();
getBoundary(&geometry);
/* --- Open file with background opacities -- -------------- */
if (atmos.moving || input.StokesMode) {
strcpy(input.background_File, "background.ray");
Background(analyze_output=FALSE, equilibria_only=FALSE);
} else {
Background(analyze_output=FALSE, equilibria_only=TRUE);
if ((atmos.fd_background =
open(input.background_File, O_RDONLY, 0)) == -1) {
sprintf(messageStr, "Unable to open inputfile %s",
input.background_File);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
readBRS();
}
convertScales(&atmos, &geometry);
getProfiles();
initSolution();
initScatter();
getCPU(1, TIME_POLL, "Total initialize");
/* --- Solve radiative transfer equations -- -------------- */
solveSpectrum(FALSE, FALSE);
/* --- Write emergent spectrum to output file -- -------------- */
sprintf(rayFileName, "spectrum_%4.2f", muz);
if ((fp_out = fopen(rayFileName, "w" )) == NULL) {
sprintf(messageStr, "Unable to open output file %s", rayFileName);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);
result = xdr_double(&xdrs, &muz);
result = xdr_vector(&xdrs, (char *) spectrum.I[0], spectrum.Nspect,
sizeof(double), (xdrproc_t) xdr_double);
/* --- Read wavelength indices for which chi and S are to be
written out for the specified direction -- -------------- */
Nread = fscanf(fp_ray, "%d", &Nspect);
checkNread(Nread, 1, argv[0], checkPoint=2);
if (Nspect > 0) {
wave_index = (int *) malloc(Nspect * sizeof(int));
Nread = 0;
while (fscanf(fp_ray, "%d", &wave_index[Nread]) != EOF) Nread++;
checkNread(Nread, Nspect, argv[0], checkPoint=3);
fclose(fp_ray);
chi = (double *) malloc(atmos.Nspace * sizeof(double));
if (atmos.Stokes)
S = (double *) malloc(4 * atmos.Nspace * sizeof(double));
else
S = (double *) malloc(atmos.Nspace * sizeof(double));
}
result = xdr_int(&xdrs, &Nspect);
/* --- Go through the list of wavelengths -- -------------- */
if (Nspect > 0 && input.limit_memory)
J = (double *) malloc(atmos.Nspace * sizeof(double));
for (n = 0; n < Nspect; n++) {
if (wave_index[n] < 0 || wave_index[n] >= spectrum.Nspect) {
sprintf(messageStr, "Illegal value of wave_index[n]: %4d\n"
"Value has to be between 0 and %4d\n",
wave_index[n], spectrum.Nspect);
Error(ERROR_LEVEL_2, argv[0], messageStr);
continue;
}
sprintf(messageStr, "Processing n = %4d, lambda = %9.3f [nm]\n",
wave_index[n], spectrum.lambda[wave_index[n]]);
Error(MESSAGE, NULL, messageStr);
as = &spectrum.as[wave_index[n]];
alloc_as(wave_index[n], crosscoupling=FALSE);
Opacity(wave_index[n], 0, to_obs=TRUE, initialize=TRUE);
readBackground(wave_index[n], 0, to_obs=TRUE);
if (input.limit_memory) {
readJlambda(wave_index[n], J);
} else
J = spectrum.J[wave_index[n]];
/* --- Add the continuum opacity and emissivity -- -------------- */
for (k = 0; k < atmos.Nspace; k++) {
chi[k] = as->chi[k] + as->chi_c[k];
S[k] = (as->eta[k] + as->eta_c[k] + as->sca_c[k]*J[k]) / chi[k];
}
result = xdr_int(&xdrs, &wave_index[n]);
result = xdr_vector(&xdrs, (char *) chi, atmos.Nspace,
sizeof(double), (xdrproc_t) xdr_double);
result = xdr_vector(&xdrs, (char *) S, atmos.Nspace,
sizeof(double), (xdrproc_t) xdr_double);
free_as(wave_index[n], crosscoupling=FALSE);
}
/* --- If magnetic fields are present -- -------------- */
if (atmos.Stokes || input.backgr_pol) {
result = xdr_vector(&xdrs, (char *) spectrum.Stokes_Q[0],
spectrum.Nspect, sizeof(double),
(xdrproc_t) xdr_double);
result = xdr_vector(&xdrs, (char *) spectrum.Stokes_U[0],
spectrum.Nspect, sizeof(double),
(xdrproc_t) xdr_double);
result = xdr_vector(&xdrs, (char *) spectrum.Stokes_V[0],
spectrum.Nspect, sizeof(double),
(xdrproc_t) xdr_double);
}
if (Nspect > 0 && input.limit_memory)
free(J);
xdr_destroy(&xdrs);
fclose(fp_out);
printTotalCPU();
}
void kdReadTipsy(KD kd,FILE *fp,int bDark,int bGas,int bStar,int bStandard)
{
int i,j,nCnt;
struct dump h;
struct gas_particle gp;
struct dark_particle dp;
struct star_particle sp;
XDR xdrs;
if (bStandard) {
assert(sizeof(Real)==sizeof(float)); /* Otherwise, this XDR stuff
ain't gonna work */
xdrstdio_create(&xdrs, fp, XDR_DECODE);
xdrHeader(&xdrs,&h);
} else {
fread(&h,sizeof(struct dump),1,fp);
}
kd->nParticles = h.nbodies;
kd->nDark = h.ndark;
kd->nGas = h.nsph;
kd->nStar = h.nstar;
kd->fTime = h.time;
kd->nActive = 0;
if (bDark) kd->nActive += kd->nDark;
if (bGas) kd->nActive += kd->nGas;
if (bStar) kd->nActive += kd->nStar;
kd->bDark = bDark;
kd->bGas = bGas;
kd->bStar = bStar;
/*
** Allocate particles.
*/
kd->p = (PARTICLE *)malloc(kd->nActive*sizeof(PARTICLE));
assert(kd->p != NULL);
/*
** Read Stuff!
*/
nCnt = 0;
for (i=0;i<h.nsph;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &gp,
sizeof(struct gas_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&gp,sizeof(struct gas_particle),1,fp);
}
if (bGas) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = gp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = gp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = gp.vel[j];
++nCnt;
}
}
for (i=0;i<h.ndark;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &dp,
sizeof(struct dark_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&dp,sizeof(struct dark_particle),1,fp);
}
if (bDark) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = dp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = dp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = dp.vel[j];
++nCnt;
}
}
for (i=0;i<h.nstar;++i) {
if (bStandard) {
xdr_vector(&xdrs, (char *) &sp,
sizeof(struct star_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
} else {
fread(&sp,sizeof(struct star_particle),1,fp);
}
if (bStar) {
kd->p[nCnt].iOrder = nCnt;
kd->p[nCnt].fMass = sp.mass;
for (j=0;j<3;++j) kd->p[nCnt].r[j] = sp.pos[j];
for (j=0;j<3;++j) kd->p[nCnt].v[j] = sp.vel[j];
++nCnt;
}
}
if (bStandard) xdr_destroy(&xdrs);
}
bool_t
xdr_stcpp_profiler_t (XDR *xdrs, stcpp_profiler_t *objp)
{
//register int32_t *buf;
//int i;
if (!xdr_uint64_t (xdrs, &objp->uptime))
return FALSE;
if (!xdr_uint64_t (xdrs, &objp->now))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->vers, 20,
sizeof (uint8_t), (xdrproc_t) xdr_uint8_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->stat, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->ports, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->remove, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read_req, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->trans_inv, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write_req, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->trans_forward, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->truncate, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->truncate_prj, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->truncate_prj_tmo, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->truncate_prj_err, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read_prj, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write_prj, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read_prj_tmo, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read_prj_err, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->read_prj_enoent, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write_prj_tmo, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->write_prj_err, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->io_process_ports, 32,
sizeof (uint16_t), (xdrproc_t) xdr_uint16_t))
return FALSE;
return TRUE;
}
void kdOutGTP(KD kd,char *pszFile,int bStandard)
{
FILE *fp;
GROUP_STAT *grp;
int pi,i,j;
struct dump h;
struct star_particle sp;
double d,d2;
XDR xdrs;
fp = fopen(pszFile,"w");
assert(fp != NULL);
grp = malloc(kd->nGroup*sizeof(GROUP_STAT));
assert(grp != NULL);
for (i=1;i<kd->nGroup;++i) {
for (j=0;j<3;++j) grp[i].r[j] = 0.0;
for (j=0;j<3;++j) grp[i].v[j] = 0.0;
grp[i].m = 0.0;
grp[i].rm = 0.0;
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
for (j=0;j<3;++j) {
grp[i].rel[j] = kd->p[pi].r[j];
}
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
grp[i].m += kd->p[pi].fMass;
for (j=0;j<3;++j) {
d = kd->p[pi].r[j] - grp[i].rel[j];
if (d > 0.5*kd->fPeriod[j]) d -= kd->fPeriod[j];
if (d <= -0.5*kd->fPeriod[j]) d += kd->fPeriod[j];
grp[i].r[j] += kd->p[pi].fMass*d;
}
for (j=0;j<3;++j) grp[i].v[j] += kd->p[pi].fMass*kd->p[pi].v[j];
}
for (i=1;i<kd->nGroup;++i) {
for (j=0;j<3;++j) {
grp[i].r[j] /= grp[i].m;
grp[i].r[j] += grp[i].rel[j];
if (grp[i].r[j] > kd->fCenter[j]+0.5*kd->fPeriod[j])
grp[i].r[j] -= kd->fPeriod[j];
if (grp[i].r[j] <= kd->fCenter[j]-0.5*kd->fPeriod[j])
grp[i].r[j] += kd->fPeriod[j];
}
for (j=0;j<3;++j) grp[i].v[j] /= grp[i].m;
}
for (pi=0;pi<kd->nActive;++pi) {
i = kd->p[pi].iGroup;
if (!i) continue;
d2 = 0.0;
for (j=0;j<3;++j) {
d = kd->p[pi].r[j] - grp[i].r[j];
if (d > 0.5*kd->fPeriod[j]) d -= kd->fPeriod[j];
if (d <= -0.5*kd->fPeriod[j]) d += kd->fPeriod[j];
d2 += d*d;
}
if (d2 > grp[i].rm) grp[i].rm = d2;
}
h.time = kd->fTime;
h.nbodies = kd->nGroup-1;
h.nsph = 0;
h.ndark = 0;
h.nstar = h.nbodies;
h.ndim = 3;
if (bStandard) {
assert(sizeof(Real)==sizeof(float)); /* Else this XDR stuff
ain't gonna work */
xdrstdio_create(&xdrs, fp, XDR_ENCODE);
xdrHeader(&xdrs,&h);
}
else {
fwrite(&h,sizeof(struct dump),1,fp);
}
for (i=1;i<kd->nGroup;++i) {
sp.mass = grp[i].m;
for (j=0;j<3;++j) sp.pos[j] = grp[i].r[j];
for (j=0;j<3;++j) sp.vel[j] = grp[i].v[j];
sp.eps = sqrt(grp[i].rm);
sp.tform = kd->fTime;
sp.metals = 0.0;
sp.phi = 0.0;
if (bStandard) {
xdr_vector(&xdrs, (char *) &sp,
sizeof(struct star_particle)/sizeof(Real),
sizeof(Real), (xdrproc_t)xdr_float);
}
else {
fwrite(&sp,sizeof(struct star_particle),1,fp);
}
}
if (bStandard) xdr_destroy(&xdrs);
free(grp);
fclose(fp);
}
void writeOpacity(void)
{
const char routineName[] = "writeOpacity";
register int nspect, mu;
bool_t to_obs, initialize, crosscoupling, boundbound, polarized,
PRD_angle_dep, result = TRUE;
long Nspace = atmos.Nspace;
int record, *as_rn, Nrecord;
FILE *fp_out;
XDR xdrs;
ActiveSet *as;
if (!strcmp(input.opac_output, "none")) return;
if ((fp_out = fopen(input.opac_output, "w")) == NULL) {
sprintf(messageStr, "Unable to open output file %s",
input.opac_output);
Error(ERROR_LEVEL_1, routineName, messageStr);
return;
}
xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);
if (atmos.moving || atmos.Stokes ||
(atmos.NPRDactive > 0 && input.PRD_angle_dep == PRD_ANGLE_DEP))
Nrecord = atmos.Nrays*spectrum.Nspect;
else
Nrecord = spectrum.Nspect;
as_rn = (int *) malloc(Nrecord * sizeof(int));
record = -1;
for (nspect = 0; nspect < spectrum.Nspect; nspect++) {
as = &spectrum.as[nspect];
if (containsActive(as)) {
alloc_as(nspect, crosscoupling=FALSE);
/* --- Check whether current active set includes a bound-bound
and/or polarized transition and/or angledependent PRD
transition. Otherwise, only angle-independent opacity and
source functions are needed -- -------------- */
boundbound = containsBoundBound(as);
PRD_angle_dep = (containsPRDline(as) && input.PRD_angle_dep != PRD_ANGLE_INDEP);
polarized = containsPolarized(as);
/* --- Case of angle-dependent opacity and source function -- - */
if (polarized || PRD_angle_dep || (atmos.moving && boundbound)) {
for (mu = 0; mu < atmos.Nrays; mu++) {
initialize = (mu == 0);
Opacity(nspect, mu, to_obs=TRUE, initialize);
result &= xdr_vector(&xdrs, (char *) as->chi, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
result &= xdr_vector(&xdrs, (char *) as->eta, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
as_rn[nspect*atmos.Nrays + mu] = ++record;
}
} else {
Opacity(nspect, 0, to_obs=TRUE, initialize=TRUE);
result &= xdr_vector(&xdrs, (char *) as->chi, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
result &= xdr_vector(&xdrs, (char *) as->eta, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
if (atmos.moving || atmos.Stokes ||
(atmos.NPRDactive > 0 && input.PRD_angle_dep == PRD_ANGLE_DEP)) {
record++;
for (mu = 0; mu < atmos.Nrays; mu++)
as_rn[nspect*atmos.Nrays + mu] = record;
} else
as_rn[nspect] = ++record;
}
free_as(nspect, crosscoupling=FALSE);
} else {
if (atmos.moving || atmos.Stokes ||
(atmos.NPRDactive > 0 && input.PRD_angle_dep != PRD_ANGLE_INDEP))
for (mu = 0; mu < atmos.Nrays; mu++)
as_rn[nspect*atmos.Nrays + mu] = -1;
else
as_rn[nspect] = -1;
}
}
xdr_destroy(&xdrs);
fclose(fp_out);
if ((fp_out = fopen(ASRS_DOT_OUT, "w")) == NULL) {
sprintf(messageStr, "Unable to open output file %s", ASRS_DOT_OUT);
Error(ERROR_LEVEL_1, routineName, messageStr);
return;
}
xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);
result &= xdr_vector(&xdrs, (char *) as_rn, Nrecord,
sizeof(int), (xdrproc_t) xdr_int);
free(as_rn);
xdr_destroy(&xdrs);
fclose(fp_out);
}
bool_t
xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp)
{
register int32_t *buf;
int i;
if (xdrs->x_op == XDR_ENCODE) {
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
} else {
IXDR_PUT_U_LONG(buf, objp->pid);
IXDR_PUT_U_LONG(buf, objp->uid);
IXDR_PUT_U_LONG(buf, objp->gid);
IXDR_PUT_U_LONG(buf, objp->ngrps);
{
register u_int *genp;
for (i = 0, genp = objp->groups;
i < 16; ++i) {
IXDR_PUT_U_LONG(buf, *genp++);
}
}
}
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
} else {
objp->pid = IXDR_GET_U_LONG(buf);
objp->uid = IXDR_GET_U_LONG(buf);
objp->gid = IXDR_GET_U_LONG(buf);
objp->ngrps = IXDR_GET_U_LONG(buf);
{
register u_int *genp;
for (i = 0, genp = objp->groups;
i < 16; ++i) {
*genp++ = IXDR_GET_U_LONG(buf);
}
}
}
return TRUE;
}
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
return TRUE;
}
void mda_dump_extra( XDR *xdrs)
{
enum PV_TYPES { DBR_STRING=0, DBR_CTRL_CHAR=32, DBR_CTRL_SHORT=29,
DBR_CTRL_LONG=33, DBR_CTRL_FLOAT=30, DBR_CTRL_DOUBLE=34 };
int i, j;
short int pvs, type, count;
count = 0;
print( "\n\nExtra PV Offset = %li", xdr_getpos( xdrs) );
pvs = si_print( xdrs, "\n\nNumber of Extra PV's = %i.\n");
if( pvs < 0)
{
fflush(stdout);
exit(1);
}
for( i = 0 ; i < pvs; i++)
{
print( "\nExtra PV #%i:\n", i+1);
cs_print( xdrs, " Name = %s\n");
cs_print( xdrs, " Description = %s\n");
if( !xdr_short(xdrs, &type) )
return;
if( (type != DBR_STRING) && (type != DBR_CTRL_CHAR) &&
(type != DBR_CTRL_SHORT) && (type != DBR_CTRL_LONG) &&
(type != DBR_CTRL_FLOAT) && (type != DBR_CTRL_DOUBLE))
{
print( " Type = %i (UNKNOWN)\n", type);
print( "\nExiting......\n");
exit(2);
}
if( type != DBR_STRING)
{
count = si_print( xdrs, " Count = %i\n");
cs_print( xdrs, " Unit = %s\n");
}
switch(type)
{
case DBR_STRING:
print( " Type = %i (DBR_STRING)\n", type);
cs_print( xdrs, " Value = \"%s\"\n");
break;
case DBR_CTRL_CHAR:
{
unsigned int size, maxsize;
char *bytes;
print( " Type = %i (DBR_CTRL_CHAR)\n", type);
print( " Value%s = ", (count == 1) ? "" : "s");
maxsize = count;
if( !xdr_bytes( xdrs, &(bytes), &size, maxsize ) )
return;
count = size;
for( j = 0; j < count; j++)
{
if( j)
print( ", ");
print( "%i", bytes[j]);
}
print( "\n");
}
break;
case DBR_CTRL_SHORT:
{
short int *shorts;
print( " Type = %i (DBR_CTRL_SHORT\n", type);
print( " Value%s = ", (count == 1) ? "" : "s");
shorts = (short int *) malloc( count * sizeof(short));
if( !xdr_vector( xdrs, (char *) shorts, count,
sizeof( short), (xdrproc_t) xdr_short))
return;
for( j = 0; j < count; j++)
{
if( j)
print( ", ");
print( "%i", shorts[j]);
}
print( "\n");
free (shorts);
}
break;
case DBR_CTRL_LONG:
{
long int *longs;
print( " Type = %i (DBR_CTRL_LONG)\n", type);
print( " Value%s = ", (count == 1) ? "" : "s");
longs = (long int *) malloc( count * sizeof(long));
if( !xdr_vector( xdrs, (char *) longs, count,
sizeof( long), (xdrproc_t) xdr_long))
return ;
for( j = 0; j < count; j++)
{
if( j)
print( ", ");
print( "%li", longs[j]);
}
print( "\n");
free( longs);
}
break;
case DBR_CTRL_FLOAT:
{
float *floats;
print( " Type = %i (DBR_CTRL_FLOAT)\n", type);
print( " Value%s = ", (count == 1) ? "" : "s");
floats = (float *) malloc( count * sizeof(float));
if( !xdr_vector( xdrs, (char *) floats, count,
sizeof( float), (xdrproc_t) xdr_float))
return ;
for( j = 0; j < count; j++)
{
if( j)
print( ", ");
print( "%.9g", floats[j]);
}
print( "\n");
free( floats);
}
break;
case DBR_CTRL_DOUBLE:
{
double *doubles;
print( " Type = %i (DBR_CTRL_DOUBLE)\n", type);
print( " Value%s = ", (count == 1) ? "" : "s");
doubles = (double *) malloc( count * sizeof(double));
if( !xdr_vector( xdrs, (char *) doubles, count,
sizeof( double), (xdrproc_t) xdr_double))
return;
for( j = 0; j < count; j++)
{
if( j)
print( ", ");
print( "%.9lg", doubles[j]);
}
print( "\n");
free( doubles);
}
break;
}
}
}
bool_t
xdr_mpp_profiler_t (XDR *xdrs, mpp_profiler_t *objp)
{
//register int32_t *buf;
//int i;
if (!xdr_uint64_t (xdrs, &objp->uptime))
return FALSE;
if (!xdr_uint64_t (xdrs, &objp->now))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->vers, 20,
sizeof (uint8_t), (xdrproc_t) xdr_uint8_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_lookup, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_forget, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_getattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_setattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_readlink, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_mknod, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_mkdir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_unlink, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_rmdir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_symlink, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_rename, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_open, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_link, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_read, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_write, 3,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_flush, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_release, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_opendir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_readdir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_releasedir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_fsyncdir, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_statfs, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_setxattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_getxattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_listxattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_removexattr, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_access, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_create, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_getlk, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_setlk, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_setlk_int, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_ioctl, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->rozofs_ll_clearlkowner, 2,
sizeof (uint64_t), (xdrproc_t) xdr_uint64_t))
return FALSE;
return TRUE;
}
/* write new bodies data */
static void write_new_bodies (DOM *dom)
{
if (dom->newb == NULL) return; /* nothing to write */
#if HDF5
PBF *bf = dom->solfec->bf;
int isize = 0, ints = 0, *i = NULL;
int dsize = 0, doubles = 0;
double *d = NULL;
SET *item;
int n;
PBF_Push (bf, "NEWBOD");
n = SET_Size (dom->newb);
PBF_Int2 (bf, "count", &n, 1);
for (item = SET_First (dom->newb); item; item = SET_Next (item))
{
BODY_Pack (item->data, &dsize, &d, &doubles, &isize, &i, &ints);
}
PBF_Int2 (bf, "ints", &ints, 1);
PBF_Int2 (bf, "i", i, ints);
PBF_Int2 (bf, "doubles", &doubles, 1);
PBF_Double2 (bf, "d", d, doubles);
free (d);
free (i);
PBF_Pop (bf);
#else
char *path, *ext;
FILE *file;
XDR xdr;
path = SOLFEC_Alloc_File_Name (dom->solfec, 16);
ext = path + strlen (path);
#if MPI
sprintf (ext, ".bod.%d", dom->rank);
#else
sprintf (ext, ".bod");
#endif
ASSERT (file = fopen (path, "a"), ERR_FILE_OPEN);
xdrstdio_create (&xdr, file, XDR_ENCODE);
int isize = 0, ints, *i = NULL;
int dsize = 0, doubles;
double *d = NULL;
SET *item;
for (item = SET_First (dom->newb); item; item = SET_Next (item))
{
doubles = ints = 0;
BODY_Pack (item->data, &dsize, &d, &doubles, &isize, &i, &ints);
ASSERT (xdr_int (&xdr, &doubles), ERR_PBF_WRITE);
ASSERT (xdr_vector (&xdr, (char*)d, doubles, sizeof (double), (xdrproc_t)xdr_double), ERR_PBF_WRITE);
ASSERT (xdr_int (&xdr, &ints), ERR_PBF_WRITE);
ASSERT (xdr_vector (&xdr, (char*)i, ints, sizeof (int), (xdrproc_t)xdr_int), ERR_PBF_WRITE);
}
free (d);
free (i);
xdr_destroy (&xdr);
fclose (file);
free (path);
#endif
}
int main(int argc, char *argv[])
{
register int k, l, n, la;
int Nspace, result, NmaxIter, Ngdelay, Ngorder, Ngperiod, btype[3],
inputs[N_INPUTS], nwrite, Nx, Nz;
double iterLimit, *lambda, Adamp;
stats.printCPU = TRUE;
commandline.quiet = FALSE;
commandline.logfile = stderr;
input.Eddington = FALSE;
getCPU(0, TIME_START, NULL);
SetFPEtraps();
fpin = fopen("2dinput.dat", "r");
xdrstdio_create(&xdrs, fpin, XDR_DECODE);
result = xdr_vector(&xdrs, (char *) inputs, N_INPUTS,
sizeof(int), (xdrproc_t) xdr_int);
atmos.angleSet.set = (enum angleset) inputs[0];
if (atmos.angleSet.set == SET_GL) {
result = xdr_int(&xdrs, &atmos.angleSet.Ninclination);
result = xdr_int(&xdrs, &atmos.angleSet.Nazimuth);
}
result = xdr_double(&xdrs, &iterLimit);
result = xdr_double(&xdrs, &Adamp);
Nx = geometry.Nx = inputs[1];
Nz = geometry.Nz = inputs[2];
NmaxIter = inputs[3];
Ngdelay = inputs[4]; Ngorder = inputs[5]; Ngperiod = inputs[6];
Nlambda = inputs[7];
Nspace = atmos.Nspace = geometry.Nx * geometry.Nz;
result = xdr_vector(&xdrs, (char *) btype, 3,
sizeof(int), (xdrproc_t) xdr_int);
geometry.hboundary = (enum boundary) btype[0];
for (n = 0; n < 2; n++)
geometry.bvalue[n] = (enum boundval) btype[1+n];
/* --- Check the validity of boundary conditions and values -- ---- */
switch (geometry.hboundary) {
case FIXED: break;
case PERIODIC: break;
default:
sprintf(messageStr, "Invalid horizontal boundary condition: %d",
geometry.hboundary);
Error(ERROR_LEVEL_2, argv[0], messageStr);
break;
}
switch (geometry.bvalue[TOP]) {
case IRRADIATED: break;
case ZERO: break;
case THERMALIZED: break;
default:
sprintf(messageStr, "Invalid boundary value at TOP: %d\n",
geometry.bvalue[TOP]);
Error(ERROR_LEVEL_2, argv[0], messageStr);
break;
}
switch (geometry.bvalue[BOTTOM]) {
case IRRADIATED: break;
case ZERO: break;
case THERMALIZED: break;
default:
sprintf(messageStr, "Invalid boundary value at BOTTOM: %d",
geometry.bvalue[BOTTOM]);
Error(ERROR_LEVEL_2, argv[0], messageStr);
break;
}
/* --- Get increments in x, store and check for monotonicity -- --- */
geometry.dx = (double *) malloc(Nx * sizeof(double));
result = xdr_vector(&xdrs, (char *) geometry.dx, Nx,
sizeof(double), (xdrproc_t) xdr_double);
for (l = 0; l < ((geometry.hboundary == PERIODIC) ? Nx : Nx-1); l++) {
geometry.dx[l] *= KM_TO_M;
if (geometry.dx[l] <= 0.0) {
sprintf(messageStr, "At l = %d:\n x does not increase strictly "
"monotonically towards the right", l);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
}
geometry.x = (double *) malloc(Nx * sizeof(double));
geometry.x[0] = 0.0;
for (l = 0; l < Nx-1; l++)
geometry.x[l+1] = geometry.x[l] + geometry.dx[l];
/* --- Get vertical grid -- -------------- */
geometry.z = (double *) malloc(Nz * sizeof(double));
result = xdr_vector(&xdrs, (char *) geometry.z, Nz,
sizeof(double), (xdrproc_t) xdr_double);
for (k = 0; k < Nz; k++) geometry.z[k] *= KM_TO_M;
geometry.dz = (double *) malloc(Nz * sizeof(double));
for (k = 0; k < Nz-1; k++) {
geometry.dz[k] = geometry.z[k] - geometry.z[k+1];
if (geometry.dz[k] <= 0.0) {
sprintf(messageStr, "At k = %d:\n z does not decrease strictly "
"monotonically towards the bottom", k);
Error(ERROR_LEVEL_2, argv[0], messageStr);
}
}
geometry.dz[Nz-1] = 0.0;
chi = (double *) malloc(Nspace * sizeof(double));
S = (double *) malloc(Nspace * sizeof(double));
Bp = (double *) malloc(Nspace * sizeof(double));
epsilon = (double *) malloc(Nspace * sizeof(double));
result = xdr_vector(&xdrs, (char *) chi, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
result = xdr_vector(&xdrs, (char *) Bp, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
result = xdr_vector(&xdrs, (char *) epsilon, Nspace,
sizeof(double), (xdrproc_t) xdr_double);
getBoundary(&atmos, &geometry);
getAngleQuadr(&geometry);
atmos.Nrays = geometry.Nrays;
atmos.wmu = geometry.wmu;
fillMesh(&geometry);
lambda = (double *) malloc(Nlambda * sizeof(double));
phi = (double *) malloc(Nlambda * sizeof(double));
wlamb = (double *) malloc(Nlambda * sizeof(double));
result = xdr_vector(&xdrs, (char *) lambda, Nlambda,
sizeof(double), (xdrproc_t) xdr_double);
wlamb[0] = (lambda[1] - lambda[0]);
for (la = 1; la < Nlambda-1; la++)
wlamb[la] = (lambda[la+1] - lambda[la-1]);
wlamb[Nlambda-1] = (lambda[Nlambda-1] - lambda[Nlambda-2]);
wphi = 0.0;
for (la = 0; la < Nlambda; la++) {
phi[la] = Voigt(Adamp, lambda[la], NULL, RYBICKI)/SQRTPI;
wphi += wlamb[la]*phi[la];
}
wphi = 1.0/wphi;
xdr_destroy(&xdrs);
fclose(fpin);
for (k = 0; k < Nspace; k++) S[k] = Bp[k];
Ng_S = NgInit(Nspace, Ngdelay, Ngorder, Ngperiod, S);
Iterate(NmaxIter, iterLimit);
nwrite = fwrite(S, sizeof(double), Nspace, stdout);
printTotalCPU();
}
/* read new bodies data */
static void read_new_bodies (DOM *dom, PBF *bf)
{
#if HDF5
double time, start, end;
PBF_Time (bf, &time); /* back up time frame from outside of this function */
PBF_Limits (bf, &start, &end);
PBF_Seek (bf, start);
do
{
for (PBF *f = bf; f; f = f->next)
{
int ipos = 0, ints;
int dpos = 0, doubles;
double *d;
int *i;
int k, n;
BODY *bod;
if (PBF_Has_Group (f, "NEWBOD") == 0) continue; /* don't try to read if there are no new bodies stored */
PBF_Push (f, "NEWBOD");
PBF_Int2 (f, "count", &n, 1);
PBF_Int2 (f, "ints", &ints, 1);
ERRMEM (i = malloc (sizeof (int [ints])));
PBF_Int2 (f, "i", i, ints);
PBF_Int2 (f, "doubles", &doubles, 1);
ERRMEM (d = malloc (sizeof (double [doubles])));
PBF_Double2 (f, "d", d, doubles);
for (k = 0; k < n; k ++)
{
bod = BODY_Unpack (dom->solfec, &dpos, d, doubles, &ipos, i, ints);
if (!MAP_Find (dom->allbodies, (void*) (long) bod->id, NULL))
{
MAP_Insert (&dom->mapmem, &dom->allbodies, (void*) (long) bod->id, bod, NULL); /* all bodies from all times */
}
else BODY_Destroy (bod); /* FIXME: bodies created in input files at time > 0;
FIXME: perhaps there is no need of moving GLV to the fist lng_RUN call,
FIXME: but rather bodies created in Python should not be put into the 'dom->newb' set;
FIXME: this way, as now, all Python created bodies will be anyway read at time 0 */
}
free (d);
free (i);
PBF_Pop (f);
}
} while (PBF_Forward (bf, 1));
dom->allbodiesread = 1; /* mark as read */
PBF_Seek (bf, time); /* seek to the backed up time again */
#else
char *path, *ext;
FILE *file;
int m, n;
XDR xdr;
if (dom->solfec->verbose)
printf ("Reading all bodies ...\n");
dom->allbodiesread = 1; /* mark as read */
path = SOLFEC_Alloc_File_Name (dom->solfec, 16);
ext = path + strlen (path);
for (m = 0; bf; bf = bf->next) m ++; /* count input files */
for (n = 0; n < m; n ++)
{
if (n || m > 1)
{
sprintf (ext, ".bod.%d", n);
if (!(file = fopen (path, "r"))) continue; /* no new bodies for this rank */
}
else /* n == 0 && m == 1 */
{
sprintf (ext, ".bod.%d", n);
if (!(file = fopen (path, "r"))) /* either prallel with "mpirun -np 1" */
{
sprintf (ext, ".bod");
if (!(file = fopen (path, "r"))) continue; /* or serial */
}
}
xdrstdio_create (&xdr, file, XDR_DECODE);
int ipos, ints, *i, dpos, doubles;
double *d;
BODY *bod;
for (;;)
{
if (xdr_int (&xdr, &doubles))
{
ERRMEM (d = malloc (sizeof (double [doubles])));
if (xdr_vector (&xdr, (char*)d, doubles, sizeof (double), (xdrproc_t)xdr_double))
{
if (xdr_int (&xdr, &ints))
{
ERRMEM (i = malloc (sizeof (int [ints])));
if (xdr_vector (&xdr, (char*)i, ints, sizeof (int), (xdrproc_t)xdr_int))
{
ipos = dpos = 0;
bod = BODY_Unpack (dom->solfec, &dpos, d, doubles, &ipos, i, ints);
if (!MAP_Find (dom->allbodies, (void*) (long) bod->id, NULL))
{
MAP_Insert (&dom->mapmem, &dom->allbodies, (void*) (long) bod->id, bod, NULL);
}
else BODY_Destroy (bod); /* FIXME: bodies created in input files at time > 0;
FIXME: perhaps there is no need of moving GLV to the fist lng_RUN call,
FIXME: but rather bodies created in Python should not be put into the 'dom->newb' set;
FIXME: this way, as now, all Python created bodies will be anyway read at time 0 */
free (d);
free (i);
}
else
{
free (d);
free (i);
break;
}
}
else
{
free (d);
break;
}
}
else
{
free (d);
break;
}
}
else break;
}
xdr_destroy (&xdr);
fclose (file);
}
free (path);
#endif
}
int XdrMGF::dataBlk(Real* array, int numvar, int size)
{
int totalSize = numvar*size;
// If this function is called by coord(),
// numvar is the problem dimension, and
// size is the number of nodes in the problem.
//libMesh::out << "Total amount of data to be written: " << totalSize << std::endl;
switch (m_type)
{
#ifdef LIBMESH_HAVE_XDR
case (XdrMGF::DECODE):
case (XdrMGF::ENCODE):
{
// FIXME - this is probably broken for Real == long double
// RHS
xdr_vector(mp_xdr_handle,
(char *) &array[0],
totalSize,
sizeof(Real),
(xdrproc_t) xdr_REAL);
}
#endif
case (XdrMGF::W_ASCII):
{
// Save stream flags
std::ios_base::fmtflags out_flags = mp_out.flags();
// We will use scientific notation with a precision of 16
// digits in the following output. The desired precision and
// format will automatically determine the width.
mp_out << std::scientific
<< std::setprecision(16);
for (int i=0; i<size; i++)
{
for (int j=0; j<numvar; j++)
mp_out << array[i*numvar + j] << " \t";
mp_out << '\n';
}
// Restore stream flags
mp_out.flags(out_flags);
mp_out.flush();
break;
}
case (XdrMGF::R_ASCII):
{
libmesh_assert (mp_in.good());
for (int i=0; i<size; i++)
{
libmesh_assert (mp_in.good());
for (int j=0; j<numvar; j++)
mp_in >> array[i*numvar + j];
mp_in.ignore(); // Read newline
}
break;
}
default:
// Unknown access type
libmesh_error_msg("Unknown m_type" << m_type);
}
return totalSize;
}
static gmx_bool do_xdr(t_fileio *fio, void *item, int nitem, int eio,
const char *desc, const char *srcfile, int line)
{
unsigned char ucdum, *ucptr;
bool_t res = 0;
float fvec[DIM];
double dvec[DIM];
int j, m, *iptr, idum;
gmx_large_int_t sdum;
real *ptr;
unsigned short us;
double d = 0;
float f = 0;
gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
if (fio->bDouble)
{
if (item && !fio->bRead)
d = *((real *) item);
res = xdr_double(fio->xdr, &d);
if (item)
*((real *) item) = d;
}
else
{
if (item && !fio->bRead)
f = *((real *) item);
res = xdr_float(fio->xdr, &f);
if (item)
*((real *) item) = f;
}
break;
case eioFLOAT:
if (item && !fio->bRead)
f = *((float *) item);
res = xdr_float(fio->xdr, &f);
if (item)
*((float *) item) = f;
break;
case eioDOUBLE:
if (item && !fio->bRead)
d = *((double *) item);
res = xdr_double(fio->xdr, &d);
if (item)
*((double *) item) = d;
break;
case eioINT:
if (item && !fio->bRead)
idum = *(int *) item;
res = xdr_int(fio->xdr, &idum);
if (item)
*(int *) item = idum;
break;
case eioGMX_LARGE_INT:
/* do_xdr will not generate a warning when a 64bit gmx_large_int_t
* value that is out of 32bit range is read into a 32bit gmx_large_int_t.
*/
if (item && !fio->bRead)
sdum = *(gmx_large_int_t *) item;
res = xdr_gmx_large_int(fio->xdr, &sdum, NULL);
if (item)
*(gmx_large_int_t *) item = sdum;
break;
case eioUCHAR:
if (item && !fio->bRead)
ucdum = *(unsigned char *) item;
res = xdr_u_char(fio->xdr, &ucdum);
if (item)
*(unsigned char *) item = ucdum;
break;
case eioNUCHAR:
ucptr = (unsigned char *) item;
res = 1;
for (j = 0; (j < nitem) && res; j++)
{
res = xdr_u_char(fio->xdr, &(ucptr[j]));
}
break;
case eioUSHORT:
if (item && !fio->bRead)
us = *(unsigned short *) item;
res = xdr_u_short(fio->xdr, (unsigned short *) &us);
if (item)
*(unsigned short *) item = us;
break;
case eioRVEC:
if (fio->bDouble)
{
if (item && !fio->bRead)
for (m = 0; (m < DIM); m++)
dvec[m] = ((real *) item)[m];
res = xdr_vector(fio->xdr, (char *) dvec, DIM,
(unsigned int) sizeof(double),
(xdrproc_t) xdr_double);
if (item)
for (m = 0; (m < DIM); m++)
((real *) item)[m] = dvec[m];
}
else
{
if (item && !fio->bRead)
for (m = 0; (m < DIM); m++)
fvec[m] = ((real *) item)[m];
res = xdr_vector(fio->xdr, (char *) fvec, DIM,
(unsigned int) sizeof(float),
(xdrproc_t) xdr_float);
if (item)
for (m = 0; (m < DIM); m++)
((real *) item)[m] = fvec[m];
}
break;
case eioNRVEC:
ptr = NULL;
res = 1;
for (j = 0; (j < nitem) && res; j++)
{
if (item)
ptr = ((rvec *) item)[j];
res = do_xdr(fio, ptr, 1, eioRVEC, desc, srcfile, line);
}
break;
case eioIVEC:
iptr = (int *) item;
res = 1;
for (m = 0; (m < DIM) && res; m++)
{
if (item && !fio->bRead)
idum = iptr[m];
res = xdr_int(fio->xdr, &idum);
if (item)
iptr[m] = idum;
}
break;
case eioSTRING:
{
char *cptr;
int slen;
if (item)
{
if (!fio->bRead)
slen = strlen((char *) item) + 1;
else
slen = 0;
}
else
slen = 0;
if (xdr_int(fio->xdr, &slen) <= 0)
gmx_fatal(FARGS, "wrong string length %d for string %s"
" (source %s, line %d)",slen,desc,srcfile,line);
if (!item && fio->bRead)
snew(cptr,slen);
else
cptr=(char *)item;
if (cptr)
res = xdr_string(fio->xdr,&cptr,slen);
else
res = 1;
if (!item && fio->bRead)
sfree(cptr);
break;
}
default:
gmx_fio_fe(fio, eio, desc, srcfile, line);
}
if ((res == 0) && (fio->bDebug))
fprintf(stderr,"Error in xdr I/O %s %s to file %s (source %s, line %d)\n",
eioNames[eio],desc,fio->fn,srcfile,line);
return (res != 0);
}
