diff --git a/src/spicelib/analysis/CUSPICE/cucktflush.c b/src/spicelib/analysis/CUSPICE/cucktflush.c
index b72b06f3b..0573d6751 100644
--- a/src/spicelib/analysis/CUSPICE/cucktflush.c
+++ b/src/spicelib/analysis/CUSPICE/cucktflush.c
@@ -35,7 +35,7 @@ cuCKTflush
 CKTcircuit *ckt
 )
 {
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         long unsigned int m, mRHS ;
 
         m = (long unsigned int)(ckt->total_n_values + 1) ; // + 1 because of CKTdiagGmin
@@ -46,14 +46,6 @@ CKTcircuit *ckt
 
         /* Clean-up the CKTloadOutputRHS */
         cudaMemset (ckt->d_CKTloadOutputRHS, 0, mRHS * sizeof(double)) ;
-    } else {
-        int i, size ;
-
-        size = SMPmatSize (ckt->CKTmatrix) ;
-        for (i = 0 ; i <= size ; i++)
-            *(ckt->CKTrhs + i) = 0 ;
-
-        SMPclear (ckt->CKTmatrix) ;
     }
 
     return (OK) ;
diff --git a/src/spicelib/analysis/CUSPICE/cucktnonconupdate.c b/src/spicelib/analysis/CUSPICE/cucktnonconupdate.c
index 4bdddc9a9..f6f9dded5 100644
--- a/src/spicelib/analysis/CUSPICE/cucktnonconupdate.c
+++ b/src/spicelib/analysis/CUSPICE/cucktnonconupdate.c
@@ -47,7 +47,7 @@ CKTcircuit *ckt
 {
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         status = cudaMemcpy (ckt->d_CKTnoncon, &(ckt->CKTnoncon), sizeof(int), cudaMemcpyHostToDevice) ;
         CUDAMEMCPYCHECK (ckt->d_CKTnoncon, 1, int, status)
     }
@@ -63,7 +63,7 @@ CKTcircuit *ckt
 {
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         status = cudaMemcpy (&(ckt->CKTnoncon), ckt->d_CKTnoncon, sizeof(int), cudaMemcpyDeviceToHost) ;
         CUDAMEMCPYCHECK (&(ckt->CKTnoncon), 1, int, status)
     }
diff --git a/src/spicelib/analysis/CUSPICE/cucktrhsoldupdate.c b/src/spicelib/analysis/CUSPICE/cucktrhsoldupdate.c
index 78feb1f98..bb31c70b7 100644
--- a/src/spicelib/analysis/CUSPICE/cucktrhsoldupdate.c
+++ b/src/spicelib/analysis/CUSPICE/cucktrhsoldupdate.c
@@ -47,7 +47,7 @@ CKTcircuit *ckt
 {
     long unsigned int size ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)(ckt->d_MatrixSize + 1) ;
         cudaMemset (ckt->d_CKTrhsOld, 0, size * sizeof(double)) ;
     }
@@ -64,7 +64,7 @@ CKTcircuit *ckt
     long unsigned int size ;
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)(ckt->d_MatrixSize + 1) ;
         status = cudaMemcpy (ckt->d_CKTrhsOld, ckt->CKTrhsOld, size * sizeof(double), cudaMemcpyHostToDevice) ;
         CUDAMEMCPYCHECK (ckt->d_CKTrhsOld, size, double, status)
@@ -82,7 +82,7 @@ CKTcircuit *ckt
     long unsigned int size ;
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)(ckt->d_MatrixSize + 1) ;
         status = cudaMemcpy (ckt->CKTrhsOld, ckt->d_CKTrhsOld, size * sizeof(double), cudaMemcpyDeviceToHost) ;
         CUDAMEMCPYCHECK (ckt->CKTrhsOld, size, double, status)
diff --git a/src/spicelib/analysis/CUSPICE/cucktsetup.c b/src/spicelib/analysis/CUSPICE/cucktsetup.c
index 320d5bb47..bed4c6192 100644
--- a/src/spicelib/analysis/CUSPICE/cucktsetup.c
+++ b/src/spicelib/analysis/CUSPICE/cucktsetup.c
@@ -76,59 +76,67 @@ CKTcircuit *ckt
     size2 = (long unsigned int)ckt->CKTnumStates ;
     size3 = (long unsigned int)ckt->total_n_timeSteps ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         /* Topology Matrix Handling */
