loadsig.c

generate eye diagram from spice sim result

        char tmp_string[MAX_NAME_LENGTH];

        current_row = 0;

/* type of independent variable */
	cp = strtok(line, " \t\n");
	if(!cp) 
           {
	    mexPrintf("error in hs_process_header:  initial vartype not found on header line\n");
	    return;
	   }

	hstype = atoi(cp);
	switch(hstype) {
	case 1:
		sf->signal_type[0] = TIME;
		break;
	case 2:
		sf->signal_type[0] = FREQUENCY;
		break;
	case 3:
		sf->signal_type[0] = VOLTAGE;
		break;
	default:
		sf->signal_type[0] = UNKNOWN;
		break;
	}

	sf->signal_first_row[0] = current_row++;
	sf->signal_num_rows[0] = 1;

/* dependent variable types */
	for(i = 1; i < sf->num_signals; i++) 
           {
		cp = strtok(NULL, " \t\n");
		if(!cp) {
		    mexPrintf("error in hs_process_header: not enough vartypes on header line\n");
		    return;
		}
		if(!isdigit(cp[0])) {
		    mexPrintf("error in hs_process_header:  bad vartype %d [%s] on header line\n", i, cp);
		    return;
		}
		hstype = atoi(cp);
		switch(hstype) {
		case 1:
		case 2:
			sf->signal_type[i] = VOLTAGE;
			break;
		case 8:
		case 15:
			sf->signal_type[i] = CURRENT;
			break;
		default:
			sf->signal_type[i] = UNKNOWN;
			break;
		}

		/* how many columns comprise this variable? */
                if (current_row >= sf->num_data_rows)
		  {
                  mexPrintf("error in hs_process_header:  data rows exceeded\n");
                  return;
		  }
		sf->signal_first_row[i] = current_row++;
		if(i < (sf->nauto) && sf->signal_type[0] == FREQUENCY) 
                   {
                   if (current_row >= sf->num_data_rows)
	  	     {
                     mexPrintf("error in hs_process_header:  data rows exceeded\n");
                     return;
		     }

		    sf->signal_num_rows[i] = 2;
                    current_row++;
		   } 
                else 
                   {
		    sf->signal_num_rows[i] = 1;
		   }
	   }


/* independent variable name */
	signam = strtok(NULL, " \t\n"); 
	if(!signam) {
		mexPrintf("error in hs_process_header: no IV name found on header line");
		return;
	}
	strncpy(sf->signal_name[0],signam,MAX_NAME_LENGTH-1);

 /* dependent variable names */
	for(i = 1; i < sf->num_signals; i++) 
           {
	    if((signam = strtok(NULL, " \t\n")) == NULL) 
                {
		mexPrintf("error in hs_process_header:  not enough DV names found on header line\n");
		return;
		}
	    strncpy(sf->signal_name[i],signam,MAX_NAME_LENGTH-1);
	}
 /* sweep parameter names */
        j = 0;
	for(i = 0; i < sf->num_sweep_names; i++) 
           {
	    if((signam = strtok(NULL, " \t\n")) == NULL) 
                {
	        mexPrintf("error in hs_process_header:  not enough sweep parameter names found on header line\n");
	        return;
	        }
            if (i < (sf->num_sweep_names-sf->num_sweep_vars))
	        continue;
            sprintf(tmp_string,"sw_%s",signam);
	    strncpy(sf->sweep_name[j++],tmp_string,MAX_NAME_LENGTH-1);

	   }

}
	
