twocond.c

ngspice又一个电子CAD仿真软件代码.功能更全

					   + pHEdge->dJpDp * dpDv);
	    }
	    if ( pVNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pVNode->nEqn ]; 
	      dpDv = dxDv[ pVNode->pEqn ];
	      gTotal -= 0.5 * pElem->dx * (pVEdge->dJnDn * dnDv
					   + pVEdge->dJpDp * dpDv);
	    }
	  }
	  break;
	case 1:
	  /* the TR element */
	  pHNode = pElem->pBRNode;
	  pVNode = pElem->pTLNode;
	  pHEdge = pElem->pBotEdge;
	  pVEdge = pElem->pLeftEdge;
	  if ( pElem->elemType == SEMICON ) {
	    /* compute the derivatives with n,p */
	    if ( pHNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pHNode->nEqn ]; 
	      dpDv = dxDv[ pHNode->pEqn ];
	      gTotal += 0.5 * pElem->dy * (pHEdge->dJnDnP1 * dnDv
					   + pHEdge->dJpDpP1 * dpDv);
	    }
	    if ( pVNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pVNode->nEqn ]; 
	      dpDv = dxDv[ pVNode->pEqn ];
	      gTotal -= 0.5 * pElem->dx * (pVEdge->dJnDn * dnDv
					   + pVEdge->dJpDp * dpDv);
	    }
	  }
	  break;
	case 2:
	  /* the BR element*/
	  pHNode = pElem->pTRNode;
	  pVNode = pElem->pBLNode;
	  pHEdge = pElem->pTopEdge;
	  pVEdge = pElem->pLeftEdge;
	  if ( pElem->elemType == SEMICON ) {
	    /* compute the derivatives with n,p */
	    if ( pHNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pHNode->nEqn ]; 
	      dpDv = dxDv[ pHNode->pEqn ];
	      gTotal += 0.5 * pElem->dy * (pHEdge->dJnDnP1 * dnDv
					   + pHEdge->dJpDpP1 * dpDv);
	    }
	    if ( pVNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pVNode->nEqn ]; 
	      dpDv = dxDv[ pVNode->pEqn ];
	      gTotal += 0.5 * pElem->dx * (pVEdge->dJnDnP1 * dnDv
					   + pVEdge->dJpDpP1 * dpDv);
	    }
	  }
	  break;
	case 3:
	  /* the BL element */
	  pHNode = pElem->pTLNode;
	  pVNode = pElem->pBRNode;
	  pHEdge = pElem->pTopEdge;
	  pVEdge = pElem->pRightEdge;
	  if ( pElem->elemType == SEMICON ) {
	    /* compute the derivatives with n,p */
	    if ( pHNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pHNode->nEqn ]; 
	      dpDv = dxDv[ pHNode->pEqn ];
	      gTotal -= 0.5 * pElem->dy * (pHEdge->dJnDn * dnDv
					   + pHEdge->dJpDp * dpDv);
	    }
	    if ( pVNode->nodeType != CONTACT ) { 
	      dnDv = dxDv[ pVNode->nEqn ]; 
	      dpDv = dxDv[ pVNode->pEqn ];
	      gTotal += 0.5 * pElem->dx * (pVEdge->dJnDnP1 * dnDv
					   + pVEdge->dJpDpP1 * dpDv);
	    }
	  }
	  break;
	}
	if ( pElem->elemType == SEMICON ) {
	  if ( pHNode->nodeType != CONTACT ) { 
	    dPsiDv = dxDv[ pHNode->psiEqn ];
	    gTotal += 0.5 * pElem->dy * dPsiDv * (pHEdge->dJnDpsiP1 + pHEdge->dJpDpsiP1 ); 
	    if ( delVContact ) {
	      gTotal -= 0.5 * pElem->dy * (pHEdge->dJnDpsiP1 + pHEdge->dJpDpsiP1 );
	    }
	  }
	  if ( pVNode->nodeType != CONTACT ) { 
	    dPsiDv = dxDv[ pVNode->psiEqn ];
	    gTotal += 0.5 * pElem->dx * dPsiDv * (pVEdge->dJnDpsiP1 + pVEdge->dJpDpsiP1 ); 
	    if ( delVContact ) {
	      gTotal -= 0.5 * pElem->dx * (pVEdge->dJnDpsiP1 + pVEdge->dJpDpsiP1 );
	    }
	  }
	}
	if ( tranAnalysis ) {
	  /* add the displacement current terms */
	  if ( pHNode->nodeType != CONTACT ) { 
	    dPsiDv = dxDv[ pHNode->psiEqn ];
	    gTotal -= intCoeff[0] * pElem->epsRel * 0.5 * pElem->dyOverDx * dPsiDv;
	    if ( delVContact ) {
	      gTotal += intCoeff[0] * pElem->epsRel * 0.5 * pElem->dyOverDx;
	    }
	  }
	  if ( pVNode->nodeType != CONTACT ) { 
	    dPsiDv = dxDv[ pVNode->psiEqn ];
	    gTotal -= intCoeff[0] * pElem->epsRel * 0.5 * pElem->dxOverDy * dPsiDv;
	    if ( delVContact ) {
	      gTotal += intCoeff[0] * pElem->epsRel * 0.5 * pElem->dxOverDy;
	    }
	  }
	}
      }
    }
  }
  
  return( gTotal );
}