-        status = cudaMalloc ((void **)&(ckt->CKTmatrix->d_CKTrhs), (n + 1) * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->CKTmatrix->d_CKTrhs, (n + 1), double, status)
+        if (ckt->total_n_Ptr > 0) {
+            status = cudaMalloc ((void **)&(ckt->CKTmatrix->d_CKTkluAx), nz * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->CKTmatrix->d_CKTkluAx, nz, double, status)
 
-        status = cudaMalloc ((void **)&(ckt->CKTmatrix->d_CKTkluAx), nz * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->CKTmatrix->d_CKTkluAx, nz, double, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTloadOutput), m * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTloadOutput, m, double, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTloadOutput), m * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTloadOutput, m, double, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRp), (nz + 1) * sizeof(int)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRp, (nz + 1), int, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTloadOutputRHS), mRHS * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTloadOutputRHS, mRHS, double, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRj), TopologyNNZ * sizeof(int)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRj, TopologyNNZ, int, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRp), (nz + 1) * sizeof(int)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRp, (nz + 1), int, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRx), TopologyNNZ * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRx, TopologyNNZ, double, status)
+        }
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRj), TopologyNNZ * sizeof(int)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRj, TopologyNNZ, int, status)
+        if (ckt->total_n_PtrRHS > 0) {
+            status = cudaMalloc ((void **)&(ckt->CKTmatrix->d_CKTrhs), (n + 1) * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->CKTmatrix->d_CKTrhs, (n + 1), double, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRx), TopologyNNZ * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRx, TopologyNNZ, double, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTloadOutputRHS), mRHS * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTloadOutputRHS, mRHS, double, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRpRHS), ((n + 1) + 1) * sizeof(int)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRpRHS, ((n + 1) + 1), int, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRpRHS), ((n + 1) + 1) * sizeof(int)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRpRHS, ((n + 1) + 1), int, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRjRHS), TopologyNNZRHS * sizeof(int)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRjRHS, TopologyNNZRHS, int, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRjRHS), TopologyNNZRHS * sizeof(int)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRjRHS, TopologyNNZRHS, int, status)
 
-        status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRxRHS), TopologyNNZRHS * sizeof(double)) ;
-        CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRxRHS, TopologyNNZRHS, double, status)
+            status = cudaMalloc ((void **)&(ckt->d_CKTtopologyMatrixCSRxRHS), TopologyNNZRHS * sizeof(double)) ;
+            CUDAMALLOCCHECK (ckt->d_CKTtopologyMatrixCSRxRHS, TopologyNNZRHS, double, status)
+        }
 
 
-        cudaMemset (ckt->d_CKTloadOutput + ckt->total_n_values, 0, sizeof(double)) ; //DiagGmin is 0 at the beginning
+        if (ckt->total_n_Ptr > 0) {
+            cudaMemset (ckt->d_CKTloadOutput + ckt->total_n_values, 0, sizeof(double)) ; //DiagGmin is 0 at the beginning
 
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRp, ckt->CKTtopologyMatrixCSRp, (nz + 1) * sizeof(int), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRp, (nz + 1), int, status)
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRp, ckt->CKTtopologyMatrixCSRp, (nz + 1) * sizeof(int), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRp, (nz + 1), int, status)
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRj, ckt->CKTtopologyMatrixCOOj, TopologyNNZ * sizeof(int), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRj, TopologyNNZ, int, status)
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRj, ckt->CKTtopologyMatrixCOOj, TopologyNNZ * sizeof(int), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRj, TopologyNNZ, int, status)
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRx, ckt->CKTtopologyMatrixCOOx, TopologyNNZ * sizeof(double), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRx, TopologyNNZ, double, status)
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRx, ckt->CKTtopologyMatrixCOOx, TopologyNNZ * sizeof(double), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRx, TopologyNNZ, double, status)
+        }
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRpRHS, ckt->CKTtopologyMatrixCSRpRHS, ((n + 1) + 1) * sizeof(int), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRpRHS, ((n + 1) + 1), int, status)
+        if (ckt->total_n_PtrRHS > 0) {
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRpRHS, ckt->CKTtopologyMatrixCSRpRHS, ((n + 1) + 1) * sizeof(int), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRpRHS, ((n + 1) + 1), int, status)
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRjRHS, ckt->CKTtopologyMatrixCOOjRHS, TopologyNNZRHS * sizeof(int), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRjRHS, TopologyNNZRHS, int, status)
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRjRHS, ckt->CKTtopologyMatrixCOOjRHS, TopologyNNZRHS * sizeof(int), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRjRHS, TopologyNNZRHS, int, status)
 
