KLU Integration from scratch #5, devices

src/spicelib/devices/asrc/asrcinit.c

@@ -68,6 +68,12 @@ SPICEdev ASRCinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = NULL,
+    .DEVbindCSCComplex = NULL,
+    .DEVbindCSCComplexToReal = NULL,
+#endif
 };
 
 

src/spicelib/devices/bjt/Makefile.am

@@ -34,6 +34,9 @@ libbjt_la_SOURCES =	\
 	bjttrunc.c
 
 
+if KLU_WANTED
+libbjt_la_SOURCES += bjtbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bjt/bjtbindCSC.c

@@ -0,0 +1,155 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bjtdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BJTbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BJTmodel *model = (BJTmodel *)inModel ;
+    BJTinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BJT models */
+    for ( ; model != NULL ; model = BJTnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BJTinstances(model); here != NULL ; here = BJTnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BJTcolColPrimePtr, BJTcolColPrimeBinding, BJTcolNode, BJTcolPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTbaseBasePrimePtr, BJTbaseBasePrimeBinding, BJTbaseNode, BJTbasePrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitEmitPrimePtr, BJTemitEmitPrimeBinding, BJTemitNode, BJTemitPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolPrimeColPtr, BJTcolPrimeColBinding, BJTcolPrimeNode, BJTcolNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolPrimeBasePrimePtr, BJTcolPrimeBasePrimeBinding, BJTcolPrimeNode, BJTbasePrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolPrimeEmitPrimePtr, BJTcolPrimeEmitPrimeBinding, BJTcolPrimeNode, BJTemitPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTbasePrimeBasePtr, BJTbasePrimeBaseBinding, BJTbasePrimeNode, BJTbaseNode);
+            CREATE_KLU_BINDING_TABLE(BJTbasePrimeColPrimePtr, BJTbasePrimeColPrimeBinding, BJTbasePrimeNode, BJTcolPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTbasePrimeEmitPrimePtr, BJTbasePrimeEmitPrimeBinding, BJTbasePrimeNode, BJTemitPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitPrimeEmitPtr, BJTemitPrimeEmitBinding, BJTemitPrimeNode, BJTemitNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitPrimeColPrimePtr, BJTemitPrimeColPrimeBinding, BJTemitPrimeNode, BJTcolPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitPrimeBasePrimePtr, BJTemitPrimeBasePrimeBinding, BJTemitPrimeNode, BJTbasePrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolColPtr, BJTcolColBinding, BJTcolNode, BJTcolNode);
+            CREATE_KLU_BINDING_TABLE(BJTbaseBasePtr, BJTbaseBaseBinding, BJTbaseNode, BJTbaseNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitEmitPtr, BJTemitEmitBinding, BJTemitNode, BJTemitNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolPrimeColPrimePtr, BJTcolPrimeColPrimeBinding, BJTcolPrimeNode, BJTcolPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTbasePrimeBasePrimePtr, BJTbasePrimeBasePrimeBinding, BJTbasePrimeNode, BJTbasePrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTemitPrimeEmitPrimePtr, BJTemitPrimeEmitPrimeBinding, BJTemitPrimeNode, BJTemitPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTsubstSubstPtr, BJTsubstSubstBinding, BJTsubstNode, BJTsubstNode);
+            CREATE_KLU_BINDING_TABLE(BJTsubstConSubstPtr, BJTsubstConSubstBinding, BJTsubstConNode, BJTsubstNode);
+            CREATE_KLU_BINDING_TABLE(BJTsubstSubstConPtr, BJTsubstSubstConBinding, BJTsubstNode, BJTsubstConNode);
+            CREATE_KLU_BINDING_TABLE(BJTbaseColPrimePtr, BJTbaseColPrimeBinding, BJTbaseNode, BJTcolPrimeNode);
+            CREATE_KLU_BINDING_TABLE(BJTcolPrimeBasePtr, BJTcolPrimeBaseBinding, BJTcolPrimeNode, BJTbaseNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BJTbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BJTmodel *model = (BJTmodel *)inModel ;
+    BJTinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BJT models */
+    for ( ; model != NULL ; model = BJTnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BJTinstances(model); here != NULL ; here = BJTnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolColPrimePtr, BJTcolColPrimeBinding, BJTcolNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbaseBasePrimePtr, BJTbaseBasePrimeBinding, BJTbaseNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitEmitPrimePtr, BJTemitEmitPrimeBinding, BJTemitNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolPrimeColPtr, BJTcolPrimeColBinding, BJTcolPrimeNode, BJTcolNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolPrimeBasePrimePtr, BJTcolPrimeBasePrimeBinding, BJTcolPrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolPrimeEmitPrimePtr, BJTcolPrimeEmitPrimeBinding, BJTcolPrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbasePrimeBasePtr, BJTbasePrimeBaseBinding, BJTbasePrimeNode, BJTbaseNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbasePrimeColPrimePtr, BJTbasePrimeColPrimeBinding, BJTbasePrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbasePrimeEmitPrimePtr, BJTbasePrimeEmitPrimeBinding, BJTbasePrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitPrimeEmitPtr, BJTemitPrimeEmitBinding, BJTemitPrimeNode, BJTemitNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitPrimeColPrimePtr, BJTemitPrimeColPrimeBinding, BJTemitPrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitPrimeBasePrimePtr, BJTemitPrimeBasePrimeBinding, BJTemitPrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolColPtr, BJTcolColBinding, BJTcolNode, BJTcolNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbaseBasePtr, BJTbaseBaseBinding, BJTbaseNode, BJTbaseNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitEmitPtr, BJTemitEmitBinding, BJTemitNode, BJTemitNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolPrimeColPrimePtr, BJTcolPrimeColPrimeBinding, BJTcolPrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbasePrimeBasePrimePtr, BJTbasePrimeBasePrimeBinding, BJTbasePrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTemitPrimeEmitPrimePtr, BJTemitPrimeEmitPrimeBinding, BJTemitPrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTsubstSubstPtr, BJTsubstSubstBinding, BJTsubstNode, BJTsubstNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTsubstConSubstPtr, BJTsubstConSubstBinding, BJTsubstConNode, BJTsubstNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTsubstSubstConPtr, BJTsubstSubstConBinding, BJTsubstNode, BJTsubstConNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTbaseColPrimePtr, BJTbaseColPrimeBinding, BJTbaseNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BJTcolPrimeBasePtr, BJTcolPrimeBaseBinding, BJTcolPrimeNode, BJTbaseNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BJTbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BJTmodel *model = (BJTmodel *)inModel ;
+    BJTinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BJT models */
+    for ( ; model != NULL ; model = BJTnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BJTinstances(model); here != NULL ; here = BJTnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolColPrimePtr, BJTcolColPrimeBinding, BJTcolNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbaseBasePrimePtr, BJTbaseBasePrimeBinding, BJTbaseNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitEmitPrimePtr, BJTemitEmitPrimeBinding, BJTemitNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolPrimeColPtr, BJTcolPrimeColBinding, BJTcolPrimeNode, BJTcolNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolPrimeBasePrimePtr, BJTcolPrimeBasePrimeBinding, BJTcolPrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolPrimeEmitPrimePtr, BJTcolPrimeEmitPrimeBinding, BJTcolPrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbasePrimeBasePtr, BJTbasePrimeBaseBinding, BJTbasePrimeNode, BJTbaseNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbasePrimeColPrimePtr, BJTbasePrimeColPrimeBinding, BJTbasePrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbasePrimeEmitPrimePtr, BJTbasePrimeEmitPrimeBinding, BJTbasePrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitPrimeEmitPtr, BJTemitPrimeEmitBinding, BJTemitPrimeNode, BJTemitNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitPrimeColPrimePtr, BJTemitPrimeColPrimeBinding, BJTemitPrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitPrimeBasePrimePtr, BJTemitPrimeBasePrimeBinding, BJTemitPrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolColPtr, BJTcolColBinding, BJTcolNode, BJTcolNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbaseBasePtr, BJTbaseBaseBinding, BJTbaseNode, BJTbaseNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitEmitPtr, BJTemitEmitBinding, BJTemitNode, BJTemitNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolPrimeColPrimePtr, BJTcolPrimeColPrimeBinding, BJTcolPrimeNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbasePrimeBasePrimePtr, BJTbasePrimeBasePrimeBinding, BJTbasePrimeNode, BJTbasePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTemitPrimeEmitPrimePtr, BJTemitPrimeEmitPrimeBinding, BJTemitPrimeNode, BJTemitPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTsubstSubstPtr, BJTsubstSubstBinding, BJTsubstNode, BJTsubstNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTsubstConSubstPtr, BJTsubstConSubstBinding, BJTsubstConNode, BJTsubstNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTsubstSubstConPtr, BJTsubstSubstConBinding, BJTsubstNode, BJTsubstConNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTbaseColPrimePtr, BJTbaseColPrimeBinding, BJTbaseNode, BJTcolPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BJTcolPrimeBasePtr, BJTcolPrimeBaseBinding, BJTcolPrimeNode, BJTbaseNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bjt/bjtdefs.h

@@ -310,6 +310,33 @@ typedef struct sBJTinstance {
 #endif /*NONOISE*/
 /* the above to avoid allocating memory when it is not needed */
 
+#ifdef KLU
+    BindElement *BJTcolColPrimeBinding ;
+    BindElement *BJTbaseBasePrimeBinding ;
+    BindElement *BJTemitEmitPrimeBinding ;
+    BindElement *BJTcolPrimeColBinding ;
+    BindElement *BJTcolPrimeBasePrimeBinding ;
+    BindElement *BJTcolPrimeEmitPrimeBinding ;
+    BindElement *BJTbasePrimeBaseBinding ;
+    BindElement *BJTbasePrimeColPrimeBinding ;
+    BindElement *BJTbasePrimeEmitPrimeBinding ;
+    BindElement *BJTemitPrimeEmitBinding ;
+    BindElement *BJTemitPrimeColPrimeBinding ;
+    BindElement *BJTemitPrimeBasePrimeBinding ;
+    BindElement *BJTcolColBinding ;
+    BindElement *BJTbaseBaseBinding ;
+    BindElement *BJTemitEmitBinding ;
+    BindElement *BJTcolPrimeColPrimeBinding ;
+    BindElement *BJTbasePrimeBasePrimeBinding ;
+    BindElement *BJTemitPrimeEmitPrimeBinding ;
+    BindElement *BJTsubstSubstBinding ;
+    BindElement *BJTsubstConSubstBinding ;
+    BindElement *BJTsubstSubstConBinding ;
+    BindElement *BJTsubstConSubstConBinding ;
+    BindElement *BJTbaseColPrimeBinding ;
+    BindElement *BJTcolPrimeBaseBinding ;
+#endif
+
 } BJTinstance ;
 
 /* entries in the state vector for bjt: */

src/spicelib/devices/bjt/bjtext.h

@@ -32,3 +32,9 @@ extern int BJTdSetup(GENmodel*, CKTcircuit*);
 extern int BJTsoaCheck(CKTcircuit *, GENmodel *);
 
 #endif
+
+#ifdef KLU
+extern int BJTbindCSC (GENmodel*, CKTcircuit*) ;
+extern int BJTbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BJTbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bjt/bjtinit.c

@@ -66,6 +66,12 @@ SPICEdev BJTinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BJTbindCSC,
+    .DEVbindCSCComplex = BJTbindCSCComplex,
+    .DEVbindCSCComplexToReal = BJTbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim1/Makefile.am

@@ -28,7 +28,11 @@ libbsim1_la_SOURCES =	\
 	bsim1itf.h
 
 
+if KLU_WANTED
+libbsim1_la_SOURCES += b1bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/bsim1/b1bindCSC.c

@@ -0,0 +1,152 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim1def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B1bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B1model *model = (B1model *)inModel ;
+    B1instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B1 models */
+    for ( ; model != NULL ; model = B1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B1instances(model); here != NULL ; here = B1nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(B1DdPtr, B1DdBinding, B1dNode, B1dNode);
+            CREATE_KLU_BINDING_TABLE(B1GgPtr, B1GgBinding, B1gNode, B1gNode);
+            CREATE_KLU_BINDING_TABLE(B1SsPtr, B1SsBinding, B1sNode, B1sNode);
+            CREATE_KLU_BINDING_TABLE(B1BbPtr, B1BbBinding, B1bNode, B1bNode);
+            CREATE_KLU_BINDING_TABLE(B1DPdpPtr, B1DPdpBinding, B1dNodePrime, B1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1SPspPtr, B1SPspBinding, B1sNodePrime, B1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1DdpPtr, B1DdpBinding, B1dNode, B1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1GbPtr, B1GbBinding, B1gNode, B1bNode);
+            CREATE_KLU_BINDING_TABLE(B1GdpPtr, B1GdpBinding, B1gNode, B1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1GspPtr, B1GspBinding, B1gNode, B1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1SspPtr, B1SspBinding, B1sNode, B1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1BdpPtr, B1BdpBinding, B1bNode, B1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1BspPtr, B1BspBinding, B1bNode, B1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1DPspPtr, B1DPspBinding, B1dNodePrime, B1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B1DPdPtr, B1DPdBinding, B1dNodePrime, B1dNode);
+            CREATE_KLU_BINDING_TABLE(B1BgPtr, B1BgBinding, B1bNode, B1gNode);
+            CREATE_KLU_BINDING_TABLE(B1DPgPtr, B1DPgBinding, B1dNodePrime, B1gNode);
+            CREATE_KLU_BINDING_TABLE(B1SPgPtr, B1SPgBinding, B1sNodePrime, B1gNode);
+            CREATE_KLU_BINDING_TABLE(B1SPsPtr, B1SPsBinding, B1sNodePrime, B1sNode);
+            CREATE_KLU_BINDING_TABLE(B1DPbPtr, B1DPbBinding, B1dNodePrime, B1bNode);
+            CREATE_KLU_BINDING_TABLE(B1SPbPtr, B1SPbBinding, B1sNodePrime, B1bNode);
+            CREATE_KLU_BINDING_TABLE(B1SPdpPtr, B1SPdpBinding, B1sNodePrime, B1dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B1bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B1model *model = (B1model *)inModel ;
+    B1instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B1 models */
+    for ( ; model != NULL ; model = B1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B1instances(model); here != NULL ; here = B1nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DdPtr, B1DdBinding, B1dNode, B1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1GgPtr, B1GgBinding, B1gNode, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SsPtr, B1SsBinding, B1sNode, B1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1BbPtr, B1BbBinding, B1bNode, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DPdpPtr, B1DPdpBinding, B1dNodePrime, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SPspPtr, B1SPspBinding, B1sNodePrime, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DdpPtr, B1DdpBinding, B1dNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1GbPtr, B1GbBinding, B1gNode, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1GdpPtr, B1GdpBinding, B1gNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1GspPtr, B1GspBinding, B1gNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SspPtr, B1SspBinding, B1sNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1BdpPtr, B1BdpBinding, B1bNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1BspPtr, B1BspBinding, B1bNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DPspPtr, B1DPspBinding, B1dNodePrime, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DPdPtr, B1DPdBinding, B1dNodePrime, B1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1BgPtr, B1BgBinding, B1bNode, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DPgPtr, B1DPgBinding, B1dNodePrime, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SPgPtr, B1SPgBinding, B1sNodePrime, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SPsPtr, B1SPsBinding, B1sNodePrime, B1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1DPbPtr, B1DPbBinding, B1dNodePrime, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SPbPtr, B1SPbBinding, B1sNodePrime, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B1SPdpPtr, B1SPdpBinding, B1sNodePrime, B1dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B1bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B1model *model = (B1model *)inModel ;
+    B1instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B1 models */
+    for ( ; model != NULL ; model = B1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B1instances(model); here != NULL ; here = B1nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DdPtr, B1DdBinding, B1dNode, B1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1GgPtr, B1GgBinding, B1gNode, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SsPtr, B1SsBinding, B1sNode, B1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1BbPtr, B1BbBinding, B1bNode, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DPdpPtr, B1DPdpBinding, B1dNodePrime, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SPspPtr, B1SPspBinding, B1sNodePrime, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DdpPtr, B1DdpBinding, B1dNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1GbPtr, B1GbBinding, B1gNode, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1GdpPtr, B1GdpBinding, B1gNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1GspPtr, B1GspBinding, B1gNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SspPtr, B1SspBinding, B1sNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1BdpPtr, B1BdpBinding, B1bNode, B1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1BspPtr, B1BspBinding, B1bNode, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DPspPtr, B1DPspBinding, B1dNodePrime, B1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DPdPtr, B1DPdBinding, B1dNodePrime, B1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1BgPtr, B1BgBinding, B1bNode, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DPgPtr, B1DPgBinding, B1dNodePrime, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SPgPtr, B1SPgBinding, B1sNodePrime, B1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SPsPtr, B1SPsBinding, B1sNodePrime, B1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1DPbPtr, B1DPbBinding, B1dNodePrime, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SPbPtr, B1SPbBinding, B1sNodePrime, B1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B1SPdpPtr, B1SPdpBinding, B1sNodePrime, B1dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim1/bsim1def.h

@@ -168,6 +168,30 @@ typedef struct sBSIM1instance {
 	double **B1nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *B1DdBinding ;
+    BindElement *B1GgBinding ;
+    BindElement *B1SsBinding ;
+    BindElement *B1BbBinding ;
+    BindElement *B1DPdpBinding ;
+    BindElement *B1SPspBinding ;
+    BindElement *B1DdpBinding ;
+    BindElement *B1GbBinding ;
+    BindElement *B1GdpBinding ;
+    BindElement *B1GspBinding ;
+    BindElement *B1SspBinding ;
+    BindElement *B1BdpBinding ;
+    BindElement *B1BspBinding ;
+    BindElement *B1DPspBinding ;
+    BindElement *B1DPdBinding ;
+    BindElement *B1BgBinding ;
+    BindElement *B1DPgBinding ;
+    BindElement *B1SPgBinding ;
+    BindElement *B1SPsBinding ;
+    BindElement *B1DPbBinding ;
+    BindElement *B1SPbBinding ;
+    BindElement *B1SPdpBinding ;
+#endif
 
 } B1instance ;
 

src/spicelib/devices/bsim1/bsim1ext.h

@@ -26,3 +26,9 @@ extern int B1temp(GENmodel*,CKTcircuit*);
 extern int B1trunc(GENmodel*,CKTcircuit*,double*);
 extern int B1disto(int,GENmodel*,CKTcircuit*);
 extern int B1dSetup(GENmodel*, register CKTcircuit*);
+
+#ifdef KLU
+extern int B1bindCSC (GENmodel*, CKTcircuit*) ;
+extern int B1bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B1bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim1/bsim1init.c

@@ -66,6 +66,12 @@ SPICEdev B1info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B1bindCSC,
+    .DEVbindCSCComplex = B1bindCSCComplex,
+    .DEVbindCSCComplexToReal = B1bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim2/Makefile.am

@@ -26,6 +26,9 @@ libbsim2_la_SOURCES =	\
 	bsim2itf.h
 
 
+if KLU_WANTED
+libbsim2_la_SOURCES += b2bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim2/b2bindCSC.c

@@ -0,0 +1,152 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim2def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B2bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B2model *model = (B2model *)inModel ;
+    B2instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B2 models */
+    for ( ; model != NULL ; model = B2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B2instances(model); here != NULL ; here = B2nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(B2DdPtr, B2DdBinding, B2dNode, B2dNode);
+            CREATE_KLU_BINDING_TABLE(B2GgPtr, B2GgBinding, B2gNode, B2gNode);
+            CREATE_KLU_BINDING_TABLE(B2SsPtr, B2SsBinding, B2sNode, B2sNode);
+            CREATE_KLU_BINDING_TABLE(B2BbPtr, B2BbBinding, B2bNode, B2bNode);
+            CREATE_KLU_BINDING_TABLE(B2DPdpPtr, B2DPdpBinding, B2dNodePrime, B2dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2SPspPtr, B2SPspBinding, B2sNodePrime, B2sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2DdpPtr, B2DdpBinding, B2dNode, B2dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2GbPtr, B2GbBinding, B2gNode, B2bNode);
+            CREATE_KLU_BINDING_TABLE(B2GdpPtr, B2GdpBinding, B2gNode, B2dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2GspPtr, B2GspBinding, B2gNode, B2sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2SspPtr, B2SspBinding, B2sNode, B2sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2BdpPtr, B2BdpBinding, B2bNode, B2dNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2BspPtr, B2BspBinding, B2bNode, B2sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2DPspPtr, B2DPspBinding, B2dNodePrime, B2sNodePrime);
+            CREATE_KLU_BINDING_TABLE(B2DPdPtr, B2DPdBinding, B2dNodePrime, B2dNode);
+            CREATE_KLU_BINDING_TABLE(B2BgPtr, B2BgBinding, B2bNode, B2gNode);
+            CREATE_KLU_BINDING_TABLE(B2DPgPtr, B2DPgBinding, B2dNodePrime, B2gNode);
+            CREATE_KLU_BINDING_TABLE(B2SPgPtr, B2SPgBinding, B2sNodePrime, B2gNode);
+            CREATE_KLU_BINDING_TABLE(B2SPsPtr, B2SPsBinding, B2sNodePrime, B2sNode);
+            CREATE_KLU_BINDING_TABLE(B2DPbPtr, B2DPbBinding, B2dNodePrime, B2bNode);
+            CREATE_KLU_BINDING_TABLE(B2SPbPtr, B2SPbBinding, B2sNodePrime, B2bNode);
+            CREATE_KLU_BINDING_TABLE(B2SPdpPtr, B2SPdpBinding, B2sNodePrime, B2dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B2bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B2model *model = (B2model *)inModel ;
+    B2instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B2 models */
+    for ( ; model != NULL ; model = B2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B2instances(model); here != NULL ; here = B2nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DdPtr, B2DdBinding, B2dNode, B2dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2GgPtr, B2GgBinding, B2gNode, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SsPtr, B2SsBinding, B2sNode, B2sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2BbPtr, B2BbBinding, B2bNode, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DPdpPtr, B2DPdpBinding, B2dNodePrime, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SPspPtr, B2SPspBinding, B2sNodePrime, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DdpPtr, B2DdpBinding, B2dNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2GbPtr, B2GbBinding, B2gNode, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2GdpPtr, B2GdpBinding, B2gNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2GspPtr, B2GspBinding, B2gNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SspPtr, B2SspBinding, B2sNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2BdpPtr, B2BdpBinding, B2bNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2BspPtr, B2BspBinding, B2bNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DPspPtr, B2DPspBinding, B2dNodePrime, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DPdPtr, B2DPdBinding, B2dNodePrime, B2dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2BgPtr, B2BgBinding, B2bNode, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DPgPtr, B2DPgBinding, B2dNodePrime, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SPgPtr, B2SPgBinding, B2sNodePrime, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SPsPtr, B2SPsBinding, B2sNodePrime, B2sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2DPbPtr, B2DPbBinding, B2dNodePrime, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SPbPtr, B2SPbBinding, B2sNodePrime, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B2SPdpPtr, B2SPdpBinding, B2sNodePrime, B2dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B2bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B2model *model = (B2model *)inModel ;
+    B2instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B2 models */
+    for ( ; model != NULL ; model = B2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B2instances(model); here != NULL ; here = B2nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DdPtr, B2DdBinding, B2dNode, B2dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2GgPtr, B2GgBinding, B2gNode, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SsPtr, B2SsBinding, B2sNode, B2sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2BbPtr, B2BbBinding, B2bNode, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DPdpPtr, B2DPdpBinding, B2dNodePrime, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SPspPtr, B2SPspBinding, B2sNodePrime, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DdpPtr, B2DdpBinding, B2dNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2GbPtr, B2GbBinding, B2gNode, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2GdpPtr, B2GdpBinding, B2gNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2GspPtr, B2GspBinding, B2gNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SspPtr, B2SspBinding, B2sNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2BdpPtr, B2BdpBinding, B2bNode, B2dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2BspPtr, B2BspBinding, B2bNode, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DPspPtr, B2DPspBinding, B2dNodePrime, B2sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DPdPtr, B2DPdBinding, B2dNodePrime, B2dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2BgPtr, B2BgBinding, B2bNode, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DPgPtr, B2DPgBinding, B2dNodePrime, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SPgPtr, B2SPgBinding, B2sNodePrime, B2gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SPsPtr, B2SPsBinding, B2sNodePrime, B2sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2DPbPtr, B2DPbBinding, B2dNodePrime, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SPbPtr, B2SPbBinding, B2sNodePrime, B2bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B2SPdpPtr, B2SPdpBinding, B2sNodePrime, B2dNodePrime);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim2/bsim2def.h

@@ -178,6 +178,31 @@ typedef struct sBSIM2instance {
 
 #define B2numStates 35           
 
+#ifdef KLU
+    BindElement *B2DdBinding ;
+    BindElement *B2GgBinding ;
+    BindElement *B2SsBinding ;
+    BindElement *B2BbBinding ;
+    BindElement *B2DPdpBinding ;
+    BindElement *B2SPspBinding ;
+    BindElement *B2DdpBinding ;
+    BindElement *B2GbBinding ;
+    BindElement *B2GdpBinding ;
+    BindElement *B2GspBinding ;
+    BindElement *B2SspBinding ;
+    BindElement *B2BdpBinding ;
+    BindElement *B2BspBinding ;
+    BindElement *B2DPspBinding ;
+    BindElement *B2DPdBinding ;
+    BindElement *B2BgBinding ;
+    BindElement *B2DPgBinding ;
+    BindElement *B2SPgBinding ;
+    BindElement *B2SPsBinding ;
+    BindElement *B2DPbBinding ;
+    BindElement *B2SPbBinding ;
+    BindElement *B2SPdpBinding ;
+#endif
+
 } B2instance ;
 
 struct bsim2SizeDependParam

src/spicelib/devices/bsim2/bsim2ext.h

@@ -22,3 +22,9 @@ extern int B2setup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
 extern int B2unsetup(GENmodel*,CKTcircuit*);
 extern int B2temp(GENmodel*,CKTcircuit*);
 extern int B2trunc(GENmodel*,CKTcircuit*,double*);
+
+#ifdef KLU
+extern int B2bindCSC (GENmodel*, CKTcircuit*) ;
+extern int B2bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B2bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim2/bsim2init.c

@@ -66,6 +66,12 @@ SPICEdev B2info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B2bindCSC,
+    .DEVbindCSCComplex = B2bindCSCComplex,
+    .DEVbindCSCComplexToReal = B2bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3/Makefile.am

@@ -27,6 +27,9 @@ libbsim3_la_SOURCES =	\
 	bsim3itf.h
 
 
+if KLU_WANTED
+libbsim3_la_SOURCES += b3bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3/b3bindCSC.c

@@ -0,0 +1,179 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim3def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM3bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3model *model = (BSIM3model *)inModel ;
+    BSIM3instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM3 models */
+    for ( ; model != NULL ; model = BSIM3nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3instances(model); here != NULL ; here = BSIM3nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM3DdPtr, BSIM3DdBinding, BSIM3dNode, BSIM3dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3GgPtr, BSIM3GgBinding, BSIM3gNode, BSIM3gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SsPtr, BSIM3SsBinding, BSIM3sNode, BSIM3sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3BbPtr, BSIM3BbBinding, BSIM3bNode, BSIM3bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPdpPtr, BSIM3DPdpBinding, BSIM3dNodePrime, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPspPtr, BSIM3SPspBinding, BSIM3sNodePrime, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3DdpPtr, BSIM3DdpBinding, BSIM3dNode, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3GbPtr, BSIM3GbBinding, BSIM3gNode, BSIM3bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3GdpPtr, BSIM3GdpBinding, BSIM3gNode, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3GspPtr, BSIM3GspBinding, BSIM3gNode, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3SspPtr, BSIM3SspBinding, BSIM3sNode, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3BdpPtr, BSIM3BdpBinding, BSIM3bNode, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3BspPtr, BSIM3BspBinding, BSIM3bNode, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPspPtr, BSIM3DPspBinding, BSIM3dNodePrime, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPdPtr, BSIM3DPdBinding, BSIM3dNodePrime, BSIM3dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3BgPtr, BSIM3BgBinding, BSIM3bNode, BSIM3gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPgPtr, BSIM3DPgBinding, BSIM3dNodePrime, BSIM3gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPgPtr, BSIM3SPgBinding, BSIM3sNodePrime, BSIM3gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPsPtr, BSIM3SPsBinding, BSIM3sNodePrime, BSIM3sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPbPtr, BSIM3DPbBinding, BSIM3dNodePrime, BSIM3bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPbPtr, BSIM3SPbBinding, BSIM3sNodePrime, BSIM3bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPdpPtr, BSIM3SPdpBinding, BSIM3sNodePrime, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3QqPtr, BSIM3QqBinding, BSIM3qNode, BSIM3qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3QdpPtr, BSIM3QdpBinding, BSIM3qNode, BSIM3dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3QgPtr, BSIM3QgBinding, BSIM3qNode, BSIM3gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3QspPtr, BSIM3QspBinding, BSIM3qNode, BSIM3sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3QbPtr, BSIM3QbBinding, BSIM3qNode, BSIM3bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3DPqPtr, BSIM3DPqBinding, BSIM3dNodePrime, BSIM3qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3GqPtr, BSIM3GqBinding, BSIM3gNode, BSIM3qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3SPqPtr, BSIM3SPqBinding, BSIM3sNodePrime, BSIM3qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3BqPtr, BSIM3BqBinding, BSIM3bNode, BSIM3qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3model *model = (BSIM3model *)inModel ;
+    BSIM3instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3 models */
+    for ( ; model != NULL ; model = BSIM3nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3instances(model); here != NULL ; here = BSIM3nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DdPtr, BSIM3DdBinding, BSIM3dNode, BSIM3dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3GgPtr, BSIM3GgBinding, BSIM3gNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SsPtr, BSIM3SsBinding, BSIM3sNode, BSIM3sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3BbPtr, BSIM3BbBinding, BSIM3bNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPdpPtr, BSIM3DPdpBinding, BSIM3dNodePrime, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPspPtr, BSIM3SPspBinding, BSIM3sNodePrime, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DdpPtr, BSIM3DdpBinding, BSIM3dNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3GbPtr, BSIM3GbBinding, BSIM3gNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3GdpPtr, BSIM3GdpBinding, BSIM3gNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3GspPtr, BSIM3GspBinding, BSIM3gNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SspPtr, BSIM3SspBinding, BSIM3sNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3BdpPtr, BSIM3BdpBinding, BSIM3bNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3BspPtr, BSIM3BspBinding, BSIM3bNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPspPtr, BSIM3DPspBinding, BSIM3dNodePrime, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPdPtr, BSIM3DPdBinding, BSIM3dNodePrime, BSIM3dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3BgPtr, BSIM3BgBinding, BSIM3bNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPgPtr, BSIM3DPgBinding, BSIM3dNodePrime, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPgPtr, BSIM3SPgBinding, BSIM3sNodePrime, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPsPtr, BSIM3SPsBinding, BSIM3sNodePrime, BSIM3sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPbPtr, BSIM3DPbBinding, BSIM3dNodePrime, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPbPtr, BSIM3SPbBinding, BSIM3sNodePrime, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPdpPtr, BSIM3SPdpBinding, BSIM3sNodePrime, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3QqPtr, BSIM3QqBinding, BSIM3qNode, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3QdpPtr, BSIM3QdpBinding, BSIM3qNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3QgPtr, BSIM3QgBinding, BSIM3qNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3QspPtr, BSIM3QspBinding, BSIM3qNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3QbPtr, BSIM3QbBinding, BSIM3qNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3DPqPtr, BSIM3DPqBinding, BSIM3dNodePrime, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3GqPtr, BSIM3GqBinding, BSIM3gNode, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3SPqPtr, BSIM3SPqBinding, BSIM3sNodePrime, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3BqPtr, BSIM3BqBinding, BSIM3bNode, BSIM3qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3model *model = (BSIM3model *)inModel ;
+    BSIM3instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3 models */
+    for ( ; model != NULL ; model = BSIM3nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3instances(model); here != NULL ; here = BSIM3nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DdPtr, BSIM3DdBinding, BSIM3dNode, BSIM3dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3GgPtr, BSIM3GgBinding, BSIM3gNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SsPtr, BSIM3SsBinding, BSIM3sNode, BSIM3sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3BbPtr, BSIM3BbBinding, BSIM3bNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPdpPtr, BSIM3DPdpBinding, BSIM3dNodePrime, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPspPtr, BSIM3SPspBinding, BSIM3sNodePrime, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DdpPtr, BSIM3DdpBinding, BSIM3dNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3GbPtr, BSIM3GbBinding, BSIM3gNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3GdpPtr, BSIM3GdpBinding, BSIM3gNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3GspPtr, BSIM3GspBinding, BSIM3gNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SspPtr, BSIM3SspBinding, BSIM3sNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3BdpPtr, BSIM3BdpBinding, BSIM3bNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3BspPtr, BSIM3BspBinding, BSIM3bNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPspPtr, BSIM3DPspBinding, BSIM3dNodePrime, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPdPtr, BSIM3DPdBinding, BSIM3dNodePrime, BSIM3dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3BgPtr, BSIM3BgBinding, BSIM3bNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPgPtr, BSIM3DPgBinding, BSIM3dNodePrime, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPgPtr, BSIM3SPgBinding, BSIM3sNodePrime, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPsPtr, BSIM3SPsBinding, BSIM3sNodePrime, BSIM3sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPbPtr, BSIM3DPbBinding, BSIM3dNodePrime, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPbPtr, BSIM3SPbBinding, BSIM3sNodePrime, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPdpPtr, BSIM3SPdpBinding, BSIM3sNodePrime, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3QqPtr, BSIM3QqBinding, BSIM3qNode, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3QdpPtr, BSIM3QdpBinding, BSIM3qNode, BSIM3dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3QgPtr, BSIM3QgBinding, BSIM3qNode, BSIM3gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3QspPtr, BSIM3QspBinding, BSIM3qNode, BSIM3sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3QbPtr, BSIM3QbBinding, BSIM3qNode, BSIM3bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3DPqPtr, BSIM3DPqBinding, BSIM3dNodePrime, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3GqPtr, BSIM3GqBinding, BSIM3gNode, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3SPqPtr, BSIM3SPqBinding, BSIM3sNodePrime, BSIM3qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3BqPtr, BSIM3BqBinding, BSIM3bNode, BSIM3qNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3/bsim3def.h

@@ -261,6 +261,40 @@ typedef struct sBSIM3instance
         double **BSIM3nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM3DdBinding ;
+    BindElement *BSIM3GgBinding ;
+    BindElement *BSIM3SsBinding ;
+    BindElement *BSIM3BbBinding ;
+    BindElement *BSIM3DPdpBinding ;
+    BindElement *BSIM3SPspBinding ;
+    BindElement *BSIM3DdpBinding ;
+    BindElement *BSIM3GbBinding ;
+    BindElement *BSIM3GdpBinding ;
+    BindElement *BSIM3GspBinding ;
+    BindElement *BSIM3SspBinding ;
+    BindElement *BSIM3BdpBinding ;
+    BindElement *BSIM3BspBinding ;
+    BindElement *BSIM3DPspBinding ;
+    BindElement *BSIM3DPdBinding ;
+    BindElement *BSIM3BgBinding ;
+    BindElement *BSIM3DPgBinding ;
+    BindElement *BSIM3SPgBinding ;
+    BindElement *BSIM3SPsBinding ;
+    BindElement *BSIM3DPbBinding ;
+    BindElement *BSIM3SPbBinding ;
+    BindElement *BSIM3SPdpBinding ;
+    BindElement *BSIM3QqBinding ;
+    BindElement *BSIM3QdpBinding ;
+    BindElement *BSIM3QgBinding ;
+    BindElement *BSIM3QspBinding ;
+    BindElement *BSIM3QbBinding ;
+    BindElement *BSIM3DPqBinding ;
+    BindElement *BSIM3GqBinding ;
+    BindElement *BSIM3SPqBinding ;
+    BindElement *BSIM3BqBinding ;
+#endif
+
 } BSIM3instance ;
 
 struct bsim3SizeDependParam

src/spicelib/devices/bsim3/bsim3ext.h

@@ -27,3 +27,9 @@ extern int BSIM3trunc(GENmodel*,CKTcircuit*,double*);
 extern int BSIM3noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int BSIM3unsetup(GENmodel*,CKTcircuit*);
 extern int BSIM3soaCheck(CKTcircuit *, GENmodel *);
+
+#ifdef KLU
+extern int BSIM3bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM3bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM3bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3/bsim3init.c

@@ -66,6 +66,12 @@ SPICEdev BSIM3info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM3bindCSC,
+    .DEVbindCSCComplex = BSIM3bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM3bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3soi_dd/Makefile.am

@@ -25,6 +25,9 @@ libbsim3soidd_la_SOURCES = \
 	b3soidditf.h
 
 
+if KLU_WANTED
+libbsim3soidd_la_SOURCES += b3soiddbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3soi_dd/b3soiddbindCSC.c

@@ -0,0 +1,410 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "b3soidddef.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B3SOIDDbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIDDmodel *model = (B3SOIDDmodel *)inModel ;
+    B3SOIDDinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B3SOIDD models */
+    for ( ; model != NULL ; model = B3SOIDDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIDDinstances(model); here != NULL ; here = B3SOIDDnextInstance(here))
+        {
+            if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0 != 0.0))
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTemptempPtr, B3SOIDDTemptempBinding, B3SOIDDtempNode, B3SOIDDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTempdpPtr, B3SOIDDTempdpBinding, B3SOIDDtempNode, B3SOIDDdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTempspPtr, B3SOIDDTempspBinding, B3SOIDDtempNode, B3SOIDDsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTempgPtr, B3SOIDDTempgBinding, B3SOIDDtempNode, B3SOIDDgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTempbPtr, B3SOIDDTempbBinding, B3SOIDDtempNode, B3SOIDDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDTempePtr, B3SOIDDTempeBinding, B3SOIDDtempNode, B3SOIDDeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDGtempPtr, B3SOIDDGtempBinding, B3SOIDDgNode, B3SOIDDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDPtempPtr, B3SOIDDDPtempBinding, B3SOIDDdNodePrime, B3SOIDDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDSPtempPtr, B3SOIDDSPtempBinding, B3SOIDDsNodePrime, B3SOIDDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDEtempPtr, B3SOIDDEtempBinding, B3SOIDDeNode, B3SOIDDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDBtempPtr, B3SOIDDBtempBinding, B3SOIDDbNode, B3SOIDDtempNode);
+                if (here->B3SOIDDbodyMod == 1)
+                {
+                    CREATE_KLU_BINDING_TABLE(B3SOIDDPtempPtr, B3SOIDDPtempBinding, B3SOIDDpNode, B3SOIDDtempNode);
+                }
+            }
+            if (here->B3SOIDDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIDDbodyMod == 1)
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIDDBpPtr, B3SOIDDBpBinding, B3SOIDDbNode, B3SOIDDpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPbPtr, B3SOIDDPbBinding, B3SOIDDpNode, B3SOIDDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPpPtr, B3SOIDDPpBinding, B3SOIDDpNode, B3SOIDDpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPgPtr, B3SOIDDPgBinding, B3SOIDDpNode, B3SOIDDgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPdpPtr, B3SOIDDPdpBinding, B3SOIDDpNode, B3SOIDDdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPspPtr, B3SOIDDPspBinding, B3SOIDDpNode, B3SOIDDsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDPePtr, B3SOIDDPeBinding, B3SOIDDpNode, B3SOIDDeNode);
+            }
+            CREATE_KLU_BINDING_TABLE(B3SOIDDEgPtr, B3SOIDDEgBinding, B3SOIDDeNode, B3SOIDDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDEdpPtr, B3SOIDDEdpBinding, B3SOIDDeNode, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDEspPtr, B3SOIDDEspBinding, B3SOIDDeNode, B3SOIDDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDGePtr, B3SOIDDGeBinding, B3SOIDDgNode, B3SOIDDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPePtr, B3SOIDDDPeBinding, B3SOIDDdNodePrime, B3SOIDDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPePtr, B3SOIDDSPeBinding, B3SOIDDsNodePrime, B3SOIDDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDEbPtr, B3SOIDDEbBinding, B3SOIDDeNode, B3SOIDDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDGbPtr, B3SOIDDGbBinding, B3SOIDDgNode, B3SOIDDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPbPtr, B3SOIDDDPbBinding, B3SOIDDdNodePrime, B3SOIDDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPbPtr, B3SOIDDSPbBinding, B3SOIDDsNodePrime, B3SOIDDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDBePtr, B3SOIDDBeBinding, B3SOIDDbNode, B3SOIDDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDBgPtr, B3SOIDDBgBinding, B3SOIDDbNode, B3SOIDDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDBdpPtr, B3SOIDDBdpBinding, B3SOIDDbNode, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDBspPtr, B3SOIDDBspBinding, B3SOIDDbNode, B3SOIDDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDBbPtr, B3SOIDDBbBinding, B3SOIDDbNode, B3SOIDDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDEePtr, B3SOIDDEeBinding, B3SOIDDeNode, B3SOIDDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDGgPtr, B3SOIDDGgBinding, B3SOIDDgNode, B3SOIDDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDGdpPtr, B3SOIDDGdpBinding, B3SOIDDgNode, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDGspPtr, B3SOIDDGspBinding, B3SOIDDgNode, B3SOIDDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPgPtr, B3SOIDDDPgBinding, B3SOIDDdNodePrime, B3SOIDDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPdpPtr, B3SOIDDDPdpBinding, B3SOIDDdNodePrime, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPspPtr, B3SOIDDDPspBinding, B3SOIDDdNodePrime, B3SOIDDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDPdPtr, B3SOIDDDPdBinding, B3SOIDDdNodePrime, B3SOIDDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPgPtr, B3SOIDDSPgBinding, B3SOIDDsNodePrime, B3SOIDDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPdpPtr, B3SOIDDSPdpBinding, B3SOIDDsNodePrime, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPspPtr, B3SOIDDSPspBinding, B3SOIDDsNodePrime, B3SOIDDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSPsPtr, B3SOIDDSPsBinding, B3SOIDDsNodePrime, B3SOIDDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDdPtr, B3SOIDDDdBinding, B3SOIDDdNode, B3SOIDDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDDdpPtr, B3SOIDDDdpBinding, B3SOIDDdNode, B3SOIDDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSsPtr, B3SOIDDSsBinding, B3SOIDDsNode, B3SOIDDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIDDSspPtr, B3SOIDDSspBinding, B3SOIDDsNode, B3SOIDDsNodePrime);
+            if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1))
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVbsPtr, B3SOIDDVbsBinding, B3SOIDDvbsNode, B3SOIDDvbsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIdsPtr, B3SOIDDIdsBinding, B3SOIDDidsNode, B3SOIDDidsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIcPtr, B3SOIDDIcBinding, B3SOIDDicNode, B3SOIDDicNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIbsPtr, B3SOIDDIbsBinding, B3SOIDDibsNode, B3SOIDDibsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIbdPtr, B3SOIDDIbdBinding, B3SOIDDibdNode, B3SOIDDibdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIiiPtr, B3SOIDDIiiBinding, B3SOIDDiiiNode, B3SOIDDiiiNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIgidlPtr, B3SOIDDIgidlBinding, B3SOIDDigidlNode, B3SOIDDigidlNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDItunPtr, B3SOIDDItunBinding, B3SOIDDitunNode, B3SOIDDitunNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDIbpPtr, B3SOIDDIbpBinding, B3SOIDDibpNode, B3SOIDDibpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDAbeffPtr, B3SOIDDAbeffBinding, B3SOIDDabeffNode, B3SOIDDabeffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVbs0effPtr, B3SOIDDVbs0effBinding, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVbseffPtr, B3SOIDDVbseffBinding, B3SOIDDvbseffNode, B3SOIDDvbseffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDXcPtr, B3SOIDDXcBinding, B3SOIDDxcNode, B3SOIDDxcNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDCbbPtr, B3SOIDDCbbBinding, B3SOIDDcbbNode, B3SOIDDcbbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDCbdPtr, B3SOIDDCbdBinding, B3SOIDDcbdNode, B3SOIDDcbdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDCbgPtr, B3SOIDDCbgBinding, B3SOIDDcbgNode, B3SOIDDcbgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDqbPtr, B3SOIDDqbBinding, B3SOIDDqbNode, B3SOIDDqbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQbfPtr, B3SOIDDQbfBinding, B3SOIDDqbfNode, B3SOIDDqbfNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQjsPtr, B3SOIDDQjsBinding, B3SOIDDqjsNode, B3SOIDDqjsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQjdPtr, B3SOIDDQjdBinding, B3SOIDDqjdNode, B3SOIDDqjdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDGmPtr, B3SOIDDGmBinding, B3SOIDDgmNode, B3SOIDDgmNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDGmbsPtr, B3SOIDDGmbsBinding, B3SOIDDgmbsNode, B3SOIDDgmbsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDGdsPtr, B3SOIDDGdsBinding, B3SOIDDgdsNode, B3SOIDDgdsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDGmePtr, B3SOIDDGmeBinding, B3SOIDDgmeNode, B3SOIDDgmeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVbs0teffPtr, B3SOIDDVbs0teffBinding, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVthPtr, B3SOIDDVthBinding, B3SOIDDvthNode, B3SOIDDvthNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVgsteffPtr, B3SOIDDVgsteffBinding, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDXcsatPtr, B3SOIDDXcsatBinding, B3SOIDDxcsatNode, B3SOIDDxcsatNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVcscvPtr, B3SOIDDVcscvBinding, B3SOIDDvcscvNode, B3SOIDDvcscvNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDVdscvPtr, B3SOIDDVdscvBinding, B3SOIDDvdscvNode, B3SOIDDvdscvNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDCbePtr, B3SOIDDCbeBinding, B3SOIDDcbeNode, B3SOIDDcbeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDum1Ptr, B3SOIDDDum1Binding, B3SOIDDdum1Node, B3SOIDDdum1Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDum2Ptr, B3SOIDDDum2Binding, B3SOIDDdum2Node, B3SOIDDdum2Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDum3Ptr, B3SOIDDDum3Binding, B3SOIDDdum3Node, B3SOIDDdum3Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDum4Ptr, B3SOIDDDum4Binding, B3SOIDDdum4Node, B3SOIDDdum4Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDDum5Ptr, B3SOIDDDum5Binding, B3SOIDDdum5Node, B3SOIDDdum5Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQaccPtr, B3SOIDDQaccBinding, B3SOIDDqaccNode, B3SOIDDqaccNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQsub0Ptr, B3SOIDDQsub0Binding, B3SOIDDqsub0Node, B3SOIDDqsub0Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQsubs1Ptr, B3SOIDDQsubs1Binding, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDQsubs2Ptr, B3SOIDDQsubs2Binding, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDqePtr, B3SOIDDqeBinding, B3SOIDDqeNode, B3SOIDDqeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDqdPtr, B3SOIDDqdBinding, B3SOIDDqdNode, B3SOIDDqdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIDDqgPtr, B3SOIDDqgBinding, B3SOIDDqgNode, B3SOIDDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIDDbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIDDmodel *model = (B3SOIDDmodel *)inModel ;
+    B3SOIDDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIDD models */
+    for ( ; model != NULL ; model = B3SOIDDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIDDinstances(model); here != NULL ; here = B3SOIDDnextInstance(here))
+        {
+            if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTemptempPtr, B3SOIDDTemptempBinding, B3SOIDDtempNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTempdpPtr, B3SOIDDTempdpBinding, B3SOIDDtempNode, B3SOIDDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTempspPtr, B3SOIDDTempspBinding, B3SOIDDtempNode, B3SOIDDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTempgPtr, B3SOIDDTempgBinding, B3SOIDDtempNode, B3SOIDDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTempbPtr, B3SOIDDTempbBinding, B3SOIDDtempNode, B3SOIDDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDTempePtr, B3SOIDDTempeBinding, B3SOIDDtempNode, B3SOIDDeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGtempPtr, B3SOIDDGtempBinding, B3SOIDDgNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPtempPtr, B3SOIDDDPtempBinding, B3SOIDDdNodePrime, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPtempPtr, B3SOIDDSPtempBinding, B3SOIDDsNodePrime, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEtempPtr, B3SOIDDEtempBinding, B3SOIDDeNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBtempPtr, B3SOIDDBtempBinding, B3SOIDDbNode, B3SOIDDtempNode);
+                if (here->B3SOIDDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPtempPtr, B3SOIDDPtempBinding, B3SOIDDpNode, B3SOIDDtempNode);
+                }
+            }
+            if (here->B3SOIDDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIDDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBpPtr, B3SOIDDBpBinding, B3SOIDDbNode, B3SOIDDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPbPtr, B3SOIDDPbBinding, B3SOIDDpNode, B3SOIDDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPpPtr, B3SOIDDPpBinding, B3SOIDDpNode, B3SOIDDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPgPtr, B3SOIDDPgBinding, B3SOIDDpNode, B3SOIDDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPdpPtr, B3SOIDDPdpBinding, B3SOIDDpNode, B3SOIDDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPspPtr, B3SOIDDPspBinding, B3SOIDDpNode, B3SOIDDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDPePtr, B3SOIDDPeBinding, B3SOIDDpNode, B3SOIDDeNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEgPtr, B3SOIDDEgBinding, B3SOIDDeNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEdpPtr, B3SOIDDEdpBinding, B3SOIDDeNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEspPtr, B3SOIDDEspBinding, B3SOIDDeNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGePtr, B3SOIDDGeBinding, B3SOIDDgNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPePtr, B3SOIDDDPeBinding, B3SOIDDdNodePrime, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPePtr, B3SOIDDSPeBinding, B3SOIDDsNodePrime, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEbPtr, B3SOIDDEbBinding, B3SOIDDeNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGbPtr, B3SOIDDGbBinding, B3SOIDDgNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPbPtr, B3SOIDDDPbBinding, B3SOIDDdNodePrime, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPbPtr, B3SOIDDSPbBinding, B3SOIDDsNodePrime, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBePtr, B3SOIDDBeBinding, B3SOIDDbNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBgPtr, B3SOIDDBgBinding, B3SOIDDbNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBdpPtr, B3SOIDDBdpBinding, B3SOIDDbNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBspPtr, B3SOIDDBspBinding, B3SOIDDbNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDBbPtr, B3SOIDDBbBinding, B3SOIDDbNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDEePtr, B3SOIDDEeBinding, B3SOIDDeNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGgPtr, B3SOIDDGgBinding, B3SOIDDgNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGdpPtr, B3SOIDDGdpBinding, B3SOIDDgNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGspPtr, B3SOIDDGspBinding, B3SOIDDgNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPgPtr, B3SOIDDDPgBinding, B3SOIDDdNodePrime, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPdpPtr, B3SOIDDDPdpBinding, B3SOIDDdNodePrime, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPspPtr, B3SOIDDDPspBinding, B3SOIDDdNodePrime, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDPdPtr, B3SOIDDDPdBinding, B3SOIDDdNodePrime, B3SOIDDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPgPtr, B3SOIDDSPgBinding, B3SOIDDsNodePrime, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPdpPtr, B3SOIDDSPdpBinding, B3SOIDDsNodePrime, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPspPtr, B3SOIDDSPspBinding, B3SOIDDsNodePrime, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSPsPtr, B3SOIDDSPsBinding, B3SOIDDsNodePrime, B3SOIDDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDdPtr, B3SOIDDDdBinding, B3SOIDDdNode, B3SOIDDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDdpPtr, B3SOIDDDdpBinding, B3SOIDDdNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSsPtr, B3SOIDDSsBinding, B3SOIDDsNode, B3SOIDDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDSspPtr, B3SOIDDSspBinding, B3SOIDDsNode, B3SOIDDsNodePrime);
+            if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVbsPtr, B3SOIDDVbsBinding, B3SOIDDvbsNode, B3SOIDDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIdsPtr, B3SOIDDIdsBinding, B3SOIDDidsNode, B3SOIDDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIcPtr, B3SOIDDIcBinding, B3SOIDDicNode, B3SOIDDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIbsPtr, B3SOIDDIbsBinding, B3SOIDDibsNode, B3SOIDDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIbdPtr, B3SOIDDIbdBinding, B3SOIDDibdNode, B3SOIDDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIiiPtr, B3SOIDDIiiBinding, B3SOIDDiiiNode, B3SOIDDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIgidlPtr, B3SOIDDIgidlBinding, B3SOIDDigidlNode, B3SOIDDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDItunPtr, B3SOIDDItunBinding, B3SOIDDitunNode, B3SOIDDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDIbpPtr, B3SOIDDIbpBinding, B3SOIDDibpNode, B3SOIDDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDAbeffPtr, B3SOIDDAbeffBinding, B3SOIDDabeffNode, B3SOIDDabeffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVbs0effPtr, B3SOIDDVbs0effBinding, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVbseffPtr, B3SOIDDVbseffBinding, B3SOIDDvbseffNode, B3SOIDDvbseffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDXcPtr, B3SOIDDXcBinding, B3SOIDDxcNode, B3SOIDDxcNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDCbbPtr, B3SOIDDCbbBinding, B3SOIDDcbbNode, B3SOIDDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDCbdPtr, B3SOIDDCbdBinding, B3SOIDDcbdNode, B3SOIDDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDCbgPtr, B3SOIDDCbgBinding, B3SOIDDcbgNode, B3SOIDDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDqbPtr, B3SOIDDqbBinding, B3SOIDDqbNode, B3SOIDDqbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQbfPtr, B3SOIDDQbfBinding, B3SOIDDqbfNode, B3SOIDDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQjsPtr, B3SOIDDQjsBinding, B3SOIDDqjsNode, B3SOIDDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQjdPtr, B3SOIDDQjdBinding, B3SOIDDqjdNode, B3SOIDDqjdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGmPtr, B3SOIDDGmBinding, B3SOIDDgmNode, B3SOIDDgmNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGmbsPtr, B3SOIDDGmbsBinding, B3SOIDDgmbsNode, B3SOIDDgmbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGdsPtr, B3SOIDDGdsBinding, B3SOIDDgdsNode, B3SOIDDgdsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDGmePtr, B3SOIDDGmeBinding, B3SOIDDgmeNode, B3SOIDDgmeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVbs0teffPtr, B3SOIDDVbs0teffBinding, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVthPtr, B3SOIDDVthBinding, B3SOIDDvthNode, B3SOIDDvthNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVgsteffPtr, B3SOIDDVgsteffBinding, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDXcsatPtr, B3SOIDDXcsatBinding, B3SOIDDxcsatNode, B3SOIDDxcsatNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVcscvPtr, B3SOIDDVcscvBinding, B3SOIDDvcscvNode, B3SOIDDvcscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDVdscvPtr, B3SOIDDVdscvBinding, B3SOIDDvdscvNode, B3SOIDDvdscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDCbePtr, B3SOIDDCbeBinding, B3SOIDDcbeNode, B3SOIDDcbeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDum1Ptr, B3SOIDDDum1Binding, B3SOIDDdum1Node, B3SOIDDdum1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDum2Ptr, B3SOIDDDum2Binding, B3SOIDDdum2Node, B3SOIDDdum2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDum3Ptr, B3SOIDDDum3Binding, B3SOIDDdum3Node, B3SOIDDdum3Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDum4Ptr, B3SOIDDDum4Binding, B3SOIDDdum4Node, B3SOIDDdum4Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDDum5Ptr, B3SOIDDDum5Binding, B3SOIDDdum5Node, B3SOIDDdum5Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQaccPtr, B3SOIDDQaccBinding, B3SOIDDqaccNode, B3SOIDDqaccNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQsub0Ptr, B3SOIDDQsub0Binding, B3SOIDDqsub0Node, B3SOIDDqsub0Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQsubs1Ptr, B3SOIDDQsubs1Binding, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDQsubs2Ptr, B3SOIDDQsubs2Binding, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDqePtr, B3SOIDDqeBinding, B3SOIDDqeNode, B3SOIDDqeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDqdPtr, B3SOIDDqdBinding, B3SOIDDqdNode, B3SOIDDqdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIDDqgPtr, B3SOIDDqgBinding, B3SOIDDqgNode, B3SOIDDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIDDbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIDDmodel *model = (B3SOIDDmodel *)inModel ;
+    B3SOIDDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIDD models */
+    for ( ; model != NULL ; model = B3SOIDDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIDDinstances(model); here != NULL ; here = B3SOIDDnextInstance(here))
+        {
+            if ((model->B3SOIDDshMod == 1) && (here->B3SOIDDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTemptempPtr, B3SOIDDTemptempBinding, B3SOIDDtempNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTempdpPtr, B3SOIDDTempdpBinding, B3SOIDDtempNode, B3SOIDDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTempspPtr, B3SOIDDTempspBinding, B3SOIDDtempNode, B3SOIDDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTempgPtr, B3SOIDDTempgBinding, B3SOIDDtempNode, B3SOIDDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTempbPtr, B3SOIDDTempbBinding, B3SOIDDtempNode, B3SOIDDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDTempePtr, B3SOIDDTempeBinding, B3SOIDDtempNode, B3SOIDDeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGtempPtr, B3SOIDDGtempBinding, B3SOIDDgNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPtempPtr, B3SOIDDDPtempBinding, B3SOIDDdNodePrime, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPtempPtr, B3SOIDDSPtempBinding, B3SOIDDsNodePrime, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEtempPtr, B3SOIDDEtempBinding, B3SOIDDeNode, B3SOIDDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBtempPtr, B3SOIDDBtempBinding, B3SOIDDbNode, B3SOIDDtempNode);
+                if (here->B3SOIDDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPtempPtr, B3SOIDDPtempBinding, B3SOIDDpNode, B3SOIDDtempNode);
+                }
+            }
+            if (here->B3SOIDDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIDDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBpPtr, B3SOIDDBpBinding, B3SOIDDbNode, B3SOIDDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPbPtr, B3SOIDDPbBinding, B3SOIDDpNode, B3SOIDDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPpPtr, B3SOIDDPpBinding, B3SOIDDpNode, B3SOIDDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPgPtr, B3SOIDDPgBinding, B3SOIDDpNode, B3SOIDDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPdpPtr, B3SOIDDPdpBinding, B3SOIDDpNode, B3SOIDDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPspPtr, B3SOIDDPspBinding, B3SOIDDpNode, B3SOIDDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDPePtr, B3SOIDDPeBinding, B3SOIDDpNode, B3SOIDDeNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEgPtr, B3SOIDDEgBinding, B3SOIDDeNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEdpPtr, B3SOIDDEdpBinding, B3SOIDDeNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEspPtr, B3SOIDDEspBinding, B3SOIDDeNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGePtr, B3SOIDDGeBinding, B3SOIDDgNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPePtr, B3SOIDDDPeBinding, B3SOIDDdNodePrime, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPePtr, B3SOIDDSPeBinding, B3SOIDDsNodePrime, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEbPtr, B3SOIDDEbBinding, B3SOIDDeNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGbPtr, B3SOIDDGbBinding, B3SOIDDgNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPbPtr, B3SOIDDDPbBinding, B3SOIDDdNodePrime, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPbPtr, B3SOIDDSPbBinding, B3SOIDDsNodePrime, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBePtr, B3SOIDDBeBinding, B3SOIDDbNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBgPtr, B3SOIDDBgBinding, B3SOIDDbNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBdpPtr, B3SOIDDBdpBinding, B3SOIDDbNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBspPtr, B3SOIDDBspBinding, B3SOIDDbNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDBbPtr, B3SOIDDBbBinding, B3SOIDDbNode, B3SOIDDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDEePtr, B3SOIDDEeBinding, B3SOIDDeNode, B3SOIDDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGgPtr, B3SOIDDGgBinding, B3SOIDDgNode, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGdpPtr, B3SOIDDGdpBinding, B3SOIDDgNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGspPtr, B3SOIDDGspBinding, B3SOIDDgNode, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPgPtr, B3SOIDDDPgBinding, B3SOIDDdNodePrime, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPdpPtr, B3SOIDDDPdpBinding, B3SOIDDdNodePrime, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPspPtr, B3SOIDDDPspBinding, B3SOIDDdNodePrime, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDPdPtr, B3SOIDDDPdBinding, B3SOIDDdNodePrime, B3SOIDDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPgPtr, B3SOIDDSPgBinding, B3SOIDDsNodePrime, B3SOIDDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPdpPtr, B3SOIDDSPdpBinding, B3SOIDDsNodePrime, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPspPtr, B3SOIDDSPspBinding, B3SOIDDsNodePrime, B3SOIDDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSPsPtr, B3SOIDDSPsBinding, B3SOIDDsNodePrime, B3SOIDDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDdPtr, B3SOIDDDdBinding, B3SOIDDdNode, B3SOIDDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDdpPtr, B3SOIDDDdpBinding, B3SOIDDdNode, B3SOIDDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSsPtr, B3SOIDDSsBinding, B3SOIDDsNode, B3SOIDDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDSspPtr, B3SOIDDSspBinding, B3SOIDDsNode, B3SOIDDsNodePrime);
+            if ((here->B3SOIDDdebugMod > 1) || (here->B3SOIDDdebugMod == -1))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVbsPtr, B3SOIDDVbsBinding, B3SOIDDvbsNode, B3SOIDDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIdsPtr, B3SOIDDIdsBinding, B3SOIDDidsNode, B3SOIDDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIcPtr, B3SOIDDIcBinding, B3SOIDDicNode, B3SOIDDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIbsPtr, B3SOIDDIbsBinding, B3SOIDDibsNode, B3SOIDDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIbdPtr, B3SOIDDIbdBinding, B3SOIDDibdNode, B3SOIDDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIiiPtr, B3SOIDDIiiBinding, B3SOIDDiiiNode, B3SOIDDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIgidlPtr, B3SOIDDIgidlBinding, B3SOIDDigidlNode, B3SOIDDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDItunPtr, B3SOIDDItunBinding, B3SOIDDitunNode, B3SOIDDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDIbpPtr, B3SOIDDIbpBinding, B3SOIDDibpNode, B3SOIDDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDAbeffPtr, B3SOIDDAbeffBinding, B3SOIDDabeffNode, B3SOIDDabeffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVbs0effPtr, B3SOIDDVbs0effBinding, B3SOIDDvbs0effNode, B3SOIDDvbs0effNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVbseffPtr, B3SOIDDVbseffBinding, B3SOIDDvbseffNode, B3SOIDDvbseffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDXcPtr, B3SOIDDXcBinding, B3SOIDDxcNode, B3SOIDDxcNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDCbbPtr, B3SOIDDCbbBinding, B3SOIDDcbbNode, B3SOIDDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDCbdPtr, B3SOIDDCbdBinding, B3SOIDDcbdNode, B3SOIDDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDCbgPtr, B3SOIDDCbgBinding, B3SOIDDcbgNode, B3SOIDDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDqbPtr, B3SOIDDqbBinding, B3SOIDDqbNode, B3SOIDDqbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQbfPtr, B3SOIDDQbfBinding, B3SOIDDqbfNode, B3SOIDDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQjsPtr, B3SOIDDQjsBinding, B3SOIDDqjsNode, B3SOIDDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQjdPtr, B3SOIDDQjdBinding, B3SOIDDqjdNode, B3SOIDDqjdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGmPtr, B3SOIDDGmBinding, B3SOIDDgmNode, B3SOIDDgmNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGmbsPtr, B3SOIDDGmbsBinding, B3SOIDDgmbsNode, B3SOIDDgmbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGdsPtr, B3SOIDDGdsBinding, B3SOIDDgdsNode, B3SOIDDgdsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDGmePtr, B3SOIDDGmeBinding, B3SOIDDgmeNode, B3SOIDDgmeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVbs0teffPtr, B3SOIDDVbs0teffBinding, B3SOIDDvbs0teffNode, B3SOIDDvbs0teffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVthPtr, B3SOIDDVthBinding, B3SOIDDvthNode, B3SOIDDvthNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVgsteffPtr, B3SOIDDVgsteffBinding, B3SOIDDvgsteffNode, B3SOIDDvgsteffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDXcsatPtr, B3SOIDDXcsatBinding, B3SOIDDxcsatNode, B3SOIDDxcsatNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVcscvPtr, B3SOIDDVcscvBinding, B3SOIDDvcscvNode, B3SOIDDvcscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDVdscvPtr, B3SOIDDVdscvBinding, B3SOIDDvdscvNode, B3SOIDDvdscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDCbePtr, B3SOIDDCbeBinding, B3SOIDDcbeNode, B3SOIDDcbeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDum1Ptr, B3SOIDDDum1Binding, B3SOIDDdum1Node, B3SOIDDdum1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDum2Ptr, B3SOIDDDum2Binding, B3SOIDDdum2Node, B3SOIDDdum2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDum3Ptr, B3SOIDDDum3Binding, B3SOIDDdum3Node, B3SOIDDdum3Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDum4Ptr, B3SOIDDDum4Binding, B3SOIDDdum4Node, B3SOIDDdum4Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDDum5Ptr, B3SOIDDDum5Binding, B3SOIDDdum5Node, B3SOIDDdum5Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQaccPtr, B3SOIDDQaccBinding, B3SOIDDqaccNode, B3SOIDDqaccNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQsub0Ptr, B3SOIDDQsub0Binding, B3SOIDDqsub0Node, B3SOIDDqsub0Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQsubs1Ptr, B3SOIDDQsubs1Binding, B3SOIDDqsubs1Node, B3SOIDDqsubs1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDQsubs2Ptr, B3SOIDDQsubs2Binding, B3SOIDDqsubs2Node, B3SOIDDqsubs2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDqePtr, B3SOIDDqeBinding, B3SOIDDqeNode, B3SOIDDqeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDqdPtr, B3SOIDDqdBinding, B3SOIDDqdNode, B3SOIDDqdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIDDqgPtr, B3SOIDDqgBinding, B3SOIDDqgNode, B3SOIDDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3soi_dd/b3soidddef.h

@@ -420,6 +420,102 @@ typedef struct sB3SOIDDinstance
         double **B3SOIDDnVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *B3SOIDDTemptempBinding ;
+    BindElement *B3SOIDDTempdpBinding ;
+    BindElement *B3SOIDDTempspBinding ;
+    BindElement *B3SOIDDTempgBinding ;
+    BindElement *B3SOIDDTempbBinding ;
+    BindElement *B3SOIDDTempeBinding ;
+    BindElement *B3SOIDDGtempBinding ;
+    BindElement *B3SOIDDDPtempBinding ;
+    BindElement *B3SOIDDSPtempBinding ;
+    BindElement *B3SOIDDEtempBinding ;
+    BindElement *B3SOIDDBtempBinding ;
+    BindElement *B3SOIDDPtempBinding ;
+    BindElement *B3SOIDDBpBinding ;
+    BindElement *B3SOIDDPbBinding ;
+    BindElement *B3SOIDDPpBinding ;
+    BindElement *B3SOIDDPgBinding ;
+    BindElement *B3SOIDDPdpBinding ;
+    BindElement *B3SOIDDPspBinding ;
+    BindElement *B3SOIDDPeBinding ;
+    BindElement *B3SOIDDEgBinding ;
+    BindElement *B3SOIDDEdpBinding ;
+    BindElement *B3SOIDDEspBinding ;
+    BindElement *B3SOIDDGeBinding ;
+    BindElement *B3SOIDDDPeBinding ;
+    BindElement *B3SOIDDSPeBinding ;
+    BindElement *B3SOIDDEbBinding ;
+    BindElement *B3SOIDDGbBinding ;
+    BindElement *B3SOIDDDPbBinding ;
+    BindElement *B3SOIDDSPbBinding ;
+    BindElement *B3SOIDDBeBinding ;
+    BindElement *B3SOIDDBgBinding ;
+    BindElement *B3SOIDDBdpBinding ;
+    BindElement *B3SOIDDBspBinding ;
+    BindElement *B3SOIDDBbBinding ;
+    BindElement *B3SOIDDEeBinding ;
+    BindElement *B3SOIDDGgBinding ;
+    BindElement *B3SOIDDGdpBinding ;
+    BindElement *B3SOIDDGspBinding ;
+    BindElement *B3SOIDDDPgBinding ;
+    BindElement *B3SOIDDDPdpBinding ;
+    BindElement *B3SOIDDDPspBinding ;
+    BindElement *B3SOIDDDPdBinding ;
+    BindElement *B3SOIDDSPgBinding ;
+    BindElement *B3SOIDDSPdpBinding ;
+    BindElement *B3SOIDDSPspBinding ;
+    BindElement *B3SOIDDSPsBinding ;
+    BindElement *B3SOIDDDdBinding ;
+    BindElement *B3SOIDDDdpBinding ;
+    BindElement *B3SOIDDSsBinding ;
+    BindElement *B3SOIDDSspBinding ;
+    BindElement *B3SOIDDVbsBinding ;
+    BindElement *B3SOIDDIdsBinding ;
+    BindElement *B3SOIDDIcBinding ;
+    BindElement *B3SOIDDIbsBinding ;
+    BindElement *B3SOIDDIbdBinding ;
+    BindElement *B3SOIDDIiiBinding ;
+    BindElement *B3SOIDDIgidlBinding ;
+    BindElement *B3SOIDDItunBinding ;
+    BindElement *B3SOIDDIbpBinding ;
+    BindElement *B3SOIDDAbeffBinding ;
+    BindElement *B3SOIDDVbs0effBinding ;
+    BindElement *B3SOIDDVbseffBinding ;
+    BindElement *B3SOIDDXcBinding ;
+    BindElement *B3SOIDDCbbBinding ;
+    BindElement *B3SOIDDCbdBinding ;
+    BindElement *B3SOIDDCbgBinding ;
+    BindElement *B3SOIDDqbBinding ;
+    BindElement *B3SOIDDQbfBinding ;
+    BindElement *B3SOIDDQjsBinding ;
+    BindElement *B3SOIDDQjdBinding ;
+    BindElement *B3SOIDDGmBinding ;
+    BindElement *B3SOIDDGmbsBinding ;
+    BindElement *B3SOIDDGdsBinding ;
+    BindElement *B3SOIDDGmeBinding ;
+    BindElement *B3SOIDDVbs0teffBinding ;
+    BindElement *B3SOIDDVthBinding ;
+    BindElement *B3SOIDDVgsteffBinding ;
+    BindElement *B3SOIDDXcsatBinding ;
+    BindElement *B3SOIDDVcscvBinding ;
+    BindElement *B3SOIDDVdscvBinding ;
+    BindElement *B3SOIDDCbeBinding ;
+    BindElement *B3SOIDDDum1Binding ;
+    BindElement *B3SOIDDDum2Binding ;
+    BindElement *B3SOIDDDum3Binding ;
+    BindElement *B3SOIDDDum4Binding ;
+    BindElement *B3SOIDDDum5Binding ;
+    BindElement *B3SOIDDQaccBinding ;
+    BindElement *B3SOIDDQsub0Binding ;
+    BindElement *B3SOIDDQsubs1Binding ;
+    BindElement *B3SOIDDQsubs2Binding ;
+    BindElement *B3SOIDDqeBinding ;
+    BindElement *B3SOIDDqdBinding ;
+    BindElement *B3SOIDDqgBinding ;
+#endif
+
 } B3SOIDDinstance ;
 
 struct b3soiddSizeDependParam

src/spicelib/devices/bsim3soi_dd/b3soiddext.h

@@ -25,3 +25,9 @@ extern int B3SOIDDtemp(GENmodel*,CKTcircuit*);
 extern int B3SOIDDtrunc(GENmodel*,CKTcircuit*,double*);
 extern int B3SOIDDnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int B3SOIDDunsetup(GENmodel*,CKTcircuit*);
+
+#ifdef KLU
+extern int B3SOIDDbindCSC (GENmodel*, CKTcircuit*) ;
+extern int B3SOIDDbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B3SOIDDbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3soi_dd/b3soiddinit.c

@@ -64,6 +64,12 @@ SPICEdev B3SOIDDinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B3SOIDDbindCSC,
+    .DEVbindCSCComplex = B3SOIDDbindCSCComplex,
+    .DEVbindCSCComplexToReal = B3SOIDDbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3soi_fd/Makefile.am

@@ -25,6 +25,9 @@ libbsim3soifd_la_SOURCES = \
 	b3soifditf.h
 
 
+if KLU_WANTED
+libbsim3soifd_la_SOURCES += b3soifdbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3soi_fd/b3soifdbindCSC.c

@@ -0,0 +1,386 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "b3soifddef.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B3SOIFDbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIFDmodel *model = (B3SOIFDmodel *)inModel ;
+    B3SOIFDinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B3SOIFD models */
+    for ( ; model != NULL ; model = B3SOIFDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIFDinstances(model); here != NULL ; here = B3SOIFDnextInstance(here))
+        {
+            if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0 != 0.0))
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTemptempPtr, B3SOIFDTemptempBinding, B3SOIFDtempNode, B3SOIFDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTempdpPtr, B3SOIFDTempdpBinding, B3SOIFDtempNode, B3SOIFDdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTempspPtr, B3SOIFDTempspBinding, B3SOIFDtempNode, B3SOIFDsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTempgPtr, B3SOIFDTempgBinding, B3SOIFDtempNode, B3SOIFDgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTempbPtr, B3SOIFDTempbBinding, B3SOIFDtempNode, B3SOIFDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDTempePtr, B3SOIFDTempeBinding, B3SOIFDtempNode, B3SOIFDeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDGtempPtr, B3SOIFDGtempBinding, B3SOIFDgNode, B3SOIFDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDPtempPtr, B3SOIFDDPtempBinding, B3SOIFDdNodePrime, B3SOIFDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDSPtempPtr, B3SOIFDSPtempBinding, B3SOIFDsNodePrime, B3SOIFDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDEtempPtr, B3SOIFDEtempBinding, B3SOIFDeNode, B3SOIFDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDBtempPtr, B3SOIFDBtempBinding, B3SOIFDbNode, B3SOIFDtempNode);
+                if (here->B3SOIFDbodyMod == 1)
+                {
+                    CREATE_KLU_BINDING_TABLE(B3SOIFDPtempPtr, B3SOIFDPtempBinding, B3SOIFDpNode, B3SOIFDtempNode);
+                }
+            }
+            if (here->B3SOIFDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIFDbodyMod == 1)
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIFDBpPtr, B3SOIFDBpBinding, B3SOIFDbNode, B3SOIFDpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPbPtr, B3SOIFDPbBinding, B3SOIFDpNode, B3SOIFDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPpPtr, B3SOIFDPpBinding, B3SOIFDpNode, B3SOIFDpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPgPtr, B3SOIFDPgBinding, B3SOIFDpNode, B3SOIFDgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPdpPtr, B3SOIFDPdpBinding, B3SOIFDpNode, B3SOIFDdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPspPtr, B3SOIFDPspBinding, B3SOIFDpNode, B3SOIFDsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDPePtr, B3SOIFDPeBinding, B3SOIFDpNode, B3SOIFDeNode);
+            }
+            CREATE_KLU_BINDING_TABLE(B3SOIFDEgPtr, B3SOIFDEgBinding, B3SOIFDeNode, B3SOIFDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDEdpPtr, B3SOIFDEdpBinding, B3SOIFDeNode, B3SOIFDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDEspPtr, B3SOIFDEspBinding, B3SOIFDeNode, B3SOIFDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDGePtr, B3SOIFDGeBinding, B3SOIFDgNode, B3SOIFDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDPePtr, B3SOIFDDPeBinding, B3SOIFDdNodePrime, B3SOIFDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSPePtr, B3SOIFDSPeBinding, B3SOIFDsNodePrime, B3SOIFDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDEbPtr, B3SOIFDEbBinding, B3SOIFDeNode, B3SOIFDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDEePtr, B3SOIFDEeBinding, B3SOIFDeNode, B3SOIFDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDGgPtr, B3SOIFDGgBinding, B3SOIFDgNode, B3SOIFDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDGdpPtr, B3SOIFDGdpBinding, B3SOIFDgNode, B3SOIFDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDGspPtr, B3SOIFDGspBinding, B3SOIFDgNode, B3SOIFDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDPgPtr, B3SOIFDDPgBinding, B3SOIFDdNodePrime, B3SOIFDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDPdpPtr, B3SOIFDDPdpBinding, B3SOIFDdNodePrime, B3SOIFDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDPspPtr, B3SOIFDDPspBinding, B3SOIFDdNodePrime, B3SOIFDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDPdPtr, B3SOIFDDPdBinding, B3SOIFDdNodePrime, B3SOIFDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSPgPtr, B3SOIFDSPgBinding, B3SOIFDsNodePrime, B3SOIFDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSPdpPtr, B3SOIFDSPdpBinding, B3SOIFDsNodePrime, B3SOIFDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSPspPtr, B3SOIFDSPspBinding, B3SOIFDsNodePrime, B3SOIFDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSPsPtr, B3SOIFDSPsBinding, B3SOIFDsNodePrime, B3SOIFDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDdPtr, B3SOIFDDdBinding, B3SOIFDdNode, B3SOIFDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDDdpPtr, B3SOIFDDdpBinding, B3SOIFDdNode, B3SOIFDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSsPtr, B3SOIFDSsBinding, B3SOIFDsNode, B3SOIFDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIFDSspPtr, B3SOIFDSspBinding, B3SOIFDsNode, B3SOIFDsNodePrime);
+            if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1))
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVbsPtr, B3SOIFDVbsBinding, B3SOIFDvbsNode, B3SOIFDvbsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIdsPtr, B3SOIFDIdsBinding, B3SOIFDidsNode, B3SOIFDidsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIcPtr, B3SOIFDIcBinding, B3SOIFDicNode, B3SOIFDicNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIbsPtr, B3SOIFDIbsBinding, B3SOIFDibsNode, B3SOIFDibsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIbdPtr, B3SOIFDIbdBinding, B3SOIFDibdNode, B3SOIFDibdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIiiPtr, B3SOIFDIiiBinding, B3SOIFDiiiNode, B3SOIFDiiiNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIgidlPtr, B3SOIFDIgidlBinding, B3SOIFDigidlNode, B3SOIFDigidlNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDItunPtr, B3SOIFDItunBinding, B3SOIFDitunNode, B3SOIFDitunNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDIbpPtr, B3SOIFDIbpBinding, B3SOIFDibpNode, B3SOIFDibpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDAbeffPtr, B3SOIFDAbeffBinding, B3SOIFDabeffNode, B3SOIFDabeffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVbs0effPtr, B3SOIFDVbs0effBinding, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVbseffPtr, B3SOIFDVbseffBinding, B3SOIFDvbseffNode, B3SOIFDvbseffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDXcPtr, B3SOIFDXcBinding, B3SOIFDxcNode, B3SOIFDxcNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDCbbPtr, B3SOIFDCbbBinding, B3SOIFDcbbNode, B3SOIFDcbbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDCbdPtr, B3SOIFDCbdBinding, B3SOIFDcbdNode, B3SOIFDcbdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDCbgPtr, B3SOIFDCbgBinding, B3SOIFDcbgNode, B3SOIFDcbgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDqbPtr, B3SOIFDqbBinding, B3SOIFDqbNode, B3SOIFDqbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQbfPtr, B3SOIFDQbfBinding, B3SOIFDqbfNode, B3SOIFDqbfNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQjsPtr, B3SOIFDQjsBinding, B3SOIFDqjsNode, B3SOIFDqjsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQjdPtr, B3SOIFDQjdBinding, B3SOIFDqjdNode, B3SOIFDqjdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDGmPtr, B3SOIFDGmBinding, B3SOIFDgmNode, B3SOIFDgmNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDGmbsPtr, B3SOIFDGmbsBinding, B3SOIFDgmbsNode, B3SOIFDgmbsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDGdsPtr, B3SOIFDGdsBinding, B3SOIFDgdsNode, B3SOIFDgdsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDGmePtr, B3SOIFDGmeBinding, B3SOIFDgmeNode, B3SOIFDgmeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVbs0teffPtr, B3SOIFDVbs0teffBinding, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVthPtr, B3SOIFDVthBinding, B3SOIFDvthNode, B3SOIFDvthNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVgsteffPtr, B3SOIFDVgsteffBinding, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDXcsatPtr, B3SOIFDXcsatBinding, B3SOIFDxcsatNode, B3SOIFDxcsatNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVcscvPtr, B3SOIFDVcscvBinding, B3SOIFDvcscvNode, B3SOIFDvcscvNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDVdscvPtr, B3SOIFDVdscvBinding, B3SOIFDvdscvNode, B3SOIFDvdscvNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDCbePtr, B3SOIFDCbeBinding, B3SOIFDcbeNode, B3SOIFDcbeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDum1Ptr, B3SOIFDDum1Binding, B3SOIFDdum1Node, B3SOIFDdum1Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDum2Ptr, B3SOIFDDum2Binding, B3SOIFDdum2Node, B3SOIFDdum2Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDum3Ptr, B3SOIFDDum3Binding, B3SOIFDdum3Node, B3SOIFDdum3Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDum4Ptr, B3SOIFDDum4Binding, B3SOIFDdum4Node, B3SOIFDdum4Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDDum5Ptr, B3SOIFDDum5Binding, B3SOIFDdum5Node, B3SOIFDdum5Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQaccPtr, B3SOIFDQaccBinding, B3SOIFDqaccNode, B3SOIFDqaccNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQsub0Ptr, B3SOIFDQsub0Binding, B3SOIFDqsub0Node, B3SOIFDqsub0Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQsubs1Ptr, B3SOIFDQsubs1Binding, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDQsubs2Ptr, B3SOIFDQsubs2Binding, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDqePtr, B3SOIFDqeBinding, B3SOIFDqeNode, B3SOIFDqeNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDqdPtr, B3SOIFDqdBinding, B3SOIFDqdNode, B3SOIFDqdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIFDqgPtr, B3SOIFDqgBinding, B3SOIFDqgNode, B3SOIFDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIFDbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIFDmodel *model = (B3SOIFDmodel *)inModel ;
+    B3SOIFDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIFD models */
+    for ( ; model != NULL ; model = B3SOIFDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIFDinstances(model); here != NULL ; here = B3SOIFDnextInstance(here))
+        {
+            if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTemptempPtr, B3SOIFDTemptempBinding, B3SOIFDtempNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTempdpPtr, B3SOIFDTempdpBinding, B3SOIFDtempNode, B3SOIFDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTempspPtr, B3SOIFDTempspBinding, B3SOIFDtempNode, B3SOIFDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTempgPtr, B3SOIFDTempgBinding, B3SOIFDtempNode, B3SOIFDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTempbPtr, B3SOIFDTempbBinding, B3SOIFDtempNode, B3SOIFDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDTempePtr, B3SOIFDTempeBinding, B3SOIFDtempNode, B3SOIFDeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGtempPtr, B3SOIFDGtempBinding, B3SOIFDgNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPtempPtr, B3SOIFDDPtempBinding, B3SOIFDdNodePrime, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPtempPtr, B3SOIFDSPtempBinding, B3SOIFDsNodePrime, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEtempPtr, B3SOIFDEtempBinding, B3SOIFDeNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDBtempPtr, B3SOIFDBtempBinding, B3SOIFDbNode, B3SOIFDtempNode);
+                if (here->B3SOIFDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPtempPtr, B3SOIFDPtempBinding, B3SOIFDpNode, B3SOIFDtempNode);
+                }
+            }
+            if (here->B3SOIFDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIFDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDBpPtr, B3SOIFDBpBinding, B3SOIFDbNode, B3SOIFDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPbPtr, B3SOIFDPbBinding, B3SOIFDpNode, B3SOIFDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPpPtr, B3SOIFDPpBinding, B3SOIFDpNode, B3SOIFDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPgPtr, B3SOIFDPgBinding, B3SOIFDpNode, B3SOIFDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPdpPtr, B3SOIFDPdpBinding, B3SOIFDpNode, B3SOIFDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPspPtr, B3SOIFDPspBinding, B3SOIFDpNode, B3SOIFDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDPePtr, B3SOIFDPeBinding, B3SOIFDpNode, B3SOIFDeNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEgPtr, B3SOIFDEgBinding, B3SOIFDeNode, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEdpPtr, B3SOIFDEdpBinding, B3SOIFDeNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEspPtr, B3SOIFDEspBinding, B3SOIFDeNode, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGePtr, B3SOIFDGeBinding, B3SOIFDgNode, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPePtr, B3SOIFDDPeBinding, B3SOIFDdNodePrime, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPePtr, B3SOIFDSPeBinding, B3SOIFDsNodePrime, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEbPtr, B3SOIFDEbBinding, B3SOIFDeNode, B3SOIFDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDEePtr, B3SOIFDEeBinding, B3SOIFDeNode, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGgPtr, B3SOIFDGgBinding, B3SOIFDgNode, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGdpPtr, B3SOIFDGdpBinding, B3SOIFDgNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGspPtr, B3SOIFDGspBinding, B3SOIFDgNode, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPgPtr, B3SOIFDDPgBinding, B3SOIFDdNodePrime, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPdpPtr, B3SOIFDDPdpBinding, B3SOIFDdNodePrime, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPspPtr, B3SOIFDDPspBinding, B3SOIFDdNodePrime, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDPdPtr, B3SOIFDDPdBinding, B3SOIFDdNodePrime, B3SOIFDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPgPtr, B3SOIFDSPgBinding, B3SOIFDsNodePrime, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPdpPtr, B3SOIFDSPdpBinding, B3SOIFDsNodePrime, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPspPtr, B3SOIFDSPspBinding, B3SOIFDsNodePrime, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSPsPtr, B3SOIFDSPsBinding, B3SOIFDsNodePrime, B3SOIFDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDdPtr, B3SOIFDDdBinding, B3SOIFDdNode, B3SOIFDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDdpPtr, B3SOIFDDdpBinding, B3SOIFDdNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSsPtr, B3SOIFDSsBinding, B3SOIFDsNode, B3SOIFDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDSspPtr, B3SOIFDSspBinding, B3SOIFDsNode, B3SOIFDsNodePrime);
+            if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVbsPtr, B3SOIFDVbsBinding, B3SOIFDvbsNode, B3SOIFDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIdsPtr, B3SOIFDIdsBinding, B3SOIFDidsNode, B3SOIFDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIcPtr, B3SOIFDIcBinding, B3SOIFDicNode, B3SOIFDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIbsPtr, B3SOIFDIbsBinding, B3SOIFDibsNode, B3SOIFDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIbdPtr, B3SOIFDIbdBinding, B3SOIFDibdNode, B3SOIFDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIiiPtr, B3SOIFDIiiBinding, B3SOIFDiiiNode, B3SOIFDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIgidlPtr, B3SOIFDIgidlBinding, B3SOIFDigidlNode, B3SOIFDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDItunPtr, B3SOIFDItunBinding, B3SOIFDitunNode, B3SOIFDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDIbpPtr, B3SOIFDIbpBinding, B3SOIFDibpNode, B3SOIFDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDAbeffPtr, B3SOIFDAbeffBinding, B3SOIFDabeffNode, B3SOIFDabeffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVbs0effPtr, B3SOIFDVbs0effBinding, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVbseffPtr, B3SOIFDVbseffBinding, B3SOIFDvbseffNode, B3SOIFDvbseffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDXcPtr, B3SOIFDXcBinding, B3SOIFDxcNode, B3SOIFDxcNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDCbbPtr, B3SOIFDCbbBinding, B3SOIFDcbbNode, B3SOIFDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDCbdPtr, B3SOIFDCbdBinding, B3SOIFDcbdNode, B3SOIFDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDCbgPtr, B3SOIFDCbgBinding, B3SOIFDcbgNode, B3SOIFDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDqbPtr, B3SOIFDqbBinding, B3SOIFDqbNode, B3SOIFDqbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQbfPtr, B3SOIFDQbfBinding, B3SOIFDqbfNode, B3SOIFDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQjsPtr, B3SOIFDQjsBinding, B3SOIFDqjsNode, B3SOIFDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQjdPtr, B3SOIFDQjdBinding, B3SOIFDqjdNode, B3SOIFDqjdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGmPtr, B3SOIFDGmBinding, B3SOIFDgmNode, B3SOIFDgmNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGmbsPtr, B3SOIFDGmbsBinding, B3SOIFDgmbsNode, B3SOIFDgmbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGdsPtr, B3SOIFDGdsBinding, B3SOIFDgdsNode, B3SOIFDgdsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDGmePtr, B3SOIFDGmeBinding, B3SOIFDgmeNode, B3SOIFDgmeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVbs0teffPtr, B3SOIFDVbs0teffBinding, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVthPtr, B3SOIFDVthBinding, B3SOIFDvthNode, B3SOIFDvthNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVgsteffPtr, B3SOIFDVgsteffBinding, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDXcsatPtr, B3SOIFDXcsatBinding, B3SOIFDxcsatNode, B3SOIFDxcsatNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVcscvPtr, B3SOIFDVcscvBinding, B3SOIFDvcscvNode, B3SOIFDvcscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDVdscvPtr, B3SOIFDVdscvBinding, B3SOIFDvdscvNode, B3SOIFDvdscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDCbePtr, B3SOIFDCbeBinding, B3SOIFDcbeNode, B3SOIFDcbeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDum1Ptr, B3SOIFDDum1Binding, B3SOIFDdum1Node, B3SOIFDdum1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDum2Ptr, B3SOIFDDum2Binding, B3SOIFDdum2Node, B3SOIFDdum2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDum3Ptr, B3SOIFDDum3Binding, B3SOIFDdum3Node, B3SOIFDdum3Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDum4Ptr, B3SOIFDDum4Binding, B3SOIFDdum4Node, B3SOIFDdum4Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDDum5Ptr, B3SOIFDDum5Binding, B3SOIFDdum5Node, B3SOIFDdum5Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQaccPtr, B3SOIFDQaccBinding, B3SOIFDqaccNode, B3SOIFDqaccNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQsub0Ptr, B3SOIFDQsub0Binding, B3SOIFDqsub0Node, B3SOIFDqsub0Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQsubs1Ptr, B3SOIFDQsubs1Binding, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDQsubs2Ptr, B3SOIFDQsubs2Binding, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDqePtr, B3SOIFDqeBinding, B3SOIFDqeNode, B3SOIFDqeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDqdPtr, B3SOIFDqdBinding, B3SOIFDqdNode, B3SOIFDqdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIFDqgPtr, B3SOIFDqgBinding, B3SOIFDqgNode, B3SOIFDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIFDbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIFDmodel *model = (B3SOIFDmodel *)inModel ;
+    B3SOIFDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIFD models */
+    for ( ; model != NULL ; model = B3SOIFDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIFDinstances(model); here != NULL ; here = B3SOIFDnextInstance(here))
+        {
+            if ((model->B3SOIFDshMod == 1) && (here->B3SOIFDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTemptempPtr, B3SOIFDTemptempBinding, B3SOIFDtempNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTempdpPtr, B3SOIFDTempdpBinding, B3SOIFDtempNode, B3SOIFDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTempspPtr, B3SOIFDTempspBinding, B3SOIFDtempNode, B3SOIFDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTempgPtr, B3SOIFDTempgBinding, B3SOIFDtempNode, B3SOIFDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTempbPtr, B3SOIFDTempbBinding, B3SOIFDtempNode, B3SOIFDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDTempePtr, B3SOIFDTempeBinding, B3SOIFDtempNode, B3SOIFDeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGtempPtr, B3SOIFDGtempBinding, B3SOIFDgNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPtempPtr, B3SOIFDDPtempBinding, B3SOIFDdNodePrime, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPtempPtr, B3SOIFDSPtempBinding, B3SOIFDsNodePrime, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEtempPtr, B3SOIFDEtempBinding, B3SOIFDeNode, B3SOIFDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDBtempPtr, B3SOIFDBtempBinding, B3SOIFDbNode, B3SOIFDtempNode);
+                if (here->B3SOIFDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPtempPtr, B3SOIFDPtempBinding, B3SOIFDpNode, B3SOIFDtempNode);
+                }
+            }
+            if (here->B3SOIFDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIFDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDBpPtr, B3SOIFDBpBinding, B3SOIFDbNode, B3SOIFDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPbPtr, B3SOIFDPbBinding, B3SOIFDpNode, B3SOIFDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPpPtr, B3SOIFDPpBinding, B3SOIFDpNode, B3SOIFDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPgPtr, B3SOIFDPgBinding, B3SOIFDpNode, B3SOIFDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPdpPtr, B3SOIFDPdpBinding, B3SOIFDpNode, B3SOIFDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPspPtr, B3SOIFDPspBinding, B3SOIFDpNode, B3SOIFDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDPePtr, B3SOIFDPeBinding, B3SOIFDpNode, B3SOIFDeNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEgPtr, B3SOIFDEgBinding, B3SOIFDeNode, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEdpPtr, B3SOIFDEdpBinding, B3SOIFDeNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEspPtr, B3SOIFDEspBinding, B3SOIFDeNode, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGePtr, B3SOIFDGeBinding, B3SOIFDgNode, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPePtr, B3SOIFDDPeBinding, B3SOIFDdNodePrime, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPePtr, B3SOIFDSPeBinding, B3SOIFDsNodePrime, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEbPtr, B3SOIFDEbBinding, B3SOIFDeNode, B3SOIFDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDEePtr, B3SOIFDEeBinding, B3SOIFDeNode, B3SOIFDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGgPtr, B3SOIFDGgBinding, B3SOIFDgNode, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGdpPtr, B3SOIFDGdpBinding, B3SOIFDgNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGspPtr, B3SOIFDGspBinding, B3SOIFDgNode, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPgPtr, B3SOIFDDPgBinding, B3SOIFDdNodePrime, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPdpPtr, B3SOIFDDPdpBinding, B3SOIFDdNodePrime, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPspPtr, B3SOIFDDPspBinding, B3SOIFDdNodePrime, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDPdPtr, B3SOIFDDPdBinding, B3SOIFDdNodePrime, B3SOIFDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPgPtr, B3SOIFDSPgBinding, B3SOIFDsNodePrime, B3SOIFDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPdpPtr, B3SOIFDSPdpBinding, B3SOIFDsNodePrime, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPspPtr, B3SOIFDSPspBinding, B3SOIFDsNodePrime, B3SOIFDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSPsPtr, B3SOIFDSPsBinding, B3SOIFDsNodePrime, B3SOIFDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDdPtr, B3SOIFDDdBinding, B3SOIFDdNode, B3SOIFDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDdpPtr, B3SOIFDDdpBinding, B3SOIFDdNode, B3SOIFDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSsPtr, B3SOIFDSsBinding, B3SOIFDsNode, B3SOIFDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDSspPtr, B3SOIFDSspBinding, B3SOIFDsNode, B3SOIFDsNodePrime);
+            if ((here->B3SOIFDdebugMod > 1) || (here->B3SOIFDdebugMod == -1))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVbsPtr, B3SOIFDVbsBinding, B3SOIFDvbsNode, B3SOIFDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIdsPtr, B3SOIFDIdsBinding, B3SOIFDidsNode, B3SOIFDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIcPtr, B3SOIFDIcBinding, B3SOIFDicNode, B3SOIFDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIbsPtr, B3SOIFDIbsBinding, B3SOIFDibsNode, B3SOIFDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIbdPtr, B3SOIFDIbdBinding, B3SOIFDibdNode, B3SOIFDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIiiPtr, B3SOIFDIiiBinding, B3SOIFDiiiNode, B3SOIFDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIgidlPtr, B3SOIFDIgidlBinding, B3SOIFDigidlNode, B3SOIFDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDItunPtr, B3SOIFDItunBinding, B3SOIFDitunNode, B3SOIFDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDIbpPtr, B3SOIFDIbpBinding, B3SOIFDibpNode, B3SOIFDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDAbeffPtr, B3SOIFDAbeffBinding, B3SOIFDabeffNode, B3SOIFDabeffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVbs0effPtr, B3SOIFDVbs0effBinding, B3SOIFDvbs0effNode, B3SOIFDvbs0effNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVbseffPtr, B3SOIFDVbseffBinding, B3SOIFDvbseffNode, B3SOIFDvbseffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDXcPtr, B3SOIFDXcBinding, B3SOIFDxcNode, B3SOIFDxcNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDCbbPtr, B3SOIFDCbbBinding, B3SOIFDcbbNode, B3SOIFDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDCbdPtr, B3SOIFDCbdBinding, B3SOIFDcbdNode, B3SOIFDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDCbgPtr, B3SOIFDCbgBinding, B3SOIFDcbgNode, B3SOIFDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDqbPtr, B3SOIFDqbBinding, B3SOIFDqbNode, B3SOIFDqbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQbfPtr, B3SOIFDQbfBinding, B3SOIFDqbfNode, B3SOIFDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQjsPtr, B3SOIFDQjsBinding, B3SOIFDqjsNode, B3SOIFDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQjdPtr, B3SOIFDQjdBinding, B3SOIFDqjdNode, B3SOIFDqjdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGmPtr, B3SOIFDGmBinding, B3SOIFDgmNode, B3SOIFDgmNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGmbsPtr, B3SOIFDGmbsBinding, B3SOIFDgmbsNode, B3SOIFDgmbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGdsPtr, B3SOIFDGdsBinding, B3SOIFDgdsNode, B3SOIFDgdsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDGmePtr, B3SOIFDGmeBinding, B3SOIFDgmeNode, B3SOIFDgmeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVbs0teffPtr, B3SOIFDVbs0teffBinding, B3SOIFDvbs0teffNode, B3SOIFDvbs0teffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVthPtr, B3SOIFDVthBinding, B3SOIFDvthNode, B3SOIFDvthNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVgsteffPtr, B3SOIFDVgsteffBinding, B3SOIFDvgsteffNode, B3SOIFDvgsteffNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDXcsatPtr, B3SOIFDXcsatBinding, B3SOIFDxcsatNode, B3SOIFDxcsatNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVcscvPtr, B3SOIFDVcscvBinding, B3SOIFDvcscvNode, B3SOIFDvcscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDVdscvPtr, B3SOIFDVdscvBinding, B3SOIFDvdscvNode, B3SOIFDvdscvNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDCbePtr, B3SOIFDCbeBinding, B3SOIFDcbeNode, B3SOIFDcbeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDum1Ptr, B3SOIFDDum1Binding, B3SOIFDdum1Node, B3SOIFDdum1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDum2Ptr, B3SOIFDDum2Binding, B3SOIFDdum2Node, B3SOIFDdum2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDum3Ptr, B3SOIFDDum3Binding, B3SOIFDdum3Node, B3SOIFDdum3Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDum4Ptr, B3SOIFDDum4Binding, B3SOIFDdum4Node, B3SOIFDdum4Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDDum5Ptr, B3SOIFDDum5Binding, B3SOIFDdum5Node, B3SOIFDdum5Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQaccPtr, B3SOIFDQaccBinding, B3SOIFDqaccNode, B3SOIFDqaccNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQsub0Ptr, B3SOIFDQsub0Binding, B3SOIFDqsub0Node, B3SOIFDqsub0Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQsubs1Ptr, B3SOIFDQsubs1Binding, B3SOIFDqsubs1Node, B3SOIFDqsubs1Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDQsubs2Ptr, B3SOIFDQsubs2Binding, B3SOIFDqsubs2Node, B3SOIFDqsubs2Node);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDqePtr, B3SOIFDqeBinding, B3SOIFDqeNode, B3SOIFDqeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDqdPtr, B3SOIFDqdBinding, B3SOIFDqdNode, B3SOIFDqdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIFDqgPtr, B3SOIFDqgBinding, B3SOIFDqgNode, B3SOIFDqgNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3soi_fd/b3soifddef.h