int hs_read_column(FILE *fp, SpiceData *sf, char *simsource)
{
	int i,current_row,k;
	float val;

	if (sf->current_column == 0)
	  {
           for (i = 0; i < sf->num_sweep_vars; i++)
	     {
 	     if(fread_float_values(simsource, &val, fp) != 1) 
               {
	       mexPrintf("error in hs_read_column: unexpected EOF at field %d\n", i);
	       return(1);
	       }
             sf->sweep_data[i][sf->cur_sweep] = val;
	     }
	  }
        k = sf->num_sweep_vars;
       
        if (sf->current_column >= sf->num_data_cols)
           return(1);
	for(i = 0; i < sf->num_data_rows; i++) 
           {
            if (((sf->current_column*sf->num_data_rows+i+k) % sf->block_size) == 0 &&
                 (sf->current_column*sf->num_data_rows+i+k) != 0)
                fseek(fp,20,SEEK_CUR);
	    if(fread_float_values(simsource, &val, fp) != 1) 
               {
	       mexPrintf("error in hs_read_column: unexpected EOF at field %d\n", i);
	       return(1);
	       }
            current_row = sf->cur_sweep*sf->num_data_rows+i;

            if (current_row >= sf->num_data_rows*sf->num_sweeps)
	      {
               mexPrintf("error in 'hs_read_column': data overflow\n");
               return(1);
	      }
            sf->signal_data[current_row][sf->current_column] = val;
	   }

	sf->current_column++;
        return(0);
}

int hs_validate_column(FILE *fp, int num_data_rows, int current_column, int num_sweep_vars, int block_size, char *simsource, int col_count)
{
	int i,k;
	float val;

        if (current_column == 0)
	  {
           if (num_sweep_vars > 0)
              fseek(fp,4*num_sweep_vars,SEEK_CUR);
	  }
        k = num_sweep_vars;
	for(i = 0; i < num_data_rows; i++) 
            {
            if (((current_column*num_data_rows+i+k) % block_size) == 0 &&
                 (current_column*num_data_rows+i+k) != 0)
                fseek(fp,20,SEEK_CUR);
	    if(fread_float_values(simsource, &val, fp) != 1) 
	       return(1);
   	    if(val >= (1e30 - DBL_EPSILON))
	       {
		 if (col_count < 10) /* assume at least 10 time steps in sim */
		   {
		    if (strncmp(simsource,"hspice",6) == 0)
                      sprintf(simsource,"hspice_sun");
                    else
                      sprintf(simsource,"cppsim_sun");
		   }
		 else if (strcmp(simsource,"cppsim_sun") == 0)
		    sprintf(simsource,"cppsim");
                 else if (strncmp(simsource,"hspice",6) == 0)
                    return(2);
	       }
	    }
        return(0);
}