-        status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRxRHS, ckt->CKTtopologyMatrixCOOxRHS, TopologyNNZRHS * sizeof(double), cudaMemcpyHostToDevice) ;
-        CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRxRHS, TopologyNNZRHS, double, status)
+            status = cudaMemcpy (ckt->d_CKTtopologyMatrixCSRxRHS, ckt->CKTtopologyMatrixCOOxRHS, TopologyNNZRHS * sizeof(double), cudaMemcpyHostToDevice) ;
+            CUDAMEMCPYCHECK (ckt->d_CKTtopologyMatrixCSRxRHS, TopologyNNZRHS, double, status)
+        }
         /* ------------------------ */
 
         status = cudaMalloc ((void **)&(ckt->d_CKTnoncon), sizeof(int)) ;
diff --git a/src/spicelib/analysis/CUSPICE/cucktstatesupdate.c b/src/spicelib/analysis/CUSPICE/cucktstatesupdate.c
index d2d26e0cd..7cec763b4 100644
--- a/src/spicelib/analysis/CUSPICE/cucktstatesupdate.c
+++ b/src/spicelib/analysis/CUSPICE/cucktstatesupdate.c
@@ -48,7 +48,7 @@ CKTcircuit *ckt
 {
     long unsigned int size ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)ckt->CKTnumStates ;
         cudaMemset (ckt->d_CKTstate0, 0, size * sizeof(double)) ;
     }
@@ -65,7 +65,7 @@ CKTcircuit *ckt
     long unsigned int size ;
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)ckt->CKTnumStates ;
         status = cudaMemcpy (ckt->d_CKTstate0, ckt->CKTstate0, size * sizeof(double), cudaMemcpyHostToDevice) ;
         CUDAMEMCPYCHECK (ckt->d_CKTstate0, size, double, status)
@@ -83,7 +83,7 @@ CKTcircuit *ckt
     long unsigned int size ;
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         size = (long unsigned int)ckt->CKTnumStates ;
         status = cudaMemcpy (ckt->CKTstate0, ckt->d_CKTstate0, size * sizeof(double), cudaMemcpyDeviceToHost) ;
         CUDAMEMCPYCHECK (ckt->CKTstate0, size, double, status)
