Jspice3
ltraload.c
Go to the documentation of this file.
1 /***************************************************************************
2 JSPICE3 adaptation of Spice3f2 - Copyright (c) Stephen R. Whiteley 1992
3 Copyright 1990 Regents of the University of California. All rights reserved.
4 Authors: 1990 Jaijeet S. Roychowdhury
5  1993 Stephen R. Whiteley
6 ****************************************************************************/
7 
8 #include "spice.h"
9 #include <stdio.h>
10 #include <math.h>
11 #include "util.h"
12 #include "ltradefs.h"
13 #include "sperror.h"
14 
15 struct ltrastuff {
16  double ls_t1, ls_t2, ls_t3;
17  double ls_qf1, ls_qf2, ls_qf3;
18  double ls_lf2, ls_lf3;
21 };
22 
23 
24 #ifdef __STDC__
25 static int ltra_pred(CKTcircuit*,LTRAmodel*,LTRAinstance*,struct ltrastuff*);
26 static double ltra_interp(LTRAinstance*,struct ltrastuff*,double*);
27 static int ltra_lin_interp(double,struct ltrastuff*);
28 static int ltra_quad_interp(double,struct ltrastuff*);
29 #else
30 static int ltra_pred();
31 static double ltra_interp();
32 static int ltra_lin_interp();
33 static int ltra_quad_interp();
34 #endif
35 
36 int
37 LTRAload(inModel,ckt)
38 
39 GENmodel *inModel;
40 CKTcircuit *ckt;
41 /* load the appropriate values for the current timepoint into the
42  * sparse matrix and the right-hand-side vector
43  */
44 {
45  LTRAmodel *model = (LTRAmodel *)inModel;
46  LTRAinstance *here;
47  struct ltrastuff ls;
48  double dummy1, dummy2;
49  int i;
50 
51  /* loop through all the transmission line models */
52  for ( ; model != NULL; model = model->LTRAnextModel) {
53 
54  if (ckt->CKTmode & (MODEINITTRAN | MODEINITPRED)) {
55 
56  switch (model->LTRAspecialCase) {
57 
58  case LTRA_MOD_RLC:
59  /*
60  * set up lists of values of the functions at the
61  * necessary timepoints.
62  */
63  LTRArlcCoeffsSetup(ckt,(GENmodel*)model);
64 
65  case LTRA_MOD_LC:
66 
67  /* setting up the coefficients for interpolation */
68  if (ckt->CKTtime > model->LTRAtd) {
69  ls.ls_over = 1;
70 
71  /* serious hack - fix! */
72  dummy1 = ckt->CKTtime - model->LTRAtd;
73  for (i = ckt->CKTtimeIndex; i >= 0; i--) {
74  if (*(ckt->CKTtimePoints + i) < dummy1) {
75  break;
76  }
77  }
78 
79  if (i == ckt->CKTtimeIndex) i--;
80  ls.ls_saved = i;
81 
82  ls.ls_t2 = *(ckt->CKTtimePoints + i);
83  ls.ls_t3 = *(ckt->CKTtimePoints + i + 1);
84  /* linear interpolation */
85  (void)ltra_lin_interp(dummy1,&ls);
86 
87  ls.ls_qinterp =
88  ((model->LTRAhowToInterp ==
90  (model->LTRAhowToInterp ==
92 
93  if ((i != 0) && ls.ls_qinterp) {
94  /* quadratic interpolation */
95 
96  ls.ls_t1 = *(ckt->CKTtimePoints + i - 1);
97  (void)ltra_quad_interp(dummy1,&ls);
98  }
99  /* interpolation coefficients set-up */
100  }
101  else {
102  ls.ls_over = 0;
103  }
104  break;
105 
106  case LTRA_MOD_RC:
107  /*
108  * set up lists of values of the coefficients at the
109  * necessary timepoints.
110  */
111  LTRArcCoeffsSetup(ckt,(GENmodel*)model);
112  break;
113 
114  case LTRA_MOD_RG:
115  break;
116 
117  default:
118  return (E_BADPARM);
119  }
120  }
121 
122 
123  /* loop through all the instances of the model */
124  for (here = model->LTRAinstances; here != NULL;
125  here = here->LTRAnextInstance) {
126 
127  if ((ckt->CKTmode & MODEDC) ||
128  (model->LTRAspecialCase == LTRA_MOD_RG)) {
129 
130  switch (model->LTRAspecialCase) {
131 
132  case LTRA_MOD_RG:
133 
134  *(here->LTRAibr1Pos1Ptr) += 1.0;
135  *(here->LTRAibr1Neg1Ptr) -= 1.0;
136  *(here->LTRAibr1Pos2Ptr) -= model->LTRAcoshlrootGR;
137  *(here->LTRAibr1Neg2Ptr) += model->LTRAcoshlrootGR;
138  *(here->LTRAibr1Ibr2Ptr) +=
139  (1+ckt->CKTgmin)*model->LTRArRsLrGRorG;
140 
141  *(here->LTRAibr2Ibr2Ptr) += model->LTRAcoshlrootGR;
142  *(here->LTRAibr2Pos2Ptr) -=
143  (1+ckt->CKTgmin)*model->LTRArGsLrGRorR;
144  *(here->LTRAibr2Neg2Ptr) +=
145  (1+ckt->CKTgmin)*model->LTRArGsLrGRorR;
146  *(here->LTRAibr2Ibr1Ptr) += 1.0;
147 
148  *(here->LTRApos1Ibr1Ptr) += 1.0;
149  *(here->LTRAneg1Ibr1Ptr) -= 1.0;
150  *(here->LTRApos2Ibr2Ptr) += 1.0;
151  *(here->LTRAneg2Ibr2Ptr) -= 1.0;
152 
153  /* Somewhere else, we have fixed the matrix with zero
154  * entries so that SMPpreOrder doesn't have fits
155  */
156  break;
157 
158  case LTRA_MOD_LC:
159  case LTRA_MOD_RLC:
160  case LTRA_MOD_RC:
161 
162  /* load a simple resistor */
163 
164  *(here->LTRApos1Ibr1Ptr) += 1.0;
165  *(here->LTRAneg1Ibr1Ptr) -= 1.0;
166  *(here->LTRApos2Ibr2Ptr) += 1.0;
167  *(here->LTRAneg2Ibr2Ptr) -= 1.0;
168 
169  *(here->LTRAibr1Ibr1Ptr) += 1.0;
170  *(here->LTRAibr1Ibr2Ptr) += 1.0;
171  *(here->LTRAibr2Pos1Ptr) += 1.0;
172  *(here->LTRAibr2Pos2Ptr) -= 1.0;
173  *(here->LTRAibr2Ibr1Ptr) -=
174  model->LTRAresist*model->LTRAlength;
175  break;
176 
177  default:
178  return(E_BADPARM);
179  }
180  continue;
181  }
182 
183  /*
184  * all cases other than DC or the RG case
185  */
186 
187  /* first timepoint after zero */
188  if (ckt->CKTmode & MODEINITTRAN) {
189  if (!(ckt->CKTmode & MODEUIC)) {
190 
191  here->LTRAinitVolt1 =
192  ( *(ckt->CKTrhsOld + here->LTRAposNode1)
193  - *(ckt->CKTrhsOld + here->LTRAnegNode1) );
194  here->LTRAinitVolt2 =
195  ( *(ckt->CKTrhsOld + here->LTRAposNode2)
196  - *(ckt->CKTrhsOld + here->LTRAnegNode2) );
197  here->LTRAinitCur1 = *(ckt->CKTrhsOld + here->LTRAbrEq1);
198  here->LTRAinitCur2 = *(ckt->CKTrhsOld + here->LTRAbrEq2);
199  }
200  }
201 
202  /* matrix loading */
203  switch (model->LTRAspecialCase) {
204 
205  case LTRA_MOD_RLC:
206 
207  /* loading for convolution parts' first terms */
208 
209  dummy1 = model->LTRAadmit*model->LTRAh1dashFirstCoeff;
210  *(here->LTRAibr1Pos1Ptr) += dummy1;
211  *(here->LTRAibr1Neg1Ptr) -= dummy1;
212  *(here->LTRAibr2Pos2Ptr) += dummy1;
213  *(here->LTRAibr2Neg2Ptr) -= dummy1;
214 
215  case LTRA_MOD_LC:
216 
217  /* this section loads for the parts of the equations
218  * that resemble the lossless equations
219  */
220 
221  *(here->LTRAibr1Pos1Ptr) += model->LTRAadmit;
222  *(here->LTRAibr1Neg1Ptr) -= model->LTRAadmit;
223  *(here->LTRAibr1Ibr1Ptr) -= 1.0;
224  *(here->LTRApos1Ibr1Ptr) += 1.0;
225  *(here->LTRAneg1Ibr1Ptr) -= 1.0;
226 
227  *(here->LTRAibr2Pos2Ptr) += model->LTRAadmit;
228  *(here->LTRAibr2Neg2Ptr) -= model->LTRAadmit;
229  *(here->LTRAibr2Ibr2Ptr) -= 1.0;
230  *(here->LTRApos2Ibr2Ptr) += 1.0;
231  *(here->LTRAneg2Ibr2Ptr) -= 1.0;
232  break;
233 
234  case LTRA_MOD_RC:
235 
236  /* this section loads for the parts of the equations
237  * that have no convolution
238  */
239 
240  *(here->LTRAibr1Ibr1Ptr) -= 1.0;
241  *(here->LTRApos1Ibr1Ptr) += 1.0;
242  *(here->LTRAneg1Ibr1Ptr) -= 1.0;
243 
244  *(here->LTRAibr2Ibr2Ptr) -= 1.0;
245  *(here->LTRApos2Ibr2Ptr) += 1.0;
246  *(here->LTRAneg2Ibr2Ptr) -= 1.0;
247 
248  /* loading for convolution parts' first terms */
249 
250  dummy1 = model->LTRAh1dashFirstCoeff;
251  *(here->LTRAibr1Pos1Ptr) += dummy1;
252  *(here->LTRAibr1Neg1Ptr) -= dummy1;
253  *(here->LTRAibr2Pos2Ptr) += dummy1;
254  *(here->LTRAibr2Neg2Ptr) -= dummy1;
255 
256  dummy1 = model->LTRAh2FirstCoeff;
257  *(here->LTRAibr1Ibr2Ptr) -= dummy1;
258  *(here->LTRAibr2Ibr1Ptr) -= dummy1;
259 
260  dummy1 = model->LTRAh3dashFirstCoeff;
261  *(here->LTRAibr1Pos2Ptr) -= dummy1;
262  *(here->LTRAibr1Neg2Ptr) += dummy1;
263  *(here->LTRAibr2Pos1Ptr) -= dummy1;
264  *(here->LTRAibr2Neg1Ptr) += dummy1;
265  break;
266 
267  default:
268  return(E_BADPARM);
269  }
270 
271  /* set up LTRAinputs - to go into the RHS of the circuit
272  * equations
273  */
274 
275  if (ckt->CKTmode & (MODEINITPRED | MODEINITTRAN)) {
276  double old1 = here->LTRAinput1Old;
277  double old2 = here->LTRAinput2Old;
278  double tol, A1, A2 , rt, at;
279 
280  /* first iteration of each timepoint */
281  /* set LTRAinput1,2 */
282  i = ltra_pred(ckt,model,here,&ls);
283  if (i) return (i);
284  /*
285  if (ckt->CKTmode && MODEINITPRED && ckt->CKTtimeIndex >= 2) {
286  rt = .5;
287  at = 1e-2;
288 
289  A1 = FABS(old1);
290  A2 = FABS(here->LTRAinput1);
291  tol = rt*MAX(A1,A2) + at;
292  A1 = old1 - here->LTRAinput1;
293  if (FABS(A1) > tol) {
294  printf("%g %g\n",old1,here->LTRAinput1);
295  return (E_ITERLIM);
296  }
297  A1 = FABS(old2);
298  A2 = FABS(here->LTRAinput2);
299  tol = rt*MAX(A1,A2) + at;
300  A1 = old2 - here->LTRAinput2;
301  if (FABS(A1) > tol) {
302  printf("%g %g\n",old2,here->LTRAinput2);
303  return (E_ITERLIM);
304  }
305  }
306  */
307  /*
308  here->LTRAinput1 = 0;
309  here->LTRAinput2 = 0;
310  */
311  }
312 
313  /* load the RHS */
314  *(ckt->CKTrhs + here->LTRAbrEq1) += here->LTRAinput1;
315  *(ckt->CKTrhs + here->LTRAbrEq2) += here->LTRAinput2;
316  }
317  }
318  return (OK);
319 }
320 
321 
322 static int
323 ltra_pred(ckt,model,here,ls)
324 
325 CKTcircuit* ckt;
327 LTRAinstance *here;
328 struct ltrastuff *ls;
329 {
330  double v1d, v2d, i1d, i2d;
331  double dummy1, dummy2;
332  int i;
333 
334  here->LTRAinput1 = here->LTRAinput2 = 0.0;
335 
336  if (ls->ls_over) {
337  /* have to interpolate values */
338 
339  switch (model->LTRAspecialCase) {
340 
341  case LTRA_MOD_LC:
342  case LTRA_MOD_RLC:
343 
344  v1d = ltra_interp(here,ls,here->LTRAv1);
345  i1d = ltra_interp(here,ls,here->LTRAi1);
346  v2d = ltra_interp(here,ls,here->LTRAv2);
347  i2d = ltra_interp(here,ls,here->LTRAi2);
348  /* interpolation done */
349  break;
350 
351  case LTRA_MOD_RC:
352  break;
353 
354  default:
355  return(E_BADPARM);
356  }
357  }
358 
359  switch (model->LTRAspecialCase) {
360  case LTRA_MOD_RLC:
361 
362  /* begin convolution parts
363  *
364  * the matrix has already been loaded above
365  */
366 
367  /* convolution of h1dash with v1 and v2 */
368  dummy1 = 0.0;
369  dummy2 = 0.0;
370  for (i = ckt->CKTtimeIndex; i > 0; i--) {
371  if (*(model->LTRAh1dashCoeffs + i) != 0.0) {
372  dummy1 += *(model->LTRAh1dashCoeffs + i)*
373  (*(here->LTRAv1 + i) - here->LTRAinitVolt1);
374  dummy2 += *(model->LTRAh1dashCoeffs + i)*
375  (*(here->LTRAv2 + i) - here->LTRAinitVolt2);
376  }
377  }
378 
379  /* the initial-condition terms */
380  dummy1 += here->LTRAinitVolt1 * model->LTRAintH1dash;
381  dummy2 += here->LTRAinitVolt2 * model->LTRAintH1dash;
382  dummy1 -= here->LTRAinitVolt1 * model->LTRAh1dashFirstCoeff;
383  dummy2 -= here->LTRAinitVolt2 * model->LTRAh1dashFirstCoeff;
384 
385  here->LTRAinput1 -= dummy1*model->LTRAadmit;
386  here->LTRAinput2 -= dummy2*model->LTRAadmit;
387  /* end convolution of h1dash with v1 and v2 */
388 
389  /* convolution of h2 with i2 and i1 */
390  dummy1 = 0.0;
391  dummy2 = 0.0;
392  if (ls->ls_over) {
393 
394  dummy1 = (i2d - here->LTRAinitCur2)*
395  model->LTRAh2FirstCoeff;
396  dummy2 = (i1d - here->LTRAinitCur1)*
397  model->LTRAh2FirstCoeff;
398 
399  /* the rest of the convolution */
400  for (i = model->LTRAauxIndex; i > 0; i--) {
401 
402  if (*(model->LTRAh2Coeffs + i) != 0.0) {
403  dummy1 += *(model->LTRAh2Coeffs + i)*
404  (*(here->LTRAi2 + i) - here->LTRAinitCur2);
405  dummy2 += *(model->LTRAh2Coeffs + i)*
406  (*(here->LTRAi1 + i) - here->LTRAinitCur1);
407  }
408  }
409  }
410 
411  /* the initial-condition terms */
412  dummy1 += here->LTRAinitCur2 * model->LTRAintH2;
413  dummy2 += here->LTRAinitCur1 * model->LTRAintH2;
414 
415  here->LTRAinput1 += dummy1;
416  here->LTRAinput2 += dummy2;
417  /* end convolution of h2 with i2 and i1 */
418 
419  /* convolution of h3dash with v2 and v1 */
420  dummy1 = 0.0;
421  dummy2 = 0.0;
422  if (ls->ls_over) {
423 
424  dummy1 = (v2d - here->LTRAinitVolt2)*
425  model->LTRAh3dashFirstCoeff;
426  dummy2 = (v1d - here->LTRAinitVolt1)*
427  model->LTRAh3dashFirstCoeff;
428 
429  /* the rest of the convolution */
430  for (i = model->LTRAauxIndex; i > 0; i--) {
431  if (*(model->LTRAh3dashCoeffs + i) != 0.0) {
432  dummy1 += *(model->LTRAh3dashCoeffs + i)*
433  (*(here->LTRAv2 + i) - here->LTRAinitVolt2);
434  dummy2 += *(model->LTRAh3dashCoeffs + i)*
435  (*(here->LTRAv1 + i) - here->LTRAinitVolt1);
436  }
437  }
438  }
439 
440  /* the initial-condition terms */
441  dummy1 += here->LTRAinitVolt2 * model->LTRAintH3dash;
442  dummy2 += here->LTRAinitVolt1 * model->LTRAintH3dash;
443 
444  here->LTRAinput1 += model->LTRAadmit*dummy1;
445  here->LTRAinput2 += model->LTRAadmit*dummy2;
446  /* end convolution of h3dash with v2 and v1 */
447 
448  case LTRA_MOD_LC:
449  /* begin lossless-like parts */
450 
451  if (!ls->ls_over) {
452 
453  here->LTRAinput1 += model->LTRAattenuation*
454  (here->LTRAinitVolt2*model->LTRAadmit +
455  here->LTRAinitCur2);
456  here->LTRAinput2 += model->LTRAattenuation*
457  (here->LTRAinitVolt1*model->LTRAadmit +
458  here->LTRAinitCur1);
459  }
460  else {
461 
462  here->LTRAinput1 += model->LTRAattenuation*
463  (v2d*model->LTRAadmit + i2d);
464  here->LTRAinput2 += model->LTRAattenuation*
465  (v1d*model->LTRAadmit + i1d);
466 
467  }
468 
469  /* end lossless-like parts */
470  break;
471 
472  case LTRA_MOD_RC:
473 
474  /* begin convolution parts
475  *
476  * the matrix has already been loaded above
477  */
478 
479  /* convolution of h1dash with v1 and v2 */
480  dummy1 = 0.0;
481  dummy2 = 0.0;
482  for (i = ckt->CKTtimeIndex; i > 0; i--) {
483  if (*(model->LTRAh1dashCoeffs + i) != 0.0) {
484  dummy1 += *(model->LTRAh1dashCoeffs + i)*
485  (*(here->LTRAv1 + i) - here->LTRAinitVolt1);
486  dummy2 += *(model->LTRAh1dashCoeffs + i)*
487  (*(here->LTRAv2 + i) - here->LTRAinitVolt2);
488  }
489  }
490 
491  /* the initial condition terms */
492  dummy1 += here->LTRAinitVolt1 * model->LTRAintH1dash;
493  dummy2 += here->LTRAinitVolt2 * model->LTRAintH1dash;
494  dummy1 -= here->LTRAinitVolt1 * model->LTRAh1dashFirstCoeff;
495  dummy2 -= here->LTRAinitVolt2 * model->LTRAh1dashFirstCoeff;
496 
497  here->LTRAinput1 -= dummy1;
498  here->LTRAinput2 -= dummy2;
499  /* end convolution of h1dash with v1 and v2 */
500 
501  /* convolution of h2 with i2 and i1 */
502  dummy1 = 0.0;
503  dummy2 = 0.0;
504  for (i = ckt->CKTtimeIndex; i > 0; i--) {
505  if (*(model->LTRAh2Coeffs+ i) != 0.0) {
506  dummy1 += *(model->LTRAh2Coeffs + i)*
507  (*(here->LTRAi2 + i) - here->LTRAinitCur2);
508  dummy2 += *(model->LTRAh2Coeffs + i)*
509  (*(here->LTRAi1 + i) - here->LTRAinitCur1);
510  }
511  }
512 
513  /* the initial-condition terms */
514  dummy1 += here->LTRAinitCur2 * model->LTRAintH2;
515  dummy2 += here->LTRAinitCur1 * model->LTRAintH2;
516  dummy1 -= here->LTRAinitCur2 * model->LTRAh2FirstCoeff;
517  dummy2 -= here->LTRAinitCur1 * model->LTRAh2FirstCoeff;
518 
519  here->LTRAinput1 += dummy1;
520  here->LTRAinput2 += dummy2;
521  /* end convolution of h2 with i2 and i1 */
522 
523  /* convolution of h3dash with v2 and v1 */
524  dummy1 = 0.0;
525  dummy2 = 0.0;
526  for (i = ckt->CKTtimeIndex; i > 0; i--) {
527  if (*(model->LTRAh3dashCoeffs+ i) != 0.0) {
528  dummy1 += *(model->LTRAh3dashCoeffs + i)*
529  (*(here->LTRAv2 + i) - here->LTRAinitVolt2);
530  dummy2 += *(model->LTRAh3dashCoeffs + i)*
531  (*(here->LTRAv1 + i) - here->LTRAinitVolt1);
532  }
533  }
534 
535  /* the initial-condition terms */
536  dummy1 += here->LTRAinitVolt2 * model->LTRAintH3dash;
537  dummy2 += here->LTRAinitVolt1 * model->LTRAintH3dash;
538  dummy1 -= here->LTRAinitVolt2 * model->LTRAh3dashFirstCoeff;
539  dummy2 -= here->LTRAinitVolt1 * model->LTRAh3dashFirstCoeff;
540 
541  here->LTRAinput1 += dummy1;
542  here->LTRAinput2 += dummy2;
543  /* end convolution of h3dash with v2 and v1 */
544 
545  break;
546 
547  default:
548  return (E_BADPARM);
549  }
550  return (OK);
551 }
552 
553 
554 static double
555 ltra_interp(here,ls,ptr)
556 
557 LTRAinstance *here;
558 struct ltrastuff *ls;
559 double *ptr;
560 {
561  double ret;
562  double max, min;
563 
564  ptr += ls->ls_saved;
565  if ((ls->ls_saved != 0) && ls->ls_qinterp) {
566 
567  ret = *(ptr-1)* ls->ls_qf1
568  + *(ptr )* ls->ls_qf2
569  + *(ptr+1)* ls->ls_qf3;
570 
571  max = MAX(*(ptr-1),*(ptr));
572  max = MAX(max,*(ptr+1));
573  min = MIN(*(ptr-1),*(ptr));
574  min = MIN(min,*(ptr+1));
575 
576  if ((ret <= max) && (ret >= min))
577  return (ret);
578  }
579  ret = *(ptr) * ls->ls_lf2
580  + *(ptr+1)* ls->ls_lf3;
581 
582  return (ret);
583 }
584 
585 
586 /* linear interpolation */
587 
588 static int
590 
591 double t;
592 struct ltrastuff *ls;
593 {
594  if (ls->ls_t2 == ls->ls_t3) return (1);
595 
596  if (t == ls->ls_t2) {
597  ls->ls_lf2 = 1.0;
598  ls->ls_lf3 = 0.0;
599  return (0);
600  }
601 
602  if (t == ls->ls_t3) {
603  ls->ls_lf2 = 0.0;
604  ls->ls_lf3 = 1.0;
605  return (0);
606  }
607 
608  ls->ls_lf3 = (t - ls->ls_t2)/(ls->ls_t3 - ls->ls_t2);
609  ls->ls_lf2 = 1 - ls->ls_lf3;
610  return (0);
611 }
612 
613 
614 /* quadratic interpolation */
615 
616 static int
618 
619 double t;
620 struct ltrastuff *ls;
621 {
622  if (t == ls->ls_t1) {
623  ls->ls_qf1 = 1.0;
624  ls->ls_qf2 = 0.0;
625  ls->ls_qf3 = 0.0;
626  return (0);
627  }
628  if (t == ls->ls_t2) {
629  ls->ls_qf1 = 0.0;
630  ls->ls_qf2 = 1.0;
631  ls->ls_qf3 = 0.0;
632  return (0);
633  }
634  if (t == ls->ls_t3) {
635  ls->ls_qf1 = 0.0;
636  ls->ls_qf2 = 0.0;
637  ls->ls_qf3 = 1.0;
638  return (0);
639  }
640  if ((ls->ls_t2 - ls->ls_t1) == 0 ||
641  (ls->ls_t3 - ls->ls_t2) == 0 ||
642  (ls->ls_t1 - ls->ls_t3) == 0) return(1);
643 
644  ls->ls_qf1 = (t - ls->ls_t2)*(t - ls->ls_t3)/
645  ((ls->ls_t1 - ls->ls_t2)*(ls->ls_t1 - ls->ls_t3));
646  ls->ls_qf2 = (t - ls->ls_t1)*(t - ls->ls_t3)/
647  ((ls->ls_t2 - ls->ls_t1)*(ls->ls_t2 - ls->ls_t3));
648  ls->ls_qf3 = (t - ls->ls_t1)*(t - ls->ls_t2)/
649  ((ls->ls_t2 - ls->ls_t3)*(ls->ls_t1 - ls->ls_t3));
650  return (0);
651 }
#define LTRA_MOD_MIXEDINTERP
Definition: ltradefs.h:199
double LTRArGsLrGRorR
Definition: ltradefs.h:125
double CKTtime
Definition: cktdefs.h:77
double * LTRAibr2Ibr2Ptr
Definition: ltradefs.h:52
double LTRAinput2
Definition: ltradefs.h:32
int ls_over
Definition: ltraload.c:19
double ls_lf2
Definition: ltraload.c:18
#define MODEINITPRED
Definition: cktdefs.h:161
#define MODEDC
Definition: cktdefs.h:149
int LTRAload(GENmodel *inModel, CKTcircuit *ckt)
Definition: ltraload.c:37
double ls_t2
Definition: ltraload.c:16
double LTRAinput1Old
Definition: ltradefs.h:33
double LTRAintH2
Definition: ltradefs.h:120
#define MAX(a, b)
Definition: spdefs.h:135
double LTRAinitVolt2
Definition: ltradefs.h:37
#define MIN(a, b)
Definition: spdefs.h:136
int ls_qinterp
Definition: ltraload.c:20
#define MODEINITTRAN
Definition: cktdefs.h:160
static double ltra_interp()
static int ltra_pred()
double * LTRAibr2Neg2Ptr
Definition: ltradefs.h:56
double LTRAinput2Old
Definition: ltradefs.h:34
double * LTRAibr1Neg2Ptr
Definition: ltradefs.h:50
double LTRAintH1dash
Definition: ltradefs.h:119
double LTRAlength
Definition: ltradefs.h:110
#define LTRA_MOD_RG
Definition: ltradefs.h:163
#define E_BADPARM
Definition: iferrmsg.h:26
double ls_qf2
Definition: ltraload.c:17
int LTRAnegNode1
Definition: ltradefs.h:26
double LTRAh3dashFirstCoeff
Definition: ltradefs.h:98
struct sLTRAinstance * LTRAnextInstance
Definition: ltradefs.h:21
void LTRArlcCoeffsSetup()
double LTRAinput1
Definition: ltradefs.h:31
double * LTRAibr2Ibr1Ptr
Definition: ltradefs.h:51
double * LTRAibr2Pos2Ptr
Definition: ltradefs.h:55
double ls_t1
Definition: ltraload.c:16
int LTRAhowToInterp
Definition: ltradefs.h:149
double LTRAh2FirstCoeff
Definition: ltradefs.h:96
double ls_qf1
Definition: ltraload.c:17
#define LTRA_MOD_LC
Definition: ltradefs.h:164
double LTRArRsLrGRorG
Definition: ltradefs.h:124
double LTRAintH3dash
Definition: ltradefs.h:121
double * LTRAibr1Pos1Ptr
Definition: ltradefs.h:47
#define OK
Definition: iferrmsg.h:17
double * LTRAi2
Definition: ltradefs.h:42
double * CKTrhsOld
Definition: cktdefs.h:98
static int ltra_lin_interp()
int CKTtimeIndex
Definition: cktdefs.h:223
LTRAinstance * LTRAinstances
Definition: ltradefs.h:84
#define NULL
Definition: spdefs.h:121
double ls_qf3
Definition: ltraload.c:17
double * LTRAibr1Ibr2Ptr
Definition: ltradefs.h:46
double * LTRAv2
Definition: ltradefs.h:41
double ls_lf3
Definition: ltraload.c:18
int LTRAbrEq1
Definition: ltradefs.h:29
double * LTRAh2Coeffs
Definition: ltradefs.h:102
double * LTRAibr2Neg1Ptr
Definition: ltradefs.h:54
int LTRAposNode1
Definition: ltradefs.h:25
double ls_t3
Definition: ltraload.c:16
double * LTRAi1
Definition: ltradefs.h:40
double * LTRAneg1Ibr1Ptr
Definition: ltradefs.h:57
double * LTRAibr1Pos2Ptr
Definition: ltradefs.h:49
double * LTRAibr2Pos1Ptr
Definition: ltradefs.h:53
char * ptr
Definition: output.c:153
double LTRAinitVolt1
Definition: ltradefs.h:35
static char model[32]
Definition: subckt.c:76
double * LTRApos2Ibr2Ptr
Definition: ltradefs.h:60
int LTRAnegNode2
Definition: ltradefs.h:28
double * LTRAh3dashCoeffs
Definition: ltradefs.h:103
double * CKTtimePoints
Definition: cktdefs.h:218
double LTRAtd
Definition: ltradefs.h:111
double LTRAcoshlrootGR
Definition: ltradefs.h:123
int LTRAauxIndex
Definition: ltradefs.h:127
int ls_saved
Definition: ltraload.c:19
double LTRAadmit
Definition: ltradefs.h:113
static int ltra_quad_interp()
double LTRAinitCur1
Definition: ltradefs.h:36
void LTRArcCoeffsSetup()
#define LTRA_MOD_RLC
Definition: ltradefs.h:161
double * LTRAneg2Ibr2Ptr
Definition: ltradefs.h:58
double CKTgmin
Definition: cktdefs.h:190
struct sLTRAmodel * LTRAnextModel
Definition: ltradefs.h:82
int LTRAbrEq2
Definition: ltradefs.h:30
double LTRAinitCur2
Definition: ltradefs.h:38
double LTRAattenuation
Definition: ltradefs.h:116
double * LTRAh1dashCoeffs
Definition: ltradefs.h:101
Definition: cddefs.h:192
double * LTRAibr1Neg1Ptr
Definition: ltradefs.h:48
int LTRAposNode2
Definition: ltradefs.h:27
long CKTmode
Definition: cktdefs.h:139
double * LTRApos1Ibr1Ptr
Definition: ltradefs.h:59
#define LTRA_MOD_QUADINTERP
Definition: ltradefs.h:198
#define LTRA_MOD_RC
Definition: ltradefs.h:162
double * CKTrhs
Definition: cktdefs.h:97
#define MODEUIC
Definition: cktdefs.h:166
double * LTRAv1
Definition: ltradefs.h:39
double * LTRAibr1Ibr1Ptr
Definition: ltradefs.h:45
double LTRAh1dashFirstCoeff
Definition: ltradefs.h:94
double LTRAresist
Definition: ltradefs.h:107
int LTRAspecialCase
Definition: ltradefs.h:158