int Boundary_write(
DBfile *idbid,
Boundary_t *ptr,
char *field)
{
char *me = "Boundary_write";
if (RGST_DEL_ATTR_FROM_FIELDS("Boundary_t","dump") != 0)
ctlerror(me,gv_errmsg_rgst_del_attrs_from_fields);
if (strcmp(field,"bnd") == 0) {
if (RGST_ADD_MULT_FIELD_ATTRS("Boundary_t",bnd_fields,attrs) != 0) {
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
}
ptr->len_nsendtot = ptr->len_nsend1 + ptr->len_nsend2 + ptr->len_nsendc;
ptr->len_zsendtot = ptr->len_zsend1 + ptr->len_zsend2 + ptr->len_zsendc;
ptr->len_nrecvtot = ptr->len_nrecv1 + ptr->len_nrecv2 + ptr->len_nrecvc;
ptr->len_zrecvtot = ptr->len_zrecv1 + ptr->len_zrecv2 + ptr->len_zrecvc;
} else if (strcmp(field,"sldbnd") == 0) {
if (RGST_ADD_MULT_FIELD_ATTRS("Boundary_t",sldbnd_fields,attrs) != 0) {
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
}
ptr->len_nsendtot = ptr->len_nsend1 + ptr->len_nsend2 + ptr->len_nsendc;
ptr->len_zsendtot = ptr->len_nsend1;
ptr->len_nrecvtot = ptr->len_nrecv1 + ptr->len_nrecv2 + ptr->len_nrecvc;
} else {
Boundary_setup_attrs();
}
return(0);
}
int Boundary_pre_read(
DBfile *idbid,
Boundary_t *ptr,
char *field)
{
char *me = "Boundary_pre_read";
if (RGST_DEL_ATTR_FROM_FIELDS("Boundary_t","dump") != 0)
ctlerror(me,gv_errmsg_rgst_del_attrs_from_fields);
if (strcmp(field,"bnd") == 0) {
if (RGST_ADD_MULT_FIELD_ATTRS("Boundary_t",bnd_fields,attrs) != 0) {
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
}
} else if (strcmp(field,"sldbnd") == 0) {
if (RGST_ADD_MULT_FIELD_ATTRS("Boundary_t",sldbnd_fields,attrs) != 0) {
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
}
ptr->active = 1;
ptr->len_zsend1 = 0;
ptr->len_zsend2 = 0;
ptr->len_zsendc = 0;
ptr->len_zrecv1 = 0;
ptr->len_zrecv2 = 0;
ptr->len_zrecvc = 0;
ptr->len_zrecvtot = 0;
} else {
Boundary_setup_attrs();
}
return(0);
}
int hash_tbl_rgst(
HashTable_t **htp,
char *name)
{
char *me = "hash_tbl_rgst";
char msg[512], *ps_save, *line_save, sym_save[MAXLINE];
int error, symflag_save;
if (name == NULL) {
ctlerror(me,"name must be specified to register hash table");
}
if ((htp == NULL) || (*htp == NULL)) {
ctlerror(me,"hash table pointer is NULL");
}
if ((*htp)->name != NULL) {
if (rgst_check_for_obj((*htp)->name) == TRUE) {
rgst_del((*htp)->name);
sprintf(msg,"\nHash table '%s' being re-registered as"
"\nHash table '%s'",(*htp)->name,name);
ctlnotice(me,msg);
}
FREEMEM((*htp)->name);
}
(*htp)->name = strsave(name);
rgst_add(name, "HashTable_t *", htp, NULL);
return(0);
}
void rgst_verify_struct_td_defn(
char *name,
RGST_StructTypeDef_t *sd,
int struct_size)
{
char *me = "rgst_verify_struct_td_defn";
int i, j;
char msg[256];
HashElm_t *hash_elm;
for (i=0; i<sd->num_fields; i++) {
if (debugflag == TRUE)
printf("\n checking field '%s'",sd->fields[i].name);
if ( (sd->fields[i].type == R_STRUCT)
|| (sd->fields[i].type == R_CTYPE_TYPEDEF)
|| (sd->fields[i].type == R_ENUM_TYPEDEF)
|| (sd->fields[i].type == R_STRUCT_TYPEDEF) ) {
if (sd->fields[i].td_name[0] == '\0') {
ctlerror(me,"td_name (name of typedef) is null");
}
hash_elm = hash_lookup_elm(sd->fields[i].td_name,rgst_types_hash_tbl);
if (hash_elm == NULL) {
if ( (strncmp(sd->fields[i].td_name,name,strlen(name) - 2) == 0)
|| ( (strcmp(name,"AttrArray_t") == 0)
&& (strcmp(sd->fields[i].td_name,"RGST_Attribute_s") == 0)
)
) {
;
}
else {
sprintf(msg,"\n\tStructure '%s' -- field '%s'\n\tof type '%s' is bad."
"\n\tRegistry does not know of type '%s'",
name,
sd->fields[i].name,
sd->fields[i].td_name,
sd->fields[i].td_name);
ctlnotice(me,msg);
}
}
else {
if (strcmp(hash_elm->type,rgst_datatype_strs[sd->fields[i].type]) != 0) {
ctlerror(me,"Programmer error: sd->fields[i].type != hash_elm->type");
}
}
}
else {
if (sd->fields[i].td_name[0] != '\0') {
ctlerror(me,"td_name (name of typedef) should be null");
}
}
for (j=0; j<sd->fields[i].ndims; j++) {
if (sd->fields[i].dims[j] < 1)
ctlerror(me,"dimension must be 1 or greater");
}
}
}
Conditional_t *Conditional_construct(int num)
{
char *me = "Conditional_construct";
int i;
Conditional_t *ptr;
if (num < 1) ctlerror(me,logic_err);
ptr = ALLOT(Conditional_t, num);
if (ptr == NULL) ctlerror(me,gv_errmsg_memory);
for (i=0; i<num; i++) {
Conditional_init(&(ptr[i]));
}
return(ptr);
}
Species_t *Species_construct(int num)
{
char *me = "Species_construct";
int i;
Species_t *spec;
if (num < 1) ctlerror(me,logic_err);
spec = ALLOT(Species_t, num);
if (spec == NULL) ctlerror(me,gv_errmsg_memory);
for (i=0; i<num; i++) {
Species_init(&(spec[i]));
}
return(spec);
}
Source_t *Source_construct(int num)
{
char *me = "Source_construct";
int i;
Source_t *ptr;
if (num < 1) ctlerror(me,logic_err);
ptr = ALLOT(Source_t, num);
if (ptr == NULL) ctlerror(me,gv_errmsg_memory);
for (i=0; i<num; i++) {
Source_init(&(ptr[i]));
}
return(ptr);
}
AttrArray_t *AttrArray_construct(int num)
{
char *me = "AttrArray_construct";
int i;
AttrArray_t *ptr;
if (num < 1) ctlerror(me,logic_err);
ptr = ALLOT(AttrArray_t, num);
if (ptr == NULL) ctlerror(me,gv_errmsg_memory);
for (i=0; i<num; i++) {
AttrArray_init(&(ptr[i]));
}
return(ptr);
}
static void
boxboxresize(Group *g, Rectangle r)
{
int rows, cols, ht, wid, i, hpad, wpad;
Rectangle rr;
if(debug) fprint(2, "boxboxresize %q %R (%d×%d) min/max %R separation %d\n", g->name, r, Dx(r), Dy(r), g->size, g->separation);
ht = 0;
for(i=0; i<g->nkids; i++){
if (g->kids[i]->size.min.y > ht)
ht = g->kids[i]->size.min.y;
}
if (ht == 0)
ctlerror("boxboxresize: height");
rows = Dy(r) / (ht+g->separation);
hpad = (Dy(r) % (ht+g->separation)) / g->nkids;
cols = (g->nkids+rows-1)/rows;
wid = Dx(r) / cols - g->separation;
for(i=0; i<g->nkids; i++){
if (g->kids[i]->size.max.x < wid)
wid = g->kids[i]->size.max.x;
}
for(i=0; i<g->nkids; i++){
if (g->kids[i]->size.min.x > wid)
wid = g->kids[i]->size.min.x;
}
if (wid > Dx(r) / cols)
ctlerror("can't fit controls in boxbox");
wpad = (Dx(r) % (wid+g->separation)) / g->nkids;
rr = rectaddpt(Rect(0,0,wid, ht), addpt(r.min, Pt(g->separation/2, g->separation/2)));
if(debug) fprint(2, "boxboxresize rows %d, cols %d, wid %d, ht %d, wpad %d, hpad %d\n", rows, cols, wid, ht, wpad, hpad);
for(i=0; i<g->nkids; i++){
if(debug) fprint(2, " %d %q: %R (%d×%d)\n", i, g->kids[i]->name, rr, Dx(rr), Dy(rr));
_ctlprint(g->kids[i], "rect %R",
rectaddpt(rr, Pt((wpad+wid+g->separation)*(i/rows), (hpad+ht+g->separation)*(i%rows))));
}
g->nseparators = rows + cols - 2;
g->separators = realloc(g->separators, g->nseparators*sizeof(Rectangle));
rr = r;
rr.max.y = rr.min.y + g->separation+hpad;
for (i = 1; i < rows; i++){
g->separators[i-1] = rectaddpt(rr, Pt(0, (hpad+ht+g->separation)*i-g->separation-hpad));
if(debug) fprint(2, "row separation %d [%d]: %R\n", i, i-1, rectaddpt(rr, Pt(0, (hpad+ht+g->separation)*i-g->separation)));
}
rr = r;
rr.max.x = rr.min.x + g->separation+wpad;
for (i = 1; i < cols; i++){
g->separators[i+rows-2] = rectaddpt(rr, Pt((wpad+wid+g->separation)*i-g->separation-wpad, 0));
if(debug) fprint(2, "col separation %d [%d]: %R\n", i, i+rows-2, rectaddpt(rr, Pt((wpad+wid+g->separation)*i-g->separation, 0)));
}
}
RGST_AttributeElem_t *rgst_create_RGST_AttributeElem_t(
char *name,
ATTR_Assoc_t assoc,
RGST_Datatype_t datatype,
void *v_ptr,
RGST_Field_t *fld_ptr)
{
char *me = "rgst_create_RGST_AttributeElem_t";
RGST_AttributeElem_t *elm;
if ((elm = ALLOT(RGST_AttributeElem_t, 1)) == NULL) ctlerror(me,gv_errmsg_memory);
elm->name = strsave(name);
elm->assoc = assoc;
elm->rgst_datatype = NUM_RGST_Datatype_t;
elm->rgst_ctype_defn = NULL;
elm->rgst_enum_defn = NULL;
elm->rgst_struct_defn = NULL;
elm->rgst_field = NULL;
elm->rgst_obj = NULL;
elm->next = NULL;
elm->prev = NULL;
switch (elm->assoc) {
case A_TYPE:
elm->rgst_datatype = datatype;
if ((datatype == R_STRUCT) || (datatype == R_STRUCT_TYPEDEF)) {
elm->rgst_struct_defn = (RGST_StructTypeDef_t *)v_ptr;
}
else if (datatype == R_CTYPE_TYPEDEF) {
elm->rgst_ctype_defn = (RGST_CTypeDef_t *)v_ptr;
}
else if (datatype == R_ENUM_TYPEDEF) {
elm->rgst_enum_defn = (RGST_EnumTypeDef_t *)v_ptr;
}
else {
ctlerror(me,logic_err);
}
break;
case A_FIELD:
elm->rgst_datatype = datatype;
elm->rgst_struct_defn = (RGST_StructTypeDef_t *)v_ptr;
elm->rgst_field = fld_ptr;
break;
case A_OBJECT:
elm->rgst_obj = (RGST_Object_t *)v_ptr;
break;
default:
ctlerror(me,"Programmer error: assoc is invalid");
}
return(elm);
}
int comreduce(
void *inbuf,
int count,
int op,
int com_type,
int data_type)
{
char *me = "comreduce";
int i, error;
int *outbufi, *inbufi;
double *outbufd, *inbufd;
MPI_Op opout;
com_start = MPI_Wtime_Wrapper();
if ((com_type != COM_ALL) && (com_type != COM_ONE))
ctlerror(me,logic_err);
switch(op) {
case COM_SUM: opout = MPI_SUM; break;
case COM_MAX: opout = MPI_MAX; break;
case COM_MIN: opout = MPI_MIN; break;
default : ctlerror(me,logic_err);
}
switch (data_type) {
case COM_DOUBLE:
outbufd = ALLOT(double,count);
inbufd = inbuf;
if (com_type==COM_ALL)
error = MPI_Allreduce_Wrapper(inbuf,outbufd,count,MPI_DOUBLE,opout,MPI_COMM_WORLD);
else
error = MPI_Reduce_Wrapper(inbuf,outbufd,count,MPI_DOUBLE,opout,0,MPI_COMM_WORLD);
for (i=0;i<count;i++) inbufd[i]=outbufd[i];
FREEMEM(outbufd);
break;
case COM_INT:
outbufi = ALLOT(int,count);
inbufi = inbuf;
if (com_type==COM_ALL)
error = MPI_Allreduce_Wrapper(inbuf,outbufi,count,MPI_INT,opout,MPI_COMM_WORLD);
else
error = MPI_Reduce_Wrapper(inbuf,outbufi,count,MPI_INT,opout,0,MPI_COMM_WORLD);
for (i=0;i<count;i++) inbufi[i]=outbufi[i];
FREEMEM(outbufi);
break;
default:
ctlerror(me,logic_err);
}
com_reduce_time += MPI_Wtime_Wrapper() - com_start;
return(error);
}
DBfile *openpdmp( char* kern, int cyc, int num, int mode, char* dmpname)
{
char *me = "openpdmp";
DBfile *idbidin;
int ierr;
char infotmp[30], msg[128];
char fullname[MAXLINE];
if (num >= 0) {
if (cyc >= 0) {
sprintf(dmpname, "%s-%04d-%05d.silo", kern, num, cyc) ;
} else {
sprintf(dmpname, "%s-%04d.silo", kern, num) ;
}
} else {
if (cyc >= 0) {
sprintf(dmpname, "%s%05d.silo", kern, cyc) ;
} else {
sprintf(dmpname, "%s.silo", kern) ;
}
}
if (mode == 2) return(NULL);
DBShowErrors(DB_NONE, NULL);
if (mode == 0) {
idbidin = DBOpen (dmpname, DB_PDB, DB_READ);
if (idbidin == NULL) ctlerror(me,gv_errmsg_DBOpen);
} else {
sprintf(infotmp, "%s dump file", meshlink_codesys);
strcpy(fullname,outpath);
strcat(fullname,dmpname);
idbidin = DBCreate(fullname, DB_CLOBBER, DB_LOCAL, infotmp, DB_PDB );
}
DBShowErrors(DB_TOP, NULL);
return(idbidin);
}
int rgst_get_nelms_in_rgst_obj (
RGST_Object_t *ro,
long *ret_dim_nelms,
long *ret_ptr_nelms,
long *ret_nelms)
{
char *me = "rgst_get_nelms_in_rgst_obj";
int i;
long dim_nelms, ptr_nelms, nelms;
dim_nelms = ptr_nelms = -1;
if (ro->array_size_type == FIELD_OFFSET) {
ctlerror(me,"Shawn hasn't coded this logic yet");
}
else if (ro->array_size_type == GLOBAL_VAR) {
ptr_nelms = rgst_get_long(ro->array_size_global_var);
nelms = ptr_nelms;
}
else if (ro->array_size_type == ABSOLUTE_VALUE) {
ptr_nelms = ro->array_size_absolute_val;
nelms = ptr_nelms;
}
else {
dim_nelms = 1;
for (i=0; i<ro->ndims; i++) {
dim_nelms = dim_nelms * ro->dims[i];
}
nelms = dim_nelms;
}
*ret_dim_nelms = dim_nelms;
*ret_ptr_nelms = ptr_nelms;
*ret_nelms = nelms;
return(0);
}
static void
groupsize(Control *c)
{
Rectangle r;
int i;
Control *q;
Group *g;
g = (Group*)c;
assert(g->type == Ctlcolumn || g->type == Ctlrow || g->type == Ctlstack);
if (g->mansize) return;
r = Rect(1, 1, 1, 1);
if (debug) fprint(2, "groupsize %q\n", g->name);
for (i = 0; i < g->nkids; i++){
q = g->kids[i];
if (q->setsize)
q->setsize(q);
if (q->size.min.x == 0 || q->size.min.y == 0 || q->size.max.x == 0 || q->size.max.y == 0)
ctlerror("%q: bad size %R", q->name, q->size);
if (debug) fprint(2, "groupsize %q: [%d %q]: %R\n", g->name, i, q->name, q->size);
switch(g->type){
case Ctlrow:
if (i)
r.min.x += q->size.min.x + g->border;
else
r.min.x = q->size.min.x;
if (i)
r.max.x += q->size.max.x + g->border;
else
r.max.x = q->size.max.x;
if (r.min.y < q->size.min.y) r.min.y = q->size.min.y;
if (r.max.y < q->size.max.y) r.max.y = q->size.max.y;
break;
case Ctlcolumn:
if (r.min.x < q->size.min.x) r.min.x = q->size.min.x;
if (r.max.x < q->size.max.x) r.max.x = q->size.max.x;
if (i)
r.min.y += q->size.min.y + g->border;
else
r.min.y = q->size.min.y;
if (i)
r.max.y += q->size.max.y + g->border;
else
r.max.y = q->size.max.y;
break;
case Ctlstack:
if (r.min.x < q->size.min.x) r.min.x = q->size.min.x;
if (r.max.x < q->size.max.x) r.max.x = q->size.max.x;
if (r.min.y < q->size.min.y) r.min.y = q->size.min.y;
if (r.max.y < q->size.max.y) r.max.y = q->size.max.y;
break;
}
}
g->size = rectaddpt(r, Pt(g->border, g->border));
if (debug) fprint(2, "groupsize %q: %R\n", g->name, g->size);
}
void* ProblemArray_allotptr(char *name, HashTable_t *hash) {
char *me = "ProblemArray_allotptr";
char msg[MAXLINE];
int i;
ProblemArray_t *prb = ProblemArray_find(name, hash);
if (prb == NULL) {
sprintf(msg, "Attempt to allocate pointer for %s failed because ProblemArray does not exist for it.",name);
ctlerror(me,msg);
}
if (prb->ptr != NULL) {
sprintf(msg, "An attempt has been made to allocate pointer a non-null pointer for %s.", name);
ctlerror(me,msg);
}
if (prb->type == R_INT) {
int *iptr = MALLOT(int, prb->len);
for (i = 0; i < prb->len; i++) {
iptr[i] = 0;
}
prb->ptr = (void *) iptr;
} else if (prb->type == R_DOUBLE) {
void AttrArray_add(
RGST_Attribute_t *new_attr,
AttrArray_t *ptr)
{
char *me = " AttrArray_add";
int i;
if (ptr == NULL) ctlerror(me,logic_err);
if (ptr->num_attrs >= ptr->size_attrs) {
ptr->size_attrs += 5;
if (ptr->attrs == NULL) {
ptr->attrs = (RGST_Attribute_t **)malloc(ptr->size_attrs * sizeof(void *));
}
else {
ptr->attrs = (RGST_Attribute_t **)realloc(ptr->attrs, ptr->size_attrs * sizeof(void *));
}
if (ptr->attrs == NULL) ctlerror(me,gv_errmsg_memory);
for (i=ptr->size_attrs-5; i<ptr->size_attrs; i++) ptr->attrs[i] = NULL;
}
ptr->attrs[ptr->num_attrs] = new_attr;
ptr->num_attrs++;
}
void *rgst_construct(
RGST_Datatype_t type,
char *struct_name,
int num)
{
char *me = "rgst_construct";
char *not_done = "shawn not done yet";
char msg[256], routine_name[128];
int i;
long long_ptr_addr;
size_t size;
RGST_StructTypeDef_t *sd = NULL;
void *ptr = NULL;
Command_t *cp = NULL;
void *struct_ptr;
if ((type < 0) || (type >= NUM_RGST_Datatype_t)) ctlerror(me,logic_err);
if (num < 1) ctlerror(me,logic_err);
if ((type >= R_CHAR) && (type <= R_DOUBLE)) {
size = (size_t)rgst_datatype_sizes[type];
ptr = ALLOT(unsigned char, (size * num));
}
void ProblemArray_add(char *name, void *ptr, int len, RGST_Datatype_t type,
HashTable_t *hash) {
char *me = "ProblemArray_add";
char msg[MAXLINE];
int exists;
ProblemArray_t *prb = NULL;
exists = 0;
if (hash == NULL) {
if (rgst_check_for_obj(name)) {
exists = 1;
prb = (ProblemArray_t *) rgst_get_t(name,"ProblemArray_t");
#ifdef DEBUG
sprintf(msg,"Attempting to over write problem array %s",name);
ctlwarning(me,msg);
#endif
} else {
prb = MALLOT(ProblemArray_t,1);
}
} else {
prb = (ProblemArray_t *) hash_lookup_obj(name, hash);
if (prb != NULL) {
exists = 1;
#ifdef DEBUG
sprintf(msg,"Attempting to over write problem array %s",name);
ctlwarning(me,msg);
#endif
} else {
prb = MALLOT(ProblemArray_t,1);
}
}
if (exists) {
if (ptr != NULL) {
prb->ptr = ptr;
prb->len = len;
}
if (prb->type != type) {
sprintf(msg,"Attempting to change type of problem array %s.",name);
ctlerror(me,msg);
}
} else {
prb->ptr = ptr;
prb->len = len;
prb->type = type;
prb->hash = NULL;
strcpy(prb->name, name);
}
if (hash == NULL) {
if (!exists) rgst_add(name,"ProblemArray_t", prb, NULL);
} else {
if (!exists) hash_add(name, "ProblemArray", prb, hash);
}
}
int Source_setup_attrs(void)
{
char *me = "Source_setup_attrs";
static int first_time_thru = TRUE;
if (RGST_ADD_ATTR_TO_FIELDS("Source_t","dump") != 0)
ctlerror(me,gv_errmsg_rgst_add_attrs_to_fields);
if (first_time_thru == TRUE) {
inst_c("Source_init", Source_init, zargse, 0, symtab);
inst_c("Source_construct", Source_construct, zargse, 0, symtab);
first_time_thru = FALSE;
}
return(0);
}
int rdparms(DBfile *idbid)
{
char *me = "rdparms";
char startdir[256];
int i, ndx;
int *ints = NULL;
double *doubles = NULL;
char *chars = NULL, *str = NULL;
DBcompoundarray *comparray;
if (DBGetDir(idbid,startdir) != 0) ctlerror(me,gv_errmsg_DBGetDir);
if (DBSetDir(idbid,"/Global/Parms") != 0) ctlerror(me,gv_errmsg_DBSetDir);
comparray = DBGetCompoundarray(idbid, "int_parms");
if ( (comparray == NULL)
|| (comparray->datatype != DB_INT) ) {
ctlerror(me,logic_err);
}
ints = (int *)comparray->values;
for (i=0; i<comparray->nelems; i++) {
if (comparray->elemlengths[i] != 1) { ctlerror(me,logic_err); }
setparmi(comparray->elemnames[i],ints[i]);
}
DBFreeCompoundarray(comparray);
comparray = DBGetCompoundarray(idbid, "double_parms");
if ( (comparray == NULL)
|| (comparray->datatype != DB_DOUBLE) ) {
ctlerror(me,logic_err);
}
doubles = (double *)comparray->values;
for (i=0; i<comparray->nelems; i++) {
if (comparray->elemlengths[i] != 1) { ctlerror(me,logic_err); }
setparmf(comparray->elemnames[i],doubles[i]);
}
DBFreeCompoundarray(comparray);
comparray = DBGetCompoundarray(idbid, "char_parms");
if ( (comparray == NULL)
|| (comparray->datatype != DB_CHAR) ) {
ctlerror(me,logic_err);
}
chars = (char *)comparray->values;
ndx = 0;
for (i=0; i<comparray->nelems; i++) {
setparmc(comparray->elemnames[i], &(chars[ndx]) );
ndx = ndx + comparray->elemlengths[i];
}
DBFreeCompoundarray(comparray);
if (DBSetDir(idbid, startdir) != 0) ctlerror(me,gv_errmsg_DBSetDir);
return(0);
}
RGST_Attribute_t * AttrArray_search(
char *attr_name,
AttrArray_t *ptr)
{
char *me ="AttrArray_search";
int i;
if (ptr == NULL) ctlerror(me,logic_err);
for (i=0; i<ptr->num_attrs; i++) {
if (strcmp(attr_name,ptr->attrs[i]->attr_name) == 0) {
return(ptr->attrs[i]);
}
}
return(NULL);
}
int rgst_init(void)
{
char *me = "rgst_init";
int i;
RGST_BasicCTypeDef_t *c_type;
RGST_Function_t *fn;
rgst_types_hash_tbl = hash_tbl_create(61, NULL);
rgst_objs_hash_tbl = hash_tbl_create(2039, NULL);
rgst_field_ndx_hash_tbl = hash_tbl_create(1021, NULL);
if ((rgst_types_hash_tbl == NULL) ||
(rgst_objs_hash_tbl == NULL) ||
(rgst_field_ndx_hash_tbl == NULL)) {
return(-1);
}
for (i=0; i<R_VOID; i++) {
if ((c_type = ALLOT(RGST_BasicCTypeDef_t, 1)) == NULL)
ctlerror(me,gv_errmsg_memory);
c_type->type = (RGST_Datatype_t) i;
c_type->type_size = rgst_datatype_sizes[i];
hash_add(rgst_datatype_strs[i],
rgst_datatype_strs[i],
c_type, rgst_types_hash_tbl);
}
if ((fn = ALLOT(RGST_Function_t, 1)) == NULL)
ctlerror(me,gv_errmsg_memory);
hash_add(rgst_datatype_strs[R_FUNCTION],
rgst_datatype_strs[R_FUNCTION],
fn, rgst_types_hash_tbl);
rgst_add_h_file_types();
rgst_types_hash_tbl->name = strsave(RGST_TYPES_HT_NAME);
rgst_objs_hash_tbl->name = strsave(RGST_OBJS_HT_NAME);
rgst_field_ndx_hash_tbl->name = strsave(RGST_Field_t_NDX_HT_NAME);
rgst_add(rgst_types_hash_tbl->name, "HashTable_t *", &rgst_types_hash_tbl, NULL);
rgst_add(rgst_objs_hash_tbl->name, "HashTable_t *", &rgst_objs_hash_tbl, NULL);
rgst_add(rgst_field_ndx_hash_tbl->name, "HashTable_t *", &rgst_field_ndx_hash_tbl, NULL);
return(0);
}
RGST_AttributeElem_t *rgst_list_attr(
ATTR_Assoc_t assoc,
char *attr_name)
{
char *me = "rgst_list_attr";
char msg[128];
RGST_Attribute_t *attr;
if ((attr = rgst_get_t(attr_name,RGST_Attribute_t_STR)) == NULL)
return(NULL);
if (assoc == A_OBJECT) return(attr->obj_head);
else if (assoc == A_TYPE) return(attr->type_head);
else if (assoc == A_FIELD) return(attr->field_head);
else ctlerror(me,logic_err);
return(NULL);
}
int Boundary_setup_attrs(void)
{
char *me = "Boundary_setup_attrs";
static int first_time_thru = TRUE;
if (RGST_ADD_MULT_FIELD_ATTRS("Boundary_t",bnd_fields,attrs) != 0)
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
if (first_time_thru == TRUE) {
#ifdef SILO
inst_c("Boundary_write", Boundary_write, zargse, 0, symtab);
inst_c("Boundary_pre_read", Boundary_pre_read, zargse, 0, symtab);
#endif
first_time_thru = FALSE;
}
return(0);
}
int hash_optimize_all(void)
{
char *me = "hash_optimize_all";
char **ht_names;
int num_ht, i;
HashTable_t **htp = NULL;
ht_names = rgst_list_objs_by_type(&num_ht, "HashTable_t *");
for (i=0; i<num_ht; i++) {
htp = (HashTable_t **)rgst_get_t(ht_names[i],"HashTable_t *");
if (htp == NULL) { ctlerror(me,logic_err); }
hash_optimize(htp);
FREEMEM(ht_names[i]);
}
FREEMEM(ht_names);
return(0);
}
void AttrArray_del(
char *attr_name,
AttrArray_t *ptr)
{
char *me = " AttrArray_del";
int i, j;
if (ptr == NULL) ctlerror(me,logic_err);
for (i=0; i<ptr->num_attrs; i++) {
if (strcmp(attr_name,ptr->attrs[i]->attr_name) == 0) {
for(j=i; j<(ptr->num_attrs-1); j++) {
ptr->attrs[j] = ptr->attrs[j+1];
}
ptr->attrs[ptr->num_attrs-1] = NULL;
ptr->num_attrs--;
return;
}
}
}
int tpamp( void )
{
char *me = "tpamp", msg[256];
int i, j, k, icur;
double *times;
TimePlot_t *my_tpd = NULL;
TimePlotCurve_t *my_tpc = NULL;
if (myid != 0) { return(0); }
strcpy(msg,outpath);
strcat(msg,pbnm);
strcat(msg,".ult");
fpamp = fopen(msg,"wt");
for (i=0 ; i<ntp ; i++) {
my_tpd = tpdata[i];
if (strcmp("time $",my_tpd->tp_curs[0]->eval_string) != 0) {
ctlerror(me,logic_err);
}
if (my_tpd->num_data_pts > 0) {
times = my_tpd->tp_curs[0]->data[0];
}
for (icur=1; icur < my_tpd->num_tp_curs; icur++) {
my_tpc = my_tpd->tp_curs[icur];
for (j=0; j<my_tpc->num_vals; j++) {
if (my_tpc->labels[j] == NULL) {
if (my_tpc->num_vals == 1) {
PRINT(fpamp,"# %s vs. time\n",my_tpc->eval_string);
}
else {
PRINT(fpamp,"# %s [%d] vs. time\n",my_tpc->eval_string,j);
}
}
else {
PRINT(fpamp,"# %s vs. time\n",my_tpc->labels[j]);
}
for (k=0; k<my_tpd->num_data_pts; k++) {
PRINT(fpamp," %.14e %.14e\n",times[k],my_tpc->data[j][k]);
}
PRINT(fpamp,"end\n") ;
}
}
}
fclose(fpamp);
return(0);
}
int hash_tbl_create_n_rgst(
HashTable_t **htp,
int size,
char *name)
{
char *me = "hash_tbl_create_n_rgst";
HashTable_t *ht;
if (name == NULL) {
ctlerror(me,"name must be specified to register hash table");
}
ht = hash_tbl_create(size,name);
if (ht == NULL) {
*htp = NULL;
return(-1);
}
rgst_add(name, "HashTable_t *", htp, NULL);
*htp = ht;
return(0);
}
int Conditional_setup_attrs(void)
{
char *me = "Conditional_setup_attrs";
static int first_time_thru = TRUE;
char *fields[10] = {
"id", "once", "active",
"expression_len", "msg_len",
"expression", "msg",
NULL
};
char *attrs[2] = {"dump", NULL};
if (RGST_ADD_MULT_FIELD_ATTRS("Conditional_t",fields,attrs) != 0)
ctlerror(me,gv_errmsg_rgst_add_mult_attrs);
if (first_time_thru == TRUE) {
inst_c("Conditional_init", Conditional_init, zargse, 0, symtab);
inst_c("Conditional_construct", Conditional_construct, zargse, 0, symtab);
first_time_thru = FALSE;
}
return(0);
}
ProblemArray_t *ProblemArray_setblk(char *name) {
char *me = "ProblemArray_setblk";
int iblk;
ProblemArray_t *prb;
ProblemArray_t *parray;
parray = MALLOT(ProblemArray_t, nblk);
if (parray == NULL) ctlerror(me,gv_errmsg_memory);
for (iblk = 0; iblk < nblk; iblk++) {
prb = ProblemArray_find(name,domains[iblk].hash);
if (prb == NULL) {
FREEMEM(parray);
break;
}
parray[iblk].ptr = prb->ptr;
parray[iblk].len = prb->len;
memset (parray[iblk].name,'\0',MAXWORD);
strncpy(parray[iblk].name,name,MAXWORD-1);
}
return(parray);
}
