Create Xref-Html Frames                    Remove All Frames
file:d:/code/LRC/Splicer/splicer_code_ver2.2/splicer_io.c        (Tue Mar 14 16:29:16 2000 )


   1: /*
   2:   splicer_io.c
   3: */
   4: #include <Xm/Xm.h>
   5: #include <Xm/Text.h>
   6: #include <X11/cursorfont.h>
   7: #include <stdio.h>
   8: #include <math.h>
   9: #include <ctype.h>
  10: #include <fcntl.h>
  11: #include <string.h>
  12: #include <malloc.h>
  13: #include <unistd.h>
  14: #include "splicer-creation-c.h"
  15: #include "splicer_vars.h"
  16: 
  17: #define MAXLINE   (1001)
  18: #define MAXPREVIEW      (20)
  19: long  atol();
  20: int close();
  21: char  line[MAXLINE];
  22: 
  23: 
  24: int SpReadSplicerTable(fptr,splicerptr,cnt)
  25: FILE  *fptr;
  26: SplicerTableInfo  *splicerptr;
  27: int *cnt;
  28: {
  29:   int status,i;
  30: 
  31:   status=fscanf(fptr,"%d %c %d %c %s %f %f %f %f %s %d %c %d %c %s %f %f %f %f",
  32:       &splicerptr[*cnt].site,&splicerptr[*cnt].hole,&splicerptr[*cnt].core,&splicerptr[*cnt].core_type,
  33:       splicerptr[*cnt].section,&splicerptr[*cnt].top_int,&splicerptr[*cnt].bot_int,
  34:       &splicerptr[*cnt].mbsf,&splicerptr[*cnt].mcd, splicerptr[*cnt+1].type_of_splice,
  35:       &splicerptr[*cnt+1].site,&splicerptr[*cnt+1].hole,&splicerptr[*cnt+1].core,&splicerptr[*cnt+1].core_type,
  36:       splicerptr[*cnt+1].section,&splicerptr[*cnt+1].top_int,&splicerptr[*cnt+1].bot_int,
  37:       &splicerptr[*cnt+1].mbsf,&splicerptr[*cnt+1].mcd);
  38:   if(status==9 || status==19) /* more data to read */
  39:   {
  40:     *cnt=*cnt+status/9;
  41:     splicerptr[*cnt].hole=toupper(splicerptr[*cnt].hole);
  42:     splicerptr[*cnt].core_type=toupper(splicerptr[*cnt].core_type);
  43:     for(i=0;i<(int)strlen(splicerptr[*cnt].section);i++)
  44:     {
  45:       if(isalpha(splicerptr[*cnt].section[i]))
  46:         splicerptr[*cnt].section[i]=toupper(splicerptr[*cnt].section[i]);
  47:     }
  48:     splicerptr[*cnt+1].hole=toupper(splicerptr[*cnt+1].hole);
  49:     splicerptr[*cnt+1].core_type=toupper(splicerptr[*cnt+1].core_type);
  50:     for(i=0;i<(int)strlen(splicerptr[*cnt+1].section);i++)
  51:     {
  52:       if(isalpha(splicerptr[*cnt+1].section[i]))
  53:         splicerptr[*cnt+1].section[i]=toupper(splicerptr[*cnt+1].section[i]);
  54:     }
  55:   }
  56:   return(status);
  57: }
  58: 
  59: int SpWriteSplicerTable(splfile)
  60: char *splfile;
  61: {
  62:   int i;
  63:   Hole  *holeptr1,*holeptr2;
  64:   Core  *coreptr1,*coreptr2;
  65:   Value *valueptr1,*valueptr2;
  66:         FILE    *fptr;
  67:         SplicerTableInfo  *spl1, *spl2;
  68: 
  69:   if((fptr=fopen(splfile, "w")) == NULL){
  70:     return;
  71:   }
  72: 
  73:   i = 1;
  74:   while(i<splicertable.data_cnt-1) {
  75:     spl1 = &splicertable.data[i];
  76:     spl2 = &splicertable.data[i+1];
  77:     if((int)strcmp(spl2->type_of_splice, "interp") == 0) {
  78:       (void)sprintf(spl2->type_of_splice, "tie");
  79:     }
  80:     (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%s\t%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\n",
  81:       spl1->site, spl1->hole, spl1->core, spl1->core_type, spl1->section, spl1->top_int, spl1->bot_int, spl1->mbsf, spl1->mcd,
  82:       spl2->type_of_splice,
  83:       spl2->site, spl2->hole, spl2->core, spl2->core_type, spl2->section, spl2->top_int, spl2->bot_int, spl2->mbsf, spl2->mcd);
  84:     i = i + 2;
  85:   } 
  86:   
  87:   i = splicertable.data_cnt-1;
  88:   spl1 = &splicertable.data[i];
  89:   (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\n", 
  90:     spl1->site, spl1->hole, spl1->core, spl1->core_type, spl1->section, spl1->top_int, spl1->bot_int, spl1->mbsf, spl1->mcd);
  91: 
  92:   fclose(fptr);
  93: 
  94:   return(True);
  95: }
  96: 
  97: int SpReadStrat(fptr,stratptr)
  98: FILE  *fptr;
  99: StratData *stratptr;
 100: {
 101:   int status,i;
 102: 
 103:   status=fscanf(fptr,"%s %s %f %f %d %d %c %d %c %s %f %f %d %d %c %d %c %s %f %f",
 104:     stratptr->name,stratptr->code,&stratptr->top_age,&stratptr->bot_age,&stratptr->top.leg,
 105:     &stratptr->top.site,&stratptr->top.hole,&stratptr->top.core,
 106:     &stratptr->top.coretype,stratptr->top.section,&stratptr->top.interval,
 107:     &stratptr->top.sb_depth,&stratptr->bot.leg,&stratptr->bot.site,&stratptr->bot.hole,&stratptr->bot.core,
 108:     &stratptr->bot.coretype,stratptr->bot.section,&stratptr->bot.interval,&stratptr->bot.sb_depth);
 109:   stratptr->top.hole=toupper(stratptr->top.hole);
 110:   stratptr->top.coretype=toupper(stratptr->top.coretype);
 111:   for(i=0;i<(int)strlen(stratptr->top.section);i++)
 112:   {
 113:     if(isalpha(stratptr->top.section[i]))
 114:       stratptr->top.section[i]=toupper(stratptr->top.section[i]);
 115:   }
 116:   stratptr->bot.hole=toupper(stratptr->bot.hole);
 117:   stratptr->bot.coretype=toupper(stratptr->bot.coretype);
 118:   for(i=0;i<(int)strlen(stratptr->bot.section);i++)
 119:   {
 120:     if(isalpha(stratptr->bot.section[i]))
 121:       stratptr->bot.section[i]=toupper(stratptr->bot.section[i]);
 122:   }
 123:   if(status==20)
 124:     return(True);
 125:   else if(status!=EOF)
 126:   {
 127:     message.error=True;
 128:                 if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
 129:                   SpBadMemAlloc("SpReadSTrat");
 130:                 }
 131:                 else {
 132:                   (void)sprintf(charptr,"Error reading stat file. This happened at datum name %s", stratptr->name);
 133:                 }
 134:     SpManageWarningBox(charptr);
 135:                 free(charptr);
 136:     return(False);
 137:   }
 138:   else
 139:     return(False);
 140: 
 141: } 
 142: 
 143: int SpWriteStrat(fptr,stratptr)
 144: FILE  *fptr;
 145: StratData *stratptr;
 146: {
 147:   char  topoffset[6],botoffset[6],
 148:     topmsd[9],botmsd[9];
 149:   
 150:   if(stratptr->top.in_affine == NO)
 151:   {
 152:     (void)sprintf(topmsd,"N/A");
 153:     (void)sprintf(topoffset,"N/A");
 154:   }
 155:   else
 156:   {
 157:     (void)sprintf(topmsd,"%.2f",stratptr->top.sb_depth+stratptr->top.offset);
 158:     (void)sprintf(topoffset,"%.2f",stratptr->top.offset);
 159:   }
 160:   if(stratptr->bot.in_affine == NO)
 161:   {
 162:     (void)sprintf(topmsd,"N/A");
 163:     (void)sprintf(botoffset,"N/A");
 164:   }
 165:   else
 166:   {
 167:     (void)sprintf(botmsd,"%.2f",stratptr->bot.sb_depth+stratptr->bot.offset);
 168:     (void)sprintf(botoffset,"%.2f",stratptr->bot.offset);
 169:   }
 170:   fprintf(fptr,"%s\t%s\t%.2f\t%.2f\t%d\t%d\t%c\t%d\t%c\t%s\t%.2f\t%.2f\t%s\t%s\t%d\t%d\t%c\t%d\t%c\t%s\t%.2f\t%.2f\t%s\t%s\n",
 171:     stratptr->name,stratptr->code,stratptr->top_age,stratptr->bot_age,stratptr->top.leg,
 172:     stratptr->top.site,stratptr->top.hole,stratptr->top.core,
 173:     stratptr->top.coretype,stratptr->top.section,stratptr->top.interval,
 174:     stratptr->top.sb_depth, topoffset, topmsd,
 175:     stratptr->bot.leg,stratptr->bot.site,stratptr->bot.hole,stratptr->bot.core,
 176:     stratptr->bot.coretype,stratptr->bot.section,stratptr->bot.interval,stratptr->bot.sb_depth,
 177:     botoffset,botmsd);
 178:   return(True);
 179: }
 180: int SpWriteData(fptr,holeptr)
 181: FILE  *fptr;
 182: Hole  *holeptr;
 183: {
 184:   int i,j;
 185:   Core  *coreptr;
 186:   Value *valueptr;
 187: 
 188:   for(i=0;i<holeptr->numcores;i++)
 189:   {
 190:     coreptr=holeptr->core[i];
 191:     for(j=0;j<coreptr->numvalues;j++)
 192:     {
 193:       valueptr=coreptr->value[j];
 194:         valueptr=coreptr->value[j];
 195:       if(valueptr->quality==GOOD)
 196:       {
 197:                                 switch (data[dset]->in_format) {
 198:                 
 199:                                   case MST95REPORT:
 200:                                   case TKREPORT:
 201:             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.3f",
 202:                   data[dset]->site,holeptr->name,coreptr->num,valueptr->type,
 203:             valueptr->section,valueptr->top_int,
 204:             valueptr->bot_int, valueptr->sb_depth, *valueptr->data);
 205:             if(smooth.method!=NONE)
 206:           (void)fprintf(fptr,"\t%.3f",valueptr->sm_data);
 207:                                     break;
 208:                                   case ODPOTHER1:
 209:                                     (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f",
 210:                                                 data[dset]->site,holeptr->name,coreptr->num,valueptr->type,
 211:                                                 valueptr->section,valueptr->top_int,
 212:                                                 valueptr->bot_int, valueptr->sb_depth, *valueptr->data);
 213:                                     if(smooth.method!=NONE)
 214:                                         (void)fprintf(fptr,"\t%.2f",valueptr->sm_data);
 215:                                     break;
 216:                                   case ODPOTHER2:
 217:                                     (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f",
 218:                                                 data[dset]->site, holeptr->name,coreptr->num,valueptr->type,
 219:                                                 valueptr->section,valueptr->top_int,
 220:                                                 valueptr->bot_int, valueptr->sb_depth, *valueptr->data);
 221:                                     if(smooth.method!=NONE)
 222:                                         (void)fprintf(fptr,"\t%.2f",valueptr->sm_data);
 223:                                     break;
 224:                                   case ODPOTHER3:
 225:                                     (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.1f\t%.2f\t%.2f",
 226:                                                 data[dset]->site, holeptr->name,coreptr->num,
 227:                                                 valueptr->section,valueptr->top_int,
 228:                                                 valueptr->bot_int, valueptr->sb_depth, *valueptr->data);
 229:                                     if(smooth.method!=NONE)
 230:                                         (void)fprintf(fptr,"\t%.2f",valueptr->sm_data);
 231:                                     break;
 232:                                   case ODPOTHER4:
 233:                                     (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.2f\t%.2f",
 234:                                                 data[dset]->site, holeptr->name,coreptr->num,
 235:                                                 valueptr->section,valueptr->top_int,
 236:                                                 valueptr->sb_depth, *valueptr->data);
 237:                                     if(smooth.method!=NONE)
 238:                                         (void)fprintf(fptr,"\t%.2f",valueptr->sm_data);
 239:                                     break;
 240:                                   case JANUSCLEAN:
 241:                                   case JANUSORIG:
 242:                                   case ODPOTHER5:
 243:                                     (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.2f\t%.3f",
 244:                                                 data[dset]->site,holeptr->name,coreptr->num,valueptr->type,
 245:                                                 valueptr->section,valueptr->top_int,
 246:                                                 valueptr->sb_depth, *valueptr->data);
 247:                                     if(smooth.method!=NONE)
 248:                                         (void)fprintf(fptr,"\t%.3f",valueptr->sm_data);
 249:                                     break;
 250:                                 }
 251:         (void)fprintf(fptr,"\t%.2f\t%.2f\n", coreptr->cum_dep_offset,
 252:             (valueptr->sb_depth+coreptr->cum_dep_offset));
 253:       }
 254:     }
 255:   }
 256:   return(True);
 257: }
 258: 
 259: int SpWriteSplicerData(filename, writeage)
 260: char    *filename;
 261: int     writeage;
 262: {
 263:   int i,j;
 264:         float   smvar;
 265:   Hole  *holeptr;
 266:   Core  *coreptr;
 267:   Value *valueptr;
 268:         FILE    *fptr;
 269: 
 270:         if((fptr=fopen(filename,"w"))==NULL)
 271:         {
 272:           (void)sprintf(buffer, "Could not write file %s.", filename);
 273:           SpManageWarningBox(buffer);
 274:           return;
 275:         }
 276: 
 277:         io_wait_cursor = XCreateFontCursor(XtDisplay(formFileSelection), XC_watch);
 278:         if(io_wait_cursor != BadAlloc && io_wait_cursor != BadFont && io_wait_cursor != BadValue) {
 279:           XDefineCursor(XtDisplay(formFileSelection), XtWindow(formFileSelection), io_wait_cursor);
 280:         }
 281: 
 282:   for(i=0;i<spcomp.numcores;i++)
 283:   {
 284:     holeptr=data[dset]->holes[spcomp.hole[i]];
 285:     coreptr=holeptr->core[spcomp.core[i]];
 286:                 if(smooth.method == NONE){
 287:       for(j=0;j<spcomp.numpercore[i];j++)
 288:       {
 289:                     /* if the first point in core is at the same depth as last point of last
 290:                        core don't write it
 291:                     */ 
 292:                     if(!(i > 0 && j == 0 && fabs(spcomp.sb_depth[i][j] - spcomp.sb_depth[i-1][spcomp.numpercore[i-1]-1]) < 0.005))
 293:                     {
 294:       valueptr=coreptr->value[spcomp.MapToOrig[i][j]];
 295:                         switch (data[dset]->in_format) {
 296: 
 297:                           case MST95REPORT:
 298:                           case TKREPORT:
 299:           (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.3f\t%.2f\t%.2f",
 300:           data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 301:           valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 302:           spcomp.sb_depth[i][j]);
 303:                              break;
 304:                           case ODPOTHER1:
 305:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f",
 306:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 307:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 308:                                         spcomp.sb_depth[i][j]);
 309:                             break;
 310:                           case ODPOTHER2:
 311:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f",
 312:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 313:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 314:                                         spcomp.sb_depth[i][j]);
 315:                             break;
 316:                           case ODPOTHER3:
 317:                             (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f",
 318:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->section, valueptr->top_int,
 319:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 320:                                         spcomp.sb_depth[i][j]);
 321:                             break;
 322:                           case ODPOTHER4:
 323:                             (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f",
 324:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->section, valueptr->top_int,
 325:                                         valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 326:                                         spcomp.sb_depth[i][j]);
 327:                             break;
 328:                           case JANUSCLEAN:
 329:                           case JANUSORIG:
 330:                           case ODPOTHER5:
 331:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.2f\t%.3f\t%.2f\t%.2f",
 332:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 333:                                         valueptr->sb_depth, spcomp.var[i][j], spcomp.Depthoffset[i],
 334:                                         spcomp.sb_depth[i][j]);
 335:                              break;
 336:                         }
 337:                         if(writeage == YES) 
 338:                         {
 339:                              (void)fprintf(fptr,"\t%.3f\n", spcomp.age[i][j]);
 340:                         }
 341:                         else
 342:                         {
 343:                              (void)fprintf(fptr,"\n");
 344:                         }
 345:                     }
 346:                     else
 347:                     {
 348:                     }
 349:                   }
 350:                 }
 351:                 else if(smooth.method == GAUSSIAN || smooth.method == OTHER){
 352:                   for(j=0;j<spcomp.numpercore[i];j++)
 353:                   {  
 354:                     if(!(i > 0 && j == 0 && fabs(spcomp.sb_depth[i][j] - spcomp.sb_depth[i-1][spcomp.numpercore[i-1]-1]) < 0.005)){ 
 355:                         valueptr=coreptr->value[spcomp.MapToOrig[i][j]];
 356:                         if(valueptr->smooth_ok >= SMOK){
 357:                           smvar = valueptr->sm_data;
 358:                         }
 359:                         else {
 360:                           smvar = spcomp.var[i][j];
 361:                         }
 362: 
 363:                         switch (data[dset]->in_format) {
 364:  
 365:                           case MST95REPORT:
 366:                           case TKREPORT:
 367:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.3f\t%.3f\t%.2f\t%.2f",
 368:                                         data[dset]->site,holeptr->name,coreptr->num,valueptr->type,valueptr->section,valueptr->top_int,
 369:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], smvar,
 370:                                         spcomp.Depthoffset[i], spcomp.sb_depth[i][j]);
 371:                             break;
 372:                           case ODPOTHER1:
 373:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",
 374:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 375:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], smvar, spcomp.Depthoffset[i],
 376:                                         spcomp.sb_depth[i][j]);
 377:                             break;
 378:                           case ODPOTHER2:
 379:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",
 380:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->type, valueptr->section, valueptr->top_int,
 381:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], smvar, spcomp.Depthoffset[i],
 382:                                         spcomp.sb_depth[i][j]);
 383:                             break;
 384:                           case ODPOTHER3:
 385:                             (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",
 386:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->section, valueptr->top_int,
 387:                                         valueptr->bot_int, valueptr->sb_depth, spcomp.var[i][j], smvar, spcomp.Depthoffset[i],
 388:                                         spcomp.sb_depth[i][j]);
 389:                             break;
 390:                           case ODPOTHER4:
 391:                             (void)fprintf(fptr,"%d\t%c\t%d\t%s\t%.1f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",
 392:                                         data[dset]->site, holeptr->name, coreptr->num, valueptr->section, valueptr->top_int,
 393:                                         valueptr->sb_depth, spcomp.var[i][j], smvar, spcomp.Depthoffset[i],
 394:                                         spcomp.sb_depth[i][j]);
 395:                             break;
 396:                           case JANUSCLEAN:
 397:                           case JANUSORIG:
 398:                           case ODPOTHER5:
 399:                             (void)fprintf(fptr,"%d\t%c\t%d\t%c\t%s\t%.1f\t%.2f\t%.3f\t%.3f\t%.2f\t%.2f",
 400:                                         data[dset]->site,holeptr->name,coreptr->num,valueptr->type,valueptr->section,valueptr->top_int,
 401:                                         valueptr->sb_depth, spcomp.var[i][j], smvar,
 402:                                         spcomp.Depthoffset[i], spcomp.sb_depth[i][j]);
 403:                             break;
 404:                         }
 405:                         if(writeage == YES) 
 406:                         {
 407:                            (void)fprintf(fptr,"\t%.3f\t%.2f\n", spcomp.age[i][j], spcomp.sedrate[i][j]);
 408:                         }
 409:                         else
 410:                         {
 411:                            (void)fprintf(fptr,"\n");
 412:                         }
 413:                     }
 414:                     else
 415:                     {
 416:                     }
 417:                   }
 418:                 }
 419:   }
 420: 
 421:         if(io_wait_cursor) {
 422:           XUndefineCursor(XtDisplay(formFileSelection), XtWindow(formFileSelection));
 423:           XFreeCursor(XtDisplay(formFileSelection), io_wait_cursor);
 424:         }
 425:         fclose(fptr);
 426:   return(True);
 427: }
 428:     
 429: 
 430: int SpReadTKreport(fptr,dataptr)
 431: FILE  *fptr;
 432: DataFile  *dataptr;
 433: {
 434:   int core_num,this_hole,this_core,max_alloc,i,status;
 435:         float   dum;
 436:   Hole  *holeptr;
 437:   Core  *coreptr;
 438:   Value *valueptr;
 439:   char  hole_name;
 440: 
 441:   /*return False=more data, true=done */
 442:   dataptr->subleg=' ';
 443:   if((status=fscanf(fptr,"%d %d %c %d",&dataptr->leg,&dataptr->site,&hole_name,&core_num))!=4)
 444:   {
 445:     if(status==EOF)
 446:       return(True);
 447:     else
 448:     {
 449:       dataptr->readerrors++;
 450:       return(False);
 451:     }
 452:   }
 453:   else
 454:   {
 455:          
 456:   /* check if new hole */
 457:     hole_name=toupper(hole_name);
 458:     if(dataptr->holes_used==NULL || strchr(dataptr->holes_used,hole_name)==NULL)
 459:     {
 460:       dataptr->numholes++;
 461:       if(dataptr->numholes >1)  /* not first hole */
 462:       {
 463:         if((charptr=(char*)realloc(dataptr->holes_used,(dataptr->numholes+1)*CHAR_SIZE))==NULL)
 464:           SpBadMemAlloc("SpReadTKreport 2");
 465:         else
 466:           dataptr->holes_used = charptr;
 467:         if((charptr=(char*)realloc((char*)dataptr->holes,dataptr->numholes*sizeof(Hole*)))==NULL)
 468:           SpBadMemAlloc("SpReadTKreport 3");
 469:         else
 470:           dataptr->holes=(Hole**)charptr;
 471:       }
 472:       else    /* first hole */
 473:       {
 474:         if((dataptr->holes_used=(char*)calloc(2,sizeof(char)))==NULL)
 475:           SpBadMemAlloc("SpReadTKreport 4");
 476:         dataptr->holes_used[0]='\0';
 477:         if((dataptr->holes=(Hole**)calloc(dataptr->numholes,sizeof(Hole*)))==NULL)
 478:           SpBadMemAlloc("SpReadTKreport 5");
 479:       }
 480:       /* set hole values */
 481:       if((dataptr->holes[dataptr->numholes-1]=(Hole*)calloc(1,sizeof(Hole)))==NULL)
 482:         SpBadMemAlloc("SpReadTKreport 6");
 483:       this_hole=dataptr->numholes-1;
 484:       holeptr=dataptr->holes[this_hole];
 485:       holeptr->name=hole_name;
 486:       (void)sprintf(dataptr->holes_used,"%s%c",dataptr->holes_used,hole_name);
 487:       holeptr->numcores=0;
 488:     }
 489:     else  /* hole already exists */
 490:       for(this_hole=0;this_hole<dataptr->numholes && 
 491:           dataptr->holes[this_hole]->name!=hole_name;this_hole++);
 492:     holeptr=dataptr->holes[this_hole];
 493:     /* check if new core*/
 494:     for(this_core=0;this_core<holeptr->numcores && core_num != holeptr->core[this_core]->num;this_core++);
 495:     if(this_core >= holeptr->numcores)
 496:     {
 497:       if(holeptr->numcores++>0) /* not first core*/
 498:       {
 499:         if((charptr=(char*)realloc((char*)holeptr->core,holeptr->numcores*sizeof(Core*)))==NULL)
 500:           SpBadMemAlloc("SpReadTKreport 7");
 501:         else
 502:           holeptr->core=(Core**)charptr;
 503:       }
 504:       else    /* firstcore */
 505:       {
 506:         if((holeptr->core=(Core**)calloc(holeptr->numcores,sizeof(Core*)))==NULL)
 507:           SpBadMemAlloc("SpReadTKreport 8");
 508:       }
 509:       /* set core values */
 510:       if((holeptr->core[this_core]=(Core*)calloc(1,sizeof(Core)))==NULL)
 511:         SpBadMemAlloc("SpReadTKreport 9");
 512:       coreptr=holeptr->core[this_core];
 513:       coreptr->num=core_num;
 514:       coreptr->numvalues=0;
 515:       if((coreptr->value=(Value**)calloc(ALLOC_INT,sizeof(Value*)))==NULL)
 516:         SpBadMemAlloc("SpReadTKreport 10");
 517:       for(coreptr->allocvalues=0;coreptr->allocvalues<ALLOC_INT;coreptr->allocvalues++)
 518:       {
 519:         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
 520:           SpBadMemAlloc("SpReadTKreport 11");
 521:       }
 522:     }
 523:     coreptr=holeptr->core[this_core];
 524:     coreptr->cum_dep_offset=0.0;
 525:     coreptr->did_offset=False;
 526:     if(coreptr->numvalues++ >= coreptr->allocvalues)
 527:     {
 528:       max_alloc=coreptr->allocvalues+ALLOC_INT;
 529:       if((charptr=(char*)realloc((char*)coreptr->value,max_alloc*sizeof(Value*)))==NULL)
 530:         SpBadMemAlloc("SpReadTKreport 12");
 531:       else
 532:         coreptr->value=(Value**) charptr;
 533:       for(;coreptr->allocvalues<max_alloc;coreptr->allocvalues++)
 534:       {
 535:         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
 536:           SpBadMemAlloc("SpReadTKreport 13");
 537:       }
 538:     }
 539:     valueptr=coreptr->value[coreptr->numvalues-1];
 540:   /* get standard core values */
 541:     while((valueptr->type=fgetc(fptr))!=EOF && isspace(valueptr->type));
 542:     if(valueptr->type==EOF)
 543:       return(True);
 544:     else
 545:       valueptr->type=toupper(valueptr->type);
 546:     while((valueptr->section[0]=fgetc(fptr))!=EOF && isspace(valueptr->section[0]));
 547:     if(valueptr->section[0]==EOF)
 548:       return(True);
 549:     else
 550:       valueptr->section[0]=toupper(valueptr->section[0]);
 551:     valueptr->section[1]=fgetc(fptr);
 552:     if(isspace(valueptr->section[1]))
 553:       valueptr->section[1]='\0';
 554:     else
 555:       valueptr->section[1]=toupper(valueptr->section[1]);
 556:     valueptr->section[1]='\0';
 557:     if((status=fscanf(fptr,"%f %f %f",&valueptr->top_int,&valueptr->bot_int,&valueptr->sb_depth))!=3)
 558:     {
 559:       if(status==EOF)
 560:         return(True);
 561:       else
 562:       {
 563:         dataptr->readerrors++;
 564:         return(False);
 565:       }
 566:     }
 567:                 if(fabs(valueptr->sb_depth - BAD_CODE) <= ROUNDCHECK) {
 568:                   valueptr->quality=BAD_SB_DEPTH;
 569:                 }
 570:                 else {
 571:         valueptr->quality=GOOD;
 572:                 }
 573:     valueptr->run_num=0;
 574:   /* get type specific values */
 575:     switch (dataptr->type)
 576:     {
 577:       case GRAPE:
 578:         if((valueptr->grape=(Grapedata*)calloc(1,sizeof(Grapedata)))==NULL)
 579:           SpBadMemAlloc("SpReadTKreport 15");
 580:         if((status=fscanf(fptr,"%f",&valueptr->grape->density)) != 1)
 581:         {
 582:           if(status==EOF)
 583:             return(True);
 584:           else
 585:           {
 586:             dataptr->readerrors++;
 587:             message.error=True;
 588:           }
 589:         }
 590:         else
 591:         {
 592:                                         valueptr->data=&valueptr->grape->density;
 593:           valueptr->grape->gamma_counts=0;
 594:                                         valueptr->grape->b_corr_density = 0.0;
 595:         }
 596:         break;
 597:       case SUSCEPTIBILITY:
 598:         if((valueptr->susceptibility=(Susceptibility*)calloc(1,sizeof(Susceptibility)))==NULL)
 599:           SpBadMemAlloc("SpReadTKreport 16");
 600:         if((status=fscanf(fptr,"%f",&valueptr->susceptibility->corrected)) !=1)
 601:         {
 602:           if(status==EOF)
 603:             return(True);
 604:           else
 605:           {
 606:             dataptr->readerrors++;
 607:             message.error=True;
 608:           }
 609:         }
 610:         else
 611:         {
 612:           valueptr->susceptibility->observed=0.0;
 613:           valueptr->data=&valueptr->susceptibility->corrected;
 614:         }
 615:         break;
 616:       case PWAVE:
 617:         if((valueptr->pwave=(Pwavedata*)calloc(1,sizeof(Pwavedata)))==NULL)
 618:           SpBadMemAlloc("SpReadTKreport 17");
 619:         if((status=fscanf(fptr,"%f",&valueptr->pwave->velocity)) !=1)
 620:         {
 621:           if(status==EOF)
 622:             return(True);
 623:           else
 624:           {
 625:             dataptr->readerrors++;
 626:             message.error=True;
 627:           }
 628:         }
 629:         else
 630:         {
 631:           valueptr->pwave->sig_strength=0;
 632:           valueptr->pwave->travel_time=0;
 633:           valueptr->pwave->displacement=0;
 634:           valueptr->data=&valueptr->pwave->velocity;
 635:         }
 636:         break;
 637:       case NATURALGAMMA:
 638:                                 if((valueptr->naturalgamma=(Natgammadata*)calloc(1,sizeof(Natgammadata)))==NULL)
 639:                                         SpBadMemAlloc("SpReadTKreport 18");
 640:                                 if((status=fscanf(fptr,"%f %d %f %f %f %f %f %d",&valueptr->naturalgamma->total_cnt,
 641:             &valueptr->naturalgamma->sample_time,
 642:             &valueptr->naturalgamma->seg1_cnt,&valueptr->naturalgamma->seg2_cnt,
 643:             &valueptr->naturalgamma->seg3_cnt,&valueptr->naturalgamma->seg4_cnt,
 644:             &valueptr->naturalgamma->seg5_cnt,&valueptr->run_num))!=8)
 645:                                 {
 646:           if(status==EOF)
 647:             return(True);
 648:           else
 649:           {
 650:                                           dataptr->readerrors++;
 651:                                           message.error=True;
 652:           }
 653:                                 }
 654:                                 else
 655:                                 {
 656:                                         valueptr->data=&valueptr->naturalgamma->total_cnt;
 657:                                 }
 658:                                 break;
 659:       case REFLECTANCEMST:
 660:         if((valueptr->reflectanceMST=(ReflectanceMST*)calloc(1,sizeof(ReflectanceMST)))==NULL)
 661:           SpBadMemAlloc("SpReadTKreport 19");
 662:         for(i=0;i<31;i++)
 663:           valueptr->reflectanceMST->nm_value[i]=0.0;
 664:         if((status=fscanf(fptr,"%f",&valueptr->reflectanceMST->nm_value[15]))!=1)
 665:         {
 666:           if(status==EOF)
 667:             return(True);
 668:           else
 669:           {
 670:             dataptr->readerrors++;
 671:             message.error=True;
 672:           }
 673:         }
 674:         else
 675:         {
 676:           valueptr->reflectanceMST->L=0.0;
 677:           valueptr->reflectanceMST->a=0.0;
 678:           valueptr->reflectanceMST->b=0.0;
 679:           valueptr->reflectanceMST->munsell_hue[0]='\0';
 680:           valueptr->reflectanceMST->munsell_value[0]='\0';
 681:           valueptr->data=&valueptr->reflectanceMST->nm_value[15];
 682:         }
 683:         break;
 684:                         case OTHERTYPE:
 685:                                 break;
 686:       default:
 687:         dataptr->readerrors++;
 688:         message.error=True;
 689:     }
 690:     if(message.error==True)
 691:     {
 692:       message.fatal=False;
 693:       message.default_button=XmDIALOG_OK_BUTTON;
 694:       message.type=XmDIALOG_ERROR;
 695:       message.caller=SPREADTKREPORT;
 696:       if((message.label=(char*)calloc(500+(int)strlen(format[dataptr->in_format])+
 697:                                           (int)strlen(type[dataptr->type]),CHAR_SIZE))==NULL)
 698:         SpBadMemAlloc("SpReadTKreport 15");
 699:       (void)sprintf(message.label,"Invalid TK format and/or %s type at %c  %d  %s  %6.1f %6.1f %8.2f",
 700:                                               type[dataptr->type], holeptr->name, coreptr->num, valueptr->section,
 701:                                               valueptr->top_int, valueptr->bot_int, valueptr->sb_depth);
 702:       SpManageMessage(message);
 703:     }
 704:     else
 705:       valueptr->sm_data=*valueptr->data;
 706:   }
 707:   return(False);
 708: }
 709: int SpReadOtherOdp(fptr,dataptr)
 710: FILE  *fptr;
 711: DataFile  *dataptr;
 712: {
 713:   char  hole_name;
 714:   int core_num,status,this_hole,this_core,max_alloc;
 715:   Value tmp_value,*valueptr;
 716:   Core  *coreptr;
 717:   Hole  *holeptr;
 718: 
 719:   /*return False=more data, true=done */
 720: /* read data line */
 721:   if(fgets(line,1000,fptr)==NULL)
 722:     return(True);
 723: /* get variables */
 724:   dataptr->subleg=' ';
 725:   switch (dataptr->in_format)
 726:   {
 727:     case  ODPOTHER1:
 728:       if((status=sscanf(line,openfileinfo.other_format,&dataptr->leg,
 729:           &dataptr->site,&hole_name,&core_num,&tmp_value.type,
 730:           tmp_value.section,&tmp_value.top_int,&tmp_value.bot_int,
 731:           &tmp_value.sb_depth,&tmp_value.otherodp))!=10)
 732:       {
 733:         if(status==EOF)
 734:           return(True);
 735:         else
 736:           message.error=True;
 737:       }
 738:       break;
 739:     case  ODPOTHER2:
 740:       dataptr->leg=0;
 741:       if((status=sscanf(line,openfileinfo.other_format,
 742:           &dataptr->site,&hole_name,&core_num,&tmp_value.type,
 743:           tmp_value.section,&tmp_value.top_int,&tmp_value.bot_int,
 744:           &tmp_value.sb_depth,&tmp_value.otherodp))!=9)
 745:       {
 746:         if(status==EOF)
 747:           return(True);
 748:         else
 749:           message.error=True;
 750:       }
 751:       break;
 752:     case  ODPOTHER3:
 753:       dataptr->leg=0;
 754:                         tmp_value.type = '?';
 755:       if((status=sscanf(line,openfileinfo.other_format, &dataptr->site,&hole_name,&core_num,
 756:           tmp_value.section,&tmp_value.top_int,&tmp_value.bot_int,
 757:           &tmp_value.sb_depth,&tmp_value.otherodp))!=8)
 758:       {
 759:         if(status==EOF)
 760:           return(True);
 761:         else
 762:           message.error=True;
 763:       }
 764:       break;
 765:     case  ODPOTHER4:
 766:       dataptr->leg=0;
 767:                         tmp_value.type = '?';
 768:       if((status=sscanf(line,openfileinfo.other_format, &dataptr->site,&hole_name,&core_num,
 769:           tmp_value.section,&tmp_value.top_int,
 770:           &tmp_value.sb_depth,&tmp_value.otherodp))!=7)
 771:       {
 772:         if(status==EOF)
 773:           return(True);
 774:         else
 775:           message.error=True;
 776:       }
 777:       tmp_value.bot_int=tmp_value.top_int;
 778:       break;
 779:                 case    ODPOTHER5:
 780:                         if((status=sscanf(line,openfileinfo.other_format,&dataptr->leg,
 781:                                         &dataptr->site,&hole_name,&core_num,&tmp_value.type,
 782:                                         tmp_value.section,&tmp_value.top_int,
 783:                                         &tmp_value.sb_depth,&tmp_value.otherodp))!=9)
 784:                         {
 785:                                 if(status==EOF)
 786:                                         return(True);
 787:                                 else
 788:                                         message.error=True;
 789:                         }
 790:                         tmp_value.bot_int=tmp_value.top_int;
 791:                         break;
 792:     default:
 793:       message.fatal=False;
 794:       message.default_button=XmDIALOG_OK_BUTTON;
 795:       message.type=XmDIALOG_ERROR;
 796:       message.caller=SPREADOTHERODP;
 797:       if((message.label=(char*)calloc(100,CHAR_SIZE))==NULL)
 798:         SpBadMemAlloc("SpReadOtherOdp 1");
 799:       (void)sprintf(message.label,"Invalid other odp data type %d",dataptr->type);
 800:       SpManageMessage(message);
 801:       return(False);
 802:   }
 803:   if(message.error)
 804:   {
 805:     message.fatal=False;
 806:     message.default_button=XmDIALOG_OK_BUTTON;
 807:     message.type=XmDIALOG_ERROR;
 808:     message.caller=SPREADOTHERODP;
 809:     if((message.label=(char*)calloc(50+(int)strlen(type[dataptr->type])+
 810:           (int)strlen(format[dataptr->in_format]) + (int)strlen(line),CHAR_SIZE))==NULL)
 811:       SpBadMemAlloc("SpReadOtherOdp 2");
 812:     (void)sprintf(message.label,"Bad %s %s at line\n %s",format[dataptr->in_format],type[dataptr->type], line);
 813:     SpManageMessage(message);
 814:     return(False);
 815:   }
 816: 
 817:   /* check if new hole */
 818:   hole_name=toupper(hole_name);
 819:   if(dataptr->holes_used==NULL || strchr(dataptr->holes_used,hole_name)==NULL)
 820:   {
 821:     dataptr->numholes++;
 822:     if(dataptr->numholes >1)  /* not first hole */
 823:     {
 824:       if((charptr=(char*)realloc(dataptr->holes_used,(dataptr->numholes+1)*CHAR_SIZE))==NULL)
 825:         SpBadMemAlloc("SpReadOtherOdp 3");
 826:       else
 827:         dataptr->holes_used = charptr;
 828:       if((charptr=(char*)realloc((char*)dataptr->holes,dataptr->numholes*sizeof(Hole*)))==NULL)
 829:         SpBadMemAlloc("SpReadOtherOdp 4");
 830:       else
 831:         dataptr->holes=(Hole**)charptr;
 832:     }
 833:     else    /* first hole */
 834:     {
 835:       if((dataptr->holes_used=(char*)calloc(2,sizeof(char)))==NULL)
 836:         SpBadMemAlloc("SpReadOtherOdp 5");
 837:       dataptr->holes_used[0]='\0';
 838:       if((dataptr->holes=(Hole**)calloc(dataptr->numholes,sizeof(Hole*)))==NULL)
 839:         SpBadMemAlloc("SpReadOtherOdp 6");
 840:     }
 841:     /* set hole values */
 842:     if((dataptr->holes[dataptr->numholes-1]=(Hole*)calloc(1,sizeof(Hole)))==NULL)
 843:       SpBadMemAlloc("SpReadOtherOdp 7");
 844:     this_hole=dataptr->numholes-1;
 845:     holeptr=dataptr->holes[this_hole];
 846:     holeptr->name=hole_name;
 847:     (void)sprintf(dataptr->holes_used,"%s%c",dataptr->holes_used,hole_name);
 848:     holeptr->numcores=0;
 849:   }
 850:   else  /* hole already exists */
 851:   {
 852:     for(this_hole=0;this_hole<dataptr->numholes && 
 853:         dataptr->holes[this_hole]->name!=hole_name;this_hole++);
 854:   }
 855:   holeptr=dataptr->holes[this_hole];
 856:   /* check if new core*/
 857:   for(this_core=0;this_core<holeptr->numcores && core_num != holeptr->core[this_core]->num;this_core++);
 858:   if(this_core >= holeptr->numcores)
 859:   {
 860:     if(holeptr->numcores++>0) /* not first core*/
 861:     {
 862:       if((charptr=(char*)realloc((char*)holeptr->core,holeptr->numcores*sizeof(Core*)))==NULL)
 863:         SpBadMemAlloc("SpReadOtherOdp 8");
 864:       else
 865:         holeptr->core=(Core**)charptr;
 866:     }
 867:     else    /* firstcore */
 868:     {
 869:       if((holeptr->core=(Core**)calloc(holeptr->numcores,sizeof(Core*)))==NULL)
 870:         SpBadMemAlloc("SpReadOtherOdp 9");
 871:     }
 872:     /* set core values */
 873:     if((holeptr->core[this_core]=(Core*)calloc(1,sizeof(Core)))==NULL)
 874:       SpBadMemAlloc("SpReadOtherOdp 10");
 875:     coreptr=holeptr->core[this_core];
 876:     coreptr->num=core_num;
 877:     coreptr->numvalues=0;
 878:     if((coreptr->value=(Value**)calloc(ALLOC_INT,sizeof(Value*)))==NULL)
 879:       SpBadMemAlloc("SpReadOtherOdp 11");
 880:     for(coreptr->allocvalues=0;coreptr->allocvalues<ALLOC_INT;coreptr->allocvalues++)
 881:     {
 882:       if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
 883:         SpBadMemAlloc("SpReadOtherOdp 12");
 884:     }
 885:   }
 886:   coreptr=holeptr->core[this_core];
 887:   coreptr->cum_dep_offset=0.0;
 888:   coreptr->did_offset=False;
 889:   if(coreptr->numvalues++ >= coreptr->allocvalues)
 890:   {
 891:     max_alloc=coreptr->allocvalues+ALLOC_INT;
 892:     if((charptr=(char*)realloc((char*)coreptr->value,max_alloc*sizeof(Value*)))==NULL)
 893:       SpBadMemAlloc("SpReadOtherOdp 13");
 894:     else
 895:       coreptr->value=(Value**) charptr;
 896:     for(;coreptr->allocvalues<max_alloc;coreptr->allocvalues++)
 897:     {
 898:       if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
 899:         SpBadMemAlloc("SpReadOtherOdp 14");
 900:     }
 901:   }
 902:   valueptr=coreptr->value[coreptr->numvalues-1];
 903: /* get standard core values */
 904:   valueptr->type=tmp_value.type;
 905:   (void)strcpy(valueptr->section,tmp_value.section);
 906:   valueptr->top_int=tmp_value.top_int;
 907:   valueptr->bot_int=tmp_value.bot_int;
 908:   valueptr->sb_depth=tmp_value.sb_depth;
 909:   valueptr->otherodp=tmp_value.otherodp;
 910:         if(fabs(valueptr->sb_depth - BAD_CODE) <= ROUNDCHECK) {
 911:           valueptr->quality=BAD_SB_DEPTH;
 912:         }
 913:         else {
 914:     valueptr->quality=GOOD;
 915:         }
 916:   valueptr->run_num=0;
 917:   valueptr->data=&valueptr->otherodp;
 918:   valueptr->sm_data=*valueptr->data;
 919:   return(False);
 920: 
 921: }
 922: 
 923: int SpReadMST95report(fptr,dataptr)
 924: FILE  *fptr;
 925: DataFile  *dataptr;
 926: {
 927: /* return False=more data, true=done */
 928:   char  c_value[20];
 929:   int core,this_hole,this_core,max_alloc,nm_num,pos;
 930:   Hole  *holeptr;
 931:   Core  *coreptr;
 932:   Value *valueptr;
 933:   int i,len;
 934: 
 935: /* read one data line */
 936:   if(fgets(line,MAXLINE,fptr)!=NULL)
 937:   {
 938:   /* get rid of ending blanks */
 939:     len=(int)strlen(line);
 940:     for(i=len-1;i>0 && isspace(line[i]);i--)
 941:       line[i]='\0';
 942:     len=(int)strlen(line);
 943:   /* get  standard header information */
 944:     (void)strncpy(c_value,&line[1],3); c_value[3]='\0';
 945:     dataptr->leg=atol(c_value);
 946:     dataptr->subleg = line[5];
 947:     (void)strncpy(c_value,&line[7],4); c_value[4]='\0';
 948:     dataptr->site= atol(c_value);
 949: 
 950:     /* check if new hole */
 951:     if(dataptr->holes_used==NULL || strchr(dataptr->holes_used,line[12])==NULL)
 952:     {
 953:       dataptr->numholes++;
 954:       if(line[12]==' ') /* no hole given, ignore line */
 955:       {
 956:         dataptr->readerrors++;
 957:         return(False);
 958:       }
 959:       if(dataptr->numholes >1)  /* not first hole */
 960:       {
 961:         if((charptr=(char*)realloc(dataptr->holes_used,(dataptr->numholes+1)*CHAR_SIZE))==NULL)
 962:           SpBadMemAlloc("SpReadMST95report 1");
 963:         else
 964:           dataptr->holes_used = charptr;
 965:         if((charptr=(char*)realloc((char*)dataptr->holes,dataptr->numholes*sizeof(Hole*)))==NULL)
 966:           SpBadMemAlloc("SpReadMST95report 2");
 967:         else
 968:           dataptr->holes=(Hole**)charptr;
 969:       }
 970:       else    /* first hole */
 971:       {
 972:         if((dataptr->holes_used=(char*)calloc(2,sizeof(char)))==NULL)
 973:           SpBadMemAlloc("SpReadMST95report 3");
 974:         dataptr->holes_used[0]='\0';
 975:         if((dataptr->holes=(Hole**)calloc(dataptr->numholes,sizeof(Hole*)))==NULL)
 976:           SpBadMemAlloc("SpReadMST95report 4");
 977:       }
 978:       /* set hole values */
 979:       if((dataptr->holes[dataptr->numholes-1]=(Hole*)calloc(1,sizeof(Hole)))==NULL)
 980:         SpBadMemAlloc("SpReadMST95report 5");
 981:       this_hole=dataptr->numholes-1;
 982:       holeptr=dataptr->holes[this_hole];
 983:       holeptr->name=toupper(line[12]);
 984:       (void)sprintf(dataptr->holes_used,"%s%c",dataptr->holes_used,line[12]);
 985:       holeptr->numcores=0;
 986:     }
 987:     else  /* hole already exists */
 988:       for(this_hole=0;this_hole<dataptr->numholes && 
 989:           dataptr->holes[this_hole]->name!=line[12];this_hole++);
 990:     holeptr=dataptr->holes[this_hole];
 991:     /* get core value */
 992:     (void)strncpy(c_value,&line[14],3); c_value[3]='\0';
 993:     core=atol(c_value);
 994:     /* check if new core*/
 995:     for(this_core=0;this_core<holeptr->numcores && core != holeptr->core[this_core]->num;this_core++);
 996:     if(this_core >= holeptr->numcores)
 997:     {
 998:       if(holeptr->numcores++>0) /* not first core*/
 999:       {
1000:         if((charptr=(char*)realloc((char*)holeptr->core,holeptr->numcores*sizeof(Core*)))==NULL)
1001:           SpBadMemAlloc("SpReadMST95report 6");
1002:         else
1003:           holeptr->core=(Core**)charptr;
1004:       }
1005:       else    /* firstcore */
1006:       {
1007:         if((holeptr->core=(Core**)malloc(holeptr->numcores*sizeof(Core*)))==NULL)
1008:           SpBadMemAlloc("SpReadMST95report 7");
1009:       }
1010:       /* set core values */
1011:       if((holeptr->core[this_core]=(Core*)calloc(1,sizeof(Core)))==NULL)
1012:         SpBadMemAlloc("SpReadMST95report 8");
1013:       coreptr=holeptr->core[this_core];
1014:       coreptr->num=core;
1015:       coreptr->numvalues=0;
1016:       if((coreptr->value=(Value**)calloc(ALLOC_INT,sizeof(Value*)))==NULL)
1017:         SpBadMemAlloc("SpReadMST95report 9");
1018:       for(coreptr->allocvalues=0;coreptr->allocvalues<ALLOC_INT;coreptr->allocvalues++)
1019:       {
1020:         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
1021:           SpBadMemAlloc("SpReadMST95report 10");
1022:       }
1023:     }
1024:     coreptr=holeptr->core[this_core];
1025:     coreptr->cum_dep_offset=0.0;
1026:     coreptr->did_offset=False;
1027:     if(coreptr->numvalues++ >= coreptr->allocvalues)
1028:     {
1029:       max_alloc=coreptr->allocvalues+ALLOC_INT;
1030:       if((charptr=(char*)realloc((char*)coreptr->value,max_alloc*sizeof(Value*)))==NULL)
1031:         SpBadMemAlloc("SpReadMST95report 11");
1032:       else
1033:         coreptr->value=(Value**) charptr;
1034:       for(;coreptr->allocvalues<max_alloc;coreptr->allocvalues++)
1035:       {
1036:         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
1037:           SpBadMemAlloc("SpReadMST95report 12");
1038:       }
1039:     }
1040:     valueptr=coreptr->value[coreptr->numvalues-1];
1041:   /* get standard core values */
1042:     valueptr->type=line[18];
1043:     valueptr->type=toupper(valueptr->type);
1044:     if(isspace(line[20]))
1045:     {
1046:       (void)strncpy(valueptr->section,&line[21],1);
1047:       valueptr->section[1]='\0';
1048:     }
1049:     else
1050:       (void)strncpy(valueptr->section,&line[20],2);
1051:     valueptr->section[2]='\0';
1052:     for(i=0;i<(int)strlen(valueptr->section);i++)
1053:     {
1054:       if(isalpha(valueptr->section[i]))
1055:         valueptr->section[i]=toupper(valueptr->section[i]);
1056:     }
1057:     (void)strncpy(c_value,&line[23],5); c_value[5]='\0';
1058:     valueptr->top_int=(float)atof(c_value);
1059:     (void)strncpy(c_value,&line[29],5); c_value[5]='\0';
1060:     valueptr->bot_int=(float)atof(c_value);
1061:     (void)strncpy(c_value,&line[35],7); c_value[7]='\0';
1062:     valueptr->sb_depth=(float)atof(c_value);
1063:                 if(fabs(valueptr->sb_depth - BAD_CODE) <= ROUNDCHECK) {
1064:                   valueptr->quality=BAD_SB_DEPTH;
1065:                 }
1066:                 else {
1067:       valueptr->quality=GOOD;
1068:                 }
1069:   /* get data type specific values */
1070:     if(dataptr->type==GRAPE)
1071:     {
1072:       if(len!=72)
1073:       {
1074:         coreptr->numvalues--;
1075:         message.error=True;
1076:         message.fatal=False;
1077:         message.caller=SPREADMST95REPORT;
1078:         message.type=XmDIALOG_WARNING;
1079:         message.default_button=XmDIALOG_OK_BUTTON;
1080:         if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL)
1081:           SpBadMemAlloc("SpReadMST95report 13");
1082:         (void)sprintf(message.label,"Invalid Grape and/or MST95 format at. %c  %d  %s  %6.1f %6.1f %8.2f",
1083:                                               holeptr->name, coreptr->num, valueptr->section, 
1084:                                               valueptr->top_int, valueptr->bot_int, valueptr->sb_depth);
1085:         return(False);
1086:       }
1087:       if((valueptr->grape=(Grapedata*)calloc(1,sizeof(Grapedata)))==NULL)
1088:         SpBadMemAlloc("SpReadMST95report 14");
1089:       (void)strncpy(c_value,&line[46],5);c_value[5]='\0';
1090:       valueptr->grape->density=(float)atof(c_value);
1091:       valueptr->data=&valueptr->grape->density;
1092:       valueptr->sm_data=valueptr->grape->density;
1093:       (void)strncpy(c_value,&line[54],5);c_value[5]='\0';
1094:       valueptr->grape->b_corr_density=(float)atof(c_value);
1095:       (void)strncpy(c_value,&line[62],5);c_value[5]='\0';
1096:       valueptr->grape->gamma_counts=atol(c_value);
1097:       (void)strncpy(c_value,&line[68],4);c_value[4]='\0';
1098:       valueptr->run_num=atol(c_value);
1099:     } 
1100:     else if (dataptr->type==PWAVE)
1101:     {
1102:       if(len!=82)
1103:       {
1104:                                 coreptr->numvalues--;
1105:                                 message.error=True;
1106:                                 message.fatal=False; 
1107:                                 message.caller=SPREADMST95REPORT;
1108:                                 message.type=XmDIALOG_WARNING; 
1109:                                 message.default_button=XmDIALOG_OK_BUTTON; 
1110:                                 if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL)
1111:                                         SpBadMemAlloc("SpReadMST95report 15");
1112:         (void)sprintf(message.label,"Invalid Pwave and/or MST95 format at. %c  %d  %s  %6.1f %6.1f %8.2f",
1113:                                                holeptr->name, coreptr->num, valueptr->section, valueptr->top_int, valueptr->bot_int,
1114:                                                valueptr->sb_depth);
1115:         return(False);
1116:       }
1117:       if((valueptr->pwave=(Pwavedata*)calloc(1,sizeof(Pwavedata)))==NULL)
1118:         SpBadMemAlloc("SpReadMST95report 16");
1119:       (void)strncpy(c_value,&line[44],7); c_value[7]='\0';
1120:       valueptr->pwave->velocity=(float)atof(c_value);
1121:       valueptr->data=&valueptr->pwave->velocity;
1122:       valueptr->sm_data=valueptr->pwave->velocity;
1123:       (void)strncpy(c_value,&line[51],4); c_value[4]='\0';
1124:       valueptr->pwave->sig_strength=atol(c_value);
1125:       (void)strncpy(c_value,&line[56],4); c_value[4]='\0';
1126:       valueptr->pwave->travel_time=atol(c_value);
1127:       (void)strncpy(c_value,&line[71],5); c_value[5]='\0';
1128:       valueptr->pwave->displacement=atol(c_value);
1129:       (void)strncpy(c_value,&line[78],4); c_value[4]='\0';
1130:       valueptr->run_num=atol(c_value);
1131:     }
1132:     else if (dataptr->type==NATURALGAMMA)
1133:     {
1134:       if(len!=92)
1135:       {
1136:                                 coreptr->numvalues--;
1137:                                 message.error=True; 
1138:                                 message.fatal=False;  
1139:                                 message.caller=SPREADMST95REPORT; 
1140:                                 message.type=XmDIALOG_WARNING;  
1141:                                 message.default_button=XmDIALOG_OK_BUTTON;  
1142:                                 if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL)
1143:                                         SpBadMemAlloc("SpReadMST95report 17");
1144:         (void)sprintf(message.label,"Invalid Natural Gamma and/or MST95 format at. %c  %d  %s  %6.1f %6.1f %8.2f",
1145:                                                holeptr->name, coreptr->num, valueptr->section, valueptr->top_int, valueptr->bot_int,
1146:                                                valueptr->sb_depth);
1147:         return(False);
1148:       }
1149:       if((valueptr->naturalgamma=(Natgammadata*)calloc(1,sizeof(Natgammadata)))==NULL)
1150:                                 SpBadMemAlloc("SpReadMST95report 18");
1151:       (void)strncpy(c_value,&line[44],8); c_value[8]='\0';
1152:       valueptr->naturalgamma->total_cnt=(float)atol(c_value);
1153:       valueptr->data=&valueptr->naturalgamma->total_cnt;
1154:       valueptr->sm_data=valueptr->naturalgamma->total_cnt;
1155:       (void)strncpy(c_value,&line[52],5); c_value[5]='\0';
1156:       valueptr->naturalgamma->sample_time=atol(c_value);
1157:       (void)strncpy(c_value,&line[58],5); c_value[5]='\0';
1158:       valueptr->naturalgamma->seg1_cnt=atof(c_value);
1159:       (void)strncpy(c_value,&line[64],5); c_value[5]='\0';
1160:       valueptr->naturalgamma->seg2_cnt=atof(c_value);
1161:       (void)strncpy(c_value,&line[70],5); c_value[5]='\0';
1162:       valueptr->naturalgamma->seg3_cnt=atof(c_value);
1163:       (void)strncpy(c_value,&line[76],5); c_value[5]='\0';
1164:       valueptr->naturalgamma->seg4_cnt=atof(c_value);
1165:       (void)strncpy(c_value,&line[82],5); c_value[5]='\0';
1166:       valueptr->naturalgamma->seg5_cnt=atof(c_value);
1167:       (void)strncpy(c_value,&line[88],4); c_value[4]='\0';
1168:       valueptr->run_num=atol(c_value);
1169:     }
1170:     else if (dataptr->type==SUSCEPTIBILITY)
1171:     {
1172:       if(len!=63)
1173:       {
1174:                                 coreptr->numvalues--;
1175:                                 message.error=True;  
1176:                                 message.fatal=False;   
1177:                                 message.caller=SPREADMST95REPORT;  
1178:                                 message.type=XmDIALOG_WARNING;   
1179:                                 message.default_button=XmDIALOG_OK_BUTTON;   
1180:                                 if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL) 
1181:                                         SpBadMemAlloc("SpReadMST95report 19");
1182:         (void)sprintf(message.label,"Invalid Magnetic Susceptibility and/or MST95 format at. %c  %d  %s  %6.1f %6.1f %8.2f",
1183:                                                holeptr->name, coreptr->num, valueptr->section, valueptr->top_int, valueptr->bot_int,
1184:                                                valueptr->sb_depth);
1185:         return(False);
1186:       }
1187:       if((valueptr->susceptibility=(Susceptibility*)calloc(1,sizeof(Susceptibility)))==NULL)
1188:                                 SpBadMemAlloc("SpReadMST95report 20");
1189:       (void)strncpy(c_value,&line[44],6); c_value[7]='\0';
1190:       valueptr->susceptibility->observed=(float)atof(c_value);
1191:       (void)strncpy(c_value,&line[50],8); c_value[7]='\0';
1192:       valueptr->susceptibility->corrected=(float)atof(c_value);
1193:       valueptr->data=&valueptr->susceptibility->corrected;
1194:       valueptr->sm_data=valueptr->susceptibility->corrected;
1195:       (void)strncpy(c_value,&line[59],4); c_value[4]='\0';
1196:       valueptr->run_num=atol(c_value);
1197:     }
1198:     else if(dataptr->type==REFLECTANCEMST)
1199:     {
1200:       if(len!=267)
1201:       {
1202:                                 coreptr->numvalues--;
1203:                                 message.error=True;   
1204:                                 message.fatal=False;    
1205:                                 message.caller=SPREADMST95REPORT;   
1206:                                 message.type=XmDIALOG_WARNING;    
1207:                                 message.default_button=XmDIALOG_OK_BUTTON;    
1208:                                 if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL)  
1209:                                         SpBadMemAlloc("SpReadMST95report 21");
1210:         (void)sprintf(message.label,"Invalid Reflectance and/or MST95 format at. %c  %d  %s  %6.1f %6.1f %8.2f",
1211:                                                holeptr->name, coreptr->num, valueptr->section, valueptr->top_int, valueptr->bot_int,
1212:                                                valueptr->sb_depth);
1213:         return(False);
1214:       }
1215:       if((valueptr->reflectanceMST=(ReflectanceMST*)calloc(1,sizeof(ReflectanceMST)))==NULL)
1216:         SpBadMemAlloc("SpReadMST95report 22");
1217:       (void)strncpy(c_value,&line[45],6); c_value[7]='\0';
1218:       valueptr->reflectanceMST->L=(float)atof(c_value);
1219:       (void)strncpy(c_value,&line[52],6); c_value[7]='\0';
1220:       valueptr->reflectanceMST->a=(float)atof(c_value);
1221:       (void)strncpy(c_value,&line[59],6); c_value[7]='\0';
1222:       valueptr->reflectanceMST->b=(float)atof(c_value);
1223:       (void)strncpy(valueptr->reflectanceMST->munsell_hue,&line[66],6);
1224:       (void)strncpy(valueptr->reflectanceMST->munsell_value,&line[73],9);
1225:       pos=81;
1226:       for(nm_num=0;nm_num<31;nm_num++)
1227:       {
1228:         (void)strncpy(c_value,&line[pos],6); c_value[7]='\0';
1229:         valueptr->reflectanceMST->nm_value[nm_num]=(float)atof(c_value);
1230:         pos+=6;
1231:       }
1232:       valueptr->data=&valueptr->reflectanceMST->nm_value[15];
1233:       valueptr->sm_data=valueptr->reflectanceMST->nm_value[15];
1234:       valueptr->run_num=0;
1235:     }
1236:                 else if(dataptr->type==OTHERTYPE) 
1237:                 {
1238: 
1239:                 }
1240:     else
1241:     {       message.error=True;    
1242:                         message.fatal=False;     
1243:                         message.caller=SPREADMST95REPORT;    
1244:                         message.type=XmDIALOG_WARNING;     
1245:                         message.default_button=XmDIALOG_OK_BUTTON;     
1246:                         if((message.label=(char*)calloc(500,CHAR_SIZE))==NULL)   
1247:                           SpBadMemAlloc("SpReadMST95report 21");
1248:       (void)sprintf(message.label,"Invalid data type %d.\n",dataptr->type);
1249:       return(False);
1250:     }
1251:     /* return not end of file */
1252:     return(False);
1253:   }
1254:   else  /* end of file found */
1255:     return(True);
1256: }
1257: 
1258: HashInfo **SpReadAffineTable(filename,num)
1259: char  *filename;
1260: int *num;
1261: {
1262:   FILE  *fptr;
1263:   int i,alloc_num,j, nh, nc,
1264:     hashsize,status;
1265:   HashInfo  **affineinfo;
1266:   float   xvalue,dummy1,dummy2;
1267:   char  did_it;
1268:         void CheckAffineTableOrder(),
1269:              CheckAffineTableMissingHole(),
1270:              MapHoleToAffineTable(),
1271:              CheckAffineTableMissingCore(),
1272:              MapCoreToAffineTable();
1273: 
1274: /* open input affine table */
1275:   if((fptr=fopen(filename,"r"))==NULL)
1276:   {
1277:     message.error=True;
1278:     message.fatal=False;
1279:     message.default_button=XmDIALOG_OK_BUTTON;
1280:     message.type=XmDIALOG_ERROR;
1281:     message.caller=SPREADAFFINETABLE;
1282:     if((message.label=(char*)calloc((int)strlen(filename)+50,CHAR_SIZE))==NULL)
1283:       SpBadMemAlloc("SpReadAffineTable 1");
1284:     (void)sprintf(message.label,"error opening affine table %s.",filename);
1285:     SpManageMessage(message);
1286:   }
1287:   else
1288:   {
1289:     message.error=False;
1290:   /* allocate initial array */
1291:     alloc_num=ALLOC_INT;
1292:     if((affineinfo=(HashInfo**)calloc(alloc_num,sizeof(HashInfo*)))==NULL)
1293:       SpBadMemAlloc("SpReadAffineTable 2");
1294:     hashsize=sizeof(HashInfo);
1295:     for(i=0;i<alloc_num;i++)
1296:     {
1297:       if((affineinfo[i]=(HashInfo*)calloc(1,hashsize))==NULL)
1298:         SpBadMemAlloc("SpReadAffineTable 3");
1299:     }
1300:   /* read affine table */
1301:     for(j=0;(status=fscanf(fptr,"%d %d %c %d %c %f %c",&affineinfo[j]->leg,
1302:         &affineinfo[j]->site,&affineinfo[j]->hole,&affineinfo[j]->core,
1303:         &affineinfo[j]->coretype,&xvalue,&did_it))==7;
1304:         j++)
1305:     {
1306:     /* convert data values as needed */
1307:       affineinfo[j]->hole=toupper(affineinfo[j]->hole);
1308:       affineinfo[j]->coretype=toupper(affineinfo[j]->coretype);
1309:       did_it=toupper(did_it);
1310:       affineinfo[j]->value= rint(xvalue*100.0);
1311:       affineinfo[j]->subleg=' ';
1312:       if(did_it=='N')
1313:         affineinfo[j]->value2=False;
1314:       else
1315:         affineinfo[j]->value2=True;
1316:                 /* put values in affine table */ 
1317:                         if(j == 0) {
1318:                           strcpy(affinetable.hole[0].name, &affineinfo[0]->hole);
1319:                           nh = 0;
1320:                           nc = 0;
1321:                           affinetable.numhole = 1;
1322:                           affinetable.hole[0].numcore = 0;
1323:                         }
1324:                         else if(j > 0 && affineinfo[j]->hole != affineinfo[j-1]->hole) {
1325:                           ++nh;
1326:                           ++affinetable.numhole;
1327:                           strcpy(affinetable.hole[nh].name, &affineinfo[j]->hole);
1328:                           nc = 0;
1329:                           affinetable.hole[nh].numcore = 0;
1330:                         }
1331:                         affinetable.hole[nh].core[nc].leg = affineinfo[j]->leg;
1332:                         affinetable.hole[nh].core[nc].site = affineinfo[j]->site;
1333:                         affinetable.hole[nh].core[nc].name = affineinfo[j]->core;
1334:                         strncpy(affinetable.hole[nh].core[nc].type, &affineinfo[j]->coretype, 1);
1335:                         affinetable.hole[nh].core[nc].cum_depth_offset = xvalue;
1336:                         affinetable.hole[nh].core[nc].did_offset = affineinfo[j]->value2;
1337:                         ++nc;
1338:                         ++affinetable.hole[nh].numcore;
1339: 
1340:     /* allocate more memory if necessary */
1341:       if(j+1>=alloc_num)
1342:       {
1343:         alloc_num+=ALLOC_INT;
1344:         if((charptr=(char*)realloc((char*)affineinfo,alloc_num*sizeof(HashInfo*)))==NULL)
1345:           SpBadMemAlloc("SpReadAffineTable 4");
1346:         else
1347:           affineinfo=(HashInfo**)charptr;
1348:         for(i=j+1;i<alloc_num;i++)
1349:         {
1350:           if((affineinfo[i]=(HashInfo*)calloc(1,hashsize))==NULL)
1351:             SpBadMemAlloc("SpReadAffineTable 5");
1352:         }
1353:       }
1354:     }
1355: 
1356:     if(status!=EOF)
1357:     {
1358:       message.error=True;
1359:       message.fatal=False;
1360:       message.default_button=XmDIALOG_OK_BUTTON;
1361:       message.caller=SPREADAFFINETABLE;
1362:       message.type=XmDIALOG_ERROR;
1363:       if((message.label=(char*)calloc((int)strlen(filename)+100,CHAR_SIZE))==NULL)
1364:         SpBadMemAlloc("SpReadAffineTable 6");
1365:       (void)sprintf(message.label,"Error reading affine table %s line %d.",filename,j);
1366:       for(i=0;i<alloc_num;i++)
1367:       {
1368:         if(affineinfo[i])
1369:         {
1370:           free(affineinfo[i]);
1371:           affineinfo[i]=NULL;
1372:         }
1373:       }
1374:       if(affineinfo)
1375:       {
1376:         free(affineinfo);
1377:         affineinfo=NULL;
1378:       }
1379:     }
1380:                 else 
1381:                 {
1382:                   for(i=0; i<dataset_cnt; ++i) {
1383:                     (void)CheckAffineTableOrder(&affinetable);
1384:                     (void)CheckAffineTableMissingHole(&affinetable, i);
1385:                     (void)MapHoleToAffineTable(&affinetable, i);
1386:                     (void)CheckAffineTableMissingCore(&affinetable, i);
1387:                     (void)MapCoreToAffineTable(&affinetable, i);
1388:                   }
1389:                 }
1390: 
1391:     *num=j;
1392:     fclose(fptr);
1393:   }
1394:   return(affineinfo);
1395: }
1396: 
1397: HashInfo **SpReadCullTable(filename,num)
1398: char  *filename;
1399: int *num;
1400: {
1401:   int fdcull,i,alloc_num,j,
1402:     hashsize,status;
1403:   HashInfo  **cullinfo;
1404: 
1405: /* open input cull table */
1406:   if((fdcull=open(filename,O_RDONLY|O_CREAT,0))== -1)
1407:     return((HashInfo**)NULL);
1408:   else
1409:   {
1410:   /* allocate initial array */
1411:     alloc_num=ALLOC_INT;
1412:     if((cullinfo=(HashInfo**)calloc(alloc_num,sizeof(HashInfo*)))==NULL)
1413:       SpBadMemAlloc("SpCullTable 2");
1414:     hashsize=sizeof(HashInfo);
1415:     for(i=0;i<alloc_num;i++)
1416:     {
1417:       if((cullinfo[i]=(HashInfo*)calloc(1,hashsize))==NULL)
1418:         SpBadMemAlloc("SpCullTable 3");
1419:     }
1420:   /* read cull table */
1421:     status=hashsize;
1422:     for(j=0;status==hashsize;j++)
1423:     {
1424:     /* allocate more memory if necessary */
1425:       if(j>=alloc_num)
1426:       {
1427:         alloc_num+=ALLOC_INT;
1428:         if((charptr=(char*)realloc((char*)cullinfo,alloc_num*sizeof(HashInfo*)))==NULL)
1429:           SpBadMemAlloc("SpCullTable 4");
1430:         else
1431:           cullinfo=(HashInfo**)charptr;
1432:         for(i=j;i<alloc_num;i++)
1433:         {
1434:           if((cullinfo[i]=(HashInfo*)calloc(1,hashsize))==NULL)
1435:             SpBadMemAlloc("SpCullTable 5");
1436:         }
1437:       }
1438:       status=read(fdcull,(char *) cullinfo[j],hashsize);
1439:     }
1440:     *num=j-1;
1441:     close(fdcull);
1442:   }
1443:   if(status!=0 || *num == 0)
1444:     return((HashInfo**)NULL);
1445:   else
1446:     return(cullinfo);
1447: }
1448: 
1449: int SpWriteAffineTable(affineptr,filename)
1450: AffineTable     *affineptr;
1451: char    *filename;
1452: {
1453:   FILE  *fptr;
1454:   int i,j;
1455:   char  did_it;
1456: 
1457: 
1458: /* open output affinetable */
1459:   if((fptr=fopen(filename,"w"))==NULL)
1460:   {
1461:     message.error=True;
1462:     message.fatal=False;
1463:     message.caller=SPWRITEAFFINETABLE;
1464:     message.default_button=XmDIALOG_OK_BUTTON;
1465:     message.type=XmDIALOG_ERROR;
1466:     if((message.label=(char*)calloc((int)strlen(filename)+50,CHAR_SIZE))==NULL)
1467:       SpBadMemAlloc("SpWriteAffineTable 1");
1468:     (void)sprintf(message.label,"Error opening affine table %s.",filename);
1469:     SpManageMessage(message);
1470:   }
1471:   else
1472:   {
1473:     message.error=False;
1474:   /* write out file */
1475:     for(i=0;i<affineptr->numhole;i++)
1476:     {
1477:       for(j=0;j<affineptr->hole[i].numcore;j++)
1478:       {
1479:         if(affineptr->hole[i].core[j].did_offset)
1480:           did_it='Y';
1481:         else
1482:           did_it='N';
1483: 
1484:         (void)fprintf(fptr,"%d\t%d\t%s\t%d\t%s\t%.2f\t%c\n", affineptr->hole[i].core[j].leg,
1485:           affineptr->hole[i].core[j].site, affineptr->hole[i].name, affineptr->hole[i].core[j].name,
1486:           affineptr->hole[i].core[j].type, 
1487:                                         affineptr->hole[i].core[j].cum_depth_offset, did_it);
1488:       }
1489:     }
1490:     fclose(fptr);
1491:   }
1492:   return(!message.error);
1493: }
1494: 
1495: int SpWriteCullTable(dataptr,filename)
1496: DataFile  *dataptr;
1497: char    *filename;
1498: {
1499:   int fdcull,flag;
1500:   int i,j,k;
1501:   HashInfo  info;
1502:   Core  *coreptr;
1503: #if OS == SUNOS
1504:   int write();
1505: #elif OS == SOLARIS
1506:   ssize_t write();
1507: #endif
1508: 
1509: 
1510: /* open output cull table */
1511:   if((fdcull=open(filename,O_WRONLY|O_CREAT,0744))== -1)
1512:   {
1513:     message.error=True;
1514:     if((charptr=(char*)calloc((int)strlen(filename)+50,CHAR_SIZE))==NULL)
1515:       SpBadMemAlloc("SpWriteCullTable 1");
1516:     else
1517:       (void)sprintf(charptr,"Error opening cull table %s.",filename);
1518:     SpManageWarningBox(charptr);
1519:     free(charptr);
1520:   }
1521:   else
1522:   {
1523:     message.error=False;
1524:   /* write out file */
1525:     info.leg=dataptr->leg;
1526:     info.subleg=dataptr->subleg;
1527:     info.site=dataptr->site;
1528:     flag=BAD_CULL1 | BAD_CULL2 | BAD_TOP;
1529:     for(i=0;i<dataptr->numholes;i++)
1530:     {
1531:       info.hole=dataptr->holes[i]->name;
1532:       {
1533:         for(j=0;j<dataptr->holes[i]->numcores;j++)
1534:         {
1535:           coreptr=dataptr->holes[i]->core[j];
1536:           info.core=coreptr->num;
1537:           for(k=0;k<coreptr->numvalues;k++)
1538:           {
1539:             info.coretype=coreptr->value[k]->type;
1540:             (void)strcpy(info.section,coreptr->value[k]->section);
1541:             info.top_int=coreptr->value[k]->top_int;
1542:           /* write flagged values to file */
1543:             if((info.value=coreptr->value[k]->quality) & flag)
1544:               (void)write(fdcull,(char*)&info,sizeof(HashInfo));
1545:           }
1546:         }
1547:       }
1548:     }
1549:     close(fdcull);
1550:   }
1551:   return(!message.error);
1552: }
1553: 
1554: int     SpWriteAgeModel(fptr)
1555: FILE    *fptr;
1556: {
1557:         int i;
1558:         char    topoffset[6],botoffset[6],
1559:                 topmsd[9],botmsd[9];
1560: 
1561:         if(agemodel_cnt < 1) 
1562:         {
1563:           return;
1564:         }
1565:         else 
1566:         {
1567:           for(i=0; i<agemodel_cnt; ++i) 
1568:           {
1569:             if(agemodel[i].top.in_affine == NO)
1570:             {
1571:                 (void)sprintf(topmsd,"N/A");
1572:                 (void)sprintf(topoffset,"N/A");
1573:             }
1574:             else
1575:             {
1576:                 (void)sprintf(topmsd,"%.2f",agemodel[i].top.sb_depth+agemodel[i].top.offset);
1577:                 (void)sprintf(topoffset,"%.2f",agemodel[i].top.offset);
1578:             }
1579:             if(agemodel[i].bot.in_affine == NO)
1580:             {
1581:                 (void)sprintf(topmsd,"N/A");
1582:                 (void)sprintf(botoffset,"N/A");
1583:             }
1584:             else
1585:             {
1586:                 (void)sprintf(botmsd,"%.2f",agemodel[i].bot.sb_depth+agemodel[i].bot.offset);
1587:                 (void)sprintf(botoffset,"%.2f",agemodel[i].bot.offset);
1588:             }
1589: 
1590:             fprintf(fptr,"%8.3f\t%8.3f\t%8.4f\t%8.3f\t%s\t%s", 
1591:                       agemodel[i].avembsf, agemodel[i].avemcd, agemodel[i].aveage, agemodel[i].sedrate, 
1592:                       agemodel[i].name, agemodel[i].code);
1593:             if(agemodel[i].type == PALEOMAG) {
1594:               fprintf(fptr, "\tPaleomag\n");
1595:             }
1596:             else if(agemodel[i].type == DIATOMS) {
1597:               fprintf(fptr, "\tDiatom\n");
1598:             }
1599:             else if(agemodel[i].type == RADIOLARIA) {
1600:               fprintf(fptr, "\tRadiolaria\n");
1601:             }
1602:             else if(agemodel[i].type == FORAMINIFERA) {
1603:               fprintf(fptr, "\tForaminifera\n");
1604:             }
1605:             else if(agemodel[i].type == NANNOFOSSILS) {
1606:               fprintf(fptr, "\tNannofossil\n");
1607:             }
1608:             else if(agemodel[i].type == HANDPICK) {
1609:               fprintf(fptr, "\tHandpick\n");
1610:             }
1611:             else if(agemodel[i].type == TIME) {
1612:               fprintf(fptr, "\tTimeSeries\n");
1613:             }
1614:             else {
1615:               fprintf(fptr, "\n");
1616:             }
1617:           }
1618:         }
1619:         return(True);
1620: }
1621: 
1622: int     SpReadAgeModel(fptr)
1623: FILE    *fptr;
1624: {
1625:         int i, status;
1626:         char s[201], strattype[50];
1627: 
1628:         agemodel_cnt = 0;
1629:         status = 1;
1630: 
1631:         for(i=0; i<MAXAGE; ++i) 
1632:         {
1633:           if(fgets(s, 200, fptr) == NULL) {
1634:             return;
1635:           }
1636:           sscanf(s, "%f %f %f %f %s %s %s",
1637:                    &agemodel[i].avembsf, &agemodel[i].avemcd, &agemodel[i].aveage, &agemodel[i].sedrate,
1638:                    &agemodel[i].name, &agemodel[i].code, strattype);
1639:           if(strcmp(strattype, "Paleomag") == 0) {
1640:             agemodel[i].type = PALEOMAG;
1641:           }
1642:           else if(strcmp(strattype, "Diatom") == 0) {
1643:             agemodel[i].type = DIATOMS;
1644:           }
1645:           else if(strcmp(strattype, "Radiolaria") == 0) {
1646:             agemodel[i].type = RADIOLARIA;
1647:           }
1648:           else if(strcmp(strattype, "Foraminifera") == 0) {
1649:             agemodel[i].type = FORAMINIFERA;
1650:           }
1651:           else if(strcmp(strattype, "Nannofossil") == 0) {
1652:             agemodel[i].type = NANNOFOSSILS;
1653:           }
1654:           else if(strcmp(strattype, "Handpick") == 0) {
1655:             agemodel[i].type = HANDPICK;
1656:           }
1657:           else if(strcmp(strattype, "TimeSeries") == 0) {
1658:             agemodel[i].type = TIME;
1659:           }
1660:           else {
1661:             agemodel[i].type = -1;
1662:           }
1663:           sprintf(strattype,"");
1664: 
1665:           ++agemodel_cnt;
1666:         }
1667:         sprintf(s,"");
1668:         return(True);
1669: }
1670: 
1671: void ReadPreviewInput(file)
1672: char *file;
1673: {
1674:   int l, len;
1675:   char *text;
1676:   FILE *fd;
1677:   XmTextPosition  pos;
1678: 
1679:   if((fd = fopen(file, "r"))==NULL) {
1680:     message.error=True;
1681:     message.fatal=False;
1682:     message.default_button=XmDIALOG_OK_BUTTON;
1683:     message.type=XmDIALOG_ERROR;
1684:     message.caller=NONE;
1685:     if((message.label=(char*)calloc((int)strlen(file)+100,CHAR_SIZE))==NULL)
1686:                         SpBadMemAlloc("SpReadPreviewInput 1");
1687:     (void)sprintf(message.label,"Error: could not open preview input file  %s.",file);
1688:     SpManageMessage(message);
1689:   }
1690:   else {
1691:     l = 0;
1692:     len = 500;
1693:     if((text=(char*)calloc(len * MAXPREVIEW + 1000, CHAR_SIZE))==NULL)
1694:                 SpBadMemAlloc("ReadPreviewInput 2");
1695:     (void)sprintf(text, "");
1696:     (void)sprintf(text, "%s\n\n", file);
1697:     while((fgets(line,500,fd) != NULL) && l<MAXPREVIEW) {
1698:       ++l;
1699:       (void)strcat(text, line);
1700:     }
1701:   } 
1702:   fclose(fd);
1703: 
1704:   pos=XmTextGetLastPosition(textPreviewInput);
1705: 
1706:   XmTextInsert(textPreviewInput,pos,text);
1707: 
1708:   free(text);
1709: }
1710: 
1711: int ReadTimeSeries(file)
1712: char *file;
1713: {
1714:   void ViewSpliceVsAge();
1715:   int i, n, ndiv, all, moreall, sumall, valcol, agecol, nline;
1716:   char *fmt, *str;
1717:   float minval, maxval, startage, endage, age, val, sumval;
1718:   FILE *fd;
1719: 
1720:   /* get the time series read info
1721:   */
1722:   str = XmTextGetString(textFieldTimeSeriesAgeCol);
1723:   agecol = atoi(str);
1724:   free(str);
1725:   str = XmTextGetString(textFieldTimeSeriesValCol);
1726:   valcol = atoi(str);
1727:   free(str);
1728:   str = XmTextGetString(textFieldTimeSeriesFromAge);
1729:   startage = atof(str);
1730:   free(str);
1731:   str = XmTextGetString(textFieldTimeSeriesToAge);
1732:   endage = atof(str);
1733:   free(str);
1734:   if(fabs(endage - 0.0) < 0.0001) {
1735:     endage = 999.9;
1736:   }
1737: 
1738:   if(XmToggleButtonGetState(toggleButtonTimeSeriesAgeMa) == True) {
1739:     timeseries.MaConvert = 1.0;
1740:   }
1741:   else if(XmToggleButtonGetState(toggleButtonTimeSeriesAgeKyr) == True) {
1742:     timeseries.MaConvert = 0.001;
1743:   }
1744:   else if(XmToggleButtonGetState(toggleButtonTimeSeriesAgeYrs) == True) {
1745:     timeseries.MaConvert = 0.000001;
1746:   }
1747:   else {
1748:   }
1749: 
1750:   /* make the read format
1751:   */
1752:   if((fmt=(char*)calloc(100,CHAR_SIZE)) == NULL)
1753:                  SpBadMemAlloc("ReadTimeSeries");
1754:   (void)sprintf(fmt,"");
1755:   i = 1;
1756:   if(agecol > valcol) {
1757:     if(valcol == 1) {
1758: 
1759:     }
1760:     else {
1761:       while(i<valcol) {
1762:         ++i;
1763:         strcat(fmt,"%*s ");
1764:       }
1765:     }
1766:     strcat(fmt,"%f ");
1767:     ++i;
1768:     if(i == agecol) {
1769:     }
1770:     else {
1771:       while(i<agecol) {
1772:         ++i;
1773:         strcat(fmt,"%*s ");
1774:       }
1775:     }
1776:     strcat(fmt,"%f");
1777:   }
1778:   else if(valcol > agecol) {
1779:     if(agecol == 1) {
1780: 
1781:     }
1782:     else {
1783:       while(i<agecol) {
1784:         ++i;
1785:         strcat(fmt,"%*s ");
1786:       }
1787:     }
1788:     strcat(fmt,"%f ");
1789:     ++i;
1790:     if(i == valcol) {
1791:     }
1792:     else {
1793:       while(i<valcol) {
1794:         ++i;
1795:         strcat(fmt,"%*s ");
1796:       }
1797:     }
1798:     strcat(fmt,"%f");
1799:   }
1800:   else {
1801:   }
1802: 
1803:   all = 500;
1804:   moreall = 100;
1805:   if((fd = fopen(file, "r"))==NULL) {
1806:     message.error=True;
1807:     message.fatal=False;
1808:     message.default_button=XmDIALOG_OK_BUTTON;
1809:     message.type=XmDIALOG_ERROR;
1810:     message.caller=NONE;
1811:     if((message.label=(char*)calloc((int)strlen(file)+100,CHAR_SIZE))==NULL)
1812:                         SpBadMemAlloc("SpReadTimeSeries");
1813:     (void)sprintf(message.label,"Error: could not open time series file  %s.",file);
1814:     SpManageMessage(message);
1815:   }
1816:   else {
1817:     timeseries.age=(float*)calloc(all, sizeof(float));
1818:     timeseries.val=(float*)calloc(all, sizeof(float));
1819:     i=0;
1820:     nline = 0;
1821:     sumall = all;
1822:     while(fgets(line,1000,fd) != NULL) {
1823:       ++nline;
1824:       if(valcol > agecol) {
1825:         if((sscanf(line,fmt, &age, &val)) != 2) {
1826:            if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
1827:               SpBadMemAlloc("ReadTimeSeries");
1828:             }
1829:             else {
1830:               (void)sprintf(charptr,"There is a format problem in time series file. This happened on line %d", nline);
1831:             }
1832:             SpManageWarningBox(charptr);
1833:             free(charptr);
1834:             SpCleanUp(TIMESERIES);
1835:             return 1;
1836:         }
1837:       }
1838:       else if(agecol > valcol) {
1839:         if((sscanf(line,fmt, &val, &age)) != 2) {
1840:           if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
1841:               SpBadMemAlloc("ReadTimeSeries");
1842:             }
1843:             else {
1844:               (void)sprintf(charptr,"There is a format problem in time series file. This happened on line %d", nline);
1845:             }
1846:             SpManageWarningBox(charptr);
1847:             free(charptr);
1848:             SpCleanUp(TIMESERIES);
1849:             return 1;
1850:         }
1851:       }
1852:       age = age * timeseries.MaConvert;
1853: 
1854:       if(age <= endage && age >= startage) {
1855: 
1856:         /* check that the age is in descending order
1857:         */
1858:         if(i>0) {
1859:           if(age < timeseries.age[i-1]) {
1860:             if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
1861:               SpBadMemAlloc("ReadTimeSeries");
1862:             }
1863:             else {
1864:               (void)sprintf(charptr,"The time series is not in descending order.\nThis happened on line %d at %.3f Ma", nline, timeseries.age[i-1]);
1865:               
1866:             }
1867:             SpManageWarningBox(charptr);
1868:             free(charptr);           
1869:             SpCleanUp(TIMESERIES);
1870:             return 1;
1871:           }
1872:         } 
1873:         timeseries.age[i] = age;
1874:         timeseries.val[i] = val;
1875: 
1876:         if(i == 0) {
1877:           minval = timeseries.val[i];
1878:           maxval = timeseries.val[i];
1879:         }
1880:         else if(timeseries.val[i] > maxval) {
1881:           maxval = timeseries.val[i];
1882:         }
1883:         else if(timeseries.val[i] < minval) {
1884:           minval = timeseries.val[i];
1885:         } 
1886: 
1887:         ++i;
1888: 
1889:         if(i >= sumall) {
1890:           sumall = sumall + moreall;
1891:           if((timeseries.age=(float*)realloc((float*)timeseries.age, sumall*sizeof(float)))==NULL)
1892:           {
1893:                         SpBadMemAlloc("ReadTimeSeries");
1894:           }
1895:           else 
1896:           {
1897:           }
1898:           if((timeseries.val=(float*)realloc((float*)timeseries.val, sumall*sizeof(float)))==NULL)
1899:           {
1900:                         SpBadMemAlloc("ReadTimeSeries");
1901:           }
1902:           else
1903:           {
1904:           }
1905:         }
1906:       }
1907:     }
1908:     timeseries.n=i;
1909:     timeseries.minval = minval;
1910:     timeseries.maxval = maxval;
1911:   }
1912:   fclose(fd);
1913:   free(fmt);
1914: 
1915:   if(timeseries.n < 2) {
1916:     if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
1917:               SpBadMemAlloc("ReadTimeSeries");
1918:     }
1919:     else {
1920:       (void)sprintf(charptr,"The time series has less than two points.");
1921:     }
1922:     SpManageWarningBox(charptr);
1923:     free(charptr);
1924:     SpCleanUp(TIMESERIES);
1925:     return 1;
1926:   }
1927: 
1928:   /* check for mult samples per level
1929:   */
1930:   sumval = timeseries.val[0];
1931:   n = 0;
1932:   ndiv = 1;
1933:   for(i=1; i<timeseries.n; ++i) {
1934:     if(timeseries.age[i] == timeseries.age[i-1] && i < timeseries.n - 1) {
1935:       sumval = sumval + timeseries.val[i];
1936:       ++ndiv;
1937:     }
1938:     else if(timeseries.age[i] == timeseries.age[i-1] && i == timeseries.n - 1) {
1939:       sumval = sumval + timeseries.val[i];
1940:       ++ndiv;
1941:       timeseries.age[n] = timeseries.age[i-1];
1942:       timeseries.val[n] = sumval/ndiv;
1943:       ++n;
1944:     }
1945:     else if(timeseries.age[i] > timeseries.age[i-1] && i < timeseries.n - 1) {
1946:       timeseries.age[n] = timeseries.age[i-1];
1947:       timeseries.val[n] = sumval/ndiv;
1948:       sumval = timeseries.val[i];
1949:       ndiv = 1;
1950:       ++n;
1951:     }
1952:     else if(timeseries.age[i] > timeseries.age[i-1] && i == timeseries.n - 1) {
1953:       timeseries.age[n] = timeseries.age[i-1];
1954:       timeseries.val[n] = sumval/ndiv;
1955:       ++n;
1956:       timeseries.age[n] = timeseries.age[i];
1957:       timeseries.val[n] = timeseries.val[i];
1958:       ++n;
1959:     }
1960:     else {
1961:     }
1962:   }
1963:   timeseries.n = n;
1964: 
1965:   if(timeseries.n < 2) {
1966:     if((charptr=(char*)calloc(200,CHAR_SIZE))==NULL) {
1967:               SpBadMemAlloc("ReadTimeSeries");
1968:     }
1969:     else {
1970:       (void)sprintf(charptr,"The time series has less than two points.");
1971:     }
1972:     SpManageWarningBox(charptr);
1973:     free(charptr);
1974:     SpCleanUp(TIMESERIES);
1975:     return 1;
1976:   }
1977: 
1978:   have_time_series = DO;
1979:   XtSetSensitive(pushButtonOpenAgeSignal, False);
1980:   XtSetSensitive(pushButtonOpenTimeSeries, False);
1981:   XtSetSensitive(radioBoxInvertTimeSeries, True);
1982:   ViewSpliceVsAge((Widget)NULL, (XtPointer)NULL, (XtPointer)NULL);
1983: 
1984:   return 0;
1985: }
1986: 
1987: int SpReadJanus(fptr,dataptr)
1988: FILE    *fptr;
1989: DataFile        *dataptr;
1990: {
1991:         char    hole_name, munsell[2][20];
1992:         int     core_num,status,this_hole,this_core,max_alloc;
1993:         float   val[6];
1994:         Value   tmp_value,*valueptr;
1995:         Core    *coreptr;
1996:         Hole    *holeptr;
1997: 
1998:         /*return False=more data, true=done */
1999: 
2000: /* read data line */
2001:         dataptr->subleg=' ';
2002:         if(fgets(buffer,1000,fptr)==NULL)
2003:                 return(True);
2004: 
2005:         if(dataptr->in_format == JANUSORIG) {
2006:           if(strcmp(buffer, "Sql statement executed OK!\n") == 0) {
2007:             return(True);
2008:           }
2009:         }
2010: 
2011: /* get variables */
2012:         switch (dataptr->type)
2013:         {
2014:                 case    GRAPE:
2015:                 case    PWAVE:
2016:                 case    NATURALGAMMA:
2017:                         if((status=sscanf(buffer, "%d %d %c %d %c %s %f %f %f",
2018:                                    &dataptr->leg, &dataptr->site, &hole_name, &core_num, &tmp_value.type,
2019:                                    tmp_value.section, &tmp_value.top_int, &tmp_value.sb_depth,
2020:                                    &val[0]))!=9)
2021:                         {
2022:                                 if(status==EOF)
2023:                                         return(True);
2024:                                 else
2025:                                         message.error=True;
2026:                         }
2027:                         break;
2028:                 case    SUSCEPTIBILITY:
2029:                         if((status=sscanf(buffer, "%d %d %c %d %c %s %f %f %f %f",
2030:                                    &dataptr->leg, &dataptr->site, &hole_name, &core_num, &tmp_value.type,
2031:                                    tmp_value.section, &tmp_value.top_int, &tmp_value.sb_depth,
2032:                                    &val[0], &val[1]))!=10)
2033:                         {
2034:                                 if(status==EOF)
2035:                                         return(True);
2036:                                 else
2037:                                         message.error=True;
2038:                         }
2039:                         break;
2040:                 case    REFLECTANCEMST:
2041:                         if((status=sscanf(buffer, "%d %d %c %d %c %s %f %f %f %f %f %s, %s, %f %f %f",
2042:                                    &dataptr->leg, &dataptr->site, &hole_name, &core_num, &tmp_value.type,
2043:                                    tmp_value.section, &tmp_value.top_int, &tmp_value.sb_depth,
2044:                                    &val[0], val[1], &val[2], munsell[0], munsell[1], &val[3], &val[4], &val[5]))!=16)
2045:                         {
2046:                                 if(status == 13) {
2047:                                 }
2048:                                 else if(status==EOF) {
2049:                                         return(True);
2050:                                 }
2051:                                 else {
2052:                                         message.error=True;
2053:                                 }
2054:                         }
2055:                         break;
2056:                 default:
2057:                         message.fatal=False;
2058:                         message.default_button=XmDIALOG_OK_BUTTON;
2059:                         message.type=XmDIALOG_ERROR;
2060:                         message.caller=SPREADJANUS;
2061:                         if((message.label=(char*)calloc(100,CHAR_SIZE))==NULL)
2062:                                 SpBadMemAlloc("SpReadJanus 1");
2063:                         (void)sprintf(message.label,"Invalid other odp data type %d",dataptr->type);
2064:                         SpManageMessage(message);
2065:                         return(True);
2066:         }
2067:         tmp_value.bot_int=tmp_value.top_int;
2068:         if(message.error)
2069:         {
2070:                 message.fatal=False;
2071:                 message.default_button=XmDIALOG_OK_BUTTON;
2072:                 message.type=XmDIALOG_ERROR;
2073:                 message.caller=SPREADJANUS;
2074:                 if((message.label=(char*)calloc(50+(int)strlen(type[dataptr->type])+
2075:                                         (int)strlen(format[dataptr->in_format]),CHAR_SIZE))==NULL)
2076:                         SpBadMemAlloc("SpReadJanus 2");
2077:                 (void)sprintf(message.label,"Bad %s %s line",format[dataptr->in_format],type[dataptr->type]);
2078:                 SpManageMessage(message);
2079:                 return(False);
2080:         }
2081:         /* check if new hole */
2082:         hole_name=toupper(hole_name);
2083:         if(dataptr->holes_used==NULL || strchr(dataptr->holes_used,hole_name)==NULL)
2084:         {
2085:                 dataptr->numholes++;
2086:                 if(dataptr->numholes >1)        /* not first hole */
2087:                 {
2088:                         if((charptr=(char*)realloc(dataptr->holes_used,(dataptr->numholes+1)*CHAR_SIZE))==NULL)
2089:                                 SpBadMemAlloc("SpReadJanus 3");
2090:                         else
2091:                                 dataptr->holes_used = charptr;
2092:                         if((charptr=(char*)realloc((char*)dataptr->holes,dataptr->numholes*sizeof(Hole*)))==NULL)
2093:                                 SpBadMemAlloc("SpReadJanus 4");
2094:                         else
2095:                                 dataptr->holes=(Hole**)charptr;
2096:                 }
2097:                 else            /* first hole */
2098:                 {
2099:                         if((dataptr->holes_used=(char*)calloc(2,sizeof(char)))==NULL)
2100:                                 SpBadMemAlloc("SpReadJanus 5");
2101:                         dataptr->holes_used[0]='\0';
2102:                         if((dataptr->holes=(Hole**)calloc(dataptr->numholes,sizeof(Hole*)))==NULL)
2103:                                 SpBadMemAlloc("SpReadJanus 6");
2104:                 }
2105:                 /* set hole values */
2106:                 if((dataptr->holes[dataptr->numholes-1]=(Hole*)calloc(1,sizeof(Hole)))==NULL)
2107:                         SpBadMemAlloc("SpReadJanus 7");
2108:                 this_hole=dataptr->numholes-1;
2109:                 holeptr=dataptr->holes[this_hole];
2110:                 holeptr->name=hole_name;
2111:                 (void)sprintf(dataptr->holes_used,"%s%c",dataptr->holes_used,hole_name);
2112:                 holeptr->numcores=0;
2113:         }
2114:         else    /* hole already exists */
2115:         {
2116:                 for(this_hole=0;this_hole<dataptr->numholes && dataptr->holes[this_hole]->name!=hole_name;this_hole++);
2117:         }
2118:         holeptr=dataptr->holes[this_hole];
2119:         /* check if new core*/
2120:         for(this_core=0;this_core<holeptr->numcores && core_num != holeptr->core[this_core]->num;this_core++);
2121:         if(this_core >= holeptr->numcores)
2122:         {
2123:                 if(holeptr->numcores++>0)       /* not first core*/
2124:                 {
2125:                         if((charptr=(char*)realloc((char*)holeptr->core,holeptr->numcores*sizeof(Core*)))==NULL)
2126:                                 SpBadMemAlloc("SpReadJanus 8");
2127:                         else
2128:                                 data[dset]->holes[this_hole]->core=(Core**)charptr;
2129:                 }
2130:                 else            /* firstcore */
2131:                 {
2132:                         if((holeptr->core=(Core**)calloc(holeptr->numcores,sizeof(Core*)))==NULL)
2133:                                 SpBadMemAlloc("SpReadJanus 9");
2134:                 }
2135:                 /* set core values */
2136:                 if((holeptr->core[this_core]=(Core*)calloc(1,sizeof(Core)))==NULL)
2137:                         SpBadMemAlloc("SpReadJanus 10");
2138:                 coreptr=holeptr->core[this_core];
2139:                 coreptr->num=core_num;
2140:                 coreptr->numvalues=0;
2141:                 if((coreptr->value=(Value**)calloc(ALLOC_INT,sizeof(Value*)))==NULL)
2142:                         SpBadMemAlloc("SpReadJanus 11");
2143:                 for(coreptr->allocvalues=0;coreptr->allocvalues<ALLOC_INT;coreptr->allocvalues++)
2144:                 {
2145:                         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
2146:                                 SpBadMemAlloc("SpReadJanus 12");
2147:                 }
2148:         }
2149:         coreptr=holeptr->core[this_core];
2150:         if(coreptr->numvalues++ >= coreptr->allocvalues)
2151:         {
2152:                 max_alloc=coreptr->allocvalues+ALLOC_INT;
2153:                 if((charptr=(char*)realloc((char*)coreptr->value,max_alloc*sizeof(Value*)))==NULL)
2154:                         SpBadMemAlloc("SpReadJanus 13");
2155:                 else
2156:                         coreptr->value=(Value**) charptr;
2157:                 for(;coreptr->allocvalues<max_alloc;coreptr->allocvalues++)
2158:                 {
2159:                         if((coreptr->value[coreptr->allocvalues]=(Value*)calloc(1,sizeof(Value)))==NULL)
2160:                                 SpBadMemAlloc("SpReadJanus 14");
2161:                 }
2162:         }
2163:         valueptr=coreptr->value[coreptr->numvalues-1];
2164: /* get standard core values */
2165:         valueptr->type=tmp_value.type;
2166:         (void)strcpy(valueptr->section,tmp_value.section);
2167:         valueptr->top_int=tmp_value.top_int;
2168:         valueptr->bot_int=tmp_value.bot_int;
2169:         valueptr->sb_depth=tmp_value.sb_depth;
2170:         if(fabs(valueptr->sb_depth - BAD_CODE) <= ROUNDCHECK)
2171:                 valueptr->quality=BAD_SB_DEPTH;
2172:         else
2173:                 valueptr->quality=GOOD;
2174:         valueptr->run_num=0;
2175:         switch (dataptr->type)
2176:         {
2177:           case GRAPE:
2178:           case PWAVE:
2179:           case NATURALGAMMA:
2180:             valueptr->otherodp = val[0];
2181:             valueptr->data = &valueptr->otherodp;
2182:             break;
2183:           case SUSCEPTIBILITY:
2184:             if((valueptr->susceptibility=(Susceptibility*)calloc(1,sizeof(Susceptibility)))==NULL)
2185:                                         SpBadMemAlloc("SpReadJanus 15");
2186:             valueptr->susceptibility->observed = val[0];
2187:             valueptr->susceptibility->corrected = val[1];
2188:             valueptr->data = &valueptr->susceptibility->corrected;
2189:             break;
2190:           case REFLECTANCEMST:
2191:             if((valueptr->reflectanceMST=(ReflectanceMST*)calloc(1,sizeof(ReflectanceMST)))==NULL)
2192:                                         SpBadMemAlloc("SpReadJanus 16");
2193:             valueptr->reflectanceMST->L = val[0];
2194:             valueptr->reflectanceMST->a = val[1];
2195:             valueptr->reflectanceMST->b = val[2];
2196:             strcpy(valueptr->reflectanceMST->munsell_hue, munsell[0]);
2197:             strcpy(valueptr->reflectanceMST->munsell_value, munsell[1]);
2198:             valueptr->data = &valueptr->reflectanceMST->L;
2199:             break;
2200:           default:
2201:             dataptr->readerrors++;
2202:             message.error=True;
2203:         }
2204: 
2205:         if(message.error==True)
2206:         {
2207:           message.fatal=False;
2208:           message.default_button=XmDIALOG_OK_BUTTON;
2209:           message.type=XmDIALOG_ERROR;
2210:           message.caller=SPREADJANUS;
2211:           if((message.label=(char*)calloc(50+(int)strlen(format[dataptr->in_format])+(int)strlen(type[dataptr->type]),sizeof(char)))==NULL)
2212:                                 SpBadMemAlloc("SpReadJanus 17");
2213:           (void)sprintf(message.label,"Bad %s %s line",format[dataptr->in_format],type[dataptr->type]);
2214:           SpManageMessage(message);
2215:         }
2216:         else
2217:           v