ltramisc.c

linux平台下类似著名的电路板作图软件 Spice的源代码

diffs = (double *) MALLOC(sizeof(double) * (timeindex+2));
dtime = (double *) MALLOC(sizeof(double) * (timeindex+2));
*/

/* now divided differences */
	/*
    for(i=timeindex+1;i>=0;i--) {
        *(diffs+i) = (i == timeindex+1 ? firstvalue : *(valuelist + i));
    }
    for(i=timeindex+1 ; i > 0 ; i--) {
        *(dtime+i) = (i == timeindex+1? curtime: *(timelist + i)) -
			*(timelist + i - 1);
    }
    j = 2;*/ /* for the second derivative */
	/*
    while(1) {
        for(i=timeindex + 1;i > 0; i--) {
            *(diffs+i) = (*(diffs+i) - *(diffs+i-1))/ *(dtime+i);
        }
        j--; if (j <= 0) break;
        for(i=timeindex+1;i > 0;i--) {
            *(dtime+i) = *(dtime+i-1) + (i == timeindex+1? 
				curtime: *(timelist + i)) - *(timelist + i - 1);
        }
	}

	for (i = timeindex; i>=0 ; i--) {
		*(difflist+i) = *(diffs+i);
	}

returnval = *(diffs+timeindex+1);
FREE(dtime);
FREE(diffs);
*/

/* difflist[0] is going to be bad */
/*

return(returnval);
}
*/


/*
 * LTRAlteCalculate - returns sum of the absolute values of the total
 * local truncation error of the 2 equations for the LTRAline
 */

/*

double
LTRAlteCalculate(ckt,model,instance,curtime)
register CKTcircuit *ckt;
register LTRAmodel *model;
register LTRAinstance *instance;
double curtime;

{
double *h1dashTcoeffs, h1dashTfirstCoeff; 
double *h2Tcoeffs, h2TfirstCoeff; 
double *h3dashTcoeffs, h3dashTfirstCoeff; 
double *SecondDerivs, FirstSecondDeriv;
double t1, t2, t3, f1, f2, f3;
double eq1LTE=0.0, eq2LTE=0.0;
int isaved, tdover, i;

if (curtime > model->LTRAtd) {
	tdover = 1;
} else {
	tdover = 0;
}

h1dashTcoeffs = (double *) MALLOC(sizeof(double) *
	model->LTRAmodelListSize);
h2Tcoeffs = (double *) MALLOC(sizeof(double) *
	model->LTRAmodelListSize);
h3dashTcoeffs = (double *) MALLOC(sizeof(double) *
	model->LTRAmodelListSize);
SecondDerivs = (double *) MALLOC(sizeof(double) *
	model->LTRAmodelListSize);

*/

/* note that other OthVals have been set up in LTRAaccept, 
 * and
 * Values in LTRAload
 */


/*
h1dashTfirstCoeff = LTRAtCoeffSetup(h1dashTcoeffs,
	model->LTRAmodelListSize, 0.0, model->LTRAh1dashValues, 
	model->LTRAh1dashFirstVal, model->LTRAh1dashOthVals, 
	curtime, ckt->CKTtimePoints,ckt->CKTtimeIndex,
	&(model->LTRAh1dashIndex), model->LTRAlteConType);

if (tdover) {

	h2TfirstCoeff = LTRAtCoeffSetup(h2Tcoeffs,
		model->LTRAmodelListSize, model->LTRAtd,
		model->LTRAh2Values, model->LTRAh2FirstOthVal, 
		model->LTRAh2OthVals, curtime, ckt->CKTtimePoints,
		ckt->CKTtimeIndex, &(model->LTRAh2Index),
		model->LTRAlteConType);

	h3dashTfirstCoeff = LTRAtCoeffSetup(h3dashTcoeffs,
		model->LTRAmodelListSize, model->LTRAtd,
		model->LTRAh3dashValues, model->LTRAh3dashFirstOthVal, 
		model->LTRAh3dashOthVals, curtime, 
		ckt->CKTtimePoints,ckt->CKTtimeIndex, 
		&(model->LTRAh3dashIndex), model->LTRAlteConType);
*/

	/* setting up the coefficients for interpolation */