double 
   oxideConductance(TWOdevice *pDevice, TWOcontact *pContact, 
                    BOOLEAN delVContact, double *dxDv, 
	            BOOLEAN tranAnalysis, double *intCoeff)
{
  /* computes the conductance of the contact given in pContact */
  int index, i, numContactNodes;
  TWOnode *pNode, *pHNode = NULL, *pVNode = NULL;
  TWOelem *pElem;
  double dPsiDv;
  double gTotal = 0.0;
  
  if ( !tranAnalysis ) {
    return( gTotal );
  }
  
  numContactNodes = pContact->numNodes;
  for ( index = 0; index < numContactNodes; index++ ) {
    pNode = pContact->pNodes[ index ];
    for ( i = 0; i <= 3; i++ ) {
      pElem = pNode->pElems[ i ];
      if ( pElem != NIL(TWOelem) ) {
	switch ( i ) {
	case 0:
	  /* the TL element */
	  pHNode = pElem->pBLNode;
	  pVNode = pElem->pTRNode;
	  break;
	case 1:
	  /* the TR element */
	  pHNode = pElem->pBRNode;
	  pVNode = pElem->pTLNode;
	  break;
	case 2:
	  /* the BR element*/
	  pHNode = pElem->pTRNode;
	  pVNode = pElem->pBLNode;
	  break;
	case 3:
	  /* the BL element */
	  pHNode = pElem->pTLNode;
	  pVNode = pElem->pBRNode;
	  break;
	}
	/* add the displacement current terms */
	if ( pHNode->nodeType != CONTACT ) { 
	  dPsiDv = dxDv[ pHNode->psiEqn ];
	  gTotal -= intCoeff[0] * pElem->epsRel * 0.5 * pElem->dyOverDx * dPsiDv;
	  if ( delVContact ) {
	    gTotal += intCoeff[0] * pElem->epsRel * 0.5 * pElem->dyOverDx;
	  }
	}
	if ( pVNode->nodeType != CONTACT ) { 
	  dPsiDv = dxDv[ pVNode->psiEqn ];
	  gTotal -= intCoeff[0] * pElem->epsRel * 0.5 * pElem->dxOverDy * dPsiDv;
	  if ( delVContact ) {
	    gTotal += intCoeff[0] * pElem->epsRel * 0.5 * pElem->dxOverDy;
	  }
	}
      }
    }
  }
  
  return( gTotal );
}

/* these functions are used for solving the complete system of 
 * equations directly using LU decomposition   1/22/88
 */

