outitf.c File Reference

#include "spice.h"
#include "ftedefs.h"
#include "inpdefs.h"
#include "ftegraph.h"
#include "spfteext.h"
#include "plotext.h"
#include "iferrmsg.h"
#include "outdata.h"

Include dependency graph for outitf.c:

Go to the source code of this file.

Data Structures
struct	dataDesc
struct	runDesc
struct	mesg

Macros
#define	DOUBLE_PRECISION   15

Typedefs
typedef struct dataDesc	dataDesc
typedef struct runDesc	runDesc

Functions
static void	out_destroy ()
static int	addDataDesc ()
static int	addSpecialDesc ()
static void	addPointToFile ()
static void	addPointToPlot ()
static void	fileInit ()
static void	fileStartPoint ()
static void	fileAddRealValue ()
static void	fileAddComplexValue ()
static void	fileEndPoint ()
static void	fileEnd ()
static void	plotInit ()
static void	plotAddRealValue ()
static void	plotAddComplexValue ()
static void	plotEnd ()
static bool	parseSpecial ()
static bool	name_eq ()
static bool	getSpecial ()
static void	freeRun ()
char *	OUTcntrlInit ()
int	OUTbeginPlot (GENERIC *outdp)
static int	addDataDesc (runDesc *run, char *name, int type, int ind)
static int	addSpecialDesc (runDesc *run, char *name, char *devname, char *param, int depind)
int	OUTdata (GENERIC *plotPtr, IFvalue *refValue, IFvalue *valuePtr)
int	OUTsetDims (GENERIC *plotPtr, int *dims, int numDims)
static void	addPointToFile (runDesc *run, IFvalue *refValue, IFvalue *valuePtr)
static void	addPointToPlot (runDesc *run, IFvalue *refValue, IFvalue *valuePtr, bool inc)
int	OUTendPlot (GENERIC *plotPtr)
static void	fileInit (runDesc *run)
static void	fileStartPoint (FILE *fp, bool bin, int num)
static void	fileAddRealValue (FILE *fp, bool bin, double value)
static void	fileAddComplexValue (FILE *fp, bool bin, IFcomplex value)
static void	fileEndPoint (FILE *fp, bool bin)
static void	fileEnd (runDesc *run)
static void	plotInit (runDesc *run, double tstart, double tstop, double tstep, struct plot *plot)
static void	plotAddRealValue (dataDesc *desc, double value, bool inc)
static void	plotAddComplexValue (dataDesc *desc, IFcomplex value, bool inc)
static void	plotEnd (runDesc *run)
static bool	parseSpecial (char *name, char *dev, char *param, char *ind)
static bool	name_eq (char *n1, char *n2)
static bool	getSpecial (dataDesc *desc, runDesc *run, IFvalue *val)
static void	freeRun (runDesc *run)
int	OUTstopnow ()
int	OUTerror (int flags, char *format, IFuid *names)

Variables
bool	OUTendit
static struct sOUTcontrol	OUTcntrl
static bool	shouldstop = false
static bool	printinfo = false
static struct mesg	msgs []

Macro Definition Documentation

#define DOUBLE_PRECISION   15

Definition at line 24 of file outitf.c.

Typedef Documentation

typedef struct dataDesc dataDesc

typedef struct runDesc runDesc

Function Documentation

static int addDataDesc ( )

static

static int addDataDesc ( runDesc *  run, char *  name, int  type, int  ind  )

static

Definition at line 321 of file outitf.c.

{
    dataDesc *data;

    if (!run->numData)
        run->data = (dataDesc *) tmalloc(sizeof (dataDesc));
    else
        run->data = (dataDesc *) trealloc((char *) run->data,
                sizeof (dataDesc) * (run->numData + 1));
    data = &run->data[run->numData];
    /* so freeRun will get nice NULL pointers for the fields we don't set */
    bzero(data, sizeof(dataDesc));

    data->name = copy(name);
    data->type = type;
    data->regular = true;
    data->outIndex = ind;

    if (ind == -1) {
        /* It's the reference vector. */
        run->refIndex = run->numData;
    }

    run->numData++;

    return (OK);
}

static void addPointToFile ( )

static