/*

	for (i = ckt->CKTtimeIndex; i>= 0; i--) {
		if (*(ckt->CKTtimePoints + i) <
			curtime - model->LTRAtd) {
			break;
			}
	}
#ifdef LTRAdebug
	if (i == ckt->CKTtimeIndex) || (i == -1) {
		printf("LTRAtrunc: mistake: cannot find delayed timepoint\n");
	}
#endif
		t1 = *(ckt->CKTtimePoints + i - 1);
		t2 = *(ckt->CKTtimePoints + i);
		t3 = *(ckt->CKTtimePoints + i + 1);

		LTRAquadInterp(curtime - model->LTRAtd,
			t1,t2,t3,&f1,&f2,&f3);
		
		isaved = i;
	}
*/

	/* interpolation coefficients set-up */

	/* LTEs for convolution with v1 */
	/* get divided differences for v1 (2nd derivative estimates) */

	/* 
	 * no need to subtract operating point values because
	 * taking differences anyway
	 */

/*
	FirstSecondDeriv = LTRAdivDiffs(SecondDerivs,instance->LTRAv1,
		*(ckt->CKTrhsOld + instance->LTRAposNode1) 
		- *(ckt->CKTrhsOld + instance->LTRAnegNode1),curtime,
		ckt->CKTtimePoints,ckt->CKTtimeIndex);

	eq1LTE += model->LTRAadmit*FABS(FirstSecondDeriv * 
		h1dashTfirstCoeff);

	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
	for (i = model->LTRAh1dashIndex; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h1dashTcoeffs+i)!=0.0)) {
		eq1LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
			*(h1dashTcoeffs+i));
			}
	}
	}

*/
	/* interpolate */
/*
	if (tdover) {

		FirstSecondDeriv = *(SecondDerivs + isaved - 1) * f1
			+ *(SecondDerivs + isaved) * f2
			+ *(SecondDerivs + isaved + 1) * f3;

		eq2LTE += model->LTRAadmit*FABS(FirstSecondDeriv * 
			h3dashTfirstCoeff);
		
	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
		for (i = model->LTRAh3dashIndex; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h3dashTcoeffs+i)!=0.0)) {
			eq2LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
				*(h3dashTcoeffs+i));
			}
		}
	}
	}
*/
	/* end LTEs for convolution with v1 */

	/* LTEs for convolution with v2 */
	/* get divided differences for v2 (2nd derivative estimates) */

/*
	FirstSecondDeriv = LTRAdivDiffs(SecondDerivs,instance->LTRAv2,
		*(ckt->CKTrhsOld + instance->LTRAposNode2) 
		- *(ckt->CKTrhsOld + instance->LTRAnegNode2),curtime,
		ckt->CKTtimePoints,ckt->CKTtimeIndex);

	eq2LTE += model->LTRAadmit*FABS(FirstSecondDeriv * 
		h1dashTfirstCoeff);

	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
	for (i = model->LTRAh1dashIndex; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h1dashTcoeffs+i)!=0.0)) {
		eq2LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
			*(h1dashTcoeffs+i));
			}
	}
	}

	if (tdover) {
*/
		/* interpolate */

/*
		FirstSecondDeriv = *(SecondDerivs + isaved - 1) * f1
			+ *(SecondDerivs + isaved) * f2
			+ *(SecondDerivs + isaved + 1) * f3;

		eq1LTE += model->LTRAadmit*FABS(FirstSecondDeriv * 
			h3dashTfirstCoeff);
		
	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
		for (i = model->LTRAh3dashIndex; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h3dashTcoeffs+i)!=0.0)) {
			eq1LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
				*(h3dashTcoeffs+i));
			}
		}
	}
	}

*/
	/* end LTEs for convolution with v2 */

	/* LTE for convolution with i1 */
	/* get divided differences for i1 (2nd derivative estimates) */

/*
	if (tdover) {
		FirstSecondDeriv = LTRAdivDiffs(SecondDerivs,instance->LTRAi1,
			*(ckt->CKTrhsOld + instance->LTRAbrEq1),curtime,
			ckt->CKTtimePoints,ckt->CKTtimeIndex);

*/
		/* interpolate */