@@ -420,6 +420,94 @@ typedef struct sB3SOIFDinstance
         double **B3SOIFDnVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *B3SOIFDTemptempBinding ;
+    BindElement *B3SOIFDTempdpBinding ;
+    BindElement *B3SOIFDTempspBinding ;
+    BindElement *B3SOIFDTempgBinding ;
+    BindElement *B3SOIFDTempbBinding ;
+    BindElement *B3SOIFDTempeBinding ;
+    BindElement *B3SOIFDGtempBinding ;
+    BindElement *B3SOIFDDPtempBinding ;
+    BindElement *B3SOIFDSPtempBinding ;
+    BindElement *B3SOIFDEtempBinding ;
+    BindElement *B3SOIFDBtempBinding ;
+    BindElement *B3SOIFDPtempBinding ;
+    BindElement *B3SOIFDBpBinding ;
+    BindElement *B3SOIFDPbBinding ;
+    BindElement *B3SOIFDPpBinding ;
+    BindElement *B3SOIFDPgBinding ;
+    BindElement *B3SOIFDPdpBinding ;
+    BindElement *B3SOIFDPspBinding ;
+    BindElement *B3SOIFDPeBinding ;
+    BindElement *B3SOIFDEgBinding ;
+    BindElement *B3SOIFDEdpBinding ;
+    BindElement *B3SOIFDEspBinding ;
+    BindElement *B3SOIFDGeBinding ;
+    BindElement *B3SOIFDDPeBinding ;
+    BindElement *B3SOIFDSPeBinding ;
+    BindElement *B3SOIFDEbBinding ;
+    BindElement *B3SOIFDEeBinding ;
+    BindElement *B3SOIFDGgBinding ;
+    BindElement *B3SOIFDGdpBinding ;
+    BindElement *B3SOIFDGspBinding ;
+    BindElement *B3SOIFDDPgBinding ;
+    BindElement *B3SOIFDDPdpBinding ;
+    BindElement *B3SOIFDDPspBinding ;
+    BindElement *B3SOIFDDPdBinding ;
+    BindElement *B3SOIFDSPgBinding ;
+    BindElement *B3SOIFDSPdpBinding ;
+    BindElement *B3SOIFDSPspBinding ;
+    BindElement *B3SOIFDSPsBinding ;
+    BindElement *B3SOIFDDdBinding ;
+    BindElement *B3SOIFDDdpBinding ;
+    BindElement *B3SOIFDSsBinding ;
+    BindElement *B3SOIFDSspBinding ;
+    BindElement *B3SOIFDVbsBinding ;
+    BindElement *B3SOIFDIdsBinding ;
+    BindElement *B3SOIFDIcBinding ;
+    BindElement *B3SOIFDIbsBinding ;
+    BindElement *B3SOIFDIbdBinding ;
+    BindElement *B3SOIFDIiiBinding ;
+    BindElement *B3SOIFDIgidlBinding ;
+    BindElement *B3SOIFDItunBinding ;
+    BindElement *B3SOIFDIbpBinding ;
+    BindElement *B3SOIFDAbeffBinding ;
+    BindElement *B3SOIFDVbs0effBinding ;
+    BindElement *B3SOIFDVbseffBinding ;
+    BindElement *B3SOIFDXcBinding ;
+    BindElement *B3SOIFDCbbBinding ;
+    BindElement *B3SOIFDCbdBinding ;
+    BindElement *B3SOIFDCbgBinding ;
+    BindElement *B3SOIFDqbBinding ;
+    BindElement *B3SOIFDQbfBinding ;
+    BindElement *B3SOIFDQjsBinding ;
+    BindElement *B3SOIFDQjdBinding ;
+    BindElement *B3SOIFDGmBinding ;
+    BindElement *B3SOIFDGmbsBinding ;
+    BindElement *B3SOIFDGdsBinding ;
+    BindElement *B3SOIFDGmeBinding ;
+    BindElement *B3SOIFDVbs0teffBinding ;
+    BindElement *B3SOIFDVthBinding ;
+    BindElement *B3SOIFDVgsteffBinding ;
+    BindElement *B3SOIFDXcsatBinding ;
+    BindElement *B3SOIFDVcscvBinding ;
+    BindElement *B3SOIFDVdscvBinding ;
+    BindElement *B3SOIFDCbeBinding ;
+    BindElement *B3SOIFDDum1Binding ;
+    BindElement *B3SOIFDDum2Binding ;
+    BindElement *B3SOIFDDum3Binding ;
+    BindElement *B3SOIFDDum4Binding ;
+    BindElement *B3SOIFDDum5Binding ;
+    BindElement *B3SOIFDQaccBinding ;
+    BindElement *B3SOIFDQsub0Binding ;
+    BindElement *B3SOIFDQsubs1Binding ;
+    BindElement *B3SOIFDQsubs2Binding ;
+    BindElement *B3SOIFDqeBinding ;
+    BindElement *B3SOIFDqdBinding ;
+    BindElement *B3SOIFDqgBinding ;
+#endif
+
 } B3SOIFDinstance ;
 
 struct b3soifdSizeDependParam