static void addPointToFile ( runDesc *  run, IFvalue *  refValue, IFvalue *  valuePtr  )

static

Definition at line 471 of file outitf.c.

{
    int i;
    IFvalue val;

    fileStartPoint(run->fp, run->binary, run->pointCount);

    if (run->refIndex != -1) {
        if (run->isComplex)
            fileAddComplexValue(run->fp, run->binary, refValue->cValue);
        else
            fileAddRealValue(run->fp, run->binary, refValue->rValue);
    }

    for (i = 0; i < run->numData; i++) {
        /* we've already printed reference vec first */
        if (run->data[i].outIndex == -1) continue;

        if (run->data[i].regular) {
            if(run->data[i].type == IF_REAL)
                fileAddRealValue(run->fp, run->binary,
                    valuePtr->v.vec.rVec
                    [run->data[i].outIndex]);
            else if (run->data[i].type == IF_COMPLEX)
                fileAddComplexValue(run->fp, run->binary,
                    valuePtr->v.vec.cVec
                    [run->data[i].outIndex]);
            else
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
        else {
            /* should pre-check instance */
            if (!getSpecial(&run->data[i], run, &val))
                continue;
            if (run->data[i].type == IF_REAL)
                fileAddRealValue(run->fp, run->binary,
                    val.rValue);
            else if (run->data[i].type == IF_COMPLEX)
                fileAddComplexValue(run->fp, run->binary,
                    val.cValue);
            else
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
    }
    fileEndPoint(run->fp, run->binary);
}

static void addPointToPlot ( )

static

static void addPointToPlot ( runDesc *  run, IFvalue *  refValue, IFvalue *  valuePtr, bool  inc  )

static

Definition at line 524 of file outitf.c.

{
    int i;
    IFvalue val;

    for (i = 0; i < run->numData; i++) {
        if (run->data[i].outIndex == -1) {
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                        refValue->rValue,inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                        refValue->cValue,inc);
        }
        else if (run->data[i].regular) {
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                    valuePtr->v.vec.rVec
                    [run->data[i].outIndex],inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                    valuePtr->v.vec.cVec
                    [run->data[i].outIndex],inc);
        }
        else {
            /* should pre-check instance */
            if (!getSpecial(&run->data[i], run, &val))
                continue;
            if (run->data[i].type == IF_REAL)
                plotAddRealValue(&run->data[i],
                        val.rValue,inc);
            else if (run->data[i].type == IF_COMPLEX)
                plotAddComplexValue(&run->data[i],
                        val.cValue,inc);
            else 
                fprintf(stderr, "OUTdata: unsupported data type\n");
        }
    }
}

static int addSpecialDesc ( )

static

static int addSpecialDesc ( runDesc *  run, char *  name, char *  devname, char *  param, int  depind  )

static

Definition at line 356 of file outitf.c.

{
    dataDesc *data;
    char *unique;       /* unique char * from back-end */

    if (!run->numData)
        run->data = (dataDesc *) tmalloc(sizeof (dataDesc));
    else
        run->data = (dataDesc *) trealloc((char *) run->data,
                sizeof (dataDesc) * (run->numData + 1));
    data = &run->data[run->numData];
    /* so freeRun will get nice NULL pointers for the fields we don't set */
    bzero(data, sizeof(dataDesc));

    data->name = copy(name);

    unique = devname;
    INPinsert(&unique, (INPtables *) ft_curckt->ci_symtab);
    data->specName = unique;

    data->specParamName = copy(param);

    data->specIndex = depind;
    data->specType = -1;
    data->specFast = NULL;
    data->regular = false;

    run->numData++;

    return (OK);
}

static void fileAddComplexValue ( )

static

static void fileAddComplexValue ( FILE *  fp, bool  bin, IFcomplex  value  )

static

Definition at line 688 of file outitf.c.

{

    if (bin) {
        fwrite((char *) &value.real, sizeof (double), 1, fp);
        fwrite((char *) &value.imag, sizeof (double), 1, fp);
    }
    else {
        fprintf(fp, "\t%.*e,%.*e\n", DOUBLE_PRECISION, value.real,
            DOUBLE_PRECISION, value.imag);
    }

}

static void fileAddRealValue ( )

