distrib/sources/tas/stm/stm_modiv.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : STM Version 1.00                                            */
   6 /*    Fichier : stm_solver.c                                                */
   7 /*                                                                          */
   8 /*    (c) copyright 2000 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Grégoire Avot                                             */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 /****************************************************************************/
  16 /*     includes                                                             */
  17 /****************************************************************************/
  18
  19 #include "stm.h"
  20
  21 #ifdef Solaris
  22 #include <ieeefp.h>
  23 #endif
  24
  25 /******************************************************************************\
  26 Global definition
  27 \******************************************************************************/
  28
  29
  30 /******************************************************************************\
  31 Insert a current in table
  32 \******************************************************************************/
  33
  34 void stm_modiv_setis( timing_iv *iv, int ne, int ns, float is )
  35 {
  36   iv->IS[ ne + ( ns * iv->NVE ) ] = is;
  37 }
  38
  39 /******************************************************************************\
  40 Get a current in table
  41 \******************************************************************************/
  42
  43 float stm_modiv_getis( timing_iv *iv, int ne, int ns )
  44 {
  45   return iv->IS[ ne + ( ns * iv->NVE ) ];
  46 }
  47
  48 /******************************************************************************\
  49 Create a new model
  50 \******************************************************************************/
  51
  52 timing_iv* stm_modiv_create( int   nve,
  53                              int   nvs,
  54                              float vemax,
  55                              float vsmax,
  56                          char (*fnct)( void *data, float ve, float vs, float* ),
  57                              void  *data
  58                            )
  59 {
  60   timing_iv *iv;
  61   int        ne;
  62   int        ns;
  63   float      is;
  64   char       r;
  65
  66   iv = stm_modiv_alloc( nve, nvs );
  67
  68   for( ne=0 ; ne<nve ; ne++ )
  69     iv->VE[ne] = ((float)ne) * vemax / ((float)(nve-1));
  70
  71   for( ns=0 ; ns<nvs ; ns++ )
  72     iv->VS[ns] = ((float)ns) * vsmax / ((float)(nvs-1));
  73
  74   if( fnct ) {
  75     for( ne=0 ; ne<nve ; ne++ ) {
  76       for( ns=0 ; ns<nvs ; ns++ ) {
  77         r = fnct( data, iv->VE[ne], iv->VS[ns] , &is ) ;
  78         if( r ) {
  79           if( !finite( is ) )
  80             r = 0;
  81         }
  82         if( !r ) {
  83           stm_modiv_destroy( iv );
  84           return NULL;
  85         }
  86         stm_modiv_setis( iv, ne, ns, is );
  87       }
  88     }
  89   }
  90
  91   return iv;
  92 }
  93
  94 /******************************************************************************\
  95 Duplicate a model
  96 \******************************************************************************/
  97
  98 timing_iv* stm_modiv_duplicate( timing_iv *orig )
  99 {
 100   timing_iv *iv;
 101   int        ne;
 102   int        ns;
 103
 104   iv = stm_modiv_alloc( orig->NVE, orig->NVS );
 105
 106   for( ne=0 ; ne<orig->NVE ; ne++ )
 107     iv->VE[ne] = orig->VE[ne];
 108
 109   for( ns=0 ; ns<orig->NVS ; ns++ )
 110     iv->VS[ns] = orig->VS[ns];
 111
 112   for( ne=0 ; ne<orig->NVE ; ne++ ) {
 113     for( ns=0 ; ns<orig->NVS ; ns++ ) {
 114       stm_modiv_setis( iv, ne, ns, stm_modiv_getis( orig, ne, ns ) );
 115     }
 116   }
 117
 118   iv->IV_CONF.PCONF0    = orig->IV_CONF.PCONF0;
 119   iv->IV_CONF.PCONF1    = orig->IV_CONF.PCONF1;
 120   iv->IV_CONF.IRAP      = orig->IV_CONF.IRAP;
 121   iv->IV_CONF.CI        = orig->IV_CONF.CI;
 122   iv->IV_INPUT.VI       = orig->IV_INPUT.VI;
 123   iv->IV_INPUT.VF       = orig->IV_INPUT.VF;
 124   iv->IV_INPUT.VTH      = orig->IV_INPUT.VTH;
 125   iv->IV_INIT.VI        = orig->IV_INIT.VI;
 126   return iv;
 127 }
 128
 129 /******************************************************************************\
 130 Allocate a model
 131 \******************************************************************************/
 132
 133 timing_iv* stm_modiv_alloc( int nve, int nvs )
 134 {
 135   timing_iv *iv;
 136   int        ne;
 137   int        ns;
 138
 139   iv = (timing_iv*)mbkalloc( sizeof( timing_iv ) );
 140
 141   iv->NVE = nve;
 142   iv->NVS = nvs;
 143
 144   iv->VE  = (float*)mbkalloc( sizeof( float ) * nve );
 145   iv->VS  = (float*)mbkalloc( sizeof( float ) * nvs );
 146   iv->IS  = (float*)mbkalloc( sizeof( float ) * nve * nve );
 147
 148   iv->IV_CONF.PCONF0    = 0.0;
 149   iv->IV_CONF.PCONF1    = 0.0;
 150   iv->IV_CONF.IRAP      = 0.0;
 151   iv->IV_CONF.CI        = 0.0;
 152   iv->IV_INPUT.VI       = 0.0;
 153   iv->IV_INPUT.VF       = 0.0;
 154   iv->IV_INPUT.VTH      = 0.0;
 155
 156   for( ne=0 ; ne<nve ; ne++ )
 157     iv->VE[ne] = 0.0;
 158
 159   for( ns=0 ; ns<nvs ; ns++ )
 160     iv->VS[ns] = 0.0;
 161
 162   for( ne=0 ; ne<nve ; ne++ ) {
 163     for( ns=0 ; ns<nvs ; ns++ ) {
 164       stm_modiv_setis( iv, ne, ns, 0.0 );
 165     }
 166   }
 167
 168   return iv;
 169 }
 170
 171 /******************************************************************************\
 172 Allocate a model
 173 \******************************************************************************/
 174
 175 void stm_modiv_destroy( timing_iv *iv )
 176 {
 177   mbkfree( iv->VE );
 178   mbkfree( iv->VS );
 179   mbkfree( iv->IS );
 180   mbkfree( iv );
 181 }
 182
 183 /******************************************************************************\
 184 Parameter to evaluate conflict capacitance
 185 \******************************************************************************/
 186
 187 void stm_modiv_set_cf( timing_iv *iv,
 188                        float ci,
 189                        float p0,
 190                        float p1,
 191                        float irap
 192                      )
 193 {
 194   iv->IV_CONF.CI     = ci;
 195   iv->IV_CONF.PCONF0 = p0;
 196   iv->IV_CONF.PCONF1 = p1;
 197   iv->IV_CONF.IRAP   = irap;
 198 }
 199
 200 /******************************************************************************\
 201 Parameter to evaluate input slope
 202 \******************************************************************************/
 203
 204 void stm_modiv_set_in( timing_iv *iv,
 205                        float      vt,
 206                        float      vi,
 207                        float      vf,
 208                        float      vth
 209                      )
 210 {
 211   iv->IV_INPUT.VI  = vi ;
 212   iv->IV_INPUT.VF  = vf ;
 213   iv->IV_INPUT.VTH = vth ;
 214   iv->IV_INPUT.VT  = vt ;
 215 }
 216
 217 float stm_modiv_in_vi( timing_iv *iv )
 218 {
 219   return iv->IV_INPUT.VI;
 220 }
 221
 222 float stm_modiv_in_vf( timing_iv *iv )
 223 {
 224   return iv->IV_INPUT.VF;
 225 }
 226
 227 float stm_modiv_in_vth( timing_iv *iv )
 228 {
 229   return iv->IV_INPUT.VTH;
 230 }
 231
 232 float stm_modiv_in_vt( timing_iv *iv )
 233 {
 234   return iv->IV_INPUT.VT;
 235 }
 236
 237 /******************************************************************************\
 238 Parameter to evaluate initial state
 239 \******************************************************************************/
 240
 241 void stm_modiv_set_ti( timing_iv *iv, float vi )
 242 {
 243   iv->IV_INIT.VI = vi;
 244 }
 245
 246 float stm_modiv_ti_vi( timing_iv *iv )
 247 {
 248   return iv->IV_INIT.VI ;
 249 }