/*
		FirstSecondDeriv = *(SecondDerivs + isaved - 1) * f1
			+ *(SecondDerivs + isaved) * f2
			+ *(SecondDerivs + isaved + 1) * f3;

		eq2LTE += FABS(FirstSecondDeriv * h2TfirstCoeff);
		
	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
		for (i = model->LTRAh2Index; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h2Tcoeffs+i)!=0.0)) {
			eq2LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
				*(h2Tcoeffs+i));
			}
		}
	}

	}
*/
	/* end LTE for convolution with i1 */

	/* LTE for convolution with i2 */
	/* get divided differences for i2 (2nd derivative estimates) */

/*
	if (tdover) {
		FirstSecondDeriv = LTRAdivDiffs(SecondDerivs,instance->LTRAi2,
			*(ckt->CKTrhsOld + instance->LTRAbrEq2),curtime,
			ckt->CKTtimePoints,ckt->CKTtimeIndex);

*/
		/* interpolate */

/*
		FirstSecondDeriv = *(SecondDerivs + isaved - 1) * f1
			+ *(SecondDerivs + isaved) * f2
			+ *(SecondDerivs + isaved + 1) * f3;

		eq1LTE += FABS(FirstSecondDeriv * h2TfirstCoeff);
		
	if (model->LTRAlteConType != LTRA_MOD_HALFCONTROL) {
		for (i = model->LTRAh2Index; i > 0; i--) {
			if ((*(SecondDerivs+i) != 0.0) && 
				(*(h2Tcoeffs+i)!=0.0)) {
			eq1LTE += model->LTRAadmit*FABS(*(SecondDerivs+i) * 
				*(h2Tcoeffs+i));
			}
		}
	}
	}

*/
	/* end LTE for convolution with i1 */

#ifdef LTRADEBUG
/*
	fprintf(stdout,"%s: LTE/input for Eq1 at time %g is: %g\n", instance->LTRAname, curtime, eq1LTE/instance->LTRAinput1);
	fprintf(stdout,"%s: LTE/input for Eq2 at time %g is: %g\n", instance->LTRAname, curtime, eq2LTE/instance->LTRAinput1);
	fprintf(stdout,"\n");
*/
#endif
	
/*
	FREE(SecondDerivs);
	FREE(h1dashTcoeffs);
	FREE(h2Tcoeffs);
	FREE(h3dashTcoeffs);

return(FABS(eq1LTE) + FABS(eq2LTE));
}
*/

/*
 * LTRAh3dashCoeffSetup sets up the coefficient list for h3dash for
 * the special case where G=0, * returns the coefficient at 
 * (current_timepoint-T)
 */

/*
double 
LTRAh3dashCoeffSetup(coefflist,listsize,T,beta,curtime,timelist,timeindex,auxindexptr)
double *coefflist, *timelist;
int listsize, timeindex;
double T, curtime, beta;
int *auxindexptr;

{
unsigned exact;
double returnval, delta1, delta2;
double dummy1, dummy2;
double lolimit1,lolimit2,hilimit1,hilimit2;
double lovalue1,lovalue2,hivalue1,hivalue2;
int i,auxindex;

*/
/* coefflist should already have been allocated to the necessary size */

/*
#ifdef LTRAdebug
if (listsize <= timeindex) {
	printf("LTRAcoeffSetup: not enough space in coefflist\n");
}
#endif


*/
/*
 * we assume a piecewise linear function, and we calculate the
 * coefficients using this assumption in the integration of the
 * function
 */

/*
if (T == 0.0) {
	auxindex = timeindex;
} else {

	if (curtime - T <= 0.0) {
		for (i =0; i<= timeindex; i++) {
			*(coefflist + i) = 0.0;
		}
		*auxindexptr = 0;
		return(0.0);
	} else {
		exact = 0;
		for (i = timeindex; i>= 0; i--) {
			if (curtime - *(timelist + i) ==  T) {
				exact =1;
				break;
			} 
			if (curtime - *(timelist + i) > T) break;
		}

#ifdef LTRADEBUG
		if ((i < 0) || ((i==0) && (exact==1)))
			printf("LTRAcoeffSetup: i <= 0: some mistake!\n");
#endif

		if (exact == 1) {
			auxindex = i-1;
		} else {
			auxindex = i;
		}
	}
}
*/
/* the first coefficient */