src/spicelib/devices/bsim3soi_fd/b3soifdext.h

@@ -26,3 +26,8 @@ extern int B3SOIFDtrunc(GENmodel*,CKTcircuit*,double*);
 extern int B3SOIFDnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int B3SOIFDunsetup(GENmodel*,CKTcircuit*);
 
+#ifdef KLU
+extern int B3SOIFDbindCSC (GENmodel*, CKTcircuit*) ;
+extern int B3SOIFDbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B3SOIFDbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3soi_fd/b3soifdinit.c

@@ -64,6 +64,12 @@ SPICEdev B3SOIFDinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B3SOIFDbindCSC,
+    .DEVbindCSCComplex = B3SOIFDbindCSCComplex,
+    .DEVbindCSCComplexToReal = B3SOIFDbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3soi_pd/Makefile.am

@@ -25,6 +25,9 @@ libbsim3soipd_la_SOURCES = \
 	b3soipditf.h
 
 
+if KLU_WANTED
+libbsim3soipd_la_SOURCES += b3soipdbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3soi_pd/b3soipdbindCSC.c

@@ -0,0 +1,323 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "b3soipddef.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B3SOIPDbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIPDmodel *model = (B3SOIPDmodel *)inModel ;
+    B3SOIPDinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B3SOIPD models */
+    for ( ; model != NULL ; model = B3SOIPDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIPDinstances(model); here != NULL ; here = B3SOIPDnextInstance(here))
+        {
+            if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0))
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIPDTemptempPtr, B3SOIPDTemptempBinding, B3SOIPDtempNode, B3SOIPDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDTempdpPtr, B3SOIPDTempdpBinding, B3SOIPDtempNode, B3SOIPDdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDTempspPtr, B3SOIPDTempspBinding, B3SOIPDtempNode, B3SOIPDsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDTempgPtr, B3SOIPDTempgBinding, B3SOIPDtempNode, B3SOIPDgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDTempbPtr, B3SOIPDTempbBinding, B3SOIPDtempNode, B3SOIPDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDGtempPtr, B3SOIPDGtempBinding, B3SOIPDgNode, B3SOIPDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDDPtempPtr, B3SOIPDDPtempBinding, B3SOIPDdNodePrime, B3SOIPDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDSPtempPtr, B3SOIPDSPtempBinding, B3SOIPDsNodePrime, B3SOIPDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDEtempPtr, B3SOIPDEtempBinding, B3SOIPDeNode, B3SOIPDtempNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDBtempPtr, B3SOIPDBtempBinding, B3SOIPDbNode, B3SOIPDtempNode);
+                if (here->B3SOIPDbodyMod == 1)
+                {
+                    CREATE_KLU_BINDING_TABLE(B3SOIPDPtempPtr, B3SOIPDPtempBinding, B3SOIPDpNode, B3SOIPDtempNode);
+                }
+            }
+            if (here->B3SOIPDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIPDbodyMod == 1)
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIPDBpPtr, B3SOIPDBpBinding, B3SOIPDbNode, B3SOIPDpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDPbPtr, B3SOIPDPbBinding, B3SOIPDpNode, B3SOIPDbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDPpPtr, B3SOIPDPpBinding, B3SOIPDpNode, B3SOIPDpNode);
+            }
+            CREATE_KLU_BINDING_TABLE(B3SOIPDEbPtr, B3SOIPDEbBinding, B3SOIPDeNode, B3SOIPDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDGbPtr, B3SOIPDGbBinding, B3SOIPDgNode, B3SOIPDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPbPtr, B3SOIPDDPbBinding, B3SOIPDdNodePrime, B3SOIPDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPbPtr, B3SOIPDSPbBinding, B3SOIPDsNodePrime, B3SOIPDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDBePtr, B3SOIPDBeBinding, B3SOIPDbNode, B3SOIPDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDBgPtr, B3SOIPDBgBinding, B3SOIPDbNode, B3SOIPDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDBdpPtr, B3SOIPDBdpBinding, B3SOIPDbNode, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDBspPtr, B3SOIPDBspBinding, B3SOIPDbNode, B3SOIPDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDBbPtr, B3SOIPDBbBinding, B3SOIPDbNode, B3SOIPDbNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDEgPtr, B3SOIPDEgBinding, B3SOIPDeNode, B3SOIPDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDEdpPtr, B3SOIPDEdpBinding, B3SOIPDeNode, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDEspPtr, B3SOIPDEspBinding, B3SOIPDeNode, B3SOIPDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDGePtr, B3SOIPDGeBinding, B3SOIPDgNode, B3SOIPDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPePtr, B3SOIPDDPeBinding, B3SOIPDdNodePrime, B3SOIPDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPePtr, B3SOIPDSPeBinding, B3SOIPDsNodePrime, B3SOIPDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDEePtr, B3SOIPDEeBinding, B3SOIPDeNode, B3SOIPDeNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDGgPtr, B3SOIPDGgBinding, B3SOIPDgNode, B3SOIPDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDGdpPtr, B3SOIPDGdpBinding, B3SOIPDgNode, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDGspPtr, B3SOIPDGspBinding, B3SOIPDgNode, B3SOIPDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPgPtr, B3SOIPDDPgBinding, B3SOIPDdNodePrime, B3SOIPDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPdpPtr, B3SOIPDDPdpBinding, B3SOIPDdNodePrime, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPspPtr, B3SOIPDDPspBinding, B3SOIPDdNodePrime, B3SOIPDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDPdPtr, B3SOIPDDPdBinding, B3SOIPDdNodePrime, B3SOIPDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPgPtr, B3SOIPDSPgBinding, B3SOIPDsNodePrime, B3SOIPDgNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPdpPtr, B3SOIPDSPdpBinding, B3SOIPDsNodePrime, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPspPtr, B3SOIPDSPspBinding, B3SOIPDsNodePrime, B3SOIPDsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSPsPtr, B3SOIPDSPsBinding, B3SOIPDsNodePrime, B3SOIPDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDdPtr, B3SOIPDDdBinding, B3SOIPDdNode, B3SOIPDdNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDDdpPtr, B3SOIPDDdpBinding, B3SOIPDdNode, B3SOIPDdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSsPtr, B3SOIPDSsBinding, B3SOIPDsNode, B3SOIPDsNode);
+            CREATE_KLU_BINDING_TABLE(B3SOIPDSspPtr, B3SOIPDSspBinding, B3SOIPDsNode, B3SOIPDsNodePrime);
+            if (here->B3SOIPDdebugMod != 0)
+            {
+                CREATE_KLU_BINDING_TABLE(B3SOIPDVbsPtr, B3SOIPDVbsBinding, B3SOIPDvbsNode, B3SOIPDvbsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIdsPtr, B3SOIPDIdsBinding, B3SOIPDidsNode, B3SOIPDidsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIcPtr, B3SOIPDIcBinding, B3SOIPDicNode, B3SOIPDicNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIbsPtr, B3SOIPDIbsBinding, B3SOIPDibsNode, B3SOIPDibsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIbdPtr, B3SOIPDIbdBinding, B3SOIPDibdNode, B3SOIPDibdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIiiPtr, B3SOIPDIiiBinding, B3SOIPDiiiNode, B3SOIPDiiiNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIgPtr, B3SOIPDIgBinding, B3SOIPDigNode, B3SOIPDigNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDGiggPtr, B3SOIPDGiggBinding, B3SOIPDgiggNode, B3SOIPDgiggNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDGigdPtr, B3SOIPDGigdBinding, B3SOIPDgigdNode, B3SOIPDgigdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDGigbPtr, B3SOIPDGigbBinding, B3SOIPDgigbNode, B3SOIPDgigbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIgidlPtr, B3SOIPDIgidlBinding, B3SOIPDigidlNode, B3SOIPDigidlNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDItunPtr, B3SOIPDItunBinding, B3SOIPDitunNode, B3SOIPDitunNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDIbpPtr, B3SOIPDIbpBinding, B3SOIPDibpNode, B3SOIPDibpNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDCbbPtr, B3SOIPDCbbBinding, B3SOIPDcbbNode, B3SOIPDcbbNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDCbdPtr, B3SOIPDCbdBinding, B3SOIPDcbdNode, B3SOIPDcbdNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDCbgPtr, B3SOIPDCbgBinding, B3SOIPDcbgNode, B3SOIPDcbgNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDQbfPtr, B3SOIPDQbfBinding, B3SOIPDqbfNode, B3SOIPDqbfNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDQjsPtr, B3SOIPDQjsBinding, B3SOIPDqjsNode, B3SOIPDqjsNode);
+                CREATE_KLU_BINDING_TABLE(B3SOIPDQjdPtr, B3SOIPDQjdBinding, B3SOIPDqjdNode, B3SOIPDqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIPDbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIPDmodel *model = (B3SOIPDmodel *)inModel ;
+    B3SOIPDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIPD models */
+    for ( ; model != NULL ; model = B3SOIPDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIPDinstances(model); here != NULL ; here = B3SOIPDnextInstance(here))
+        {
+            if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDTemptempPtr, B3SOIPDTemptempBinding, B3SOIPDtempNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDTempdpPtr, B3SOIPDTempdpBinding, B3SOIPDtempNode, B3SOIPDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDTempspPtr, B3SOIPDTempspBinding, B3SOIPDtempNode, B3SOIPDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDTempgPtr, B3SOIPDTempgBinding, B3SOIPDtempNode, B3SOIPDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDTempbPtr, B3SOIPDTempbBinding, B3SOIPDtempNode, B3SOIPDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGtempPtr, B3SOIPDGtempBinding, B3SOIPDgNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPtempPtr, B3SOIPDDPtempBinding, B3SOIPDdNodePrime, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPtempPtr, B3SOIPDSPtempBinding, B3SOIPDsNodePrime, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEtempPtr, B3SOIPDEtempBinding, B3SOIPDeNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBtempPtr, B3SOIPDBtempBinding, B3SOIPDbNode, B3SOIPDtempNode);
+                if (here->B3SOIPDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDPtempPtr, B3SOIPDPtempBinding, B3SOIPDpNode, B3SOIPDtempNode);
+                }
+            }
+            if (here->B3SOIPDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIPDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBpPtr, B3SOIPDBpBinding, B3SOIPDbNode, B3SOIPDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDPbPtr, B3SOIPDPbBinding, B3SOIPDpNode, B3SOIPDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDPpPtr, B3SOIPDPpBinding, B3SOIPDpNode, B3SOIPDpNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEbPtr, B3SOIPDEbBinding, B3SOIPDeNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGbPtr, B3SOIPDGbBinding, B3SOIPDgNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPbPtr, B3SOIPDDPbBinding, B3SOIPDdNodePrime, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPbPtr, B3SOIPDSPbBinding, B3SOIPDsNodePrime, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBePtr, B3SOIPDBeBinding, B3SOIPDbNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBgPtr, B3SOIPDBgBinding, B3SOIPDbNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBdpPtr, B3SOIPDBdpBinding, B3SOIPDbNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBspPtr, B3SOIPDBspBinding, B3SOIPDbNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDBbPtr, B3SOIPDBbBinding, B3SOIPDbNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEgPtr, B3SOIPDEgBinding, B3SOIPDeNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEdpPtr, B3SOIPDEdpBinding, B3SOIPDeNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEspPtr, B3SOIPDEspBinding, B3SOIPDeNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGePtr, B3SOIPDGeBinding, B3SOIPDgNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPePtr, B3SOIPDDPeBinding, B3SOIPDdNodePrime, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPePtr, B3SOIPDSPeBinding, B3SOIPDsNodePrime, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDEePtr, B3SOIPDEeBinding, B3SOIPDeNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGgPtr, B3SOIPDGgBinding, B3SOIPDgNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGdpPtr, B3SOIPDGdpBinding, B3SOIPDgNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGspPtr, B3SOIPDGspBinding, B3SOIPDgNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPgPtr, B3SOIPDDPgBinding, B3SOIPDdNodePrime, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPdpPtr, B3SOIPDDPdpBinding, B3SOIPDdNodePrime, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPspPtr, B3SOIPDDPspBinding, B3SOIPDdNodePrime, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDPdPtr, B3SOIPDDPdBinding, B3SOIPDdNodePrime, B3SOIPDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPgPtr, B3SOIPDSPgBinding, B3SOIPDsNodePrime, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPdpPtr, B3SOIPDSPdpBinding, B3SOIPDsNodePrime, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPspPtr, B3SOIPDSPspBinding, B3SOIPDsNodePrime, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSPsPtr, B3SOIPDSPsBinding, B3SOIPDsNodePrime, B3SOIPDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDdPtr, B3SOIPDDdBinding, B3SOIPDdNode, B3SOIPDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDDdpPtr, B3SOIPDDdpBinding, B3SOIPDdNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSsPtr, B3SOIPDSsBinding, B3SOIPDsNode, B3SOIPDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDSspPtr, B3SOIPDSspBinding, B3SOIPDsNode, B3SOIPDsNodePrime);
+            if (here->B3SOIPDdebugMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDVbsPtr, B3SOIPDVbsBinding, B3SOIPDvbsNode, B3SOIPDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIdsPtr, B3SOIPDIdsBinding, B3SOIPDidsNode, B3SOIPDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIcPtr, B3SOIPDIcBinding, B3SOIPDicNode, B3SOIPDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIbsPtr, B3SOIPDIbsBinding, B3SOIPDibsNode, B3SOIPDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIbdPtr, B3SOIPDIbdBinding, B3SOIPDibdNode, B3SOIPDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIiiPtr, B3SOIPDIiiBinding, B3SOIPDiiiNode, B3SOIPDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIgPtr, B3SOIPDIgBinding, B3SOIPDigNode, B3SOIPDigNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGiggPtr, B3SOIPDGiggBinding, B3SOIPDgiggNode, B3SOIPDgiggNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGigdPtr, B3SOIPDGigdBinding, B3SOIPDgigdNode, B3SOIPDgigdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDGigbPtr, B3SOIPDGigbBinding, B3SOIPDgigbNode, B3SOIPDgigbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIgidlPtr, B3SOIPDIgidlBinding, B3SOIPDigidlNode, B3SOIPDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDItunPtr, B3SOIPDItunBinding, B3SOIPDitunNode, B3SOIPDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDIbpPtr, B3SOIPDIbpBinding, B3SOIPDibpNode, B3SOIPDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDCbbPtr, B3SOIPDCbbBinding, B3SOIPDcbbNode, B3SOIPDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDCbdPtr, B3SOIPDCbdBinding, B3SOIPDcbdNode, B3SOIPDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDCbgPtr, B3SOIPDCbgBinding, B3SOIPDcbgNode, B3SOIPDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDQbfPtr, B3SOIPDQbfBinding, B3SOIPDqbfNode, B3SOIPDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDQjsPtr, B3SOIPDQjsBinding, B3SOIPDqjsNode, B3SOIPDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B3SOIPDQjdPtr, B3SOIPDQjdBinding, B3SOIPDqjdNode, B3SOIPDqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B3SOIPDbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B3SOIPDmodel *model = (B3SOIPDmodel *)inModel ;
+    B3SOIPDinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B3SOIPD models */
+    for ( ; model != NULL ; model = B3SOIPDnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B3SOIPDinstances(model); here != NULL ; here = B3SOIPDnextInstance(here))
+        {
+            if ((model->B3SOIPDshMod == 1) && (here->B3SOIPDrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDTemptempPtr, B3SOIPDTemptempBinding, B3SOIPDtempNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDTempdpPtr, B3SOIPDTempdpBinding, B3SOIPDtempNode, B3SOIPDdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDTempspPtr, B3SOIPDTempspBinding, B3SOIPDtempNode, B3SOIPDsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDTempgPtr, B3SOIPDTempgBinding, B3SOIPDtempNode, B3SOIPDgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDTempbPtr, B3SOIPDTempbBinding, B3SOIPDtempNode, B3SOIPDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGtempPtr, B3SOIPDGtempBinding, B3SOIPDgNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPtempPtr, B3SOIPDDPtempBinding, B3SOIPDdNodePrime, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPtempPtr, B3SOIPDSPtempBinding, B3SOIPDsNodePrime, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEtempPtr, B3SOIPDEtempBinding, B3SOIPDeNode, B3SOIPDtempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBtempPtr, B3SOIPDBtempBinding, B3SOIPDbNode, B3SOIPDtempNode);
+                if (here->B3SOIPDbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDPtempPtr, B3SOIPDPtempBinding, B3SOIPDpNode, B3SOIPDtempNode);
+                }
+            }
+            if (here->B3SOIPDbodyMod == 2)
+            {
+            }
+            else if (here->B3SOIPDbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBpPtr, B3SOIPDBpBinding, B3SOIPDbNode, B3SOIPDpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDPbPtr, B3SOIPDPbBinding, B3SOIPDpNode, B3SOIPDbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDPpPtr, B3SOIPDPpBinding, B3SOIPDpNode, B3SOIPDpNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEbPtr, B3SOIPDEbBinding, B3SOIPDeNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGbPtr, B3SOIPDGbBinding, B3SOIPDgNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPbPtr, B3SOIPDDPbBinding, B3SOIPDdNodePrime, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPbPtr, B3SOIPDSPbBinding, B3SOIPDsNodePrime, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBePtr, B3SOIPDBeBinding, B3SOIPDbNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBgPtr, B3SOIPDBgBinding, B3SOIPDbNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBdpPtr, B3SOIPDBdpBinding, B3SOIPDbNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBspPtr, B3SOIPDBspBinding, B3SOIPDbNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDBbPtr, B3SOIPDBbBinding, B3SOIPDbNode, B3SOIPDbNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEgPtr, B3SOIPDEgBinding, B3SOIPDeNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEdpPtr, B3SOIPDEdpBinding, B3SOIPDeNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEspPtr, B3SOIPDEspBinding, B3SOIPDeNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGePtr, B3SOIPDGeBinding, B3SOIPDgNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPePtr, B3SOIPDDPeBinding, B3SOIPDdNodePrime, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPePtr, B3SOIPDSPeBinding, B3SOIPDsNodePrime, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDEePtr, B3SOIPDEeBinding, B3SOIPDeNode, B3SOIPDeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGgPtr, B3SOIPDGgBinding, B3SOIPDgNode, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGdpPtr, B3SOIPDGdpBinding, B3SOIPDgNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGspPtr, B3SOIPDGspBinding, B3SOIPDgNode, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPgPtr, B3SOIPDDPgBinding, B3SOIPDdNodePrime, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPdpPtr, B3SOIPDDPdpBinding, B3SOIPDdNodePrime, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPspPtr, B3SOIPDDPspBinding, B3SOIPDdNodePrime, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDPdPtr, B3SOIPDDPdBinding, B3SOIPDdNodePrime, B3SOIPDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPgPtr, B3SOIPDSPgBinding, B3SOIPDsNodePrime, B3SOIPDgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPdpPtr, B3SOIPDSPdpBinding, B3SOIPDsNodePrime, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPspPtr, B3SOIPDSPspBinding, B3SOIPDsNodePrime, B3SOIPDsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSPsPtr, B3SOIPDSPsBinding, B3SOIPDsNodePrime, B3SOIPDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDdPtr, B3SOIPDDdBinding, B3SOIPDdNode, B3SOIPDdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDDdpPtr, B3SOIPDDdpBinding, B3SOIPDdNode, B3SOIPDdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSsPtr, B3SOIPDSsBinding, B3SOIPDsNode, B3SOIPDsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDSspPtr, B3SOIPDSspBinding, B3SOIPDsNode, B3SOIPDsNodePrime);
+            if (here->B3SOIPDdebugMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDVbsPtr, B3SOIPDVbsBinding, B3SOIPDvbsNode, B3SOIPDvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIdsPtr, B3SOIPDIdsBinding, B3SOIPDidsNode, B3SOIPDidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIcPtr, B3SOIPDIcBinding, B3SOIPDicNode, B3SOIPDicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIbsPtr, B3SOIPDIbsBinding, B3SOIPDibsNode, B3SOIPDibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIbdPtr, B3SOIPDIbdBinding, B3SOIPDibdNode, B3SOIPDibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIiiPtr, B3SOIPDIiiBinding, B3SOIPDiiiNode, B3SOIPDiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIgPtr, B3SOIPDIgBinding, B3SOIPDigNode, B3SOIPDigNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGiggPtr, B3SOIPDGiggBinding, B3SOIPDgiggNode, B3SOIPDgiggNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGigdPtr, B3SOIPDGigdBinding, B3SOIPDgigdNode, B3SOIPDgigdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDGigbPtr, B3SOIPDGigbBinding, B3SOIPDgigbNode, B3SOIPDgigbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIgidlPtr, B3SOIPDIgidlBinding, B3SOIPDigidlNode, B3SOIPDigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDItunPtr, B3SOIPDItunBinding, B3SOIPDitunNode, B3SOIPDitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDIbpPtr, B3SOIPDIbpBinding, B3SOIPDibpNode, B3SOIPDibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDCbbPtr, B3SOIPDCbbBinding, B3SOIPDcbbNode, B3SOIPDcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDCbdPtr, B3SOIPDCbdBinding, B3SOIPDcbdNode, B3SOIPDcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDCbgPtr, B3SOIPDCbgBinding, B3SOIPDcbgNode, B3SOIPDcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDQbfPtr, B3SOIPDQbfBinding, B3SOIPDqbfNode, B3SOIPDqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDQjsPtr, B3SOIPDQjsBinding, B3SOIPDqjsNode, B3SOIPDqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B3SOIPDQjdPtr, B3SOIPDQjdBinding, B3SOIPDqjdNode, B3SOIPDqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3soi_pd/b3soipddef.h

@@ -385,6 +385,73 @@ typedef struct sB3SOIPDinstance
         double **B3SOIPDnVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *B3SOIPDTemptempBinding ;
+    BindElement *B3SOIPDTempdpBinding ;
+    BindElement *B3SOIPDTempspBinding ;
+    BindElement *B3SOIPDTempgBinding ;
+    BindElement *B3SOIPDTempbBinding ;
+    BindElement *B3SOIPDGtempBinding ;
+    BindElement *B3SOIPDDPtempBinding ;
+    BindElement *B3SOIPDSPtempBinding ;
+    BindElement *B3SOIPDEtempBinding ;
+    BindElement *B3SOIPDBtempBinding ;
+    BindElement *B3SOIPDPtempBinding ;
+    BindElement *B3SOIPDBpBinding ;
+    BindElement *B3SOIPDPbBinding ;
+    BindElement *B3SOIPDPpBinding ;
+    BindElement *B3SOIPDEbBinding ;
+    BindElement *B3SOIPDGbBinding ;
+    BindElement *B3SOIPDDPbBinding ;
+    BindElement *B3SOIPDSPbBinding ;
+    BindElement *B3SOIPDBeBinding ;
+    BindElement *B3SOIPDBgBinding ;
+    BindElement *B3SOIPDBdpBinding ;
+    BindElement *B3SOIPDBspBinding ;
+    BindElement *B3SOIPDBbBinding ;
+    BindElement *B3SOIPDEgBinding ;
+    BindElement *B3SOIPDEdpBinding ;
+    BindElement *B3SOIPDEspBinding ;
+    BindElement *B3SOIPDGeBinding ;
+    BindElement *B3SOIPDDPeBinding ;
+    BindElement *B3SOIPDSPeBinding ;
+    BindElement *B3SOIPDEeBinding ;
+    BindElement *B3SOIPDGgBinding ;
+    BindElement *B3SOIPDGdpBinding ;
+    BindElement *B3SOIPDGspBinding ;
+    BindElement *B3SOIPDDPgBinding ;
+    BindElement *B3SOIPDDPdpBinding ;
+    BindElement *B3SOIPDDPspBinding ;
+    BindElement *B3SOIPDDPdBinding ;
+    BindElement *B3SOIPDSPgBinding ;
+    BindElement *B3SOIPDSPdpBinding ;
+    BindElement *B3SOIPDSPspBinding ;
+    BindElement *B3SOIPDSPsBinding ;
+    BindElement *B3SOIPDDdBinding ;
+    BindElement *B3SOIPDDdpBinding ;
+    BindElement *B3SOIPDSsBinding ;
+    BindElement *B3SOIPDSspBinding ;
+    BindElement *B3SOIPDVbsBinding ;
+    BindElement *B3SOIPDIdsBinding ;
+    BindElement *B3SOIPDIcBinding ;
+    BindElement *B3SOIPDIbsBinding ;
+    BindElement *B3SOIPDIbdBinding ;
+    BindElement *B3SOIPDIiiBinding ;
+    BindElement *B3SOIPDIgBinding ;
+    BindElement *B3SOIPDGiggBinding ;
+    BindElement *B3SOIPDGigdBinding ;
+    BindElement *B3SOIPDGigbBinding ;
+    BindElement *B3SOIPDIgidlBinding ;
+    BindElement *B3SOIPDItunBinding ;
+    BindElement *B3SOIPDIbpBinding ;
+    BindElement *B3SOIPDCbbBinding ;
+    BindElement *B3SOIPDCbdBinding ;
+    BindElement *B3SOIPDCbgBinding ;
+    BindElement *B3SOIPDQbfBinding ;
+    BindElement *B3SOIPDQjsBinding ;
+    BindElement *B3SOIPDQjdBinding ;
+#endif
+
 } B3SOIPDinstance ;
 
 struct b3soipdSizeDependParam

src/spicelib/devices/bsim3soi_pd/b3soipdext.h

@@ -25,3 +25,9 @@ extern int B3SOIPDtemp(GENmodel*,CKTcircuit*);
 extern int B3SOIPDtrunc(GENmodel*,CKTcircuit*,double*);
 extern int B3SOIPDnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int B3SOIPDunsetup(GENmodel*,CKTcircuit*);
+
+#ifdef KLU
+extern int B3SOIPDbindCSC (GENmodel*, CKTcircuit*) ;
+extern int B3SOIPDbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B3SOIPDbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3soi_pd/b3soipdinit.c

@@ -65,6 +65,12 @@ SPICEdev B3SOIPDinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B3SOIPDbindCSC,
+    .DEVbindCSCComplex = B3SOIPDbindCSCComplex,
+    .DEVbindCSCComplexToReal = B3SOIPDbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3v0/Makefile.am

@@ -24,6 +24,9 @@ libbsim3v0_la_SOURCES = \
 	bsim3v0itf.h
 
 
+if KLU_WANTED
+libbsim3v0_la_SOURCES += b3v0bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3v0/b3v0bindCSC.c

@@ -0,0 +1,179 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim3v0def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM3v0bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v0model *model = (BSIM3v0model *)inModel ;
+    BSIM3v0instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM3v0 models */
+    for ( ; model != NULL ; model = BSIM3v0nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v0instances(model); here != NULL ; here = BSIM3v0nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DdPtr, BSIM3v0DdBinding, BSIM3v0dNode, BSIM3v0dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0GgPtr, BSIM3v0GgBinding, BSIM3v0gNode, BSIM3v0gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SsPtr, BSIM3v0SsBinding, BSIM3v0sNode, BSIM3v0sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0BbPtr, BSIM3v0BbBinding, BSIM3v0bNode, BSIM3v0bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPdpPtr, BSIM3v0DPdpBinding, BSIM3v0dNodePrime, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPspPtr, BSIM3v0SPspBinding, BSIM3v0sNodePrime, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DdpPtr, BSIM3v0DdpBinding, BSIM3v0dNode, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0GbPtr, BSIM3v0GbBinding, BSIM3v0gNode, BSIM3v0bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0GdpPtr, BSIM3v0GdpBinding, BSIM3v0gNode, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0GspPtr, BSIM3v0GspBinding, BSIM3v0gNode, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SspPtr, BSIM3v0SspBinding, BSIM3v0sNode, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0BdpPtr, BSIM3v0BdpBinding, BSIM3v0bNode, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0BspPtr, BSIM3v0BspBinding, BSIM3v0bNode, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPspPtr, BSIM3v0DPspBinding, BSIM3v0dNodePrime, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPdPtr, BSIM3v0DPdBinding, BSIM3v0dNodePrime, BSIM3v0dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0BgPtr, BSIM3v0BgBinding, BSIM3v0bNode, BSIM3v0gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPgPtr, BSIM3v0DPgBinding, BSIM3v0dNodePrime, BSIM3v0gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPgPtr, BSIM3v0SPgBinding, BSIM3v0sNodePrime, BSIM3v0gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPsPtr, BSIM3v0SPsBinding, BSIM3v0sNodePrime, BSIM3v0sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPbPtr, BSIM3v0DPbBinding, BSIM3v0dNodePrime, BSIM3v0bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPbPtr, BSIM3v0SPbBinding, BSIM3v0sNodePrime, BSIM3v0bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPdpPtr, BSIM3v0SPdpBinding, BSIM3v0sNodePrime, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0QqPtr, BSIM3v0QqBinding, BSIM3v0qNode, BSIM3v0qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0QdpPtr, BSIM3v0QdpBinding, BSIM3v0qNode, BSIM3v0dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0QspPtr, BSIM3v0QspBinding, BSIM3v0qNode, BSIM3v0sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0QgPtr, BSIM3v0QgBinding, BSIM3v0qNode, BSIM3v0gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0QbPtr, BSIM3v0QbBinding, BSIM3v0qNode, BSIM3v0bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0DPqPtr, BSIM3v0DPqBinding, BSIM3v0dNodePrime, BSIM3v0qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0SPqPtr, BSIM3v0SPqBinding, BSIM3v0sNodePrime, BSIM3v0qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0GqPtr, BSIM3v0GqBinding, BSIM3v0gNode, BSIM3v0qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v0BqPtr, BSIM3v0BqBinding, BSIM3v0bNode, BSIM3v0qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v0bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v0model *model = (BSIM3v0model *)inModel ;
+    BSIM3v0instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v0 models */
+    for ( ; model != NULL ; model = BSIM3v0nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v0instances(model); here != NULL ; here = BSIM3v0nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DdPtr, BSIM3v0DdBinding, BSIM3v0dNode, BSIM3v0dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0GgPtr, BSIM3v0GgBinding, BSIM3v0gNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SsPtr, BSIM3v0SsBinding, BSIM3v0sNode, BSIM3v0sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0BbPtr, BSIM3v0BbBinding, BSIM3v0bNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPdpPtr, BSIM3v0DPdpBinding, BSIM3v0dNodePrime, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPspPtr, BSIM3v0SPspBinding, BSIM3v0sNodePrime, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DdpPtr, BSIM3v0DdpBinding, BSIM3v0dNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0GbPtr, BSIM3v0GbBinding, BSIM3v0gNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0GdpPtr, BSIM3v0GdpBinding, BSIM3v0gNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0GspPtr, BSIM3v0GspBinding, BSIM3v0gNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SspPtr, BSIM3v0SspBinding, BSIM3v0sNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0BdpPtr, BSIM3v0BdpBinding, BSIM3v0bNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0BspPtr, BSIM3v0BspBinding, BSIM3v0bNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPspPtr, BSIM3v0DPspBinding, BSIM3v0dNodePrime, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPdPtr, BSIM3v0DPdBinding, BSIM3v0dNodePrime, BSIM3v0dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0BgPtr, BSIM3v0BgBinding, BSIM3v0bNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPgPtr, BSIM3v0DPgBinding, BSIM3v0dNodePrime, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPgPtr, BSIM3v0SPgBinding, BSIM3v0sNodePrime, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPsPtr, BSIM3v0SPsBinding, BSIM3v0sNodePrime, BSIM3v0sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPbPtr, BSIM3v0DPbBinding, BSIM3v0dNodePrime, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPbPtr, BSIM3v0SPbBinding, BSIM3v0sNodePrime, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPdpPtr, BSIM3v0SPdpBinding, BSIM3v0sNodePrime, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0QqPtr, BSIM3v0QqBinding, BSIM3v0qNode, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0QdpPtr, BSIM3v0QdpBinding, BSIM3v0qNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0QspPtr, BSIM3v0QspBinding, BSIM3v0qNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0QgPtr, BSIM3v0QgBinding, BSIM3v0qNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0QbPtr, BSIM3v0QbBinding, BSIM3v0qNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0DPqPtr, BSIM3v0DPqBinding, BSIM3v0dNodePrime, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0SPqPtr, BSIM3v0SPqBinding, BSIM3v0sNodePrime, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0GqPtr, BSIM3v0GqBinding, BSIM3v0gNode, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v0BqPtr, BSIM3v0BqBinding, BSIM3v0bNode, BSIM3v0qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v0bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v0model *model = (BSIM3v0model *)inModel ;
+    BSIM3v0instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v0 models */
+    for ( ; model != NULL ; model = BSIM3v0nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v0instances(model); here != NULL ; here = BSIM3v0nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DdPtr, BSIM3v0DdBinding, BSIM3v0dNode, BSIM3v0dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0GgPtr, BSIM3v0GgBinding, BSIM3v0gNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SsPtr, BSIM3v0SsBinding, BSIM3v0sNode, BSIM3v0sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0BbPtr, BSIM3v0BbBinding, BSIM3v0bNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPdpPtr, BSIM3v0DPdpBinding, BSIM3v0dNodePrime, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPspPtr, BSIM3v0SPspBinding, BSIM3v0sNodePrime, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DdpPtr, BSIM3v0DdpBinding, BSIM3v0dNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0GbPtr, BSIM3v0GbBinding, BSIM3v0gNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0GdpPtr, BSIM3v0GdpBinding, BSIM3v0gNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0GspPtr, BSIM3v0GspBinding, BSIM3v0gNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SspPtr, BSIM3v0SspBinding, BSIM3v0sNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0BdpPtr, BSIM3v0BdpBinding, BSIM3v0bNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0BspPtr, BSIM3v0BspBinding, BSIM3v0bNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPspPtr, BSIM3v0DPspBinding, BSIM3v0dNodePrime, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPdPtr, BSIM3v0DPdBinding, BSIM3v0dNodePrime, BSIM3v0dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0BgPtr, BSIM3v0BgBinding, BSIM3v0bNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPgPtr, BSIM3v0DPgBinding, BSIM3v0dNodePrime, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPgPtr, BSIM3v0SPgBinding, BSIM3v0sNodePrime, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPsPtr, BSIM3v0SPsBinding, BSIM3v0sNodePrime, BSIM3v0sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPbPtr, BSIM3v0DPbBinding, BSIM3v0dNodePrime, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPbPtr, BSIM3v0SPbBinding, BSIM3v0sNodePrime, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPdpPtr, BSIM3v0SPdpBinding, BSIM3v0sNodePrime, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0QqPtr, BSIM3v0QqBinding, BSIM3v0qNode, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0QdpPtr, BSIM3v0QdpBinding, BSIM3v0qNode, BSIM3v0dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0QspPtr, BSIM3v0QspBinding, BSIM3v0qNode, BSIM3v0sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0QgPtr, BSIM3v0QgBinding, BSIM3v0qNode, BSIM3v0gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0QbPtr, BSIM3v0QbBinding, BSIM3v0qNode, BSIM3v0bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0DPqPtr, BSIM3v0DPqBinding, BSIM3v0dNodePrime, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0SPqPtr, BSIM3v0SPqBinding, BSIM3v0sNodePrime, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0GqPtr, BSIM3v0GqBinding, BSIM3v0gNode, BSIM3v0qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v0BqPtr, BSIM3v0BqBinding, BSIM3v0bNode, BSIM3v0qNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3v0/bsim3v0def.h

@@ -191,6 +191,40 @@ typedef struct sBSIM3v0instance
         double **BSIM3v0nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM3v0DdBinding ;
+    BindElement *BSIM3v0GgBinding ;
+    BindElement *BSIM3v0SsBinding ;
+    BindElement *BSIM3v0BbBinding ;
+    BindElement *BSIM3v0DPdpBinding ;
+    BindElement *BSIM3v0SPspBinding ;
+    BindElement *BSIM3v0DdpBinding ;
+    BindElement *BSIM3v0GbBinding ;
+    BindElement *BSIM3v0GdpBinding ;
+    BindElement *BSIM3v0GspBinding ;
+    BindElement *BSIM3v0SspBinding ;
+    BindElement *BSIM3v0BdpBinding ;
+    BindElement *BSIM3v0BspBinding ;
+    BindElement *BSIM3v0DPspBinding ;
+    BindElement *BSIM3v0DPdBinding ;
+    BindElement *BSIM3v0BgBinding ;
+    BindElement *BSIM3v0DPgBinding ;
+    BindElement *BSIM3v0SPgBinding ;
+    BindElement *BSIM3v0SPsBinding ;
+    BindElement *BSIM3v0DPbBinding ;
+    BindElement *BSIM3v0SPbBinding ;
+    BindElement *BSIM3v0SPdpBinding ;
+    BindElement *BSIM3v0QqBinding ;
+    BindElement *BSIM3v0QdpBinding ;
+    BindElement *BSIM3v0QspBinding ;
+    BindElement *BSIM3v0QgBinding ;
+    BindElement *BSIM3v0QbBinding ;
+    BindElement *BSIM3v0DPqBinding ;
+    BindElement *BSIM3v0SPqBinding ;
+    BindElement *BSIM3v0GqBinding ;
+    BindElement *BSIM3v0BqBinding ;
+#endif
+
 } BSIM3v0instance ;
 
 struct bsim3v0SizeDependParam

src/spicelib/devices/bsim3v0/bsim3v0ext.h

@@ -25,3 +25,8 @@ extern int BSIM3v0trunc(GENmodel*,CKTcircuit*,double*);
 extern int BSIM3v0noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int  BSIM3v0unsetup(GENmodel *, CKTcircuit *);
 
+#ifdef KLU
+extern int BSIM3v0bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v0bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v0bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3v0/bsim3v0init.c

@@ -65,6 +65,12 @@ SPICEdev B3v0info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM3v0bindCSC,
+    .DEVbindCSCComplex = BSIM3v0bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM3v0bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3v1/Makefile.am

@@ -25,6 +25,9 @@ libbsim3v1_la_SOURCES = \
 	bsim3v1itf.h
 
 
+if KLU_WANTED
+libbsim3v1_la_SOURCES += b3v1bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3v1/b3v1bindCSC.c

@@ -0,0 +1,179 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim3v1def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM3v1bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v1model *model = (BSIM3v1model *)inModel ;
+    BSIM3v1instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM3v1 models */
+    for ( ; model != NULL ; model = BSIM3v1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v1instances(model); here != NULL ; here = BSIM3v1nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DdPtr, BSIM3v1DdBinding, BSIM3v1dNode, BSIM3v1dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1GgPtr, BSIM3v1GgBinding, BSIM3v1gNode, BSIM3v1gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SsPtr, BSIM3v1SsBinding, BSIM3v1sNode, BSIM3v1sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1BbPtr, BSIM3v1BbBinding, BSIM3v1bNode, BSIM3v1bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPdpPtr, BSIM3v1DPdpBinding, BSIM3v1dNodePrime, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPspPtr, BSIM3v1SPspBinding, BSIM3v1sNodePrime, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DdpPtr, BSIM3v1DdpBinding, BSIM3v1dNode, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1GbPtr, BSIM3v1GbBinding, BSIM3v1gNode, BSIM3v1bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1GdpPtr, BSIM3v1GdpBinding, BSIM3v1gNode, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1GspPtr, BSIM3v1GspBinding, BSIM3v1gNode, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SspPtr, BSIM3v1SspBinding, BSIM3v1sNode, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1BdpPtr, BSIM3v1BdpBinding, BSIM3v1bNode, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1BspPtr, BSIM3v1BspBinding, BSIM3v1bNode, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPspPtr, BSIM3v1DPspBinding, BSIM3v1dNodePrime, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPdPtr, BSIM3v1DPdBinding, BSIM3v1dNodePrime, BSIM3v1dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1BgPtr, BSIM3v1BgBinding, BSIM3v1bNode, BSIM3v1gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPgPtr, BSIM3v1DPgBinding, BSIM3v1dNodePrime, BSIM3v1gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPgPtr, BSIM3v1SPgBinding, BSIM3v1sNodePrime, BSIM3v1gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPsPtr, BSIM3v1SPsBinding, BSIM3v1sNodePrime, BSIM3v1sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPbPtr, BSIM3v1DPbBinding, BSIM3v1dNodePrime, BSIM3v1bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPbPtr, BSIM3v1SPbBinding, BSIM3v1sNodePrime, BSIM3v1bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPdpPtr, BSIM3v1SPdpBinding, BSIM3v1sNodePrime, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1QqPtr, BSIM3v1QqBinding, BSIM3v1qNode, BSIM3v1qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1QdpPtr, BSIM3v1QdpBinding, BSIM3v1qNode, BSIM3v1dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1QspPtr, BSIM3v1QspBinding, BSIM3v1qNode, BSIM3v1sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1QgPtr, BSIM3v1QgBinding, BSIM3v1qNode, BSIM3v1gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1QbPtr, BSIM3v1QbBinding, BSIM3v1qNode, BSIM3v1bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1DPqPtr, BSIM3v1DPqBinding, BSIM3v1dNodePrime, BSIM3v1qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1SPqPtr, BSIM3v1SPqBinding, BSIM3v1sNodePrime, BSIM3v1qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1GqPtr, BSIM3v1GqBinding, BSIM3v1gNode, BSIM3v1qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v1BqPtr, BSIM3v1BqBinding, BSIM3v1bNode, BSIM3v1qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v1bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v1model *model = (BSIM3v1model *)inModel ;
+    BSIM3v1instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v1 models */
+    for ( ; model != NULL ; model = BSIM3v1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v1instances(model); here != NULL ; here = BSIM3v1nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DdPtr, BSIM3v1DdBinding, BSIM3v1dNode, BSIM3v1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1GgPtr, BSIM3v1GgBinding, BSIM3v1gNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SsPtr, BSIM3v1SsBinding, BSIM3v1sNode, BSIM3v1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1BbPtr, BSIM3v1BbBinding, BSIM3v1bNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPdpPtr, BSIM3v1DPdpBinding, BSIM3v1dNodePrime, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPspPtr, BSIM3v1SPspBinding, BSIM3v1sNodePrime, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DdpPtr, BSIM3v1DdpBinding, BSIM3v1dNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1GbPtr, BSIM3v1GbBinding, BSIM3v1gNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1GdpPtr, BSIM3v1GdpBinding, BSIM3v1gNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1GspPtr, BSIM3v1GspBinding, BSIM3v1gNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SspPtr, BSIM3v1SspBinding, BSIM3v1sNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1BdpPtr, BSIM3v1BdpBinding, BSIM3v1bNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1BspPtr, BSIM3v1BspBinding, BSIM3v1bNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPspPtr, BSIM3v1DPspBinding, BSIM3v1dNodePrime, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPdPtr, BSIM3v1DPdBinding, BSIM3v1dNodePrime, BSIM3v1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1BgPtr, BSIM3v1BgBinding, BSIM3v1bNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPgPtr, BSIM3v1DPgBinding, BSIM3v1dNodePrime, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPgPtr, BSIM3v1SPgBinding, BSIM3v1sNodePrime, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPsPtr, BSIM3v1SPsBinding, BSIM3v1sNodePrime, BSIM3v1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPbPtr, BSIM3v1DPbBinding, BSIM3v1dNodePrime, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPbPtr, BSIM3v1SPbBinding, BSIM3v1sNodePrime, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPdpPtr, BSIM3v1SPdpBinding, BSIM3v1sNodePrime, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1QqPtr, BSIM3v1QqBinding, BSIM3v1qNode, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1QdpPtr, BSIM3v1QdpBinding, BSIM3v1qNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1QspPtr, BSIM3v1QspBinding, BSIM3v1qNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1QgPtr, BSIM3v1QgBinding, BSIM3v1qNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1QbPtr, BSIM3v1QbBinding, BSIM3v1qNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1DPqPtr, BSIM3v1DPqBinding, BSIM3v1dNodePrime, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1SPqPtr, BSIM3v1SPqBinding, BSIM3v1sNodePrime, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1GqPtr, BSIM3v1GqBinding, BSIM3v1gNode, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v1BqPtr, BSIM3v1BqBinding, BSIM3v1bNode, BSIM3v1qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v1bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v1model *model = (BSIM3v1model *)inModel ;
+    BSIM3v1instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v1 models */
+    for ( ; model != NULL ; model = BSIM3v1nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v1instances(model); here != NULL ; here = BSIM3v1nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DdPtr, BSIM3v1DdBinding, BSIM3v1dNode, BSIM3v1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1GgPtr, BSIM3v1GgBinding, BSIM3v1gNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SsPtr, BSIM3v1SsBinding, BSIM3v1sNode, BSIM3v1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1BbPtr, BSIM3v1BbBinding, BSIM3v1bNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPdpPtr, BSIM3v1DPdpBinding, BSIM3v1dNodePrime, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPspPtr, BSIM3v1SPspBinding, BSIM3v1sNodePrime, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DdpPtr, BSIM3v1DdpBinding, BSIM3v1dNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1GbPtr, BSIM3v1GbBinding, BSIM3v1gNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1GdpPtr, BSIM3v1GdpBinding, BSIM3v1gNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1GspPtr, BSIM3v1GspBinding, BSIM3v1gNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SspPtr, BSIM3v1SspBinding, BSIM3v1sNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1BdpPtr, BSIM3v1BdpBinding, BSIM3v1bNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1BspPtr, BSIM3v1BspBinding, BSIM3v1bNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPspPtr, BSIM3v1DPspBinding, BSIM3v1dNodePrime, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPdPtr, BSIM3v1DPdBinding, BSIM3v1dNodePrime, BSIM3v1dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1BgPtr, BSIM3v1BgBinding, BSIM3v1bNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPgPtr, BSIM3v1DPgBinding, BSIM3v1dNodePrime, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPgPtr, BSIM3v1SPgBinding, BSIM3v1sNodePrime, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPsPtr, BSIM3v1SPsBinding, BSIM3v1sNodePrime, BSIM3v1sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPbPtr, BSIM3v1DPbBinding, BSIM3v1dNodePrime, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPbPtr, BSIM3v1SPbBinding, BSIM3v1sNodePrime, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPdpPtr, BSIM3v1SPdpBinding, BSIM3v1sNodePrime, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1QqPtr, BSIM3v1QqBinding, BSIM3v1qNode, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1QdpPtr, BSIM3v1QdpBinding, BSIM3v1qNode, BSIM3v1dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1QspPtr, BSIM3v1QspBinding, BSIM3v1qNode, BSIM3v1sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1QgPtr, BSIM3v1QgBinding, BSIM3v1qNode, BSIM3v1gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1QbPtr, BSIM3v1QbBinding, BSIM3v1qNode, BSIM3v1bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1DPqPtr, BSIM3v1DPqBinding, BSIM3v1dNodePrime, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1SPqPtr, BSIM3v1SPqBinding, BSIM3v1sNodePrime, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1GqPtr, BSIM3v1GqBinding, BSIM3v1gNode, BSIM3v1qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v1BqPtr, BSIM3v1BqBinding, BSIM3v1bNode, BSIM3v1qNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3v1/bsim3v1def.h

@@ -192,6 +192,40 @@ typedef struct sBSIM3v1instance
         double **BSIM3v1nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM3v1DdBinding ;
+    BindElement *BSIM3v1GgBinding ;
+    BindElement *BSIM3v1SsBinding ;
+    BindElement *BSIM3v1BbBinding ;
+    BindElement *BSIM3v1DPdpBinding ;
+    BindElement *BSIM3v1SPspBinding ;
+    BindElement *BSIM3v1DdpBinding ;
+    BindElement *BSIM3v1GbBinding ;
+    BindElement *BSIM3v1GdpBinding ;
+    BindElement *BSIM3v1GspBinding ;
+    BindElement *BSIM3v1SspBinding ;
+    BindElement *BSIM3v1BdpBinding ;
+    BindElement *BSIM3v1BspBinding ;
+    BindElement *BSIM3v1DPspBinding ;
+    BindElement *BSIM3v1DPdBinding ;
+    BindElement *BSIM3v1BgBinding ;
+    BindElement *BSIM3v1DPgBinding ;
+    BindElement *BSIM3v1SPgBinding ;
+    BindElement *BSIM3v1SPsBinding ;
+    BindElement *BSIM3v1DPbBinding ;
+    BindElement *BSIM3v1SPbBinding ;
+    BindElement *BSIM3v1SPdpBinding ;
+    BindElement *BSIM3v1QqBinding ;
+    BindElement *BSIM3v1QdpBinding ;
+    BindElement *BSIM3v1QspBinding ;
+    BindElement *BSIM3v1QgBinding ;
+    BindElement *BSIM3v1QbBinding ;
+    BindElement *BSIM3v1DPqBinding ;
+    BindElement *BSIM3v1SPqBinding ;
+    BindElement *BSIM3v1GqBinding ;
+    BindElement *BSIM3v1BqBinding ;
+#endif
+
 } BSIM3v1instance ;
 
 struct bsim3v1SizeDependParam

src/spicelib/devices/bsim3v1/bsim3v1ext.h

@@ -26,3 +26,8 @@ extern int BSIM3v1trunc(GENmodel *, CKTcircuit *, double *);
 extern int BSIM3v1noise(int, int, GENmodel *, CKTcircuit *, Ndata *, double *);
 extern int BSIM3v1unsetup(GENmodel *, CKTcircuit *);
 
+#ifdef KLU
+extern int BSIM3v1bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v1bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v1bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3v1/bsim3v1init.c

@@ -65,6 +65,12 @@ SPICEdev BSIM3v1info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM3v1bindCSC,
+    .DEVbindCSCComplex = BSIM3v1bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM3v1bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim3v32/Makefile.am

@@ -27,6 +27,9 @@ libbsim3v32_la_SOURCES = \
 	bsim3v32itf.h
 
 
+if KLU_WANTED
+libbsim3v32_la_SOURCES += b3v32bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim3v32/b3v32bindCSC.c

@@ -0,0 +1,179 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim3v32def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM3v32bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v32model *model = (BSIM3v32model *)inModel ;
+    BSIM3v32instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM3v32 models */
+    for ( ; model != NULL ; model = BSIM3v32nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v32instances(model); here != NULL ; here = BSIM3v32nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DdPtr, BSIM3v32DdBinding, BSIM3v32dNode, BSIM3v32dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32GgPtr, BSIM3v32GgBinding, BSIM3v32gNode, BSIM3v32gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SsPtr, BSIM3v32SsBinding, BSIM3v32sNode, BSIM3v32sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32BbPtr, BSIM3v32BbBinding, BSIM3v32bNode, BSIM3v32bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPdpPtr, BSIM3v32DPdpBinding, BSIM3v32dNodePrime, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPspPtr, BSIM3v32SPspBinding, BSIM3v32sNodePrime, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DdpPtr, BSIM3v32DdpBinding, BSIM3v32dNode, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32GbPtr, BSIM3v32GbBinding, BSIM3v32gNode, BSIM3v32bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32GdpPtr, BSIM3v32GdpBinding, BSIM3v32gNode, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32GspPtr, BSIM3v32GspBinding, BSIM3v32gNode, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SspPtr, BSIM3v32SspBinding, BSIM3v32sNode, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32BdpPtr, BSIM3v32BdpBinding, BSIM3v32bNode, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32BspPtr, BSIM3v32BspBinding, BSIM3v32bNode, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPspPtr, BSIM3v32DPspBinding, BSIM3v32dNodePrime, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPdPtr, BSIM3v32DPdBinding, BSIM3v32dNodePrime, BSIM3v32dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32BgPtr, BSIM3v32BgBinding, BSIM3v32bNode, BSIM3v32gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPgPtr, BSIM3v32DPgBinding, BSIM3v32dNodePrime, BSIM3v32gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPgPtr, BSIM3v32SPgBinding, BSIM3v32sNodePrime, BSIM3v32gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPsPtr, BSIM3v32SPsBinding, BSIM3v32sNodePrime, BSIM3v32sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPbPtr, BSIM3v32DPbBinding, BSIM3v32dNodePrime, BSIM3v32bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPbPtr, BSIM3v32SPbBinding, BSIM3v32sNodePrime, BSIM3v32bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPdpPtr, BSIM3v32SPdpBinding, BSIM3v32sNodePrime, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32QqPtr, BSIM3v32QqBinding, BSIM3v32qNode, BSIM3v32qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32QdpPtr, BSIM3v32QdpBinding, BSIM3v32qNode, BSIM3v32dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32QspPtr, BSIM3v32QspBinding, BSIM3v32qNode, BSIM3v32sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32QgPtr, BSIM3v32QgBinding, BSIM3v32qNode, BSIM3v32gNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32QbPtr, BSIM3v32QbBinding, BSIM3v32qNode, BSIM3v32bNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32DPqPtr, BSIM3v32DPqBinding, BSIM3v32dNodePrime, BSIM3v32qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32SPqPtr, BSIM3v32SPqBinding, BSIM3v32sNodePrime, BSIM3v32qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32GqPtr, BSIM3v32GqBinding, BSIM3v32gNode, BSIM3v32qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM3v32BqPtr, BSIM3v32BqBinding, BSIM3v32bNode, BSIM3v32qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v32bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v32model *model = (BSIM3v32model *)inModel ;
+    BSIM3v32instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v32 models */
+    for ( ; model != NULL ; model = BSIM3v32nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v32instances(model); here != NULL ; here = BSIM3v32nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DdPtr, BSIM3v32DdBinding, BSIM3v32dNode, BSIM3v32dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32GgPtr, BSIM3v32GgBinding, BSIM3v32gNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SsPtr, BSIM3v32SsBinding, BSIM3v32sNode, BSIM3v32sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32BbPtr, BSIM3v32BbBinding, BSIM3v32bNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPdpPtr, BSIM3v32DPdpBinding, BSIM3v32dNodePrime, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPspPtr, BSIM3v32SPspBinding, BSIM3v32sNodePrime, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DdpPtr, BSIM3v32DdpBinding, BSIM3v32dNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32GbPtr, BSIM3v32GbBinding, BSIM3v32gNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32GdpPtr, BSIM3v32GdpBinding, BSIM3v32gNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32GspPtr, BSIM3v32GspBinding, BSIM3v32gNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SspPtr, BSIM3v32SspBinding, BSIM3v32sNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32BdpPtr, BSIM3v32BdpBinding, BSIM3v32bNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32BspPtr, BSIM3v32BspBinding, BSIM3v32bNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPspPtr, BSIM3v32DPspBinding, BSIM3v32dNodePrime, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPdPtr, BSIM3v32DPdBinding, BSIM3v32dNodePrime, BSIM3v32dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32BgPtr, BSIM3v32BgBinding, BSIM3v32bNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPgPtr, BSIM3v32DPgBinding, BSIM3v32dNodePrime, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPgPtr, BSIM3v32SPgBinding, BSIM3v32sNodePrime, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPsPtr, BSIM3v32SPsBinding, BSIM3v32sNodePrime, BSIM3v32sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPbPtr, BSIM3v32DPbBinding, BSIM3v32dNodePrime, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPbPtr, BSIM3v32SPbBinding, BSIM3v32sNodePrime, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPdpPtr, BSIM3v32SPdpBinding, BSIM3v32sNodePrime, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32QqPtr, BSIM3v32QqBinding, BSIM3v32qNode, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32QdpPtr, BSIM3v32QdpBinding, BSIM3v32qNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32QspPtr, BSIM3v32QspBinding, BSIM3v32qNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32QgPtr, BSIM3v32QgBinding, BSIM3v32qNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32QbPtr, BSIM3v32QbBinding, BSIM3v32qNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32DPqPtr, BSIM3v32DPqBinding, BSIM3v32dNodePrime, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32SPqPtr, BSIM3v32SPqBinding, BSIM3v32sNodePrime, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32GqPtr, BSIM3v32GqBinding, BSIM3v32gNode, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM3v32BqPtr, BSIM3v32BqBinding, BSIM3v32bNode, BSIM3v32qNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM3v32bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM3v32model *model = (BSIM3v32model *)inModel ;
+    BSIM3v32instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM3v32 models */
+    for ( ; model != NULL ; model = BSIM3v32nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM3v32instances(model); here != NULL ; here = BSIM3v32nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DdPtr, BSIM3v32DdBinding, BSIM3v32dNode, BSIM3v32dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32GgPtr, BSIM3v32GgBinding, BSIM3v32gNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SsPtr, BSIM3v32SsBinding, BSIM3v32sNode, BSIM3v32sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32BbPtr, BSIM3v32BbBinding, BSIM3v32bNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPdpPtr, BSIM3v32DPdpBinding, BSIM3v32dNodePrime, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPspPtr, BSIM3v32SPspBinding, BSIM3v32sNodePrime, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DdpPtr, BSIM3v32DdpBinding, BSIM3v32dNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32GbPtr, BSIM3v32GbBinding, BSIM3v32gNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32GdpPtr, BSIM3v32GdpBinding, BSIM3v32gNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32GspPtr, BSIM3v32GspBinding, BSIM3v32gNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SspPtr, BSIM3v32SspBinding, BSIM3v32sNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32BdpPtr, BSIM3v32BdpBinding, BSIM3v32bNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32BspPtr, BSIM3v32BspBinding, BSIM3v32bNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPspPtr, BSIM3v32DPspBinding, BSIM3v32dNodePrime, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPdPtr, BSIM3v32DPdBinding, BSIM3v32dNodePrime, BSIM3v32dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32BgPtr, BSIM3v32BgBinding, BSIM3v32bNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPgPtr, BSIM3v32DPgBinding, BSIM3v32dNodePrime, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPgPtr, BSIM3v32SPgBinding, BSIM3v32sNodePrime, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPsPtr, BSIM3v32SPsBinding, BSIM3v32sNodePrime, BSIM3v32sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPbPtr, BSIM3v32DPbBinding, BSIM3v32dNodePrime, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPbPtr, BSIM3v32SPbBinding, BSIM3v32sNodePrime, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPdpPtr, BSIM3v32SPdpBinding, BSIM3v32sNodePrime, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32QqPtr, BSIM3v32QqBinding, BSIM3v32qNode, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32QdpPtr, BSIM3v32QdpBinding, BSIM3v32qNode, BSIM3v32dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32QspPtr, BSIM3v32QspBinding, BSIM3v32qNode, BSIM3v32sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32QgPtr, BSIM3v32QgBinding, BSIM3v32qNode, BSIM3v32gNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32QbPtr, BSIM3v32QbBinding, BSIM3v32qNode, BSIM3v32bNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32DPqPtr, BSIM3v32DPqBinding, BSIM3v32dNodePrime, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32SPqPtr, BSIM3v32SPqBinding, BSIM3v32sNodePrime, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32GqPtr, BSIM3v32GqBinding, BSIM3v32gNode, BSIM3v32qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM3v32BqPtr, BSIM3v32BqBinding, BSIM3v32bNode, BSIM3v32qNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim3v32/bsim3v32def.h

@@ -258,6 +258,40 @@ typedef struct sBSIM3v32instance
         double **BSIM3v32nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM3v32DdBinding ;
+    BindElement *BSIM3v32GgBinding ;
+    BindElement *BSIM3v32SsBinding ;
+    BindElement *BSIM3v32BbBinding ;
+    BindElement *BSIM3v32DPdpBinding ;
+    BindElement *BSIM3v32SPspBinding ;
+    BindElement *BSIM3v32DdpBinding ;
+    BindElement *BSIM3v32GbBinding ;
+    BindElement *BSIM3v32GdpBinding ;
+    BindElement *BSIM3v32GspBinding ;
+    BindElement *BSIM3v32SspBinding ;
+    BindElement *BSIM3v32BdpBinding ;
+    BindElement *BSIM3v32BspBinding ;
+    BindElement *BSIM3v32DPspBinding ;
+    BindElement *BSIM3v32DPdBinding ;
+    BindElement *BSIM3v32BgBinding ;
+    BindElement *BSIM3v32DPgBinding ;
+    BindElement *BSIM3v32SPgBinding ;
+    BindElement *BSIM3v32SPsBinding ;
+    BindElement *BSIM3v32DPbBinding ;
+    BindElement *BSIM3v32SPbBinding ;
+    BindElement *BSIM3v32SPdpBinding ;
+    BindElement *BSIM3v32QqBinding ;
+    BindElement *BSIM3v32QdpBinding ;
+    BindElement *BSIM3v32QspBinding ;
+    BindElement *BSIM3v32QgBinding ;
+    BindElement *BSIM3v32QbBinding ;
+    BindElement *BSIM3v32DPqBinding ;
+    BindElement *BSIM3v32SPqBinding ;
+    BindElement *BSIM3v32GqBinding ;
+    BindElement *BSIM3v32BqBinding ;
+#endif
+
 } BSIM3v32instance ;
 
 struct bsim3v32SizeDependParam

src/spicelib/devices/bsim3v32/bsim3v32ext.h

@@ -28,3 +28,9 @@ extern int BSIM3v32trunc(GENmodel*,CKTcircuit*,double*);
 extern int BSIM3v32noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int BSIM3v32unsetup(GENmodel*,CKTcircuit*);
 extern int BSIM3v32soaCheck(CKTcircuit *, GENmodel *);
+
+#ifdef KLU
+extern int BSIM3v32bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v32bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM3v32bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim3v32/bsim3v32init.c

@@ -66,6 +66,12 @@ SPICEdev BSIM3v32info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM3v32bindCSC,
+    .DEVbindCSCComplex = BSIM3v32bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM3v32bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim4v5/Makefile.am

@@ -28,6 +28,9 @@ libbsim4v5_la_SOURCES =	\
 	bsim4v5itf.h
 
 
+if KLU_WANTED
+libbsim4v5_la_SOURCES += b4v5bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim4v5/b4v5bindCSC.c

@@ -0,0 +1,323 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim4v5def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM4v5bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v5model *model = (BSIM4v5model *)inModel ;
+    BSIM4v5instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM4v5 models */
+    for ( ; model != NULL ; model = BSIM4v5nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v5instances(model); here != NULL ; here = BSIM4v5nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPbpPtr, BSIM4v5DPbpBinding, BSIM4v5dNodePrime, BSIM4v5bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5GPbpPtr, BSIM4v5GPbpBinding, BSIM4v5gNodePrime, BSIM4v5bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPbpPtr, BSIM4v5SPbpBinding, BSIM4v5sNodePrime, BSIM4v5bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5BPdpPtr, BSIM4v5BPdpBinding, BSIM4v5bNodePrime, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5BPgpPtr, BSIM4v5BPgpBinding, BSIM4v5bNodePrime, BSIM4v5gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5BPspPtr, BSIM4v5BPspBinding, BSIM4v5bNodePrime, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5BPbpPtr, BSIM4v5BPbpBinding, BSIM4v5bNodePrime, BSIM4v5bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DdPtr, BSIM4v5DdBinding, BSIM4v5dNode, BSIM4v5dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5GPgpPtr, BSIM4v5GPgpBinding, BSIM4v5gNodePrime, BSIM4v5gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SsPtr, BSIM4v5SsBinding, BSIM4v5sNode, BSIM4v5sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPdpPtr, BSIM4v5DPdpBinding, BSIM4v5dNodePrime, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPspPtr, BSIM4v5SPspBinding, BSIM4v5sNodePrime, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DdpPtr, BSIM4v5DdpBinding, BSIM4v5dNode, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5GPdpPtr, BSIM4v5GPdpBinding, BSIM4v5gNodePrime, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5GPspPtr, BSIM4v5GPspBinding, BSIM4v5gNodePrime, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SspPtr, BSIM4v5SspBinding, BSIM4v5sNode, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPspPtr, BSIM4v5DPspBinding, BSIM4v5dNodePrime, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPdPtr, BSIM4v5DPdBinding, BSIM4v5dNodePrime, BSIM4v5dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPgpPtr, BSIM4v5DPgpBinding, BSIM4v5dNodePrime, BSIM4v5gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPgpPtr, BSIM4v5SPgpBinding, BSIM4v5sNodePrime, BSIM4v5gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPsPtr, BSIM4v5SPsBinding, BSIM4v5sNodePrime, BSIM4v5sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPdpPtr, BSIM4v5SPdpBinding, BSIM4v5sNodePrime, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5QqPtr, BSIM4v5QqBinding, BSIM4v5qNode, BSIM4v5qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5QbpPtr, BSIM4v5QbpBinding, BSIM4v5qNode, BSIM4v5bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5QdpPtr, BSIM4v5QdpBinding, BSIM4v5qNode, BSIM4v5dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5QspPtr, BSIM4v5QspBinding, BSIM4v5qNode, BSIM4v5sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5QgpPtr, BSIM4v5QgpBinding, BSIM4v5qNode, BSIM4v5gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5DPqPtr, BSIM4v5DPqBinding, BSIM4v5dNodePrime, BSIM4v5qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5SPqPtr, BSIM4v5SPqBinding, BSIM4v5sNodePrime, BSIM4v5qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v5GPqPtr, BSIM4v5GPqBinding, BSIM4v5gNodePrime, BSIM4v5qNode);
+            if (here->BSIM4v5rgateMod != 0)
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEgePtr, BSIM4v5GEgeBinding, BSIM4v5gNodeExt, BSIM4v5gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEgpPtr, BSIM4v5GEgpBinding, BSIM4v5gNodeExt, BSIM4v5gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GPgePtr, BSIM4v5GPgeBinding, BSIM4v5gNodePrime, BSIM4v5gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEdpPtr, BSIM4v5GEdpBinding, BSIM4v5gNodeExt, BSIM4v5dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEspPtr, BSIM4v5GEspBinding, BSIM4v5gNodeExt, BSIM4v5sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEbpPtr, BSIM4v5GEbpBinding, BSIM4v5gNodeExt, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMdpPtr, BSIM4v5GMdpBinding, BSIM4v5gNodeMid, BSIM4v5dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMgpPtr, BSIM4v5GMgpBinding, BSIM4v5gNodeMid, BSIM4v5gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMgmPtr, BSIM4v5GMgmBinding, BSIM4v5gNodeMid, BSIM4v5gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMgePtr, BSIM4v5GMgeBinding, BSIM4v5gNodeMid, BSIM4v5gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMspPtr, BSIM4v5GMspBinding, BSIM4v5gNodeMid, BSIM4v5sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GMbpPtr, BSIM4v5GMbpBinding, BSIM4v5gNodeMid, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DPgmPtr, BSIM4v5DPgmBinding, BSIM4v5dNodePrime, BSIM4v5gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GPgmPtr, BSIM4v5GPgmBinding, BSIM4v5gNodePrime, BSIM4v5gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5GEgmPtr, BSIM4v5GEgmBinding, BSIM4v5gNodeExt, BSIM4v5gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SPgmPtr, BSIM4v5SPgmBinding, BSIM4v5sNodePrime, BSIM4v5gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BPgmPtr, BSIM4v5BPgmBinding, BSIM4v5bNodePrime, BSIM4v5gNodeMid);
+            }
+            if ((here->BSIM4v5rbodyMod == 1) || (here->BSIM4v5rbodyMod == 2))
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DPdbPtr, BSIM4v5DPdbBinding, BSIM4v5dNodePrime, BSIM4v5dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SPsbPtr, BSIM4v5SPsbBinding, BSIM4v5sNodePrime, BSIM4v5sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DBdpPtr, BSIM4v5DBdpBinding, BSIM4v5dbNode, BSIM4v5dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DBdbPtr, BSIM4v5DBdbBinding, BSIM4v5dbNode, BSIM4v5dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DBbpPtr, BSIM4v5DBbpBinding, BSIM4v5dbNode, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DBbPtr, BSIM4v5DBbBinding, BSIM4v5dbNode, BSIM4v5bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BPdbPtr, BSIM4v5BPdbBinding, BSIM4v5bNodePrime, BSIM4v5dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BPbPtr, BSIM4v5BPbBinding, BSIM4v5bNodePrime, BSIM4v5bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BPsbPtr, BSIM4v5BPsbBinding, BSIM4v5bNodePrime, BSIM4v5sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SBspPtr, BSIM4v5SBspBinding, BSIM4v5sbNode, BSIM4v5sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SBbpPtr, BSIM4v5SBbpBinding, BSIM4v5sbNode, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SBbPtr, BSIM4v5SBbBinding, BSIM4v5sbNode, BSIM4v5bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SBsbPtr, BSIM4v5SBsbBinding, BSIM4v5sbNode, BSIM4v5sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BdbPtr, BSIM4v5BdbBinding, BSIM4v5bNode, BSIM4v5dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BbpPtr, BSIM4v5BbpBinding, BSIM4v5bNode, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BsbPtr, BSIM4v5BsbBinding, BSIM4v5bNode, BSIM4v5sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5BbPtr, BSIM4v5BbBinding, BSIM4v5bNode, BSIM4v5bNode);
+            }
+            if (model->BSIM4v5rdsMod)
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DgpPtr, BSIM4v5DgpBinding, BSIM4v5dNode, BSIM4v5gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DspPtr, BSIM4v5DspBinding, BSIM4v5dNode, BSIM4v5sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5DbpPtr, BSIM4v5DbpBinding, BSIM4v5dNode, BSIM4v5bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SdpPtr, BSIM4v5SdpBinding, BSIM4v5sNode, BSIM4v5dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SgpPtr, BSIM4v5SgpBinding, BSIM4v5sNode, BSIM4v5gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v5SbpPtr, BSIM4v5SbpBinding, BSIM4v5sNode, BSIM4v5bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM4v5bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v5model *model = (BSIM4v5model *)inModel ;
+    BSIM4v5instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM4v5 models */
+    for ( ; model != NULL ; model = BSIM4v5nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v5instances(model); here != NULL ; here = BSIM4v5nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPbpPtr, BSIM4v5DPbpBinding, BSIM4v5dNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPbpPtr, BSIM4v5GPbpBinding, BSIM4v5gNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPbpPtr, BSIM4v5SPbpBinding, BSIM4v5sNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPdpPtr, BSIM4v5BPdpBinding, BSIM4v5bNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPgpPtr, BSIM4v5BPgpBinding, BSIM4v5bNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPspPtr, BSIM4v5BPspBinding, BSIM4v5bNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPbpPtr, BSIM4v5BPbpBinding, BSIM4v5bNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DdPtr, BSIM4v5DdBinding, BSIM4v5dNode, BSIM4v5dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPgpPtr, BSIM4v5GPgpBinding, BSIM4v5gNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SsPtr, BSIM4v5SsBinding, BSIM4v5sNode, BSIM4v5sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPdpPtr, BSIM4v5DPdpBinding, BSIM4v5dNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPspPtr, BSIM4v5SPspBinding, BSIM4v5sNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DdpPtr, BSIM4v5DdpBinding, BSIM4v5dNode, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPdpPtr, BSIM4v5GPdpBinding, BSIM4v5gNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPspPtr, BSIM4v5GPspBinding, BSIM4v5gNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SspPtr, BSIM4v5SspBinding, BSIM4v5sNode, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPspPtr, BSIM4v5DPspBinding, BSIM4v5dNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPdPtr, BSIM4v5DPdBinding, BSIM4v5dNodePrime, BSIM4v5dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPgpPtr, BSIM4v5DPgpBinding, BSIM4v5dNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPgpPtr, BSIM4v5SPgpBinding, BSIM4v5sNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPsPtr, BSIM4v5SPsBinding, BSIM4v5sNodePrime, BSIM4v5sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPdpPtr, BSIM4v5SPdpBinding, BSIM4v5sNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5QqPtr, BSIM4v5QqBinding, BSIM4v5qNode, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5QbpPtr, BSIM4v5QbpBinding, BSIM4v5qNode, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5QdpPtr, BSIM4v5QdpBinding, BSIM4v5qNode, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5QspPtr, BSIM4v5QspBinding, BSIM4v5qNode, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5QgpPtr, BSIM4v5QgpBinding, BSIM4v5qNode, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPqPtr, BSIM4v5DPqBinding, BSIM4v5dNodePrime, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPqPtr, BSIM4v5SPqBinding, BSIM4v5sNodePrime, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPqPtr, BSIM4v5GPqBinding, BSIM4v5gNodePrime, BSIM4v5qNode);
+            if (here->BSIM4v5rgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEgePtr, BSIM4v5GEgeBinding, BSIM4v5gNodeExt, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEgpPtr, BSIM4v5GEgpBinding, BSIM4v5gNodeExt, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPgePtr, BSIM4v5GPgeBinding, BSIM4v5gNodePrime, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEdpPtr, BSIM4v5GEdpBinding, BSIM4v5gNodeExt, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEspPtr, BSIM4v5GEspBinding, BSIM4v5gNodeExt, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEbpPtr, BSIM4v5GEbpBinding, BSIM4v5gNodeExt, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMdpPtr, BSIM4v5GMdpBinding, BSIM4v5gNodeMid, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMgpPtr, BSIM4v5GMgpBinding, BSIM4v5gNodeMid, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMgmPtr, BSIM4v5GMgmBinding, BSIM4v5gNodeMid, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMgePtr, BSIM4v5GMgeBinding, BSIM4v5gNodeMid, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMspPtr, BSIM4v5GMspBinding, BSIM4v5gNodeMid, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GMbpPtr, BSIM4v5GMbpBinding, BSIM4v5gNodeMid, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPgmPtr, BSIM4v5DPgmBinding, BSIM4v5dNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GPgmPtr, BSIM4v5GPgmBinding, BSIM4v5gNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5GEgmPtr, BSIM4v5GEgmBinding, BSIM4v5gNodeExt, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPgmPtr, BSIM4v5SPgmBinding, BSIM4v5sNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPgmPtr, BSIM4v5BPgmBinding, BSIM4v5bNodePrime, BSIM4v5gNodeMid);
+            }
+            if ((here->BSIM4v5rbodyMod == 1) || (here->BSIM4v5rbodyMod == 2))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DPdbPtr, BSIM4v5DPdbBinding, BSIM4v5dNodePrime, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SPsbPtr, BSIM4v5SPsbBinding, BSIM4v5sNodePrime, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DBdpPtr, BSIM4v5DBdpBinding, BSIM4v5dbNode, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DBdbPtr, BSIM4v5DBdbBinding, BSIM4v5dbNode, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DBbpPtr, BSIM4v5DBbpBinding, BSIM4v5dbNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DBbPtr, BSIM4v5DBbBinding, BSIM4v5dbNode, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPdbPtr, BSIM4v5BPdbBinding, BSIM4v5bNodePrime, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPbPtr, BSIM4v5BPbBinding, BSIM4v5bNodePrime, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BPsbPtr, BSIM4v5BPsbBinding, BSIM4v5bNodePrime, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SBspPtr, BSIM4v5SBspBinding, BSIM4v5sbNode, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SBbpPtr, BSIM4v5SBbpBinding, BSIM4v5sbNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SBbPtr, BSIM4v5SBbBinding, BSIM4v5sbNode, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SBsbPtr, BSIM4v5SBsbBinding, BSIM4v5sbNode, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BdbPtr, BSIM4v5BdbBinding, BSIM4v5bNode, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BbpPtr, BSIM4v5BbpBinding, BSIM4v5bNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BsbPtr, BSIM4v5BsbBinding, BSIM4v5bNode, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5BbPtr, BSIM4v5BbBinding, BSIM4v5bNode, BSIM4v5bNode);
+            }
+            if (model->BSIM4v5rdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DgpPtr, BSIM4v5DgpBinding, BSIM4v5dNode, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DspPtr, BSIM4v5DspBinding, BSIM4v5dNode, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5DbpPtr, BSIM4v5DbpBinding, BSIM4v5dNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SdpPtr, BSIM4v5SdpBinding, BSIM4v5sNode, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SgpPtr, BSIM4v5SgpBinding, BSIM4v5sNode, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v5SbpPtr, BSIM4v5SbpBinding, BSIM4v5sNode, BSIM4v5bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM4v5bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v5model *model = (BSIM4v5model *)inModel ;
+    BSIM4v5instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM4v5 models */
+    for ( ; model != NULL ; model = BSIM4v5nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v5instances(model); here != NULL ; here = BSIM4v5nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPbpPtr, BSIM4v5DPbpBinding, BSIM4v5dNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPbpPtr, BSIM4v5GPbpBinding, BSIM4v5gNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPbpPtr, BSIM4v5SPbpBinding, BSIM4v5sNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPdpPtr, BSIM4v5BPdpBinding, BSIM4v5bNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPgpPtr, BSIM4v5BPgpBinding, BSIM4v5bNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPspPtr, BSIM4v5BPspBinding, BSIM4v5bNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPbpPtr, BSIM4v5BPbpBinding, BSIM4v5bNodePrime, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DdPtr, BSIM4v5DdBinding, BSIM4v5dNode, BSIM4v5dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPgpPtr, BSIM4v5GPgpBinding, BSIM4v5gNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SsPtr, BSIM4v5SsBinding, BSIM4v5sNode, BSIM4v5sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPdpPtr, BSIM4v5DPdpBinding, BSIM4v5dNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPspPtr, BSIM4v5SPspBinding, BSIM4v5sNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DdpPtr, BSIM4v5DdpBinding, BSIM4v5dNode, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPdpPtr, BSIM4v5GPdpBinding, BSIM4v5gNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPspPtr, BSIM4v5GPspBinding, BSIM4v5gNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SspPtr, BSIM4v5SspBinding, BSIM4v5sNode, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPspPtr, BSIM4v5DPspBinding, BSIM4v5dNodePrime, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPdPtr, BSIM4v5DPdBinding, BSIM4v5dNodePrime, BSIM4v5dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPgpPtr, BSIM4v5DPgpBinding, BSIM4v5dNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPgpPtr, BSIM4v5SPgpBinding, BSIM4v5sNodePrime, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPsPtr, BSIM4v5SPsBinding, BSIM4v5sNodePrime, BSIM4v5sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPdpPtr, BSIM4v5SPdpBinding, BSIM4v5sNodePrime, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5QqPtr, BSIM4v5QqBinding, BSIM4v5qNode, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5QbpPtr, BSIM4v5QbpBinding, BSIM4v5qNode, BSIM4v5bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5QdpPtr, BSIM4v5QdpBinding, BSIM4v5qNode, BSIM4v5dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5QspPtr, BSIM4v5QspBinding, BSIM4v5qNode, BSIM4v5sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5QgpPtr, BSIM4v5QgpBinding, BSIM4v5qNode, BSIM4v5gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPqPtr, BSIM4v5DPqBinding, BSIM4v5dNodePrime, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPqPtr, BSIM4v5SPqBinding, BSIM4v5sNodePrime, BSIM4v5qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPqPtr, BSIM4v5GPqBinding, BSIM4v5gNodePrime, BSIM4v5qNode);
+            if (here->BSIM4v5rgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEgePtr, BSIM4v5GEgeBinding, BSIM4v5gNodeExt, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEgpPtr, BSIM4v5GEgpBinding, BSIM4v5gNodeExt, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPgePtr, BSIM4v5GPgeBinding, BSIM4v5gNodePrime, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEdpPtr, BSIM4v5GEdpBinding, BSIM4v5gNodeExt, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEspPtr, BSIM4v5GEspBinding, BSIM4v5gNodeExt, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEbpPtr, BSIM4v5GEbpBinding, BSIM4v5gNodeExt, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMdpPtr, BSIM4v5GMdpBinding, BSIM4v5gNodeMid, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMgpPtr, BSIM4v5GMgpBinding, BSIM4v5gNodeMid, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMgmPtr, BSIM4v5GMgmBinding, BSIM4v5gNodeMid, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMgePtr, BSIM4v5GMgeBinding, BSIM4v5gNodeMid, BSIM4v5gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMspPtr, BSIM4v5GMspBinding, BSIM4v5gNodeMid, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GMbpPtr, BSIM4v5GMbpBinding, BSIM4v5gNodeMid, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPgmPtr, BSIM4v5DPgmBinding, BSIM4v5dNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GPgmPtr, BSIM4v5GPgmBinding, BSIM4v5gNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5GEgmPtr, BSIM4v5GEgmBinding, BSIM4v5gNodeExt, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPgmPtr, BSIM4v5SPgmBinding, BSIM4v5sNodePrime, BSIM4v5gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPgmPtr, BSIM4v5BPgmBinding, BSIM4v5bNodePrime, BSIM4v5gNodeMid);
+            }
+            if ((here->BSIM4v5rbodyMod == 1) || (here->BSIM4v5rbodyMod == 2))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DPdbPtr, BSIM4v5DPdbBinding, BSIM4v5dNodePrime, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SPsbPtr, BSIM4v5SPsbBinding, BSIM4v5sNodePrime, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DBdpPtr, BSIM4v5DBdpBinding, BSIM4v5dbNode, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DBdbPtr, BSIM4v5DBdbBinding, BSIM4v5dbNode, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DBbpPtr, BSIM4v5DBbpBinding, BSIM4v5dbNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DBbPtr, BSIM4v5DBbBinding, BSIM4v5dbNode, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPdbPtr, BSIM4v5BPdbBinding, BSIM4v5bNodePrime, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPbPtr, BSIM4v5BPbBinding, BSIM4v5bNodePrime, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BPsbPtr, BSIM4v5BPsbBinding, BSIM4v5bNodePrime, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SBspPtr, BSIM4v5SBspBinding, BSIM4v5sbNode, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SBbpPtr, BSIM4v5SBbpBinding, BSIM4v5sbNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SBbPtr, BSIM4v5SBbBinding, BSIM4v5sbNode, BSIM4v5bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SBsbPtr, BSIM4v5SBsbBinding, BSIM4v5sbNode, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BdbPtr, BSIM4v5BdbBinding, BSIM4v5bNode, BSIM4v5dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BbpPtr, BSIM4v5BbpBinding, BSIM4v5bNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BsbPtr, BSIM4v5BsbBinding, BSIM4v5bNode, BSIM4v5sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5BbPtr, BSIM4v5BbBinding, BSIM4v5bNode, BSIM4v5bNode);
+            }
+            if (model->BSIM4v5rdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DgpPtr, BSIM4v5DgpBinding, BSIM4v5dNode, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DspPtr, BSIM4v5DspBinding, BSIM4v5dNode, BSIM4v5sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5DbpPtr, BSIM4v5DbpBinding, BSIM4v5dNode, BSIM4v5bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SdpPtr, BSIM4v5SdpBinding, BSIM4v5sNode, BSIM4v5dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SgpPtr, BSIM4v5SgpBinding, BSIM4v5sNode, BSIM4v5gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v5SbpPtr, BSIM4v5SbpBinding, BSIM4v5sNode, BSIM4v5bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim4v5/bsim4v5def.h

@@ -563,6 +563,79 @@ typedef struct sBSIM4v5instance
         double **BSIM4v5nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM4v5DPbpBinding ;
+    BindElement *BSIM4v5GPbpBinding ;
+    BindElement *BSIM4v5SPbpBinding ;
+    BindElement *BSIM4v5BPdpBinding ;
+    BindElement *BSIM4v5BPgpBinding ;
+    BindElement *BSIM4v5BPspBinding ;
+    BindElement *BSIM4v5BPbpBinding ;
+    BindElement *BSIM4v5DdBinding ;
+    BindElement *BSIM4v5GPgpBinding ;
+    BindElement *BSIM4v5SsBinding ;
+    BindElement *BSIM4v5DPdpBinding ;
+    BindElement *BSIM4v5SPspBinding ;
+    BindElement *BSIM4v5DdpBinding ;
+    BindElement *BSIM4v5GPdpBinding ;
+    BindElement *BSIM4v5GPspBinding ;
+    BindElement *BSIM4v5SspBinding ;
+    BindElement *BSIM4v5DPspBinding ;
+    BindElement *BSIM4v5DPdBinding ;
+    BindElement *BSIM4v5DPgpBinding ;
+    BindElement *BSIM4v5SPgpBinding ;
+    BindElement *BSIM4v5SPsBinding ;
+    BindElement *BSIM4v5SPdpBinding ;
+    BindElement *BSIM4v5QqBinding ;
+    BindElement *BSIM4v5QbpBinding ;
+    BindElement *BSIM4v5QdpBinding ;
+    BindElement *BSIM4v5QspBinding ;
+    BindElement *BSIM4v5QgpBinding ;
+    BindElement *BSIM4v5DPqBinding ;
+    BindElement *BSIM4v5SPqBinding ;
+    BindElement *BSIM4v5GPqBinding ;
+    BindElement *BSIM4v5GEgeBinding ;
+    BindElement *BSIM4v5GEgpBinding ;
+    BindElement *BSIM4v5GPgeBinding ;
+    BindElement *BSIM4v5GEdpBinding ;
+    BindElement *BSIM4v5GEspBinding ;
+    BindElement *BSIM4v5GEbpBinding ;
+    BindElement *BSIM4v5GMdpBinding ;
+    BindElement *BSIM4v5GMgpBinding ;
+    BindElement *BSIM4v5GMgmBinding ;
+    BindElement *BSIM4v5GMgeBinding ;
+    BindElement *BSIM4v5GMspBinding ;
+    BindElement *BSIM4v5GMbpBinding ;
+    BindElement *BSIM4v5DPgmBinding ;
+    BindElement *BSIM4v5GPgmBinding ;
+    BindElement *BSIM4v5GEgmBinding ;
+    BindElement *BSIM4v5SPgmBinding ;
+    BindElement *BSIM4v5BPgmBinding ;
+    BindElement *BSIM4v5DPdbBinding ;
+    BindElement *BSIM4v5SPsbBinding ;
+    BindElement *BSIM4v5DBdpBinding ;
+    BindElement *BSIM4v5DBdbBinding ;
+    BindElement *BSIM4v5DBbpBinding ;
+    BindElement *BSIM4v5DBbBinding ;
+    BindElement *BSIM4v5BPdbBinding ;
+    BindElement *BSIM4v5BPbBinding ;
+    BindElement *BSIM4v5BPsbBinding ;
+    BindElement *BSIM4v5SBspBinding ;
+    BindElement *BSIM4v5SBbpBinding ;
+    BindElement *BSIM4v5SBbBinding ;
+    BindElement *BSIM4v5SBsbBinding ;
+    BindElement *BSIM4v5BdbBinding ;
+    BindElement *BSIM4v5BbpBinding ;
+    BindElement *BSIM4v5BsbBinding ;
+    BindElement *BSIM4v5BbBinding ;
+    BindElement *BSIM4v5DgpBinding ;
+    BindElement *BSIM4v5DspBinding ;
+    BindElement *BSIM4v5DbpBinding ;
+    BindElement *BSIM4v5SdpBinding ;
+    BindElement *BSIM4v5SgpBinding ;
+    BindElement *BSIM4v5SbpBinding ;
+#endif
+
 } BSIM4v5instance ;
 
 struct bsim4v5SizeDependParam

