int main(int argc, char **argv)
{
POLYNOMIAL *poly;
long nPoly, iPoly, row, rows, iInput;
int iArg;
char *input, *output;
unsigned long pipeFlags;
SCANNED_ARG *scanned;
SDDS_DATASET SDDSin, SDDSout;
double *outputData ;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&scanned, argc, argv);
if (argc<3)
bomb(NULL, USAGE);
outputData = NULL;
input = output = NULL;
pipeFlags = 0;
poly = NULL;
nPoly = 0;
for (iArg=1; iArg<argc; iArg++) {
if (scanned[iArg].arg_type==OPTION) {
/* process options here */
switch (match_string(scanned[iArg].list[0], option, CLO_OPTIONS, 0)) {
case CLO_EVALUATE:
if (!(poly = SDDS_Realloc(poly, sizeof(*poly)*(nPoly+1))) ||
!(poly[nPoly].inputColumn
=SDDS_Malloc(sizeof(*(poly[nPoly].inputColumn))*5)) ||
!(poly[nPoly].powerColumn
=SDDS_Malloc(sizeof(*(poly[nPoly].powerColumn))*5)))
SDDS_Bomb("memory allocation failure");
scanned[iArg].n_items -= 1;
if (!scanItemList(&poly[nPoly].flags, scanned[iArg].list+1, &scanned[iArg].n_items, 0,
"filename", SDDS_STRING, &(poly[nPoly].filename), 1, POLY_FILE_SEEN,
"output", SDDS_STRING, &(poly[nPoly].outputColumn), 1, POLY_OUTPUT_SEEN,
"coefficients", SDDS_STRING, &(poly[nPoly].coefColumn), 1, POLY_COEF_SEEN,
"input0", SDDS_STRING, poly[nPoly].inputColumn+0, 1, POLY_IN0_SEEN,
"power0", SDDS_STRING, poly[nPoly].powerColumn+0, 1, POLY_OUT0_SEEN,
"input1", SDDS_STRING, poly[nPoly].inputColumn+1, 1, POLY_IN1_SEEN,
"power1", SDDS_STRING, poly[nPoly].powerColumn+1, 1, POLY_OUT1_SEEN,
"input2", SDDS_STRING, poly[nPoly].inputColumn+2, 1, POLY_IN2_SEEN,
"power2", SDDS_STRING, poly[nPoly].powerColumn+2, 1, POLY_OUT2_SEEN,
"input3", SDDS_STRING, poly[nPoly].inputColumn+3, 1, POLY_IN3_SEEN,
"power3", SDDS_STRING, poly[nPoly].powerColumn+3, 1, POLY_OUT3_SEEN,
"input4", SDDS_STRING, poly[nPoly].inputColumn+4, 1, POLY_IN4_SEEN,
"power4", SDDS_STRING, poly[nPoly].powerColumn+4, 1, POLY_OUT4_SEEN,
NULL) ||
!(poly[nPoly].flags&POLY_FILE_SEEN) || !(poly[nPoly].flags&POLY_OUTPUT_SEEN) ||
!(poly[nPoly].flags&POLY_COEF_SEEN) || !(poly[nPoly].flags&POLY_IN0_SEEN) ||
!(poly[nPoly].flags&POLY_OUT0_SEEN))
SDDS_Bomb("invalid -evaluate syntax");
nPoly++;
break;
case CLO_PIPE:
if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags))
SDDS_Bomb("invalid -pipe syntax");
break;
default:
fprintf(stderr, "error: unknown/ambiguous option: %s\n",
scanned[iArg].list[0]);
exit(1);
break;
}
}
else {
if (!input)
input = scanned[iArg].list[0];
else if (!output)
output = scanned[iArg].list[0];
else
SDDS_Bomb("too many filenames seen");
}
}
processFilenames("sddspoly", &input, &output, pipeFlags, 0, NULL);
if (nPoly==0)
SDDS_Bomb("give at least one -evaluate option");
if (!SDDS_InitializeInput(&SDDSin, input))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!SDDS_InitializeCopy(&SDDSout, &SDDSin, output, "w"))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (iPoly=0; iPoly<nPoly; iPoly++)
initializePolynomial(&poly[iPoly], &SDDSin, &SDDSout);
if (!SDDS_WriteLayout(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
while (SDDS_ReadPage(&SDDSin)>0) {
rows = SDDS_CountRowsOfInterest(&SDDSin);
if (!SDDS_CopyPage(&SDDSout, &SDDSin))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!(outputData = SDDS_Realloc(outputData, sizeof(*outputData)*rows)))
SDDS_Bomb("memory allocation failure");
for (iPoly=0; iPoly<nPoly; iPoly++) {
for (iInput=0; iInput<poly[iPoly].nInputs; iInput++) {
if (!(poly[iPoly].inputData[iInput]=
SDDS_GetColumnInDoubles(&SDDSin, poly[iPoly].inputColumn[iInput])))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
for (row=0; row<rows; row++) {
for (iInput=0; iInput<poly[iPoly].nInputs; iInput++)
poly[iPoly].input[iInput] = poly[iPoly].inputData[iInput][row];
outputData[row] = evaluatePoly(poly[iPoly].coef, poly[iPoly].power,
poly[iPoly].nTerms,
poly[iPoly].input, poly[iPoly].nInputs);
}
if (!SDDS_SetColumn(&SDDSout, SDDS_SET_BY_NAME,
outputData, rows, poly[iPoly].outputColumn))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_WritePage(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
free(outputData);
if (!SDDS_Terminate(&SDDSin)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
if (!SDDS_Terminate(&SDDSout)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
free_scanargs(&scanned,argc);
FreePolynormialMemory(poly,nPoly);
free(poly);
return 0;
}
void
QSS_SEQ_initialize (SIM_simulator simulate)
{
QSS_simulator simulator = (QSS_simulator) simulate->state->sim;
getTime (simulator->iTime);
int i, j, k, s, forUL;
double e, zc[4];
simulator->frw = FRW_Framework (simulator->data);
double t = simulator->time->time;
char logFile[128];
strcpy (logFile, simulator->output->name);
simulator->simulationLog = SD_SimulationLog (logFile);
// Local mappings.
QSS_data qssData = simulator->data;
QSS_time qssTime = simulator->time;
FRW_framework frw = simulator->frw;
double *q = qssData->q;
double *x = qssData->x;
const int order = qssData->order;
const int coeffs = order + 1;
#ifdef DEBUG
SD_simulationSettings settings = simulator->settings;
SD_simulationLog simulationLog = simulator->simulationLog;
#endif
QSS_model qssModel = simulator->model;
QA_quantizer quantizer;
SD_output output = simulator->output;
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "Initialize simulation\n");
}
#endif
forUL = qssData->states;
for (i = 0; i < forUL; i++)
{
qssData->lqu[i] = qssData->dQRel[i] * fabs (x[i * coeffs]);
if (qssData->lqu[i] < qssData->dQMin[i])
{
qssData->lqu[i] = qssData->dQMin[i];
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "Initial value: x[%d][0] = %g", i, x[i * coeffs]);
}
#endif
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "Initialize solver...");
}
#endif
simulator->quantizer = QA_Quantizer (qssData, qssTime);
quantizer = simulator->quantizer;
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize state derivatives...");
}
#endif
forUL = qssData->states;
for (i = 0; i < forUL; i++)
{
FRW_recomputeDerivative (frw, qssModel, qssData, qssTime, i);
QA_nextTime (quantizer,i,t,qssTime->nextStateTime,x,qssData->lqu);
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "Initial derivative: x[%d][1] = %g", i,
x[i * coeffs + 1]);
}
#endif
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize input...");
}
#endif
forUL = qssData->inputs;
for (i = 0; i < forUL; i++)
{
j = qssData->TD[i];
FRW_nextInputTime (frw, qssModel, qssData, qssTime, 0, j, i);
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize events...");
}
#endif
forUL = qssData->events;
for (i = 0; i < forUL; i++)
{
if (qssData->nZS[i])
{
int nZS = qssData->nZS[i];
e = INF;
for (j = 0; j < nZS; j++)
{
k = qssData->ZS[i][j];
if (qssData->dQMin[k] < e)
{
e = qssData->dQMin[k];
}
}
}
else
{
e = qssData->ft * qssData->params->zcHyst;
}
qssModel->events->zeroCrossing (i, q, qssData->d, qssData->alg,
qssTime->time, zc);
s = sign (zc[0]);
qssData->event[i].zcSign = s;
qssData->event[i].zcHyst = e / 10.0;
if (qssData->event[i].direction == 0 || qssData->event[i].direction == s
|| zc[0] == 0)
{
if (zc[0] == 0 && qssData->event[i].relation == 3)
{
qssModel->events->handlerPos (i, q, qssData->d, qssData->alg, t);
}
else if (zc[0] == 0 && qssData->event[i].relation == 1)
{
qssModel->events->handlerNeg (i, q, qssData->d, qssData->alg, t);
}
else if (s >= 0)
{
qssModel->events->handlerPos (i, q, qssData->d, qssData->alg, t);
}
else
{
qssModel->events->handlerNeg (i, q, qssData->d, qssData->alg, t);
}
qssModel->events->zeroCrossing (i, q, qssData->d, qssData->alg, t,
zc);
qssData->event[i].zcSign = sign (zc[0]);
int nHZ = qssData->nHZ[i];
for (k = 0; k < nHZ; k++)
{
j = qssData->HZ[i][k];
FRW_nextEventTime (frw, qssModel, qssData, qssTime, j);
}
int nHD = qssData->nHD[i];
for (k = 0; k < nHD; k++)
{
j = qssData->HD[i][k];
e = t - qssTime->tx[j];
if (e > 0)
{
int cf0 = j * coeffs;
x[cf0] = evaluatePoly (cf0, e, x, order);
}
qssTime->tx[j] = t;
FRW_recomputeDerivative (frw, qssModel, qssData, qssTime, j);
}
if (nHD)
{
QA_recomputeNextTimes (quantizer, nHD, qssData->HD[i], t,
qssTime->nextStateTime, x, qssData->lqu,
q);
}
}
FRW_nextEventTime (frw, qssModel, qssData, qssTime, i);
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize state variables time...");
}
#endif
forUL = qssData->states;
for (i = 0; i < forUL; i++)
{
QA_recomputeNextTime (quantizer, i, qssTime->time, qssTime->nextStateTime,
x, qssData->lqu, q);
}
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize output...");
}
#endif
simulator->log = OUT_Output (qssData, qssTime, output);
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
SD_print (simulationLog, "Initialize time...");
}
#endif
simulator->scheduler = SC_Scheduler (qssData, qssTime);
#ifdef DEBUG
if (settings->debug & SD_DBG_InitValues)
{
SD_print (simulationLog, "done.");
}
if (settings->debug & SD_DBG_VarChanges)
{
SD_setSimulationLogVariables(simulationLog, qssData->states, qssData->events);
}
#endif
QSS_SEQ_logMemory (simulator);
getTime (simulator->sTime);
subTime (simulator->sTime, simulator->iTime);
simulator->initTime += getTimeValue (simulator->sTime);
}
