distrib/sources/tas/stm/stm_mod_meta.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit: STM Version 1.00                                             */
   6 /*    Fichier: stm_mod_meta.c                                               */
   7 /*                                                                          */
   8 /*    (c) copyright 2000 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s): Gilles Augustins                                           */
  12 /*               Antony Pinto                                               */
  13 /*                                                                          */
  14 /****************************************************************************/
  15
  16 /****************************************************************************/
  17 /*     includes                                                             */
  18 /****************************************************************************/
  19
  20 #include "stm.h"
  21
  22
  23 /****************************************************************************/
  24 /*     functions                                                            */
  25 /****************************************************************************/
  26
  27 float stm_round (float d, int precision)
  28 {
  29     long   l;
  30     int    i = 0;
  31     float dp;
  32     int    cs;
  33
  34     dp = d < 0 ? -d : d;
  35
  36     if (dp == 0.0)
  37         return 0.0;
  38
  39     cs = (int)pow ((float)10, (float)precision);
  40     if (dp >= cs) {
  41         l = (long)dp;
  42         while (l / cs) {
  43             l /= 10;
  44             i++;
  45         }
  46         while (i--)
  47             l *= 10;
  48         if (d < 0)
  49             return -(float)l;
  50         else
  51             return (float)l;
  52     } else {
  53         cs /= 10;
  54         while (dp < cs) {
  55             dp *= 10;
  56             i++;
  57         }
  58         l = (long)dp;
  59         if (l == LONG_MAX)
  60             avt_errmsg (STM_ERRMSG, "050", AVT_ERROR);
  61         dp = (float)l;
  62         while (i--)
  63             dp /= 10;
  64         if (d < 0)
  65             return -dp;
  66         else
  67             return dp;
  68     }
  69 }
  70
  71 /****************************************************************************/
  72
  73 float *stm_dyna_slews (int n, float slew)
  74 {
  75     int i ;
  76     float *slopes;
  77
  78     if(slew < 0.0)
  79         slew = STM_DEF_SLEW;
  80
  81     slopes = (float*)mbkalloc ((2 * n + 1) * sizeof (float));
  82     for (i = 0 ; i < 2 * n + 1 ; i++)
  83         slopes[i] = stm_round (slew / pow ((float)((pow (n - 5, 2) + 12) / 10), (float)(n - i)), 2);
  84
  85     return slopes;
  86 }
  87 /****************************************************************************/
  88
  89 float *stm_dyna_slewsforpln (int n, float thmin, float thmax)
  90 {
  91     int i ;
  92     float step;
  93     float *slopes;
  94
  95     slopes = (float*)mbkalloc ((2 * n + 1) * sizeof (float));
  96     step = (thmax - thmin) / (2 * n);
  97     for (i = 0 ; i < 2 * n + 1 ; i++)
  98         slopes[i] = stm_round (thmin + (i * step), 2);
  99
 100     return slopes;
 101 }
 102
 103 /****************************************************************************/
 104
 105 float *stm_dyna_loads (int n, float avg_r, float load)
 106 {
 107     int i ;
 108     float *dyna_slews;
 109     float *loads ;
 110
 111
 112     dyna_slews = stm_dyna_slews (n, -1.0);
 113
 114     loads = (float*)mbkalloc ((2 * n + 1) * sizeof (float)) ;
 115     for (i = 0 ; i < 2 * n + 1 ; i++){
 116         if(load < 0.0)
 117          loads[i] = stm_round (stm_thr2scm (dyna_slews[i], STM_DEFAULT_SMINR, STM_DEFAULT_SMAXR, STM_DEFAULT_VTN, V_FLOAT_TAB[__SIM_POWER_SUPPLY].VALUE, V_FLOAT_TAB[__SIM_POWER_SUPPLY].VALUE, STM_UP) / avg_r, 2) * 1000;
 118         else
 119          loads[i] = stm_round (load / pow ((float)((pow (n - 5, 2) + 12) / 10), (float)(n - i)), 2);
 120     }
 121
 122     mbkfree (dyna_slews);
 123
 124     return loads;
 125 }
 126 /****************************************************************************/
 127
 128 float *stm_dyna_loadsforpln (int n, float thmin, float thmax)
 129 {
 130     int i ;
 131     float step;
 132     float *loads ;
 133
 134
 135     loads = (float*)mbkalloc ((2 * n + 1) * sizeof (float)) ;
 136     step = (thmax - thmin) / (2 * n);
 137     for (i = 0 ; i < 2 * n + 1 ; i++)
 138         loads[i] = stm_round (thmin + (i * step), 2);
 139
 140
 141     return loads;
 142 }
 143
 144
 145 /****************************************************************************/
 146
 147 float stm_mod_getcaracslewmin (timing_model *model)
 148 {
 149     ptype_list *ptype;
 150
 151     if (!model)
 152         return STM_NOVALUE;
 153
 154     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 155         return STM_NOVALUE;
 156     else
 157         return ((stm_carac_values*)ptype->DATA)->SLEW_MIN;
 158 }
 159
 160 /****************************************************************************/
 161
 162 float stm_mod_getcaracslewoutmin (timing_model *model)
 163 {
 164     ptype_list *ptype;
 165
 166     if (!model)
 167         return STM_NOVALUE;
 168
 169     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 170         return STM_NOVALUE;
 171     else
 172         return ((stm_carac_values*)ptype->DATA)->SLEWOUT_MIN;
 173 }
 174
 175 /****************************************************************************/
 176
 177 float stm_mod_getcaracloadmin (timing_model *model)
 178 {
 179     ptype_list *ptype;
 180
 181     if (!model)
 182         return STM_NOVALUE;
 183
 184     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 185         return STM_NOVALUE;
 186     else
 187         return ((stm_carac_values*)ptype->DATA)->LOAD_MIN;
 188 }
 189
 190 /****************************************************************************/
 191
 192 float stm_mod_getcaracslewmax (timing_model *model)
 193 {
 194     ptype_list *ptype;
 195
 196     if (!model)
 197         return STM_NOVALUE;
 198
 199     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 200         return STM_NOVALUE;
 201     else
 202         return ((stm_carac_values*)ptype->DATA)->SLEW_MAX;
 203 }
 204
 205 /****************************************************************************/
 206
 207 float stm_mod_getcaracslewoutmax (timing_model *model)
 208 {
 209     ptype_list *ptype;
 210
 211     if (!model)
 212         return STM_NOVALUE;
 213
 214     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 215         return STM_NOVALUE;
 216     else
 217         return ((stm_carac_values*)ptype->DATA)->SLEWOUT_MAX;
 218 }
 219
 220 /****************************************************************************/
 221
 222 float stm_mod_getcaracloadmax (timing_model *model)
 223 {
 224     ptype_list *ptype;
 225
 226     if (!model)
 227         return STM_NOVALUE;
 228
 229     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES)))
 230         return STM_NOVALUE;
 231     else
 232         return ((stm_carac_values*)ptype->DATA)->LOAD_MAX;
 233 }
 234
 235 /****************************************************************************/
 236
 237 void stm_mod_setcaracslew (timing_model *model, float slew)
 238 {
 239     ptype_list *ptype;
 240     stm_carac_values *cvalues;
 241
 242     if (!model)
 243         return;
 244
 245     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES))) {
 246         cvalues = (stm_carac_values*)mbkalloc (sizeof (struct stm_carac_values));
 247         cvalues->LOAD_MIN = FLT_MAX;
 248         cvalues->LOAD_MAX = FLT_MIN;
 249         cvalues->SLEW_MIN = FLT_MAX;
 250         cvalues->SLEW_MAX = FLT_MIN;
 251         cvalues->SLEWOUT_MIN = FLT_MAX;
 252         cvalues->SLEWOUT_MAX = FLT_MIN;
 253         model->USER = addptype (model->USER, STM_CARAC_VALUES, cvalues);
 254     } else
 255         cvalues = (stm_carac_values*)ptype->DATA;
 256
 257     cvalues->SLEW_MIN = cvalues->SLEW_MIN < slew ? cvalues->SLEW_MIN : slew;
 258     cvalues->SLEW_MAX = cvalues->SLEW_MAX > slew ? cvalues->SLEW_MAX : slew;
 259 }
 260
 261 /****************************************************************************/
 262
 263 void stm_mod_setcaracslewout (timing_model *model, float slew)
 264 {
 265     ptype_list *ptype;
 266     stm_carac_values *cvalues;
 267
 268     if (!model)
 269         return;
 270
 271     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES))) {
 272         cvalues = (stm_carac_values*)mbkalloc (sizeof (struct stm_carac_values));
 273         cvalues->LOAD_MIN = FLT_MAX;
 274         cvalues->LOAD_MAX = FLT_MIN;
 275         cvalues->SLEW_MIN = FLT_MAX;
 276         cvalues->SLEW_MAX = FLT_MIN;
 277         cvalues->SLEWOUT_MIN = FLT_MAX;
 278         cvalues->SLEWOUT_MAX = FLT_MIN;
 279         model->USER = addptype (model->USER, STM_CARAC_VALUES, cvalues);
 280     } else
 281         cvalues = (stm_carac_values*)ptype->DATA;
 282
 283     cvalues->SLEWOUT_MIN = cvalues->SLEWOUT_MIN < slew ? cvalues->SLEWOUT_MIN : slew;
 284     cvalues->SLEWOUT_MAX = cvalues->SLEWOUT_MAX > slew ? cvalues->SLEWOUT_MAX : slew;
 285 }
 286
 287 /****************************************************************************/
 288
 289 void stm_mod_setcaracload (timing_model *model, float load)
 290 {
 291     ptype_list *ptype;
 292     stm_carac_values *cvalues;
 293
 294     if (!model)
 295         return;
 296
 297     if (!(ptype = getptype (model->USER, STM_CARAC_VALUES))) {
 298         cvalues = (stm_carac_values*)mbkalloc (sizeof (struct stm_carac_values));
 299         cvalues->LOAD_MIN = FLT_MAX;
 300         cvalues->LOAD_MAX = FLT_MIN;
 301         cvalues->SLEW_MIN = FLT_MAX;
 302         cvalues->SLEW_MAX = FLT_MIN;
 303         cvalues->SLEWOUT_MIN = FLT_MAX;
 304         cvalues->SLEWOUT_MAX = FLT_MIN;
 305         model->USER = addptype (model->USER, STM_CARAC_VALUES, cvalues);
 306     } else
 307         cvalues = (stm_carac_values*)ptype->DATA;
 308
 309     cvalues->LOAD_MIN = cvalues->LOAD_MIN < load ? cvalues->LOAD_MIN : load;
 310     cvalues->LOAD_MAX = cvalues->LOAD_MAX > load ? cvalues->LOAD_MAX : load;
 311 }
 312
 313 /****************************************************************************/
 314
 315 long stm_genloadaxis (double *loads, float load_min, float load_max)
 316 {
 317     int i, n = 4;
 318     float step = (load_max - load_min) / (pow(2, n) - 1);
 319
 320     loads[0] = load_min;
 321     for (i = 0; i < n; i++)
 322         loads[i + 1] = loads[i] + step * pow(2, i);
 323
 324     return (n + 1);
 325 }
 326
 327 /****************************************************************************/
 328
 329 long stm_genslewaxis (double *slews, float slew_min, float slew_max)
 330 {
 331     int i, n = 4;
 332     float step = (slew_max - slew_min) / (pow(2, n) - 1);
 333
 334     slews[0] = slew_min;
 335     for (i = 0; i < n; i++)
 336         slews[i + 1] = slews[i] + step * pow(2, i);
 337
 338     return (n + 1);
 339 }
 340
 341 /****************************************************************************/
 342 /*{{{                    Generals                                           */
 343 /****************************************************************************/
 344 /*{{{                    stm_mod_stm2tbl_delay()                            */
 345 /*                                                                          */
 346 /*                                                                          */
 347 /****************************************************************************/
 348 timing_model *stm_mod_stm2tbl_delay(timing_model *model, float *slews,
 349                                     long ns, float *loads, long nl,
 350                                     float ci0)
 351 {
 352     switch (model->UTYPE)
 353     {
 354         case STM_MOD_MODSCM:
 355              return stm_mod_scm2tbl_delay(model,slews,ns,loads,nl,ci0,STM_DEF_SLEW,STM_DEF_LOAD);
 356         case STM_MOD_MODPLN:
 357              return stm_mod_pln2tbl_delay(model,slews,ns,loads,nl,ci0);
 358         case STM_MOD_MODFCT:
 359              return stm_mod_fct2tbl_delay(model,slews,ns,loads,nl,ci0);
 360         case STM_MOD_MODTBL:
 361              return model;
 362         default :
 363              model->UMODEL.TABLE = NULL;
 364              return model;
 365     }
 366 }
 367
 368 /*}}}************************************************************************/
 369 /*{{{                    stm_mod_stm2tbl_slew()                             */
 370 /*                                                                          */
 371 /*                                                                          */
 372 /****************************************************************************/
 373 timing_model *stm_mod_stm2tbl_slew(timing_model *model, float *slews,
 374                                    long ns, float *loads, long nl, float ci0)
 375 {
 376     switch (model->UTYPE)
 377     {
 378         case STM_MOD_MODSCM:
 379              return stm_mod_scm2tbl_slew(model,slews,ns,loads,nl,ci0,STM_DEF_SLEW,STM_DEF_LOAD);
 380         case STM_MOD_MODPLN:
 381              return stm_mod_pln2tbl_slew(model,slews,ns,loads,nl,ci0);
 382         case STM_MOD_MODFCT:
 383              return stm_mod_fct2tbl_slew(model,slews,ns,loads,nl,ci0);
 384         case STM_MOD_MODTBL:
 385              return model;
 386         default :
 387              model->UMODEL.TABLE = NULL;
 388              return NULL;
 389     }
 390 }
 391
 392 /*}}}************************************************************************/
 393 /*{{{                    stm_mod_defaultstm2tbl_delay()                     */
 394 /*                                                                          */
 395 /*                                                                          */
 396 /****************************************************************************/
 397 void stm_mod_defaultstm2tbl_delay(timing_model *model, char xtype, char ytype, float slew, float load)
 398 {
 399     switch (model->UTYPE)
 400     {
 401         case STM_MOD_MODSCM :
 402              stm_mod_defaultscm2tbl_delay(model, slew, load);
 403              break;
 404         case STM_MOD_MODPLN :
 405              stm_mod_defaultpln2tbl_delay(model);
 406              break;
 407         case STM_MOD_MODFCT :
 408              stm_mod_defaultfct2tbl_delay(model,xtype,ytype);
 409              break;
 410         case STM_MOD_MODTBL :
 411              break;
 412         default :
 413              model->UMODEL.TABLE = NULL;
 414     }
 415
 416 }
 417
 418 /*}}}************************************************************************/
 419 /*{{{                    stm_mod_defaultstm2tbl_slew()                      */
 420 /*                                                                          */
 421 /*                                                                          */
 422 /****************************************************************************/
 423 void stm_mod_defaultstm2tbl_slew(timing_model *model, char xtype, char ytype, float slew, float load)
 424 {
 425     switch (model->UTYPE)
 426     {
 427         case STM_MOD_MODSCM:
 428              stm_mod_defaultscm2tbl_slew(model, slew, load);
 429              break;
 430         case STM_MOD_MODPLN:
 431              stm_mod_defaultpln2tbl_slew(model);
 432              break;
 433         case STM_MOD_MODFCT:
 434              stm_mod_defaultfct2tbl_slew(model,xtype,ytype);
 435              break;
 436         case STM_MOD_MODTBL :
 437              break;
 438         default :
 439              model->UMODEL.TABLE = NULL;
 440     }
 441
 442 }
 443
 444 /*}}}************************************************************************/
 445 /*}}}************************************************************************/
 446 /*{{{                    SCM                                                */
 447 /****************************************************************************/
 448
 449 /****************************************************************************/
 450
 451 timing_model *stm_mod_scm2tbl_delay (timing_model *model, float *slews, long ns, float *loads, long nl, float ci0, float slew, float load)
 452 {
 453     ptype_list          *ptype;
 454     stm_carac_values    *cvalues = NULL;
 455     double               loc_slews[1024];
 456     double               loc_slews_scaled[1024];
 457     double               loc_loads[1024];
 458     long                 loc_ns = 0;
 459     long                 loc_nl = 0;
 460     timing_table        *tbl;
 461     int                  i;
 462     float                slew_scaled;
 463
 464     if (!model)
 465         return NULL;
 466
 467     if (model->UTYPE != STM_MOD_MODSCM)
 468         return NULL;
 469
 470     if ((ptype = getptype (model->USER, STM_CARAC_VALUES)))
 471         cvalues = (stm_carac_values*)ptype->DATA;
 472
 473     if (!slews && !ns) {
 474         if (cvalues)
 475             loc_ns = stm_genslewaxis (loc_slews, cvalues->SLEW_MIN, cvalues->SLEW_MAX);
 476     } else {
 477         loc_ns = ns;
 478         for (i = 0; i < loc_ns; i++)
 479             loc_slews[i] = slews[i];
 480     }
 481
 482     if (!loads && !nl) {
 483         if (cvalues)
 484             loc_nl = stm_genloadaxis (loc_loads, cvalues->LOAD_MIN, cvalues->LOAD_MAX);
 485     } else {
 486         loc_nl = nl;
 487         for (i = 0; i < loc_nl; i++)
 488             loc_loads[i] = loads[i];
 489     }
 490     if(slew < 0.0 && load >= 0.0) loc_nl = 0;
 491     if(load < 0.0 && slew >= 0.0) loc_ns = 0;
 492
 493     if (!loc_ns && !loc_nl)
 494       return NULL;
 495     else
 496     {
 497       model->NAME   = stm_dlymname_extract(model->NAME);
 498       if(stm_if_thresholds()){
 499           slew_scaled = stm_mod_shrinkslew_thr2scm(model, slew);
 500           stm_mod_shrinkslewaxis_thr2scm(model, loc_slews_scaled, loc_slews, loc_ns);
 501       }else{
 502           for (i = 0; i < loc_ns; i++)
 503              loc_slews_scaled[i] = loc_slews[i];
 504       }
 505
 506     if (loc_ns && loc_nl)
 507         tbl   = stm_modtbl_create_delay2D_fstm(model,loc_slews_scaled,loc_ns,loc_loads,loc_nl,ci0);
 508     else if (!loc_ns && loc_nl)
 509         tbl   = stm_modtbl_create_delay1Dslewfix_fstm(model,loc_loads,loc_nl,slew_scaled,ci0);
 510     else if (loc_ns && !loc_nl)
 511         tbl   = stm_modtbl_create_delay1Dloadfix_fstm(model,loc_slews_scaled,loc_ns,load);
 512     stm_mod_destroy_model (model);
 513     model->UTYPE          = STM_MOD_MODTBL;
 514     model->UMODEL.TABLE   = tbl;
 515
 516
 517       if(stm_if_thresholds()){
 518           stm_mod_shrinkslewaxis_scm2thr (model, loc_slews);
 519       }
 520
 521       return model;
 522     }
 523 }
 524
 525 /****************************************************************************/
 526
 527 timing_model *stm_mod_scm2tbl_slew (timing_model *model, float *slews, long ns, float *loads, long nl, float ci0, float slew, float load)
 528 {
 529     ptype_list *ptype;
 530     stm_carac_values *cvalues = NULL;
 531     double loc_slews[1024];
 532     double loc_slews_scaled[1024];
 533     double loc_loads[1024];
 534     long  loc_ns = 0;
 535     long  loc_nl = 0;
 536     timing_table *tbl;
 537     int i;
 538     float slew_scaled;
 539
 540     if (!model)
 541         return NULL;
 542
 543     if (model->UTYPE != STM_MOD_MODSCM)
 544         return NULL;
 545
 546     if ((ptype = getptype (model->USER, STM_CARAC_VALUES)))
 547         cvalues = (stm_carac_values*)ptype->DATA;
 548
 549     if (!slews && !ns) {
 550         if (cvalues)
 551             loc_ns = stm_genslewaxis (loc_slews, cvalues->SLEW_MIN, cvalues->SLEW_MAX);
 552     } else {
 553         loc_ns = ns;
 554         for (i = 0; i < loc_ns; i++)
 555             loc_slews[i] = slews[i];
 556     }
 557
 558     if (!loads && !nl) {
 559         if (cvalues)
 560             loc_nl = stm_genloadaxis (loc_loads, cvalues->LOAD_MIN, cvalues->LOAD_MAX);
 561     } else {
 562         loc_nl = nl;
 563         for (i = 0; i < loc_nl; i++)
 564             loc_loads[i] = loads[i];
 565     }
 566     if(slew < 0.0 && load >= 0.0) loc_nl = 0;
 567     if(load < 0.0 && slew >= 0.0) loc_ns = 0;
 568
 569     if (!loc_ns && !loc_nl)
 570       return NULL;
 571     else
 572     {
 573       model->NAME   = stm_slwmname_extract(model->NAME);
 574       if(stm_if_thresholds()){
 575           slew_scaled = stm_mod_shrinkslew_thr2scm(model, slew);
 576           stm_mod_shrinkslewaxis_thr2scm(model, loc_slews_scaled, loc_slews, loc_ns);
 577       }else{
 578           for (i = 0; i < loc_ns; i++)
 579              loc_slews_scaled[i] = loc_slews[i];
 580       }
 581     if (loc_ns && loc_nl)
 582         tbl   = stm_modtbl_create_slew2D_fstm(model,loc_slews_scaled,loc_ns,loc_loads,loc_nl,ci0);
 583     else if (!loc_ns && loc_nl)
 584         tbl   = stm_modtbl_create_slew1Dslewfix_fstm(model,loc_loads,loc_nl,slew_scaled,ci0);
 585     else if (loc_ns && !loc_nl)
 586         tbl   = stm_modtbl_create_slew1Dloadfix_fstm(model,loc_slews_scaled,loc_ns,load);
 587     stm_mod_destroy_model (model);
 588     model->UTYPE          = STM_MOD_MODTBL;
 589     model->UMODEL.TABLE   = tbl;
 590       if(stm_if_thresholds()){
 591           stm_mod_shrinkslewaxis_scm2thr (model, loc_slews);
 592           stm_mod_shrinkslewdata_scm2thr (model);
 593       }
 594
 595       return model;
 596     }
 597 }
 598
 599 /****************************************************************************/
 600
 601 void stm_mod_defaultscm2tbl_slew (timing_model *model, float slew, float load)
 602 {
 603     float *s_axis;
 604     float *l_axis;
 605     float vf, imax, vt;
 606     int ns, nl, frees=0, freel=0;
 607
 608
 609     if(slew < 0.0 && STM_AXIS_NSLOPE){
 610         s_axis = STM_AXIS_SLOPEIN;
 611         ns = STM_AXIS_NSLOPE;
 612     }else if(getptype (model->USER, STM_CARAC_VALUES)){
 613         s_axis = NULL;
 614         ns = 0;
 615     }else{
 616         s_axis = stm_dyna_slews (STM_DEF_AXIS_BASE, slew);
 617         ns = STM_DEF_AXIS_BASE * 2 + 1;
 618         frees=1;
 619     }
 620     if(load < 0.0 && STM_AXIS_NCAPA){
 621         l_axis = STM_AXIS_CAPAOUT;
 622         nl = STM_AXIS_NCAPA;
 623     }else if(getptype (model->USER, STM_CARAC_VALUES)){
 624         l_axis = NULL;
 625         nl = 0;
 626     }else{
 627         vf = stm_mod_vf (model);
 628         vt = stm_mod_vt (model);
 629         if (vf < vt)
 630             vf = stm_mod_vdd(model) - vt;
 631         imax = stm_mod_imax (model);
 632         l_axis = stm_dyna_loads (STM_DEF_AXIS_BASE, vf / imax, load);
 633         nl = STM_DEF_AXIS_BASE * 2 + 1;
 634         freel=1;
 635     }
 636
 637     stm_mod_scm2tbl_slew (model, s_axis, ns, l_axis, nl, 0.0, slew, load);
 638
 639     if(frees)
 640         mbkfree (s_axis);
 641     if(freel)
 642         mbkfree (l_axis);
 643 }
 644
 645 /****************************************************************************/
 646
 647 void stm_mod_defaultscm2tbl_delay (timing_model *model, float slew, float load)
 648 {
 649     float *s_axis;
 650     float *l_axis;
 651     float vf, imax, vt;
 652     int ns, nl, frees=0, freel=0;
 653
 654
 655     if(slew < 0.0 && STM_AXIS_NSLOPE){
 656         s_axis = STM_AXIS_SLOPEIN;
 657         ns = STM_AXIS_NSLOPE;
 658     }else if(getptype (model->USER, STM_CARAC_VALUES)){
 659         s_axis = NULL;
 660         ns = 0;
 661     }else{
 662         s_axis = stm_dyna_slews (STM_DEF_AXIS_BASE, slew);
 663         ns = STM_DEF_AXIS_BASE * 2 + 1;
 664         frees=1;
 665     }
 666     if(load < 0.0 && STM_AXIS_NCAPA){
 667         l_axis = STM_AXIS_CAPAOUT;
 668         nl = STM_AXIS_NCAPA;
 669     }else if(getptype (model->USER, STM_CARAC_VALUES)){
 670         l_axis = NULL;
 671         nl = 0;
 672     }else{
 673         vf = stm_mod_vf (model);
 674         vt = stm_mod_vt (model);
 675         if (vf < vt)
 676             vf = stm_mod_vdd(model) - vt;
 677         imax = stm_mod_imax (model);
 678         l_axis = stm_dyna_loads (STM_DEF_AXIS_BASE, vf / imax, load);
 679         nl = STM_DEF_AXIS_BASE * 2 + 1;
 680         freel=1;
 681     }
 682
 683     stm_mod_scm2tbl_delay (model, s_axis, ns, l_axis, nl, 0.0, slew, load);
 684
 685     if(frees)
 686         mbkfree (s_axis);
 687     if(freel)
 688         mbkfree (l_axis);
 689 }
 690
 691 /*}}}************************************************************************/
 692 /*{{{                    PLN                                                */
 693 /****************************************************************************/
 694 timing_model *stm_mod_pln2tbl_delay (timing_model *model, float *slews, long ns, float *loads, long nl, float ci0)
 695 {
 696     ptype_list *ptype;
 697     stm_carac_values *cvalues = NULL;
 698     double loc_slews[1024];
 699     double loc_loads[1024];
 700     long  loc_ns = 0;
 701     long  loc_nl = 0;
 702     timing_table *tbl;
 703     int i;
 704
 705     if (!model)
 706         return NULL;
 707
 708     if (model->UTYPE != STM_MOD_MODPLN)
 709         return NULL;
 710
 711     if ((ptype = getptype (model->USER, STM_CARAC_VALUES)))
 712         cvalues = (stm_carac_values*)ptype->DATA;
 713
 714     if (!slews && !ns) {
 715         if (cvalues)
 716             loc_ns = stm_genslewaxis (loc_slews, cvalues->SLEW_MIN, cvalues->SLEW_MAX);
 717     } else {
 718         loc_ns = ns;
 719         for (i = 0; i < loc_ns; i++)
 720             loc_slews[i] = slews[i];
 721     }
 722
 723     if (!loads && !nl) {
 724         if (cvalues)
 725             loc_nl = stm_genloadaxis (loc_loads, cvalues->LOAD_MIN, cvalues->LOAD_MAX);
 726     } else {
 727         loc_nl = nl;
 728         for (i = 0; i < loc_nl; i++)
 729             loc_loads[i] = loads[i];
 730     }
 731
 732     if (!loc_ns && !loc_nl)
 733       return NULL;
 734     else
 735     {
 736       model->NAME   = stm_dlymname_extract(model->NAME);
 737     if (loc_ns && loc_nl)
 738         tbl   = stm_modtbl_create_delay2D_fstm(model,loc_slews,loc_ns,loc_loads,loc_nl,ci0);
 739     else if (!loc_ns && loc_nl)
 740         tbl   = stm_modtbl_create_delay1Dslewfix_fstm(model,loc_loads,loc_nl,STM_DEF_SLEW,ci0);
 741     else if (loc_ns && !loc_nl)
 742         tbl   = stm_modtbl_create_delay1Dloadfix_fstm(model,loc_slews,loc_ns,STM_DEF_LOAD);
 743     stm_mod_destroy_model (model);
 744     model->UTYPE          = STM_MOD_MODTBL;
 745     model->UMODEL.TABLE   = tbl;
 746
 747       return model;
 748     }
 749 }
 750
 751 /****************************************************************************/
 752
 753 timing_model *stm_mod_pln2tbl_slew (timing_model *model, float *slews, long ns, float *loads, long nl, float ci0)
 754 {
 755     ptype_list *ptype;
 756     stm_carac_values *cvalues = NULL;
 757     double loc_slews[1024];
 758     double loc_loads[1024];
 759     long  loc_ns = 0;
 760     long  loc_nl = 0;
 761     timing_table *tbl;
 762     int i;
 763
 764     if (!model)
 765         return NULL;
 766
 767     if (model->UTYPE != STM_MOD_MODPLN)
 768         return NULL;
 769
 770     if ((ptype = getptype (model->USER, STM_CARAC_VALUES)))
 771         cvalues = (stm_carac_values*)ptype->DATA;
 772
 773     if (!slews && !ns) {
 774         if (cvalues)
 775             loc_ns = stm_genslewaxis (loc_slews, cvalues->SLEW_MIN, cvalues->SLEW_MAX);
 776     } else {
 777         loc_ns = ns;
 778         for (i = 0; i < loc_ns; i++)
 779             loc_slews[i] = slews[i];
 780     }
 781
 782     if (!loads && !nl) {
 783         if (cvalues)
 784             loc_nl = stm_genloadaxis (loc_loads, cvalues->LOAD_MIN, cvalues->LOAD_MAX);
 785     } else {
 786         loc_nl = nl;
 787         for (i = 0; i < loc_nl; i++)
 788             loc_loads[i] = loads[i];
 789     }
 790
 791     if (!loc_ns && !loc_nl)
 792       return NULL;
 793     else
 794     {
 795       model->NAME   = stm_slwmname_extract(model->NAME);
 796     if (loc_ns && loc_nl)
 797         tbl   = stm_modtbl_create_slew2D_fstm(model,loc_slews,loc_ns,loc_loads,loc_nl,ci0);
 798     else if (!loc_ns && loc_nl)
 799         tbl   = stm_modtbl_create_slew1Dslewfix_fstm(model,loc_loads,loc_nl,STM_DEF_SLEW,ci0);
 800     else if (loc_ns && !loc_nl)
 801         tbl   = stm_modtbl_create_slew1Dloadfix_fstm(model,loc_slews,loc_ns,STM_DEF_LOAD);
 802     stm_mod_destroy_model (model);
 803     model->UTYPE          = STM_MOD_MODTBL;
 804     model->UMODEL.TABLE   = tbl;
 805
 806       return model;
 807     }
 808 }
 809
 810 /****************************************************************************/
 811
 812 void stm_mod_defaultpln2tbl_slew (timing_model *model)
 813 {
 814     float *s_axis = NULL;
 815     float *l_axis = NULL;
 816     float thcapamin = -1.0, thcapamax = -1.0;
 817     float thslewmin = -1.0, thslewmax = -1.0;
 818     int i, nbvar;
 819     long nbvarmask, ns = 0, nl = 0;
 820     long nbvar_degree = model->UMODEL.POLYNOM->DEG_NBVAR;
 821
 822     nbvarmask = ULONG_MAX >> (sizeof(long) * 4);
 823     nbvar = nbvar_degree & nbvarmask;
 824
 825     for(i = 0; i < nbvar; i++){
 826         if(model->UMODEL.POLYNOM->VAR[i]->TYPE == STM_INPUT_SLEW){
 827             thslewmin = model->UMODEL.POLYNOM->VAR[i]->THMIN;
 828             thslewmax = model->UMODEL.POLYNOM->VAR[i]->THMAX;
 829             break;
 830         }
 831     }
 832     for(i = 0; i < nbvar; i++){
 833         if(model->UMODEL.POLYNOM->VAR[i]->TYPE == STM_LOAD){
 834             thcapamin = model->UMODEL.POLYNOM->VAR[i]->THMIN;
 835             thcapamax = model->UMODEL.POLYNOM->VAR[i]->THMAX;
 836             break;
 837         }
 838     }
 839
 840     if((thslewmin >= 0.0) && (thslewmax >= 0.0)){
 841         s_axis = stm_dyna_slewsforpln (STM_DEF_AXIS_BASE, thslewmin, thslewmax);
 842         ns = STM_DEF_AXIS_BASE * 2 + 1;
 843     }
 844     if((thcapamin >= 0.0) && (thcapamax >= 0.0)){
 845         l_axis = stm_dyna_loadsforpln (STM_DEF_AXIS_BASE, thcapamin, thcapamax);
 846         nl = STM_DEF_AXIS_BASE * 2 + 1;
 847     }
 848
 849     stm_mod_pln2tbl_slew (model, s_axis, ns, l_axis, nl, 0.0);
 850
 851     mbkfree (s_axis);
 852     mbkfree (l_axis);
 853 }
 854
 855 /****************************************************************************/
 856
 857 void stm_mod_defaultpln2tbl_delay (timing_model *model)
 858 {
 859     float *s_axis = NULL;
 860     float *l_axis = NULL;
 861     float thcapamin = -1.0, thcapamax = -1.0;
 862     float thslewmin = -1.0, thslewmax = -1.0;
 863     int i, nbvar;
 864     long nbvarmask, ns = 0, nl = 0;
 865     long nbvar_degree = model->UMODEL.POLYNOM->DEG_NBVAR;
 866
 867     nbvarmask = ULONG_MAX >> (sizeof(long) * 4);
 868     nbvar = nbvar_degree & nbvarmask;
 869
 870     for(i = 0; i < nbvar; i++){
 871         if(model->UMODEL.POLYNOM->VAR[i]->TYPE == STM_INPUT_SLEW){
 872             thslewmin = model->UMODEL.POLYNOM->VAR[i]->THMIN;
 873             thslewmax = model->UMODEL.POLYNOM->VAR[i]->THMAX;
 874             break;
 875         }
 876     }
 877     for(i = 0; i < nbvar; i++){
 878         if(model->UMODEL.POLYNOM->VAR[i]->TYPE == STM_LOAD){
 879             thcapamin = model->UMODEL.POLYNOM->VAR[i]->THMIN;
 880             thcapamax = model->UMODEL.POLYNOM->VAR[i]->THMAX;
 881             break;
 882         }
 883     }
 884
 885     if((thslewmin >= 0.0) && (thslewmax >= 0.0)){
 886         s_axis = stm_dyna_slewsforpln (STM_DEF_AXIS_BASE, thslewmin, thslewmax);
 887         ns = STM_DEF_AXIS_BASE * 2 + 1;
 888     }
 889     if((thcapamin >= 0.0) && (thcapamax >= 0.0)){
 890         l_axis = stm_dyna_loadsforpln (STM_DEF_AXIS_BASE, thcapamin, thcapamax);
 891         nl = STM_DEF_AXIS_BASE * 2 + 1;
 892     }
 893
 894     stm_mod_pln2tbl_delay (model, s_axis, ns, l_axis, nl, 0.0);
 895
 896     mbkfree (s_axis);
 897     mbkfree (l_axis);
 898 }
 899
 900 /*}}}************************************************************************/
 901 /*{{{                    FCT                                                */
 902 /****************************************************************************/
 903 /*{{{                    stm_mod_fct2tbl_delay()                            */
 904 /*                                                                          */
 905 /*                                                                          */
 906 /****************************************************************************/
 907 timing_model *stm_mod_fct2tbl_delay(timing_model *model, float *slews,
 908                                     long ns, float *loads, long nl, float ci0)
 909 {
 910   stm_carac_values  *cvalues = NULL;
 911   ptype_list        *ptype;
 912   double             loc_slews[1024], loc_loads[1024];
 913   long               loc_ns = 0, loc_nl = 0;
 914   int                i;
 915   timing_table      *tbl;
 916
 917   if (!model || model->UTYPE != STM_MOD_MODFCT)
 918     return NULL;
 919   else
 920   {
 921     if ((ptype = getptype(model->USER, STM_CARAC_VALUES)))
 922       cvalues =(stm_carac_values*)ptype->DATA;
 923
 924     if (slews || ns)
 925     {
 926       loc_ns = ns;
 927       for (i = 0; i < loc_ns; i++)
 928         loc_slews[i] = slews[i];
 929     }
 930     else if (cvalues)
 931           loc_ns = stm_genslewaxis(loc_slews, cvalues->SLEW_MIN,
 932                                                            cvalues->SLEW_MAX);
 933     if (loads || nl)
 934     {
 935       loc_nl = nl;
 936       for (i = 0; i < loc_nl; i++)
 937         loc_loads[i] = loads[i];
 938     }
 939     else if (cvalues)
 940           loc_nl = stm_genloadaxis(loc_loads, cvalues->LOAD_MIN,
 941                                                            cvalues->LOAD_MAX);
 942
 943     if (!loc_ns && !loc_nl)
 944       return NULL;
 945     else
 946     {
 947       model->NAME   = stm_dlymname_extract(model->NAME);
 948       if (loc_ns && loc_nl)
 949           tbl   = stm_modtbl_create_delay2D_fstm(model,loc_slews,loc_ns,loc_loads,loc_nl,ci0);
 950       else if (!loc_ns && loc_nl)
 951           tbl   = stm_modtbl_create_delay1Dslewfix_fstm(model,loc_loads,loc_nl,STM_DEF_SLEW,ci0);
 952       else if (loc_ns && !loc_nl)
 953           tbl   = stm_modtbl_create_delay1Dloadfix_fstm(model,loc_slews,loc_ns,STM_DEF_LOAD);
 954       stm_mod_destroy_model (model);
 955       model->UTYPE          = STM_MOD_MODTBL;
 956       model->UMODEL.TABLE   = tbl;
 957       return model;
 958     }
 959   }
 960 }
 961
 962 /*}}}************************************************************************/
 963 /*{{{                    stm_mod_fct2tbl_slew()                             */
 964 /*                                                                          */
 965 /*                                                                          */
 966 /****************************************************************************/
 967 timing_model *stm_mod_fct2tbl_slew(timing_model *model, float *slews, long ns, float *loads, long nl, float ci0)
 968 {
 969   stm_carac_values  *cvalues = NULL;
 970   timing_table      *tbl;
 971   ptype_list        *ptype;
 972   double             loc_slews[1024], loc_loads[1024];
 973   long               loc_ns = 0, loc_nl = 0;
 974   int                i;
 975
 976   if (!model || model->UTYPE != STM_MOD_MODPLN)
 977     return NULL;
 978   else
 979   {
 980     if ((ptype = getptype(model->USER, STM_CARAC_VALUES)))
 981       cvalues =(stm_carac_values*)ptype->DATA;
 982     if (!slews && !ns)
 983     {
 984       if (cvalues)
 985         loc_ns = stm_genslewaxis(loc_slews, cvalues->SLEW_MIN,
 986                                  cvalues->SLEW_MAX);
 987     }
 988     else
 989     {
 990       loc_ns = ns;
 991       for (i = 0; i < loc_ns; i++)
 992         loc_slews[i] = slews[i];
 993     }
 994     if (!loads && !nl)
 995     {
 996       if (cvalues)
 997         loc_nl = stm_genloadaxis(loc_loads, cvalues->LOAD_MIN,
 998                                  cvalues->LOAD_MAX);
 999     }
1000     else
1001     {
1002       loc_nl = nl;
1003       for (i = 0; i < loc_nl; i++)
1004         loc_loads[i] = loads[i];
1005     }
1006     if (!loc_ns && !loc_nl)
1007       return NULL;
1008     else
1009     {
1010       model->NAME   = stm_slwmname_extract(model->NAME);
1011     if (loc_ns && loc_nl)
1012         tbl   = stm_modtbl_create_slew2D_fstm(model,loc_slews,loc_ns,loc_loads,loc_nl,ci0);
1013     else if (!loc_ns && loc_nl)
1014         tbl   = stm_modtbl_create_slew1Dslewfix_fstm(model,loc_loads,loc_nl,STM_DEF_SLEW,ci0);
1015     else if (loc_ns && !loc_nl)
1016         tbl   = stm_modtbl_create_slew1Dloadfix_fstm(model,loc_slews,loc_ns,STM_DEF_LOAD);
1017     stm_mod_destroy_model (model);
1018     model->UTYPE          = STM_MOD_MODTBL;
1019     model->UMODEL.TABLE   = tbl;
1020
1021       return model;
1022     }
1023   }
1024 }
1025
1026 /*}}}************************************************************************/
1027 /*{{{                    stm_getAxis()                                      */
1028 /*                                                                          */
1029 /*                                                                          */
1030 /****************************************************************************/
1031 void stm_getAxis(timing_model *model,
1032                  float *x, long *nx,
1033                  float *y, long *ny)
1034 {
1035   ptype_list        *ptype;
1036   stm_carac_values  *cvalues = NULL;
1037   float              vf, imax, vt, *loc_axis;
1038   double             slews[1024], loads[1024];
1039   int                i;
1040
1041   if(STM_AXIS_NSLOPE){
1042     *nx = STM_AXIS_NSLOPE;
1043     for (i = 0; i < *nx; i ++)
1044       x[i] = STM_AXIS_SLOPEIN[i];
1045   }else{
1046     loc_axis = stm_dyna_slews (STM_DEF_AXIS_BASE, -1.0);
1047     *nx = STM_DEF_AXIS_BASE * 2 + 1;
1048     for (i = 0; i < *nx; i ++)
1049       x[i] = loc_axis[i];
1050     mbkfree (loc_axis);
1051   }
1052   if(STM_AXIS_NCAPA){
1053     *ny = STM_AXIS_NCAPA;
1054     for (i = 0; i < *ny; i ++)
1055       y[i] = STM_AXIS_CAPAOUT[i];
1056   }else{
1057     avt_errmsg (STM_ERRMSG,"039", AVT_ERROR);
1058     *ny = 5;
1059     for (i = 0; i < *ny; i ++)
1060       y[i]     = 10.0 + i*10.0 ;
1061   }
1062 }
1063
1064 /*}}}************************************************************************/
1065 /*{{{                    stm_mod_defaultfct2tbl_slew()                      */
1066 /*                                                                          */
1067 /*                                                                          */
1068 /****************************************************************************/
1069 void stm_mod_defaultfct2tbl_slew(timing_model *model, char xtype, char ytype)
1070 {
1071   float          s_axis[2048], l_axis[2048];
1072   long           ns = 0, nl = 0;
1073   ptype_list    *ptype;
1074
1075   stm_getAxis(model, s_axis, &ns, l_axis, &nl);
1076
1077   ptype         = getptype(model->USER,STM_CARAC_VALUES);
1078   if (ptype)
1079         model->USER     = delptype(model->USER,STM_CARAC_VALUES);
1080
1081   if (xtype == STM_NOTYPE)
1082   {
1083     stm_mod_fct2tbl_slew(model, NULL, 0, l_axis, nl, 0.0);
1084   }
1085   else if (ytype == STM_NOTYPE)
1086   {
1087     stm_mod_fct2tbl_slew(model, s_axis, ns, NULL, 0, 0.0);
1088   }
1089   else
1090   {
1091     stm_mod_fct2tbl_slew(model, s_axis, ns, l_axis, nl, 0.0);
1092   }
1093
1094   if (ptype)
1095   {
1096         ptype->NEXT     = model->USER;
1097         model->USER = ptype;
1098   }
1099 }
1100
1101 /*}}}************************************************************************/
1102 /*{{{                    stm_mod_defaultfct2tbl_delay()                     */
1103 /*                                                                          */
1104 /*                                                                          */
1105 /****************************************************************************/
1106 void stm_mod_defaultfct2tbl_delay(timing_model *model, char xtype, char ytype)
1107 {
1108   float          s_axis[2048], l_axis[2048];
1109   long           ns = 0, nl = 0;
1110   ptype_list    *ptype;
1111   void          *data;
1112   long           type;
1113
1114   stm_getAxis(model, s_axis, &ns, l_axis, &nl);
1115
1116   ptype             = getptype(model->USER,STM_CARAC_VALUES);
1117   if (ptype)
1118   {
1119     data        = ptype->DATA;
1120     type        = ptype->TYPE;
1121         model->USER     = delptype(model->USER,STM_CARAC_VALUES);
1122   }
1123   if (xtype == STM_NOTYPE)
1124     stm_mod_fct2tbl_delay (model, NULL, 0, l_axis, nl, 0.0);
1125   else if (ytype == STM_NOTYPE)
1126     stm_mod_fct2tbl_delay (model, s_axis, ns, NULL, 0, 0.0);
1127   else
1128     stm_mod_fct2tbl_delay (model, s_axis, ns, l_axis, nl, 0.0);
1129
1130   if (ptype)
1131   {
1132         model->USER = addptype(model->USER,type,data);
1133   }
1134 }
1135
1136 /*}}}************************************************************************/
1137 /*}}}************************************************************************/
1138
1139 double stm_thr2scm(double fin, double thmin, double thmax, double vt, double vf, double vdd, char type)
1140 {
1141     char elptype;
1142     if(type == STM_UP)
1143         elptype = elpRISE;
1144     else if(type == STM_DN)
1145         elptype = elpFALL;
1146     return elpThr2Scm (fin, thmin, thmax, vt, vf, vdd, elptype);
1147 }
1148
1149 double stm_scm2thr(double fout, double thmin, double thmax, double vt, double vf, double vdd, char type)
1150 {
1151     char elptype;
1152     if(type == STM_UP)
1153         elptype = elpRISE;
1154     else if(type == STM_DN)
1155         elptype = elpFALL;
1156     return elpScm2Thr (fout, thmin, thmax, vt, vf, vdd, elptype);
1157 }
1158
1159 void stm_mod_shrinkslewaxis_thr2scm(timing_model *model, double *slews_scaled, double *slews, long ns)
1160 {
1161     int i;
1162     double vt, vdd, vf, thmin, thmax;
1163     char type;
1164
1165     vt = stm_mod_vt(model);
1166     vdd = stm_mod_vdd_input(model);
1167     vf = stm_mod_vf_input(model);
1168     if((model->TTYPE == STM_HL) || (model->TTYPE == STM_HH)){
1169         thmin = STM_DEFAULT_SMINR;
1170         thmax = STM_DEFAULT_SMAXR;
1171         type = STM_UP;
1172     }else if((model->TTYPE == STM_LH) || (model->TTYPE == STM_LL)){
1173         thmin = STM_DEFAULT_SMINF;
1174         thmax = STM_DEFAULT_SMAXF;
1175         type = STM_DN;
1176     }
1177     for (i = 0; i < ns; i++)
1178         slews_scaled[i] = stm_thr2scm (slews[i], thmin, thmax, vt, vf, vdd, type);
1179 }
1180
1181 double stm_mod_shrinkslew_thr2scm(timing_model *model, double fin)
1182 {
1183     double vt, vdd, vf, thmin, thmax;
1184     char type;
1185
1186     if(model->UTYPE != STM_MOD_MODSCM)
1187         return fin;
1188     vt = stm_mod_vt(model);
1189     vdd = stm_mod_vdd_input(model);
1190     vf = stm_mod_vf_input(model);
1191     if((model->TTYPE == STM_HL) || (model->TTYPE == STM_HH)){
1192         thmin = STM_DEFAULT_SMINR;
1193         thmax = STM_DEFAULT_SMAXR;
1194         type = STM_UP;
1195     }else if((model->TTYPE == STM_LH) || (model->TTYPE == STM_LL)){
1196         thmin = STM_DEFAULT_SMINF;
1197         thmax = STM_DEFAULT_SMAXF;
1198         type = STM_DN;
1199     }
1200     return stm_thr2scm (fin, thmin, thmax, vt, vf, vdd, type);
1201 }
1202
1203 double stm_mod_shrinkslew_scm2thr(timing_model *model, double fout)
1204 {
1205     double vt, vdd, vf, thmin, thmax;
1206     char type;
1207
1208     if(model->UTYPE != STM_MOD_MODSCM)
1209         return fout;
1210     vt = stm_mod_vt(model);
1211     vdd = stm_mod_vdd(model);
1212     vf = stm_mod_vf(model);
1213     if((model->TTYPE == STM_LH) || (model->TTYPE == STM_HH)){
1214         thmin = STM_DEFAULT_SMINR;
1215         thmax = STM_DEFAULT_SMAXR;
1216         type = STM_UP;
1217     }else if((model->TTYPE == STM_HL) || (model->TTYPE == STM_LL)){
1218         thmin = STM_DEFAULT_SMINF;
1219         thmax = STM_DEFAULT_SMAXF;
1220         type = STM_DN;
1221     }
1222     return stm_scm2thr (fout, thmin, thmax, vt, vf, vdd, type);
1223 }
1224
1225 void stm_mod_shrinkslewaxis_scm2thr (timing_model *model, double *slews)
1226 {
1227    int i;
1228 /*   double vt, vdd, vf, thmin, thmax;
1229    char type;*/
1230    timing_table *table = model->UMODEL.TABLE;
1231
1232 /*   vt = stm_mod_vt(model);
1233    vdd = stm_mod_vdd_input(model);
1234    vf = stm_mod_vf_input(model);
1235    if((model->TTYPE == STM_HL) || (model->TTYPE == STM_HH)){
1236        thmin = STM_DEFAULT_SMINR;
1237        thmax = STM_DEFAULT_SMAXR;
1238        type = STM_UP;
1239    }else if((model->TTYPE == STM_LH) || (model->TTYPE == STM_LL)){
1240        thmin = STM_DEFAULT_SMINF;
1241        thmax = STM_DEFAULT_SMAXF;
1242        type = STM_DN;
1243    }*/
1244    if (table->XTYPE == STM_INPUT_SLEW || table->XTYPE == STM_CLOCK_SLEW) {
1245       for (i = 0; i < table->NX; i++) {
1246          table->XRANGE[i] = /*stm_scm2thr (table->XRANGE[i], thmin, thmax, vt, vf, vdd, type)*/slews[i];
1247       }
1248    }
1249
1250    if (table->YTYPE == STM_INPUT_SLEW || table->YTYPE == STM_CLOCK_SLEW) {
1251       for (i = 0; i < table->NY; i++) {
1252          table->YRANGE[i] = /*stm_scm2thr (table->YRANGE[i], thmin, thmax, vt, vf, vdd, type)*/slews[i];
1253       }
1254    }
1255 }
1256
1257 void stm_mod_shrinkslewdata_scm2thr (timing_model *model)
1258 {
1259    int i, j;
1260    double vt, vdd, vth, vf, thmin, thmax;
1261    char type;
1262    timing_table *table = model->UMODEL.TABLE;
1263
1264    vt = stm_mod_vt(model);
1265    vdd = stm_mod_vdd(model);
1266    vf = stm_mod_vf(model);
1267    vth = stm_mod_vth(model);
1268    if((model->TTYPE == STM_LH) || (model->TTYPE == STM_HH)){
1269        thmin = STM_DEFAULT_SMINR;
1270        thmax = STM_DEFAULT_SMAXR;
1271        type = STM_UP;
1272    }else if((model->TTYPE == STM_HL) || (model->TTYPE == STM_LL)){
1273        thmin = STM_DEFAULT_SMINF;
1274        thmax = STM_DEFAULT_SMAXF;
1275        type = STM_DN;
1276    }
1277
1278    if (!stm_modtbl_isnull (table->CST)) {
1279      stm_modtbl_setconst (table, stm_scm2thr (table->CST, thmin, thmax, vt, vf, vdd, type));
1280    }
1281    else
1282    if (table->SET1D) {
1283       for (i = 0; i < table->NX; i++) {
1284         table->SET1D[i] = stm_scm2thr (table->SET1D[i], thmin, thmax, vt, vf, vdd, type);
1285       }
1286    }
1287    else
1288    if (table->SET2D) {
1289       for (i = 0; i < table->NX; i++) {
1290          for (j = 0; j < table->NY; j++) {
1291            table->SET2D[i][j] = stm_scm2thr (table->SET2D[i][j], thmin, thmax, vt, vf, vdd, type);
1292          }
1293       }
1294    }
1295 }
1296
1297
1298 int stm_if_thresholds(void)
1299 {
1300     if((STM_DEFAULT_SMINR > 0.0) &&
1301        (STM_DEFAULT_SMAXR > 0.0) &&
1302        (STM_DEFAULT_SMINF > 0.0) &&
1303        (STM_DEFAULT_SMAXF > 0.0))
1304         return 1;
1305     else
1306         return 0;
1307 }