src/spicelib/devices/bsim4v5/bsim4v5ext.h

@@ -27,3 +27,9 @@ extern int BSIM4v5trunc(GENmodel*,CKTcircuit*,double*);
 extern int BSIM4v5noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int BSIM4v5unsetup(GENmodel*,CKTcircuit*);
 extern int BSIM4v5soaCheck(CKTcircuit *, GENmodel *);
+
+#ifdef KLU
+extern int BSIM4v5bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM4v5bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM4v5bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim4v5/bsim4v5init.c

@@ -66,6 +66,12 @@ SPICEdev BSIM4v5info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM4v5bindCSC,
+    .DEVbindCSCComplex = BSIM4v5bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM4v5bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsim4v6/Makefile.am

@@ -28,6 +28,9 @@ libbsim4v6_la_SOURCES =	\
 	bsim4v6itf.h
 
 
+if KLU_WANTED
+libbsim4v6_la_SOURCES += b4v6bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsim4v6/b4v6bindCSC.c

@@ -0,0 +1,323 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "bsim4v6def.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+BSIM4v6bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v6model *model = (BSIM4v6model *)inModel ;
+    BSIM4v6instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the BSIM4v6 models */
+    for ( ; model != NULL ; model = BSIM4v6nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v6instances(model); here != NULL ; here = BSIM4v6nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPbpPtr, BSIM4v6DPbpBinding, BSIM4v6dNodePrime, BSIM4v6bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6GPbpPtr, BSIM4v6GPbpBinding, BSIM4v6gNodePrime, BSIM4v6bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPbpPtr, BSIM4v6SPbpBinding, BSIM4v6sNodePrime, BSIM4v6bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6BPdpPtr, BSIM4v6BPdpBinding, BSIM4v6bNodePrime, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6BPgpPtr, BSIM4v6BPgpBinding, BSIM4v6bNodePrime, BSIM4v6gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6BPspPtr, BSIM4v6BPspBinding, BSIM4v6bNodePrime, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6BPbpPtr, BSIM4v6BPbpBinding, BSIM4v6bNodePrime, BSIM4v6bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DdPtr, BSIM4v6DdBinding, BSIM4v6dNode, BSIM4v6dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6GPgpPtr, BSIM4v6GPgpBinding, BSIM4v6gNodePrime, BSIM4v6gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SsPtr, BSIM4v6SsBinding, BSIM4v6sNode, BSIM4v6sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPdpPtr, BSIM4v6DPdpBinding, BSIM4v6dNodePrime, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPspPtr, BSIM4v6SPspBinding, BSIM4v6sNodePrime, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DdpPtr, BSIM4v6DdpBinding, BSIM4v6dNode, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6GPdpPtr, BSIM4v6GPdpBinding, BSIM4v6gNodePrime, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6GPspPtr, BSIM4v6GPspBinding, BSIM4v6gNodePrime, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SspPtr, BSIM4v6SspBinding, BSIM4v6sNode, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPspPtr, BSIM4v6DPspBinding, BSIM4v6dNodePrime, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPdPtr, BSIM4v6DPdBinding, BSIM4v6dNodePrime, BSIM4v6dNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPgpPtr, BSIM4v6DPgpBinding, BSIM4v6dNodePrime, BSIM4v6gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPgpPtr, BSIM4v6SPgpBinding, BSIM4v6sNodePrime, BSIM4v6gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPsPtr, BSIM4v6SPsBinding, BSIM4v6sNodePrime, BSIM4v6sNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPdpPtr, BSIM4v6SPdpBinding, BSIM4v6sNodePrime, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6QqPtr, BSIM4v6QqBinding, BSIM4v6qNode, BSIM4v6qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6QbpPtr, BSIM4v6QbpBinding, BSIM4v6qNode, BSIM4v6bNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6QdpPtr, BSIM4v6QdpBinding, BSIM4v6qNode, BSIM4v6dNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6QspPtr, BSIM4v6QspBinding, BSIM4v6qNode, BSIM4v6sNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6QgpPtr, BSIM4v6QgpBinding, BSIM4v6qNode, BSIM4v6gNodePrime);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6DPqPtr, BSIM4v6DPqBinding, BSIM4v6dNodePrime, BSIM4v6qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6SPqPtr, BSIM4v6SPqBinding, BSIM4v6sNodePrime, BSIM4v6qNode);
+            CREATE_KLU_BINDING_TABLE(BSIM4v6GPqPtr, BSIM4v6GPqBinding, BSIM4v6gNodePrime, BSIM4v6qNode);
+            if (here->BSIM4v6rgateMod != 0)
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEgePtr, BSIM4v6GEgeBinding, BSIM4v6gNodeExt, BSIM4v6gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEgpPtr, BSIM4v6GEgpBinding, BSIM4v6gNodeExt, BSIM4v6gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GPgePtr, BSIM4v6GPgeBinding, BSIM4v6gNodePrime, BSIM4v6gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEdpPtr, BSIM4v6GEdpBinding, BSIM4v6gNodeExt, BSIM4v6dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEspPtr, BSIM4v6GEspBinding, BSIM4v6gNodeExt, BSIM4v6sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEbpPtr, BSIM4v6GEbpBinding, BSIM4v6gNodeExt, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMdpPtr, BSIM4v6GMdpBinding, BSIM4v6gNodeMid, BSIM4v6dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMgpPtr, BSIM4v6GMgpBinding, BSIM4v6gNodeMid, BSIM4v6gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMgmPtr, BSIM4v6GMgmBinding, BSIM4v6gNodeMid, BSIM4v6gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMgePtr, BSIM4v6GMgeBinding, BSIM4v6gNodeMid, BSIM4v6gNodeExt);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMspPtr, BSIM4v6GMspBinding, BSIM4v6gNodeMid, BSIM4v6sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GMbpPtr, BSIM4v6GMbpBinding, BSIM4v6gNodeMid, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DPgmPtr, BSIM4v6DPgmBinding, BSIM4v6dNodePrime, BSIM4v6gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GPgmPtr, BSIM4v6GPgmBinding, BSIM4v6gNodePrime, BSIM4v6gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6GEgmPtr, BSIM4v6GEgmBinding, BSIM4v6gNodeExt, BSIM4v6gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SPgmPtr, BSIM4v6SPgmBinding, BSIM4v6sNodePrime, BSIM4v6gNodeMid);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BPgmPtr, BSIM4v6BPgmBinding, BSIM4v6bNodePrime, BSIM4v6gNodeMid);
+            }
+            if ((here->BSIM4v6rbodyMod == 1) || (here->BSIM4v6rbodyMod == 2))
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DPdbPtr, BSIM4v6DPdbBinding, BSIM4v6dNodePrime, BSIM4v6dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SPsbPtr, BSIM4v6SPsbBinding, BSIM4v6sNodePrime, BSIM4v6sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DBdpPtr, BSIM4v6DBdpBinding, BSIM4v6dbNode, BSIM4v6dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DBdbPtr, BSIM4v6DBdbBinding, BSIM4v6dbNode, BSIM4v6dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DBbpPtr, BSIM4v6DBbpBinding, BSIM4v6dbNode, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DBbPtr, BSIM4v6DBbBinding, BSIM4v6dbNode, BSIM4v6bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BPdbPtr, BSIM4v6BPdbBinding, BSIM4v6bNodePrime, BSIM4v6dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BPbPtr, BSIM4v6BPbBinding, BSIM4v6bNodePrime, BSIM4v6bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BPsbPtr, BSIM4v6BPsbBinding, BSIM4v6bNodePrime, BSIM4v6sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SBspPtr, BSIM4v6SBspBinding, BSIM4v6sbNode, BSIM4v6sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SBbpPtr, BSIM4v6SBbpBinding, BSIM4v6sbNode, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SBbPtr, BSIM4v6SBbBinding, BSIM4v6sbNode, BSIM4v6bNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SBsbPtr, BSIM4v6SBsbBinding, BSIM4v6sbNode, BSIM4v6sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BdbPtr, BSIM4v6BdbBinding, BSIM4v6bNode, BSIM4v6dbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BbpPtr, BSIM4v6BbpBinding, BSIM4v6bNode, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BsbPtr, BSIM4v6BsbBinding, BSIM4v6bNode, BSIM4v6sbNode);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6BbPtr, BSIM4v6BbBinding, BSIM4v6bNode, BSIM4v6bNode);
+            }
+            if (model->BSIM4v6rdsMod)
+            {
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DgpPtr, BSIM4v6DgpBinding, BSIM4v6dNode, BSIM4v6gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DspPtr, BSIM4v6DspBinding, BSIM4v6dNode, BSIM4v6sNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6DbpPtr, BSIM4v6DbpBinding, BSIM4v6dNode, BSIM4v6bNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SdpPtr, BSIM4v6SdpBinding, BSIM4v6sNode, BSIM4v6dNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SgpPtr, BSIM4v6SgpBinding, BSIM4v6sNode, BSIM4v6gNodePrime);
+                CREATE_KLU_BINDING_TABLE(BSIM4v6SbpPtr, BSIM4v6SbpBinding, BSIM4v6sNode, BSIM4v6bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM4v6bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v6model *model = (BSIM4v6model *)inModel ;
+    BSIM4v6instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM4v6 models */
+    for ( ; model != NULL ; model = BSIM4v6nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v6instances(model); here != NULL ; here = BSIM4v6nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPbpPtr, BSIM4v6DPbpBinding, BSIM4v6dNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPbpPtr, BSIM4v6GPbpBinding, BSIM4v6gNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPbpPtr, BSIM4v6SPbpBinding, BSIM4v6sNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPdpPtr, BSIM4v6BPdpBinding, BSIM4v6bNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPgpPtr, BSIM4v6BPgpBinding, BSIM4v6bNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPspPtr, BSIM4v6BPspBinding, BSIM4v6bNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPbpPtr, BSIM4v6BPbpBinding, BSIM4v6bNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DdPtr, BSIM4v6DdBinding, BSIM4v6dNode, BSIM4v6dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPgpPtr, BSIM4v6GPgpBinding, BSIM4v6gNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SsPtr, BSIM4v6SsBinding, BSIM4v6sNode, BSIM4v6sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPdpPtr, BSIM4v6DPdpBinding, BSIM4v6dNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPspPtr, BSIM4v6SPspBinding, BSIM4v6sNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DdpPtr, BSIM4v6DdpBinding, BSIM4v6dNode, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPdpPtr, BSIM4v6GPdpBinding, BSIM4v6gNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPspPtr, BSIM4v6GPspBinding, BSIM4v6gNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SspPtr, BSIM4v6SspBinding, BSIM4v6sNode, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPspPtr, BSIM4v6DPspBinding, BSIM4v6dNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPdPtr, BSIM4v6DPdBinding, BSIM4v6dNodePrime, BSIM4v6dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPgpPtr, BSIM4v6DPgpBinding, BSIM4v6dNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPgpPtr, BSIM4v6SPgpBinding, BSIM4v6sNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPsPtr, BSIM4v6SPsBinding, BSIM4v6sNodePrime, BSIM4v6sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPdpPtr, BSIM4v6SPdpBinding, BSIM4v6sNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6QqPtr, BSIM4v6QqBinding, BSIM4v6qNode, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6QbpPtr, BSIM4v6QbpBinding, BSIM4v6qNode, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6QdpPtr, BSIM4v6QdpBinding, BSIM4v6qNode, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6QspPtr, BSIM4v6QspBinding, BSIM4v6qNode, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6QgpPtr, BSIM4v6QgpBinding, BSIM4v6qNode, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPqPtr, BSIM4v6DPqBinding, BSIM4v6dNodePrime, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPqPtr, BSIM4v6SPqBinding, BSIM4v6sNodePrime, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPqPtr, BSIM4v6GPqBinding, BSIM4v6gNodePrime, BSIM4v6qNode);
+            if (here->BSIM4v6rgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEgePtr, BSIM4v6GEgeBinding, BSIM4v6gNodeExt, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEgpPtr, BSIM4v6GEgpBinding, BSIM4v6gNodeExt, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPgePtr, BSIM4v6GPgeBinding, BSIM4v6gNodePrime, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEdpPtr, BSIM4v6GEdpBinding, BSIM4v6gNodeExt, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEspPtr, BSIM4v6GEspBinding, BSIM4v6gNodeExt, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEbpPtr, BSIM4v6GEbpBinding, BSIM4v6gNodeExt, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMdpPtr, BSIM4v6GMdpBinding, BSIM4v6gNodeMid, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMgpPtr, BSIM4v6GMgpBinding, BSIM4v6gNodeMid, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMgmPtr, BSIM4v6GMgmBinding, BSIM4v6gNodeMid, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMgePtr, BSIM4v6GMgeBinding, BSIM4v6gNodeMid, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMspPtr, BSIM4v6GMspBinding, BSIM4v6gNodeMid, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GMbpPtr, BSIM4v6GMbpBinding, BSIM4v6gNodeMid, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPgmPtr, BSIM4v6DPgmBinding, BSIM4v6dNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GPgmPtr, BSIM4v6GPgmBinding, BSIM4v6gNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6GEgmPtr, BSIM4v6GEgmBinding, BSIM4v6gNodeExt, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPgmPtr, BSIM4v6SPgmBinding, BSIM4v6sNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPgmPtr, BSIM4v6BPgmBinding, BSIM4v6bNodePrime, BSIM4v6gNodeMid);
+            }
+            if ((here->BSIM4v6rbodyMod == 1) || (here->BSIM4v6rbodyMod == 2))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DPdbPtr, BSIM4v6DPdbBinding, BSIM4v6dNodePrime, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SPsbPtr, BSIM4v6SPsbBinding, BSIM4v6sNodePrime, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DBdpPtr, BSIM4v6DBdpBinding, BSIM4v6dbNode, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DBdbPtr, BSIM4v6DBdbBinding, BSIM4v6dbNode, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DBbpPtr, BSIM4v6DBbpBinding, BSIM4v6dbNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DBbPtr, BSIM4v6DBbBinding, BSIM4v6dbNode, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPdbPtr, BSIM4v6BPdbBinding, BSIM4v6bNodePrime, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPbPtr, BSIM4v6BPbBinding, BSIM4v6bNodePrime, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BPsbPtr, BSIM4v6BPsbBinding, BSIM4v6bNodePrime, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SBspPtr, BSIM4v6SBspBinding, BSIM4v6sbNode, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SBbpPtr, BSIM4v6SBbpBinding, BSIM4v6sbNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SBbPtr, BSIM4v6SBbBinding, BSIM4v6sbNode, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SBsbPtr, BSIM4v6SBsbBinding, BSIM4v6sbNode, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BdbPtr, BSIM4v6BdbBinding, BSIM4v6bNode, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BbpPtr, BSIM4v6BbpBinding, BSIM4v6bNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BsbPtr, BSIM4v6BsbBinding, BSIM4v6bNode, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6BbPtr, BSIM4v6BbBinding, BSIM4v6bNode, BSIM4v6bNode);
+            }
+            if (model->BSIM4v6rdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DgpPtr, BSIM4v6DgpBinding, BSIM4v6dNode, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DspPtr, BSIM4v6DspBinding, BSIM4v6dNode, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6DbpPtr, BSIM4v6DbpBinding, BSIM4v6dNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SdpPtr, BSIM4v6SdpBinding, BSIM4v6sNode, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SgpPtr, BSIM4v6SgpBinding, BSIM4v6sNode, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(BSIM4v6SbpPtr, BSIM4v6SbpBinding, BSIM4v6sNode, BSIM4v6bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+BSIM4v6bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    BSIM4v6model *model = (BSIM4v6model *)inModel ;
+    BSIM4v6instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the BSIM4v6 models */
+    for ( ; model != NULL ; model = BSIM4v6nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = BSIM4v6instances(model); here != NULL ; here = BSIM4v6nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPbpPtr, BSIM4v6DPbpBinding, BSIM4v6dNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPbpPtr, BSIM4v6GPbpBinding, BSIM4v6gNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPbpPtr, BSIM4v6SPbpBinding, BSIM4v6sNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPdpPtr, BSIM4v6BPdpBinding, BSIM4v6bNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPgpPtr, BSIM4v6BPgpBinding, BSIM4v6bNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPspPtr, BSIM4v6BPspBinding, BSIM4v6bNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPbpPtr, BSIM4v6BPbpBinding, BSIM4v6bNodePrime, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DdPtr, BSIM4v6DdBinding, BSIM4v6dNode, BSIM4v6dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPgpPtr, BSIM4v6GPgpBinding, BSIM4v6gNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SsPtr, BSIM4v6SsBinding, BSIM4v6sNode, BSIM4v6sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPdpPtr, BSIM4v6DPdpBinding, BSIM4v6dNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPspPtr, BSIM4v6SPspBinding, BSIM4v6sNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DdpPtr, BSIM4v6DdpBinding, BSIM4v6dNode, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPdpPtr, BSIM4v6GPdpBinding, BSIM4v6gNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPspPtr, BSIM4v6GPspBinding, BSIM4v6gNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SspPtr, BSIM4v6SspBinding, BSIM4v6sNode, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPspPtr, BSIM4v6DPspBinding, BSIM4v6dNodePrime, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPdPtr, BSIM4v6DPdBinding, BSIM4v6dNodePrime, BSIM4v6dNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPgpPtr, BSIM4v6DPgpBinding, BSIM4v6dNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPgpPtr, BSIM4v6SPgpBinding, BSIM4v6sNodePrime, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPsPtr, BSIM4v6SPsBinding, BSIM4v6sNodePrime, BSIM4v6sNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPdpPtr, BSIM4v6SPdpBinding, BSIM4v6sNodePrime, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6QqPtr, BSIM4v6QqBinding, BSIM4v6qNode, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6QbpPtr, BSIM4v6QbpBinding, BSIM4v6qNode, BSIM4v6bNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6QdpPtr, BSIM4v6QdpBinding, BSIM4v6qNode, BSIM4v6dNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6QspPtr, BSIM4v6QspBinding, BSIM4v6qNode, BSIM4v6sNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6QgpPtr, BSIM4v6QgpBinding, BSIM4v6qNode, BSIM4v6gNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPqPtr, BSIM4v6DPqBinding, BSIM4v6dNodePrime, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPqPtr, BSIM4v6SPqBinding, BSIM4v6sNodePrime, BSIM4v6qNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPqPtr, BSIM4v6GPqBinding, BSIM4v6gNodePrime, BSIM4v6qNode);
+            if (here->BSIM4v6rgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEgePtr, BSIM4v6GEgeBinding, BSIM4v6gNodeExt, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEgpPtr, BSIM4v6GEgpBinding, BSIM4v6gNodeExt, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPgePtr, BSIM4v6GPgeBinding, BSIM4v6gNodePrime, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEdpPtr, BSIM4v6GEdpBinding, BSIM4v6gNodeExt, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEspPtr, BSIM4v6GEspBinding, BSIM4v6gNodeExt, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEbpPtr, BSIM4v6GEbpBinding, BSIM4v6gNodeExt, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMdpPtr, BSIM4v6GMdpBinding, BSIM4v6gNodeMid, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMgpPtr, BSIM4v6GMgpBinding, BSIM4v6gNodeMid, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMgmPtr, BSIM4v6GMgmBinding, BSIM4v6gNodeMid, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMgePtr, BSIM4v6GMgeBinding, BSIM4v6gNodeMid, BSIM4v6gNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMspPtr, BSIM4v6GMspBinding, BSIM4v6gNodeMid, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GMbpPtr, BSIM4v6GMbpBinding, BSIM4v6gNodeMid, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPgmPtr, BSIM4v6DPgmBinding, BSIM4v6dNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GPgmPtr, BSIM4v6GPgmBinding, BSIM4v6gNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6GEgmPtr, BSIM4v6GEgmBinding, BSIM4v6gNodeExt, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPgmPtr, BSIM4v6SPgmBinding, BSIM4v6sNodePrime, BSIM4v6gNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPgmPtr, BSIM4v6BPgmBinding, BSIM4v6bNodePrime, BSIM4v6gNodeMid);
+            }
+            if ((here->BSIM4v6rbodyMod == 1) || (here->BSIM4v6rbodyMod == 2))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DPdbPtr, BSIM4v6DPdbBinding, BSIM4v6dNodePrime, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SPsbPtr, BSIM4v6SPsbBinding, BSIM4v6sNodePrime, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DBdpPtr, BSIM4v6DBdpBinding, BSIM4v6dbNode, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DBdbPtr, BSIM4v6DBdbBinding, BSIM4v6dbNode, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DBbpPtr, BSIM4v6DBbpBinding, BSIM4v6dbNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DBbPtr, BSIM4v6DBbBinding, BSIM4v6dbNode, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPdbPtr, BSIM4v6BPdbBinding, BSIM4v6bNodePrime, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPbPtr, BSIM4v6BPbBinding, BSIM4v6bNodePrime, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BPsbPtr, BSIM4v6BPsbBinding, BSIM4v6bNodePrime, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SBspPtr, BSIM4v6SBspBinding, BSIM4v6sbNode, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SBbpPtr, BSIM4v6SBbpBinding, BSIM4v6sbNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SBbPtr, BSIM4v6SBbBinding, BSIM4v6sbNode, BSIM4v6bNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SBsbPtr, BSIM4v6SBsbBinding, BSIM4v6sbNode, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BdbPtr, BSIM4v6BdbBinding, BSIM4v6bNode, BSIM4v6dbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BbpPtr, BSIM4v6BbpBinding, BSIM4v6bNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BsbPtr, BSIM4v6BsbBinding, BSIM4v6bNode, BSIM4v6sbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6BbPtr, BSIM4v6BbBinding, BSIM4v6bNode, BSIM4v6bNode);
+            }
+            if (model->BSIM4v6rdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DgpPtr, BSIM4v6DgpBinding, BSIM4v6dNode, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DspPtr, BSIM4v6DspBinding, BSIM4v6dNode, BSIM4v6sNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6DbpPtr, BSIM4v6DbpBinding, BSIM4v6dNode, BSIM4v6bNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SdpPtr, BSIM4v6SdpBinding, BSIM4v6sNode, BSIM4v6dNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SgpPtr, BSIM4v6SgpBinding, BSIM4v6sNode, BSIM4v6gNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(BSIM4v6SbpPtr, BSIM4v6SbpBinding, BSIM4v6sNode, BSIM4v6bNodePrime);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsim4v6/bsim4v6def.h

@@ -572,6 +572,79 @@ typedef struct sBSIM4v6instance
         double **BSIM4v6nVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *BSIM4v6DPbpBinding ;
+    BindElement *BSIM4v6GPbpBinding ;
+    BindElement *BSIM4v6SPbpBinding ;
+    BindElement *BSIM4v6BPdpBinding ;
+    BindElement *BSIM4v6BPgpBinding ;
+    BindElement *BSIM4v6BPspBinding ;
+    BindElement *BSIM4v6BPbpBinding ;
+    BindElement *BSIM4v6DdBinding ;
+    BindElement *BSIM4v6GPgpBinding ;
+    BindElement *BSIM4v6SsBinding ;
+    BindElement *BSIM4v6DPdpBinding ;
+    BindElement *BSIM4v6SPspBinding ;
+    BindElement *BSIM4v6DdpBinding ;
+    BindElement *BSIM4v6GPdpBinding ;
+    BindElement *BSIM4v6GPspBinding ;
+    BindElement *BSIM4v6SspBinding ;
+    BindElement *BSIM4v6DPspBinding ;
+    BindElement *BSIM4v6DPdBinding ;
+    BindElement *BSIM4v6DPgpBinding ;
+    BindElement *BSIM4v6SPgpBinding ;
+    BindElement *BSIM4v6SPsBinding ;
+    BindElement *BSIM4v6SPdpBinding ;
+    BindElement *BSIM4v6QqBinding ;
+    BindElement *BSIM4v6QbpBinding ;
+    BindElement *BSIM4v6QdpBinding ;
+    BindElement *BSIM4v6QspBinding ;
+    BindElement *BSIM4v6QgpBinding ;
+    BindElement *BSIM4v6DPqBinding ;
+    BindElement *BSIM4v6SPqBinding ;
+    BindElement *BSIM4v6GPqBinding ;
+    BindElement *BSIM4v6GEgeBinding ;
+    BindElement *BSIM4v6GEgpBinding ;
+    BindElement *BSIM4v6GPgeBinding ;
+    BindElement *BSIM4v6GEdpBinding ;
+    BindElement *BSIM4v6GEspBinding ;
+    BindElement *BSIM4v6GEbpBinding ;
+    BindElement *BSIM4v6GMdpBinding ;
+    BindElement *BSIM4v6GMgpBinding ;
+    BindElement *BSIM4v6GMgmBinding ;
+    BindElement *BSIM4v6GMgeBinding ;
+    BindElement *BSIM4v6GMspBinding ;
+    BindElement *BSIM4v6GMbpBinding ;
+    BindElement *BSIM4v6DPgmBinding ;
+    BindElement *BSIM4v6GPgmBinding ;
+    BindElement *BSIM4v6GEgmBinding ;
+    BindElement *BSIM4v6SPgmBinding ;
+    BindElement *BSIM4v6BPgmBinding ;
+    BindElement *BSIM4v6DPdbBinding ;
+    BindElement *BSIM4v6SPsbBinding ;
+    BindElement *BSIM4v6DBdpBinding ;
+    BindElement *BSIM4v6DBdbBinding ;
+    BindElement *BSIM4v6DBbpBinding ;
+    BindElement *BSIM4v6DBbBinding ;
+    BindElement *BSIM4v6BPdbBinding ;
+    BindElement *BSIM4v6BPbBinding ;
+    BindElement *BSIM4v6BPsbBinding ;
+    BindElement *BSIM4v6SBspBinding ;
+    BindElement *BSIM4v6SBbpBinding ;
+    BindElement *BSIM4v6SBbBinding ;
+    BindElement *BSIM4v6SBsbBinding ;
+    BindElement *BSIM4v6BdbBinding ;
+    BindElement *BSIM4v6BbpBinding ;
+    BindElement *BSIM4v6BsbBinding ;
+    BindElement *BSIM4v6BbBinding ;
+    BindElement *BSIM4v6DgpBinding ;
+    BindElement *BSIM4v6DspBinding ;
+    BindElement *BSIM4v6DbpBinding ;
+    BindElement *BSIM4v6SdpBinding ;
+    BindElement *BSIM4v6SgpBinding ;
+    BindElement *BSIM4v6SbpBinding ;
+#endif
+
 } BSIM4v6instance ;
 
 struct bsim4v6SizeDependParam