SpiceData *init_SpiceData(int num_signals, int nauto, int num_data_rows, int num_data_cols, int num_sweeps, int num_sweep_vars, int num_sweep_names, int block_size)
{
int i,length_signal_data;  
SpiceData *A; 
   
if ((A = (SpiceData *) mxCalloc(1,sizeof(SpiceData))) == NULL)   
   {   
   mexPrintf("error in 'init_SpiceData':  mxCalloc call failed\n");   
   mexPrintf("out of memory!\n");   
   return(NULL);   
  }   

A->num_data_rows = num_data_rows;
A->num_data_cols = num_data_cols;
A->num_signals = num_signals;
A->nauto = nauto;
A->num_sweeps = num_sweeps;
A->num_sweep_vars = num_sweep_vars;
A->num_sweep_names = num_sweep_names;
A->block_size = block_size;

/*
mexPrintf("num_signals = %d, nauto = %d, num_data_rows = %d, num_data_cols = %d\n", num_signals, nauto, num_data_rows, num_data_cols);
mexPrintf("num_sweeps = %d, num_sweep_vars = %d, block size = %d\n",num_sweeps, num_sweep_vars, block_size);
*/

if ((A->signal_name = (char **) mxCalloc(num_signals,sizeof(char *))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
for (i = 0; i < num_signals; i++)   
    if (((A->signal_name)[i] = (char *) mxCalloc(MAX_NAME_LENGTH,sizeof(char))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   

if (num_sweep_vars > 0)
  {
  if ((A->sweep_name = (char **) mxCalloc(num_sweep_vars,sizeof(char *))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
  for (i = 0; i < num_sweep_vars; i++)   
      if (((A->sweep_name)[i] = (char *) mxCalloc(MAX_NAME_LENGTH,sizeof(char))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
  if ((A->sweep_data = (float **) mxCalloc(num_sweep_vars,sizeof(float *))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
  for (i = 0; i < num_sweep_vars; i++)   
      if (((A->sweep_data)[i] = (float *) mxCalloc(num_sweeps,sizeof(float))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
  }
length_signal_data = num_sweeps*num_data_rows;

/* mexPrintf("length_signal_data = %d,num_data_cols=%d\n",length_signal_data,num_data_cols); */
if ((A->signal_data = (float **) mxCalloc(length_signal_data,sizeof(float *))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
for (i = 0; i < length_signal_data; i++)   
    if (((A->signal_data)[i] = (float *) mxCalloc(num_data_cols,sizeof(float))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   

if (((A->signal_first_row) = (int *) mxCalloc(num_signals,sizeof(int))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
if (((A->signal_num_rows) = (int *) mxCalloc(num_signals,sizeof(int))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       }   
if (((A->signal_type) = (int *) mxCalloc(num_signals,sizeof(int))) == NULL)   
       {   
        mexPrintf("error in 'init_SpiceData':  mxCalloc call failed - \n");   
        mexPrintf("  not enough memory!!\n");   
        return(NULL);   
       } 
return(A);
}   


void free_SpiceData(SpiceData *A)
{
int i;  


for (i = 0; i < A->num_data_rows*A->num_sweeps; i++)
   mxFree((A->signal_data)[i]);
mxFree(A->signal_data);

if (A->num_sweep_vars > 0)
  {
   for (i = 0; i < A->num_sweep_vars; i++)
     mxFree((A->sweep_data)[i]);
   mxFree(A->sweep_data);
   for (i = 0; i < A->num_sweep_vars; i++)
     mxFree((A->sweep_name)[i]);
   mxFree(A->sweep_name);
  }
for (i = 0; i < A->num_signals; i++)
   mxFree((A->signal_name)[i]);
mxFree(A->signal_name);


mxFree(A->signal_first_row);
mxFree(A->signal_num_rows);   
mxFree(A->signal_type);
mxFree(A);
}   


/* fix problem with big endian, little endian issue */
size_t fread_int_values(char *simsource,unsigned int *ibuf, 
                        int size_of_block, FILE *fp)
  {
   unsigned char *charbuf;
   int i;
   size_t blocks_read;

   if ((charbuf = (unsigned char *) mxCalloc(4*size_of_block,sizeof(unsigned char))) == NULL)   
         {   
          mexPrintf("error in 'fread_int_values':  mxCalloc call failed - \n");   
          mexPrintf("  not enough memory!!\n");   
          return(-1);   
        }   
   blocks_read = fread(charbuf, sizeof(unsigned char),4*size_of_block, fp);
   if (strcmp(simsource,"hspice_win") == 0)
     {
      for (i = 0; i < size_of_block; i++)
         {
         ibuf[i] = charbuf[i*4+3]*(1<<24) + charbuf[i*4+2]*(1<<16) 
                     + charbuf[i*4+1]*(1<<8) + charbuf[i*4];
         }
     }
   else
     { 
      for (i = 0; i < size_of_block; i++)
         {
         ibuf[i] = charbuf[i*4]*(1<<24) + charbuf[i*4+1]*(1<<16) 
                     + charbuf[i*4+2]*(1<<8) + charbuf[i*4+3];
         }
     }
   mxFree(charbuf);
   return(((size_t) ((int) blocks_read)/4));
  }

/* fix problem with big endian, little endian issue */
int fread_float_values(char *simsource,float *fval, FILE *fp)
  {
   unsigned char *cptr,tmp;

   if (fread(fval,4,1,fp) != 1)
      return(0);
   if (strcmp(simsource,"hspice_sun") == 0 || 
       strcmp(simsource,"cppsim_sun") == 0)
     { 
      cptr = (unsigned char *)fval;
      tmp = cptr[0];
      cptr[0] = cptr[3];
      cptr[3] =tmp;
      tmp = cptr[1];
      cptr[1] = cptr[2];
      cptr[2] = tmp;
     }
   return(1);
  }