static

static void fileAddRealValue ( FILE *  fp, bool  bin, double  value  )

static

Definition at line 672 of file outitf.c.

{
    if (bin)
        fwrite((char *) &value, sizeof (double), 1, fp);
    else
        fprintf(fp, "\t%.*e\n", DOUBLE_PRECISION, value);
    
    return;
}

static void fileEnd ( )

static

static void fileEnd ( runDesc *  run )

static

Definition at line 721 of file outitf.c.

{
    long place;

    if (run->fp == stdout)
        return;
    fflush(run->fp);    /* For LATTICE... */
    place = ftell(run->fp);
    fseek(run->fp, run->pointPos, 0);
    fprintf(run->fp, "%d", run->pointCount);
    fseek(run->fp, place, 0);
    fflush(run->fp);

    return;
}

static void fileEndPoint ( )

static

static void fileEndPoint ( FILE *  fp, bool  bin  )

static

Definition at line 709 of file outitf.c.

{
    return;
}

static void fileInit ( )

static

static void fileInit ( runDesc *  run )

static

Definition at line 603 of file outitf.c.

{
    int i;
    char *name, buf[BSIZE_SP];
    int type;

    /* This is a hack. */
    run->isComplex = false;
    for (i = 0; i < run->numData; i++)
        if (run->data[i].type == IF_COMPLEX)
            run->isComplex = true;

    fprintf(run->fp, "Title: %s\n", run->name);
    fprintf(run->fp, "Date: %s\n", datestring());
    fprintf(run->fp, "Plotname: %s\n", run->type);
    fprintf(run->fp, "Flags: %s\n", run->isComplex ? "complex" : "real");
    fprintf(run->fp, "No. Variables: %d\n", run->numData);
    fprintf(run->fp, "No. Points: ");

    fflush(run->fp);        /* Gotta do this for LATTICE. */
    run->pointPos = ftell(run->fp);
    fprintf(run->fp, "0       \n"); /* Save 8 spaces here. */

    fprintf(run->fp, "Command: version %s\n", ft_sim->version);
    fprintf(run->fp, "Variables:\n");

    for (i = 0; i < run->numData; i++) {
        if (isdigit(*run->data[i].name)) {
      (void) sprintf(buf, "v(%s)", run->data[i].name);
          name = buf;
        }
        else {
          name = run->data[i].name;
        }
        if (substring("#branch", name))
            type = SV_CURRENT;
        else if (cieq(name, "time"))
            type = SV_TIME;
        else if (cieq(name, "frequency"))
            type = SV_FREQUENCY;
        else 
            type = SV_VOLTAGE;
        fprintf(run->fp, "\t%d\t%s\t%s\n", i, name,
                ft_typenames(type));
    }

    fprintf(run->fp, "%s:\n", run->binary ? "Binary" : "Values");

    return;
}

static void fileStartPoint ( )

static

static void fileStartPoint ( FILE *  fp, bool  bin, int  num  )

static

Definition at line 658 of file outitf.c.

{
    if (!bin)
        fprintf(fp, "%d", num - 1);

    return;
}

static void freeRun ( )

static

static void freeRun ( runDesc *  run )

static

Definition at line 1012 of file outitf.c.

{

    int i;

    for (i = 0; i < run->numData; i++) {
      txfree(run->data[i].name);
      txfree(run->data[i].specParamName);
    }
    txfree((char*)run->data);
    txfree(run->type);
    txfree(run->name);
    txfree((char*)run);

}

static bool getSpecial ( )

static

static bool getSpecial ( dataDesc *  desc, runDesc *  run, IFvalue *  val  )

static

Definition at line 975 of file outitf.c.

{
    IFvalue selector;
    struct variable *vv;

    selector.iValue = desc->specIndex;
    if (INPaName(desc->specParamName, val, run->circuit, &desc->specType,
            desc->specName, &desc->specFast, ft_sim, &desc->type,
            &selector) == OK) {
        desc->type &= (IF_REAL | IF_COMPLEX);   /* mask out other bits */
        return (true);
    }
    if (vv = if_getstat(run->circuit, &desc->name[1],
        (wordlist **)NULL)) {
            /* skip @ sign */
        desc->type = IF_REAL;
        if (vv->va_type == VT_REAL)
            val->rValue = vv->va_real;
        else if (vv->va_type == VT_NUM)
            val->rValue = vv->va_num;
        else if (vv->va_type == VT_BOOL)
            val->rValue = (vv->va_bool ? 1.0 : 0.0);
        else {
            return (false); /* not a real */
        }
        tfree(vv);
        return (true);
    }
    return (false);
}