src/spicelib/devices/bsim4v6/bsim4v6ext.h

@@ -27,3 +27,9 @@ extern int BSIM4v6trunc(GENmodel*,CKTcircuit*,double*);
 extern int BSIM4v6noise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int BSIM4v6unsetup(GENmodel*,CKTcircuit*);
 extern int BSIM4v6soaCheck(CKTcircuit *, GENmodel *);
+
+#ifdef KLU
+extern int BSIM4v6bindCSC (GENmodel*, CKTcircuit*) ;
+extern int BSIM4v6bindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int BSIM4v6bindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsim4v6/bsim4v6init.c

@@ -66,6 +66,12 @@ SPICEdev BSIM4v6info = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = BSIM4v6bindCSC,
+    .DEVbindCSCComplex = BSIM4v6bindCSCComplex,
+    .DEVbindCSCComplexToReal = BSIM4v6bindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/bsimsoi/Makefile.am

@@ -27,6 +27,9 @@ libbsim4soi_la_SOURCES = \
         b4soiitf.h
 
 
+if KLU_WANTED
+libbsim4soi_la_SOURCES += b4soibindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/bsimsoi/b4soibindCSC.c

@@ -0,0 +1,506 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "b4soidef.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+B4SOIbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B4SOImodel *model = (B4SOImodel *)inModel ;
+    B4SOIinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the B4SOI models */
+    for ( ; model != NULL ; model = B4SOInextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B4SOIinstances(model); here != NULL ; here = B4SOInextInstance(here))
+        {
+            if ((model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0))
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOITemptempPtr, B4SOITemptempBinding, B4SOItempNode, B4SOItempNode);
+                CREATE_KLU_BINDING_TABLE(B4SOITempdpPtr, B4SOITempdpBinding, B4SOItempNode, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOITempspPtr, B4SOITempspBinding, B4SOItempNode, B4SOIsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOITempgPtr, B4SOITempgBinding, B4SOItempNode, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOITempbPtr, B4SOITempbBinding, B4SOItempNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGtempPtr, B4SOIGtempBinding, B4SOIgNode, B4SOItempNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDPtempPtr, B4SOIDPtempBinding, B4SOIdNodePrime, B4SOItempNode);
+                CREATE_KLU_BINDING_TABLE(B4SOISPtempPtr, B4SOISPtempBinding, B4SOIsNodePrime, B4SOItempNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIEtempPtr, B4SOIEtempBinding, B4SOIeNode, B4SOItempNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBtempPtr, B4SOIBtempBinding, B4SOIbNode, B4SOItempNode);
+                if (here->B4SOIbodyMod == 1)
+                {
+                    CREATE_KLU_BINDING_TABLE(B4SOIPtempPtr, B4SOIPtempBinding, B4SOIpNode, B4SOItempNode);
+                }
+                if (here->B4SOIsoiMod != 0)
+                {
+                    CREATE_KLU_BINDING_TABLE(B4SOITempePtr, B4SOITempeBinding, B4SOItempNode, B4SOIeNode);
+                }
+            }
+            if (here->B4SOIbodyMod == 2)
+            {
+            }
+            else if (here->B4SOIbodyMod == 1)
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIBpPtr, B4SOIBpBinding, B4SOIbNode, B4SOIpNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIPbPtr, B4SOIPbBinding, B4SOIpNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIPpPtr, B4SOIPpBinding, B4SOIpNode, B4SOIpNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIPgPtr, B4SOIPgBinding, B4SOIpNode, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGpPtr, B4SOIGpBinding, B4SOIgNode, B4SOIpNode);
+            }
+            if (here->B4SOIrgateMod != 0)
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIGEgePtr, B4SOIGEgeBinding, B4SOIgNodeExt, B4SOIgNodeExt);
+                CREATE_KLU_BINDING_TABLE(B4SOIGEgPtr, B4SOIGEgBinding, B4SOIgNodeExt, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGgePtr, B4SOIGgeBinding, B4SOIgNode, B4SOIgNodeExt);
+                CREATE_KLU_BINDING_TABLE(B4SOIGEdpPtr, B4SOIGEdpBinding, B4SOIgNodeExt, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOIGEspPtr, B4SOIGEspBinding, B4SOIgNodeExt, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CREATE_KLU_BINDING_TABLE(B4SOIGEbPtr, B4SOIGEbBinding, B4SOIgNodeExt, B4SOIbNode);
+                }
+                CREATE_KLU_BINDING_TABLE(B4SOIGMdpPtr, B4SOIGMdpBinding, B4SOIgNodeMid, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOIGMgPtr, B4SOIGMgBinding, B4SOIgNodeMid, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGMgmPtr, B4SOIGMgmBinding, B4SOIgNodeMid, B4SOIgNodeMid);
+                CREATE_KLU_BINDING_TABLE(B4SOIGMgePtr, B4SOIGMgeBinding, B4SOIgNodeMid, B4SOIgNodeExt);
+                CREATE_KLU_BINDING_TABLE(B4SOIGMspPtr, B4SOIGMspBinding, B4SOIgNodeMid, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CREATE_KLU_BINDING_TABLE(B4SOIGMbPtr, B4SOIGMbBinding, B4SOIgNodeMid, B4SOIbNode);
+                }
+                CREATE_KLU_BINDING_TABLE(B4SOIGMePtr, B4SOIGMeBinding, B4SOIgNodeMid, B4SOIeNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDPgmPtr, B4SOIDPgmBinding, B4SOIdNodePrime, B4SOIgNodeMid);
+                CREATE_KLU_BINDING_TABLE(B4SOIGgmPtr, B4SOIGgmBinding, B4SOIgNode, B4SOIgNodeMid);
+                CREATE_KLU_BINDING_TABLE(B4SOIGEgmPtr, B4SOIGEgmBinding, B4SOIgNodeExt, B4SOIgNodeMid);
+                CREATE_KLU_BINDING_TABLE(B4SOISPgmPtr, B4SOISPgmBinding, B4SOIsNodePrime, B4SOIgNodeMid);
+                CREATE_KLU_BINDING_TABLE(B4SOIEgmPtr, B4SOIEgmBinding, B4SOIeNode, B4SOIgNodeMid);
+            }
+            if (here->B4SOIsoiMod != 2) /* v3.2 */
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIEbPtr, B4SOIEbBinding, B4SOIeNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGbPtr, B4SOIGbBinding, B4SOIgNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDPbPtr, B4SOIDPbBinding, B4SOIdNodePrime, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOISPbPtr, B4SOISPbBinding, B4SOIsNodePrime, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBePtr, B4SOIBeBinding, B4SOIbNode, B4SOIeNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBgPtr, B4SOIBgBinding, B4SOIbNode, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBdpPtr, B4SOIBdpBinding, B4SOIbNode, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOIBspPtr, B4SOIBspBinding, B4SOIbNode, B4SOIsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOIBbPtr, B4SOIBbBinding, B4SOIbNode, B4SOIbNode);
+            }
+            CREATE_KLU_BINDING_TABLE(B4SOIEgPtr, B4SOIEgBinding, B4SOIeNode, B4SOIgNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIEdpPtr, B4SOIEdpBinding, B4SOIeNode, B4SOIdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIEspPtr, B4SOIEspBinding, B4SOIeNode, B4SOIsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIGePtr, B4SOIGeBinding, B4SOIgNode, B4SOIeNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIDPePtr, B4SOIDPeBinding, B4SOIdNodePrime, B4SOIeNode);
+            CREATE_KLU_BINDING_TABLE(B4SOISPePtr, B4SOISPeBinding, B4SOIsNodePrime, B4SOIeNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIEePtr, B4SOIEeBinding, B4SOIeNode, B4SOIeNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIGgPtr, B4SOIGgBinding, B4SOIgNode, B4SOIgNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIGdpPtr, B4SOIGdpBinding, B4SOIgNode, B4SOIdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIGspPtr, B4SOIGspBinding, B4SOIgNode, B4SOIsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIDPgPtr, B4SOIDPgBinding, B4SOIdNodePrime, B4SOIgNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIDPdpPtr, B4SOIDPdpBinding, B4SOIdNodePrime, B4SOIdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIDPspPtr, B4SOIDPspBinding, B4SOIdNodePrime, B4SOIsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOIDPdPtr, B4SOIDPdBinding, B4SOIdNodePrime, B4SOIdNode);
+            CREATE_KLU_BINDING_TABLE(B4SOISPgPtr, B4SOISPgBinding, B4SOIsNodePrime, B4SOIgNode);
+            CREATE_KLU_BINDING_TABLE(B4SOISPdpPtr, B4SOISPdpBinding, B4SOIsNodePrime, B4SOIdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOISPspPtr, B4SOISPspBinding, B4SOIsNodePrime, B4SOIsNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOISPsPtr, B4SOISPsBinding, B4SOIsNodePrime, B4SOIsNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIDdPtr, B4SOIDdBinding, B4SOIdNode, B4SOIdNode);
+            CREATE_KLU_BINDING_TABLE(B4SOIDdpPtr, B4SOIDdpBinding, B4SOIdNode, B4SOIdNodePrime);
+            CREATE_KLU_BINDING_TABLE(B4SOISsPtr, B4SOISsBinding, B4SOIsNode, B4SOIsNode);
+            CREATE_KLU_BINDING_TABLE(B4SOISspPtr, B4SOISspBinding, B4SOIsNode, B4SOIsNodePrime);
+            if (here->B4SOIrbodyMod == 1)
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIDPdbPtr, B4SOIDPdbBinding, B4SOIdNodePrime, B4SOIdbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOISPsbPtr, B4SOISPsbBinding, B4SOIsNodePrime, B4SOIsbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDBdpPtr, B4SOIDBdpBinding, B4SOIdbNode, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOIDBdbPtr, B4SOIDBdbBinding, B4SOIdbNode, B4SOIdbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDBbPtr, B4SOIDBbBinding, B4SOIdbNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOISBspPtr, B4SOISBspBinding, B4SOIsbNode, B4SOIsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOISBsbPtr, B4SOISBsbBinding, B4SOIsbNode, B4SOIsbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOISBbPtr, B4SOISBbBinding, B4SOIsbNode, B4SOIbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBdbPtr, B4SOIBdbBinding, B4SOIbNode, B4SOIdbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIBsbPtr, B4SOIBsbBinding, B4SOIbNode, B4SOIsbNode);
+            }
+            if (model->B4SOIrdsMod)
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIDgPtr, B4SOIDgBinding, B4SOIdNode, B4SOIgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIDspPtr, B4SOIDspBinding, B4SOIdNode, B4SOIsNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOISdpPtr, B4SOISdpBinding, B4SOIsNode, B4SOIdNodePrime);
+                CREATE_KLU_BINDING_TABLE(B4SOISgPtr, B4SOISgBinding, B4SOIsNode, B4SOIgNode);
+                if (model->B4SOIsoiMod != 2)
+                {
+                    CREATE_KLU_BINDING_TABLE(B4SOIDbPtr, B4SOIDbBinding, B4SOIdNode, B4SOIbNode);
+                    CREATE_KLU_BINDING_TABLE(B4SOISbPtr, B4SOISbBinding, B4SOIsNode, B4SOIbNode);
+                }
+            }
+            if (here->B4SOIdebugMod != 0)
+            {
+                CREATE_KLU_BINDING_TABLE(B4SOIVbsPtr, B4SOIVbsBinding, B4SOIvbsNode, B4SOIvbsNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIdsPtr, B4SOIIdsBinding, B4SOIidsNode, B4SOIidsNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIcPtr, B4SOIIcBinding, B4SOIicNode, B4SOIicNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIbsPtr, B4SOIIbsBinding, B4SOIibsNode, B4SOIibsNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIbdPtr, B4SOIIbdBinding, B4SOIibdNode, B4SOIibdNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIiiPtr, B4SOIIiiBinding, B4SOIiiiNode, B4SOIiiiNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIgPtr, B4SOIIgBinding, B4SOIigNode, B4SOIigNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGiggPtr, B4SOIGiggBinding, B4SOIgiggNode, B4SOIgiggNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGigdPtr, B4SOIGigdBinding, B4SOIgigdNode, B4SOIgigdNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIGigbPtr, B4SOIGigbBinding, B4SOIgigbNode, B4SOIgigbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIgidlPtr, B4SOIIgidlBinding, B4SOIigidlNode, B4SOIigidlNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIItunPtr, B4SOIItunBinding, B4SOIitunNode, B4SOIitunNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIIbpPtr, B4SOIIbpBinding, B4SOIibpNode, B4SOIibpNode);
+                CREATE_KLU_BINDING_TABLE(B4SOICbbPtr, B4SOICbbBinding, B4SOIcbbNode, B4SOIcbbNode);
+                CREATE_KLU_BINDING_TABLE(B4SOICbdPtr, B4SOICbdBinding, B4SOIcbdNode, B4SOIcbdNode);
+                CREATE_KLU_BINDING_TABLE(B4SOICbgPtr, B4SOICbgBinding, B4SOIcbgNode, B4SOIcbgNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIQbfPtr, B4SOIQbfBinding, B4SOIqbfNode, B4SOIqbfNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIQjsPtr, B4SOIQjsBinding, B4SOIqjsNode, B4SOIqjsNode);
+                CREATE_KLU_BINDING_TABLE(B4SOIQjdPtr, B4SOIQjdBinding, B4SOIqjdNode, B4SOIqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B4SOIbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B4SOImodel *model = (B4SOImodel *)inModel ;
+    B4SOIinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B4SOI models */
+    for ( ; model != NULL ; model = B4SOInextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B4SOIinstances(model); here != NULL ; here = B4SOInextInstance(here))
+        {
+            if ((model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITemptempPtr, B4SOITemptempBinding, B4SOItempNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITempdpPtr, B4SOITempdpBinding, B4SOItempNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITempspPtr, B4SOITempspBinding, B4SOItempNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITempgPtr, B4SOITempgBinding, B4SOItempNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITempbPtr, B4SOITempbBinding, B4SOItempNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGtempPtr, B4SOIGtempBinding, B4SOIgNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPtempPtr, B4SOIDPtempBinding, B4SOIdNodePrime, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPtempPtr, B4SOISPtempBinding, B4SOIsNodePrime, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEtempPtr, B4SOIEtempBinding, B4SOIeNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBtempPtr, B4SOIBtempBinding, B4SOIbNode, B4SOItempNode);
+                if (here->B4SOIbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIPtempPtr, B4SOIPtempBinding, B4SOIpNode, B4SOItempNode);
+                }
+                if (here->B4SOIsoiMod != 0)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOITempePtr, B4SOITempeBinding, B4SOItempNode, B4SOIeNode);
+                }
+            }
+            if (here->B4SOIbodyMod == 2)
+            {
+            }
+            else if (here->B4SOIbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBpPtr, B4SOIBpBinding, B4SOIbNode, B4SOIpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIPbPtr, B4SOIPbBinding, B4SOIpNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIPpPtr, B4SOIPpBinding, B4SOIpNode, B4SOIpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIPgPtr, B4SOIPgBinding, B4SOIpNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGpPtr, B4SOIGpBinding, B4SOIgNode, B4SOIpNode);
+            }
+            if (here->B4SOIrgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEgePtr, B4SOIGEgeBinding, B4SOIgNodeExt, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEgPtr, B4SOIGEgBinding, B4SOIgNodeExt, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGgePtr, B4SOIGgeBinding, B4SOIgNode, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEdpPtr, B4SOIGEdpBinding, B4SOIgNodeExt, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEspPtr, B4SOIGEspBinding, B4SOIgNodeExt, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEbPtr, B4SOIGEbBinding, B4SOIgNodeExt, B4SOIbNode);
+                }
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMdpPtr, B4SOIGMdpBinding, B4SOIgNodeMid, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMgPtr, B4SOIGMgBinding, B4SOIgNodeMid, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMgmPtr, B4SOIGMgmBinding, B4SOIgNodeMid, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMgePtr, B4SOIGMgeBinding, B4SOIgNodeMid, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMspPtr, B4SOIGMspBinding, B4SOIgNodeMid, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMbPtr, B4SOIGMbBinding, B4SOIgNodeMid, B4SOIbNode);
+                }
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGMePtr, B4SOIGMeBinding, B4SOIgNodeMid, B4SOIeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPgmPtr, B4SOIDPgmBinding, B4SOIdNodePrime, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGgmPtr, B4SOIGgmBinding, B4SOIgNode, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGEgmPtr, B4SOIGEgmBinding, B4SOIgNodeExt, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPgmPtr, B4SOISPgmBinding, B4SOIsNodePrime, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEgmPtr, B4SOIEgmBinding, B4SOIeNode, B4SOIgNodeMid);
+            }
+            if (here->B4SOIsoiMod != 2) /* v3.2 */
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEbPtr, B4SOIEbBinding, B4SOIeNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGbPtr, B4SOIGbBinding, B4SOIgNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPbPtr, B4SOIDPbBinding, B4SOIdNodePrime, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPbPtr, B4SOISPbBinding, B4SOIsNodePrime, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBePtr, B4SOIBeBinding, B4SOIbNode, B4SOIeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBgPtr, B4SOIBgBinding, B4SOIbNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBdpPtr, B4SOIBdpBinding, B4SOIbNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBspPtr, B4SOIBspBinding, B4SOIbNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBbPtr, B4SOIBbBinding, B4SOIbNode, B4SOIbNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEgPtr, B4SOIEgBinding, B4SOIeNode, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEdpPtr, B4SOIEdpBinding, B4SOIeNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEspPtr, B4SOIEspBinding, B4SOIeNode, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGePtr, B4SOIGeBinding, B4SOIgNode, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPePtr, B4SOIDPeBinding, B4SOIdNodePrime, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPePtr, B4SOISPeBinding, B4SOIsNodePrime, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIEePtr, B4SOIEeBinding, B4SOIeNode, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGgPtr, B4SOIGgBinding, B4SOIgNode, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGdpPtr, B4SOIGdpBinding, B4SOIgNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGspPtr, B4SOIGspBinding, B4SOIgNode, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPgPtr, B4SOIDPgBinding, B4SOIdNodePrime, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPdpPtr, B4SOIDPdpBinding, B4SOIdNodePrime, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPspPtr, B4SOIDPspBinding, B4SOIdNodePrime, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPdPtr, B4SOIDPdBinding, B4SOIdNodePrime, B4SOIdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPgPtr, B4SOISPgBinding, B4SOIsNodePrime, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPdpPtr, B4SOISPdpBinding, B4SOIsNodePrime, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPspPtr, B4SOISPspBinding, B4SOIsNodePrime, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPsPtr, B4SOISPsBinding, B4SOIsNodePrime, B4SOIsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDdPtr, B4SOIDdBinding, B4SOIdNode, B4SOIdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDdpPtr, B4SOIDdpBinding, B4SOIdNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISsPtr, B4SOISsBinding, B4SOIsNode, B4SOIsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISspPtr, B4SOISspBinding, B4SOIsNode, B4SOIsNodePrime);
+            if (here->B4SOIrbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDPdbPtr, B4SOIDPdbBinding, B4SOIdNodePrime, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISPsbPtr, B4SOISPsbBinding, B4SOIsNodePrime, B4SOIsbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDBdpPtr, B4SOIDBdpBinding, B4SOIdbNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDBdbPtr, B4SOIDBdbBinding, B4SOIdbNode, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDBbPtr, B4SOIDBbBinding, B4SOIdbNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISBspPtr, B4SOISBspBinding, B4SOIsbNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISBsbPtr, B4SOISBsbBinding, B4SOIsbNode, B4SOIsbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISBbPtr, B4SOISBbBinding, B4SOIsbNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBdbPtr, B4SOIBdbBinding, B4SOIbNode, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIBsbPtr, B4SOIBsbBinding, B4SOIbNode, B4SOIsbNode);
+            }
+            if (model->B4SOIrdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDgPtr, B4SOIDgBinding, B4SOIdNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDspPtr, B4SOIDspBinding, B4SOIdNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISdpPtr, B4SOISdpBinding, B4SOIsNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISgPtr, B4SOISgBinding, B4SOIsNode, B4SOIgNode);
+                if (model->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIDbPtr, B4SOIDbBinding, B4SOIdNode, B4SOIbNode);
+                    CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOISbPtr, B4SOISbBinding, B4SOIsNode, B4SOIbNode);
+                }
+            }
+            if (here->B4SOIdebugMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIVbsPtr, B4SOIVbsBinding, B4SOIvbsNode, B4SOIvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIdsPtr, B4SOIIdsBinding, B4SOIidsNode, B4SOIidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIcPtr, B4SOIIcBinding, B4SOIicNode, B4SOIicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIbsPtr, B4SOIIbsBinding, B4SOIibsNode, B4SOIibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIbdPtr, B4SOIIbdBinding, B4SOIibdNode, B4SOIibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIiiPtr, B4SOIIiiBinding, B4SOIiiiNode, B4SOIiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIgPtr, B4SOIIgBinding, B4SOIigNode, B4SOIigNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGiggPtr, B4SOIGiggBinding, B4SOIgiggNode, B4SOIgiggNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGigdPtr, B4SOIGigdBinding, B4SOIgigdNode, B4SOIgigdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIGigbPtr, B4SOIGigbBinding, B4SOIgigbNode, B4SOIgigbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIgidlPtr, B4SOIIgidlBinding, B4SOIigidlNode, B4SOIigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIItunPtr, B4SOIItunBinding, B4SOIitunNode, B4SOIitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIIbpPtr, B4SOIIbpBinding, B4SOIibpNode, B4SOIibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOICbbPtr, B4SOICbbBinding, B4SOIcbbNode, B4SOIcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOICbdPtr, B4SOICbdBinding, B4SOIcbdNode, B4SOIcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOICbgPtr, B4SOICbgBinding, B4SOIcbgNode, B4SOIcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIQbfPtr, B4SOIQbfBinding, B4SOIqbfNode, B4SOIqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIQjsPtr, B4SOIQjsBinding, B4SOIqjsNode, B4SOIqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(B4SOIQjdPtr, B4SOIQjdBinding, B4SOIqjdNode, B4SOIqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+B4SOIbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    B4SOImodel *model = (B4SOImodel *)inModel ;
+    B4SOIinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the B4SOI models */
+    for ( ; model != NULL ; model = B4SOInextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = B4SOIinstances(model); here != NULL ; here = B4SOInextInstance(here))
+        {
+            if ((model->B4SOIshMod == 1) && (here->B4SOIrth0 != 0.0))
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITemptempPtr, B4SOITemptempBinding, B4SOItempNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITempdpPtr, B4SOITempdpBinding, B4SOItempNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITempspPtr, B4SOITempspBinding, B4SOItempNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITempgPtr, B4SOITempgBinding, B4SOItempNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITempbPtr, B4SOITempbBinding, B4SOItempNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGtempPtr, B4SOIGtempBinding, B4SOIgNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPtempPtr, B4SOIDPtempBinding, B4SOIdNodePrime, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPtempPtr, B4SOISPtempBinding, B4SOIsNodePrime, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEtempPtr, B4SOIEtempBinding, B4SOIeNode, B4SOItempNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBtempPtr, B4SOIBtempBinding, B4SOIbNode, B4SOItempNode);
+                if (here->B4SOIbodyMod == 1)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIPtempPtr, B4SOIPtempBinding, B4SOIpNode, B4SOItempNode);
+                }
+                if (here->B4SOIsoiMod != 0)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOITempePtr, B4SOITempeBinding, B4SOItempNode, B4SOIeNode);
+                }
+            }
+            if (here->B4SOIbodyMod == 2)
+            {
+            }
+            else if (here->B4SOIbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBpPtr, B4SOIBpBinding, B4SOIbNode, B4SOIpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIPbPtr, B4SOIPbBinding, B4SOIpNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIPpPtr, B4SOIPpBinding, B4SOIpNode, B4SOIpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIPgPtr, B4SOIPgBinding, B4SOIpNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGpPtr, B4SOIGpBinding, B4SOIgNode, B4SOIpNode);
+            }
+            if (here->B4SOIrgateMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEgePtr, B4SOIGEgeBinding, B4SOIgNodeExt, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEgPtr, B4SOIGEgBinding, B4SOIgNodeExt, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGgePtr, B4SOIGgeBinding, B4SOIgNode, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEdpPtr, B4SOIGEdpBinding, B4SOIgNodeExt, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEspPtr, B4SOIGEspBinding, B4SOIgNodeExt, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEbPtr, B4SOIGEbBinding, B4SOIgNodeExt, B4SOIbNode);
+                }
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMdpPtr, B4SOIGMdpBinding, B4SOIgNodeMid, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMgPtr, B4SOIGMgBinding, B4SOIgNodeMid, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMgmPtr, B4SOIGMgmBinding, B4SOIgNodeMid, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMgePtr, B4SOIGMgeBinding, B4SOIgNodeMid, B4SOIgNodeExt);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMspPtr, B4SOIGMspBinding, B4SOIgNodeMid, B4SOIsNodePrime);
+                if (here->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMbPtr, B4SOIGMbBinding, B4SOIgNodeMid, B4SOIbNode);
+                }
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGMePtr, B4SOIGMeBinding, B4SOIgNodeMid, B4SOIeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPgmPtr, B4SOIDPgmBinding, B4SOIdNodePrime, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGgmPtr, B4SOIGgmBinding, B4SOIgNode, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGEgmPtr, B4SOIGEgmBinding, B4SOIgNodeExt, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPgmPtr, B4SOISPgmBinding, B4SOIsNodePrime, B4SOIgNodeMid);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEgmPtr, B4SOIEgmBinding, B4SOIeNode, B4SOIgNodeMid);
+            }
+            if (here->B4SOIsoiMod != 2) /* v3.2 */
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEbPtr, B4SOIEbBinding, B4SOIeNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGbPtr, B4SOIGbBinding, B4SOIgNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPbPtr, B4SOIDPbBinding, B4SOIdNodePrime, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPbPtr, B4SOISPbBinding, B4SOIsNodePrime, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBePtr, B4SOIBeBinding, B4SOIbNode, B4SOIeNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBgPtr, B4SOIBgBinding, B4SOIbNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBdpPtr, B4SOIBdpBinding, B4SOIbNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBspPtr, B4SOIBspBinding, B4SOIbNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBbPtr, B4SOIBbBinding, B4SOIbNode, B4SOIbNode);
+            }
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEgPtr, B4SOIEgBinding, B4SOIeNode, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEdpPtr, B4SOIEdpBinding, B4SOIeNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEspPtr, B4SOIEspBinding, B4SOIeNode, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGePtr, B4SOIGeBinding, B4SOIgNode, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPePtr, B4SOIDPeBinding, B4SOIdNodePrime, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPePtr, B4SOISPeBinding, B4SOIsNodePrime, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIEePtr, B4SOIEeBinding, B4SOIeNode, B4SOIeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGgPtr, B4SOIGgBinding, B4SOIgNode, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGdpPtr, B4SOIGdpBinding, B4SOIgNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGspPtr, B4SOIGspBinding, B4SOIgNode, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPgPtr, B4SOIDPgBinding, B4SOIdNodePrime, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPdpPtr, B4SOIDPdpBinding, B4SOIdNodePrime, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPspPtr, B4SOIDPspBinding, B4SOIdNodePrime, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPdPtr, B4SOIDPdBinding, B4SOIdNodePrime, B4SOIdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPgPtr, B4SOISPgBinding, B4SOIsNodePrime, B4SOIgNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPdpPtr, B4SOISPdpBinding, B4SOIsNodePrime, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPspPtr, B4SOISPspBinding, B4SOIsNodePrime, B4SOIsNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPsPtr, B4SOISPsBinding, B4SOIsNodePrime, B4SOIsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDdPtr, B4SOIDdBinding, B4SOIdNode, B4SOIdNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDdpPtr, B4SOIDdpBinding, B4SOIdNode, B4SOIdNodePrime);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISsPtr, B4SOISsBinding, B4SOIsNode, B4SOIsNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISspPtr, B4SOISspBinding, B4SOIsNode, B4SOIsNodePrime);
+            if (here->B4SOIrbodyMod == 1)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDPdbPtr, B4SOIDPdbBinding, B4SOIdNodePrime, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISPsbPtr, B4SOISPsbBinding, B4SOIsNodePrime, B4SOIsbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDBdpPtr, B4SOIDBdpBinding, B4SOIdbNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDBdbPtr, B4SOIDBdbBinding, B4SOIdbNode, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDBbPtr, B4SOIDBbBinding, B4SOIdbNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISBspPtr, B4SOISBspBinding, B4SOIsbNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISBsbPtr, B4SOISBsbBinding, B4SOIsbNode, B4SOIsbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISBbPtr, B4SOISBbBinding, B4SOIsbNode, B4SOIbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBdbPtr, B4SOIBdbBinding, B4SOIbNode, B4SOIdbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIBsbPtr, B4SOIBsbBinding, B4SOIbNode, B4SOIsbNode);
+            }
+            if (model->B4SOIrdsMod)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDgPtr, B4SOIDgBinding, B4SOIdNode, B4SOIgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDspPtr, B4SOIDspBinding, B4SOIdNode, B4SOIsNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISdpPtr, B4SOISdpBinding, B4SOIsNode, B4SOIdNodePrime);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISgPtr, B4SOISgBinding, B4SOIsNode, B4SOIgNode);
+                if (model->B4SOIsoiMod != 2)
+                {
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIDbPtr, B4SOIDbBinding, B4SOIdNode, B4SOIbNode);
+                    CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOISbPtr, B4SOISbBinding, B4SOIsNode, B4SOIbNode);
+                }
+            }
+            if (here->B4SOIdebugMod != 0)
+            {
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIVbsPtr, B4SOIVbsBinding, B4SOIvbsNode, B4SOIvbsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIdsPtr, B4SOIIdsBinding, B4SOIidsNode, B4SOIidsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIcPtr, B4SOIIcBinding, B4SOIicNode, B4SOIicNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIbsPtr, B4SOIIbsBinding, B4SOIibsNode, B4SOIibsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIbdPtr, B4SOIIbdBinding, B4SOIibdNode, B4SOIibdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIiiPtr, B4SOIIiiBinding, B4SOIiiiNode, B4SOIiiiNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIgPtr, B4SOIIgBinding, B4SOIigNode, B4SOIigNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGiggPtr, B4SOIGiggBinding, B4SOIgiggNode, B4SOIgiggNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGigdPtr, B4SOIGigdBinding, B4SOIgigdNode, B4SOIgigdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIGigbPtr, B4SOIGigbBinding, B4SOIgigbNode, B4SOIgigbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIgidlPtr, B4SOIIgidlBinding, B4SOIigidlNode, B4SOIigidlNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIItunPtr, B4SOIItunBinding, B4SOIitunNode, B4SOIitunNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIIbpPtr, B4SOIIbpBinding, B4SOIibpNode, B4SOIibpNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOICbbPtr, B4SOICbbBinding, B4SOIcbbNode, B4SOIcbbNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOICbdPtr, B4SOICbdBinding, B4SOIcbdNode, B4SOIcbdNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOICbgPtr, B4SOICbgBinding, B4SOIcbgNode, B4SOIcbgNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIQbfPtr, B4SOIQbfBinding, B4SOIqbfNode, B4SOIqbfNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIQjsPtr, B4SOIQjsBinding, B4SOIqjsNode, B4SOIqjsNode);
+                CONVERT_KLU_BINDING_TABLE_TO_REAL(B4SOIQjdPtr, B4SOIQjdBinding, B4SOIqjdNode, B4SOIqjdNode);
+            }
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/bsimsoi/b4soidef.h

