flags.c

波浪数值模拟

  if (num!=3)
    funwaveC_error_message("Syntax Error: Not enough arguments for cross output!");

  P->var = variable_t_index(vtype);

  P->D = ptr_to_field2D(P->var);

  P->py = atoi(yloc);

  //  check_yloc(P->py); // check to make sure in bounds


  P->OP = parse_output_options(rest);
  if (P->OP->OT == FILE_M) {
    P->OP->fp = open_file_for_writing(P->OP->fname->str);
  }

  F->cross_list = g_slist_append(F->cross_list,P);

}

void parse_level_along(char *s, oflags *F)
{
  char vtype[16],xloc[80],tmp[80],*rest;
  int num; 
  along_line *P;

  P = (along_line * ) g_malloc(sizeof(along_line));

  num = sscanf(s,"%*s %*s %s %s %s",vtype,xloc,tmp);
  rest = strstr(s,tmp);

  if (num!=3)
    funwaveC_error_message("Syntax Error: Not enough arguments for along output!");

  P->var = variable_t_index(vtype);

  P->D = ptr_to_field2D(P->var);

  P->px = atoi(xloc);
  //  check_xloc(P->px,P->var);  // check to make sure in bounds
  P->OP = parse_output_options(rest);
  if (P->OP->OT == FILE_M) {
    P->OP->fp = open_file_for_writing(P->OP->fname->str);
  }

  F->along_list = g_slist_append(F->along_list,P);

}


/* Parses the init.dat input line:  level? snapshot [U,V,T,Q,S] */

void parse_level_snapshot(char *s, oflags *F)
{
  char vtype[16],tmp[80],*rest;
  int num; 
  snapshot_output *P;

  P = (snapshot_output * ) g_malloc(sizeof(snapshot_output));

  num = sscanf(s,"%*s %*s %s %s",vtype,tmp);
  rest = strstr(s,tmp);

  if (num!=2)
    funwaveC_error_message("Syntax Error: Not enough arguments for snapshot output!");

  P->index = 0;
  P->var = variable_t_index(vtype);

  P->D = ptr_to_field2D(P->var);

  P->OP = parse_output_options(rest);

  F->snapshot_list = g_slist_append(F->snapshot_list,P);

}


/* Parses the init.dat input line:  level? snapshot [U,V,T,Q,S] */

void parse_level_floats(char *s, oflags *F)
{
  char tmp[80],*rest;
  int num; 
  floats_output *FO;

  FO = (floats_output * ) g_malloc(sizeof(floats_output));

  num = sscanf(s,"%*s %*s %s",tmp);
  rest = strstr(s,tmp);

  if (num!=1)
    funwaveC_error_message("Syntax Error: Not enough arguments for floats output!");

  //  FO->var = variable_t_index(vtype);

  FO->full_output = ON;
  FO->OP = parse_output_options(rest);

  F->FO = FO;

}



void parse_level(char *s, oflags *F)
{
  char type[16], rest[80];
  int num;

  num = sscanf(s,"%*s %s %s",type,rest);

  if (num != 2)
    funwaveC_error_message("Syntax Error: Not enough arguments for level1 output!");

  if (!strcasecmp(type,"point")) {
    parse_level_point(s,F);
    return;
  }

  if (!strcasecmp(type,"cross")) {
    parse_level_cross(s,F);
    return;
  }

  if (!strcasecmp(type,"along")) {
    parse_level_along(s,F);
    return;
  }

  if (!strcasecmp(type,"snapshot")) {
    parse_level_snapshot(s,F);
    return;
  }

  if (!strcasecmp(type,"floats")) {
    parse_level_floats(s,F);
    return;
  }

  funwaveC_error_message("Syntax Error: Wrong type of level  output.  Need [point,cross,along,snapshot,floats].");

}




void parse_line(char *s,outputflags *A)
{
  char level[16];
  int num;

  num = sscanf(s,"%s %*s",level);

  if (num!=1) {
    funwaveC_error_message("Error: Could not assign string in 'flags.c: parse_line()'!\n");
    fprintf(stderr,"Syntax error in init file.\n");
    exit(-1);
  }

  if (!strcasecmp(level,"level1")) 
    parse_level(s,A->F1);
  else {
   if (!strcasecmp(level,"level2")) {
     parse_level(s,A->F2);
    }
   else {
     if (!strcasecmp(level,"level3")) {
       parse_level(s,A->F3);
     }
     else {
       funwaveC_error_message("Syntax Error in the init file!\n");
       exit(-1);
     }
   }
  }
  

}



outputflags* parse_output(FILE *fin)
{

  oflags *F1;
  oflags *F2,*F3;
  outputflags *A;

  char s[120];

  F1 = oflags_new();   // initialize the flag values
  F2 = oflags_new();
  F3 = oflags_new();

  A = (outputflags * ) g_malloc(sizeof(outputflags));
  A->F1 = F1;
  A->F2 = F2;
  A->F3 = F3;


  while (get_next_line(fin, s)!=NULL) 
    if (strlen(s)>1) {
      parse_line(s,A);   /* BUGS for level3 ********* */
#ifdef DEBUG
      g_print("Line: %s parsed\n",s);
#endif
    }

  return A;

}



/* --- oflags  & output routines --- */

void output_point(point *P)
{

  double pt;
  output_options_t *O = P->OP;

  if (global_time <= O->start_time)
    return;

  pt = point_var(P->var,P->px,P->py);

  switch (O->OT) {
  case FILE_M:  fprintf(O->fp," %f \n",pt);  /* don't worry about binary yet */
                break;
  case TERM_M:  printf(" %f \n",pt);
              break;
  case GUI_M:   printf("GUI output in the future\n");
  }

#ifdef DEBUG
  g_print("Finished with output_point()\n");
#endif

}

