Jspice3
ltraacct.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 "ltradefs.h"
12 #include "sperror.h"
13 #include "util.h"
14 #include "cktext.h"
15 
16 #ifdef __STDC__
18 #else
19 static void ltra_sbrk();
20 #endif
21 
22 
23 int
24 LTRAaccept(ckt,inModel)
25 
26 CKTcircuit *ckt;
27 GENmodel *inModel;
28 {
29  LTRAmodel *model = (LTRAmodel *)inModel;
30  LTRAinstance *here;
31  int compact = 1;
32 
33  if (ckt->CKTmode & MODEINITTRAN) {
34  ckt->CKTsizeIncr = 10;
35  ckt->CKTtimeIndex = 0;
36  ckt->CKTtimeListSize = ckt->CKTfinalTime/ckt->CKTmaxStep + 0.5;
37  FREE(ckt->CKTtimePoints);
38  ckt->CKTtimePoints =
39  (double *)MALLOC(sizeof(double)*ckt->CKTtimeListSize);
40  }
41  else if (ckt->CKTmode & MODETRAN) {
42  ckt->CKTtimeIndex++;
43  if (ckt->CKTtimeIndex >= ckt->CKTtimeListSize) {
44  /* need more space */
45 
46  ckt->CKTsizeIncr = 5 + ckt->CKTtimeIndex*
47  (ckt->CKTfinalTime - ckt->CKTtime)/ckt->CKTtime;
48 
49  ckt->CKTtimeListSize += ckt->CKTsizeIncr;
50  ckt->CKTtimePoints = (double *)REALLOC((char *)
51  ckt->CKTtimePoints,sizeof(double)*ckt->CKTtimeListSize);
52  }
53  *(ckt->CKTtimePoints + ckt->CKTtimeIndex) = ckt->CKTtime;
54  }
55 
56  /* loop through all the transmission line models */
57  for ( ; model != NULL; model = model->LTRAnextModel ) {
58 
59  if (ckt->CKTmode & MODEINITTRAN) {
60 
61  model->LTRAmodelListSize = 10;
62 
63  model->LTRAh1dashCoeffs = (double *)
64  MALLOC(sizeof(double)*model->LTRAmodelListSize);
65  model->LTRAh2Coeffs = (double *)
66  MALLOC(sizeof(double)*model->LTRAmodelListSize);
67  model->LTRAh3dashCoeffs = (double *)
68  MALLOC(sizeof(double)*model->LTRAmodelListSize);
69  }
70 
71  else if (ckt->CKTtimeIndex >= model->LTRAmodelListSize) {
72  /* need more space */
73  model->LTRAmodelListSize += ckt->CKTsizeIncr;
74 
75  model->LTRAh1dashCoeffs = (double *)
76  REALLOC((char *)model->LTRAh1dashCoeffs,
77  sizeof(double)*model->LTRAmodelListSize);
78  model->LTRAh2Coeffs = (double *)
79  REALLOC((char *)model->LTRAh2Coeffs,
80  sizeof(double)*model->LTRAmodelListSize);
81  model->LTRAh3dashCoeffs = (double *)
82  REALLOC((char *)model->LTRAh3dashCoeffs,
83  sizeof(double)*model->LTRAmodelListSize);
84  }
85 
86  /* loop through all the instances of the model */
87  for (here = model->LTRAinstances; here != NULL;
88  here = here->LTRAnextInstance) {
89 
90  here->LTRAinput1Old = here->LTRAinput1;
91  here->LTRAinput2Old = here->LTRAinput2;
92 
93  if (ckt->CKTmode & MODEINITTRAN) {
94  here->LTRAinstListSize = 10;
95 
96  here->LTRAv1 = (double *)
97  MALLOC(sizeof(double)*here->LTRAinstListSize);
98  here->LTRAi1 = (double *)
99  MALLOC(sizeof(double)*here->LTRAinstListSize);
100  here->LTRAv2 = (double *)
101  MALLOC(sizeof(double)*here->LTRAinstListSize);
102  here->LTRAi2 = (double *)
103  MALLOC(sizeof(double)*here->LTRAinstListSize);
104  }
105 
106  else if (ckt->CKTtimeIndex >= here->LTRAinstListSize) {
107  /* need more space */
108  here->LTRAinstListSize += ckt->CKTsizeIncr;
109 
110  here->LTRAv1 = (double *) REALLOC((char *)
111  here->LTRAv1,sizeof(double)*(here->LTRAinstListSize));
112  here->LTRAi1 = (double *) REALLOC((char *)
113  here->LTRAi1,sizeof(double)*(here->LTRAinstListSize));
114  here->LTRAv2 = (double *) REALLOC((char *)
115  here->LTRAv2,sizeof(double)*(here->LTRAinstListSize));
116  here->LTRAi2 = (double *) REALLOC((char *)
117  here->LTRAi2,sizeof(double)*(here->LTRAinstListSize));
118  }
119 
120  *(here->LTRAv1 + ckt->CKTtimeIndex) =
121  *(ckt->CKTrhsOld + here->LTRAposNode1) -
122  *(ckt->CKTrhsOld + here->LTRAnegNode1) ;
123  *(here->LTRAv2 + ckt->CKTtimeIndex) =
124  *(ckt->CKTrhsOld + here->LTRAposNode2) -
125  *(ckt->CKTrhsOld + here->LTRAnegNode2) ;
126  *(here->LTRAi1 + ckt->CKTtimeIndex) =
127  *(ckt->CKTrhsOld + here->LTRAbrEq1) ;
128  *(here->LTRAi2 + ckt->CKTtimeIndex) =
129  *(ckt->CKTrhsOld + here->LTRAbrEq2) ;
130 
131  if (ckt->CKTtryToCompact && (ckt->CKTtimeIndex >= 2)) {
132 
133  /* figure out if the last 3 points lie on a st. line for
134  * all the terminal variables
135  */
136  double t1,t2,t3;
137 
138  t1 = *(ckt->CKTtimePoints + ckt->CKTtimeIndex - 2);
139  t2 = *(ckt->CKTtimePoints + ckt->CKTtimeIndex - 1);
140  t3 = *(ckt->CKTtimePoints + ckt->CKTtimeIndex);
141 
142  if (compact) {
143  compact = LTRAstraightLineCheck(
144  t1,*(here->LTRAv1 + ckt->CKTtimeIndex - 2),
145  t2,*(here->LTRAv1 + ckt->CKTtimeIndex - 1),
146  t3,*(here->LTRAv1 + ckt->CKTtimeIndex),
147  model->LTRAstLineReltol,model->LTRAstLineAbstol);
148  }
149  if (compact) {
150  compact = LTRAstraightLineCheck(
151  t1,*(here->LTRAv2 + ckt->CKTtimeIndex - 2),
152  t2,*(here->LTRAv2 + ckt->CKTtimeIndex - 1),
153  t3,*(here->LTRAv2 + ckt->CKTtimeIndex),
154  model->LTRAstLineReltol,model->LTRAstLineAbstol);
155  }
156  if (compact) {
157  compact = LTRAstraightLineCheck(
158  t1,*(here->LTRAi1 + ckt->CKTtimeIndex - 2),
159  t2,*(here->LTRAi1 + ckt->CKTtimeIndex - 1),
160  t3,*(here->LTRAi1 + ckt->CKTtimeIndex),
161  model->LTRAstLineReltol,model->LTRAstLineAbstol);
162  }
163  if (compact) {
164  compact = LTRAstraightLineCheck(
165  t1,*(here->LTRAi2 + ckt->CKTtimeIndex - 2),
166  t2,*(here->LTRAi2 + ckt->CKTtimeIndex - 1),
167  t3,*(here->LTRAi2 + ckt->CKTtimeIndex),
168  model->LTRAstLineReltol,model->LTRAstLineAbstol);
169  }
170  }
171 
172  /*
173  *(ckt->CKTstate0 + here->LTRAv1Tot) =
174  (*(here->LTRAv1 + ckt->CKTtimeIndex) +
175  *(here->LTRAi1 + ckt->CKTtimeIndex)*model->LTRAimped)*
176  model->LTRAattenuation;
177  *(ckt->CKTstate0 + here->LTRAv2Tot) =
178  (*(here->LTRAv2 + ckt->CKTtimeIndex) +
179  *(here->LTRAi1 + ckt->CKTtimeIndex)*model->LTRAimped)*
180  model->LTRAattenuation;
181 
182  if (ckt->CKTtimeIndex > 0) {
183  ltra_sbrk(ckt,model,here);
184  }
185  */
186  }
187  }
188  if (ckt->CKTtryToCompact && compact && (ckt->CKTtimeIndex >= 2)) {
189 
190  /* last three timepoints have variables lying on a straight
191  * line, do a compaction
192  */
193 
194  model = (LTRAmodel *)inModel;
195  for ( ; model != NULL; model = model->LTRAnextModel) {
196  for (here = model->LTRAinstances; here != NULL;
197  here = here->LTRAnextInstance) {
198 
199  *(here->LTRAv1 + ckt->CKTtimeIndex - 1) =
200  *(here->LTRAv1 + ckt->CKTtimeIndex);
201  *(here->LTRAv2 + ckt->CKTtimeIndex - 1) =
202  *(here->LTRAv2 + ckt->CKTtimeIndex);
203  *(here->LTRAi1 + ckt->CKTtimeIndex - 1) =
204  *(here->LTRAi1 + ckt->CKTtimeIndex);
205  *(here->LTRAi2 + ckt->CKTtimeIndex - 1) =
206  *(here->LTRAi2 + ckt->CKTtimeIndex);
207  }
208  }
209 
210  *(ckt->CKTtimePoints + ckt->CKTtimeIndex - 1) =
211  *(ckt->CKTtimePoints + ckt->CKTtimeIndex);
212  ckt->CKTtimeIndex--;
213 
214 #ifdef LTRADEBUG
215  fprintf(stdout,"compacted at time=%g\n",
216  *(ckt->CKTtimePoints+ckt->CKTtimeIndex));
217  fflush(stdout);
218 #endif
219 
220  }
221  return(OK);
222 }
223 
224 #define CHECK(a,b,c) (MAX(MAX(a,b),c)-MIN(MIN(a,b),c) >= \
225  FABS(50.0*(.33*ckt->CKTreltol*(a+b+c) + ckt->CKTabstol)))
226 
227 static void
228 ltra_sbrk(ckt,model,here)
229 
230 CKTcircuit *ckt;
232 LTRAinstance *here;
233 {
234  double v1, v2, v3, d1, d2;
235  double A1, A2, A3;
236 
237  v1 = *(ckt->CKTstate0 + here->LTRAv1Tot);
238  v2 = *(ckt->CKTstate1 + here->LTRAv1Tot);
239  v3 = ckt->CKTtimeIndex <= 1 ? v2 :
240  *(ckt->CKTstate2 + here->LTRAv1Tot);
241  d1 = (v1-v2)/ckt->CKTdelta;
242  d2 = (v2-v3)/ckt->CKTdeltaOld[1];
243 
244  A1 = d1 - d2;
245  A2 = FABS(d1);
246  A3 = FABS(d2);
247  if (FABS(A1) >= model->LTRAreltol*MAX(A2,A3) + model->LTRAabstol
248  && CHECK(v1,v2,v3)) {
249  (void)CKTsetBreak(ckt,
250  *(ckt->CKTtimePoints + ckt->CKTtimeIndex-1) + model->LTRAtd);
251  return;
252  }
253 
254  v1 = *(ckt->CKTstate0 + here->LTRAv2Tot);
255  v2 = *(ckt->CKTstate1 + here->LTRAv2Tot);
256  v3 = ckt->CKTtimeIndex <= 1 ? v2 :
257  *(ckt->CKTstate2 + here->LTRAv2Tot);
258  d1 = (v1-v2)/ckt->CKTdelta;
259  d2 = (v2-v3)/ckt->CKTdeltaOld[1];
260 
261  A1 = d1 - d2;
262  A2 = FABS(d1);
263  A3 = FABS(d2);
264  if (FABS(A1) >= model->LTRAreltol*MAX(A2,A3) + model->LTRAabstol
265  && CHECK(v1,v2,v3)) {
266  (void)CKTsetBreak(ckt,
267  *(ckt->CKTtimePoints + ckt->CKTtimeIndex-1) + model->LTRAtd);
268  return;
269  }
270 }
double LTRAinput2
Definition: ltradefs.h:32
#define MODETRAN
Definition: cktdefs.h:145
double LTRAinput1Old
Definition: ltradefs.h:33
#define MAX(a, b)
Definition: spdefs.h:135
#define MODEINITTRAN
Definition: cktdefs.h:160
double LTRAinput2Old
Definition: ltradefs.h:34
#define CHECK(a, b, c)
Definition: ltraacct.c:224
int LTRAnegNode1
Definition: ltradefs.h:26
struct sLTRAinstance * LTRAnextInstance
Definition: ltradefs.h:21
double LTRAinput1
Definition: ltradefs.h:31
#define FREE(ptr)
Definition: spdefs.h:436
double LTRAstLineReltol
Definition: ltradefs.h:128
int LTRAaccept(CKTcircuit *ckt, GENmodel *inModel)
Definition: ltraacct.c:24
int CKTsetBreak()
double LTRAabstol
Definition: ltradefs.h:155
int LTRAmodelListSize
Definition: ltradefs.h:104
#define OK
Definition: iferrmsg.h:17
double * LTRAi2
Definition: ltradefs.h:42
double LTRAstLineAbstol
Definition: ltradefs.h:130
#define MALLOC(x)
Definition: util.h:9
double LTRAreltol
Definition: ltradefs.h:156
LTRAinstance * LTRAinstances
Definition: ltradefs.h:84
#define NULL
Definition: spdefs.h:121
double * LTRAv2
Definition: ltradefs.h:41
int LTRAbrEq1
Definition: ltradefs.h:29
double * LTRAh2Coeffs
Definition: ltradefs.h:102
int LTRAposNode1
Definition: ltradefs.h:25
double * LTRAi1
Definition: ltradefs.h:40
static void ltra_sbrk()
int LTRAinstListSize
Definition: ltradefs.h:43
static char model[32]
Definition: subckt.c:76
#define FABS(a)
Definition: util.h:41
int LTRAnegNode2
Definition: ltradefs.h:28
double * LTRAh3dashCoeffs
Definition: ltradefs.h:103
double LTRAtd
Definition: ltradefs.h:111
#define REALLOC(ptr, type, number)
Definition: spdefs.h:434
int LTRAstraightLineCheck()
struct sLTRAmodel * LTRAnextModel
Definition: ltradefs.h:82
int LTRAbrEq2
Definition: ltradefs.h:30
double * LTRAh1dashCoeffs
Definition: ltradefs.h:101
int LTRAposNode2
Definition: ltradefs.h:27
double * LTRAv1
Definition: ltradefs.h:39