@@ -742,6 +742,110 @@ typedef struct sB4SOIinstance
         double **B4SOInVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *B4SOITemptempBinding ;
+    BindElement *B4SOITempdpBinding ;
+    BindElement *B4SOITempspBinding ;
+    BindElement *B4SOITempgBinding ;
+    BindElement *B4SOITempbBinding ;
+    BindElement *B4SOIGtempBinding ;
+    BindElement *B4SOIDPtempBinding ;
+    BindElement *B4SOISPtempBinding ;
+    BindElement *B4SOIEtempBinding ;
+    BindElement *B4SOIBtempBinding ;
+    BindElement *B4SOIPtempBinding ;
+    BindElement *B4SOITempeBinding ;
+    BindElement *B4SOIBpBinding ;
+    BindElement *B4SOIPbBinding ;
+    BindElement *B4SOIPpBinding ;
+    BindElement *B4SOIPgBinding ;
+    BindElement *B4SOIGpBinding ;
+    BindElement *B4SOIGEgeBinding ;
+    BindElement *B4SOIGEgBinding ;
+    BindElement *B4SOIGgeBinding ;
+    BindElement *B4SOIGEdpBinding ;
+    BindElement *B4SOIGEspBinding ;
+    BindElement *B4SOIGEbBinding ;
+    BindElement *B4SOIGMdpBinding ;
+    BindElement *B4SOIGMgBinding ;
+    BindElement *B4SOIGMgmBinding ;
+    BindElement *B4SOIGMgeBinding ;
+    BindElement *B4SOIGMspBinding ;
+    BindElement *B4SOIGMbBinding ;
+    BindElement *B4SOIGMeBinding ;
+    BindElement *B4SOIDPgmBinding ;
+    BindElement *B4SOIGgmBinding ;
+    BindElement *B4SOIGEgmBinding ;
+    BindElement *B4SOISPgmBinding ;
+    BindElement *B4SOIEgmBinding ;
+    BindElement *B4SOIEbBinding ;
+    BindElement *B4SOIGbBinding ;
+    BindElement *B4SOIDPbBinding ;
+    BindElement *B4SOISPbBinding ;
+    BindElement *B4SOIBeBinding ;
+    BindElement *B4SOIBgBinding ;
+    BindElement *B4SOIBdpBinding ;
+    BindElement *B4SOIBspBinding ;
+    BindElement *B4SOIBbBinding ;
+    BindElement *B4SOIEgBinding ;
+    BindElement *B4SOIEdpBinding ;
+    BindElement *B4SOIEspBinding ;
+    BindElement *B4SOIGeBinding ;
+    BindElement *B4SOIDPeBinding ;
+    BindElement *B4SOISPeBinding ;
+    BindElement *B4SOIEeBinding ;
+    BindElement *B4SOIGgBinding ;
+    BindElement *B4SOIGdpBinding ;
+    BindElement *B4SOIGspBinding ;
+    BindElement *B4SOIDPgBinding ;
+    BindElement *B4SOIDPdpBinding ;
+    BindElement *B4SOIDPspBinding ;
+    BindElement *B4SOIDPdBinding ;
+    BindElement *B4SOISPgBinding ;
+    BindElement *B4SOISPdpBinding ;
+    BindElement *B4SOISPspBinding ;
+    BindElement *B4SOISPsBinding ;
+    BindElement *B4SOIDdBinding ;
+    BindElement *B4SOIDdpBinding ;
+    BindElement *B4SOISsBinding ;
+    BindElement *B4SOISspBinding ;
+    BindElement *B4SOIDPdbBinding ;
+    BindElement *B4SOISPsbBinding ;
+    BindElement *B4SOIDBdpBinding ;
+    BindElement *B4SOIDBdbBinding ;
+    BindElement *B4SOIDBbBinding ;
+    BindElement *B4SOISBspBinding ;
+    BindElement *B4SOISBsbBinding ;
+    BindElement *B4SOISBbBinding ;
+    BindElement *B4SOIBdbBinding ;
+    BindElement *B4SOIBsbBinding ;
+    BindElement *B4SOIDgBinding ;
+    BindElement *B4SOIDspBinding ;
+    BindElement *B4SOISdpBinding ;
+    BindElement *B4SOISgBinding ;
+    BindElement *B4SOIDbBinding ;
+    BindElement *B4SOISbBinding ;
+    BindElement *B4SOIVbsBinding ;
+    BindElement *B4SOIIdsBinding ;
+    BindElement *B4SOIIcBinding ;
+    BindElement *B4SOIIbsBinding ;
+    BindElement *B4SOIIbdBinding ;
+    BindElement *B4SOIIiiBinding ;
+    BindElement *B4SOIIgBinding ;
+    BindElement *B4SOIGiggBinding ;
+    BindElement *B4SOIGigdBinding ;
+    BindElement *B4SOIGigbBinding ;
+    BindElement *B4SOIIgidlBinding ;
+    BindElement *B4SOIItunBinding ;
+    BindElement *B4SOIIbpBinding ;
+    BindElement *B4SOICbbBinding ;
+    BindElement *B4SOICbdBinding ;
+    BindElement *B4SOICbgBinding ;
+    BindElement *B4SOIQbfBinding ;
+    BindElement *B4SOIQjsBinding ;
+    BindElement *B4SOIQjdBinding ;
+#endif
+
 } B4SOIinstance ;
 
 struct b4soiSizeDependParam