static bool name_eq ( )

static

static bool name_eq ( char *  n1, char *  n2  )

static

Definition at line 949 of file outitf.c.

{
    char *s;

    if (!n1 || !n2)
        return (false);
    s = strchr(n1,'(');
    if (s)
        n1 = s+1;
    s = strchr(n2,'(');
    if (s)
        n2 = s+1;

    for ( ; ; n1++,n2++) {
        if ((*n1 == 0 || *n1 == ')') && (*n2 == 0 || *n2 == ')'))
            return (true);
        if (*n1 != *n2)
            break;
    }
    return (false);
}

static void out_destroy ( )

static

Definition at line 130 of file outitf.c.

{
    if (OUTcntrl.out_rundesc) {
        freeRun((runDesc*)OUTcntrl.out_rundesc);
        OUTcntrl.out_rundesc = NULL;
    }
    OUTcntrl.out_check      = false;
    OUTcntrl.out_usecurplot = false;
    OUTcntrl.out_keepplot   = false;
    OUTcntrl.out_points     = NULL;
    OUTcntrl.out_index      = 0;
    OUTcntrl.out_max        = 0;
    OUTcntrl.out_fail       = 0;
    OUTcntrl.out_evaluate   = NULL;
    OUTcntrl.out_end        = NULL;
}

int OUTbeginPlot

(

GENERIC *

outdp

)

Definition at line 149 of file outitf.c.