@@ -98,7 +98,7 @@ cuCKTstate01copy
 CKTcircuit *ckt
 )
 {
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         long unsigned int size ;
         cudaError_t status ;
 
@@ -121,7 +121,7 @@ CKTcircuit *ckt
     int i ;
     double *temp ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         temp = ckt->d_CKTstates [ckt->CKTmaxOrder + 1] ;
         for (i = ckt->CKTmaxOrder ; i >= 0 ; i--)
             ckt->d_CKTstates [i + 1] = ckt->d_CKTstates [i] ;
@@ -144,7 +144,7 @@ cuCKTstate123copy
 CKTcircuit *ckt
 )
 {
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         long unsigned int size ;
         cudaError_t status ;
 
@@ -171,7 +171,7 @@ CKTcircuit *ckt
 {
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         status = cudaMemcpy (ckt->d_CKTdeltaOld, ckt->CKTdeltaOld, 7 * sizeof(double), cudaMemcpyHostToDevice) ;
         CUDAMEMCPYCHECK (ckt->d_CKTdeltaOld, 7, double, status)
     }
diff --git a/src/spicelib/analysis/CUSPICE/cucktsystem.c b/src/spicelib/analysis/CUSPICE/cucktsystem.c
index b186bab28..37de783d0 100644
--- a/src/spicelib/analysis/CUSPICE/cucktsystem.c
+++ b/src/spicelib/analysis/CUSPICE/cucktsystem.c
@@ -48,13 +48,16 @@ CKTcircuit *ckt
     long unsigned int nz, n ;
     cudaError_t status ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0) {
         nz = (long unsigned int)ckt->CKTmatrix->CKTklunz ;
-        n = (long unsigned int)ckt->CKTmatrix->CKTkluN ;
 
         /* Copy back the Matrix */
         status = cudaMemcpy (ckt->CKTmatrix->CKTkluAx, ckt->CKTmatrix->d_CKTkluAx, nz * sizeof(double), cudaMemcpyDeviceToHost) ;
         CUDAMEMCPYCHECK (ckt->CKTmatrix->CKTkluAx, nz, double, status)
+    }
+
+    if (ckt->total_n_PtrRHS > 0) {
+        n = (long unsigned int)ckt->CKTmatrix->CKTkluN ;
 
         /* Copy back the RHS */
         status = cudaMemcpy (ckt->CKTrhs, ckt->CKTmatrix->d_CKTrhs, (n + 1) * sizeof(double), cudaMemcpyDeviceToHost) ;
diff --git a/src/spicelib/analysis/CUSPICE/cuckttrunc.cu b/src/spicelib/analysis/CUSPICE/cuckttrunc.cu
index c3d159968..079b0a042 100644
--- a/src/spicelib/analysis/CUSPICE/cuckttrunc.cu
+++ b/src/spicelib/analysis/CUSPICE/cuckttrunc.cu
@@ -31,7 +31,7 @@ cuCKTtrunc
 CKTcircuit *ckt, double timetemp, double *timeStep
 )
 {
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         long unsigned int size ;
         double timetempGPU ;
         int thread_x, thread_y, block_x ;
diff --git a/src/spicelib/analysis/cktload.c b/src/spicelib/analysis/cktload.c
index 80b1500b5..6da6ba2e3 100644
--- a/src/spicelib/analysis/cktload.c
+++ b/src/spicelib/analysis/cktload.c
@@ -138,44 +138,48 @@ CKTload(CKTcircuit *ckt)
                                                                 // without the zeroes along the diagonal
     TopologyNNZRHS = ckt->total_n_PtrRHS ;
 
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
-        /* Copy the CKTdiagGmin value to the GPU */
-        // The real Gmin is needed only when the matrix will reside entirely on the GPU
-        // Right now, only some models support CUDA, so the matrix is only partially created on the GPU
-        cudaMemset (ckt->d_CKTloadOutput + ckt->total_n_values, 0, sizeof(double)) ;
-        //cudaError_t statusMemcpy ;
-        //statusMemcpy = cudaMemcpy (ckt->d_CKTloadOutput + ckt->total_n_values, &(ckt->CKTdiagGmin), sizeof(double), cudaMemcpyHostToDevice) ;
-        //CUDAMEMCPYCHECK (ckt->d_CKTloadOutput + ckt->total_n_values, 1, double, statusMemcpy)
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
+        if (ckt->total_n_Ptr > 0) {
+            /* Copy the CKTdiagGmin value to the GPU */
+            // The real Gmin is needed only when the matrix will reside entirely on the GPU
+            // Right now, only some models support CUDA, so the matrix is only partially created on the GPU
+            cudaMemset (ckt->d_CKTloadOutput + ckt->total_n_values, 0, sizeof(double)) ;
+            //cudaError_t statusMemcpy ;
+            //statusMemcpy = cudaMemcpy (ckt->d_CKTloadOutput + ckt->total_n_values, &(ckt->CKTdiagGmin), sizeof(double), cudaMemcpyHostToDevice) ;
+            //CUDAMEMCPYCHECK (ckt->d_CKTloadOutput + ckt->total_n_values, 1, double, statusMemcpy)
 
-        /* Performing CSRMV for the Sparse Matrix using CUSPARSE */
-        cusparseStatus = cusparseDcsrmv ((cusparseHandle_t)(ckt->CKTmatrix->CKTcsrmvHandle),
-                                         CUSPARSE_OPERATION_NON_TRANSPOSE,
-                                         ckt->CKTmatrix->CKTklunz, ckt->total_n_values + 1,
-                                         ckt->total_n_Ptr + ckt->CKTdiagElements,
-                                         &alpha, (cusparseMatDescr_t)(ckt->CKTmatrix->CKTcsrmvDescr),
-                                         ckt->d_CKTtopologyMatrixCSRx, ckt->d_CKTtopologyMatrixCSRp,
-                                         ckt->d_CKTtopologyMatrixCSRj, ckt->d_CKTloadOutput, &beta,
-                                         ckt->CKTmatrix->d_CKTkluAx) ;
+            /* Performing CSRMV for the Sparse Matrix using CUSPARSE */
+            cusparseStatus = cusparseDcsrmv ((cusparseHandle_t)(ckt->CKTmatrix->CKTcsrmvHandle),
+                                             CUSPARSE_OPERATION_NON_TRANSPOSE,
+                                             ckt->CKTmatrix->CKTklunz, ckt->total_n_values + 1,
+                                             ckt->total_n_Ptr + ckt->CKTdiagElements,
+                                             &alpha, (cusparseMatDescr_t)(ckt->CKTmatrix->CKTcsrmvDescr),
+                                             ckt->d_CKTtopologyMatrixCSRx, ckt->d_CKTtopologyMatrixCSRp,
+                                             ckt->d_CKTtopologyMatrixCSRj, ckt->d_CKTloadOutput, &beta,
+                                             ckt->CKTmatrix->d_CKTkluAx) ;
 
-        if (cusparseStatus != CUSPARSE_STATUS_SUCCESS)
-        {
-            fprintf (stderr, "CUSPARSE MATRIX Call Error\n") ;
-            return (E_NOMEM) ;
+            if (cusparseStatus != CUSPARSE_STATUS_SUCCESS)
+            {
+                fprintf (stderr, "CUSPARSE MATRIX Call Error\n") ;
+                return (E_NOMEM) ;
+            }
         }
 
-        /* Performing CSRMV for the RHS using CUSPARSE */
-        cusparseStatus = cusparseDcsrmv ((cusparseHandle_t)(ckt->CKTmatrix->CKTcsrmvHandle),
-                                         CUSPARSE_OPERATION_NON_TRANSPOSE,
-                                         ckt->CKTmatrix->CKTkluN + 1, ckt->total_n_valuesRHS, ckt->total_n_PtrRHS,
-                                         &alpha, (cusparseMatDescr_t)(ckt->CKTmatrix->CKTcsrmvDescr),
-                                         ckt->d_CKTtopologyMatrixCSRxRHS, ckt->d_CKTtopologyMatrixCSRpRHS,
-                                         ckt->d_CKTtopologyMatrixCSRjRHS, ckt->d_CKTloadOutputRHS, &beta,
-                                         ckt->CKTmatrix->d_CKTrhs) ;
+        if (ckt->total_n_PtrRHS > 0) {
+            /* Performing CSRMV for the RHS using CUSPARSE */
+            cusparseStatus = cusparseDcsrmv ((cusparseHandle_t)(ckt->CKTmatrix->CKTcsrmvHandle),
+                                             CUSPARSE_OPERATION_NON_TRANSPOSE,
+                                             ckt->CKTmatrix->CKTkluN + 1, ckt->total_n_valuesRHS, ckt->total_n_PtrRHS,
+                                             &alpha, (cusparseMatDescr_t)(ckt->CKTmatrix->CKTcsrmvDescr),
+                                             ckt->d_CKTtopologyMatrixCSRxRHS, ckt->d_CKTtopologyMatrixCSRpRHS,
+                                             ckt->d_CKTtopologyMatrixCSRjRHS, ckt->d_CKTloadOutputRHS, &beta,
+                                             ckt->CKTmatrix->d_CKTrhs) ;
 
-        if (cusparseStatus != CUSPARSE_STATUS_SUCCESS)
-        {
-            fprintf (stderr, "CUSPARSE RHS Call Error\n") ;
-            return (E_NOMEM) ;
+            if (cusparseStatus != CUSPARSE_STATUS_SUCCESS)
+            {
+                fprintf (stderr, "CUSPARSE RHS Call Error\n") ;
+                return (E_NOMEM) ;
+            }
         }
 
         cudaDeviceSynchronize () ;
diff --git a/src/spicelib/analysis/cktsetup.c b/src/spicelib/analysis/cktsetup.c
index 379faea1a..8c65c3b6e 100644
--- a/src/spicelib/analysis/cktsetup.c
+++ b/src/spicelib/analysis/cktsetup.c
@@ -223,110 +223,114 @@ CKTsetup(CKTcircuit *ckt)
 
         /* CKTloadOutput for the RHS Vector allocation - DIRECTLY in the GPU memory */
 
+        if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
+            /* Diagonal Elements Counting */
+            j = 0 ;
+            for (i = 0 ; i < n ; i++)
+                if (ckt->CKTmatrix->CKTdiag_CSC [i] != NULL)
+                    j++ ;
 
-        /* Diagonal Elements Counting */
-        j = 0 ;
-        for (i = 0 ; i < n ; i++)
-            if (ckt->CKTmatrix->CKTdiag_CSC [i] != NULL)
-                j++ ;
+            ckt->CKTdiagElements = j ;
+            TopologyNNZ = ckt->total_n_Ptr + ckt->CKTdiagElements ; // + ckt->CKTdiagElements because of CKTdiagGmin
+                                                                    // without the zeroes along the diagonal
+            TopologyNNZRHS = ckt->total_n_PtrRHS ;
 
-        ckt->CKTdiagElements = j ;
+            if (ckt->total_n_Ptr > 0) {
+                /* Topology Matrix Pre-Allocation in COO format */
+                ckt->CKTtopologyMatrixCOOi = TMALLOC (int, TopologyNNZ) ;
+                ckt->CKTtopologyMatrixCOOj = TMALLOC (int, TopologyNNZ) ;
+                ckt->CKTtopologyMatrixCOOx = TMALLOC (double, TopologyNNZ) ;
 
-        /* Topology Matrix Pre-Allocation in COO format */
-        TopologyNNZ = ckt->total_n_Ptr + ckt->CKTdiagElements ; // + ckt->CKTdiagElements because of CKTdiagGmin
-                                                                // without the zeroes along the diagonal
-        ckt->CKTtopologyMatrixCOOi = TMALLOC (int, TopologyNNZ) ;
-        ckt->CKTtopologyMatrixCOOj = TMALLOC (int, TopologyNNZ) ;
-        ckt->CKTtopologyMatrixCOOx = TMALLOC (double, TopologyNNZ) ;
-
-        /* Topology Matrix for the RHS Pre-Allocation in COO format */
-        TopologyNNZRHS = ckt->total_n_PtrRHS ;
-        ckt->CKTtopologyMatrixCOOiRHS = TMALLOC (int, TopologyNNZRHS) ;
-        ckt->CKTtopologyMatrixCOOjRHS = TMALLOC (int, TopologyNNZRHS) ;
-        ckt->CKTtopologyMatrixCOOxRHS = TMALLOC (double, TopologyNNZRHS) ;
-
-
-        if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
-
-        /* Topology Matrix Pre-Allocation in CSR format */
-        ckt->CKTtopologyMatrixCSRp = TMALLOC (int, nz + 1) ;
-
-        /* Topology Matrix for the RHS Pre-Allocation in CSR format */
-        ckt->CKTtopologyMatrixCSRpRHS = TMALLOC (int, (n + 1) + 1) ;
-
-
-        /* Topology Matrix Construction & Topology Matrix for the RHS Construction */
-
-        u = 0 ;
-        uRHS = 0 ;
-        for (i = 0 ; i < DEVmaxnum ; i++)
-            if (DEVices [i] && DEVices [i]->DEVtopology && ckt->CKThead [i])
-                DEVices [i]->DEVtopology (ckt->CKThead [i], ckt, &u, &uRHS) ;
-
-
-        /* CKTdiagGmin Contribute Addition to the Topology Matrix */
-        k = u ;
-        for (j = 0 ; j < n ; j++)
-        {
-            if (ckt->CKTmatrix->CKTdiag_CSC [j] >= ckt->CKTmatrix->CKTkluAx)
-            {
-                ckt->CKTtopologyMatrixCOOi [k] = (int)(ckt->CKTmatrix->CKTdiag_CSC [j] - ckt->CKTmatrix->CKTkluAx) ;
-                ckt->CKTtopologyMatrixCOOj [k] = ckt->total_n_values ;
-                ckt->CKTtopologyMatrixCOOx [k] = 1 ;
-                k++ ;
+                /* Topology Matrix Pre-Allocation in CSR format */
+                ckt->CKTtopologyMatrixCSRp = TMALLOC (int, nz + 1) ;
             }
-        }
 
-        /* Copy the Topology Matrix to the GPU in COO format */
+            if (ckt->total_n_PtrRHS > 0) {
+                /* Topology Matrix for the RHS Pre-Allocation in COO format */
+                ckt->CKTtopologyMatrixCOOiRHS = TMALLOC (int, TopologyNNZRHS) ;
+                ckt->CKTtopologyMatrixCOOjRHS = TMALLOC (int, TopologyNNZRHS) ;
+                ckt->CKTtopologyMatrixCOOxRHS = TMALLOC (double, TopologyNNZRHS) ;
+
+                /* Topology Matrix for the RHS Pre-Allocation in CSR format */
+                ckt->CKTtopologyMatrixCSRpRHS = TMALLOC (int, (n + 1) + 1) ;
+            }
+
+            /* Topology Matrix Construction & Topology Matrix for the RHS Construction */
+
+            u = 0 ;
+            uRHS = 0 ;
+            for (i = 0 ; i < DEVmaxnum ; i++)
+                if (DEVices [i] && DEVices [i]->DEVtopology && ckt->CKThead [i])
+                    DEVices [i]->DEVtopology (ckt->CKThead [i], ckt, &u, &uRHS) ;
 
 
-        /* COO format to CSR format Conversion using Quick Sort */
+            /* CKTdiagGmin Contribute Addition to the Topology Matrix */
+            if (ckt->total_n_Ptr > 0) {
+                k = u ;
+                for (j = 0 ; j < n ; j++)
+                {
+                    if (ckt->CKTmatrix->CKTdiag_CSC [j] >= ckt->CKTmatrix->CKTkluAx)
+                    {
+                        ckt->CKTtopologyMatrixCOOi [k] = (int)(ckt->CKTmatrix->CKTdiag_CSC [j] - ckt->CKTmatrix->CKTkluAx) ;
+                        ckt->CKTtopologyMatrixCOOj [k] = ckt->total_n_values ;
+                        ckt->CKTtopologyMatrixCOOx [k] = 1 ;
+                        k++ ;
+                    }
+                }
+            }
 
-        Element *TopologyStruct ;
-        TopologyStruct = TMALLOC (Element, TopologyNNZ) ;
+            /* Copy the Topology Matrix to the GPU in COO format */
 
-        for (i = 0 ; i < TopologyNNZ ; i++)
-        {
-            TopologyStruct [i].row = ckt->CKTtopologyMatrixCOOi [i] ;
-            TopologyStruct [i].col = ckt->CKTtopologyMatrixCOOj [i] ;
-            TopologyStruct [i].val = ckt->CKTtopologyMatrixCOOx [i] ;
-        }
 
-        qsort (TopologyStruct, (size_t)TopologyNNZ, sizeof(Element), Compare) ;
+            /* COO format to CSR format Conversion using Quick Sort */
+            if (ckt->total_n_Ptr > 0) {
+                Element *TopologyStruct ;
+                TopologyStruct = TMALLOC (Element, TopologyNNZ) ;
 
-        for (i = 0 ; i < TopologyNNZ ; i++)
-        {
-            ckt->CKTtopologyMatrixCOOi [i] = TopologyStruct [i].row ;
-            ckt->CKTtopologyMatrixCOOj [i] = TopologyStruct [i].col ;
-            ckt->CKTtopologyMatrixCOOx [i] = TopologyStruct [i].val ;
-        }
+                for (i = 0 ; i < TopologyNNZ ; i++)
+                {
+                    TopologyStruct [i].row = ckt->CKTtopologyMatrixCOOi [i] ;
+                    TopologyStruct [i].col = ckt->CKTtopologyMatrixCOOj [i] ;
+                    TopologyStruct [i].val = ckt->CKTtopologyMatrixCOOx [i] ;
+                }
 
-        ret = Compress (ckt->CKTtopologyMatrixCOOi, ckt->CKTtopologyMatrixCSRp, nz, TopologyNNZ) ;
+                qsort (TopologyStruct, (size_t)TopologyNNZ, sizeof(Element), Compare) ;
 
-        /* COO format to CSR format Conversion for the RHS using Quick Sort */
+                for (i = 0 ; i < TopologyNNZ ; i++)
+                {
+                    ckt->CKTtopologyMatrixCOOi [i] = TopologyStruct [i].row ;
+                    ckt->CKTtopologyMatrixCOOj [i] = TopologyStruct [i].col ;
+                    ckt->CKTtopologyMatrixCOOx [i] = TopologyStruct [i].val ;
+                }
 
-        Element *TopologyStructRHS ;
-        TopologyStructRHS = TMALLOC (Element, TopologyNNZRHS) ;
+                ret = Compress (ckt->CKTtopologyMatrixCOOi, ckt->CKTtopologyMatrixCSRp, nz, TopologyNNZ) ;
+            }
 
-        for (i = 0 ; i < TopologyNNZRHS ; i++)
-        {
-            TopologyStructRHS [i].row = ckt->CKTtopologyMatrixCOOiRHS [i] ;
-            TopologyStructRHS [i].col = ckt->CKTtopologyMatrixCOOjRHS [i] ;
-            TopologyStructRHS [i].val = ckt->CKTtopologyMatrixCOOxRHS [i] ;
-        }
+            /* COO format to CSR format Conversion for the RHS using Quick Sort */
+            if (ckt->total_n_PtrRHS > 0) {
+                Element *TopologyStructRHS ;
+                TopologyStructRHS = TMALLOC (Element, TopologyNNZRHS) ;
 
-        qsort (TopologyStructRHS, (size_t)TopologyNNZRHS, sizeof(Element), Compare) ;
+                for (i = 0 ; i < TopologyNNZRHS ; i++)
+                {
+                    TopologyStructRHS [i].row = ckt->CKTtopologyMatrixCOOiRHS [i] ;
+                    TopologyStructRHS [i].col = ckt->CKTtopologyMatrixCOOjRHS [i] ;
+                    TopologyStructRHS [i].val = ckt->CKTtopologyMatrixCOOxRHS [i] ;
+                }
 
-        for (i = 0 ; i < TopologyNNZRHS ; i++)
-        {
-            ckt->CKTtopologyMatrixCOOiRHS [i] = TopologyStructRHS [i].row ;
-            ckt->CKTtopologyMatrixCOOjRHS [i] = TopologyStructRHS [i].col ;
-            ckt->CKTtopologyMatrixCOOxRHS [i] = TopologyStructRHS [i].val ;
-        }
+                qsort (TopologyStructRHS, (size_t)TopologyNNZRHS, sizeof(Element), Compare) ;
 
-        ret = Compress (ckt->CKTtopologyMatrixCOOiRHS, ckt->CKTtopologyMatrixCSRpRHS, n + 1, TopologyNNZRHS) ;
+                for (i = 0 ; i < TopologyNNZRHS ; i++)
+                {
+                    ckt->CKTtopologyMatrixCOOiRHS [i] = TopologyStructRHS [i].row ;
+                    ckt->CKTtopologyMatrixCOOjRHS [i] = TopologyStructRHS [i].col ;
+                    ckt->CKTtopologyMatrixCOOxRHS [i] = TopologyStructRHS [i].val ;
+                }
 
-        /* Multiply the Topology Matrix by the M Vector to build the Final CSC Matrix - after the CKTload Call */
+                ret = Compress (ckt->CKTtopologyMatrixCOOiRHS, ckt->CKTtopologyMatrixCSRpRHS, n + 1, TopologyNNZRHS) ;
+            }
+
+            /* Multiply the Topology Matrix by the M Vector to build the Final CSC Matrix - after the CKTload Call */
         }
 #endif
 
@@ -340,7 +344,7 @@ CKTsetup(CKTcircuit *ckt)
     }
 
 #ifdef USE_CUSPICE
-    if (ckt->total_n_Ptr > 0 && ckt->total_n_PtrRHS > 0) {
+    if (ckt->total_n_Ptr > 0 || ckt->total_n_PtrRHS > 0) {
         ckt->d_MatrixSize = SMPmatSize (ckt->CKTmatrix) ;
         status = cuCKTsetup (ckt) ;
         if (status != 0)