src/spicelib/devices/bsimsoi/b4soiext.h

@@ -29,3 +29,9 @@ extern int B4SOItrunc(GENmodel*,CKTcircuit*,double*);
 extern int B4SOInoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int B4SOIunsetup(GENmodel*,CKTcircuit*);
 extern int B4SOIsoaCheck(CKTcircuit *, GENmodel *);
+
+#ifdef KLU
+extern int B4SOIbindCSC (GENmodel*, CKTcircuit*) ;
+extern int B4SOIbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int B4SOIbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/bsimsoi/b4soiinit.c

@@ -64,6 +64,12 @@ SPICEdev B4SOIinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = B4SOIbindCSC,
+    .DEVbindCSCComplex = B4SOIbindCSCComplex,
+    .DEVbindCSCComplexToReal = B4SOIbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/cap/Makefile.am

@@ -28,6 +28,9 @@ libcap_la_SOURCES =	\
 	captrunc.c
 
 
+if KLU_WANTED
+libcap_la_SOURCES += capbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/cap/capbindCSC.c

@@ -0,0 +1,98 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "capdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+CAPbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CAPmodel *model = (CAPmodel *)inModel ;
+    CAPinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the CAP models */
+    for ( ; model != NULL ; model = CAPnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CAPinstances(model); here != NULL ; here = CAPnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(CAPposPosPtr, CAPposPosBinding, CAPposNode, CAPposNode);
+            CREATE_KLU_BINDING_TABLE(CAPnegNegPtr, CAPnegNegBinding, CAPnegNode, CAPnegNode);
+            CREATE_KLU_BINDING_TABLE(CAPposNegPtr, CAPposNegBinding, CAPposNode, CAPnegNode);
+            CREATE_KLU_BINDING_TABLE(CAPnegPosPtr, CAPnegPosBinding, CAPnegNode, CAPposNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CAPbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CAPmodel *model = (CAPmodel *)inModel ;
+    CAPinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CAP models */
+    for ( ; model != NULL ; model = CAPnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CAPinstances(model); here != NULL ; here = CAPnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CAPposPosPtr, CAPposPosBinding, CAPposNode, CAPposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CAPnegNegPtr, CAPnegNegBinding, CAPnegNode, CAPnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CAPposNegPtr, CAPposNegBinding, CAPposNode, CAPnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CAPnegPosPtr, CAPnegPosBinding, CAPnegNode, CAPposNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CAPbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CAPmodel *model = (CAPmodel *)inModel ;
+    CAPinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CAP models */
+    for ( ; model != NULL ; model = CAPnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CAPinstances(model); here != NULL ; here = CAPnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CAPposPosPtr, CAPposPosBinding, CAPposNode, CAPposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CAPnegNegPtr, CAPnegNegBinding, CAPnegNode, CAPnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CAPposNegPtr, CAPposNegBinding, CAPposNode, CAPnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CAPnegPosPtr, CAPnegPosBinding, CAPnegNode, CAPposNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/cap/capdefs.h

@@ -65,6 +65,13 @@ typedef struct sCAPinstance {
     int    CAPsenParmNo;         /* parameter # for sensitivity use;
                 set equal to  0 if not a design parameter*/
 
+#ifdef KLU
+    BindElement *CAPposPosBinding ;
+    BindElement *CAPnegNegBinding ;
+    BindElement *CAPposNegBinding ;
+    BindElement *CAPnegPosBinding ;
+#endif
+
 } CAPinstance ;
 
 #define CAPqcap CAPstate    /* charge on the capacitor */

src/spicelib/devices/cap/capext.h

@@ -21,3 +21,8 @@ extern int CAPtemp(GENmodel*,CKTcircuit*);
 extern int CAPtrunc(GENmodel*,CKTcircuit*,double*);
 extern int CAPsoaCheck(CKTcircuit *, GENmodel *);
 
+#ifdef KLU
+extern int CAPbindCSC (GENmodel*, CKTcircuit*) ;
+extern int CAPbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int CAPbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/cap/capinit.c

@@ -66,6 +66,12 @@ SPICEdev CAPinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = CAPbindCSC,
+    .DEVbindCSCComplex = CAPbindCSCComplex,
+    .DEVbindCSCComplexToReal = CAPbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/cccs/Makefile.am

@@ -20,7 +20,11 @@ libcccs_la_SOURCES =	\
 	cccssset.c
 
 
+if KLU_WANTED
+libcccs_la_SOURCES += cccsbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/cccs/cccsbindCSC.c

@@ -0,0 +1,92 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "cccsdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+CCCSbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCCSmodel *model = (CCCSmodel *)inModel ;
+    CCCSinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the CCCS models */
+    for ( ; model != NULL ; model = CCCSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCCSinstances(model); here != NULL ; here = CCCSnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(CCCSposContBrPtr, CCCSposContBrBinding, CCCSposNode, CCCScontBranch);
+            CREATE_KLU_BINDING_TABLE(CCCSnegContBrPtr, CCCSnegContBrBinding, CCCSnegNode, CCCScontBranch);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CCCSbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCCSmodel *model = (CCCSmodel *)inModel ;
+    CCCSinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CCCS models */
+    for ( ; model != NULL ; model = CCCSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCCSinstances(model); here != NULL ; here = CCCSnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCCSposContBrPtr, CCCSposContBrBinding, CCCSposNode, CCCScontBranch);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCCSnegContBrPtr, CCCSnegContBrBinding, CCCSnegNode, CCCScontBranch);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CCCSbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCCSmodel *model = (CCCSmodel *)inModel ;
+    CCCSinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CCCS models */
+    for ( ; model != NULL ; model = CCCSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCCSinstances(model); here != NULL ; here = CCCSnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCCSposContBrPtr, CCCSposContBrBinding, CCCSposNode, CCCScontBranch);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCCSnegContBrPtr, CCCSnegContBrBinding, CCCSnegNode, CCCScontBranch);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/cccs/cccsdefs.h

@@ -44,6 +44,11 @@ typedef struct sCCCSinstance {
     int  CCCSsenParmNo;   /* parameter # for sensitivity use;
             set equal to  0 if not a design parameter*/
 
+#ifdef KLU
+    BindElement *CCCSposContBrBinding ;
+    BindElement *CCCSnegContBrBinding ;
+#endif
+
 } CCCSinstance ;
 
 /* per model data */

src/spicelib/devices/cccs/cccsext.h

@@ -14,3 +14,8 @@ extern void CCCSsPrint(GENmodel*,CKTcircuit*);
 extern int CCCSsSetup(SENstruct*,GENmodel*);
 extern int CCCSsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
 
+#ifdef KLU
+extern int CCCSbindCSC (GENmodel*, CKTcircuit*) ;
+extern int CCCSbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int CCCSbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/cccs/cccsinit.c

@@ -66,6 +66,12 @@ SPICEdev CCCSinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = CCCSbindCSC,
+    .DEVbindCSCComplex = CCCSbindCSCComplex,
+    .DEVbindCSCComplexToReal = CCCSbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/ccvs/Makefile.am

@@ -21,6 +21,9 @@ libccvs_la_SOURCES =	\
 	ccvssset.c
 
 
+if KLU_WANTED
+libccvs_la_SOURCES += ccvsbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)

src/spicelib/devices/ccvs/ccvsbindCSC.c

@@ -0,0 +1,101 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "ccvsdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+CCVSbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCVSmodel *model = (CCVSmodel *)inModel ;
+    CCVSinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the CCVS models */
+    for ( ; model != NULL ; model = CCVSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCVSinstances(model); here != NULL ; here = CCVSnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(CCVSposIbrPtr, CCVSposIbrBinding, CCVSposNode, CCVSbranch);
+            CREATE_KLU_BINDING_TABLE(CCVSnegIbrPtr, CCVSnegIbrBinding, CCVSnegNode, CCVSbranch);
+            CREATE_KLU_BINDING_TABLE(CCVSibrNegPtr, CCVSibrNegBinding, CCVSbranch, CCVSnegNode);
+            CREATE_KLU_BINDING_TABLE(CCVSibrPosPtr, CCVSibrPosBinding, CCVSbranch, CCVSposNode);
+            CREATE_KLU_BINDING_TABLE(CCVSibrContBrPtr, CCVSibrContBrBinding, CCVSbranch, CCVScontBranch);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CCVSbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCVSmodel *model = (CCVSmodel *)inModel ;
+    CCVSinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CCVS models */
+    for ( ; model != NULL ; model = CCVSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCVSinstances(model); here != NULL ; here = CCVSnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCVSposIbrPtr, CCVSposIbrBinding, CCVSposNode, CCVSbranch);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCVSnegIbrPtr, CCVSnegIbrBinding, CCVSnegNode, CCVSbranch);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCVSibrNegPtr, CCVSibrNegBinding, CCVSbranch, CCVSnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCVSibrPosPtr, CCVSibrPosBinding, CCVSbranch, CCVSposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CCVSibrContBrPtr, CCVSibrContBrBinding, CCVSbranch, CCVScontBranch);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CCVSbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CCVSmodel *model = (CCVSmodel *)inModel ;
+    CCVSinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CCVS models */
+    for ( ; model != NULL ; model = CCVSnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CCVSinstances(model); here != NULL ; here = CCVSnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCVSposIbrPtr, CCVSposIbrBinding, CCVSposNode, CCVSbranch);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCVSnegIbrPtr, CCVSnegIbrBinding, CCVSnegNode, CCVSbranch);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCVSibrNegPtr, CCVSibrNegBinding, CCVSbranch, CCVSnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCVSibrPosPtr, CCVSibrPosBinding, CCVSbranch, CCVSposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CCVSibrContBrPtr, CCVSibrContBrBinding, CCVSbranch, CCVScontBranch);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/ccvs/ccvsdefs.h