/*
delta1 = curtime -T - *(timelist + auxindex);
lolimit1 = T;
hilimit1 = T + delta1;
lovalue1 = 0.0;*/ /* E3dash should be consistent with this */
/*
hivalue1 = LTRArlcH3dashIntFunc(hilimit1,T,beta);
dummy1 = intlinfunc(lolimit1,hilimit1,lovalue1,
	hivalue1,lolimit1,hilimit1)/delta1;
returnval = dummy1;


*/
/* the coefficients for the rest of the timepoints */
/*
for (i=auxindex; i>0; i--) {

	delta2 = delta1;*/ /* previous delta1 */
	/*lolimit2 = lolimit1;*/ /* previous lolimit1 */
	/*hilimit2 = hilimit1;*/ /*previous hilimit1 */
	/*lovalue2 = lovalue1;*/ /* previous lovalue1 */
	/*hivalue2 = hivalue1;*/ /*previous hivalue1 */
	/*dummy2 = dummy1;*/ /* previous dummy1 */
	/*
	delta1 = *(timelist + i) - *(timelist + i - 1);
	lolimit1 = hilimit2;
	hilimit1 = curtime - *(timelist + i - 1);
	lovalue1 = hivalue2;
	hivalue1 = LTRArlcH3dashIntFunc(hilimit1,T,beta);
	dummy1 = intlinfunc(lolimit1,hilimit1,lovalue1,hivalue1,lolimit1,hilimit1)/delta1;

	*(coefflist + i) = dummy1 - dummy2;
}
*auxindexptr = auxindex;
return(returnval);
}
*/

/*
 * LTRAh1dashCoeffSetup sets up the coefficient list for h1dash in
 * the special case where G=0
 * returns the coefficient at current_timepoint
 */
 /*

double 
LTRAh1dashCoeffSetup(coefflist,listsize,beta,curtime,timelist,timeindex,auxindexptr)
double *coefflist, *timelist;
int listsize, timeindex;
double beta, curtime;
int *auxindexptr;

{
double returnval, delta1, delta2;
double dummy1, dummy2;
double lolimit1,lolimit2,hilimit1,hilimit2;
double lovalue1,lovalue2,hivalue1,hivalue2;
int i,auxindex;

*/
/* coefflist should already have been allocated to the necessary size */

/*
#ifdef LTRAdebug
if (listsize <= timeindex) {
	printf("LTRAh1dashCoeffSetup: not enough space in coefflist\n");
}
#endif



auxindex = timeindex;

*/
/* the first coefficient */
/*
delta1 = curtime - *(timelist + auxindex);
lolimit1 = 0.0;
hilimit1 = delta1;
lovalue1 = 0.0;
hivalue1 = LTRArlcH1dashTwiceIntFunc(hilimit1,beta);
dummy1 = hivalue1/delta1;
returnval = dummy1;



*/
/* the coefficients for the rest of the timepoints */

/*
for (i=auxindex; i>0; i--) {

	delta2 = delta1;*/ /* previous delta1 */
	/*lolimit2 = lolimit1;*/ /* previous lolimit1 */
	/*hilimit2 = hilimit1;*/ /*previous hilimit1 */
	/*lovalue2 = lovalue1;*/ /* previous lovalue1 */
	/*hivalue2 = hivalue1;*/ /*previous hivalue1 */
	/*dummy2 = dummy1;*/ /* previous dummy1 */
	/*
	delta1 = *(timelist + i) - *(timelist + i - 1);
	lolimit1 = hilimit2;
	hilimit1 = curtime - *(timelist + i - 1);
	lovalue1 = hivalue2;
	hivalue1 = LTRArlcH1dashTwiceIntFunc(hilimit1,beta);
	dummy1 = (hivalue1 - lovalue1)/delta1;

	*(coefflist + i) = dummy1 - dummy2;
}
*auxindexptr = auxindex;
return(returnval);
}
*/