projects / tas-yagle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial version of donated sources by Avertec, 3.4p5.
[tas-yagle.git] / distrib / sources / tas / trc / trc_capa.c
1 /****************************************************************************/
2 /* */
3 /* Chaine de CAO & VLSI Alliance */
4 /* */
5 /* Produit : TRC Version 1.01 */
6 /* Fichier : trc_hier.c */
7 /* */
8 /* (c) copyright 1997-1998 Laboratoire LIP6 equipe ASIM */
9 /* Tous droits reserves */
10 /* Support : e-mail alliance-support@asim.lip6.fr */
11 /* */
12 /* Auteur(s) : Gregoire AVOT */
13 /* */
14 /****************************************************************************/
15
16 #include "trc.h"
17
18 /* CVS informations :
19
20 Revision : $Revision: 1.29 $
21 Author : $Author: fabrice $
22 Date : $Date: 2008/03/20 16:23:04 $
23
24 */
25
26 int RCX_NB_CAPA_L0 = -1 ;
27 int RCX_NB_CAPA_L1 = -1 ;
28 int RCX_NB_CAPA_L2 = -1 ;
29 int RCX_CAPA_NOM_MIN = -1 ;
30 int RCX_CAPA_NOM_MAX = -1 ;
31 int RCX_CAPA_UP_NOM_MIN = -1 ;
32 int RCX_CAPA_UP_NOM_MAX = -1 ;
33 int RCX_CAPA_DW_NOM_MIN = -1 ;
34 int RCX_CAPA_DW_NOM_MAX = -1 ;
35 int RCX_CAPA_UP_MIN = -1 ;
36 int RCX_CAPA_UP_MAX = -1 ;
37 int RCX_CAPA_DW_MIN = -1 ;
38 int RCX_CAPA_DW_MAX = -1 ;
39 int RCX_CAPA_NOMF_MIN = -1 ;
40 int RCX_CAPA_NOMF_MAX = -1 ;
41 int RCX_CAPA_UP_NOMF_MIN = -1 ;
42 int RCX_CAPA_UP_NOMF_MAX = -1 ;
43 int RCX_CAPA_DW_NOMF_MIN = -1 ;
44 int RCX_CAPA_DW_NOMF_MAX = -1 ;
45
46 /******************************************************************************\
47
48 Renvoie la capacité associée à un locon.
49
50 slope : TRC_SLOPE_UP, TRC_SLOPE_DOWN, TRC_SLOPE_UNK.
51 type : TRC_CAPA_MIN, TRC_CAPA_NOM, TRC_CAPA_NOM_MIN,
52 TRC_CAPA_NOM_MAX, TRC_CAPA_MAX.
53 domain : TRC_HALF, TRC_END
54
55 status (peut être NULL) : indique quelle est la valeur de la capacité.
56 RCX_CAPA_OK : la capacité a été exactement trouvée.
57 RCX_CAPA_EQUIV : la capacité a été déduite.
58
59 \******************************************************************************/
60
61 RCXFLOAT rcx_getloconcapa( locon_list *locon,
62 char slope,
63 char type,
64 char domain,
65 char *status
66 )
67 {
68 float *ptspace ;
69 RCXFLOAT capa ;
70
71 ptspace = rcx_loconcapa_getspace( locon ) ;
72 if( !ptspace ) {
73 if( status )
74 *status = RCX_CAPA_EQUIV ;
75 return 0.0 ;
76 }
77 if( status ) *status = RCX_CAPA_OK ;
78
79 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
80
81 case ELP_CAPA_LEVEL0 :
82
83 switch( type ) {
84
85 case TRC_CAPA_NOM :
86 if( domain == TRC_HALF )
87 capa = ( ptspace[RCX_CAPA_NOM_MIN] + ptspace[RCX_CAPA_NOM_MAX] ) / 2.0 ;
88 else
89 capa = ( ptspace[RCX_CAPA_NOMF_MIN] + ptspace[RCX_CAPA_NOMF_MAX] ) / 2.0 ;
90 break ;
91
92 case TRC_CAPA_NOM_MIN :
93 if( domain == TRC_HALF )
94 capa = ptspace[RCX_CAPA_NOM_MIN] ;
95 else
96 capa = ptspace[RCX_CAPA_NOMF_MIN] ;
97 break ;
98
99 case TRC_CAPA_NOM_MAX :
100 if( domain == TRC_HALF )
101 capa = ptspace[RCX_CAPA_NOM_MAX] ;
102 else
103 capa = ptspace[RCX_CAPA_NOMF_MAX] ;
104 break ;
105
106 default :
107 if( domain == TRC_HALF )
108 capa = ( ptspace[RCX_CAPA_NOM_MIN] + ptspace[RCX_CAPA_NOM_MAX] ) / 2.0 ;
109 else
110 capa = ( ptspace[RCX_CAPA_NOMF_MIN] + ptspace[RCX_CAPA_NOMF_MAX] ) / 2.0 ;
111 if( status ) *status = RCX_CAPA_EQUIV ;
112 break ;
113 }
114
115 break;
116
117 case ELP_CAPA_LEVEL1 :
118
119 switch( type ) {
120
121 case TRC_CAPA_NOM :
122
123 switch( slope ) {
124
125 case TRC_SLOPE_UP :
126 if( domain == TRC_HALF )
127 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] ) / 2.0 ;
128 else
129 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] ) / 2.0 ;
130 break ;
131
132 case TRC_SLOPE_DOWN :
133 if( domain == TRC_HALF )
134 capa = ( ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 2.0 ;
135 else
136 capa = ( ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 2.0 ;
137 break ;
138
139 case TRC_SLOPE_UNK :
140 if( domain == TRC_HALF )
141 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] +
142 ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 4.0 ;
143 else
144 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] +
145 ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 4.0 ;
146 if( status ) *status = RCX_CAPA_EQUIV ;
147 break ;
148 }
149 break ;
150
151 case TRC_CAPA_NOM_MIN :
152
153 switch( slope ) {
154
155 case TRC_SLOPE_UP :
156 if( domain == TRC_HALF )
157 capa = ptspace[RCX_CAPA_UP_NOM_MIN] ;
158 else
159 capa = ptspace[RCX_CAPA_UP_NOMF_MIN] ;
160 break ;
161
162 case TRC_SLOPE_DOWN :
163 if( domain == TRC_HALF )
164 capa = ptspace[RCX_CAPA_DW_NOM_MIN] ;
165 else
166 capa = ptspace[RCX_CAPA_DW_NOMF_MIN] ;
167 break ;
168
169 case TRC_SLOPE_UNK :
170 if( domain == TRC_HALF )
171 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MIN] ) / 2.0 ;
172 else
173 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MIN] ) / 2.0 ;
174 if( status ) *status = RCX_CAPA_EQUIV ;
175 break ;
176 }
177 break ;
178
179 case TRC_CAPA_NOM_MAX :
180
181 switch( slope ) {
182
183 case TRC_SLOPE_UP :
184 if( domain == TRC_HALF )
185 capa = ptspace[RCX_CAPA_UP_NOM_MAX] ;
186 else
187 capa = ptspace[RCX_CAPA_UP_NOMF_MAX] ;
188 break ;
189
190 case TRC_SLOPE_DOWN :
191 if( domain == TRC_HALF )
192 capa = ptspace[RCX_CAPA_DW_NOM_MAX] ;
193 else
194 capa = ptspace[RCX_CAPA_DW_NOMF_MAX] ;
195 break ;
196
197 case TRC_SLOPE_UNK :
198 if( domain == TRC_HALF )
199 capa = ( ptspace[RCX_CAPA_UP_NOM_MAX] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 2.0 ;
200 else
201 capa = ( ptspace[RCX_CAPA_UP_NOMF_MAX] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 2.0 ;
202 if( status ) *status = RCX_CAPA_EQUIV ;
203 break ;
204 }
205 break ;
206
207 default :
208
209 switch( slope ) {
210
211 case TRC_SLOPE_UP :
212 if( domain == TRC_HALF )
213 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] ) / 2.0 ;
214 else
215 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] ) / 2.0 ;
216 break ;
217
218 case TRC_SLOPE_DOWN :
219 if( domain == TRC_HALF )
220 capa = ( ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 2.0 ;
221 else
222 capa = ( ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 2.0 ;
223 break ;
224
225 case TRC_SLOPE_UNK :
226 if( domain == TRC_HALF )
227 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] +
228 ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 4.0 ;
229 else
230 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] +
231 ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 4.0 ;
232 break ;
233 }
234 if( status ) *status = RCX_CAPA_EQUIV ;
235 }
236 break;
237
238 case ELP_CAPA_LEVEL2 :
239
240 switch( type ) {
241
242 case TRC_CAPA_MIN :
243
244 switch( slope ) {
245
246 case TRC_SLOPE_UP :
247 capa = ptspace[RCX_CAPA_UP_MIN];
248 break ;
249
250 case TRC_SLOPE_DOWN :
251 capa = ptspace[RCX_CAPA_DW_MIN];
252 break ;
253
254 case TRC_SLOPE_UNK :
255 capa = ( ptspace[RCX_CAPA_UP_MIN] + ptspace[RCX_CAPA_DW_MIN] ) / 2.0 ;
256 if( status ) *status = RCX_CAPA_EQUIV ;
257 break ;
258 }
259
260 break ;
261
262 case TRC_CAPA_NOM :
263
264 switch( slope ) {
265
266 case TRC_SLOPE_UP :
267 if( domain == TRC_HALF )
268 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] ) / 2.0 ;
269 else
270 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] ) / 2.0 ;
271 break ;
272
273 case TRC_SLOPE_DOWN :
274 if( domain == TRC_HALF )
275 capa = ( ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 2.0 ;
276 else
277 capa = ( ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 2.0 ;
278 break ;
279
280 case TRC_SLOPE_UNK :
281 if( domain == TRC_HALF )
282 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_UP_NOM_MAX] +
283 ptspace[RCX_CAPA_DW_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 4.0 ;
284 else
285 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_UP_NOMF_MAX] +
286 ptspace[RCX_CAPA_DW_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 4.0 ;
287 if( status ) *status = RCX_CAPA_EQUIV ;
288 break ;
289 }
290
291 break ;
292
293 case TRC_CAPA_NOM_MIN :
294
295 switch( slope ) {
296
297 case TRC_SLOPE_UP :
298 if( domain == TRC_HALF )
299 capa = ptspace[RCX_CAPA_UP_NOM_MIN] ;
300 else
301 capa = ptspace[RCX_CAPA_UP_NOMF_MIN] ;
302 break ;
303
304 case TRC_SLOPE_DOWN :
305 if( domain == TRC_HALF )
306 capa = ptspace[RCX_CAPA_DW_NOM_MIN] ;
307 else
308 capa = ptspace[RCX_CAPA_DW_NOMF_MIN] ;
309 break ;
310
311 case TRC_SLOPE_UNK :
312 if( domain == TRC_HALF )
313 capa = ( ptspace[RCX_CAPA_UP_NOM_MIN] + ptspace[RCX_CAPA_DW_NOM_MIN] ) / 2.0 ;
314 else
315 capa = ( ptspace[RCX_CAPA_UP_NOMF_MIN] + ptspace[RCX_CAPA_DW_NOMF_MIN] ) / 2.0 ;
316 if( status ) *status = RCX_CAPA_EQUIV ;
317 break ;
318 }
319
320 break ;
321
322 case TRC_CAPA_NOM_MAX :
323
324 switch( slope ) {
325
326 case TRC_SLOPE_UP :
327 if( domain == TRC_HALF )
328 capa = ptspace[RCX_CAPA_UP_NOM_MAX] ;
329 else
330 capa = ptspace[RCX_CAPA_UP_NOMF_MAX] ;
331 break ;
332
333 case TRC_SLOPE_DOWN :
334 if( domain == TRC_HALF )
335 capa = ptspace[RCX_CAPA_DW_NOM_MAX] ;
336 else
337 capa = ptspace[RCX_CAPA_DW_NOMF_MAX] ;
338 break ;
339
340 case TRC_SLOPE_UNK :
341 if( domain == TRC_HALF )
342 capa = ( ptspace[RCX_CAPA_UP_NOM_MAX] + ptspace[RCX_CAPA_DW_NOM_MAX] ) / 2.0 ;
343 else
344 capa = ( ptspace[RCX_CAPA_UP_NOMF_MAX] + ptspace[RCX_CAPA_DW_NOMF_MAX] ) / 2.0 ;
345 if( status ) *status = RCX_CAPA_EQUIV ;
346 break ;
347 }
348
349 break ;
350
351 case TRC_CAPA_MAX :
352
353 switch( slope ) {
354
355 case TRC_SLOPE_UP :
356 capa = ptspace[RCX_CAPA_UP_MAX] ;
357 break ;
358
359 case TRC_SLOPE_DOWN :
360 capa = ptspace[RCX_CAPA_DW_MAX] ;
361 break ;
362
363 case TRC_SLOPE_UNK :
364 capa = ( ptspace[RCX_CAPA_UP_MAX] + ptspace[RCX_CAPA_DW_MAX] ) / 2.0 ;
365 if( status ) *status = RCX_CAPA_EQUIV ;
366 break ;
367 }
368
369 break ;
370 }
371
372 break;
373 }
374 return capa ;
375 }
376
377 float rcx_get_all_locon_capa( losig_list *losig, char slope, char type, char domain )
378 {
379 ptype_list *ptl;
380 chain_list *scancon;
381 locon_list *locon;
382 float sumcapa=0.0;
383
384 ptl = getptype( losig->USER, LOFIGCHAIN );
385 if( ptl ) {
386 for( scancon = (chain_list*)ptl->DATA ;
387 scancon ;
388 scancon = scancon->NEXT ) {
389 locon = (locon_list*)scancon->DATA;
390 if( !rcx_isvalidlocon( locon ) )
391 continue;
392 sumcapa = sumcapa + rcx_getloconcapa( locon, slope, type, domain, NULL ) ;
393 }
394 }
395
396 return sumcapa;
397 }
398 /******************************************************************************\
399
400 Initialise la capacité sur un locon.
401 Seul l'un des deux arguments lofig ou loins doit être positionné. Il s'agit de
402 l'endroit où est stocké le tableau des capacités allouées par tat.
403
404 \******************************************************************************/
405
406 void rcx_setloconcapa_l0( lofig_list *lofig,
407 loins_list *loins,
408 locon_list *locon,
409 char domain,
410 RCXFLOAT capamin,
411 RCXFLOAT capamax
412 )
413 {
414 float *ptspace;
415
416 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL0 ) {
417 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 1 );
418 }
419
420 ptspace = rcx_loconcapa_getspace( locon );
421 if( !ptspace )
422 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
423
424 switch( domain ) {
425 case TRC_HALF :
426 ptspace[RCX_CAPA_NOM_MIN] = capamin ;
427 ptspace[RCX_CAPA_NOM_MAX] = capamax ;
428 break ;
429 case TRC_END :
430 ptspace[RCX_CAPA_NOMF_MIN] = capamin ;
431 ptspace[RCX_CAPA_NOMF_MAX] = capamax ;
432 break ;
433 case TRC_FULL :
434 ptspace[RCX_CAPA_NOM_MIN] = capamin ;
435 ptspace[RCX_CAPA_NOM_MAX] = capamax ;
436 ptspace[RCX_CAPA_NOMF_MIN] = capamin ;
437 ptspace[RCX_CAPA_NOMF_MAX] = capamax ;
438 }
439 }
440
441 void rcx_setloconcapa_l1( lofig_list *lofig,
442 loins_list *loins,
443 locon_list *locon,
444 char domain,
445 RCXFLOAT capa_up_min,
446 RCXFLOAT capa_up_max,
447 RCXFLOAT capa_dw_min,
448 RCXFLOAT capa_dw_max
449 )
450 {
451 float *ptspace;
452
453 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL1 ) {
454 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 2 );
455 }
456
457 ptspace = rcx_loconcapa_getspace( locon );
458 if( !ptspace )
459 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
460
461 switch( domain ) {
462 case TRC_HALF :
463 ptspace[RCX_CAPA_UP_NOM_MIN] = capa_up_min;
464 ptspace[RCX_CAPA_UP_NOM_MAX] = capa_up_max;
465 ptspace[RCX_CAPA_DW_NOM_MIN] = capa_dw_min;
466 ptspace[RCX_CAPA_DW_NOM_MAX] = capa_dw_max;
467 break ;
468 case TRC_END :
469 ptspace[RCX_CAPA_UP_NOMF_MIN] = capa_up_min;
470 ptspace[RCX_CAPA_UP_NOMF_MAX] = capa_up_max;
471 ptspace[RCX_CAPA_DW_NOMF_MIN] = capa_dw_min;
472 ptspace[RCX_CAPA_DW_NOMF_MAX] = capa_dw_max;
473 break ;
474 case TRC_FULL :
475 ptspace[RCX_CAPA_UP_NOM_MIN] = capa_up_min;
476 ptspace[RCX_CAPA_UP_NOM_MAX] = capa_up_max;
477 ptspace[RCX_CAPA_DW_NOM_MIN] = capa_dw_min;
478 ptspace[RCX_CAPA_DW_NOM_MAX] = capa_dw_max;
479 ptspace[RCX_CAPA_UP_NOMF_MIN] = capa_up_min;
480 ptspace[RCX_CAPA_UP_NOMF_MAX] = capa_up_max;
481 ptspace[RCX_CAPA_DW_NOMF_MIN] = capa_dw_min;
482 ptspace[RCX_CAPA_DW_NOMF_MAX] = capa_dw_max;
483 break ;
484 }
485 }
486
487 /* les capacités capa_up_min, capa_up_max, capa_dw_min, capa_dw_max sont prise en
488 compte uniquement si domain=TRC_HALF */
489 void rcx_setloconcapa_l2( lofig_list *lofig,
490 loins_list *loins,
491 locon_list *locon,
492 char domain,
493 RCXFLOAT capa_up_min,
494 RCXFLOAT capa_up_nom_min,
495 RCXFLOAT capa_up_nom_max,
496 RCXFLOAT capa_up_max,
497 RCXFLOAT capa_dw_min,
498 RCXFLOAT capa_dw_nom_min,
499 RCXFLOAT capa_dw_nom_max,
500 RCXFLOAT capa_dw_max
501 )
502 {
503 float *ptspace;
504
505 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL2 ) {
506 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 3 );
507 }
508
509 ptspace = rcx_loconcapa_getspace( locon );
510 if( !ptspace )
511 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
512
513 switch( domain ) {
514 case TRC_HALF :
515 ptspace[RCX_CAPA_UP_MIN] = capa_up_min;
516 ptspace[RCX_CAPA_UP_MAX] = capa_up_max;
517 ptspace[RCX_CAPA_DW_MIN] = capa_dw_min;
518 ptspace[RCX_CAPA_DW_MAX] = capa_dw_max;
519 ptspace[RCX_CAPA_UP_NOM_MIN] = capa_up_nom_min;
520 ptspace[RCX_CAPA_UP_NOM_MAX] = capa_up_nom_max;
521 ptspace[RCX_CAPA_DW_NOM_MIN] = capa_dw_nom_min;
522 ptspace[RCX_CAPA_DW_NOM_MAX] = capa_dw_nom_max;
523 break ;
524 case TRC_END :
525 ptspace[RCX_CAPA_UP_NOMF_MIN] = capa_up_nom_min;
526 ptspace[RCX_CAPA_UP_NOMF_MAX] = capa_up_nom_max;
527 ptspace[RCX_CAPA_DW_NOMF_MIN] = capa_dw_nom_min;
528 ptspace[RCX_CAPA_DW_NOMF_MAX] = capa_dw_nom_max;
529 break ;
530 case TRC_FULL :
531 ptspace[RCX_CAPA_UP_MIN] = capa_up_min;
532 ptspace[RCX_CAPA_UP_MAX] = capa_up_max;
533 ptspace[RCX_CAPA_DW_MIN] = capa_dw_min;
534 ptspace[RCX_CAPA_DW_MAX] = capa_dw_max;
535 ptspace[RCX_CAPA_UP_NOM_MIN] = capa_up_nom_min;
536 ptspace[RCX_CAPA_UP_NOM_MAX] = capa_up_nom_max;
537 ptspace[RCX_CAPA_DW_NOM_MIN] = capa_dw_nom_min;
538 ptspace[RCX_CAPA_DW_NOM_MAX] = capa_dw_nom_max;
539 ptspace[RCX_CAPA_UP_NOMF_MIN] = capa_up_nom_min;
540 ptspace[RCX_CAPA_UP_NOMF_MAX] = capa_up_nom_max;
541 ptspace[RCX_CAPA_DW_NOMF_MIN] = capa_dw_nom_min;
542 ptspace[RCX_CAPA_DW_NOMF_MAX] = capa_dw_nom_max;
543 break ;
544 }
545
546 }
547
548 /******************************************************************************\
549
550 Ajoute la capacité sur un locon.
551 Seul l'un des deux arguments lofig ou loins doit être positionné. Il s'agit de
552 l'endroit où est stocké le tableau des capacités allouées par tat.
553
554 \******************************************************************************/
555
556 void rcx_addloconcapa_l0( lofig_list *lofig,
557 loins_list *loins,
558 locon_list *locon,
559 char domain,
560 RCXFLOAT capamin,
561 RCXFLOAT capamax
562 )
563 {
564 float *ptspace;
565
566 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL0 ) {
567 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 4 );
568 }
569
570 ptspace = rcx_loconcapa_getspace( locon );
571 if( !ptspace )
572 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
573
574 if( domain == TRC_HALF ) {
575 if( RCX_CAPA_NOM_MIN != RCX_CAPA_NOM_MIN ) {
576 ptspace[RCX_CAPA_NOM_MIN] = ptspace[RCX_CAPA_NOM_MIN] + capamin ;
577 ptspace[RCX_CAPA_NOM_MAX] = ptspace[RCX_CAPA_NOM_MAX] + capamax ;
578 }
579 else
580 ptspace[RCX_CAPA_NOM_MIN] = ptspace[RCX_CAPA_NOM_MIN] + (capamax+capamin)/2.0 ;
581 }
582 else {
583 if( RCX_CAPA_NOMF_MIN != RCX_CAPA_NOMF_MIN ) {
584 ptspace[RCX_CAPA_NOMF_MIN] = ptspace[RCX_CAPA_NOMF_MIN] + capamin ;
585 ptspace[RCX_CAPA_NOMF_MAX] = ptspace[RCX_CAPA_NOMF_MAX] + capamax ;
586 }
587 else
588 ptspace[RCX_CAPA_NOMF_MIN] = ptspace[RCX_CAPA_NOMF_MIN] + (capamax+capamin)/2.0 ;
589 }
590 }
591
592 void rcx_addloconcapa_l1( lofig_list *lofig,
593 loins_list *loins,
594 locon_list *locon,
595 char domain,
596 RCXFLOAT capa_up_min,
597 RCXFLOAT capa_up_max,
598 RCXFLOAT capa_dw_min,
599 RCXFLOAT capa_dw_max
600 )
601 {
602 float *ptspace;
603
604 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL1 ) {
605 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 5 );
606 }
607
608 ptspace = rcx_loconcapa_getspace( locon );
609 if( !ptspace )
610 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
611
612 if( domain == TRC_HALF ) {
613 if( RCX_CAPA_UP_NOM_MIN != RCX_CAPA_UP_NOM_MAX ) {
614 ptspace[RCX_CAPA_UP_NOM_MIN] = ptspace[RCX_CAPA_UP_NOM_MIN] + capa_up_min;
615 ptspace[RCX_CAPA_UP_NOM_MAX] = ptspace[RCX_CAPA_UP_NOM_MAX] + capa_up_max;
616 ptspace[RCX_CAPA_DW_NOM_MIN] = ptspace[RCX_CAPA_DW_NOM_MIN] + capa_dw_min;
617 ptspace[RCX_CAPA_DW_NOM_MAX] = ptspace[RCX_CAPA_DW_NOM_MAX] + capa_dw_max;
618 }
619 else {
620 ptspace[RCX_CAPA_UP_NOM_MIN] = ptspace[RCX_CAPA_UP_NOM_MIN] + (capa_up_max+capa_up_min)/2.0;
621 ptspace[RCX_CAPA_DW_NOM_MIN] = ptspace[RCX_CAPA_DW_NOM_MIN] + (capa_dw_max+capa_dw_min)/2.0;
622 }
623 }
624 else {
625 if( RCX_CAPA_UP_NOMF_MIN != RCX_CAPA_UP_NOMF_MAX ) {
626 ptspace[RCX_CAPA_UP_NOMF_MIN] = ptspace[RCX_CAPA_UP_NOMF_MIN] + capa_up_min;
627 ptspace[RCX_CAPA_UP_NOMF_MAX] = ptspace[RCX_CAPA_UP_NOMF_MAX] + capa_up_max;
628 ptspace[RCX_CAPA_DW_NOMF_MIN] = ptspace[RCX_CAPA_DW_NOMF_MIN] + capa_dw_min;
629 ptspace[RCX_CAPA_DW_NOMF_MAX] = ptspace[RCX_CAPA_DW_NOMF_MAX] + capa_dw_max;
630 }
631 else {
632 ptspace[RCX_CAPA_UP_NOMF_MIN] = ptspace[RCX_CAPA_UP_NOMF_MIN] + (capa_up_max+capa_up_min)/2.0;
633 ptspace[RCX_CAPA_DW_NOMF_MIN] = ptspace[RCX_CAPA_DW_NOMF_MIN] + (capa_dw_max+capa_dw_min)/2.0;
634 }
635 }
636 }
637
638 /* les capacités capa_up_min, capa_up_max, capa_dw_min, capa_dw_max sont prise en
639 compte uniquement si domain=TRC_HALF */
640 void rcx_addloconcapa_l2( lofig_list *lofig,
641 loins_list *loins,
642 locon_list *locon,
643 char domain,
644 RCXFLOAT capa_up_min,
645 RCXFLOAT capa_up_nom_min,
646 RCXFLOAT capa_up_nom_max,
647 RCXFLOAT capa_up_max,
648 RCXFLOAT capa_dw_min,
649 RCXFLOAT capa_dw_nom_min,
650 RCXFLOAT capa_dw_nom_max,
651 RCXFLOAT capa_dw_max
652 )
653 {
654 float *ptspace;
655
656 if( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE != ELP_CAPA_LEVEL2 ) {
657 avt_errmsg( TRC_ERRMSG, "004", AVT_FATAL, 6 );
658 }
659
660 ptspace = rcx_loconcapa_getspace( locon );
661 if( !ptspace )
662 ptspace = rcx_loconcapa_addspace( lofig, loins, locon );
663
664
665 if( domain == TRC_HALF ) {
666
667 ptspace[RCX_CAPA_UP_MIN] = ptspace[RCX_CAPA_UP_MIN] + capa_up_min;
668 ptspace[RCX_CAPA_UP_MAX] = ptspace[RCX_CAPA_UP_MAX] + capa_up_max;
669 ptspace[RCX_CAPA_DW_MIN] = ptspace[RCX_CAPA_DW_MIN] + capa_dw_min;
670 ptspace[RCX_CAPA_DW_MAX] = ptspace[RCX_CAPA_DW_MAX] + capa_dw_max;
671
672 if( RCX_CAPA_UP_NOM_MIN != RCX_CAPA_UP_NOM_MAX ) {
673 ptspace[RCX_CAPA_UP_NOM_MIN] = ptspace[RCX_CAPA_UP_NOM_MIN] + capa_up_nom_min;
674 ptspace[RCX_CAPA_UP_NOM_MAX] = ptspace[RCX_CAPA_UP_NOM_MAX] + capa_up_nom_max;
675 ptspace[RCX_CAPA_DW_NOM_MIN] = ptspace[RCX_CAPA_DW_NOM_MIN] + capa_dw_nom_min;
676 ptspace[RCX_CAPA_DW_NOM_MAX] = ptspace[RCX_CAPA_DW_NOM_MAX] + capa_dw_nom_max;
677 }
678 else {
679 ptspace[RCX_CAPA_UP_NOM_MIN] = ptspace[RCX_CAPA_UP_NOM_MIN] + (capa_up_nom_min+capa_up_nom_max)/2.0;
680 ptspace[RCX_CAPA_DW_NOM_MIN] = ptspace[RCX_CAPA_DW_NOM_MIN] + (capa_dw_nom_min+capa_dw_nom_max)/2.0;
681 }
682 }
683 else {
684 if( RCX_CAPA_UP_NOMF_MIN != RCX_CAPA_UP_NOMF_MAX ) {
685 ptspace[RCX_CAPA_UP_NOMF_MIN] = ptspace[RCX_CAPA_UP_NOMF_MIN] + capa_up_nom_min;
686 ptspace[RCX_CAPA_UP_NOMF_MAX] = ptspace[RCX_CAPA_UP_NOMF_MAX] + capa_up_nom_max;
687 ptspace[RCX_CAPA_DW_NOMF_MIN] = ptspace[RCX_CAPA_DW_NOMF_MIN] + capa_dw_nom_min;
688 ptspace[RCX_CAPA_DW_NOMF_MAX] = ptspace[RCX_CAPA_DW_NOMF_MAX] + capa_dw_nom_max;
689 }
690 else {
691 ptspace[RCX_CAPA_UP_NOMF_MIN] = ptspace[RCX_CAPA_UP_NOMF_MIN] + (capa_up_nom_min+capa_up_nom_max)/2.0;
692 ptspace[RCX_CAPA_DW_NOMF_MIN] = ptspace[RCX_CAPA_DW_NOMF_MIN] + (capa_dw_nom_min+capa_dw_nom_max)/2.0;
693 }
694 }
695 }
696
697 /******************************************************************************\
698
699 Ajoute les capacités de loconb dans celles de locona.
700
701 \******************************************************************************/
702
703 void rcx_add_capa_locon( lofig_list *lofig,
704 locon_list *locona,
705 locon_list *loconb
706 )
707 {
708 char domain[] = { TRC_HALF, TRC_END } ;
709 unsigned int i;
710
711 for( i=0 ; i<sizeof(domain)/sizeof(domain[0]) ; i++ ) {
712 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
713 case ELP_CAPA_LEVEL0 :
714 rcx_addloconcapa_l0( lofig,
715 NULL,
716 locona,
717 domain[i],
718 rcx_getloconcapa( loconb,
719 TRC_SLOPE_UNK,
720 TRC_CAPA_NOM_MIN,
721 domain[i],
722 NULL
723 ),
724 rcx_getloconcapa( loconb,
725 TRC_SLOPE_UNK,
726 TRC_CAPA_NOM_MAX,
727 domain[i],
728 NULL
729 )
730 );
731 break ;
732 case ELP_CAPA_LEVEL1 :
733 rcx_addloconcapa_l1( lofig,
734 NULL,
735 locona,
736 domain[i],
737 rcx_getloconcapa( loconb,
738 TRC_SLOPE_UP,
739 TRC_CAPA_NOM_MIN,
740 domain[i],
741 NULL
742 ),
743 rcx_getloconcapa( loconb,
744 TRC_SLOPE_UP,
745 TRC_CAPA_NOM_MAX,
746 domain[i],
747 NULL
748 ),
749 rcx_getloconcapa( loconb,
750 TRC_SLOPE_DOWN,
751 TRC_CAPA_NOM_MIN,
752 domain[i],
753 NULL
754 ),
755 rcx_getloconcapa( loconb,
756 TRC_SLOPE_DOWN,
757 TRC_CAPA_NOM_MAX,
758 domain[i],
759 NULL
760 )
761 );
762 break ;
763 case ELP_CAPA_LEVEL2 :
764 rcx_addloconcapa_l2( lofig,
765 NULL,
766 locona,
767 domain[i],
768 rcx_getloconcapa( loconb,
769 TRC_SLOPE_UP,
770 TRC_CAPA_MIN,
771 domain[i],
772 NULL
773 ),
774 rcx_getloconcapa( loconb,
775 TRC_SLOPE_UP,
776 TRC_CAPA_NOM_MIN,
777 domain[i],
778 NULL
779 ),
780 rcx_getloconcapa( loconb,
781 TRC_SLOPE_UP,
782 TRC_CAPA_NOM_MAX,
783 domain[i],
784 NULL
785 ),
786 rcx_getloconcapa( loconb,
787 TRC_SLOPE_UP,
788 TRC_CAPA_MAX,
789 domain[i],
790 NULL
791 ),
792 rcx_getloconcapa( loconb,
793 TRC_SLOPE_DOWN,
794 TRC_CAPA_MIN,
795 domain[i],
796 NULL
797 ),
798 rcx_getloconcapa( loconb,
799 TRC_SLOPE_DOWN,
800 TRC_CAPA_NOM_MIN,
801 domain[i],
802 NULL
803 ),
804 rcx_getloconcapa( loconb,
805 TRC_SLOPE_DOWN,
806 TRC_CAPA_NOM_MAX,
807 domain[i],
808 NULL
809 ),
810 rcx_getloconcapa( loconb,
811 TRC_SLOPE_DOWN,
812 TRC_CAPA_MAX,
813 domain[i],
814 NULL
815 )
816 );
817 break ;
818 }
819 }
820 }
821
822 /******************************************************************************\
823
824 Efface une capacité associée à un locon.
825
826 \******************************************************************************/
827
828 void rcx_freeloconcapa( lofig_list *lofig,
829 loins_list *loins,
830 locon_list *locon
831 )
832 {
833 if( rcx_loconcapa_freespace( lofig, loins, locon ) )
834 locon->USER = delptype( locon->USER, RCX_LOCONCAPA_SPACE );
835 }
836
837 /******************************************************************************\
838
839 Ajoute un emplacement pour stocker une capacité sur un locon.
840 Seul l'un des deux arguments lofig ou loins doit être positionné. Il s'agit de
841 l'endroit où est stocké le tableau des capacités allouées par tat.
842
843 \******************************************************************************/
844
845 float* rcx_loconcapa_addspace( lofig_list *lofig,
846 loins_list *loins,
847 locon_list *locon
848 )
849 {
850 HeapAlloc *heap;
851 float *space;
852 int n, i;
853
854 heap = rcx_loconcapa_giveheap( lofig, loins );
855 space = AddHeapItem( heap );
856
857 locon->USER = addptype( locon->USER, RCX_LOCONCAPA_SPACE, space );
858 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
859 case ELP_CAPA_LEVEL0 : n = RCX_NB_CAPA_L0 ; break ;
860 case ELP_CAPA_LEVEL1 : n = RCX_NB_CAPA_L1 ; break ;
861 case ELP_CAPA_LEVEL2 : n = RCX_NB_CAPA_L2 ; break ;
862 }
863
864 for( i=0 ; i < n ; i++ )
865 space[i] = 0.0 ;
866
867 return space;
868 }
869
870 /******************************************************************************\
871
872 Renvoie l'emplacement pour stocker une capacité sur un locon, ou NULL si cet
873 emplacement n'a jamais été créé par rcx_loconcapa_addspace().
874
875 \******************************************************************************/
876
877 float* rcx_loconcapa_getspace( locon_list *locon )
878 {
879 ptype_list *ptl;
880
881 ptl = getptype( locon->USER, RCX_LOCONCAPA_SPACE );
882 if( !ptl ) return NULL;
883 return (float*)ptl->DATA;
884 }
885
886 /******************************************************************************\
887
888 Libère l'emplacement pour stocker une capacité.
889
890 \******************************************************************************/
891
892 char rcx_loconcapa_freespace( lofig_list *lofig,
893 loins_list *loins,
894 locon_list *locon )
895 {
896 ptype_list *ptl;
897 HeapAlloc *heap;
898 float *space;
899
900 ptl = getptype( locon->USER, RCX_LOCONCAPA_SPACE );
901 if( !ptl ) return 0;
902 space = (float*)ptl->DATA;
903
904 heap = rcx_loconcapa_giveheap( lofig, loins );
905 DelHeapItem( heap, space );
906
907 return 1;
908 }
909
910 /******************************************************************************\
911
912 Renvoie un HeapAlloc associé soit à une lofig, soit à une loins.
913
914 \******************************************************************************/
915
916 HeapAlloc* rcx_loconcapa_giveheap( lofig_list *lofig, loins_list *loins )
917 {
918 HeapAlloc *heap;
919 ptype_list *ptl;
920 int n;
921
922 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
923 case ELP_CAPA_LEVEL0 : n = RCX_NB_CAPA_L0 * sizeof( float ) ; break ;
924 case ELP_CAPA_LEVEL1 : n = RCX_NB_CAPA_L1 * sizeof( float ) ; break ;
925 case ELP_CAPA_LEVEL2 : n = RCX_NB_CAPA_L2 * sizeof( float ) ; break ;
926 default :
927 rcx_error(44,NULL,AVT_FATAL);
928 }
929
930 if( lofig ) {
931 ptl = getptype( lofig->USER, RCX_LOCONCAPA_HEAP );
932 if( !ptl ) {
933 heap = mbkalloc( sizeof( HeapAlloc ) );
934 CreateHeap( n, 4096, heap );
935 lofig->USER = addptype( lofig->USER, RCX_LOCONCAPA_HEAP, heap );
936 }
937 else {
938 heap = (HeapAlloc*)ptl->DATA;
939 }
940 }
941 else {
942 ptl = getptype( loins->USER, RCX_LOCONCAPA_HEAP );
943 if( !ptl ) {
944 heap = mbkalloc( sizeof( HeapAlloc ) );
945 CreateHeap( n, 32, heap );
946 loins->USER = addptype( loins->USER, RCX_LOCONCAPA_HEAP, heap );
947 }
948 else {
949 heap = (HeapAlloc*)ptl->DATA;
950 }
951 }
952
953 return heap;
954 }
955
956 /******************************************************************************\
957
958 Libère le HeapAlloc
959
960 \******************************************************************************/
961
962 void rcx_loconcapa_freeheap( lofig_list *lofig, loins_list *loins )
963 {
964 HeapAlloc *heap;
965 ptype_list *ptl;
966
967 if( lofig )
968 ptl = getptype( lofig->USER, RCX_LOCONCAPA_HEAP );
969 if( loins )
970 ptl = getptype( loins->USER, RCX_LOCONCAPA_HEAP );
971
972 if( ptl ) {
973 heap = (HeapAlloc*)ptl->DATA;
974 DeleteHeap( heap );
975 if( lofig )
976 lofig->USER = delptype( lofig->USER, RCX_LOCONCAPA_HEAP );
977 if( loins )
978 loins->USER = delptype( loins->USER, RCX_LOCONCAPA_HEAP );
979 mbkfree( heap );
980 }
981 }
982
983 /******************************************************************************\
984
985
986
987 \******************************************************************************/
988
989 RCXFLOAT rcx_getnodecapa( losig_list *ptsig,
990 lonode_list *node,
991 RCXFLOAT extcapa,
992 rcx_slope *slope,
993 char type,
994 char domain,
995 RCXFLOAT coefctc
996 )
997 {
998 RCXFLOAT capa=0.0, c ;
999 loctc_list *ctc ;
1000 lowire_list *lowire ;
1001 chain_list *chain ;
1002 num_list *sc;
1003 int nb;
1004 locon_list *ptlocon;
1005 float capalocon;
1006 rcx_list *ptrcx;
1007 char capatype;
1008
1009 ptrcx = getrcx( ptsig );
1010
1011 // Capacité due aux capacités couplées.
1012 c = 0.0 ;
1013 for( chain = node->CTCLIST ; chain ; chain = chain->NEXT ) {
1014 ctc = (loctc_list*)chain->DATA;
1015 c = c + rcx_capamiller( ptsig, ctc, slope, type );
1016 }
1017 capa = capa + c;
1018
1019 // Capacité due aux fils.
1020 c = 0.0 ;
1021 for( chain = node->WIRELIST ; chain ; chain = chain->NEXT ) {
1022 lowire = (lowire_list*)(chain->DATA);
1023 c = c + lowire->CAPA/2.0 ;
1024 }
1025 capa = capa + c;
1026
1027 // Capacité due aux connecteurs.
1028 c = 0.0 ;
1029 for( chain = getloconnode( node ) ; chain ; chain = chain->NEXT ) {
1030
1031 ptlocon = (locon_list*)chain->DATA ;
1032 if( !rcx_isvalidlocon( ptlocon ) )
1033 continue;
1034
1035 nb=0;
1036
1037 if( type == RCX_MIN )
1038 capatype = TRC_CAPA_NOM_MIN ;
1039 else
1040 capatype = TRC_CAPA_NOM_MAX ;
1041 capalocon = rcx_getloconcapa( ptlocon, slope->SENS, capatype, domain, NULL );
1042
1043 if( capalocon > 0.0 ) {
1044 for( sc = ptlocon->PNODE, nb=0 ; sc ; sc=sc->NEXT, nb++ );
1045 c = c + capalocon / nb ;
1046 }
1047
1048 if( rcx_isloconexternal( ptlocon ) ) {
1049 if( nb == 0 )
1050 for( sc = ptlocon->PNODE, nb=0 ; sc ; sc=sc->NEXT, nb++ );
1051
1052 c = c + extcapa / nb ;
1053 }
1054 }
1055 capa = capa + c ;
1056
1057 // Application du correctif pour les capacités de couplage globales.
1058
1059 capa = capa * coefctc ;
1060
1061 // Redimensionnement des capacités
1062
1063 capa = capa * tlc_getcapafactor();
1064
1065 return(capa);
1066 }
1067
1068 /******************************************************************************\
1069
1070 Récupère différents type de capacité :
1071
1072 capatype : flag
1073 RCX_SIGCAPA_GROUND : Renvoie les capacités à la masse.
1074 RCX_SIGCAPA_CTK : Renvoie les capacités de couplage.
1075 capapos : flag
1076 RCX_SIGCAPA_LOCAL : Prend en compte les capacités localisées.
1077 RCX_SIGCAPA_GLOBAL : Prend en compte les capacités globales.
1078 capadyna : valeur
1079 RCX_SIGCAPA_NORM : CTC à leurs valeurs nominales.
1080 RCX_SIGCAPA_MILLER : Modifie la valeurs des CTC avec l'effet Miller.
1081 RCX_SIGCAPA_DELTA : Calcule la VARIATION de capacité due à l'effet Miller.
1082
1083 slope : utilisé seulement si capadyna différent de RCX_SIGCAPA_NORM.
1084 type : RCX_MIN | RCX_MAX. utilisé seulement si capadyna différent de
1085 RCX_SIGCAPA_NORM.
1086
1087 \******************************************************************************/
1088
1089 RCXFLOAT rcx_getsigcapa( lofig_list *lofig,
1090 losig_list *ptsig,
1091 char capatype,
1092 char capapos,
1093 char capadyna,
1094 rcx_slope *slope,
1095 char type,
1096 char domain
1097 )
1098 {
1099 RCXFLOAT sumcapa = 0.0 ;
1100 RCXFLOAT capa;
1101 long node;
1102 char thiscapatype;
1103 char thiscapapos;
1104 chain_list *scanctc;
1105 loctc_list *ctc;
1106 lowire_list *scanwire;
1107 char hasglobal = 'N';
1108 rcx_list *ptrcx=NULL;
1109 ptype_list *ptl;
1110 locon_list *locon;
1111 chain_list *scancon;
1112 char slopetype;
1113 char ctype;
1114
1115 ptrcx = getrcx( ptsig );
1116
1117 if( capapos == RCX_SIGCAPA_GLOBAL ) {
1118 if( GETFLAG( ptrcx->FLAG, RCXHASNOGCTC ) )
1119 return 0.0;
1120 }
1121
1122 if( lofig )
1123 rcn_lock_signal( lofig, ptsig );
1124
1125 if( ( capatype & RCX_SIGCAPA_GROUND ) == RCX_SIGCAPA_GROUND &&
1126 ( capapos & RCX_SIGCAPA_LOCAL ) == RCX_SIGCAPA_LOCAL &&
1127 ( capadyna == RCX_SIGCAPA_NORM || capadyna == RCX_SIGCAPA_MILLER )
1128 ) {
1129 ptl = getptype( ptsig->USER, LOFIGCHAIN );
1130 if( ptl ) {
1131 for( scancon = (chain_list*)ptl->DATA ;
1132 scancon ;
1133 scancon = scancon->NEXT ) {
1134 locon = (locon_list*)scancon->DATA;
1135 if( !rcx_isvalidlocon( locon ) )
1136 continue;
1137 if ( !slope )
1138 slopetype = TRC_SLOPE_UNK;
1139 else
1140 slopetype = slope->SENS;
1141 if( type == RCX_MIN )
1142 ctype = TRC_CAPA_NOM_MIN ;
1143 else
1144 ctype = TRC_CAPA_NOM_MAX ;
1145 capa = rcx_getloconcapa( locon, slopetype, ctype, domain, NULL );
1146 sumcapa = sumcapa + capa ;
1147 }
1148 }
1149 }
1150
1151 for( scanctc = ptsig->PRCN->PCTC ; scanctc ;scanctc = scanctc->NEXT ) {
1152
1153 ctc = (loctc_list*)scanctc->DATA;
1154
1155 node = rcn_ctcnode( ctc, ptsig );
1156
1157 thiscapatype = 0;
1158 thiscapapos = 0;
1159
1160 if( rcx_iscrosstalkcapa( ctc, ptsig ) )
1161 thiscapatype = thiscapatype | RCX_SIGCAPA_CTK ;
1162 else
1163 thiscapatype = thiscapatype | RCX_SIGCAPA_GROUND ;
1164
1165 if( node )
1166 thiscapapos = thiscapapos | RCX_SIGCAPA_LOCAL ;
1167 else {
1168 thiscapapos = thiscapapos | RCX_SIGCAPA_GLOBAL ;
1169 hasglobal = 'Y';
1170 }
1171
1172 if( ( thiscapatype & capatype ) && ( thiscapapos & capapos ) ) {
1173
1174 capa = 0.0;
1175
1176 switch( capadyna ) {
1177 case RCX_SIGCAPA_NORM :
1178 capa = ctc->CAPA ;
1179 break;
1180 case RCX_SIGCAPA_MILLER :
1181 capa = rcx_capamiller( ptsig, ctc, slope, type );
1182 break;
1183 case RCX_SIGCAPA_DELTA :
1184 capa = rcx_capamiller( ptsig, ctc, slope, type )
1185 - ctc->CAPA;
1186 break;
1187 }
1188
1189 sumcapa = sumcapa + capa;
1190 }
1191 }
1192
1193 if( ( capatype & RCX_SIGCAPA_GROUND ) == RCX_SIGCAPA_GROUND &&
1194 ( capapos & RCX_SIGCAPA_LOCAL ) == RCX_SIGCAPA_LOCAL &&
1195 ( capadyna == RCX_SIGCAPA_NORM || capadyna == RCX_SIGCAPA_MILLER )
1196 ) {
1197
1198 for( scanwire = ptsig->PRCN->PWIRE ; scanwire ; scanwire = scanwire->NEXT )
1199 sumcapa = sumcapa + scanwire->CAPA ;
1200 }
1201
1202 if( hasglobal=='N' && ptrcx )
1203 SETFLAG( ptrcx->FLAG, RCXHASNOGCTC );
1204
1205 if( lofig )
1206 rcn_unlock_signal( lofig, ptsig );
1207 return( sumcapa );
1208
1209 }
1210
1211 /******************************************************************************\
1212 Renvoie la capacité vue par un net RCX
1213 \******************************************************************************/
1214 float rcx_getcapa( lofig_list *lofig, losig_list *losig )
1215 {
1216 float capa;
1217 float sumcapa=0.0;
1218
1219 capa = rcx_get_all_locon_capa( losig, TRC_SLOPE_UNK, TRC_CAPA_NOM, TRC_HALF ) ;
1220 sumcapa = sumcapa + capa ;
1221 capa = rcn_getcapa( lofig, losig ) ;
1222 sumcapa = sumcapa + capa ;
1223
1224 return sumcapa;
1225 }
1226
1227 void rcx_add_capa_from_instance_to_figure( loins_list *loins,
1228 lofig_list *lofig,
1229 locon_list *loconint,
1230 locon_list *loconext
1231 )
1232 {
1233 RCXFLOAT cmin, cmax ;
1234 RCXFLOAT cminf, cmaxf ;
1235 RCXFLOAT cupmin, cupmax ;
1236 RCXFLOAT cdwmin, cdwmax ;
1237 RCXFLOAT cupminf, cupmaxf ;
1238 RCXFLOAT cdwminf, cdwmaxf ;
1239 RCXFLOAT cupnommin, cupnommax ;
1240 RCXFLOAT cdwnommin, cdwnommax ;
1241 RCXFLOAT cupnomminf, cupnommaxf ;
1242 RCXFLOAT cdwnomminf, cdwnommaxf ;
1243
1244 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
1245 case ELP_CAPA_LEVEL0 :
1246 cmin = rcx_getloconcapa( loconint, TRC_SLOPE_UNK, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1247 cmax = rcx_getloconcapa( loconint, TRC_SLOPE_UNK, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1248 cminf = rcx_getloconcapa( loconint, TRC_SLOPE_UNK, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1249 cmaxf = rcx_getloconcapa( loconint, TRC_SLOPE_UNK, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1250 rcx_freeloconcapa( NULL, loins, loconint );
1251 if( cmin>0.0 || cmax>0.0 || cminf || cmaxf ) {
1252 rcx_addloconcapa_l0( lofig, NULL, loconext, TRC_HALF, cmin, cmax );
1253 rcx_addloconcapa_l0( lofig, NULL, loconext, TRC_HALF, cminf, cmaxf );
1254 }
1255 break ;
1256 case ELP_CAPA_LEVEL1 :
1257 cupmin = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1258 cupmax = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1259 cdwmin = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1260 cdwmax = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1261 cupminf = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1262 cupmaxf = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1263 cdwminf = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1264 cdwmaxf = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1265 rcx_freeloconcapa( NULL, loins, loconint );
1266 if( cupmin>0.0 || cupmax>0.0 || cdwmin>0.0 || cdwmax>0.0 ||
1267 cupminf>0.0 || cupmaxf>0.0 || cdwminf>0.0 || cdwmaxf>0.0 ) {
1268 rcx_addloconcapa_l1( lofig, NULL, loconext, TRC_HALF, cupmin, cupmax, cdwmin, cdwmax );
1269 rcx_addloconcapa_l1( lofig, NULL, loconext, TRC_END, cupmin, cupmax, cdwmin, cdwmax );
1270 }
1271 break ;
1272 case ELP_CAPA_LEVEL2 :
1273 cupmin = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_MIN, TRC_HALF, NULL );
1274 cupmax = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_MAX, TRC_HALF, NULL );
1275 cdwmin = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_MIN, TRC_HALF, NULL );
1276 cdwmax = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_MAX, TRC_HALF, NULL );
1277 cupnommin = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1278 cupnommax = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1279 cdwnommin = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1280 cdwnommax = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1281 cupnomminf = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1282 cupnommaxf = rcx_getloconcapa( loconint, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1283 cdwnomminf = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1284 cdwnommaxf = rcx_getloconcapa( loconint, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1285 rcx_freeloconcapa( NULL, loins, loconint );
1286 if( cupmin>0.0 || cdwnommin>0.0 || cdwnommax>0.0 || cupmax>0.0 ||
1287 cdwmin>0.0 || cupnommin>0.0 || cupnommax>0.0 || cdwmax>0.0 ||
1288 cdwminf>0.0 || cupnomminf>0.0 || cupnommaxf>0.0 || cdwmaxf>0.0 ) {
1289 rcx_addloconcapa_l2( lofig, NULL, loconext, TRC_HALF,
1290 cupmin, cupnommin, cupnommax, cupmax,
1291 cdwmin, cdwnommin, cdwnommax, cdwmax
1292 );
1293 rcx_addloconcapa_l2( lofig, NULL, loconext, TRC_END,
1294 cupmin, cupnomminf, cupnommaxf, cupmax,
1295 cdwmin, cdwnomminf, cdwnommaxf, cdwmax
1296 );
1297 }
1298 break ;
1299 }
1300 }
1301
1302 void rcx_transfert_capa_from_instance_to_figure( loins_list *loins,
1303 lofig_list *lofig,
1304 locon_list *locon
1305 )
1306 {
1307 RCXFLOAT cmin, cmax ;
1308 RCXFLOAT cminf, cmaxf ;
1309 RCXFLOAT cupmin, cupmax ;
1310 RCXFLOAT cdwmin, cdwmax ;
1311 RCXFLOAT cupminf, cupmaxf ;
1312 RCXFLOAT cdwminf, cdwmaxf ;
1313 RCXFLOAT cupnommin, cupnommax ;
1314 RCXFLOAT cdwnommin, cdwnommax ;
1315 RCXFLOAT cupnomminf, cupnommaxf ;
1316 RCXFLOAT cdwnomminf, cdwnommaxf ;
1317
1318 switch( V_INT_TAB[__ELP_CAPA_LEVEL].VALUE ) {
1319 case ELP_CAPA_LEVEL0 :
1320 cmin = rcx_getloconcapa( locon, TRC_SLOPE_UNK, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1321 cmax = rcx_getloconcapa( locon, TRC_SLOPE_UNK, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1322 cminf = rcx_getloconcapa( locon, TRC_SLOPE_UNK, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1323 cmaxf = rcx_getloconcapa( locon, TRC_SLOPE_UNK, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1324 rcx_freeloconcapa( NULL, loins, locon );
1325 if( cmin>0.0 || cmax>0.0 || cminf || cmaxf ) {
1326 rcx_setloconcapa_l0( lofig, NULL, locon, TRC_HALF, cmin, cmax );
1327 rcx_setloconcapa_l0( lofig, NULL, locon, TRC_HALF, cminf, cmaxf );
1328 }
1329 break ;
1330 case ELP_CAPA_LEVEL1 :
1331 cupmin = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1332 cupmax = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1333 cdwmin = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1334 cdwmax = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1335 cupminf = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1336 cupmaxf = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1337 cdwminf = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1338 cdwmaxf = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1339 rcx_freeloconcapa( NULL, loins, locon );
1340 if( cupmin>0.0 || cupmax>0.0 || cdwmin>0.0 || cdwmax>0.0 ||
1341 cupminf>0.0 || cupmaxf>0.0 || cdwminf>0.0 || cdwmaxf>0.0 ) {
1342 rcx_setloconcapa_l1( lofig, NULL, locon, TRC_HALF, cupmin, cupmax, cdwmin, cdwmax );
1343 rcx_setloconcapa_l1( lofig, NULL, locon, TRC_END, cupmin, cupmax, cdwmin, cdwmax );
1344 }
1345 break ;
1346 case ELP_CAPA_LEVEL2 :
1347 cupmin = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_MIN, TRC_HALF, NULL );
1348 cupmax = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_MAX, TRC_HALF, NULL );
1349 cdwmin = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_MIN, TRC_HALF, NULL );
1350 cdwmax = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_MAX, TRC_HALF, NULL );
1351 cupnommin = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1352 cupnommax = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1353 cdwnommin = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_HALF, NULL );
1354 cdwnommax = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_HALF, NULL );
1355 cupnomminf = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1356 cupnommaxf = rcx_getloconcapa( locon, TRC_SLOPE_UP, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1357 cdwnomminf = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MIN, TRC_END, NULL );
1358 cdwnommaxf = rcx_getloconcapa( locon, TRC_SLOPE_DOWN, TRC_CAPA_NOM_MAX, TRC_END, NULL );
1359 rcx_freeloconcapa( NULL, loins, locon );
1360 if( cupmin>0.0 || cdwnommin>0.0 || cdwnommax>0.0 || cupmax>0.0 ||
1361 cdwmin>0.0 || cupnommin>0.0 || cupnommax>0.0 || cdwmax>0.0 ||
1362 cdwminf>0.0 || cupnomminf>0.0 || cupnommaxf>0.0 || cdwmaxf>0.0 ) {
1363 rcx_setloconcapa_l2( lofig, NULL, locon, TRC_HALF,
1364 cupmin, cupnommin, cupnommax, cupmax,
1365 cdwmin, cdwnommin, cdwnommax, cdwmax
1366 );
1367 rcx_setloconcapa_l2( lofig, NULL, locon, TRC_END,
1368 cupmin, cupnomminf, cupnommaxf, cupmax,
1369 cdwmin, cdwnomminf, cdwnommaxf, cdwmax
1370 );
1371 }
1372 break ;
1373 }
1374
1375 }