void 
   NUMD2current(TWOdevice *pDevice, BOOLEAN tranAnalysis, 
                double *intCoeff, double *id)
{
  TWOcontact *pPContact = pDevice->pFirstContact;
/*  TWOcontact *pNContact = pDevice->pLastContact; */
  double ip, ipPrime, *solution;
/*  double in;*/
  BOOLEAN deltaVContact = FALSE;
  
  solution = pDevice->dcDeltaSolution;
  ip = contactCurrent( pDevice, pPContact );
  /*
  in = contactCurrent( pDevice, pNContact );
  fprintf(stdout, "DIO current: ( %11.4e error )\n", ip+in );
  fprintf(stdout, "     Ip = %11.4e     In = %11.4e\n", ip, in );
  */

  /* 
   * for the additional contribution to id will make use of 
   * contactConductance. This function will be called
   * with the dcDeltaSolution vector instead of the incremental quantities
   */
  ipPrime = contactConductance( pDevice, pPContact, deltaVContact,
			       solution, tranAnalysis, intCoeff );
  
  ipPrime *= JNorm * pDevice->width * LNorm;
  ip += ipPrime;
  *id = ip;
}

void 
   NBJT2current(TWOdevice *pDevice, BOOLEAN tranAnalysis, double *intCoeff, 
                double *ie, double *ic)
{
  TWOcontact *pEmitContact = pDevice->pLastContact;
  TWOcontact *pColContact = pDevice->pFirstContact;
/*  TWOcontact *pBaseContact = pDevice->pFirstContact->next; */
  double *solution, iePrime, icPrime;
/*  double ib; */
  
  solution = pDevice->dcDeltaSolution;
  
  *ie = contactCurrent( pDevice, pEmitContact );
  *ic = contactCurrent( pDevice, pColContact );
  /*
  ib = contactCurrent( pDevice, pBaseContact );
  fprintf(stdout, "BJT current: ( %11.4e error )\n", *ic+ib+*ie );
  fprintf(stdout, "     Ic = %11.4e     Ib = %11.4e\n", *ic, ib );
  fprintf(stdout, "     Ie = %11.4e\n", *ie );
  */
  
  iePrime = contactConductance( pDevice, pEmitContact, FALSE, solution,
			       tranAnalysis, intCoeff );
  
  icPrime = contactConductance( pDevice, pColContact, FALSE, solution,
			       tranAnalysis, intCoeff );
  
  iePrime *= JNorm * pDevice->width * LNorm;
  icPrime *= JNorm * pDevice->width * LNorm;
  
  *ie += iePrime;
  *ic += icPrime;
}

void 
   NUMOScurrent(TWOdevice *pDevice, BOOLEAN tranAnalysis, double *intCoeff, 
                double *id, double *is, double *ig)
{
  TWOcontact *pDContact = pDevice->pFirstContact;
  TWOcontact *pGContact = pDevice->pFirstContact->next;
  TWOcontact *pSContact = pDevice->pFirstContact->next->next;
/*  TWOcontact *pBContact = pDevice->pLastContact; */
  double *solution, idPrime, isPrime, igPrime;
/*  double ib; */
  
  solution = pDevice->dcDeltaSolution;
  
  *id = contactCurrent( pDevice, pDContact );

/* 
 * This is a terrible hack
 */  
  
#ifdef NORMAL_GATE  
  *ig = GateTypeCurrent( pDevice, pGContact, tranAnalysis );
#else
  *ig = GateTypeCurrent( pDevice, pGContact);
#endif  
  
  *is = contactCurrent( pDevice, pSContact );
  /*
  ib = contactCurrent( pDevice, pBContact );
  fprintf(stdout, "MOS current: ( %11.4e error )\n", *id+*ig+*is+ib );
  fprintf(stdout, "     Id = %11.4e     Is = %11.4e\n", *id, *is );
  fprintf(stdout, "     Ig = %11.4e     Ib = %11.4e\n", *ig, ib );
  */

  idPrime = contactConductance( pDevice, pDContact, FALSE,
			       solution, tranAnalysis, intCoeff );
  
  isPrime = contactConductance( pDevice, pSContact, FALSE,
			       solution, tranAnalysis, intCoeff );
  
  igPrime = GateTypeConductance( pDevice, pGContact, FALSE,
				solution, tranAnalysis, intCoeff );
  
  idPrime *= JNorm * pDevice->width * LNorm;
  isPrime *= JNorm * pDevice->width * LNorm;
  igPrime *= JNorm * pDevice->width * LNorm;
  
  *id += idPrime;
  *is += isPrime;
  *ig += igPrime;
}