LRESULT HcpyPlotBW( HWND hwnd)
{
int bgcolor;
if (cp_getvar("hcopypscolor", CP_NUM, &bgcolor))
cp_remvar("hcopypscolor");
com_hardcopy(NULL);
return 0;
}
int WIN_Text( char * text, int x, int y)
{
tpWindowData wd;
HFONT hfont;
LOGFONT lf;
int CentiDegrees = 0;
if (!currentgraph) return 0;
wd = pWindowData(currentgraph);
if (!wd) return 0;
lf.lfHeight = (int) (1.1 * currentgraph->fontheight) ;
lf.lfWidth = 0 ;
lf.lfEscapement = CentiDegrees ;
lf.lfOrientation = CentiDegrees ;
lf.lfWeight = 500 ;
lf.lfItalic = 0 ;
lf.lfUnderline = 0 ;
lf.lfStrikeOut = 0 ;
lf.lfCharSet = 0 ;
lf.lfOutPrecision = 0 ;
lf.lfClipPrecision = 0 ;
lf.lfQuality = 0 ;
lf.lfPitchAndFamily = 0 ;
/* set up fonts */
if (!cp_getvar("wfont", CP_STRING, lf.lfFaceName)) {
(void) lstrcpy(lf.lfFaceName, DEF_FONTW);
}
if (!cp_getvar("wfont_size", CP_NUM, (char *) &(lf.lfHeight))) {
lf.lfHeight = (int) (1.1 * currentgraph->fontheight) ;
}
// lstrcpy (lf.lfFaceName, "Courier"/*"Times New Roman"*/) ;
hfont = CreateFontIndirect (&lf);
SelectObject(wd->hDC, hfont);
SetTextColor( wd->hDC, ColorTable[wd->ColorIndex]);
TextOut( wd->hDC, x, wd->Area.bottom - y - currentgraph->fontheight, text, strlen(text));
DeleteObject(SelectObject(wd->hDC, GetStockObject(SYSTEM_FONT)));
return (0);
}
/* simple printout of data into a file, similar to data table in ft_gnuplot
command: wrsimple file vecs
*/
void
ft_writesimple(double *xlims, double *ylims, char *filename, char *title, char *xlabel, char *ylabel, GRIDTYPE gridtype, PLOTTYPE plottype, struct dvec *vecs)
{
FILE *file_data;
struct dvec *v, *scale = NULL;
double xval;
int i, numVecs;
bool appendwrite;
char filename_data[128];
NG_IGNORE(xlims);
NG_IGNORE(ylims);
NG_IGNORE(title);
NG_IGNORE(xlabel);
NG_IGNORE(ylabel);
NG_IGNORE(gridtype);
NG_IGNORE(plottype);
sprintf(filename_data, "%s.data", filename);
appendwrite = cp_getvar("appendwrite", CP_BOOL, NULL);
/* Sanity checking. */
for (v = vecs, numVecs = 0; v; v = v->v_link2)
numVecs++;
if (numVecs == 0)
return;
/* Open the output data file. */
if ((file_data = fopen(filename_data, appendwrite ? "a" : "w")) == NULL) {
perror(filename);
return;
}
i = 0;
for (v = vecs; v; v = v->v_link2)
scale = v->v_scale;
/* Write out the data as simple arrays */
for (i = 0; i < scale->v_length; i++) {
for (v = vecs; v; v = v->v_link2) {
scale = v->v_scale;
xval = isreal(scale) ?
scale->v_realdata[i] : realpart(scale->v_compdata[i]);
if (isreal(v))
fprintf(file_data, "% e % e ", xval, v->v_realdata[i]);
else
fprintf(file_data, "% e % e % e ", xval, realpart(v->v_compdata[i]), imagpart(v->v_compdata[i]));
}
fprintf(file_data, "\n");
}
(void) fclose(file_data);
}
main(int ac, char **av)
#endif /* HAS_WINDOWS */
{
wordlist *wl = NULL;
#ifndef X_DISPLAY_MISSING
char *displayname;
/* grrr, Xtk forced contortions */
char *argv[2];
int argc = 2;
char buf[512];
#endif /* X_DISPLAY_MISSING */
ivars( );
cp_in = stdin;
cp_out = stdout;
cp_err = stderr;
#ifndef X_DISPLAY_MISSING
if (cp_getvar("display", CP_STRING, buf)) {
displayname = buf;
} else if (!(displayname = getenv("DISPLAY"))) {
fprintf(stderr, "Can't open X display.");
goto out;
}
argv[0] = "nutmeg";
argv[1] = displayname;
/* initialize X toolkit */
toplevel = XtInitialize("nutmeg", "Nutmeg", NULL, 0, &argc, argv);
out:
#endif /* X_DISPLAY_MISSING */
if (ac > 1)
wl = wl_build(av + 1);
hlp_main(Help_Path, wl);
#ifndef X_DISPLAY_MISSING
if (hlp_usex) {
printf("Hit control-C when done.\n"); /* sigh */
XtMainLoop();
}
#endif /* X_DISPLAY_MISSING */
#ifdef HAS_WINDOWS
/* Keep window open untill a key is pressed */
printf("Press a key to quit\n");
while( getchar() == EOF) {}
#endif /* HAS_WINDOWS */
return EXIT_NORMAL;
}
int
X11_Arc(int x0, int y0, int radius, double theta, double delta_theta)
{
int t1, t2;
if (0 && !cp_getvar("x11lineararcs", CP_BOOL, NULL))
linear_arc(x0, y0, radius, theta, delta_theta);
if (DEVDEP(currentgraph).isopen) {
t1 = (int) (64 * (180.0 / M_PI) * theta);
t2 = (int) (64 * (180.0 / M_PI) * delta_theta);
if (t2 == 0)
return 0;
XDrawArc(display, DEVDEP(currentgraph).window, DEVDEP(currentgraph).gc,
x0 - radius,
currentgraph->absolute.height - radius - y0,
(Dimension) (2 * radius), (Dimension) (2 * radius), t1, t2);
}
return 0;
}
void
gr_pmsg(char *text)
{
char buf[BSIZE_SP];
buf[0] = '\0';
DevUpdate();
if (cp_getvar("device", CP_STRING, buf, sizeof(buf)) && !(strcmp("/dev/tty", buf) == 0))
fprintf(cp_err, "%s", text);
else if (currentgraph->grid.xlabel)
/* MW. grid.xlabel may be NULL */
DevDrawText(text, currentgraph->viewport.width -
(int) (strlen(currentgraph->grid.xlabel) + 3) *
currentgraph->fontwidth,
currentgraph->absolute.height - currentgraph->fontheight, 0);
else
fprintf(cp_err, " %s \n", text);
DevUpdate();
}
int GL_Init(void)
{
if (!cp_getvar("hcopyscale", CP_STRING, psscale)) {
scale = 1.0;
} else {
sscanf(psscale, "%lf", &scale);
if ((scale <= 0) || (scale > 10))
scale = 1.0;
}
dispdev->numlinestyles = NUMELEMS(linestyle);
dispdev->numcolors = 6;
dispdev->width = (int)(DELXMAX * scale);
dispdev->height = (int)(DELYMAX * scale);
screenflag = 0;
dispdev->minx = (int)(XOFF * 1.0);
dispdev->miny = (int)(YOFF * 1.0);
return (0);
}
int
X11_Arc(int x0, int y0, int radius, double theta1, double theta2)
{
int t1, t2;
if (!cp_getvar("x11lineararcs", VT_BOOL, (char *) &t1)) {
linear_arc(x0, y0, radius, theta1, theta2);
}
if (DEVDEP(currentgraph).isopen) {
if (theta1 >= theta2)
theta2 = 2 * M_PI + theta2;
t1 = 64 * (180.0 / M_PI) * theta1;
t2 = 64 * (180.0 / M_PI) * theta2 - t1;
if (t2 == 0)
return 0;
XDrawArc(display, DEVDEP(currentgraph).window, DEVDEP(currentgraph).gc,
x0 - radius,
currentgraph->absolute.height - radius - y0,
2 * radius, 2 * radius, t1, t2);
}
return 0;
}
void
raw_write(char *name, struct plot *pl, bool app, bool binary)
{
FILE *fp;
bool realflag = TRUE, writedims;
bool raw_padding;
int length, numdims, dims[MAXDIMS];
int nvars, i, j, prec;
struct dvec *v, *lv;
wordlist *wl;
struct variable *vv;
double dd;
char buf[BSIZE_SP];
char *branch;
raw_padding = !cp_getvar("nopadding", CP_BOOL, NULL);
/* Why bother printing out an empty plot? */
if (!pl->pl_dvecs) {
fprintf(cp_err, "Error: plot is empty, nothing written.\n");
return;
}
if (raw_prec != -1)
prec = raw_prec;
else
prec = DEFPREC;
#if defined(__MINGW32__) || defined(_MSC_VER)
/* - Binary file binary write - hvogt 15.03.2000 ---------------------*/
if (binary) {
if ((fp = fopen(name, app ? "ab" : "wb")) == NULL) {
perror(name);
return;
}
fprintf(cp_out, "binary raw file\n");
} else {
if ((fp = fopen(name, app ? "a" : "w")) == NULL) {
perror(name);
return;
}
fprintf(cp_out, "ASCII raw file\n");
}
/* --------------------------------------------------------------------*/
#else
if (!(fp = fopen(name, app ? "a" : "w"))) {
perror(name);
return;
}
#endif
numdims = nvars = length = 0;
for (v = pl->pl_dvecs; v; v = v->v_next) {
if (iscomplex(v))
realflag = FALSE;
nvars++;
/* Find the length and dimensions of the longest vector
* in the plot.
* Be paranoid and assume somewhere we may have
* forgotten to set the dimensions of 1-D vectors.
*/
if (v->v_numdims <= 1) {
v->v_numdims = 1;
v->v_dims[0] = v->v_length;
}
if (v->v_length > length) {
length = v->v_length;
numdims = v->v_numdims;
for (j = 0; j < numdims; j++) {
dims[j] = v->v_dims[j];
}
}
}
fprintf(fp, "Title: %s\n", pl->pl_title);
fprintf(fp, "Date: %s\n", pl->pl_date);
fprintf(fp, "Plotname: %s\n", pl->pl_name);
fprintf(fp, "Flags: %s%s\n",
realflag ? "real" : "complex", raw_padding ? "" : " unpadded");
fprintf(fp, "No. Variables: %d\n", nvars);
fprintf(fp, "No. Points: %d\n", length);
if (numdims > 1) {
dimstring(dims, numdims, buf);
fprintf(fp, "Dimensions: %s\n", buf);
}
for (wl = pl->pl_commands; wl; wl = wl->wl_next)
fprintf(fp, "Command: %s\n", wl->wl_word);
for (vv = pl->pl_env; vv; vv = vv->va_next) {
wl = cp_varwl(vv);
if (vv->va_type == CP_BOOL) {
fprintf(fp, "Option: %s\n", vv->va_name);
} else {
fprintf(fp, "Option: %s = ", vv->va_name);
if (vv->va_type == CP_LIST)
fprintf(fp, "( ");
wl_print(wl, fp);
if (vv->va_type == CP_LIST)
fprintf(fp, " )");
(void) putc('\n', fp);
}
}
/* Before we write the stuff out, make sure that the scale is the first
* in the list.
*/
for (lv = NULL, v = pl->pl_dvecs; v != pl->pl_scale; v = v->v_next)
lv = v;
if (lv) {
lv->v_next = v->v_next;
v->v_next = pl->pl_dvecs;
pl->pl_dvecs = v;
}
fprintf(fp, "Variables:\n");
for (i = 0, v = pl->pl_dvecs; v; v = v->v_next) {
if (v->v_type == SV_CURRENT) {
branch = NULL;
if ((branch = strstr(v->v_name, "#branch")) != NULL) {
*branch = '\0';
}
fprintf(fp, "\t%d\ti(%s)\t%s", i++, v->v_name, ft_typenames(v->v_type));
if (branch != NULL) *branch = '#';
} else if (v->v_type == SV_VOLTAGE) {
fprintf(fp, "\t%d\t%s\t%s", i++, v->v_name, ft_typenames(v->v_type));
} else {
fprintf(fp, "\t%d\t%s\t%s", i++, v->v_name, ft_typenames(v->v_type));
}
if (v->v_flags & VF_MINGIVEN)
fprintf(fp, " min=%e", v->v_minsignal);
if (v->v_flags & VF_MAXGIVEN)
fprintf(fp, " max=%e", v->v_maxsignal);
if (v->v_defcolor)
fprintf(fp, " color=%s", v->v_defcolor);
if (v->v_gridtype)
fprintf(fp, " grid=%d", v->v_gridtype);
if (v->v_plottype)
fprintf(fp, " plot=%d", v->v_plottype);
/* Only write dims if they are different from default. */
writedims = FALSE;
if (v->v_numdims != numdims) {
writedims = TRUE;
} else {
for (j = 0; j < numdims; j++)
if (dims[j] != v->v_dims[j])
writedims = TRUE;
}
if (writedims) {
dimstring(v->v_dims, v->v_numdims, buf);
fprintf(fp, " dims=%s", buf);
}
(void) putc('\n', fp);
}
if (binary) {
fprintf(fp, "Binary:\n");
for (i = 0; i < length; i++) {
for (v = pl->pl_dvecs; v; v = v->v_next) {
/* Don't run off the end of this vector's data. */
if (i < v->v_length) {
if (realflag) {
dd = (isreal(v) ? v->v_realdata[i] :
realpart(v->v_compdata[i]));
(void) fwrite(&dd, sizeof(double), 1, fp);
} else if (isreal(v)) {
dd = v->v_realdata[i];
(void) fwrite(&dd, sizeof(double), 1, fp);
dd = 0.0;
(void) fwrite(&dd, sizeof(double), 1, fp);
} else {
dd = realpart(v->v_compdata[i]);
(void) fwrite(&dd, sizeof(double), 1, fp);
dd = imagpart(v->v_compdata[i]);
(void) fwrite(&dd, sizeof(double), 1, fp);
}
} else if (raw_padding) {
dd = 0.0;
if (realflag) {
(void) fwrite(&dd, sizeof(double), 1, fp);
} else {
(void) fwrite(&dd, sizeof(double), 1, fp);
(void) fwrite(&dd, sizeof(double), 1, fp);
}
}
}
}
} else {
fprintf(fp, "Values:\n");
for (i = 0; i < length; i++) {
fprintf(fp, " %d", i);
for (v = pl->pl_dvecs; v; v = v->v_next) {
if (i < v->v_length) {
if (realflag)
fprintf(fp, "\t%.*e\n", prec,
isreal(v) ? v->v_realdata[i] :
realpart(v->v_compdata[i]));
else if (isreal(v))
fprintf(fp, "\t%.*e,0.0\n", prec,
v->v_realdata[i]);
else
fprintf(fp, "\t%.*e,%.*e\n", prec,
realpart(v->v_compdata[i]),
prec,
imagpart(v->v_compdata[i]));
} else if (raw_padding) {
if (realflag)
fprintf(fp, "\t%.*e\n", prec, 0.0);
else
fprintf(fp, "\t%.*e,%.*e\n", prec, 0.0, prec, 0.0);
}
}
(void) putc('\n', fp);
}
}
(void) fclose(fp);
}
int
gr_init(double *xlims, double *ylims, /* The size of the screen. */
char *xname, char *plotname, /* What to label things. */
char *hcopy, /* The raster file. */
int nplots, /* How many plots there will be. */
double xdelta, double ydelta, /* Line increments for the scale. */
GRIDTYPE gridtype, /* The grid type */
PLOTTYPE plottype, /* and the plot type. */
char *xlabel, char *ylabel, /* Labels for axes. */
int xtype, int ytype, /* The types of the data graphed. */
char *pname,
char *commandline) /* For xi_zoomdata() */
{
GRAPH *graph;
wordlist *wl;
char *comb_title;
NG_IGNORE(nplots);
if ((graph = NewGraph()) == NULL)
return (FALSE);
/*
The global currentgraph will always be the current graph.
*/
SetGraphContext(graph->graphid);
graph->onevalue = (xname ? FALSE : TRUE);
/* communicate filename to plot 5 driver */
if (hcopy)
graph->devdep = hcopy;
cur.plotno = 0;
/* note: should do only once, maybe in gr_init_once */
if (!cp_getvar("pointchars", CP_STRING, pointchars, sizeof(pointchars)))
(void) strcpy(pointchars, DEFPOINTCHARS);
if (!cp_getvar("ticmarks", CP_NUM, &graph->ticmarks, 0)) {
if (cp_getvar("ticmarks", CP_BOOL, NULL, 0))
graph->ticmarks = 10;
else
graph->ticmarks = 0;
}
if (cp_getvar("ticlist", CP_LIST, ticlist, 0)) {
wl = vareval("ticlist");
ticlist = wl_flatten(wl);
graph->ticdata = readtics(ticlist);
} else {
graph->ticdata = NULL;
}
if (!xlims || !ylims) {
internalerror("gr_init: no range specified");
return (FALSE);
}
/* save upper and lower limits */
graph->data.xmin = xlims[0];
graph->data.xmax = xlims[1];
graph->data.ymin = ylims[0];
graph->data.ymax = ylims[1];
/* get title into plot window */
if (!pname)
pname = "(unknown)";
if (!plotname)
plotname = "(unknown)";
comb_title = tprintf("%s: %s", pname, plotname);
graph->plotname = comb_title;
/* note: have enum here or some better convention */
if (NewViewport(graph) == 1) {
/* note: where is the error message generated? */
/* note: undo tmallocs */
fprintf(cp_err, "Can't open viewport for graphics.\n");
return (FALSE);
}
/* layout decisions */
/* note: have to do before gr_fixgrid and after NewViewport */
graph->viewportxoff = graph->fontwidth * 8; /* 8 lines on left */
graph->viewportyoff = graph->fontheight * 4; /* 4 on bottom */
DevClear();
graph->grid.gridtype = gridtype;
graph->plottype = plottype;
graph->grid.xdatatype = xtype;
graph->grid.ydatatype = ytype;
graph->grid.xdelta = xdelta;
graph->grid.ydelta = ydelta;
graph->grid.ysized = 0;
graph->grid.xsized = 0;
if (!graph->onevalue) {
if (xlabel)
graph->grid.xlabel = xlabel;
else
graph->grid.xlabel = xname;
if (ylabel)
graph->grid.ylabel = ylabel;
} else {
if (xlabel)
graph->grid.xlabel = xlabel;
else
graph->grid.xlabel = "real";
if (ylabel)
graph->grid.ylabel = ylabel;
else
graph->grid.ylabel = "imag";
}
gr_resize_internal(graph);
gr_redrawgrid(graph);
/* Set up colors and line styles. */
if (dispdev->numlinestyles == 1)
cur.linestyle = 0; /* Use the same one all the time. */
else
cur.linestyle = 1;
/* XXX Special exception for SMITH */
if (dispdev->numcolors > 2 &&
(graph->grid.gridtype == GRID_SMITH ||
graph->grid.gridtype == GRID_SMITHGRID))
{
cur.color = 3;
} else {
cur.color = 1;
}
graph->commandline = copy(commandline);
return (TRUE);
}
int WIN_Init( )
{
char colorstring[BSIZE_SP];
/* Initialization of display descriptor */
dispdev->width = GetSystemMetrics( SM_CXSCREEN);
dispdev->height = GetSystemMetrics( SM_CYSCREEN);
dispdev->numlinestyles = 5; /* see implications in WinPrint! */
dispdev->numcolors = NumWinColors;
/* always, user may have set color0 to white */
/* get background color information from spinit, only "white"
is recognized as a suitable option! */
if (cp_getvar("color0", CP_STRING, colorstring)) {
if (cieq(colorstring, "white")) isblack = FALSE;
else isblack = TRUE;
}
/* get linewidth information from spinit */
if (!cp_getvar("xbrushwidth", CP_NUM, &linewidth))
linewidth = 0;
if (linewidth < 0) linewidth = 0;
/* only for the first time: */
if (!IsRegistered) {
isblackold = isblack;
/* get linewidth information from spinit
if (!cp_getvar("xbrushwidth", CP_NUM, &linewidth))
linewidth = 0;
if (linewidth < 0) linewidth = 0; */
/* Initialize colors */
if (isblack) {
ColorTable[0] = RGB( 0, 0, 0); /* black = background */
ColorTable[1] = RGB(255,255,255); /* white = text and grid */
}
else {
ColorTable[0] = RGB(255,255,255); /* white = background */
ColorTable[1] = RGB( 0, 0, 0); /* black = text and grid */
}
ColorTable[2] = RGB( 0,255, 0); /* green = first line */
ColorTable[3] = RGB(255, 0, 0); /* red */
ColorTable[4] = RGB( 0, 0,255); /* blue */
ColorTable[5] = RGB(255,255, 0); /* yellow */
ColorTable[6] = RGB(255, 0,255); /* violett */
ColorTable[7] = RGB( 0,255,255); /* azur */
ColorTable[8] = RGB(255,128, 0); /* orange */
ColorTable[9] = RGB(128, 64, 0); /* brown */
ColorTable[10]= RGB(128, 0,255); /* light violett */
ColorTable[11]= RGB(255,128,128); /* pink */
/* 2. color bank (with different line style */
if (isblack)
ColorTable[12]= RGB(255,255,255); /* white */
else
ColorTable[12]= RGB( 0, 0, 0); /* black */
ColorTable[13]= RGB( 0,255, 0); /* green */
ColorTable[14]= RGB(255, 0, 0); /* red */
ColorTable[15]= RGB( 0, 0,255); /* blue */
ColorTable[16]= RGB(255,255, 0); /* yellow */
ColorTable[17]= RGB(255, 0,255); /* violett */
ColorTable[18]= RGB( 0,255,255); /* azur */
ColorTable[19]= RGB(255,128, 0); /* orange */
ColorTable[20]= RGB(128, 64, 0); /* brown */
ColorTable[21]= RGB(128, 0,255); /* light violett */
ColorTable[22]= RGB(255,128,128); /* pink */
/* Ansii fixed font */
PlotFont = GetStockFont( ANSI_FIXED_FONT);
/* register window class */
TheWndClass.lpszClassName = WindowName;
TheWndClass.hInstance = hInst;
TheWndClass.lpfnWndProc = PlotWindowProc;
TheWndClass.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
TheWndClass.lpszMenuName = NULL;
TheWndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
if (isblack)
TheWndClass.hbrBackground = GetStockObject( BLACK_BRUSH);
else
TheWndClass.hbrBackground = GetStockObject( WHITE_BRUSH);
TheWndClass.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(2));
TheWndClass.cbClsExtra = 0;
TheWndClass.cbWndExtra = sizeof(GRAPH *);
if (!RegisterClass(&TheWndClass)) return 1;
}
/* not first time */
else if (isblackold != isblack) {
if (isblack) {
ColorTable[0] = RGB( 0, 0, 0); /* black = background */
ColorTable[1] = RGB(255,255,255); /* white = text and grid */
}
else {
ColorTable[0] = RGB(255,255,255); /* white = background */
ColorTable[1] = RGB( 0, 0, 0); /* black = text and grid */
}
if (isblack)
ColorTable[12]= RGB(255,255,255); /* white */
else
ColorTable[12]= RGB( 0, 0, 0); /* black */
isblackold=isblack;
}
IsRegistered = 1;
/* ready */
return (0);
}
/* NewViewport is responsible for filling in graph->viewport */
int
X11_NewViewport(GRAPH *graph)
{
char fontname[513]; /* who knows . . . */
char *p, *q;
Cursor cursor;
XSetWindowAttributes w_attrs;
XGCValues gcvalues;
static Arg formargs[ ] = {
{ XtNleft, (XtArgVal) XtChainLeft },
{ XtNresizable, (XtArgVal) TRUE }
};
static Arg bboxargs[ ] = {
{ XtNfromHoriz, (XtArgVal) NULL },
{ XtNbottom, (XtArgVal) XtChainTop },
{ XtNtop, (XtArgVal) XtChainTop },
{ XtNleft, (XtArgVal) XtChainRight },
{ XtNright, (XtArgVal) XtChainRight }
};
static Arg buttonargs[ ] = {
{ XtNlabel, (XtArgVal) NULL },
{ XtNfromVert, (XtArgVal) NULL },
{ XtNbottom, (XtArgVal) XtChainTop },
{ XtNtop, (XtArgVal) XtChainTop },
{ XtNleft, (XtArgVal) XtRubber },
{ XtNright, (XtArgVal) XtRubber },
{ XtNresizable, (XtArgVal) TRUE }
};
static Arg viewargs[] = {
{ XtNresizable, (XtArgVal) TRUE },
{ XtNwidth, (XtArgVal) 300 },
{ XtNheight, (XtArgVal) 300 },
{ XtNright, (XtArgVal) XtChainRight }
};
int trys;
graph->devdep = TMALLOC(X11devdep, 1);
/* set up new shell */
DEVDEP(graph).shell = XtCreateApplicationShell
("shell", topLevelShellWidgetClass, NULL, 0);
XtVaSetValues(DEVDEP(graph).shell, XtNtitle, graph->plotname, NULL);
/* set up form widget */
DEVDEP(graph).form = XtCreateManagedWidget
("form", formWidgetClass, DEVDEP(graph).shell, formargs, XtNumber(formargs));
/* set up viewport */
DEVDEP(graph).view = XtCreateManagedWidget
("viewport", widgetClass, DEVDEP(graph).form, viewargs, XtNumber(viewargs));
XtAddEventHandler(DEVDEP(graph).view, ButtonPressMask, FALSE,
handlebuttonev, graph);
XtAddEventHandler(DEVDEP(graph).view, KeyPressMask, FALSE,
handlekeypressed, graph);
XtAddEventHandler(DEVDEP(graph).view, StructureNotifyMask, FALSE,
resize, graph);
XtAddEventHandler(DEVDEP(graph).view, ExposureMask, FALSE,
redraw, graph);
/* set up button box */
XtSetArg(bboxargs[1], XtNfromHoriz, DEVDEP(graph).view);
DEVDEP(graph).buttonbox = XtCreateManagedWidget
("buttonbox", boxWidgetClass, DEVDEP(graph).form, bboxargs, XtNumber(bboxargs));
/* set up buttons */
XtSetArg(buttonargs[0], XtNlabel, "quit");
XtSetArg(bboxargs[1], XtNfromVert, NULL);
DEVDEP(graph).buttons[0] = XtCreateManagedWidget
("quit", commandWidgetClass, DEVDEP(graph).buttonbox, buttonargs, 1);
XtAddCallback(DEVDEP(graph).buttons[0], XtNcallback, killwin, graph);
XtSetArg(buttonargs[0], XtNlabel, "hardcopy");
XtSetArg(bboxargs[1], XtNfromVert, DEVDEP(graph).buttons[0]);
DEVDEP(graph).buttons[1] = XtCreateManagedWidget
("hardcopy", commandWidgetClass, DEVDEP(graph).buttonbox, buttonargs, 1);
XtAddCallback(DEVDEP(graph).buttons[1], XtNcallback, hardcopy, graph);
/* set up fonts */
if (!cp_getvar("font", CP_STRING, fontname))
(void) strcpy(fontname, DEF_FONT);
for (p = fontname; *p && *p <= ' '; p++)
;
if (p != fontname) {
for (q = fontname; *p; *q++ = *p++)
;
*q = 0;
}
trys = 1;
while (!(DEVDEP(graph).font = XLoadQueryFont(display, fontname))) {
sprintf(ErrorMessage, "can't open font %s", fontname);
strcpy(fontname, "fixed");
if (trys > 1) {
internalerror(ErrorMessage);
RECOVERNEWVIEWPORT();
return (1);
}
trys += 1;
}
graph->fontwidth = DEVDEP(graph).font->max_bounds.rbearing -
DEVDEP(graph).font->min_bounds.lbearing + 1;
graph->fontheight = DEVDEP(graph).font->max_bounds.ascent +
DEVDEP(graph).font->max_bounds.descent + 1;
XtRealizeWidget(DEVDEP(graph).shell);
DEVDEP(graph).window = XtWindow(DEVDEP(graph).view);
DEVDEP(graph).isopen = 0;
w_attrs.bit_gravity = ForgetGravity;
XChangeWindowAttributes(display, DEVDEP(graph).window, CWBitGravity,
&w_attrs);
/* have to note font and set mask GCFont in XCreateGC, p.w.h. */
gcvalues.font = DEVDEP(graph).font->fid;
gcvalues.line_width = MW_LINEWIDTH;
gcvalues.cap_style = CapNotLast;
gcvalues.function = GXcopy;
DEVDEP(graph).gc = XCreateGC(display, DEVDEP(graph).window,
GCFont | GCLineWidth | GCCapStyle | GCFunction, &gcvalues);
/* should absolute.positions really be shell.pos? */
graph->absolute.xpos = DEVDEP(graph).view->core.x;
graph->absolute.ypos = DEVDEP(graph).view->core.y;
graph->absolute.width = DEVDEP(graph).view->core.width;
graph->absolute.height = DEVDEP(graph).view->core.height;
initlinestyles();
initcolors(graph);
/* set up cursor */
cursor = XCreateFontCursor(display, XC_left_ptr);
XDefineCursor(display, DEVDEP(graph).window, cursor);
/* WM_DELETE_WINDOW protocol */
atom_wm_protocols = XInternAtom(display, "WM_PROTOCOLS", False);
atom_wm_delete_window = XInternAtom(display, "WM_DELETE_WINDOW", False);
XtAddEventHandler(DEVDEP(graph).shell, NoEventMask, True, handle_wm_messages, graph);
XSetWMProtocols(display, XtWindow(DEVDEP(graph).shell), &atom_wm_delete_window, 1);
return (0);
}
int
X11_Init(void)
{
char buf[512];
char *displayname;
XGCValues gcvalues;
/* grrr, Xtk forced contortions */
char *argv[2];
int argc = 2;
if (cp_getvar("display", CP_STRING, buf)) {
displayname = buf;
} else if (!(displayname = getenv("DISPLAY"))) {
internalerror("Can't open X display.");
return (1);
}
# ifdef DEBUG
_Xdebug = 1;
# endif
argv[0] = "ngspice";
argv[1] = displayname;
/*
argv[2] = "-geometry";
argv[3] = "=1x1+2+2";
*/
/* initialize X toolkit */
toplevel = XtInitialize("ngspice", "Nutmeg", NULL, 0, &argc, argv);
display = XtDisplay(toplevel);
X11_Open = 1;
/* "invert" works better than "xor" for B&W */
/* xor gc should be a function of the pixels that are written on */
/* gcvalues.function = GXxor; */
/* this patch makes lines visible on true color displays
Guenther Roehrich 22-Jan-99 */
gcvalues.function = GXinvert;
gcvalues.line_width = 1;
gcvalues.foreground = 1;
gcvalues.background = 0;
xorgc = XCreateGC(display, DefaultRootWindow(display),
GCLineWidth | GCFunction | GCForeground | GCBackground,
&gcvalues);
/* set correct information */
dispdev->numlinestyles = NUMLINESTYLES;
dispdev->numcolors = NUMCOLORS;
dispdev->width = DisplayWidth(display, DefaultScreen(display));
dispdev->height = DisplayHeight(display, DefaultScreen(display));
/* we don't want non-fatal X errors to call exit */
XSetErrorHandler(errorhandler);
numdispplanes = DisplayPlanes(display, DefaultScreen(display));
return (0);
}
int
BSIM4param(
int param,
IFvalue *value,
GENinstance *inst,
IFvalue *select)
{
double scale;
BSIM4instance *here = (BSIM4instance*)inst;
NG_IGNORE(select);
if (!cp_getvar("scale", CP_REAL, &scale))
scale = 1;
switch(param)
{ case BSIM4_W:
here->BSIM4w = value->rValue * scale;
here->BSIM4wGiven = TRUE;
break;
case BSIM4_L:
here->BSIM4l = value->rValue * scale;
here->BSIM4lGiven = TRUE;
break;
case BSIM4_M:
here->BSIM4m = value->rValue;
here->BSIM4mGiven = TRUE;
break;
case BSIM4_NF:
here->BSIM4nf = value->rValue;
here->BSIM4nfGiven = TRUE;
break;
case BSIM4_MIN:
here->BSIM4min = value->iValue;
here->BSIM4minGiven = TRUE;
break;
case BSIM4_AS:
here->BSIM4sourceArea = value->rValue * scale * scale;
here->BSIM4sourceAreaGiven = TRUE;
break;
case BSIM4_AD:
here->BSIM4drainArea = value->rValue * scale * scale;
here->BSIM4drainAreaGiven = TRUE;
break;
case BSIM4_PS:
here->BSIM4sourcePerimeter = value->rValue * scale;
here->BSIM4sourcePerimeterGiven = TRUE;
break;
case BSIM4_PD:
here->BSIM4drainPerimeter = value->rValue * scale;
here->BSIM4drainPerimeterGiven = TRUE;
break;
case BSIM4_NRS:
here->BSIM4sourceSquares = value->rValue;
here->BSIM4sourceSquaresGiven = TRUE;
break;
case BSIM4_NRD:
here->BSIM4drainSquares = value->rValue;
here->BSIM4drainSquaresGiven = TRUE;
break;
case BSIM4_OFF:
here->BSIM4off = value->iValue;
break;
case BSIM4_SA:
here->BSIM4sa = value->rValue;
here->BSIM4saGiven = TRUE;
break;
case BSIM4_SB:
here->BSIM4sb = value->rValue;
here->BSIM4sbGiven = TRUE;
break;
case BSIM4_SD:
here->BSIM4sd = value->rValue;
here->BSIM4sdGiven = TRUE;
break;
case BSIM4_SCA:
here->BSIM4sca = value->rValue;
here->BSIM4scaGiven = TRUE;
break;
case BSIM4_SCB:
here->BSIM4scb = value->rValue;
here->BSIM4scbGiven = TRUE;
break;
case BSIM4_SCC:
here->BSIM4scc = value->rValue;
here->BSIM4sccGiven = TRUE;
break;
case BSIM4_SC:
here->BSIM4sc = value->rValue;
here->BSIM4scGiven = TRUE;
break;
case BSIM4_RBSB:
here->BSIM4rbsb = value->rValue;
here->BSIM4rbsbGiven = TRUE;
break;
case BSIM4_RBDB:
here->BSIM4rbdb = value->rValue;
here->BSIM4rbdbGiven = TRUE;
break;
case BSIM4_RBPB:
here->BSIM4rbpb = value->rValue;
here->BSIM4rbpbGiven = TRUE;
break;
case BSIM4_RBPS:
here->BSIM4rbps = value->rValue;
here->BSIM4rbpsGiven = TRUE;
break;
case BSIM4_RBPD:
here->BSIM4rbpd = value->rValue;
here->BSIM4rbpdGiven = TRUE;
break;
case BSIM4_DELVTO:
here->BSIM4delvto = value->rValue;
here->BSIM4delvtoGiven = TRUE;
break;
case BSIM4_XGW:
here->BSIM4xgw = value->rValue;
here->BSIM4xgwGiven = TRUE;
break;
case BSIM4_NGCON:
here->BSIM4ngcon = value->rValue;
here->BSIM4ngconGiven = TRUE;
break;
case BSIM4_TRNQSMOD:
here->BSIM4trnqsMod = value->iValue;
here->BSIM4trnqsModGiven = TRUE;
break;
case BSIM4_ACNQSMOD:
here->BSIM4acnqsMod = value->iValue;
here->BSIM4acnqsModGiven = TRUE;
break;
case BSIM4_RBODYMOD:
here->BSIM4rbodyMod = value->iValue;
here->BSIM4rbodyModGiven = TRUE;
break;
case BSIM4_RGATEMOD:
here->BSIM4rgateMod = value->iValue;
here->BSIM4rgateModGiven = TRUE;
break;
case BSIM4_GEOMOD:
here->BSIM4geoMod = value->iValue;
here->BSIM4geoModGiven = TRUE;
break;
case BSIM4_RGEOMOD:
here->BSIM4rgeoMod = value->iValue;
here->BSIM4rgeoModGiven = TRUE;
break;
case BSIM4_IC_VDS:
here->BSIM4icVDS = value->rValue;
here->BSIM4icVDSGiven = TRUE;
break;
case BSIM4_IC_VGS:
here->BSIM4icVGS = value->rValue;
here->BSIM4icVGSGiven = TRUE;
break;
case BSIM4_IC_VBS:
here->BSIM4icVBS = value->rValue;
here->BSIM4icVBSGiven = TRUE;
break;
case BSIM4_IC:
switch(value->v.numValue)
{ case 3:
here->BSIM4icVBS = *(value->v.vec.rVec+2);
here->BSIM4icVBSGiven = TRUE;
case 2:
here->BSIM4icVGS = *(value->v.vec.rVec+1);
here->BSIM4icVGSGiven = TRUE;
case 1:
here->BSIM4icVDS = *(value->v.vec.rVec);
here->BSIM4icVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}
//bool
//do_measure(
// char *what, /*in: analysis type*/
// bool chk_only /*in: TRUE if checking for "autostop", FALSE otherwise*/
//)
int
do_measure(
char *what, /*in: analysis type*/
int chk_only /*in: TRUE if checking for "autostop", FALSE otherwise*/
)
{
struct line *meas_card, *meas_results = NULL, *end = NULL, *newcard;
char *line, *an_name, *an_type, *resname, *meastype, *str_ptr, out_line[1000];
int ok = 0;
int fail;
int num_failed = 0;
double result = 0;
// bool first_time = TRUE;
// bool measures_passed;
int first_time = TRUE;
int measures_passed;
wordlist *measure_word_list;
int precision = measure_get_precision();
#ifdef HAS_PROGREP
if (!chk_only)
SetAnalyse("meas", 0);
#endif
an_name = strdup(what); /* analysis type, e.g. "tran" */
strtolower(an_name);
measure_word_list = NULL;
measures_passed = TRUE;
/* don't allow .meas if batchmode is set by -b and -r rawfile given */
if (ft_batchmode && rflag) {
fprintf(cp_err, "\nNo .measure possible in batch mode (-b) with -r rawfile set!\n");
fprintf(cp_err, "Remove rawfile and use .print or .plot or\n");
fprintf(cp_err, "select interactive mode (optionally with .control section) instead.\n\n");
return (measures_passed);
}
/* don't allow autostop if no .meas commands are given in the input file */
if ((cp_getvar("autostop", CP_BOOL, NULL)) && (ft_curckt->ci_meas == NULL)) {
fprintf(cp_err, "\nWarning: No .meas commands found!\n");
fprintf(cp_err, " Option autostop is not available, ignored!\n\n");
cp_remvar("autostop");
return (FALSE);
}
/* Evaluating the linked list of .meas cards, assembled from the input deck
by fcn inp_spsource() in inp.c:575.
A typical .meas card will contain:
parameter value
nameof card .meas(ure)
analysis type tran only tran available currently
result name myout defined by user
measurement type trig|delay|param|expr|avg|mean|max|min|rms|integ(ral)|when
The measurement type determines how to continue the .meas card.
param|expr are skipped in first pass through .meas cards and are treated in second pass,
all others are treated in fcn get_measure2() (com_measure2.c).
*/
/* first pass through .meas cards: evaluate everything except param|expr */
for (meas_card = ft_curckt->ci_meas; meas_card != NULL; meas_card = meas_card->li_next) {
line = meas_card->li_line;
txfree(gettok(&line)); /* discard .meas */
an_type = gettok(&line);
resname = gettok(&line);
meastype = gettok(&line);
if (chkAnalysisType(an_type) != TRUE) {
if (!chk_only) {
fprintf(cp_err, "Error: unrecognized analysis type '%s' for the following .meas statement on line %d:\n", an_type, meas_card->li_linenum);
fprintf(cp_err, " %s\n", meas_card->li_line);
}
txfree(an_type);
txfree(resname);
txfree(meastype);
continue;
}
/* print header before evaluating first .meas line */
else if (first_time) {
first_time = FALSE;
if (!chk_only && strcmp(an_type, "tran") == 0) {
fprintf(stdout, "\n Measurements for Transient Analysis\n\n");
}
}
/* skip param|expr measurement types for now -- will be done after other measurements */
if (strncmp(meastype, "param", 5) == 0 || strncmp(meastype, "expr", 4) == 0)
continue;
/* skip .meas line, if analysis type from line and name of analysis performed differ */
if (strcmp(an_name, an_type) != 0) {
txfree(an_type);
txfree(resname);
txfree(meastype);
continue;
}
/* New way of processing measure statements using common code
in fcn get_measure2() (com_measure2.c)*/
out_line[0] = '\0';
measure_word_list = measure_parse_line(meas_card->li_line);
if (measure_word_list) {
fail = get_measure2(measure_word_list, &result, out_line, chk_only);
if (fail) {
measures_passed = FALSE;
if (!chk_only)
fprintf(stderr, " %s failed!\n\n", meas_card->li_line);
num_failed++;
if (chk_only) {
/* added for speed - cleanup last parse and break */
txfree(an_type);
txfree(resname);
txfree(meastype);
wl_free(measure_word_list);
break;
}
} else {
if (!chk_only)
nupa_add_param(resname, result);
}
wl_free(measure_word_list);
} else {
measures_passed = FALSE;
num_failed++;
}
if (!chk_only) {
newcard = alloc(struct line);
newcard->li_line = strdup(out_line);
newcard->li_next = NULL;
if (meas_results == NULL) {
meas_results = end = newcard;
} else {
end->li_next = newcard;
end = newcard;
}
}
txfree(an_type);
txfree(resname);
txfree(meastype);
} /* end of for loop (first pass through .meas lines) */
int HSMHVparam(
int param,
IFvalue *value,
GENinstance *inst,
IFvalue *select)
{
double scale;
HSMHVinstance *here = (HSMHVinstance*)inst;
NG_IGNORE(select);
if (!cp_getvar("scale", CP_REAL, &scale))
scale = 1;
switch (param) {
case HSMHV_COSELFHEAT:
here->HSMHV_coselfheat = value->iValue;
here->HSMHV_coselfheat_Given = TRUE;
break;
case HSMHV_COSUBNODE:
here->HSMHV_cosubnode = value->iValue;
here->HSMHV_cosubnode_Given = TRUE;
break;
case HSMHV_W:
here->HSMHV_w = value->rValue * scale;
here->HSMHV_w_Given = TRUE;
break;
case HSMHV_L:
here->HSMHV_l = value->rValue * scale;
here->HSMHV_l_Given = TRUE;
break;
case HSMHV_AS:
here->HSMHV_as = value->rValue * scale * scale;
here->HSMHV_as_Given = TRUE;
break;
case HSMHV_AD:
here->HSMHV_ad = value->rValue * scale * scale;
here->HSMHV_ad_Given = TRUE;
break;
case HSMHV_PS:
here->HSMHV_ps = value->rValue * scale;
here->HSMHV_ps_Given = TRUE;
break;
case HSMHV_PD:
here->HSMHV_pd = value->rValue * scale;
here->HSMHV_pd_Given = TRUE;
break;
case HSMHV_NRS:
here->HSMHV_nrs = value->rValue;
here->HSMHV_nrs_Given = TRUE;
break;
case HSMHV_NRD:
here->HSMHV_nrd = value->rValue;
here->HSMHV_nrd_Given = TRUE;
break;
case HSMHV_DTEMP:
here->HSMHV_dtemp = value->rValue;
here->HSMHV_dtemp_Given = TRUE;
break;
case HSMHV_OFF:
here->HSMHV_off = value->iValue;
break;
case HSMHV_IC_VBS:
here->HSMHV_icVBS = value->rValue;
here->HSMHV_icVBS_Given = TRUE;
break;
case HSMHV_IC_VDS:
here->HSMHV_icVDS = value->rValue;
here->HSMHV_icVDS_Given = TRUE;
break;
case HSMHV_IC_VGS:
here->HSMHV_icVGS = value->rValue;
here->HSMHV_icVGS_Given = TRUE;
break;
case HSMHV_IC:
switch (value->v.numValue) {
case 3:
here->HSMHV_icVBS = *(value->v.vec.rVec + 2);
here->HSMHV_icVBS_Given = TRUE;
case 2:
here->HSMHV_icVGS = *(value->v.vec.rVec + 1);
here->HSMHV_icVGS_Given = TRUE;
case 1:
here->HSMHV_icVDS = *(value->v.vec.rVec);
here->HSMHV_icVDS_Given = TRUE;
break;
default:
return(E_BADPARM);
}
break;
case HSMHV_CORBNET:
here->HSMHV_corbnet = value->iValue;
here->HSMHV_corbnet_Given = TRUE;
break;
case HSMHV_RBPB:
here->HSMHV_rbpb = value->rValue;
here->HSMHV_rbpb_Given = TRUE;
break;
case HSMHV_RBPD:
here->HSMHV_rbpd = value->rValue;
here->HSMHV_rbpd_Given = TRUE;
break;
case HSMHV_RBPS:
here->HSMHV_rbps = value->rValue;
here->HSMHV_rbps_Given = TRUE;
break;
case HSMHV_RBDB:
here->HSMHV_rbdb = value->rValue;
here->HSMHV_rbdb_Given = TRUE;
break;
case HSMHV_RBSB:
here->HSMHV_rbsb = value->rValue;
here->HSMHV_rbsb_Given = TRUE;
break;
case HSMHV_CORG:
here->HSMHV_corg = value->iValue;
here->HSMHV_corg_Given = TRUE;
break;
case HSMHV_NGCON:
here->HSMHV_ngcon = value->rValue;
here->HSMHV_ngcon_Given = TRUE;
break;
case HSMHV_XGW:
here->HSMHV_xgw = value->rValue;
here->HSMHV_xgw_Given = TRUE;
break;
case HSMHV_XGL:
here->HSMHV_xgl = value->rValue;
here->HSMHV_xgl_Given = TRUE;
break;
case HSMHV_NF:
here->HSMHV_nf = value->rValue;
here->HSMHV_nf_Given = TRUE;
break;
case HSMHV_SA:
here->HSMHV_sa = value->rValue;
here->HSMHV_sa_Given = TRUE;
break;
case HSMHV_SB:
here->HSMHV_sb = value->rValue;
here->HSMHV_sb_Given = TRUE;
break;
case HSMHV_SD:
here->HSMHV_sd = value->rValue;
here->HSMHV_sd_Given = TRUE;
break;
case HSMHV_NSUBCDFM:
here->HSMHV_nsubcdfm = value->rValue;
here->HSMHV_nsubcdfm_Given = TRUE;
break;
case HSMHV_M:
here->HSMHV_m = value->rValue;
here->HSMHV_m_Given = TRUE;
break;
case HSMHV_SUBLD1:
here->HSMHV_subld1 = value->rValue;
here->HSMHV_subld1_Given = TRUE;
break;
case HSMHV_SUBLD2:
here->HSMHV_subld2 = value->rValue;
here->HSMHV_subld2_Given = TRUE;
break;
case HSMHV_LOVER:
here->HSMHV_lover = value->rValue;
here->HSMHV_lover_Given = TRUE;
break;
case HSMHV_LOVERS:
here->HSMHV_lovers = value->rValue;
here->HSMHV_lovers_Given = TRUE;
break;
case HSMHV_LOVERLD:
here->HSMHV_loverld = value->rValue;
here->HSMHV_loverld_Given = TRUE;
break;
case HSMHV_LDRIFT1:
here->HSMHV_ldrift1 = value->rValue;
here->HSMHV_ldrift1_Given = TRUE;
break;
case HSMHV_LDRIFT2:
here->HSMHV_ldrift2 = value->rValue;
here->HSMHV_ldrift2_Given = TRUE;
break;
case HSMHV_LDRIFT1S:
here->HSMHV_ldrift1s = value->rValue;
here->HSMHV_ldrift1s_Given = TRUE;
break;
case HSMHV_LDRIFT2S:
here->HSMHV_ldrift2s = value->rValue;
here->HSMHV_ldrift2s_Given = TRUE;
break;
default:
return(E_BADPARM);
}
return(OK);
}
static int
dosim(
char *what, /* in: command (pz,op,dc,ac,tf,tran,sens,disto,noise,run) */
wordlist *wl /* in: command option */
/* global variables in: ft_curckt, ft_circuits,
out: ft_setflag, ft_intrpt, rawfileFp, rawfileBinary,
last_used_rawfile
*/
)
{
wordlist *ww = NULL;
bool dofile = FALSE;
char buf[BSIZE_SP];
struct circ *ct;
int err = 0;
/* set file type to binary or to what is given by environmental
variable SPICE_ASCIIRAWFILE in ivars.c */
bool ascii = AsciiRawFile;
if (eq(what, "run") && wl)
dofile = TRUE;
/* add "what" to beginning of wordlist wl, except "what" equals "run"
and a rawfile name is given (in wl) */
if (!dofile) {
ww = wl_cons(copy(what), wl);
}
/* reset output file type according to variable given in spinit */
if (cp_getvar("filetype", CP_STRING, buf)) {
if (eq(buf, "binary"))
ascii = FALSE;
else if (eq(buf, "ascii"))
ascii = TRUE;
else {
fprintf(cp_err,
"Warning: strange file type \"%s\" (using \"ascii\")\n", buf);
ascii = TRUE;
}
}
if (!ft_curckt) {
fprintf(cp_err, "Error: there aren't any circuits loaded.\n");
return 1;
} else if (ft_curckt->ci_ckt == NULL) { /* Set noparse? */
fprintf(cp_err, "Error: circuit not parsed.\n");
return 1;
}
for (ct = ft_circuits; ct; ct = ct->ci_next)
if (ct->ci_inprogress && (ct != ft_curckt)) {
fprintf(cp_err,
"Warning: losing old state for circuit '%s'\n",
ct->ci_name);
ct->ci_inprogress = FALSE;
}
/* "resume" will never occur in ngspice */
if (ft_curckt->ci_inprogress && eq(what, "resume")) {
ft_setflag = TRUE; /* don't allow abort upon interrupt during run */
ft_intrpt = FALSE;
fprintf(cp_err, "Warning: resuming run in progress.\n");
com_resume(NULL);
ft_setflag = FALSE; /* Now allow aborts again */
return 0;
}
/* From now on until the next prompt, an interrupt will just
* set a flag and let spice finish up, then control will be
* passed back to the user.
*/
ft_setflag = TRUE; /* Don't allow abort upon interrupt during run. */
ft_intrpt = FALSE;
/* command "run" is given with rawfile name in wl */
if (dofile) {
if (!*wl->wl_word)
rawfileFp = stdout;
#if defined(__MINGW32__) || defined(_MSC_VER)
/* ask if binary or ASCII, open file with wb or w */
else if (ascii) {
if ((rawfileFp = fopen(wl->wl_word, "w")) == NULL) {
perror(wl->wl_word);
ft_setflag = FALSE;
return 1;
}
fprintf(cp_out, "ASCII raw file\n");
}
else if (!ascii) {
if ((rawfileFp = fopen(wl->wl_word, "wb")) == NULL) {
perror(wl->wl_word);
ft_setflag = FALSE;
return 1;
}
fprintf(cp_out, "binary raw file\n");
}
/*---------------------------------------------------------------------------*/
#else
else if (!(rawfileFp = fopen(wl->wl_word, "w"))) {
setvbuf(rawfileFp, rawfileBuf, _IOFBF, RAWBUF_SIZE);
perror(wl->wl_word);
ft_setflag = FALSE;
return 1;
}
#endif /* __MINGW32__ */
rawfileBinary = !ascii;
} else {
rawfileFp = NULL;
}
/*save rawfile name */
if (last_used_rawfile)
tfree(last_used_rawfile);
if (rawfileFp)
last_used_rawfile = copy(wl->wl_word);
else
last_used_rawfile = NULL;
ft_curckt->ci_inprogress = TRUE;
/* "sens2" not used in ngspice */
if (eq(what, "sens2")) {
if (if_sens_run(ft_curckt->ci_ckt, ww, ft_curckt->ci_symtab) == 1) {
/* The circuit was interrupted somewhere. */
fprintf(cp_err, "%s simulation interrupted\n", what);
#ifdef XSPICE
/* gtri - add - 12/12/90 - wbk - record error and return errchk */
g_ipc.run_error = IPC_TRUE;
if (g_ipc.enabled)
ipc_send_errchk();
/* gtri - end - 12/12/90 */
#endif
} else {
ft_curckt->ci_inprogress = FALSE;
}
/* Do a run of the circuit */
} else {
err = if_run(ft_curckt->ci_ckt, what, ww, ft_curckt->ci_symtab);
if (err == 1) {
/* The circuit was interrupted somewhere. */
fprintf(cp_err, "%s simulation interrupted\n", what);
#ifdef XSPICE
/* record error and return errchk */
g_ipc.run_error = IPC_TRUE;
if (g_ipc.enabled)
ipc_send_errchk();
/* gtri - end - 12/12/90 */
#endif
err = 0;
} else if (err == 2) {
fprintf(cp_err, "%s simulation(s) aborted\n", what);
ft_curckt->ci_inprogress = FALSE;
err = 1;
} else {
ft_curckt->ci_inprogress = FALSE;
}
}
/* close the rawfile */
if (rawfileFp) {
if (ftell(rawfileFp) == 0) {
(void) fclose(rawfileFp);
(void) unlink(wl->wl_word);
} else {
(void) fclose(rawfileFp);
}
}
ft_curckt->ci_runonce = TRUE;
ft_setflag = FALSE;
/* va: garbage collection: unlink first word (inserted here) and tfree it */
if (!dofile) {
tfree(ww->wl_word);
if (wl)
wl->wl_prev = NULL;
tfree(ww);
}
/* execute the .measure statements */
if (!err && ft_curckt->ci_last_an && ft_curckt->ci_meas)
do_measure(ft_curckt->ci_last_an, FALSE);
return err;
}
void
ft_gnuplot(double *xlims, double *ylims, char *filename, char *title, char *xlabel, char *ylabel, GRIDTYPE gridtype, PLOTTYPE plottype, struct dvec *vecs)
{
FILE *file, *file_data;
struct dvec *v, *scale = NULL;
double xval, yval, extrange;
int i, numVecs, linewidth, err, terminal_type;
bool xlog, ylog, nogrid, markers;
char buf[BSIZE_SP], pointstyle[BSIZE_SP], *text, plotstyle[BSIZE_SP], terminal[BSIZE_SP];
char filename_data[128];
char filename_plt[128];
sprintf(filename_data, "%s.data", filename);
sprintf(filename_plt, "%s.plt", filename);
/* Sanity checking. */
for (v = vecs, numVecs = 0; v; v = v->v_link2)
numVecs++;
if (numVecs == 0) {
return;
} else if (numVecs > GP_MAXVECTORS) {
fprintf(cp_err, "Error: too many vectors for gnuplot.\n");
return;
}
if (fabs((ylims[1]-ylims[0])/ylims[0]) < 1.0e-6) {
fprintf(cp_err, "Error: range min ... max too small for using gnuplot.\n");
fprintf(cp_err, " Consider plotting with offset %g.\n", ylims[0]);
return;
}
extrange = 0.05 * (ylims[1] - ylims[0]);
if (!cp_getvar("gnuplot_terminal", CP_STRING, terminal)) {
terminal_type = 1;
} else {
terminal_type = 1;
if (cieq(terminal,"png"))
terminal_type = 2;
}
if (!cp_getvar("xbrushwidth", CP_NUM, &linewidth))
linewidth = 1;
if (linewidth < 1) linewidth = 1;
if (!cp_getvar("pointstyle", CP_STRING, pointstyle)) {
markers = FALSE;
} else {
if (cieq(pointstyle,"markers"))
markers = TRUE;
else
markers = FALSE;
}
/* Make sure the gridtype is supported. */
switch (gridtype) {
case GRID_LIN:
nogrid = xlog = ylog = FALSE;
break;
case GRID_XLOG:
xlog = TRUE;
nogrid = ylog = FALSE;
break;
case GRID_YLOG:
ylog = TRUE;
nogrid = xlog = FALSE;
break;
case GRID_LOGLOG:
xlog = ylog = TRUE;
nogrid = FALSE;
break;
case GRID_NONE:
nogrid = TRUE;
xlog = ylog = FALSE;
break;
default:
fprintf(cp_err, "Error: grid type unsupported by gnuplot.\n");
return;
}
/* Open the output gnuplot file. */
if ((file = fopen(filename_plt, "w")) == NULL) {
perror(filename);
return;
}
/* Set up the file header. */
#if !defined(__MINGW__) && !defined(_MSC_VER)
fprintf(file, "set terminal X11\n");
#endif
if (title) {
text = cp_unquote(title);
fprintf(file, "set title \"%s\"\n", text);
tfree(text);
}
if (xlabel) {
text = cp_unquote(xlabel);
fprintf(file, "set xlabel \"%s\"\n", text);
tfree(text);
}
if (ylabel) {
text = cp_unquote(ylabel);
fprintf(file, "set ylabel \"%s\"\n", text);
tfree(text);
}
if (!nogrid) {
if (linewidth > 1)
fprintf(file, "set grid lw %d \n" , linewidth);
else
fprintf(file, "set grid\n");
}
if (xlog) {
fprintf(file, "set logscale x\n");
if (xlims)
fprintf(file, "set xrange [%1.0e:%1.0e]\n",
pow(10, floor(log10(xlims[0]))), pow(10, ceil(log10(xlims[1]))));
fprintf(file, "set xrange [%e:%e]\n", xlims[0], xlims[1]);
fprintf(file, "set mxtics 10\n");
fprintf(file, "set grid mxtics\n");
} else {
fprintf(file, "unset logscale x \n");
if (xlims)
fprintf(file, "set xrange [%e:%e]\n", xlims[0], xlims[1]);
}
if (ylog) {
fprintf(file, "set logscale y \n");
if (ylims)
fprintf(file, "set yrange [%1.0e:%1.0e]\n",
pow(10, floor(log10(ylims[0]))), pow(10, ceil(log10(ylims[1]))));
fprintf(file, "set mytics 10\n");
fprintf(file, "set grid mytics\n");
} else {
fprintf(file, "unset logscale y \n");
if (ylims)
fprintf(file, "set yrange [%e:%e]\n", ylims[0] - extrange, ylims[1] + extrange);
}
fprintf(file, "#set xtics 1\n");
fprintf(file, "#set x2tics 1\n");
fprintf(file, "#set ytics 1\n");
fprintf(file, "#set y2tics 1\n");
if (linewidth > 1)
fprintf(file, "set border lw %d\n", linewidth);
if (plottype == PLOT_COMB) {
strcpy(plotstyle, "boxes");
} else if (plottype == PLOT_POINT) {
if (markers) {
// fprintf(file, "Markers: True\n");
} else {
// fprintf(file, "LargePixels: True\n");
}
strcpy(plotstyle, "points");
} else {
strcpy(plotstyle, "lines");
}
/* Open the output gnuplot data file. */
if ((file_data = fopen(filename_data, "w")) == NULL) {
perror(filename);
return;
}
fprintf(file, "set format y \"%%g\"\n");
fprintf(file, "set format x \"%%g\"\n");
fprintf(file, "plot ");
i = 0;
/* Write out the gnuplot command */
for (v = vecs; v; v = v->v_link2) {
scale = v->v_scale;
if (v->v_name) {
i = i + 2;
if (i > 2) fprintf(file, ",\\\n");
fprintf(file, "\'%s\' using %d:%d with %s lw %d title \"%s\" ",
filename_data, i-1, i, plotstyle, linewidth, v->v_name);
}
}
fprintf(file, "\n");
fprintf(file, "set terminal push\n");
if (terminal_type == 1) {
fprintf(file, "set terminal postscript eps color\n");
fprintf(file, "set out \'%s.eps\'\n", filename);
} else {
fprintf(file, "set terminal png\n");
fprintf(file, "set out \'%s.png\'\n", filename);
}
fprintf(file, "replot\n");
fprintf(file, "set term pop\n");
fprintf(file, "replot\n");
(void) fclose(file);
/* Write out the data and setup arrays */
for (i = 0; i < scale->v_length; i++) {
for (v = vecs; v; v = v->v_link2) {
scale = v->v_scale;
xval = isreal(scale) ?
scale->v_realdata[i] : realpart(scale->v_compdata[i]);
yval = isreal(v) ?
v->v_realdata[i] : realpart(v->v_compdata[i]);
fprintf(file_data, "%e %e ", xval, yval);
}
fprintf(file_data, "\n");
}
(void) fclose(file_data);
#if defined(__MINGW32__) || defined(_MSC_VER)
/* for external fcn system() */
// (void) sprintf(buf, "start /B wgnuplot %s -" , filename_plt);
(void) sprintf(buf, "start /B wgnuplot -persist %s " , filename_plt);
_flushall();
#else
/* for external fcn system() from LINUX environment */
(void) sprintf(buf, "xterm -e gnuplot %s - &", filename_plt);
#endif
err = system(buf);
}
//void
//inp_nutsource(FILE *fp, bool comfile, char *filename)
void
inp_nutsource(FILE *fp, int comfile, char *filename)
{
struct line *deck, *dd, *ld;
struct line *realdeck, *options = NULL;
char *tt = NULL, name[BSIZE_SP], *s, *t;
//bool commands = FALSE;
int commands = FALSE;
wordlist *wl = NULL, *end = NULL;
wordlist *controls = NULL;
FILE *lastin, *lastout, *lasterr;
deck = inp_readall(fp, NULL, comfile, FALSE); /* still to check if . or filename instead of NULL */
if (!deck)
return;
realdeck = inp_deckcopy(deck);
if (!comfile) {
/* Save the title before INPgetTitle gets it. */
tt = copy(deck->li_line);
if (!deck->li_next)
fprintf(cp_err, "Warning: no lines in deck...\n");
}
(void) fclose(fp);
/* Now save the IO context and start a new control set... After
* we are done with the source we'll put the old file descriptors
* back. I guess we could use a FILE stack, but since this routine
* is recursive anyway...
*/
lastin = cp_curin;
lastout = cp_curout;
lasterr = cp_curerr;
cp_curin = cp_in;
cp_curout = cp_out;
cp_curerr = cp_err;
cp_pushcontrol();
/* We should now go through the deck and execute front-end
* commands and remove them. Front-end commands are enclosed by
* the lines .control and .endc, unless comfile
* is TRUE, in which case every line must be a front-end command.
* There are too many problems with matching the first word on
* the line.
*/
ld = deck;
if (comfile) {
/* This is easy. */
for (dd = deck; dd; dd = ld) {
ld = dd->li_next;
if ((dd->li_line[0] == '*') && (dd->li_line[1] != '#'))
continue;
if (!ciprefix(".control", dd->li_line) &&
!ciprefix(".endc", dd->li_line)) {
if (dd->li_line[0] == '*')
(void) cp_evloop(dd->li_line + 2);
else
(void) cp_evloop(dd->li_line);
}
tfree(dd->li_line);
tfree(dd);
}
} else {
for (dd = deck->li_next; dd; dd = ld->li_next) {
if ((dd->li_line[0] == '*') && (dd->li_line[1] != '#')) {
ld = dd;
continue;
}
(void) strncpy(name, dd->li_line, BSIZE_SP);
for (s = name; *s && isspace(*s); s++)
;
for (t = s; *t && !isspace(*t); t++)
;
*t = '\0';
if (ciprefix(".control", dd->li_line)) {
ld->li_next = dd->li_next;
tfree(dd->li_line);
tfree(dd);
if (commands)
fprintf(cp_err, "Warning: redundant .control line\n");
else
commands = TRUE;
} else if (ciprefix(".endc", dd->li_line)) {
ld->li_next = dd->li_next;
tfree(dd->li_line);
tfree(dd);
if (commands)
commands = FALSE;
else
fprintf(cp_err, "Warning: misplaced .endc line\n");
} else if (commands || prefix("*#", dd->li_line)) {
controls = wl_cons(NULL, controls);
wl = controls;
if (prefix("*#", dd->li_line))
wl->wl_word = copy(dd->li_line + 2);
else
wl->wl_word = dd->li_line;
ld->li_next = dd->li_next;
tfree(dd);
} else if (!*dd->li_line) {
/* So blank lines in com files don't get
* considered as circuits.
*/
ld->li_next = dd->li_next;
tfree(dd->li_line);
tfree(dd);
} else {
inp_casefix(s);
inp_casefix(dd->li_line);
if (eq(s, ".width") || ciprefix(".four", s) ||
eq(s, ".plot") ||
eq(s, ".print") ||
eq(s, ".save"))
{
wl_append_word(&wl, &end, copy(dd->li_line));
ld->li_next = dd->li_next;
tfree(dd->li_line);
tfree(dd);
} else {
ld = dd;
}
}
}
if (deck->li_next) {
/* There is something left after the controls. */
fprintf(cp_out, "\nCircuit: %s\n\n", tt);
fprintf(stderr, "\nCircuit: %s\n\n", tt);
/* Now expand subcircuit macros. Note that we have to
* fix the case before we do this but after we
* deal with the commands.
*/
if (!cp_getvar("nosubckt", CP_BOOL, NULL))
deck->li_next = inp_subcktexpand(deck->li_next);
deck->li_actual = realdeck;
nutinp_dodeck(deck, tt, wl, FALSE, options, filename);
}
/* Now that the deck is loaded, do the commands... */
controls = wl_reverse(controls);
for (wl = controls; wl; wl = wl->wl_next)
(void) cp_evloop(wl->wl_word);
wl_free(controls);
}
/* Now reset everything. Pop the control stack, and fix up the IO
* as it was before the source.
*/
cp_popcontrol();
cp_curin = lastin;
cp_curout = lastout;
cp_curerr = lasterr;
tfree(tt);
}
void
com_diff(wordlist *wl)
{
double vntol, abstol, reltol, tol, cmax, cm1, cm2;
struct plot *p1, *p2 = NULL;
struct dvec *v1, *v2;
double d1, d2;
ngcomplex_t c1, c2, c3;
int i, j;
char *v1_name; /* cannonical v1 name */
char *v2_name; /* cannonical v2 name */
NGHASHPTR crossref_p; /* cross reference hash table */
SPICE_DSTRING ibuf; /* used to build cannonical name */
wordlist *tw;
char numbuf[BSIZE_SP], numbuf2[BSIZE_SP], numbuf3[BSIZE_SP], numbuf4[BSIZE_SP]; /* For printnum */
if (!cp_getvar("diff_vntol", CP_REAL, &vntol))
vntol = 1.0e-6;
if (!cp_getvar("diff_abstol", CP_REAL, &abstol))
abstol = 1.0e-12;
if (!cp_getvar("diff_reltol", CP_REAL, &reltol))
reltol = 0.001;
/* Let's try to be clever about defaults. This code is ugly. */
if (!wl || !wl->wl_next) {
if (plot_list && plot_list->pl_next && !plot_list->pl_next->pl_next) {
p1 = plot_list;
p2 = plot_list->pl_next;
if (wl && !eq(wl->wl_word, p1->pl_typename) &&
!eq(wl->wl_word, p2->pl_typename)) {
fprintf(cp_err, "Error: no such plot \"%s\"\n",
wl->wl_word);
return;
}
fprintf(cp_err, "Plots are \"%s\" and \"%s\"\n",
plot_list->pl_typename,
plot_list->pl_next->pl_typename);
if (wl)
wl = NULL;
} else {
fprintf(cp_err, "Error: plot names not given.\n");
return;
}
} else {
for (p1 = plot_list; p1; p1 = p1->pl_next)
if (eq(wl->wl_word, p1->pl_typename))
break;
if (!p1) {
fprintf(cp_err, "Error: no such plot %s\n", wl->wl_word);
return;
}
wl = wl->wl_next;
}
if (!p2) {
for (p2 = plot_list; p2; p2 = p2->pl_next)
if (eq(wl->wl_word, p2->pl_typename))
break;
if (!p2) {
fprintf(cp_err, "Error: no such plot %s\n", wl->wl_word);
return;
}
wl = wl->wl_next;
}
/* Now do some tests to make sure these plots are really the
* same type, etc.
*/
if (!eq(p1->pl_name, p2->pl_name))
fprintf(cp_err,
"Warning: plots %s and %s seem to be of different types\n",
p1->pl_typename, p2->pl_typename);
if (!eq(p1->pl_title, p2->pl_title))
fprintf(cp_err,
"Warning: plots %s and %s seem to be from different circuits\n",
p1->pl_typename, p2->pl_typename);
/* This may not be the best way to do this. It wasn't :). The original
* was O(n2) - not good. Now use a hash table to reduce it to O(n). */
for (v1 = p1->pl_dvecs; v1; v1 = v1->v_next)
v1->v_link2 = NULL;
spice_dstring_init(&ibuf);
crossref_p = nghash_init(NGHASH_MIN_SIZE);
nghash_unique(crossref_p, FALSE);
for (v2 = p2->pl_dvecs; v2; v2 = v2->v_next) {
v2->v_link2 = NULL;
v2_name = cannonical_name(v2->v_name, &ibuf);
nghash_insert(crossref_p, v2_name, v2);
}
for (v1 = p1->pl_dvecs; v1; v1 = v1->v_next) {
v1_name = cannonical_name(v1->v_name, &ibuf);
for (v2 = nghash_find(crossref_p, v1_name);
v2;
v2 = nghash_find_again(crossref_p, v1_name))
{
if (!v2->v_link2 &&
((v1->v_flags & (VF_REAL | VF_COMPLEX)) ==
(v2->v_flags & (VF_REAL | VF_COMPLEX))) &&
(v1->v_type == v2->v_type))
{
v1->v_link2 = v2;
v2->v_link2 = v1;
break;
}
}
}
spice_dstring_free(&ibuf);
nghash_free(crossref_p, NULL, NULL);
for (v1 = p1->pl_dvecs; v1; v1 = v1->v_next)
if (!v1->v_link2)
fprintf(cp_err,
">>> %s vector %s in %s not in %s, or of wrong type\n",
isreal(v1) ? "real" : "complex",
v1->v_name, p1->pl_typename, p2->pl_typename);
for (v2 = p2->pl_dvecs; v2; v2 = v2->v_next)
if (!v2->v_link2)
fprintf(cp_err,
">>> %s vector %s in %s not in %s, or of wrong type\n",
isreal(v2) ? "real" : "complex",
v2->v_name, p2->pl_typename, p1->pl_typename);
/* Throw out the ones that aren't in the arg list */
if (wl && !eq(wl->wl_word, "all")) { /* Just in case */
for (v1 = p1->pl_dvecs; v1; v1 = v1->v_next)
if (v1->v_link2) {
for (tw = wl; tw; tw = tw->wl_next)
if (nameeq(v1->v_name, tw->wl_word))
break;
if (!tw)
v1->v_link2 = NULL;
}
for (v2 = p2->pl_dvecs; v2; v2 = v2->v_next)
if (v2->v_link2) {
for (tw = wl; tw; tw = tw->wl_next)
if (nameeq(v2->v_name, tw->wl_word))
break;
if (!tw)
v2->v_link2 = NULL;
}
}
/* Now we have all the vectors linked to their twins. Travel
* down each one and print values that differ enough.
*/
for (v1 = p1->pl_dvecs; v1; v1 = v1->v_next) {
if (!v1->v_link2)
continue;
v2 = v1->v_link2;
if (v1->v_type == SV_VOLTAGE)
tol = vntol;
else
tol = abstol;
j = MAX(v1->v_length, v2->v_length);
for (i = 0; i < j; i++) {
if (v1->v_length <= i) {
fprintf(cp_out,
">>> %s is %d long in %s and %d long in %s\n",
v1->v_name, v1->v_length,
p1->pl_typename, v2->v_length, p2->pl_typename);
break;
} else if (v2->v_length <= i) {
fprintf(cp_out,
">>> %s is %d long in %s and %d long in %s\n",
v2->v_name, v2->v_length,
p2->pl_typename, v1->v_length, p1->pl_typename);
break;
} else {
if (isreal(v1)) {
d1 = v1->v_realdata[i];
d2 = v2->v_realdata[i];
if (MAX(fabs(d1), fabs(d2)) * reltol +
tol < fabs(d1 - d2)) {
printnum(numbuf, d1);
fprintf(cp_out,
"%s.%s[%d] = %-15s ",
p1->pl_typename, v1->v_name, i, numbuf);
printnum(numbuf, d2);
fprintf(cp_out,
"%s.%s[%d] = %s\n",
p2->pl_typename, v2->v_name, i, numbuf);
}
} else {
c1 = v1->v_compdata[i];
c2 = v2->v_compdata[i];
realpart(c3) = realpart(c1) - realpart(c2);
imagpart(c3) = imagpart(c1) - imagpart(c2);
/* Stupid evil PC compilers */
cm1 = cmag(c1);
cm2 = cmag(c2);
cmax = MAX(cm1, cm2);
if (cmax * reltol + tol < cmag(c3)) {
printnum(numbuf, realpart(c1));
printnum(numbuf2, imagpart(c1));
printnum(numbuf3, realpart(c2));
printnum(numbuf4, imagpart(c2));
fprintf(cp_out,
"%s.%s[%d] = %-10s, %-10s %s.%s[%d] = %-10s, %s\n",
p1->pl_typename, v1->v_name, i,
numbuf,
numbuf2,
p2->pl_typename, v2->v_name, i,
numbuf3,
numbuf4);
}
}
}
}
}
}
int
BSIM3v1param(int param, IFvalue *value, GENinstance *inst, IFvalue *select)
{
double scale;
BSIM3v1instance *here = (BSIM3v1instance*)inst;
if ( !cp_getvar( "scale", CP_REAL, (double*) &scale ) ) scale = 1;
switch(param)
{ case BSIM3v1_W:
here->BSIM3v1w = value->rValue*scale;
here->BSIM3v1wGiven = TRUE;
break;
case BSIM3v1_L:
here->BSIM3v1l = value->rValue*scale;
here->BSIM3v1lGiven = TRUE;
break;
case BSIM3v1_M:
here->BSIM3v1m = value->rValue;
here->BSIM3v1mGiven = TRUE;
break;
case BSIM3v1_AS:
here->BSIM3v1sourceArea = value->rValue*scale*scale;
here->BSIM3v1sourceAreaGiven = TRUE;
break;
case BSIM3v1_AD:
here->BSIM3v1drainArea = value->rValue*scale*scale;
here->BSIM3v1drainAreaGiven = TRUE;
break;
case BSIM3v1_PS:
here->BSIM3v1sourcePerimeter = value->rValue*scale;
here->BSIM3v1sourcePerimeterGiven = TRUE;
break;
case BSIM3v1_PD:
here->BSIM3v1drainPerimeter = value->rValue*scale;
here->BSIM3v1drainPerimeterGiven = TRUE;
break;
case BSIM3v1_NRS:
here->BSIM3v1sourceSquares = value->rValue;
here->BSIM3v1sourceSquaresGiven = TRUE;
break;
case BSIM3v1_NRD:
here->BSIM3v1drainSquares = value->rValue;
here->BSIM3v1drainSquaresGiven = TRUE;
break;
case BSIM3v1_OFF:
here->BSIM3v1off = value->iValue;
break;
case BSIM3v1_IC_VBS:
here->BSIM3v1icVBS = value->rValue;
here->BSIM3v1icVBSGiven = TRUE;
break;
case BSIM3v1_IC_VDS:
here->BSIM3v1icVDS = value->rValue;
here->BSIM3v1icVDSGiven = TRUE;
break;
case BSIM3v1_IC_VGS:
here->BSIM3v1icVGS = value->rValue;
here->BSIM3v1icVGSGiven = TRUE;
break;
case BSIM3v1_NQSMOD:
here->BSIM3v1nqsMod = value->iValue;
here->BSIM3v1nqsModGiven = TRUE;
break;
case BSIM3v1_IC:
switch(value->v.numValue){
case 3:
here->BSIM3v1icVBS = *(value->v.vec.rVec+2);
here->BSIM3v1icVBSGiven = TRUE;
case 2:
here->BSIM3v1icVGS = *(value->v.vec.rVec+1);
here->BSIM3v1icVGSGiven = TRUE;
case 1:
here->BSIM3v1icVDS = *(value->v.vec.rVec);
here->BSIM3v1icVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}
int
fourier(wordlist *wl, struct plot *current_plot)
{
struct dvec *time, *vec;
struct pnode *pn, *names;
double *ff, fundfreq, *data = NULL;
int nfreqs, fourgridsize, polydegree;
double *freq, *mag, *phase, *nmag, *nphase; /* Outputs from CKTfour */
double thd, *timescale = NULL;
char *s;
int i, err, fw;
char xbuf[20];
int shift;
int rv = 1;
char newvecname[32];
struct dvec *n;
int newveccount = 1;
static int callstof = 1;
if (!current_plot)
return 1;
sprintf(xbuf, "%1.1e", 0.0);
shift = (int) strlen(xbuf) - 7;
if (!current_plot || !current_plot->pl_scale) {
fprintf(cp_err, "Error: no vectors loaded.\n");
return 1;
}
if (!cp_getvar("nfreqs", CP_NUM, &nfreqs) || nfreqs < 1)
nfreqs = 10;
if (!cp_getvar("polydegree", CP_NUM, &polydegree) || polydegree < 0)
polydegree = 1;
if (!cp_getvar("fourgridsize", CP_NUM, &fourgridsize) || fourgridsize < 1)
fourgridsize = DEF_FOURGRIDSIZE;
time = current_plot->pl_scale;
if (!isreal(time)) {
fprintf(cp_err, "Error: fourier needs real time scale\n");
return 1;
}
s = wl->wl_word;
if ((ff = ft_numparse(&s, FALSE)) == NULL || (*ff <= 0.0)) {
fprintf(cp_err, "Error: bad fund freq %s\n", wl->wl_word);
return 1;
}
fundfreq = *ff;
freq = TMALLOC(double, nfreqs);
mag = TMALLOC(double, nfreqs);
phase = TMALLOC(double, nfreqs);
nmag = TMALLOC(double, nfreqs);
nphase = TMALLOC(double, nfreqs);
wl = wl->wl_next;
names = ft_getpnames(wl, TRUE);
for (pn = names; pn; pn = pn->pn_next) {
vec = ft_evaluate(pn);
for (; vec; vec = vec->v_link2) {
if (vec->v_length != time->v_length) {
fprintf(cp_err,
"Error: lengths don't match: %d, %d\n",
vec->v_length, time->v_length);
continue;
}
if (!isreal(vec)) {
fprintf(cp_err, "Error: %s isn't real!\n", vec->v_name);
continue;
}
if (polydegree) {
double *dp, d;
/* Build the grid... */
timescale = TMALLOC(double, fourgridsize);
data = TMALLOC(double, fourgridsize);
dp = ft_minmax(time, TRUE);
/* Now get the last fund freq... */
d = 1 / fundfreq; /* The wavelength... */
if (dp[1] - dp[0] < d) {
fprintf(cp_err, "Error: wavelength longer than time span\n");
goto done;
} else if (dp[1] - dp[0] > d) {
dp[0] = dp[1] - d;
}
d = (dp[1] - dp[0]) / fourgridsize;
for (i = 0; i < fourgridsize; i++)
timescale[i] = dp[0] + i * d;
/* Now interpolate the data... */
if (!ft_interpolate(vec->v_realdata, data,
time->v_realdata, vec->v_length,
timescale, fourgridsize,
polydegree)) {
fprintf(cp_err, "Error: can't interpolate\n");
goto done;
}
} else {
fourgridsize = vec->v_length;
data = vec->v_realdata;
timescale = time->v_realdata;
}
err = CKTfour(fourgridsize, nfreqs, &thd, timescale,
data, fundfreq, freq, mag, phase, nmag,
nphase);
if (err != OK) {
ft_sperror(err, "fourier");
goto done;
}
fprintf(cp_out, "Fourier analysis for %s:\n", vec->v_name);
fprintf(cp_out,
" No. Harmonics: %d, THD: %g %%, Gridsize: %d, Interpolation Degree: %d\n\n",
nfreqs, thd, fourgridsize,
polydegree);
/* Each field will have width cp_numdgt + 6 (or 7
* with HP-UX) + 1 if there is a - sign.
*/
fw = ((cp_numdgt > 0) ? cp_numdgt : 6) + 5 + shift;
fprintf(cp_out, "Harmonic %-*s %-*s %-*s %-*s %-*s\n",
fw, "Frequency", fw, "Magnitude",
fw, "Phase", fw, "Norm. Mag",
fw, "Norm. Phase");
fprintf(cp_out, "-------- %-*s %-*s %-*s %-*s %-*s\n",
fw, "---------", fw, "---------",
fw, "-----", fw, "---------",
fw, "-----------");
for (i = 0; i < nfreqs; i++) {
char *pnumfr, *pnumma, *pnumph, *pnumnm, *pnumnp;
pnumfr = pnum(freq[i]);
pnumma = pnum(mag[i]);
pnumph = pnum(phase[i]);
pnumnm = pnum(nmag[i]);
pnumnp = pnum(nphase[i]);
fprintf(cp_out,
" %-4d %-*s %-*s %-*s %-*s %-*s\n",
i,
fw, pnumfr,
fw, pnumma,
fw, pnumph,
fw, pnumnm,
fw, pnumnp);
tfree(pnumfr);
tfree(pnumma);
tfree(pnumph);
tfree(pnumnm);
tfree(pnumnp);
}
fputs("\n", cp_out);
/* generate name for new vector, using vec->name */
sprintf(newvecname, "fourier%d%d", callstof, newveccount);
/* create and assign a new vector n */
/* with size 3 * nfreqs in current plot */
n = alloc(struct dvec);
ZERO(n, struct dvec);
n->v_name = copy(newvecname);
n->v_type = SV_NOTYPE;
n->v_flags = (VF_REAL | VF_PERMANENT);
n->v_length = 3 * nfreqs;
n->v_numdims = 2;
n->v_dims[0] = 3;
n->v_dims[1] = nfreqs;
n->v_realdata = TMALLOC(double, n->v_length);
vec_new(n);
/* store data in vector: freq, mag, phase */
for (i = 0; i < nfreqs; i++) {
n->v_realdata[i] = freq[i];
n->v_realdata[i + nfreqs] = mag[i];
n->v_realdata[i + 2 * nfreqs] = phase[i];
}
newveccount++;
if (polydegree) {
tfree(timescale);
tfree(data);
}
timescale = NULL;
data = NULL;
}
}
void
ft_xgraph(double *xlims, double *ylims, char *filename, char *title, char *xlabel, char *ylabel, GRIDTYPE gridtype, PLOTTYPE plottype, struct dvec *vecs)
{
FILE *file;
struct dvec *v, *scale;
double xval, yval;
int i, numVecs, linewidth;
bool xlog, ylog, nogrid, markers;
char buf[BSIZE_SP], pointstyle[BSIZE_SP], *text;
/* Sanity checking. */
for (v = vecs, numVecs = 0; v; v = v->v_link2)
numVecs++;
if (numVecs == 0) {
return;
} else if (numVecs > XG_MAXVECTORS) {
fprintf(cp_err, "Error: too many vectors for Xgraph.\n");
return;
}
if (!cp_getvar("xbrushwidth", CP_NUM, &linewidth))
linewidth = 1;
if (linewidth < 1)
linewidth = 1;
if (!cp_getvar("pointstyle", CP_STRING, pointstyle)) {
markers = FALSE;
} else {
if (cieq(pointstyle, "markers"))
markers = TRUE;
else
markers = FALSE;
}
/* Make sure the gridtype is supported. */
switch (gridtype) {
case GRID_LIN:
nogrid = xlog = ylog = FALSE;
break;
case GRID_XLOG:
xlog = TRUE;
nogrid = ylog = FALSE;
break;
case GRID_YLOG:
ylog = TRUE;
nogrid = xlog = FALSE;
break;
case GRID_LOGLOG:
xlog = ylog = TRUE;
nogrid = FALSE;
break;
case GRID_NONE:
nogrid = TRUE;
xlog = ylog = FALSE;
break;
default:
fprintf(cp_err, "Error: grid type unsupported by Xgraph.\n");
return;
}
/* Open the output file. */
if ((file = fopen(filename, "w")) == NULL) {
perror(filename);
return;
}
/* Set up the file header. */
if (title) {
text = cp_unquote(title);
fprintf(file, "TitleText: %s\n", text);
tfree(text);
}
if (xlabel) {
text = cp_unquote(xlabel);
fprintf(file, "XUnitText: %s\n", text);
tfree(text);
}
if (ylabel) {
text = cp_unquote(ylabel);
fprintf(file, "YUnitText: %s\n", text);
tfree(text);
}
if (nogrid) {
fprintf(file, "Ticks: True\n");
}
if (xlog) {
fprintf(file, "LogX: True\n");
if (xlims) {
fprintf(file, "XLowLimit: % e\n", log10(xlims[0]));
fprintf(file, "XHighLimit: % e\n", log10(xlims[1]));
}
} else {
if (xlims) {
fprintf(file, "XLowLimit: % e\n", xlims[0]);
fprintf(file, "XHighLimit: % e\n", xlims[1]);
}
}
if (ylog) {
fprintf(file, "LogY: True\n");
if (ylims) {
fprintf(file, "YLowLimit: % e\n", log10(ylims[0]));
fprintf(file, "YHighLimit: % e\n", log10(ylims[1]));
}
} else {
if (ylims) {
fprintf(file, "YLowLimit: % e\n", ylims[0]);
fprintf(file, "YHighLimit: % e\n", ylims[1]);
}
}
fprintf(file, "LineWidth: %d\n", linewidth);
fprintf(file, "BoundBox: True\n");
if (plottype == PLOT_COMB) {
fprintf(file, "BarGraph: True\n");
fprintf(file, "NoLines: True\n");
} else if (plottype == PLOT_POINT) {
if (markers)
fprintf(file, "Markers: True\n");
else
fprintf(file, "LargePixels: True\n");
fprintf(file, "NoLines: True\n");
}
/* Write out the data. */
for (v = vecs; v; v = v->v_link2) {
scale = v->v_scale;
if (v->v_name)
fprintf(file, "\"%s\"\n", v->v_name);
for (i = 0; i < scale->v_length; i++) {
xval = isreal(scale) ?
scale->v_realdata[i] : realpart(scale->v_compdata[i]);
yval = isreal(v) ?
v->v_realdata[i] : realpart(v->v_compdata[i]);
fprintf(file, "% e % e\n", xval, yval);
}
fprintf(file, "\n");
}
(void) fclose(file);
(void) sprintf(buf, "xgraph %s &", filename);
(void) system(buf);
}
/* should be able to do this by sleight of hand on graph parameters */
static void
zoomin(GRAPH *graph)
{
/* note: need to add circular boxes XXX */
int x0, y0, x1, y1;
double fx0, fx1, fy0, fy1, ftemp;
char buf[BSIZE_SP];
char buf2[128];
char *t;
Window rootwindow, childwindow;
int rootx, rooty;
unsigned int state;
int x, y, upperx, uppery;
unsigned width, height;
/* open box and get area to zoom in on */
XQueryPointer(display, DEVDEP(graph).window, &rootwindow,
&childwindow, &rootx, &rooty, &x0, &y0, &state);
x = x1 = x0 + BOXSIZE;
y = y1 = y0 + BOXSIZE;
upperx = x0;
uppery = y0;
width = BOXSIZE;
height = BOXSIZE;
XDrawRectangle(display, DEVDEP(graph).window, xorgc,
upperx, uppery, width, height);
XWarpPointer(display, None, DEVDEP(graph).window, 0, 0, 0, 0, x1, y1);
while (state & Button3Mask) {
if (x != x1 || y != y1) {
x1 = x;
y1 = y;
XDrawRectangle(display, DEVDEP(graph).window, xorgc,
upperx, uppery, width, height);
upperx = MIN(x1, x0);
uppery = MIN(y1, y0);
width = (unsigned) ABS(x1 - x0);
height = (unsigned) ABS(y1 - y0);
XDrawRectangle(display, DEVDEP(graph).window, xorgc,
upperx, uppery, width, height);
}
XQueryPointer(display, DEVDEP(graph).window, &rootwindow,
&childwindow, &rootx, &rooty, &x, &y, &state);
}
XDrawRectangle(display, DEVDEP(graph).window, xorgc,
upperx, uppery, width, height);
X_ScreentoData(graph, x0, y0, &fx0, &fy0);
X_ScreentoData(graph, x1, y1, &fx1, &fy1);
if (fx0 > fx1) {
ftemp = fx0;
fx0 = fx1;
fx1 = ftemp;
}
if (fy0 > fy1) {
ftemp = fy0;
fy0 = fy1;
fy1 = ftemp;
}
strncpy(buf2, graph->plotname, sizeof(buf2));
if ((t = strchr(buf2, ':')) != NULL)
*t = 0;
if (!eq(plot_cur->pl_typename, buf2)) {
(void) sprintf(buf,
"setplot %s; %s xlimit %.20e %.20e ylimit %.20e %.20e; setplot $curplot\n",
buf2, graph->commandline, fx0, fx1, fy0, fy1);
} else {
(void) sprintf(buf, "%s xlimit %e %e ylimit %e %e\n",
graph->commandline, fx0, fx1, fy0, fy1);
}
/* don't use the following if using GNU Readline or BSD EditLine */
#if !defined(HAVE_GNUREADLINE) && !defined(HAVE_BSDEDITLINE)
{
wordlist *wl;
/* hack for Gordon Jacobs */
/* add to history list if plothistory is set */
if (cp_getvar("plothistory", CP_BOOL, NULL)) {
wl = cp_parse(buf);
(void) cp_addhistent(cp_event++, wl);
}
}
#endif /* !defined(HAVE_GNUREADLINE) && !defined(HAVE_BSDEDITLINE) */
(void) cp_evloop(buf);
}
static void
initcolors(GRAPH *graph)
{
int i;
static char *colornames[] = { "black", /* white */
"white", "red", "blue",
"orange", "green", "pink",
"brown", "khaki", "plum",
"orchid", "violet", "maroon",
"turquoise", "sienna", "coral",
"cyan", "magenta", "gold",
"yellow", ""
};
XColor visualcolor, exactcolor;
char buf[BSIZE_SP], colorstring[BSIZE_SP];
int xmaxcolors = NUMCOLORS; /* note: can we get rid of this? */
if (numdispplanes == 1) {
/* black and white */
xmaxcolors = 2;
DEVDEP(graph).colors[0] = DEVDEP(graph).view->core.background_pixel;
if (DEVDEP(graph).colors[0] == WhitePixel(display, DefaultScreen(display)))
DEVDEP(graph).colors[1] = BlackPixel(display, DefaultScreen(display));
else
DEVDEP(graph).colors[1] = WhitePixel(display, DefaultScreen(display));
} else {
if (numdispplanes < NXPLANES)
xmaxcolors = 1 << numdispplanes;
for (i = 0; i < xmaxcolors; i++) {
(void) sprintf(buf, "color%d", i);
if (!cp_getvar(buf, CP_STRING, colorstring))
(void) strcpy(colorstring, colornames[i]);
if (!XAllocNamedColor(display,
DefaultColormap(display, DefaultScreen(display)),
colorstring, &visualcolor, &exactcolor)) {
(void) sprintf(ErrorMessage,
"can't get color %s\n", colorstring);
externalerror(ErrorMessage);
DEVDEP(graph).colors[i] = i ? BlackPixel(display,
DefaultScreen(display))
: WhitePixel(display, DefaultScreen(display));
continue;
}
DEVDEP(graph).colors[i] = visualcolor.pixel;
/* MW. I don't need this, everyone must know what he is doing
if (i > 0 &&
DEVDEP(graph).colors[i] == DEVDEP(graph).view->core.background_pixel) {
DEVDEP(graph).colors[i] = DEVDEP(graph).colors[0];
} */
}
/* MW. Set Beackgroound here */
XSetWindowBackground(display, DEVDEP(graph).window, DEVDEP(graph).colors[0]);
/* if (DEVDEP(graph).colors[0] != DEVDEP(graph).view->core.background_pixel) {
DEVDEP(graph).colors[0] = DEVDEP(graph).view->core.background_pixel;
} */
}
for (i = xmaxcolors; i < NUMCOLORS; i++) {
DEVDEP(graph).colors[i] = DEVDEP(graph).colors[i + 1 - xmaxcolors];
}
}
int
BSIM3v32param (int param, IFvalue *value, GENinstance *inst, IFvalue *select)
{
double scale;
BSIM3v32instance *here = (BSIM3v32instance*)inst;
NG_IGNORE(select);
if (!cp_getvar("scale", CP_REAL, &scale, 0))
scale = 1;
switch(param)
{ case BSIM3v32_W:
here->BSIM3v32w = value->rValue*scale;
here->BSIM3v32wGiven = TRUE;
break;
case BSIM3v32_L:
here->BSIM3v32l = value->rValue*scale;
here->BSIM3v32lGiven = TRUE;
break;
case BSIM3v32_M:
here->BSIM3v32m = value->rValue;
here->BSIM3v32mGiven = TRUE;
break;
case BSIM3v32_AS:
here->BSIM3v32sourceArea = value->rValue*scale*scale;
here->BSIM3v32sourceAreaGiven = TRUE;
break;
case BSIM3v32_AD:
here->BSIM3v32drainArea = value->rValue*scale*scale;
here->BSIM3v32drainAreaGiven = TRUE;
break;
case BSIM3v32_PS:
here->BSIM3v32sourcePerimeter = value->rValue*scale;
here->BSIM3v32sourcePerimeterGiven = TRUE;
break;
case BSIM3v32_PD:
here->BSIM3v32drainPerimeter = value->rValue*scale;
here->BSIM3v32drainPerimeterGiven = TRUE;
break;
case BSIM3v32_NRS:
here->BSIM3v32sourceSquares = value->rValue;
here->BSIM3v32sourceSquaresGiven = TRUE;
break;
case BSIM3v32_NRD:
here->BSIM3v32drainSquares = value->rValue;
here->BSIM3v32drainSquaresGiven = TRUE;
break;
case BSIM3v32_OFF:
here->BSIM3v32off = value->iValue;
break;
case BSIM3v32_IC_VBS:
here->BSIM3v32icVBS = value->rValue;
here->BSIM3v32icVBSGiven = TRUE;
break;
case BSIM3v32_IC_VDS:
here->BSIM3v32icVDS = value->rValue;
here->BSIM3v32icVDSGiven = TRUE;
break;
case BSIM3v32_IC_VGS:
here->BSIM3v32icVGS = value->rValue;
here->BSIM3v32icVGSGiven = TRUE;
break;
case BSIM3v32_NQSMOD:
here->BSIM3v32nqsMod = value->iValue;
here->BSIM3v32nqsModGiven = TRUE;
break;
case BSIM3v32_GEO:
here->BSIM3v32geo = value->iValue;
here->BSIM3v32geoGiven = TRUE;
break;
case BSIM3v32_DELVTO:
here->BSIM3v32delvto = value->rValue;
here->BSIM3v32delvtoGiven = TRUE;
break;
case BSIM3v32_MULU0:
here->BSIM3v32mulu0 = value->rValue;
here->BSIM3v32mulu0Given = TRUE;
break;
case BSIM3v32_IC:
switch(value->v.numValue){
case 3:
here->BSIM3v32icVBS = *(value->v.vec.rVec+2);
here->BSIM3v32icVBSGiven = TRUE;
case 2:
here->BSIM3v32icVGS = *(value->v.vec.rVec+1);
here->BSIM3v32icVGSGiven = TRUE;
case 1:
here->BSIM3v32icVDS = *(value->v.vec.rVec);
here->BSIM3v32icVDSGiven = TRUE;
break;
default:
return(E_BADPARM);
}
break;
default:
return(E_BADPARM);
}
return(OK);
}
static int
beginPlot(JOB *analysisPtr, CKTcircuit *circuitPtr, char *cktName, char *analName, char *refName, int refType, int numNames, char **dataNames, int dataType, bool windowed, runDesc **runp)
{
runDesc *run;
struct save_info *saves;
bool *savesused = NULL;
int numsaves;
int i, j, depind = 0;
char namebuf[BSIZE_SP], parambuf[BSIZE_SP], depbuf[BSIZE_SP];
char *ch, tmpname[BSIZE_SP];
bool saveall = TRUE;
bool savealli = FALSE;
char *an_name;
/*to resume a run saj
*All it does is reassign the file pointer and return (requires *runp to be NULL if this is not needed)
*/
if (dataType == 666 && numNames == 666) {
run = *runp;
run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary,
run->type, run->name);
} else {
/*end saj*/
/* Check to see if we want to print informational data. */
if (cp_getvar("printinfo", CP_BOOL, NULL))
fprintf(cp_err, "(debug printing enabled)\n");
/* Check to see if we want to save only interpolated data. */
if (cp_getvar("interp", CP_BOOL, NULL)) {
interpolated = TRUE;
fprintf(cp_out, "Warning: Interpolated raw file data!\n\n");
}
*runp = run = TMALLOC(struct runDesc, 1);
/* First fill in some general information. */
run->analysis = analysisPtr;
run->circuit = circuitPtr;
run->name = copy(cktName);
run->type = copy(analName);
run->windowed = windowed;
run->numData = 0;
an_name = spice_analysis_get_name(analysisPtr->JOBtype);
ft_curckt->ci_last_an = an_name;
/* Now let's see which of these things we need. First toss in the
* reference vector. Then toss in anything that getSaves() tells
* us to save that we can find in the name list. Finally unpack
* the remaining saves into parameters.
*/
numsaves = ft_getSaves(&saves);
if (numsaves) {
savesused = TMALLOC(bool, numsaves);
saveall = FALSE;
for (i = 0; i < numsaves; i++) {
if (saves[i].analysis && !cieq(saves[i].analysis, an_name)) {
/* ignore this one this time around */
savesused[i] = TRUE;
continue;
}
/* Check for ".save all" and new synonym ".save allv" */
if (cieq(saves[i].name, "all") || cieq(saves[i].name, "allv")) {
saveall = TRUE;
savesused[i] = TRUE;
saves[i].used = 1;
continue;
}
/* And now for the new ".save alli" option */
if (cieq(saves[i].name, "alli")) {
savealli = TRUE;
savesused[i] = TRUE;
saves[i].used = 1;
continue;
}
}
}
/* Pass 0. */
if (refName) {
addDataDesc(run, refName, refType, -1);
for (i = 0; i < numsaves; i++)
if (!savesused[i] && name_eq(saves[i].name, refName)) {
savesused[i] = TRUE;
saves[i].used = 1;
}
} else {
run->refIndex = -1;
}
/* Pass 1. */
if (numsaves && !saveall) {
for (i = 0; i < numsaves; i++)
if (!savesused[i])
for (j = 0; j < numNames; j++)
if (name_eq(saves[i].name, dataNames[j])) {
addDataDesc(run, dataNames[j], dataType, j);
savesused[i] = TRUE;
saves[i].used = 1;
break;
}
} else {
for (i = 0; i < numNames; i++)
if (!refName || !name_eq(dataNames[i], refName))
/* Save the node as long as it's an internal device node */
if (!strstr(dataNames[i], "#internal") &&
!strstr(dataNames[i], "#source") &&
!strstr(dataNames[i], "#drain") &&
!strstr(dataNames[i], "#collector") &&
!strstr(dataNames[i], "#emitter") &&
!strstr(dataNames[i], "#base"))
{
addDataDesc(run, dataNames[i], dataType, i);
}
}
/* Pass 1 and a bit.
This is a new pass which searches for all the internal device
nodes, and saves the terminal currents instead */
if (savealli) {
depind = 0;
for (i = 0; i < numNames; i++) {
if (strstr(dataNames[i], "#internal") ||
strstr(dataNames[i], "#source") ||
strstr(dataNames[i], "#drain") ||
strstr(dataNames[i], "#collector") ||
strstr(dataNames[i], "#emitter") ||
strstr(dataNames[i], "#base"))
{
tmpname[0] = '@';
tmpname[1] = '\0';
strncat(tmpname, dataNames[i], BSIZE_SP-1);
ch = strchr(tmpname, '#');
if (strstr(ch, "#collector")) {
strcpy(ch, "[ic]");
} else if (strstr(ch, "#base")) {
strcpy(ch, "[ib]");
} else if (strstr(ch, "#emitter")) {
strcpy(ch, "[ie]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[is]");
} else if (strstr(ch, "#drain")) {
strcpy(ch, "[id]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[ig]");
} else if (strstr(ch, "#source")) {
strcpy(ch, "[is]");
if (parseSpecial(tmpname, namebuf, parambuf, depbuf))
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
strcpy(ch, "[ib]");
} else if (strstr(ch, "#internal") && (tmpname[1] == 'd')) {
strcpy(ch, "[id]");
} else {
fprintf(cp_err,
"Debug: could output current for %s\n", tmpname);
continue;
}
if (parseSpecial(tmpname, namebuf, parambuf, depbuf)) {
if (*depbuf) {
fprintf(stderr,
"Warning : unexpected dependent variable on %s\n", tmpname);
} else {
addSpecialDesc(run, tmpname, namebuf, parambuf, depind);
}
}
}
}
}
/* Pass 2. */
for (i = 0; i < numsaves; i++) {
if (savesused[i])
continue;
if (!parseSpecial(saves[i].name, namebuf, parambuf, depbuf)) {
if (saves[i].analysis)
fprintf(cp_err, "Warning: can't parse '%s': ignored\n",
saves[i].name);
continue;
}
/* Now, if there's a dep variable, do we already have it? */
if (*depbuf) {
for (j = 0; j < run->numData; j++)
if (name_eq(depbuf, run->data[j].name))
break;
if (j == run->numData) {
/* Better add it. */
for (j = 0; j < numNames; j++)
if (name_eq(depbuf, dataNames[j]))
break;
if (j == numNames) {
fprintf(cp_err,
"Warning: can't find '%s': value '%s' ignored\n",
depbuf, saves[i].name);
continue;
}
addDataDesc(run, dataNames[j], dataType, j);
savesused[i] = TRUE;
saves[i].used = 1;
depind = j;
} else {
depind = run->data[j].outIndex;
}
}
addSpecialDesc(run, saves[i].name, namebuf, parambuf, depind);
}
if (numsaves) {
for (i = 0; i < numsaves; i++) {
tfree(saves[i].analysis);
tfree(saves[i].name);
}
tfree(saves);
tfree(savesused);
}
if (numNames &&
((run->numData == 1 && run->refIndex != -1) ||
(run->numData == 0 && run->refIndex == -1)))
{
fprintf(cp_err, "Error: no data saved for %s; analysis not run\n",
spice_analysis_get_description(analysisPtr->JOBtype));
return E_NOTFOUND;
}
/* Now that we have our own data structures built up, let's see what
* nutmeg wants us to do.
*/
run->writeOut = ft_getOutReq(&run->fp, &run->runPlot, &run->binary,
run->type, run->name);
if (run->writeOut) {
fileInit(run);
} else {
plotInit(run);
if (refName)
run->runPlot->pl_ndims = 1;
}
}
/* define storage for old and new data, to allow interpolation */
if (interpolated && run->circuit->CKTcurJob->JOBtype == 4) {
valueold = TMALLOC(double, run->numData);
for (i = 0; i < run->numData; i++)
valueold[i] = 0.0;
valuenew = TMALLOC(double, run->numData);
}
/* ARGSUSED */
int
CAPparam(int param, IFvalue *value, GENinstance *inst, IFvalue *select)
{
double scale;
CAPinstance *here = (CAPinstance*)inst;
NG_IGNORE(select);
if (!cp_getvar("scale", CP_REAL, &scale, 0))
scale = 1;
switch(param) {
case CAP_CAP:
here->CAPcapac = value->rValue;
if (!here->CAPmGiven)
here->CAPm = 1.0;
here->CAPcapGiven = TRUE;
break;
case CAP_IC:
here->CAPinitCond = value->rValue;
here->CAPicGiven = TRUE;
break;
case CAP_TEMP:
here->CAPtemp = value->rValue + CONSTCtoK;
here->CAPtempGiven = TRUE;
break;
case CAP_DTEMP:
here->CAPdtemp = value->rValue;
here->CAPdtempGiven = TRUE;
break;
case CAP_WIDTH:
here->CAPwidth = value->rValue * scale;
here->CAPwidthGiven = TRUE;
break;
case CAP_LENGTH:
here->CAPlength = value->rValue * scale;
here->CAPlengthGiven = TRUE;
break;
case CAP_M:
here->CAPm = value->rValue;
here->CAPmGiven = TRUE;
break;
case CAP_SCALE:
here->CAPscale = value->rValue;
here->CAPscaleGiven = TRUE;
break;
case CAP_CAP_SENS:
here->CAPsenParmNo = value->iValue;
break;
case CAP_TC1:
here->CAPtc1 = value->rValue;
here->CAPtc1Given = TRUE;
break;
case CAP_TC2:
here->CAPtc2 = value->rValue;
here->CAPtc2Given = TRUE;
break;
case CAP_BV_MAX:
here->CAPbv_max = value->rValue;
here->CAPbv_maxGiven = TRUE;
break;
default:
return(E_BADPARM);
}
return(OK);
}
int HSM2param(
int param,
IFvalue *value,
GENinstance *inst,
IFvalue *select)
{
double scale;
HSM2instance *here = (HSM2instance*)inst;
NG_IGNORE(select);
if (!cp_getvar("scale", CP_REAL, &scale))
scale = 1;
switch (param) {
case HSM2_W:
here->HSM2_w = value->rValue * scale;
here->HSM2_w_Given = TRUE;
break;
case HSM2_L:
here->HSM2_l = value->rValue * scale;
here->HSM2_l_Given = TRUE;
break;
case HSM2_AS:
here->HSM2_as = value->rValue * scale * scale;
here->HSM2_as_Given = TRUE;
break;
case HSM2_AD:
here->HSM2_ad = value->rValue * scale * scale;
here->HSM2_ad_Given = TRUE;
break;
case HSM2_PS:
here->HSM2_ps = value->rValue * scale;
here->HSM2_ps_Given = TRUE;
break;
case HSM2_PD:
here->HSM2_pd = value->rValue * scale;
here->HSM2_pd_Given = TRUE;
break;
case HSM2_NRS:
here->HSM2_nrs = value->rValue;
here->HSM2_nrs_Given = TRUE;
break;
case HSM2_NRD:
here->HSM2_nrd = value->rValue;
here->HSM2_nrd_Given = TRUE;
break;
case HSM2_TEMP:
here->HSM2_temp = value->rValue;
here->HSM2_temp_Given = TRUE;
break;
case HSM2_DTEMP:
here->HSM2_dtemp = value->rValue;
here->HSM2_dtemp_Given = TRUE;
break;
case HSM2_OFF:
here->HSM2_off = value->iValue;
break;
case HSM2_IC_VBS:
here->HSM2_icVBS = value->rValue;
here->HSM2_icVBS_Given = TRUE;
break;
case HSM2_IC_VDS:
here->HSM2_icVDS = value->rValue;
here->HSM2_icVDS_Given = TRUE;
break;
case HSM2_IC_VGS:
here->HSM2_icVGS = value->rValue;
here->HSM2_icVGS_Given = TRUE;
break;
case HSM2_IC:
switch (value->v.numValue) {
case 3:
here->HSM2_icVBS = *(value->v.vec.rVec + 2);
here->HSM2_icVBS_Given = TRUE;
case 2:
here->HSM2_icVGS = *(value->v.vec.rVec + 1);
here->HSM2_icVGS_Given = TRUE;
case 1:
here->HSM2_icVDS = *(value->v.vec.rVec);
here->HSM2_icVDS_Given = TRUE;
break;
default:
return(E_BADPARM);
}
break;
case HSM2_CORBNET:
here->HSM2_corbnet = value->iValue;
here->HSM2_corbnet_Given = TRUE;
break;
case HSM2_RBPB:
here->HSM2_rbpb = value->rValue;
here->HSM2_rbpb_Given = TRUE;
break;
case HSM2_RBPD:
here->HSM2_rbpd = value->rValue;
here->HSM2_rbpd_Given = TRUE;
break;
case HSM2_RBPS:
here->HSM2_rbps = value->rValue;
here->HSM2_rbps_Given = TRUE;
break;
case HSM2_RBDB:
here->HSM2_rbdb = value->rValue;
here->HSM2_rbdb_Given = TRUE;
break;
case HSM2_RBSB:
here->HSM2_rbsb = value->rValue;
here->HSM2_rbsb_Given = TRUE;
break;
case HSM2_CORG:
here->HSM2_corg = value->iValue;
here->HSM2_corg_Given = TRUE;
break;
/* case HSM2_RSHG: */
/* here->HSM2_rshg = value->rValue; */
/* here->HSM2_rshg_Given = TRUE; */
/* break; */
case HSM2_NGCON:
here->HSM2_ngcon = value->rValue;
here->HSM2_ngcon_Given = TRUE;
break;
case HSM2_XGW:
here->HSM2_xgw = value->rValue;
here->HSM2_xgw_Given = TRUE;
break;
case HSM2_XGL:
here->HSM2_xgl = value->rValue;
here->HSM2_xgl_Given = TRUE;
break;
case HSM2_NF:
here->HSM2_nf = value->rValue;
here->HSM2_nf_Given = TRUE;
break;
case HSM2_SA:
here->HSM2_sa = value->rValue;
here->HSM2_sa_Given = TRUE;
break;
case HSM2_SB:
here->HSM2_sb = value->rValue;
here->HSM2_sb_Given = TRUE;
break;
case HSM2_SD:
here->HSM2_sd = value->rValue;
here->HSM2_sd_Given = TRUE;
break;
case HSM2_NSUBCDFM:
here->HSM2_nsubcdfm = value->rValue;
here->HSM2_nsubcdfm_Given = TRUE;
break;
case HSM2_MPHDFM:
here->HSM2_mphdfm = value->rValue;
here->HSM2_mphdfm_Given = TRUE;
break;
case HSM2_M:
here->HSM2_m = value->rValue;
here->HSM2_m_Given = TRUE;
break;
/* WPE */
case HSM2_SCA:
here->HSM2_sca = value->rValue;
here->HSM2_sca_Given = TRUE;
break;
case HSM2_SCB:
here->HSM2_scb = value->rValue;
here->HSM2_scb_Given = TRUE;
break;
case HSM2_SCC:
here->HSM2_scc= value->rValue;
here->HSM2_scc_Given = TRUE;
break;
default:
return(E_BADPARM);
}
return(OK);
}
void
com_resume(wordlist *wl)
{
struct dbcomm *db;
int err;
/*rawfile output saj*/
bool dofile = FALSE;
char buf[BSIZE_SP];
bool ascii = AsciiRawFile;
/*end saj*/
NG_IGNORE(wl);
/*saj fix segment*/
if (!ft_curckt) {
fprintf(cp_err, "Error: there aren't any circuits loaded.\n");
return;
} else if (ft_curckt->ci_ckt == NULL) { /* Set noparse? */
fprintf(cp_err, "Error: circuit not parsed.\n");
return;
}
/*saj*/
if (ft_curckt->ci_inprogress == FALSE) {
fprintf(cp_err, "Note: run starting\n");
com_run(NULL);
return;
}
ft_curckt->ci_inprogress = TRUE;
ft_setflag = TRUE;
reset_trace();
for (db = dbs, resumption = FALSE; db; db = db->db_next)
if (db->db_type == DB_IPLOT || db->db_type == DB_IPLOTALL)
resumption = TRUE;
/*rawfile output saj*/
if (last_used_rawfile)
dofile = TRUE;
if (cp_getvar("filetype", CP_STRING, buf)) {
if (eq(buf, "binary"))
ascii = FALSE;
else if (eq(buf, "ascii"))
ascii = TRUE;
else
fprintf(cp_err,
"Warning: strange file type \"%s\" (using \"ascii\")\n", buf);
}
if (dofile) {
if (!last_used_rawfile)
rawfileFp = stdout;
#if defined(__MINGW32__) || defined(_MSC_VER)
/* ask if binary or ASCII, open file with w or wb hvogt 15.3.2000 */
else if (ascii) {
if ((rawfileFp = fopen(last_used_rawfile, "a")) == NULL) {
setvbuf(rawfileFp, rawfileBuf, _IOFBF, RAWBUF_SIZE);
perror(last_used_rawfile);
ft_setflag = FALSE;
return;
}
} else if (!ascii) {
if ((rawfileFp = fopen(last_used_rawfile, "ab")) == NULL) {
setvbuf(rawfileFp, rawfileBuf, _IOFBF, RAWBUF_SIZE);
perror(last_used_rawfile);
ft_setflag = FALSE;
return;
}
}
/*---------------------------------------------------------------------------*/
#else
else if (!(rawfileFp = fopen(last_used_rawfile, "a"))) {
setvbuf(rawfileFp, rawfileBuf, _IOFBF, RAWBUF_SIZE);
perror(last_used_rawfile);
ft_setflag = FALSE;
return;
}
#endif
rawfileBinary = !ascii;
} else {
rawfileFp = NULL;
} /* if dofile */
/*end saj*/
err = if_run(ft_curckt->ci_ckt, "resume", NULL,
ft_curckt->ci_symtab);
/*close rawfile saj*/
if (rawfileFp) {
if (ftell(rawfileFp) == 0) {
(void) fclose(rawfileFp);
(void) unlink(last_used_rawfile);
} else {
(void) fclose(rawfileFp);
}
}
/*end saj*/
if (err == 1) {
/* The circuit was interrupted somewhere. */
fprintf(cp_err, "simulation interrupted\n");
} else if (err == 2) {
fprintf(cp_err, "simulation aborted\n");
ft_curckt->ci_inprogress = FALSE;
} else {
ft_curckt->ci_inprogress = FALSE;
}
}