/* Work on these two routines !!!!! */

void output_cross_line(cross_line *P)
{

  output_options_t *O = P->OP;
  field2D *D;


  if (global_time <= O->start_time)
    return;

  P->D = ptr_to_field2D(P->var);

  D = P->D;
  switch(O->OT) {
  case TERM_M: write_cross_shore_array_ascii(stdout,D,P->py);
    return;
  case FILE_M: 
    switch(O->FOT) {
    case ASCII_M: write_cross_shore_array_ascii(O->fp,D,P->py);
      return;
    case BINARY_M: write_cross_shore_array_binary(O->fp,D,P->py);
      return;
    default: funwaveC_error_message("BAD file type to output_cross_line()");
    }
  default: funwaveC_error_message("BAD output type to output_cross_line()");
  }
}

void output_along_line(along_line *P)
{
  output_options_t *O = P->OP;
  field2D *D;

  P->D = ptr_to_field2D(P->var);

  D = P->D;

  if (global_time <= O->start_time)
    return;

  switch(O->OT) {
  case TERM_M: write_alongshore_array_ascii(stdout,D,P->px);
    return;
  case FILE_M: 
    switch(O->FOT) {
    case ASCII_M: write_alongshore_array_ascii(O->fp,D,P->px);
      return;
    case BINARY_M: write_alongshore_array_binary(O->fp,D,P->px);
      return;
    default: funwaveC_error_message("BAD file type to output_along_line()");
    }
  default: funwaveC_error_message("BAD output type to output_along_line()");
  }

}


extern field2D*  calculate_vorticity(field2D *U, field2D *V);

void output_snapshot(snapshot_output *P)
{

  char fname[80];
  output_options_t *O;
  field2D *DD;

  P->D = ptr_to_field2D(P->var);

  O = P->OP;
  sprintf(fname,"%s_%04d.dat",O->fname->str,P->index++);    

  switch (P->var) {
  case U_M:
  case V_M:
  case ETA_M:
  case TAUBX_M:
  case TAUBY_M:
  case EDDY_BR_M:
  case TRACER_M:  DD = P->D;
    break;
    //  case STREAMF_M:  DD = calculate_streamfunction(VV, H, dx);
    //		     break;
  case VORTICITY_M: DD = calculate_vorticity(UU, VV );
    break;
  }

  if (global_time > O->start_time) {
    switch (O->OT) {
      case ASCII_M: save_field2D_ascii(fname, DD );
            break;
      case BINARY_M: save_field2D_binary(fname, DD );
      break;
      default: funwaveC_error_message("Bad Arg to oflags ascii/binary output");
    }
  }

}






void traverse_point_list(GSList *plist)
{
  GSList *list;

  for (list=plist;list;list=list->next)
    output_point((point * ) list->data);

}

void traverse_cross_list(GSList *clist)
{
  GSList *list;

  for (list=clist;list;list=list->next)
    output_cross_line((cross_line * ) list->data);

}

void traverse_along_list(GSList *alist)
{
  GSList *list;

  for (list=alist;list;list=list->next)
    output_along_line((along_line * ) list->data);

}

void traverse_snapshot_list(GSList *alist)
{
  GSList *list;

  for (list=alist;list;list=list->next)
    output_snapshot((snapshot_output * ) list->data);

}




void output_floats_info(floats_output *FO)
{
  int i;
  output_options_t *O;
  FILE *ofp;
  size_t size;

  if (FO == NULL)   /* If this thing is a null pointer than just return */
    return;


  O = FO->OP;
  ofp = O->fp;

  if (global_time <= O->start_time)
    return;

  if (O->OT == TERM_M) {   /* write float positions to the terminal */
    for (i=0;i<Floats.nfloats;i++) 
      fprintf(stderr,"%9.3g ",Floats.xloc[i]);

    for (i=0;i<Floats.nfloats;i++) 
      fprintf(stderr,"%9.3g ",Floats.yloc[i]);

    if (FO->full_output == ON) {
      for (i=0;i<Floats.nfloats;i++) 
        fprintf(stderr,"%9.3g ",Floats.uvel[i]);
      for (i=0;i<Floats.nfloats;i++) 
        fprintf(stderr,"%9.3g ",Floats.vvel[i]);
    }

    fprintf(stderr,"\n");
    return;
  }

  /* else assume it's going to a file not a gui or netcdf */

  if (O->FOT ==ASCII_M) {
    for (i=0;i<Floats.nfloats;i++) 
      fprintf(ofp,"%9.3g ",Floats.xloc[i]);

    for (i=0;i<Floats.nfloats;i++) 
      fprintf(ofp,"%9.3g ",Floats.yloc[i]);

    if (FO->full_output == ON) {
      for (i=0;i<Floats.nfloats;i++) 
        fprintf(ofp,"%9.3g ",Floats.uvel[i]);
      for (i=0;i<Floats.nfloats;i++) 
        fprintf(ofp,"%9.3g ",Floats.vvel[i]);
    }

    fprintf(ofp,"\n");
    return;
  }

  if (O->FOT == BINARY_M) {
    size = sizeof(double);
    fwrite(Floats.xloc,size,Floats.nfloats,ofp);
    fwrite(Floats.yloc,size,Floats.nfloats,ofp);
    if (FO->full_output == ON) {
      fwrite(Floats.uvel,size,Floats.nfloats,ofp);
      fwrite(Floats.vvel,size,Floats.nfloats,ofp);
    }

  }
     

}



void level_output(oflags *l1)
{
  traverse_point_list(l1->point_list);
  traverse_cross_list(l1->cross_list);
  traverse_along_list(l1->along_list);
  traverse_snapshot_list(l1->snapshot_list);
  output_floats_info(l1->FO);

}