{
    struct sOUTdata *outd = (struct sOUTdata*)outdp;
    struct plot *plot = NULL;
    runDesc *run;
    char **saves;
    char *cktName;
    bool *savesused;
    int numsaves;
    int i, j, depind;
    char namebuf[BSIZE_SP], parambuf[BSIZE_SP], depbuf[BSIZE_SP];
    bool saveall = true;
    extern char *kw_printinfo;

    shouldstop = false;

    if (OUTcntrl.out_check) {
        OUTcntrl.out_index = 0;
    }
    if (OUTcntrl.out_usecurplot) {
        plot = plot_cur;
    }
    if (OUTcntrl.out_keepplot && OUTcntrl.out_rundesc) {
        *outd->plotPtr = (GENERIC*)OUTcntrl.out_rundesc;
        return (OK);
    }

    if (ft_curckt && ft_curckt->ci_ckt == outd->circuitPtr)
        cktName = ft_curckt->ci_name;
    else {
        /* hack for test system interface */
        if (outd->circuitPtr == NULL)
            cktName = (char*)outd->refName + (strlen(outd->refName) + 1);
        else
            cktName = "circuit name";
    }

    /* Check to see if we want to print informational data. */
    if (cp_getvar(kw_printinfo, VT_BOOL, (char *) &printinfo))
    fprintf(cp_err, "(debug printing enabled)\n");

    run = alloc(struct runDesc);
    *outd->plotPtr = (GENERIC*)run;

    /* First fill in some general stuff. */
    run->analysis = outd->analysisPtr;
    run->circuit = outd->circuitPtr;
    run->name = copy(cktName);
    run->type = copy(outd->analName);
    if (outd->numPts <= 0)
        run->numPoints = 1;
    else
        run->numPoints = outd->numPts;

    if (OUTcntrl.out_check) {
        run->numPoints = 1;
    }
    if (OUTcntrl.out_keepplot) {
        OUTcntrl.out_rundesc = (char*)run;
    }

    /* 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 = (bool *) tmalloc(sizeof (bool) * numsaves);
        saveall = false;
        for (i = 0; i < numsaves; i++)
            if (cieq(saves[i], "all")) {
                saveall = true;
                savesused[i] = true;
                break;
            }
    }

    /* Pass 0. */
    if (outd->refName) {
        addDataDesc(run, outd->refName, outd->refType, -1);
        for (i = 0; i < numsaves; i++)
            if (name_eq(saves[i], outd->refName)) {
                savesused[i] = true;
            }
    }
    else {
        run->refIndex = -1;
    }

    /* Pass 1. */
    if (numsaves && !saveall) {
        for (i = 0; i < numsaves; i++) {
            for (j = 0; j < outd->numNames; j++)
                if (name_eq(saves[i], outd->dataNames[j])) {
                    addDataDesc(run, outd->dataNames[j],
                            outd->dataType, j);
                    savesused[i] = true;
                    break;
                }
        }
    }
    else {
        for (i = 0; i < outd->numNames; i++)
            if (!outd->refName ||
                    !name_eq(outd->dataNames[i], outd->refName)) {
                addDataDesc(run, outd->dataNames[i], outd->dataType, i);
            }
    }

    /* Pass 2. */
    for (i = 0; i < numsaves; i++) {
        if (savesused[i])
            continue;
        if (!parseSpecial(saves[i], namebuf, parambuf, depbuf)) {
            if (numsaves == 1 && !saves[0])
                fprintf(cp_err, "Warning: no variables saved\n");
            else
                fprintf(cp_err, "Warning: can't parse '%s': ignored\n",
                    saves[i]);
            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 < outd->numNames; j++)
                    if (name_eq(depbuf, outd->dataNames[j]))
                        break;
                if (j == outd->numNames) {
                    fprintf(cp_err,
            "Warning: can't find '%s': value '%s' ignored\n",
                        depbuf, saves[i]);
                    continue;
                }
                addDataDesc(run, outd->dataNames[j], outd->dataType, j);
                savesused[i] = true;
                depind = j;
            }
            else
                depind = run->data[j].outIndex;
        }
        addSpecialDesc(run, saves[i], namebuf, parambuf, depind);
    }

    if (numsaves)
        txfree((char*)savesused);
    
    /* 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,outd->initValue,outd->finalValue,outd->step,plot);

    if (outd->refName && run->runPlot)
        run->runPlot->pl_ndims = 1;

    return (OK);
}

char* OUTcntrlInit

(

)

Definition at line 111 of file outitf.c.

{
    /* return the OUTcntrl structure */
    OUTcntrl.out_destroy    = out_destroy;
    OUTcntrl.out_rundesc    = NULL;
    OUTcntrl.out_check      = false;
    OUTcntrl.out_usecurplot = false;
    OUTcntrl.out_keepplot   = false;
    OUTcntrl.out_points     = NULL;
    OUTcntrl.out_index      = 0;
    OUTcntrl.out_max        = 0;
    OUTcntrl.out_fail       = 0;
    OUTcntrl.out_evaluate   = NULL;
    OUTcntrl.out_end        = NULL;
    return (char *)&OUTcntrl;
}

int OUTdata	(	GENERIC *	plotPtr,
		IFvalue *	refValue,
		IFvalue *	valuePtr
	)

Definition at line 396 of file outitf.c.

{
    runDesc *run = (runDesc *) plotPtr;

    if (OUTcntrl.out_check) {

        if (refValue->rValue < OUTcntrl.out_points[OUTcntrl.out_index])
            return (OK);

        addPointToPlot(run,refValue,valuePtr,false);
        if (OUTcntrl.out_evaluate)
            OUTcntrl.out_fail = (*OUTcntrl.out_evaluate)();
        else
            OUTcntrl.out_fail = false;

        OUTcntrl.out_index++;
        if (OUTcntrl.out_fail || OUTcntrl.out_index == OUTcntrl.out_max) {
            OUTendit = true;
        }
        return (OK);
    }

    run->pointCount++;

    if (run->writeOut) {
        addPointToFile(run,refValue,valuePtr);
    }
    else {
        addPointToPlot(run,refValue,valuePtr,true);
        gr_iplot(run->runPlot);
    }

    if (ft_bpcheck(run->runPlot, run->pointCount) == false)
        shouldstop = true;

    vec_gc();
    return (OK);
}

int OUTendPlot

(

GENERIC *

plotPtr

)

Definition at line 571 of file outitf.c.