@@ -48,6 +48,14 @@ typedef struct sCCVSinstance {
     int  CCVSsenParmNo;   /* parameter # for sensitivity use;
             set equal to  0 if not a design parameter*/
 
+#ifdef KLU
+    BindElement *CCVSposIbrBinding ;
+    BindElement *CCVSnegIbrBinding ;
+    BindElement *CCVSibrNegBinding ;
+    BindElement *CCVSibrPosBinding ;
+    BindElement *CCVSibrContBrBinding ;
+#endif
+
 } CCVSinstance ;
 
 /* per model data */

src/spicelib/devices/ccvs/ccvsext.h

@@ -14,3 +14,9 @@ extern void CCVSsPrint(GENmodel*,CKTcircuit*);
 extern int CCVSsSetup(SENstruct*,GENmodel*);
 extern int CCVSsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
 extern int CCVSunsetup(GENmodel*,CKTcircuit*);
+
+#ifdef KLU
+extern int CCVSbindCSC (GENmodel*, CKTcircuit*) ;
+extern int CCVSbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int CCVSbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/ccvs/ccvsinit.c

@@ -66,6 +66,12 @@ SPICEdev CCVSinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = CCVSbindCSC,
+    .DEVbindCSCComplex = CCVSbindCSCComplex,
+    .DEVbindCSCComplexToReal = CCVSbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/cpl/cplinit.c

@@ -66,6 +66,12 @@ SPICEdev CPLinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = NULL,
+    .DEVbindCSCComplex = NULL,
+    .DEVbindCSCComplexToReal = NULL,
+#endif
 };
 
 

src/spicelib/devices/csw/Makefile.am

@@ -21,7 +21,11 @@ libcsw_la_SOURCES =	\
 	cswtrunc.c
 
 
+if KLU_WANTED
+libcsw_la_SOURCES += cswbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/csw/cswbindCSC.c

@@ -0,0 +1,98 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "cswdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+CSWbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CSWmodel *model = (CSWmodel *)inModel ;
+    CSWinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the CSW models */
+    for ( ; model != NULL ; model = CSWnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CSWinstances(model); here != NULL ; here = CSWnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(CSWposPosPtr, CSWposPosBinding, CSWposNode, CSWposNode);
+            CREATE_KLU_BINDING_TABLE(CSWposNegPtr, CSWposNegBinding, CSWposNode, CSWnegNode);
+            CREATE_KLU_BINDING_TABLE(CSWnegPosPtr, CSWnegPosBinding, CSWnegNode, CSWposNode);
+            CREATE_KLU_BINDING_TABLE(CSWnegNegPtr, CSWnegNegBinding, CSWnegNode, CSWnegNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CSWbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CSWmodel *model = (CSWmodel *)inModel ;
+    CSWinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CSW models */
+    for ( ; model != NULL ; model = CSWnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CSWinstances(model); here != NULL ; here = CSWnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CSWposPosPtr, CSWposPosBinding, CSWposNode, CSWposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CSWposNegPtr, CSWposNegBinding, CSWposNode, CSWnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CSWnegPosPtr, CSWnegPosBinding, CSWnegNode, CSWposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(CSWnegNegPtr, CSWnegNegBinding, CSWnegNode, CSWnegNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+CSWbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    CSWmodel *model = (CSWmodel *)inModel ;
+    CSWinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the CSW models */
+    for ( ; model != NULL ; model = CSWnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = CSWinstances(model); here != NULL ; here = CSWnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CSWposPosPtr, CSWposPosBinding, CSWposNode, CSWposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CSWposNegPtr, CSWposNegBinding, CSWposNode, CSWnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CSWnegPosPtr, CSWnegPosBinding, CSWnegNode, CSWposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(CSWnegNegPtr, CSWnegNegBinding, CSWnegNode, CSWnegNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/csw/cswdefs.h

@@ -47,10 +47,18 @@ typedef struct sCSWinstance {
     unsigned CSWzero_stateGiven : 1;  /* flag to indicate initial state */
 #ifndef NONOISE
     double CSWnVar[NSTATVARS];
-#else
+#else /* NONOISE */
     double *CSWnVar;
+#endif /* NONOISE */
+
+#ifdef KLU
+    BindElement *CSWposPosBinding ;
+    BindElement *CSWposNegBinding ;
+    BindElement *CSWnegPosBinding ;
+    BindElement *CSWnegNegBinding ;
 #endif
-} CSWinstance;
+
+} CSWinstance ;
 
 /* data per model */
 

src/spicelib/devices/csw/cswext.h

@@ -14,3 +14,10 @@ extern int CSWpzLoad(GENmodel *, CKTcircuit *, SPcomplex *);
 extern int CSWsetup(SMPmatrix *, GENmodel *, CKTcircuit *, int *);
 extern int CSWnoise(int, int, GENmodel *, CKTcircuit *, Ndata *, double *);
 extern int CSWtrunc(GENmodel *, CKTcircuit *, double *);
+
+#ifdef KLU
+extern int CSWbindCSC (GENmodel*, CKTcircuit*) ;
+extern int CSWbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int CSWbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif
+

src/spicelib/devices/csw/cswinit.c

@@ -68,6 +68,12 @@ SPICEdev CSWinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = CSWbindCSC,
+    .DEVbindCSCComplex = CSWbindCSCComplex,
+    .DEVbindCSCComplexToReal = CSWbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/dio/Makefile.am

@@ -32,6 +32,11 @@ libdio_la_SOURCES =	\
 	diotrunc.c
 
 
+if KLU_WANTED
+libdio_la_SOURCES += diobindCSC.c
+endif
+
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/dio/diobindCSC.c

@@ -0,0 +1,107 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "diodefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+DIObindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    DIOmodel *model = (DIOmodel *)inModel ;
+    DIOinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the DIO models */
+    for ( ; model != NULL ; model = DIOnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = DIOinstances(model); here != NULL ; here = DIOnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(DIOposPosPrimePtr, DIOposPosPrimeBinding, DIOposNode, DIOposPrimeNode);
+            CREATE_KLU_BINDING_TABLE(DIOnegPosPrimePtr, DIOnegPosPrimeBinding, DIOnegNode, DIOposPrimeNode);
+            CREATE_KLU_BINDING_TABLE(DIOposPrimePosPtr, DIOposPrimePosBinding, DIOposPrimeNode, DIOposNode);
+            CREATE_KLU_BINDING_TABLE(DIOposPrimeNegPtr, DIOposPrimeNegBinding, DIOposPrimeNode, DIOnegNode);
+            CREATE_KLU_BINDING_TABLE(DIOposPosPtr, DIOposPosBinding, DIOposNode, DIOposNode);
+            CREATE_KLU_BINDING_TABLE(DIOnegNegPtr, DIOnegNegBinding, DIOnegNode, DIOnegNode);
+            CREATE_KLU_BINDING_TABLE(DIOposPrimePosPrimePtr, DIOposPrimePosPrimeBinding, DIOposPrimeNode, DIOposPrimeNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+DIObindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    DIOmodel *model = (DIOmodel *)inModel ;
+    DIOinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the DIO models */
+    for ( ; model != NULL ; model = DIOnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = DIOinstances(model); here != NULL ; here = DIOnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOposPosPrimePtr, DIOposPosPrimeBinding, DIOposNode, DIOposPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOnegPosPrimePtr, DIOnegPosPrimeBinding, DIOnegNode, DIOposPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOposPrimePosPtr, DIOposPrimePosBinding, DIOposPrimeNode, DIOposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOposPrimeNegPtr, DIOposPrimeNegBinding, DIOposPrimeNode, DIOnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOposPosPtr, DIOposPosBinding, DIOposNode, DIOposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOnegNegPtr, DIOnegNegBinding, DIOnegNode, DIOnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(DIOposPrimePosPrimePtr, DIOposPrimePosPrimeBinding, DIOposPrimeNode, DIOposPrimeNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+DIObindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    DIOmodel *model = (DIOmodel *)inModel ;
+    DIOinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the DIO models */
+    for ( ; model != NULL ; model = DIOnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = DIOinstances(model); here != NULL ; here = DIOnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOposPosPrimePtr, DIOposPosPrimeBinding, DIOposNode, DIOposPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOnegPosPrimePtr, DIOnegPosPrimeBinding, DIOnegNode, DIOposPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOposPrimePosPtr, DIOposPrimePosBinding, DIOposPrimeNode, DIOposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOposPrimeNegPtr, DIOposPrimeNegBinding, DIOposPrimeNode, DIOnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOposPosPtr, DIOposPosBinding, DIOposNode, DIOposNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOnegNegPtr, DIOnegNegBinding, DIOnegNode, DIOnegNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(DIOposPrimePosPrimePtr, DIOposPrimePosPrimeBinding, DIOposPrimeNode, DIOposPrimeNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/dio/diodefs.h

@@ -186,6 +186,16 @@ typedef struct sDIOinstance {
         double **DIOnVar;
 #endif /* NONOISE */
 
+#ifdef KLU
+    BindElement *DIOposPosPrimeBinding ;
+    BindElement *DIOnegPosPrimeBinding ;
+    BindElement *DIOposPrimePosBinding ;
+    BindElement *DIOposPrimeNegBinding ;
+    BindElement *DIOposPosBinding ;
+    BindElement *DIOnegNegBinding ;
+    BindElement *DIOposPrimePosPrimeBinding ;
+#endif
+
 } DIOinstance ;
 
 #define DIOsenGeq DIOsens /* stores the perturbed values of geq */

src/spicelib/devices/dio/dioext.h

@@ -27,3 +27,8 @@ extern int DIOnoise(int,int,GENmodel*,CKTcircuit*,Ndata*,double*);
 extern int DIOdSetup(DIOmodel*,CKTcircuit*);
 extern int DIOsoaCheck(CKTcircuit *, GENmodel *);
 
+#ifdef KLU
+extern int DIObindCSC (GENmodel*, CKTcircuit*) ;
+extern int DIObindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int DIObindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/dio/dioinit.c

@@ -67,6 +67,12 @@ SPICEdev DIOinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = DIObindCSC,
+    .DEVbindCSCComplex = DIObindCSCComplex,
+    .DEVbindCSCComplexToReal = DIObindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/hfet1/Makefile.am

@@ -22,7 +22,11 @@ libhfet_la_SOURCES =	\
 	hfettrunc.c
 
 
+if KLU_WANTED
+libhfet_la_SOURCES += hfetbindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/hfet1/hfetbindCSC.c

@@ -0,0 +1,170 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "hfetdefs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+HFETAbindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFETAmodel *model = (HFETAmodel *)inModel ;
+    HFETAinstance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the HFETA models */
+    for ( ; model != NULL ; model = HFETAnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFETAinstances(model); here != NULL ; here = HFETAnextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(HFETAdrainDrainPrimePtr, HFETAdrainDrainPrimeBinding, HFETAdrainNode, HFETAdrainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeDrainPrimePtr, HFETAgatePrimeDrainPrimeBinding, HFETAgatePrimeNode, HFETAdrainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeSourcePrimePtr, HFETAgatePrimeSourcePrimeBinding, HFETAgatePrimeNode, HFETAsourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourceSourcePrimePtr, HFETAsourceSourcePrimeBinding, HFETAsourceNode, HFETAsourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrimeDrainPtr, HFETAdrainPrimeDrainBinding, HFETAdrainPrimeNode, HFETAdrainNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrimeGatePrimePtr, HFETAdrainPrimeGatePrimeBinding, HFETAdrainPrimeNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrimeSourcePrimePtr, HFETAdrainPrimeSourcePrimeBinding, HFETAdrainPrimeNode, HFETAsourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrimeGatePrimePtr, HFETAsourcePrimeGatePrimeBinding, HFETAsourcePrimeNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrimeSourcePtr, HFETAsourcePrimeSourceBinding, HFETAsourcePrimeNode, HFETAsourceNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrimeDrainPrimePtr, HFETAsourcePrimeDrainPrimeBinding, HFETAsourcePrimeNode, HFETAdrainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainDrainPtr, HFETAdrainDrainBinding, HFETAdrainNode, HFETAdrainNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeGatePrimePtr, HFETAgatePrimeGatePrimeBinding, HFETAgatePrimeNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourceSourcePtr, HFETAsourceSourceBinding, HFETAsourceNode, HFETAsourceNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrimeDrainPrimePtr, HFETAdrainPrimeDrainPrimeBinding, HFETAdrainPrimeNode, HFETAdrainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrimeSourcePrimePtr, HFETAsourcePrimeSourcePrimeBinding, HFETAsourcePrimeNode, HFETAsourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrimeDrainPrmPrmPtr, HFETAdrainPrimeDrainPrmPrmBinding, HFETAdrainPrimeNode, HFETAdrainPrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrmPrmDrainPrimePtr, HFETAdrainPrmPrmDrainPrimeBinding, HFETAdrainPrmPrmNode, HFETAdrainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrmPrmGatePrimePtr, HFETAdrainPrmPrmGatePrimeBinding, HFETAdrainPrmPrmNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeDrainPrmPrmPtr, HFETAgatePrimeDrainPrmPrmBinding, HFETAgatePrimeNode, HFETAdrainPrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAdrainPrmPrmDrainPrmPrmPtr, HFETAdrainPrmPrmDrainPrmPrmBinding, HFETAdrainPrmPrmNode, HFETAdrainPrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrimeSourcePrmPrmPtr, HFETAsourcePrimeSourcePrmPrmBinding, HFETAsourcePrimeNode, HFETAsourcePrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrmPrmSourcePrimePtr, HFETAsourcePrmPrmSourcePrimeBinding, HFETAsourcePrmPrmNode, HFETAsourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrmPrmGatePrimePtr, HFETAsourcePrmPrmGatePrimeBinding, HFETAsourcePrmPrmNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeSourcePrmPrmPtr, HFETAgatePrimeSourcePrmPrmBinding, HFETAgatePrimeNode, HFETAsourcePrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAsourcePrmPrmSourcePrmPrmPtr, HFETAsourcePrmPrmSourcePrmPrmBinding, HFETAsourcePrmPrmNode, HFETAsourcePrmPrmNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgateGatePtr, HFETAgateGateBinding, HFETAgateNode, HFETAgateNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgateGatePrimePtr, HFETAgateGatePrimeBinding, HFETAgateNode, HFETAgatePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFETAgatePrimeGatePtr, HFETAgatePrimeGateBinding, HFETAgatePrimeNode, HFETAgateNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+HFETAbindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFETAmodel *model = (HFETAmodel *)inModel ;
+    HFETAinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the HFETA models */
+    for ( ; model != NULL ; model = HFETAnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFETAinstances(model); here != NULL ; here = HFETAnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainDrainPrimePtr, HFETAdrainDrainPrimeBinding, HFETAdrainNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeDrainPrimePtr, HFETAgatePrimeDrainPrimeBinding, HFETAgatePrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeSourcePrimePtr, HFETAgatePrimeSourcePrimeBinding, HFETAgatePrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourceSourcePrimePtr, HFETAsourceSourcePrimeBinding, HFETAsourceNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrimeDrainPtr, HFETAdrainPrimeDrainBinding, HFETAdrainPrimeNode, HFETAdrainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrimeGatePrimePtr, HFETAdrainPrimeGatePrimeBinding, HFETAdrainPrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrimeSourcePrimePtr, HFETAdrainPrimeSourcePrimeBinding, HFETAdrainPrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrimeGatePrimePtr, HFETAsourcePrimeGatePrimeBinding, HFETAsourcePrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrimeSourcePtr, HFETAsourcePrimeSourceBinding, HFETAsourcePrimeNode, HFETAsourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrimeDrainPrimePtr, HFETAsourcePrimeDrainPrimeBinding, HFETAsourcePrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainDrainPtr, HFETAdrainDrainBinding, HFETAdrainNode, HFETAdrainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeGatePrimePtr, HFETAgatePrimeGatePrimeBinding, HFETAgatePrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourceSourcePtr, HFETAsourceSourceBinding, HFETAsourceNode, HFETAsourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrimeDrainPrimePtr, HFETAdrainPrimeDrainPrimeBinding, HFETAdrainPrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrimeSourcePrimePtr, HFETAsourcePrimeSourcePrimeBinding, HFETAsourcePrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrimeDrainPrmPrmPtr, HFETAdrainPrimeDrainPrmPrmBinding, HFETAdrainPrimeNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrmPrmDrainPrimePtr, HFETAdrainPrmPrmDrainPrimeBinding, HFETAdrainPrmPrmNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrmPrmGatePrimePtr, HFETAdrainPrmPrmGatePrimeBinding, HFETAdrainPrmPrmNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeDrainPrmPrmPtr, HFETAgatePrimeDrainPrmPrmBinding, HFETAgatePrimeNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAdrainPrmPrmDrainPrmPrmPtr, HFETAdrainPrmPrmDrainPrmPrmBinding, HFETAdrainPrmPrmNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrimeSourcePrmPrmPtr, HFETAsourcePrimeSourcePrmPrmBinding, HFETAsourcePrimeNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrmPrmSourcePrimePtr, HFETAsourcePrmPrmSourcePrimeBinding, HFETAsourcePrmPrmNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrmPrmGatePrimePtr, HFETAsourcePrmPrmGatePrimeBinding, HFETAsourcePrmPrmNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeSourcePrmPrmPtr, HFETAgatePrimeSourcePrmPrmBinding, HFETAgatePrimeNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAsourcePrmPrmSourcePrmPrmPtr, HFETAsourcePrmPrmSourcePrmPrmBinding, HFETAsourcePrmPrmNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgateGatePtr, HFETAgateGateBinding, HFETAgateNode, HFETAgateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgateGatePrimePtr, HFETAgateGatePrimeBinding, HFETAgateNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFETAgatePrimeGatePtr, HFETAgatePrimeGateBinding, HFETAgatePrimeNode, HFETAgateNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+HFETAbindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFETAmodel *model = (HFETAmodel *)inModel ;
+    HFETAinstance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the HFETA models */
+    for ( ; model != NULL ; model = HFETAnextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFETAinstances(model); here != NULL ; here = HFETAnextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainDrainPrimePtr, HFETAdrainDrainPrimeBinding, HFETAdrainNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeDrainPrimePtr, HFETAgatePrimeDrainPrimeBinding, HFETAgatePrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeSourcePrimePtr, HFETAgatePrimeSourcePrimeBinding, HFETAgatePrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourceSourcePrimePtr, HFETAsourceSourcePrimeBinding, HFETAsourceNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrimeDrainPtr, HFETAdrainPrimeDrainBinding, HFETAdrainPrimeNode, HFETAdrainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrimeGatePrimePtr, HFETAdrainPrimeGatePrimeBinding, HFETAdrainPrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrimeSourcePrimePtr, HFETAdrainPrimeSourcePrimeBinding, HFETAdrainPrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrimeGatePrimePtr, HFETAsourcePrimeGatePrimeBinding, HFETAsourcePrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrimeSourcePtr, HFETAsourcePrimeSourceBinding, HFETAsourcePrimeNode, HFETAsourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrimeDrainPrimePtr, HFETAsourcePrimeDrainPrimeBinding, HFETAsourcePrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainDrainPtr, HFETAdrainDrainBinding, HFETAdrainNode, HFETAdrainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeGatePrimePtr, HFETAgatePrimeGatePrimeBinding, HFETAgatePrimeNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourceSourcePtr, HFETAsourceSourceBinding, HFETAsourceNode, HFETAsourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrimeDrainPrimePtr, HFETAdrainPrimeDrainPrimeBinding, HFETAdrainPrimeNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrimeSourcePrimePtr, HFETAsourcePrimeSourcePrimeBinding, HFETAsourcePrimeNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrimeDrainPrmPrmPtr, HFETAdrainPrimeDrainPrmPrmBinding, HFETAdrainPrimeNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrmPrmDrainPrimePtr, HFETAdrainPrmPrmDrainPrimeBinding, HFETAdrainPrmPrmNode, HFETAdrainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrmPrmGatePrimePtr, HFETAdrainPrmPrmGatePrimeBinding, HFETAdrainPrmPrmNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeDrainPrmPrmPtr, HFETAgatePrimeDrainPrmPrmBinding, HFETAgatePrimeNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAdrainPrmPrmDrainPrmPrmPtr, HFETAdrainPrmPrmDrainPrmPrmBinding, HFETAdrainPrmPrmNode, HFETAdrainPrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrimeSourcePrmPrmPtr, HFETAsourcePrimeSourcePrmPrmBinding, HFETAsourcePrimeNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrmPrmSourcePrimePtr, HFETAsourcePrmPrmSourcePrimeBinding, HFETAsourcePrmPrmNode, HFETAsourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrmPrmGatePrimePtr, HFETAsourcePrmPrmGatePrimeBinding, HFETAsourcePrmPrmNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeSourcePrmPrmPtr, HFETAgatePrimeSourcePrmPrmBinding, HFETAgatePrimeNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAsourcePrmPrmSourcePrmPrmPtr, HFETAsourcePrmPrmSourcePrmPrmBinding, HFETAsourcePrmPrmNode, HFETAsourcePrmPrmNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgateGatePtr, HFETAgateGateBinding, HFETAgateNode, HFETAgateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgateGatePrimePtr, HFETAgateGatePrimeBinding, HFETAgateNode, HFETAgatePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFETAgatePrimeGatePtr, HFETAgatePrimeGateBinding, HFETAgatePrimeNode, HFETAgateNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/hfet1/hfetdefs.h

@@ -125,6 +125,37 @@ typedef struct sHFETAinstance {
     double HFETAfgds;
     double HFETAggrwl;
 
+#ifdef KLU
+    BindElement *HFETAdrainDrainPrimeBinding ;
+    BindElement *HFETAgatePrimeDrainPrimeBinding ;
+    BindElement *HFETAgatePrimeSourcePrimeBinding ;
+    BindElement *HFETAsourceSourcePrimeBinding ;
+    BindElement *HFETAdrainPrimeDrainBinding ;
+    BindElement *HFETAdrainPrimeGatePrimeBinding ;
+    BindElement *HFETAdrainPrimeSourcePrimeBinding ;
+    BindElement *HFETAsourcePrimeGatePrimeBinding ;
+    BindElement *HFETAsourcePrimeSourceBinding ;
+    BindElement *HFETAsourcePrimeDrainPrimeBinding ;
+    BindElement *HFETAdrainDrainBinding ;
+    BindElement *HFETAgatePrimeGatePrimeBinding ;
+    BindElement *HFETAsourceSourceBinding ;
+    BindElement *HFETAdrainPrimeDrainPrimeBinding ;
+    BindElement *HFETAsourcePrimeSourcePrimeBinding ;
+    BindElement *HFETAdrainPrimeDrainPrmPrmBinding ;
+    BindElement *HFETAdrainPrmPrmDrainPrimeBinding ;
+    BindElement *HFETAdrainPrmPrmGatePrimeBinding ;
+    BindElement *HFETAgatePrimeDrainPrmPrmBinding ;
+    BindElement *HFETAdrainPrmPrmDrainPrmPrmBinding ;
+    BindElement *HFETAsourcePrimeSourcePrmPrmBinding ;
+    BindElement *HFETAsourcePrmPrmSourcePrimeBinding ;
+    BindElement *HFETAsourcePrmPrmGatePrimeBinding ;
+    BindElement *HFETAgatePrimeSourcePrmPrmBinding ;
+    BindElement *HFETAsourcePrmPrmSourcePrmPrmBinding ;
+    BindElement *HFETAgateGateBinding ;
+    BindElement *HFETAgateGatePrimeBinding ;
+    BindElement *HFETAgatePrimeGateBinding ;
+#endif
+
 } HFETAinstance ;
 
 

src/spicelib/devices/hfet1/hfetext.h

@@ -15,3 +15,9 @@ extern int HFETAsetup(SMPmatrix*,GENmodel*,CKTcircuit*,int*);
 extern int HFETAtemp(GENmodel*,CKTcircuit*);
 extern int HFETAtrunc(GENmodel*,CKTcircuit*,double*);
 extern int HFETAunsetup(GENmodel*,CKTcircuit*);
+
+#ifdef KLU
+extern int HFETAbindCSC (GENmodel*, CKTcircuit*) ;
+extern int HFETAbindCSCComplex (GENmodel*, CKTcircuit*) ;
+extern int HFETAbindCSCComplexToReal (GENmodel*, CKTcircuit*) ;
+#endif

src/spicelib/devices/hfet1/hfetinit.c

@@ -66,6 +66,12 @@ SPICEdev HFETAinfo = {
     .DEVdump = NULL,
     .DEVacct = NULL,
 #endif
+
+#ifdef KLU
+    .DEVbindCSC = HFETAbindCSC,
+    .DEVbindCSCComplex = HFETAbindCSC,
+    .DEVbindCSCComplexToReal = HFETAbindCSCComplexToReal,
+#endif
 };
 
 

src/spicelib/devices/hfet2/Makefile.am

@@ -22,7 +22,11 @@ libhfet2_la_SOURCES =	\
 	hfet2trunc.c
 
 
+if KLU_WANTED
+libhfet2_la_SOURCES += hfet2bindCSC.c
+endif
 
 AM_CPPFLAGS = @AM_CPPFLAGS@ -I$(top_srcdir)/src/include
 AM_CFLAGS = $(STATIC)
+
 MAINTAINERCLEANFILES = Makefile.in

src/spicelib/devices/hfet2/hfet2bindCSC.c

@@ -0,0 +1,131 @@
+/**********
+Author: 2013 Francesco Lannutti
+**********/
+
+#include "ngspice/ngspice.h"
+#include "ngspice/cktdefs.h"
+#include "hfet2defs.h"
+#include "ngspice/sperror.h"
+#include "ngspice/klu-binding.h"
+
+#include <stdlib.h>
+
+static
+int
+BindCompare (const void *a, const void *b)
+{
+    BindElement *A, *B ;
+    A = (BindElement *)a ;
+    B = (BindElement *)b ;
+
+    return ((int)(A->Sparse - B->Sparse)) ;
+}
+
+int
+HFET2bindCSC (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFET2model *model = (HFET2model *)inModel ;
+    HFET2instance *here ;
+    double *i ;
+    BindElement *matched, *BindStruct ;
+    size_t nz ;
+
+    BindStruct = ckt->CKTmatrix->CKTbindStruct ;
+    nz = (size_t)ckt->CKTmatrix->CKTklunz ;
+
+    /* loop through all the HFET2 models */
+    for ( ; model != NULL ; model = HFET2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFET2instances(model); here != NULL ; here = HFET2nextInstance(here))
+        {
+            CREATE_KLU_BINDING_TABLE(HFET2drainDrainPrimePtr, HFET2drainDrainPrimeBinding, HFET2drainNode, HFET2drainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2gateDrainPrimePtr, HFET2gateDrainPrimeBinding, HFET2gateNode, HFET2drainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2gateSourcePrimePtr, HFET2gateSourcePrimeBinding, HFET2gateNode, HFET2sourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourceSourcePrimePtr, HFET2sourceSourcePrimeBinding, HFET2sourceNode, HFET2sourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2drainPrimeDrainPtr, HFET2drainPrimeDrainBinding, HFET2drainPrimeNode, HFET2drainNode);
+            CREATE_KLU_BINDING_TABLE(HFET2drainPrimeGatePtr, HFET2drainPrimeGateBinding, HFET2drainPrimeNode, HFET2gateNode);
+            CREATE_KLU_BINDING_TABLE(HFET2drainPriHFET2ourcePrimePtr, HFET2drainPriHFET2ourcePrimeBinding, HFET2drainPrimeNode, HFET2sourcePrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourcePrimeGatePtr, HFET2sourcePrimeGateBinding, HFET2sourcePrimeNode, HFET2gateNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourcePriHFET2ourcePtr, HFET2sourcePriHFET2ourceBinding, HFET2sourcePrimeNode, HFET2sourceNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourcePrimeDrainPrimePtr, HFET2sourcePrimeDrainPrimeBinding, HFET2sourcePrimeNode, HFET2drainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2drainDrainPtr, HFET2drainDrainBinding, HFET2drainNode, HFET2drainNode);
+            CREATE_KLU_BINDING_TABLE(HFET2gateGatePtr, HFET2gateGateBinding, HFET2gateNode, HFET2gateNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourceSourcePtr, HFET2sourceSourceBinding, HFET2sourceNode, HFET2sourceNode);
+            CREATE_KLU_BINDING_TABLE(HFET2drainPrimeDrainPrimePtr, HFET2drainPrimeDrainPrimeBinding, HFET2drainPrimeNode, HFET2drainPrimeNode);
+            CREATE_KLU_BINDING_TABLE(HFET2sourcePriHFET2ourcePrimePtr, HFET2sourcePriHFET2ourcePrimeBinding, HFET2sourcePrimeNode, HFET2sourcePrimeNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+HFET2bindCSCComplex (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFET2model *model = (HFET2model *)inModel ;
+    HFET2instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the HFET2 models */
+    for ( ; model != NULL ; model = HFET2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFET2instances(model); here != NULL ; here = HFET2nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainDrainPrimePtr, HFET2drainDrainPrimeBinding, HFET2drainNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2gateDrainPrimePtr, HFET2gateDrainPrimeBinding, HFET2gateNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2gateSourcePrimePtr, HFET2gateSourcePrimeBinding, HFET2gateNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourceSourcePrimePtr, HFET2sourceSourcePrimeBinding, HFET2sourceNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainPrimeDrainPtr, HFET2drainPrimeDrainBinding, HFET2drainPrimeNode, HFET2drainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainPrimeGatePtr, HFET2drainPrimeGateBinding, HFET2drainPrimeNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainPriHFET2ourcePrimePtr, HFET2drainPriHFET2ourcePrimeBinding, HFET2drainPrimeNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourcePrimeGatePtr, HFET2sourcePrimeGateBinding, HFET2sourcePrimeNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourcePriHFET2ourcePtr, HFET2sourcePriHFET2ourceBinding, HFET2sourcePrimeNode, HFET2sourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourcePrimeDrainPrimePtr, HFET2sourcePrimeDrainPrimeBinding, HFET2sourcePrimeNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainDrainPtr, HFET2drainDrainBinding, HFET2drainNode, HFET2drainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2gateGatePtr, HFET2gateGateBinding, HFET2gateNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourceSourcePtr, HFET2sourceSourceBinding, HFET2sourceNode, HFET2sourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2drainPrimeDrainPrimePtr, HFET2drainPrimeDrainPrimeBinding, HFET2drainPrimeNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_COMPLEX(HFET2sourcePriHFET2ourcePrimePtr, HFET2sourcePriHFET2ourcePrimeBinding, HFET2sourcePrimeNode, HFET2sourcePrimeNode);
+        }
+    }
+
+    return (OK) ;
+}
+
+int
+HFET2bindCSCComplexToReal (GENmodel *inModel, CKTcircuit *ckt)
+{
+    HFET2model *model = (HFET2model *)inModel ;
+    HFET2instance *here ;
+
+    NG_IGNORE (ckt) ;
+
+    /* loop through all the HFET2 models */
+    for ( ; model != NULL ; model = HFET2nextModel(model))
+    {
+        /* loop through all the instances of the model */
+        for (here = HFET2instances(model); here != NULL ; here = HFET2nextInstance(here))
+        {
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainDrainPrimePtr, HFET2drainDrainPrimeBinding, HFET2drainNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2gateDrainPrimePtr, HFET2gateDrainPrimeBinding, HFET2gateNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2gateSourcePrimePtr, HFET2gateSourcePrimeBinding, HFET2gateNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourceSourcePrimePtr, HFET2sourceSourcePrimeBinding, HFET2sourceNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainPrimeDrainPtr, HFET2drainPrimeDrainBinding, HFET2drainPrimeNode, HFET2drainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainPrimeGatePtr, HFET2drainPrimeGateBinding, HFET2drainPrimeNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainPriHFET2ourcePrimePtr, HFET2drainPriHFET2ourcePrimeBinding, HFET2drainPrimeNode, HFET2sourcePrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourcePrimeGatePtr, HFET2sourcePrimeGateBinding, HFET2sourcePrimeNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourcePriHFET2ourcePtr, HFET2sourcePriHFET2ourceBinding, HFET2sourcePrimeNode, HFET2sourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourcePrimeDrainPrimePtr, HFET2sourcePrimeDrainPrimeBinding, HFET2sourcePrimeNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainDrainPtr, HFET2drainDrainBinding, HFET2drainNode, HFET2drainNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2gateGatePtr, HFET2gateGateBinding, HFET2gateNode, HFET2gateNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourceSourcePtr, HFET2sourceSourceBinding, HFET2sourceNode, HFET2sourceNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2drainPrimeDrainPrimePtr, HFET2drainPrimeDrainPrimeBinding, HFET2drainPrimeNode, HFET2drainPrimeNode);
+            CONVERT_KLU_BINDING_TABLE_TO_REAL(HFET2sourcePriHFET2ourcePrimePtr, HFET2sourcePriHFET2ourcePrimeBinding, HFET2sourcePrimeNode, HFET2sourcePrimeNode);
+        }
+    }
+
+    return (OK) ;
+}

src/spicelib/devices/hfet2/hfet2defs.h

@@ -85,7 +85,25 @@ typedef struct sHFET2instance {
     double HFET2vcrit;
     double HFET2ggrlw;
     double HFET2jslw;
-    
+
+#ifdef KLU
+    BindElement *HFET2drainDrainPrimeBinding ;
+    BindElement *HFET2gateDrainPrimeBinding ;
+    BindElement *HFET2gateSourcePrimeBinding ;
+    BindElement *HFET2sourceSourcePrimeBinding ;
+    BindElement *HFET2drainPrimeDrainBinding ;
+    BindElement *HFET2drainPrimeGateBinding ;
+    BindElement *HFET2drainPriHFET2ourcePrimeBinding ;
+    BindElement *HFET2sourcePrimeGateBinding ;
+    BindElement *HFET2sourcePriHFET2ourceBinding ;
+    BindElement *HFET2sourcePrimeDrainPrimeBinding ;
+    BindElement *HFET2drainDrainBinding ;
+    BindElement *HFET2gateGateBinding ;
+    BindElement *HFET2sourceSourceBinding ;
+    BindElement *HFET2drainPrimeDrainPrimeBinding ;
+    BindElement *HFET2sourcePriHFET2ourcePrimeBinding ;
+#endif
+
 } HFET2instance ;