{
    runDesc *run = (runDesc *) plotPtr;
    
    if (OUTcntrl.out_check) {
        if (OUTcntrl.out_end)
            (*OUTcntrl.out_end)();
        OUTendit = false;
        return (OK);
    }
    else if (OUTcntrl.out_keepplot) {
        return (OK);
    }

    if (run->writeOut)
        fileEnd(run);
    else {
        gr_end_iplot();
        plotEnd(run);
    }

    freeRun(run);

    return (OK);
}

int OUTerror	(	int	flags,
		char *	format,
		IFuid *	names
	)

Definition at line 1062 of file outitf.c.

{

    struct mesg *m;
    char buf[BSIZE_SP], *s, *bptr;
    int nindex = 0;

    if ((flags == ERR_INFO) && !printinfo)
        return (OK);

    for (m = msgs; m->flag; m++)
        if (flags & m->flag)
            fprintf(cp_err, "%s: ", m->string);

    for (s = format, bptr = buf; *s; s++) {
        if (*s == '%' && (s == format || *(s-1) != '%') && *(s+1) == 's') {
            strcpy(bptr, names[nindex]);
            bptr += strlen(names[nindex]);
            s++;
            nindex++;
        }
        else {
            *bptr++ = *s;
        }
    }
    *bptr = '\0';
    fprintf(cp_err, "%s\n", buf);
    fflush(cp_err);
    return (OK);
}

int OUTsetDims	(	GENERIC *	plotPtr,
		int *	dims,
		int	numDims
	)

Definition at line 441 of file outitf.c.

{
    runDesc *run = (runDesc *) plotPtr;
    struct dvec *v;
    int i, j;

    if (OUTcntrl.out_check) {
        OUTcntrl.out_index = 0;
        if (OUTcntrl.out_fail)
            OUTendit = true;
        return (OK);
    }

    if (run->writeOut)
        return (OK);

    for (i = 0; i < run->numData; i++) {
        v = run->data[i].vec;
        for (j = 0; j < numDims; j++)
            v->v_dims[j] = dims[j];
        v->v_numdims = numDims;
    }
    return (OK);
}

int OUTstopnow

(

)

Definition at line 1032 of file outitf.c.

{
    static REQUEST reqst = { checkup_option, 0 };

    if (!ft_batchmode)
        DevInput(&reqst, 0);
    if (ft_intrpt || shouldstop) {
        ft_intrpt = shouldstop = false;
        return (1);
    }
    else
        return (0);
}

static bool parseSpecial ( )

static

static bool parseSpecial ( char *  name, char *  dev, char *  param, char *  ind  )

static

Definition at line 902 of file outitf.c.

{
    char *s;

    *dev = *param = *ind = '\0';

    if (*name != '@')
        return (false);
    name++;
    
    s = dev;
    while (*name && (*name != '['))
        *s++ = *name++;
    *s = '\0';
    if (!*name)
        return (true);
    name++;

    s = param;
    while (*name && (*name != ',') && (*name != ']'))
        *s++ = *name++;
    *s = '\0';
    if (*name == ']')
        return (!name[1] ? true : false);
    else if (!*name)
        return (false);
    name++;

    s = ind;
    while (*name && (*name != ']'))
        *s++ = *name++;
    *s = '\0';
    if (*name && !name[1])
        return (true);
    else
        return (false);
}

static void plotAddComplexValue ( )

static

static void plotAddComplexValue ( dataDesc *  desc, IFcomplex  value, bool  inc  )

static

Definition at line 860 of file outitf.c.

{
    struct dvec *v = desc->vec;

    if (!inc) {
        v->v_compdata[0].cx_real = value.real;
        v->v_compdata[0].cx_imag = value.imag;
        v->v_length = 1;
        return;
    }
    if (v->v_length >= v->v_rlength) {
        v->v_compdata = (complex *) trealloc((char *) v->v_compdata,
            sizeof (complex) * (v->v_length + 1));
        v->v_rlength = v->v_length + 1;
    }
    v->v_compdata[v->v_length].cx_real = value.real;
    v->v_compdata[v->v_length].cx_imag = value.imag;
    v->v_length++;

    return;
}

static void plotAddRealValue ( )

static

static void plotAddRealValue ( dataDesc *  desc, double  value, bool  inc  )

static

Definition at line 816 of file outitf.c.

{
    struct dvec *v = desc->vec;

    if (isreal(v)) {
        if (!inc) {
            v->v_realdata[0] = value;
            v->v_length = 1;
            return;
        }
        if (v->v_length >= v->v_rlength) {
            v->v_realdata = (double *) trealloc((char *) v->v_realdata,
                sizeof (double) * (v->v_length + 1));
            v->v_rlength = v->v_length + 1;
        }
        v->v_realdata[v->v_length] = value;
    }
    else {
        /* a real parading as a VF_COMPLEX */
        if (!inc) {
            v->v_compdata[0].cx_real = value;
            v->v_compdata[0].cx_imag = (double) 0;
            v->v_length = 1;
            return;
        }
        if (v->v_length >= v->v_rlength) {
            v->v_compdata = (complex *) trealloc((char *) v->v_compdata,
                sizeof (complex) * (v->v_length + 1));
            v->v_rlength = v->v_length + 1;
        }
        v->v_compdata[v->v_length].cx_real = value;
        v->v_compdata[v->v_length].cx_imag = (double) 0;
    }
    v->v_length++;

    return;
}

static void plotEnd ( )

static

static void plotEnd ( runDesc *  run )

static

Definition at line 889 of file outitf.c.

{
    return;
}

static void plotInit ( )

static

static void plotInit ( runDesc *  run, double  tstart, double  tstop, double  tstep, struct plot *  plot  )

static

Definition at line 743 of file outitf.c.

{
    struct plot *pl;
    char buf[100];
    struct dvec *v;
    dataDesc *dd;
    int i;

    if (plot == NULL) {
        pl = plot_alloc(run->type);
        plot_new(pl);
        plot_setcur(pl->pl_typename);
    }
    else
        pl = plot;
    pl->pl_title = copy(run->name);
    pl->pl_name = copy(run->type);
    pl->pl_date = copy(datestring( ));
    pl->pl_ndims = 0;
    pl->pl_start = tstart;
    pl->pl_stop = tstop;
    pl->pl_step = tstep;
    run->runPlot = pl;

    /* This is a hack. */
    /* if any of them are complex, make them all complex */
    run->isComplex = false;
    for (i = 0; i < run->numData; i++) {
      if (run->data[i].type == IF_COMPLEX) run->isComplex = true;
    }

    for (i = 0; i < run->numData; i++) {
        dd = &run->data[i];
        v = alloc(struct dvec);
        if (isdigit(*dd->name)) {
            (void) sprintf(buf, "v(%s)", dd->name);
            v->v_name = copy(buf);
        }
        else
            v->v_name = copy(dd->name);
        if (substring("#branch", v->v_name) || eq(v->v_name,"isweep"))
            v->v_type = SV_CURRENT;
        else if (cieq(v->v_name, "time"))
            v->v_type = SV_TIME;
        else if (cieq(v->v_name, "frequency"))
            v->v_type = SV_FREQUENCY;
        else 
            v->v_type = SV_VOLTAGE;
        v->v_length = 0;
        v->v_rlength = run->numPoints;
        v->v_scale = NULL;

        if (!run->isComplex) {
            v->v_flags = VF_REAL;
            v->v_realdata = (double *) 
                tmalloc(v->v_rlength * sizeof(double));
        }
        else {
            v->v_flags = VF_COMPLEX;
            v->v_compdata = (complex *) 
                tmalloc(v->v_rlength * sizeof(complex));
        }
        vec_newperm(v);
        dd->vec = v;
    }
}

Variable Documentation

struct mesg msgs[]

static

Initial value:

= {
        { "Warning", ERR_WARNING } ,
        { "Fatal error", ERR_FATAL } ,
        { "Panic", ERR_PANIC } ,
        { "Note", ERR_INFO } ,
        { NULL, 0 }
}

struct sOUTcontrol OUTcntrl

static

Definition at line 62 of file outitf.c.

bool OUTendit

Definition at line 60 of file outitf.c.

bool printinfo = false

static

Definition at line 107 of file outitf.c.

bool shouldstop = false

static

Definition at line 106 of file outitf.c.