# Patent

## Title
Simulation of electrical circuits

## Abstract

A method, computer program product, and apparatus for simulating circuits. The method comprises modeling a circuit with an appropriate system of equations, partitioning a time interval on which the system of equations is defined, producing an interpolating polynomial on the time interval, and applying a two tiered iterative approach to solve the system of equations. The approach begins by decomposing a candidate solution vector into its time domain and frequency domain components. The Fourier transform is applied to the frequency domain components and time domain methods are applied to both the time domain components and the Fourier transformed frequency domain components to generate the solution to the original system of equations. Newton's method can be used in combination with a Krylov iterative subspace solver to perform the two-tiered iteration. The computer program product and the apparatus implement the method of simulating circuits.

## Background
BACKGROUND AND SUMMARY
The field of the invention relates generally to the simulation of electrical circuits, and more particularly to the time domain, steady-state simulation of circuits including frequency-dependent linear components.
An important step in the process of designing and constructing radio frequency (RF) integrated circuits is simulation. Indeed, simulation can and should be performed during the design process to ensure that the ultimate goals are achievable and will be realized by the finished product. For example, simulation should be used in the design of the RF integrated circuits that are at the heart of various wireless products such as cellular telephones. Moreover, the exploding demand for high performance wireless products has increased interest in efficient and accurate simulation techniques for RF integrated circuits.
A wireless communications device is comprised of a transmitter and a receiver. Each of these components can be separated into a baseband section and an RF section. The baseband section consists of the range of transmission and reception frequencies. The RF section of the transmitter converts the processed baseband signal to the assigned channel and then sends the signal out. The RF section of the receiver receives the signal and converts it to a baseband signal.
A transmitter should be made so that a minimal amount of energy is used to transmit a standard amount of energy, while not interfering with any transceivers operating on neighboring channels. A receiver should be made so that it can recover small signals accurately, without interference from other channels, while using a minimal amount of energy.
Unfortunately, RF circuits—which are generally constructed using such components as amplifiers, filters, mixers, and oscillators—do not lend themselves to conventional simulation techniques for several reasons.
First, RF circuits have narrowband signals that ride on modulated carriers. For example, cellular telephones have a modulated bandwidth in the range of tens to hundreds of kHz—a relatively low frequency modulation signal range—that rides on a high frequency carrier signal in the range of a few GHz. Since standard simulators, such as SPICE class simulators, use transient analysis to predict the non-linear behavior of a circuit, and since this type of analysis is expensive to use to resolve low modulation frequencies in the presence of a high carrier frequency, these simulators are not well suited to RF circuit simulation.
Second, RF circuits such as mixers exhibit non-linear behavior in response to an additional, large periodic signal known as the LO. This behavior arises because these circuits translate signals from one frequency to another. Unfortunately, standard simulators perform small-signal analyses, such as are needed to predict circuit noise, by linearizing a non-linear, time-invariant circuit about a constant operating point. Therefore, they produce a linear, time-invariant representation that is unable to exhibit the frequency translation effects that are needed to correctly predict noise and gain.
Third, many linear passive components, which play a significant role in circuit behavior, are modeled in the frequency domain using analytic expressions or S-parameter tables. Distributed components are described using partial differential equations, and hence lend themselves to frequency domain analysis. In contrast, time domain simulators are structured to solve systems of first-order, ordinary differential equations. Therefore, they are of limited use by themselves in modeling distributed components.
Thus, RF circuit simulation is difficult because RF circuits typically contain signals with multiple timescale properties, since the data and carrier signals in a system are usually separated in frequency by several orders of magnitude.
When a narrowband signal is passed through a non-linear circuit, it produces a broadband signal with a relatively sparse spectrum. Special purpose RF simulators exploit this sparsity of spectrum in order to make the necessary computations tractable. For example, instead of performing a long transient analysis of a circuit driven by a periodic source, the simulator may seek to find the steady-state directly.
Circuit simulation methods ultimately solve circuit equations, i.e., systems of differential equations. They do this in either the time domain or the frequency domain.
Time domain simulation methods discretize circuit equations using finite difference methods such as the second-order Gear method. The advantage of using time domain methods is that they can select time points based on localized error estimates. As a result, they can easily handle strongly nonlinear phenomena and sharp transitions in circuit waveforms.
Frequency domain simulation methods, such as the harmonic balance method, are popular for RF circuit simulation as they have the advantage of attaining spectral accuracy for smooth waveforms. In addition, the development of matrix-free Krylov-subspace algorithms has made dedicated RF simulation tools even more popular as they can now be used to analyze circuits with thousands of devices.
RF communication circuits often contain components—particularly passive components such as transmission lines, integrated inductors, and SAW filters—where distributed effects are important. Distributed components are components that are not conveniently described by a finite-dimensional, or “lumped,” state-space model because they have an infinite-dimensional state space. The term “distributed component” is used to refer to any component more conveniently described by a frequency domain or convolutional representation. Frequency domain methods have the advantage that they can be used with equal ease to simulate either distributed devices or lumped devices.
In contrast to frequency domain techniques, which have no more difficulty simulating distributed devices than lumped devices, a significant drawback of time domain methods heretofore, is that the simulation of distributed or passive components is much more difficult for them. However, since time domain methods do have the distinct advantage previously noted—that they can select time points based on localized error estimates—it is desirable to use them in simulating distributed devices, in spite of the difficulties associated with their implementation.
There are generally two approaches to using time domain methods in simulating distributed devices. The first approach is to apply a model generation tool to generate finite-dimensional, state-space models for those components. These state-space models are then easily simulated in the time domain. The second approach is to compute, the impulse response of the distributed element, and then apply a convolution approach at each time step to obtain the time domain response of the element. In transient analysis one may use a direct convolution approach to simulate these components without significant difficulty.
In the more general setting of RF circuit simulation, however, such as when using periodic steady-state analysis via shooting-Newton methods, problems arise due to the fact that the distributed components have an infinite-dimensional state space.
First it is not sufficient to calculate the state of the circuit at a single point of the periodic time interval in order to describe the periodic steady-state. Instead, the distributed state of the devices is computed. This in turn implies that the sensitivity calculation in the shooting methods involves more than the two end points of the periodic interval.
Second, the distributed components destroy the block-banded structure of the Jacobian that is exploited in preconditioner computation.
Thus, each type of method—time domain or frequency domain—has strengths that makes it useful in simulation. However, when used alone, each method has weaknesses that limit its applicability to simulating RF circuits efficiently and effectively. It is therefore highly desirable to have a way to combine the strengths of these methods and simultaneously overcome their individual weaknesses. In particular, it would be very useful to have a way to simulate an RF circuit so that on the one hand steady-state time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—i.e., those with an infinite dimensional state space, or a frequency domain description,—can also be simulated.
The present invention solves these problems by providing a method, an apparatus, and a computer program product for simulating a radio frequency (RF) circuit. Various embodiments use a hybrid frequency-time approach to RF simulation. In particular, these embodiments can be used to simulate an RF circuit so that on the one hand steady-state time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—e.g., those with an infinite dimensional state space, or a frequency domain description,—can also be simulated.



BRIEF DESCRIPTION OF THE DRAWINGS
The drawings illustrate the design and utility of embodiments of the present invention, in which similar elements are referred to by common reference numerals. In order to better appreciate the advantages and objects of a preferred embodiment, reference should be made to the accompanying drawings that illustrate this preferred embodiment. However, the drawings depict only one embodiment of the invention, and should not be taken as limiting its scope. With this caveat, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:
FIG. 1 is a schematic of a circuit simulation apparatus;
FIG. 2 is a flow chart of the steps that the apparatus of FIG. 1 performs in simulating a circuit;
FIG. 3 is a flow chart of the Newton's method step in FIG. 2, performed by the apparatus of FIG. 1 in simulating a circuit;
FIG. 4 is a flow chart of the equation evaluation step in FIG. 3, as performed by the apparatus of FIG. 1 in simulating a circuit;
FIG. 5 is a flow chart of the equation update step in FIG. 3, as performed by the apparatus of FIG. 1 in simulating a circuit;
FIG. 6 is a flow chart of the Krylov iteration step in FIG. 5, as performed by the apparatus of FIG. 1 in simulating a circuit;
FIG. 7 is a flow chart of the matrix-vector product evaluation step in FIG. 6, as performed by the apparatus of FIG. 1 in simulating a circuit;
FIG. 8 is a flow chart of the steps a computer program product uses for performing circuit simulation;
FIG. 9 is a flow chart of the Newton's method step in FIG. 8, performed by the computer program product in simulating a circuit;
FIG. 10 is a flow chart of the equation evaluation step in FIG. 9, as performed by the computer program in simulating a circuit;
FIG. 11 is a flow chart of the equation update step in FIG. 9, as performed by the computer program product in simulating a circuit;
FIG. 12 is a flow chart of the Krylov iteration step in FIG. 11, as performed by the computer program product in simulating a circuit;
FIG. 13 is a flow chart of the matrix-vector product evaluation step in FIG. 12, as performed by the computer program product in simulating a circuit;
FIG. 14 is a flow chart of the steps of a method for performing circuit simulation;
FIG. 15 is a flow chart of the Newton's method step in FIG. 14, used in the method of simulating a circuit;
FIG. 16 is a flow chart of the equation evaluation step in FIG. 15, used in the method of simulating a circuit;
FIG. 17 is a flow chart of the equation update step in FIG. 15, used in the method of simulating a circuit;
FIG. 18 is a flow chart of the Krylov iteration step in FIG. 17, used in the method of simulating a circuit; and
FIG. 19 is a flow chart of the matrix-vector product evaluation step in FIG. 18, used in the method of simulating a circuit.



DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
An important step in the process of designing and constructing a circuit—such as, for example, a radio frequency (RF) integrated circuit—is simulation. Indeed, simulation can and should be performed to ensure that the ultimate goals are achievable and will be realized by the finished product. For example, simulation should be used in the production of the RF integrated circuits that are at the heart of various wireless products such as cellular telephones. Moreover, the exploding demand for high performance wireless products has increased interest in efficient and accurate simulation techniques for RF integrated circuits.
In accordance with one preferred embodiment of the present invention, an apparatus for accurately and efficiently simulating a circuit is provided. FIG. 1 is a schematic of the circuit simulation apparatus 100. The apparatus 100 is comprised of a computing apparatus 120 (such as a computer), a means 110 for inputting circuit data into the computer 120, and a computer program 130 that is capable of processing inputted circuit data using a hybrid frequency domain—time domain approach to simulation. In particular, the present invention can be used to simulate a circuit so that on the one hand steady-state (or alternatively, periodic steady-state) time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—i.e., those with an infinite dimensional state space—can also be simulated.
The apparatus 100 produces a model of the circuit. This model is in the form of an appropriate system of equations. The apparatus 100 uses a two-tiered iterative approach to solving the system of equations. FIG. 2 is a flow chart depicting an overview of how the apparatus 100 solves the system of equations to simulate the circuit. As will be discussed in detail below, the apparatus 100 partitions a time interval 205 on which the system of equations is defined, and produces an interpolating polynomial 210 on the interval. The interpolating polynomial 210 provides an initial approximation to the solution, and is used in an iterative method to generate the next approximation. A preferred iterative method is Newton's method 215, and it serves as the top tier of the two-tiered iteration approach used by the apparatus 100.
FIG. 3 is a flow chart showing the implementation of Newton's method 215 to generate the next approximation, and ultimately a solution to the system of equations. The most recent approximation is evaluated in the appropriate iterative equation 305. The result is used to update the equation 310 and an error term is calculated. The error term is compared to a preset tolerance. If the error exceeds the tolerance 325 another iteration is performed 330. Otherwise, if the error is less than the tolerance 315 the iteration stops and the solution is provided as an output 320.
The equation evaluation step 305 of FIG. 3 is shown in greater detail in FIG. 4, which is a flow chart of the evaluation step 305. The candidate solution vector is decomposed 405 into its frequency domain components 420 and its time domain components 410. The apparatus 100 takes the Fourier transform 425 of the frequency domain components, evaluates the result in the frequency domain 430, and then takes the inverse Fourier transform 435 of the evaluation. Meanwhile, the apparatus evaluates the time domain components in the time domain 415. The inverse Fourier transformed evaluation 435 is then combined with the time domain evaluation 415 to produce the equation evaluation 305.
FIG. 5 is a flow chart of the equation update step 310 of FIG. 3, i.e., of Newton's method 215 (or other suitable iterative method). The apparatus prepares information on the Jacobian matrix 505 used in the iterations of Newton's method 215. It also prepares a preconditioner 510 to help speed up convergence to the solution. It then performs the lower tier iteration, which in a preferred embodiment uses a Krylov iterative subspace solver 515, which will be discussed in detail below.
FIG. 6 is a flow chart of the Krylov iterative subspace solver 515 of FIG. 5. The Krylov solver 515 computes a new direction vector 605, and uses it to compute a matrix-vector product evaluation 610 that is part of this lower tier iteration. The result of this evaluation 610 is used to compute the next solution approximation 615. An error term is calculated and compared to a preset tolerance that can—but need not necessarily—be the same as the tolerance used in the top tier iteration discussed above. If the error exceeds the tolerance 630, another iteration is performed 635. Otherwise the solution is provided as an output to be used to update 625 next iteration of the Newton's method loop 310 in FIG. 3.
FIG. 7 is a flow chart of the matrix-vector product evaluation 610 step of FIG. 6. The Krylov subspace vector is decomposed 705 into its frequency domain components 720 and its time domain components 710. The apparatus 100 takes the Fourier transform 725 of the frequency domain components 720, performs a frequency domain Jacobian matrix evaluation 730 on the result, and then takes the inverse Fourier transform 735 of the evaluation 730. The apparatus 100 also performs a time domain Jacobian matrix multiplication 715 using the time domain components 710. The result of this multiplication 715 is combined with the inverse Fourier transform 735 of the frequency domain evaluation 730 to produce the next Krylov solution approximation 615.
A. TIME-FREQUENCY DECOMPOSITION
As a non-limiting example, consider a two-port system. The distributed component properties can be partitioned into time and frequency domain representations as follows. For each port in the distributed component, there is a port equation in the circuit equations. For a two-port system, one of the ports satisfies the relation:




  
    
      
        
          (
          
            1
            -
            
              s
              11
            
          
          )
        
        ⁢
        
          e
          1
        
      
      +
      
        
          (
          
            
              s
              11
            
            -
            1
          
          )
        
        ⁢
        
          e
          1
          ′
        
      
      -
      
        
          s
          12
        
        ⁢
        
          
            
              R
              1
            
            
              R
              2
            
          
        
        ⁢
        
          e
          2
        
      
      +
      
        
          s
          12
        
        ⁢
        
          
            
              R
              1
            
            
              R
              2
            
          
        
        ⁢
        
          e
          2
          ′
        
      
      -
      
        
          (
          
            
              s
              11
            
            +
            1
          
          )
        
        ⁢
        
          R
          1
        
        ⁢
        
          i
          1
        
      
      -
      
        
          s
          12
        
        ⁢
        
          
            
              R
              1
            
            ⁢
            
              R
              2
            
          
        
        ⁢
        
          i
          2
        
      
    
    =
    0
  
  ,




where S(ω)=(sij) is the scattering parameter matrix—which is frequency dependent—ej and ej′ are used to denote the potential at portj, Rj is the resistance at port j, and ij is the current at port j. The other port satisfies the relation:





  
    
      
        -
        
          s
          21
        
      
      ⁢
      
        
          
            R
            2
          
          
            R
            1
          
        
      
      ⁢
      
        e
        1
      
    
    +
    
      
        s
        21
      
      ⁢
      
        
          
            R
            2
          
          
            R
            1
          
        
      
      ⁢
      
        e
        1
        ′
      
    
    -
    
      
        (
        
          1
          -
          
            s
            22
          
        
        )
      
      ⁢
      
        e
        2
      
    
    +
    
      
        (
        
          
            s
            22
          
          -
          1
        
        )
      
      ⁢
      
        e
        2
        ′
      
    
    -
    
      
        s
        21
      
      ⁢
      
        
          
            R
            1
          
          ⁢
          
            R
            2
          
        
      
      ⁢
      
        i
        1
      
    
    -
    
      
        (
        
          
            s
            22
          
          +
          1
        
        )
      
      ⁢
      
        R
        2
      
      ⁢
      
        i
        2
      
    
  
  =
  0.




Since the S-parameter in this formula is frequency dependent, the corresponding equations in the time domain are more complicated but, as will be seen, they can be readily obtained using frequency-time domain transformations. For periodic steady state analysis, the spectrum of the solutions is at integer multiples of the fundamental frequency, which makes the transformation particularly simple. In some cases it is also convenient to decompose the port equations into a frequency-described S-parameter part and a time-described part.
The first port equation can be decomposed into:



  
    
      A
      1
    
    =
    
      
        
          (
          
            1
            -
            
              
                s
                _
              
              11
            
          
          )
        
        ⁢
        
          e
          1
        
      
      -
      
        
          (
          
            1
            -
            
              
                s
                _
              
              11
            
          
          )
        
        ⁢
        
          e
          1
          ′
        
      
      -
      
        
          
            s
            _
          
          12
        
        ⁢
        
          
            
              R
              1
            
            
              R
              2
            
          
        
        ⁢
        
          e
          2
        
      
      +
      
        
          
            s
            _
          
          12
        
        ⁢
        
          
            
              R
              1
            
            
              R
              2
            
          
        
        ⁢
        
          e
          2
          ′
        
      
      -
      
        
          (
          
            1
            +
            
              
                s
                _
              
              11
            
          
          )
        
        ⁢
        
          R
          1
        
        ⁢
        
          i
          1
        
      
      -
      
        
          
            s
            _
          
          12
        
        ⁢
        
          
            
              R
              1
            
            ⁢
            
              R
              2
            
          
        
        ⁢
        
          i
          2
        
        ⁢
        
          
        
        ⁢
        and
      
    
  




  
    
      
        B
        1
      
      =
      
        
          
            (
            
              
                
                  s
                  _
                
                11
              
              -
              
                s
                11
              
            
            )
          
          ⁢
          
            e
            1
          
        
        +
        
          
            (
            
              
                s
                11
              
              -
              
                
                  s
                  _
                
                11
              
            
            )
          
          ⁢
          
            e
            1
            ′
          
        
        -
        
          
            (
            
              
                s
                12
              
              -
              
                
                  s
                  _
                
                12
              
            
            )
          
          ⁢
          
            
              
                R
                1
              
              
                R
                2
              
            
          
          ⁢
          
            e
            2
          
        
        +
        
          
            (
            
              
                s
                12
              
              -
              
                
                  s
                  _
                
                12
              
            
            )
          
          ⁢
          
            
              
                R
                1
              
              
                R
                2
              
            
          
          ⁢
          
            e
            2
            ′
          
        
        -
        
          
            (
            
              
                s
                11
              
              -
              
                
                  s
                  _
                
                11
              
            
            )
          
          ⁢
          
            R
            1
          
          ⁢
          
            i
            1
          
        
        -
        
          
            (
            
              
                s
                12
              
              -
              
                
                  s
                  _
                
                12
              
            
            )
          
          ⁢
          
            
              
                R
                1
              
              ⁢
              
                R
                2
              
            
          
          ⁢
          
            i
            2
          
        
      
    
    ,
  



where A1+B1=0. Likewise the second port equation can be decomposed into:




  
    
      A
      2
    
    =
    
      
        
          -
          
            
              s
              _
            
            21
          
        
        ⁢
        
          
            
              R
              2
            
            
              R
              1
            
          
        
        ⁢
        
          e
          1
        
      
      +
      
        
          
            s
            _
          
          21
        
        ⁢
        
          
            
              R
              2
            
            
              R
              1
            
          
        
        ⁢
        
          e
          1
          ′
        
      
      +
      
        
          (
          
            1
            -
            
              
                s
                _
              
              22
            
          
          )
        
        ⁢
        
          e
          2
        
      
      +
      
        
          (
          
            1
            -
            
              
                s
                _
              
              22
            
          
          )
        
        ⁢
        
          e
          2
          ′
        
      
      -
      
        
          
            s
            _
          
          21
        
        ⁢
        
          
            
              R
              1
            
            ⁢
            
              R
              2
            
          
        
        ⁢
        
          i
          1
        
      
      -
      
        
          
            s
            _
          
          22
        
        ⁢
        
          R
          2
        
        ⁢
        
          i
          2
        
        ⁢
        
          
        
        ⁢
        and
      
    
  




  
    
      
        B
        2
      
      =
      
        
          
            -
            
              (
              
                
                  s
                  21
                
                -
                
                  
                    s
                    _
                  
                  21
                
              
              )
            
          
          ⁢
          
            
              
                R
                2
              
              
                R
                1
              
            
          
          ⁢
          
            e
            1
          
        
        +
        
          
            (
            
              
                s
                21
              
              -
              
                
                  s
                  _
                
                21
              
            
            )
          
          ⁢
          
            
              
                R
                2
              
              
                R
                1
              
            
          
          ⁢
          
            e
            1
            ′
          
        
        -
        
          
            (
            
              
                s
                22
              
              -
              
                
                  s
                  _
                
                22
              
            
            )
          
          ⁢
          
            e
            2
          
        
        +
        
          
            (
            
              
                s
                22
              
              -
              
                
                  s
                  _
                
                22
              
            
            )
          
          ⁢
          
            e
            2
            ′
          
        
        -
        
          
            (
            
              
                s
                21
              
              -
              
                
                  s
                  _
                
                21
              
            
            )
          
          ⁢
          
            
              
                R
                1
              
              ⁢
              
                R
                2
              
            
          
          ⁢
          
            i
            2
          
        
        -
        
          
            (
            
              
                s
                22
              
              -
              
                
                  s
                  _
                
                22
              
            
            )
          
          ⁢
          
            R
            2
          
          ⁢
          
            i
            2
          
        
      
    
    ,
  



where A2+B2=0

In general, S-parameters with bars in the split equations are the S-parameters of some time domain effect such as delay, DC offset, or linear scale. These time domain effects can be calculated in the time domain separately. One simple, non-limiting example is to choose constants for the approximation when the S-parameters at high frequencies approach a constant. Then the frequency-dependent parts, B1 and B2, do not have any high-frequency effects and the impacts of B1 and B2 can be calculated in the frequency domain using Fourier transforms, but without exhibiting oscillations in the sharp transition regions of the time domain waveform. This oscillating behavior in the sharp transition regions of the time domain waveform is known as Gibbs phenomenon.
Moreover, the solution procedure of a preferred embodiment of the present invention can be performed with any time domain, periodic, steady-state solution method. However, one important factor in the implementation is the efficient evaluation of the Fourier transforms. While any method of taking the Fourier transform may, in principle, be used, a preferred embodiment of the present invention uses the method of Chebyshev Fourier quadrature. This method will be discussed in more detail below. However, before describing this method, the discussion focuses on the equations used in the modeling step.
B. THE MODELING EQUATIONS
In the modeling step, the type of circuit determines the form of the model. Lumped circuit behavior—which can be dealt with using time domain methods—can be described by a set of N non-linear differential algebraic equations that can be written, without loss of generality, as:




  
    
      
        
          
            
              
                d
                
                  Q
                  ⁡
                  
                    (
                    
                      v
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                    )
                  
                
              
              
                d
                t
              
            
            +
            
              I
              ⁡
              
                (
                
                  v
                  ⁡
                  
                    (
                    t
                    )
                  
                
                )
              
            
            +
            
              u
              ⁡
              
                (
                r
                )
              
            
          
          =
          0
        
        ;
      
    
    
      
        (
        1
        )
      
    
  




where Q(v(t))εRn is a vector that represents the contribution of the dynamic elements such as inductors and capacitors, I(v(t))εRn is a vector representing static elements such as resistors, u(t)εRn is a vector of inputs, and v(t)εRn is a vector that contains state variables such as node voltages.

Distributed components—which are generally formulated in the frequency domain—are described using a more general form. Suppose that there are K linear, time-invariant, but distributed devices, each of which possesses a convolutional (impulse response) representation. Then the time domain circuit equations may be formulated as:




  
    
      
        
          
            
              d
              
                Q
                ⁡
                
                  (
                  
                    v
                    ⁡
                    
                      (
                      t
                      )
                    
                  
                  )
                
              
            
            
              d
              t
            
          
          +
          
            I
            ⁢
            
              (
              
                v
                ⁡
                
                  (
                  t
                  )
                
              
              )
            
          
          +
          
            [
            
              
                ∑
                
                  k
                  =
                  1
                
                K
              
              ⁢
              
                
              
              ⁢
              
                
                  P
                  k
                
                ⁢
                
                  
                    ∫
                    
                      -
                      ∞
                    
                    t
                  
                  ⁢
                  
                    
                      
                        H
                        k
                      
                      ⁡
                      
                        (
                        
                          t
                          -
                          τ
                        
                        )
                      
                    
                    ⁢
                    
                      P
                      k
                      T
                    
                    ⁢
                    
                      v
                      ⁡
                      
                        (
                        τ
                        )
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      d
                      τ
                    
                  
                
              
            
            ]
          
          +
          
            u
            ⁡
            
              (
              t
              )
            
          
        
        =
        0.
      
    
    
      
        (
        2
        )
      
    
  




Here Hk:(−∞,t]→Rp×pk is the pk×pk matrix of impulse responses for the kth distributed component. It is related to the rest of the circuit equations via a matrix PkεRn×p, where the transpose of Pk, PkT, is an operator that extracts the relevant portion of the state vector. Thus, Pk is one in the (i,j) entry if thejth connection to the kth device is through the state variable with index i, and zero otherwise. PkT is an operator that extracts the relevant portion of the state vector.
In RF circuit simulation, the focus is typically on solving steady-state problems. The periodic, steady-state problem is the simplest and serves as a model for all the others. The periodic, steady-state solution is the solution of Equation (2) that also satisfies the two-point boundary condition v(t+7)−v(t)=0 for some period T and all time t. It is therefore sufficient to calculate the periodic, steady-state solution in the interval [0,T), i.e., the solution is some v(t)ε[0,T)×Rn. This is useful because the (discrete) Fourier transform Fv: →, and its inverse F1=F*—i.e., the inverse of the Fourier operator is the conjugate transpose of the operator—may be used in representing and manipulating signals. F, of course, maps v to its frequency domain representation, i.e., it produces the Fourier series coefficients.
Without loss of generality, a physically realizable distributed linear element can be represented as an N-port component described by an N×N frequency-dependent scattering S-parameter matrix. Since the convolution operation is diagonalized by the Fourier transform, the circuit equations can be written in terms of the frequency dependent matrix H(ω) as:




  
    
      
        
          
            
              
                d
                
                  Q
                  ⁡
                  
                    (
                    
                      v
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                    )
                  
                
              
              
                d
                t
              
            
            +
            
              I
              ⁢
              
                (
                
                  v
                  ⁡
                  
                    (
                    t
                    )
                  
                
                )
              
            
            +
            
              [
              
                
                  ∑
                  
                    k
                    =
                    1
                  
                  N
                
                ⁢
                
                  
                
                ⁢
                
                  
                    P
                    k
                  
                  ⁢
                  
                    F
                    *
                  
                  ⁢
                  
                    
                      H
                      k
                    
                    ⁡
                    
                      (
                      ω
                      )
                    
                  
                  ⁢
                  
                    FP
                    k
                    T
                  
                  ⁢
                  v
                
              
              ]
            
            +
            
              u
              ⁡
              
                (
                t
                )
              
            
          
          =
          0
        
        ,
      
    
    
      
        (
        3
        )
      
    
  




where Hk(ω) is the (continuous) Fourier transform of the kth impulse response matrix.

C. CALCULATION OF THE FOURIER TRANSFORMS
The Fourier transforms 425 and 725—i.e., the Fourier coefficients—computed in both tiers of the two-tiered iterative approach, may be calculated in several different ways, depending on the embodiment used. Examples of calculation methods include the Fast Fourier Transform, the non-equispace Fourier transform, and the various quadrature methods. In a preferred embodiment the Chebyshev Fourier quadrature method is used by the simulation apparatus 100.
Chebyshev discretization—discussed below—achieves high accuracy with relatively few time points. Therefore, the Fourier transform and the inverse Fourier transform can be successfully applied to transform the waveforms between the frequency domain and time domain. The computational cost is at most O(M2), where M is the number of time steps.
For simplicity, consider the Chebyshev collocation method in a single interval—its application to multiple intervals is accomplished on an interval-by-interval basis. In order to use the frequency-dependent S-parameters directly, the time domain waveform is transformed into the frequency domain. Because the waveform is represented with high-order Chebyshev polynomials—as discussed below—Chebyshev quadrature formulas can be used to obtain the Fourier spectrum with high-order accuracy. The order of accuracy is essentially equal to the number of Chebyshev collocation points, i.e., the number of time steps in one Chebyshev time interval. Unlike low-order polynomial approximation methods such as the second-order Gear method, there is no loss of spectral accuracy in this process.
Assume that the time steps are ti, where i=0, . . . , M. Then the integration formula is




  
    
      
        ∫
        
          t
          0
        
        
          t
          M
        
      
      ⁢
      
        
          v
          ⁡
          
            (
            t
            )
          
        
        ⁢
        
          
        
        ⁢
        
          d
          t
        
      
    
    =
    
      
        ∑
        
          i
          =
          1
        
        M
      
      ⁢
      
        
      
      ⁢
      
        
          w
          i
        
        ⁢
        
          v
          ⁡
          
            (
            
              t
              i
            
            )
          
        
      
    
  
  ,
  
    
  
  ⁢
  where








  
    w
    i
  
  =
  
    {
    
      
        
          
            
              
                1
                
                  
                    M
                    2
                  
                  -
                  1
                
              
              ,
            
          
          
            
              i
              =
              0
            
          
        
        
          
            
              
                
                  2
                  M
                
                ⁢
                
                  (
                  
                    1
                    +
                    
                      
                        
                          (
                          
                            -
                            1
                          
                          )
                        
                        
                          (
                          
                            i
                            -
                            1
                          
                          )
                        
                      
                      
                        
                          M
                          2
                        
                        -
                        1
                      
                    
                    +
                    
                      
                        ∑
                        
                          k
                          =
                          1
                        
                        
                          
                            M
                            2
                          
                          -
                          1
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          2
                          
                            1
                            -
                            
                              4
                              ⁢
                              
                                k
                                2
                              
                            
                          
                        
                        ⁢
                        
                          cos
                          ⁡
                          
                            (
                            
                              2
                              ⁢
                              k
                              ⁢
                              
                                π
                                M
                              
                            
                            )
                          
                        
                      
                    
                  
                  )
                
              
              ,
            
          
          
            
              i
              ⁢
              
                <
                _
              
              ⁢
              
                M
                2
              
            
          
        
        
          
            
              
                w
                
                  M
                  -
                  i
                
              
              ,
            
          
          
            
              
                M
                2
              
              <
              i
              ⁢
              
                <
                _
              
              ⁢
              M
            
          
        
      
      .
    
  




The function under consideration is periodic. Therefore, the Fourier spectrum can be calculated using the following formula:




  
    
      
        ∫
        
          t
          0
        
        
          t
          M
        
      
      ⁢
      
        
          v
          ⁡
          
            (
            t
            )
          
        
        ⁢
        
          e
          
            
              -
              j
            
            ⁢
            
              
            
            ⁢
            k
            ⁢
            
              
                2
                ⁢
                π
              
              T
            
            ⁢
            t
          
        
        ⁢
        
          
        
        ⁢
        
          d
          t
        
      
    
    =
    
      
        ∑
        
          i
          =
          0
        
        M
      
      ⁢
      
        
      
      ⁢
      
        
          w
          i
        
        ⁢
        
          v
          ⁡
          
            (
            
              t
              i
            
            )
          
        
        ⁢
        
          e
          
            
              -
              j
            
            ⁢
            
              
            
            ⁢
            k
            ⁢
            
              
                2
                ⁢
                π
              
              T
            
            ⁢
            
              t
              i
            
          
        
      
    
  
  ,




where in keeping with engineering, as opposed to mathematical, notation, j=√{square root over (−1)}.

With the Fourier spectrum known, the evaluation of the portion of the Jacobian due to the frequency-dependent elements can be performed in the frequency domain in the same fashion as in the harmonic balance method. The Jacobian matrix does not have to be formed explicitly. Instead, only the operation of multiplying the Jacobian by a given vector v—as done in Krylov-subspace iterative solvers such as GMRES—is done in the solution of the linear system. This operation is used in taking the matrix-vector product of the linear solver.
After the result of the operation is obtained in the frequency domain, it is transformed back to the time domain using the inverse Fourier transformation. The time domain simulation uses the result at the time points ti, i=0, . . . , M.
For these transformations, the levels of computational complexity of the multi-interval, Chebyshev method and traditional low-order methods are the same, and are generally proportional to the number of time points. Since the number of time points of the Chebyshev method is much smaller than that of traditional time domain methods, the Chebyshev method provides a significant advantage over even traditional low-order methods.
Since there are infinitely many Fourier coefficients for a given function, a choice is made on how many coefficients should actually be computed. This choice is significant because of the potential for aliasing errors. The general rule is that coefficients should be calculated only as far as the available data permits, and this is ultimately based on the number of time steps involved. Accuracy of the Fourier spectrum is quite satisfactory when M is at least 2 k, where M is the number of time points and k is the number of coefficients. As the ratio




  M
  k




increases, so too does the accuracy of the spectrum. Thus, the finer the partition is, the greater the number of coefficients that can be calculated, which concomitantly increases the overall accuracy of the final solution.

D. THE TIME DOMAIN SOLUTION METHOD
In principle, any time domain method can be used to solve the system of equations. However, for traditional, low-order polynomial methods such as the second-order Gear method, the Fourier transformation step is expensive in the sense that it involves many calculations. Therefore, the preferred embodiment of the present invention uses a multi-interval, Chebyshev method as the time domain simulation method. This method has the advantage of preserving the accuracy of the frequency domain model description, and involves less computational time than traditional methods.
Returning to FIG. 2, in a preferred embodiment the simulation apparatus 100 partitions the time interval 205 using Chebyshev Gauss-Lobatto collocation points. These points are of the form




  
    
      t
      j
    
    =
    
      cos
      ⁡
      
        (
        
          
            π
            ⁢
            
              
            
            ⁢
            j
          
          M
        
        )
      
    
  
  ,




j=0, . . . , M. Next the simulator 100 produces an interpolating polynomial 210 based on the given values of u(t) evaluated at the collocation points. The interpolating polynomial is of degree M, and is formed using the standard Chebyshev polynomials, which are of the form: Tk(t)=cos(k cos −1(t)), and which despite being defined in terms of the cosine and arceosine functions are actually expressible inductively as algebraic functions of the variable t.

If uk=u(tk), then the interpolating polynomial has the form:




  
    
      
        
          
            I
            M
          
          ⁢
          
            u
            ⁡
            
              (
              t
              )
            
          
        
        =
        
          
            ∑
            
              k
              =
              0
            
            M
          
          ⁢
          
            
          
          ⁢
          
            
              u
              k
            
            ⁢
            
              
                
                  T
                  k
                
                ⁡
                
                  (
                  t
                  )
                
              
              .
            
          
        
      
    
    
      
        (
        4
        )
      
    
  




Since the polynomial is a linear combination of Chebyshev polynomials, its derivative can be computed using the usual backwards recurrence relation for these polynomials. Thus, the derivative of the polynomial is:





  
    
      
        
          
            
              
                (
                
                  
                    I
                    M
                  
                  ⁢
                  u
                
                )
              
              ′
            
            ⁢
            
              (
              t
              )
            
          
          =
          
            
              ∑
              
                k
                =
                0
              
              M
            
            ⁢
            
              
            
            ⁢
            
              
                u
                k
                ′
              
              ⁢
              
                
                  T
                  k
                
                ⁡
                
                  (
                  t
                  )
                
              
            
          
        
        ,
      
    
    
      
        (
        5
        )
      
    
  




where the uk′ are found from the uk by using the backward relations:

uM=0

ckuk′=uk+2′+2(k+1)uk+1, k=1, 2, . . . , M−1

u0=u2′+2u1  (6)

where ck=2 when k=0 or M, and ck=1 otherwise. The interpolating polynomial has the important property that its time derivative agrees with that of the solution to the differential equation at each collocation point.

The differentiation matrix D can be obtained by expressing the interpolating polynomial in terms of Lagrange interpolating polynomials, gj(t), and setting




  
    D
    kj
  
  =
  
    
      
        d
        
          g
          j
        
      
      
        d
        t
      
    
    ⁢
    
      
        (
        
          t
          k
        
        )
      
      .
    
  




Then the differentiation matrix is D=(Dkj). The entries of the matrix are also expressible as:





  
    
      
        
          
            
              
                
                  D
                  kj
                
                ⁢
                
                =
                
                  
                    
                      
                        c
                        k
                      
                      ⁡
                      
                        (
                        
                          -
                          1
                        
                        )
                      
                    
                    
                      j
                      +
                      k
                    
                  
                  
                    
                      c
                      j
                    
                    ⁡
                    
                      (
                      
                        
                          t
                          k
                        
                        -
                        
                          t
                          j
                        
                      
                      )
                    
                  
                
              
              ,
            
          
          
            
              
              ⁢
              
                j
                ≠
                k
              
            
          
        
        
          
            
              
                
                  D
                  kk
                
                =
                
                  -
                  
                    
                      t
                      k
                    
                    
                      2
                      ⁢
                      
                        (
                        
                          1
                          -
                          
                            t
                            k
                            2
                          
                        
                        )
                      
                    
                  
                
              
              ,
            
          
          
            
              
              ⁢
              
                
                  k
                  ≠
                  0
                
                ,
                M
              
            
          
        
        
          
            
              
                
                  D
                  00
                
                =
                
                  
                    -
                    
                      D
                      MM
                    
                  
                  =
                  
                    
                      
                        2
                        ⁢
                        
                          M
                          2
                        
                      
                      +
                      1
                    
                    6
                  
                
              
              ,
            
          
          
            
              
            
          
        
      
    
    
      
        (
        7
        )
      
    
  




where, as before, ck=2 when k=0 or M, and ck=1 otherwise.

Although the preferred embodiment described above makes use of Chebyshev polynomials, other types of orthogonal polynomials can be used, such as, for example, Legendre polynomials. In fact, one of ordinary skill in the art will appreciate that an arbitrary collection of time domain basis functions can be used without departing from the spirit of the present invention. However, in a preferred embodiment the functions will be basis elements from a complete orthonormal basis for L2 of the appropriate measure space.
As in the classical harmonic balance method, a high degree of accuracy is achievable because in each approximation interval all of the usual desirable properties of Chebyshev polynomials can be exploited.
One approach for the next step is to compute the Jacobian matrix in preparation for applying Newton's method 215. However, in one embodiment only an implicit representation of the Jacobian is used—the actual Jacobian matrix does not have to be constructed explicitly. Iteration is then performed with a decision made at each iteration: if the error is greater than some preset tolerance 325, then another iteration is performed 330. Otherwise, if the error is within the tolerance 315, the solution is given as an output 320.
A significant feature of the present embodiment is the fact that there are actually two sets of iterations being performed. First, there are the iterations directly associated with Newton's method 215. Second, there are the iterations directly associated with the Krylov subspace solver 515. The Krylov subspace solver iterations 515 can be viewed as nested within the Newton's method 215 iterations, with the Krylov subspace solver output 625 serving as the updated input for Newton's method 215. Ultimately, it is the combination of these two iterative procedures that produces the solution to the system of equations.
A difficulty in applying Newton's method 215 lies in inverting the Jacobian, since the general iteration formula is of the form:

Xn+1=Xn−JF(Xn)−1F(Xn)  (8)

where Xj is the jth approximation to the solution of F(X)=0, and JF is the Jacobian matrix of F. In addition, in the nonlinear, steady-state computation, a system is solved at each step of Newton's method 215.

FIG. 5 shows how a preferred embodiment obviates this difficulty in the operation of the Krylov iterative subspace solver 515—the lower iteration tier—by decomposing the Jacobian matrix 505 into three pieces: a dynamic piece, JC, a static piece, JG, and a distributed piece, JD. Using this decomposition 505, the simulator 100 constructs a preconditioner 510 to accelerate the convergence of the iterations, while applying a matrix-implicit, Krylov subspace iterative solver 515. As previously discussed, in the Krylov loop 515 an error term is calculated based on the result 615 produced by the solver 515. If the error is less than a preset tolerance 620, the result is given as an output 625 used in the next Newton's method loop 215. Otherwise another iteration is performed 635.
With the Chebyshev discretization—i.e., the development of the Chebyshev interpolating polynomial—the difficult task of solving the large linear systems generated from the circuit Jacobian matrix is facilitated using




  
    
      
        
          G
          ⁡
          
            (
            
              t
              k
            
            )
          
        
        =
        
          
            
              ∂
              I
            
            
              ∂
              v
            
          
          ⁢
          
            
              
                
                
                  v
                  ⁡
                  
                    (
                    
                      t
                      k
                    
                    )
                  
                
              
              ⁢
              
                ,
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        k
                      
                      )
                    
                  
                  =
                  
                    
                      ∂
                      Q
                    
                    
                      ∂
                      v
                    
                  
                
              
              
            
            
              v
              ⁡
              
                (
                
                  t
                  k
                
                )
              
            
          
        
      
    
    
      
        (
        9
        )
      
    
  




to produce the following expression for the dynamic piece of the Jacobian:





  
    
      
        
          J
          C
        
        =
        
          
            [
            
              
                
                  
                    
                      D
                      1
                    
                    ⊗
                    
                      I
                      1
                    
                  
                
                
                  ...
                
                
                  
                    
                  
                
                
                  
                    
                      D
                      0
                      1
                    
                    ⊗
                    
                      I
                      1
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  ⋰
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                      D
                      2
                    
                    ⊗
                    
                      I
                      2
                    
                  
                
                
                  
                    
                      D
                      0
                      2
                    
                    ⊗
                    
                      I
                      2
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  ⋰
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
            
            ]
          
          ⁢
          
            
          
          ⁢
          
            

          
          ⁢
          
            
          
          [
          
            
              
                
                  C
                  ⁡
                  
                    (
                    
                      t
                      1
                    
                    )
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  C
                  ⁡
                  
                    (
                    
                      t
                      2
                    
                    )
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                
                  C
                  ⁡
                  
                    (
                    
                      t
                      3
                    
                    )
                  
                
              
              
                
                  
                
              
            
            
              
                
                  
                
              
              
                
                  
                
              
              
                
                  
                
              
              
                ⋰
              
            
          
          ]
        
      
    
    
      
        (
        10
        )
      
    
  




where Dk is that part of the Chebyshev differentiation matrix, D, that is in the kth interval ([Dij]|i,j=1, . . . , M), D0kis([Dij]|i=1, . . . , M; j=0), and Ik is the identity matrix of dimension equal to the number of time points in the kth interval. Corresponding expressions for the static and distributed pieces are:





  
    
      
        
          J
          G
        
        =
        
          
            
              [
              
                
                  
                    
                      G
                      ⁡
                      
                        (
                        
                          t
                          1
                        
                        )
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                
                
                  
                    
                      
                    
                  
                  
                    
                      G
                      ⁡
                      
                        (
                        
                          t
                          2
                        
                        )
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                
                
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      G
                      ⁡
                      
                        (
                        
                          t
                          3
                        
                        )
                      
                    
                  
                  
                    
                      
                    
                  
                
                
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    ⋰
                  
                
              
              ]
            
            ⁢
            
              
            
            ⁢
            and
            ⁢
            
              
            
            ⁢
            
              J
              D
            
          
          =
          
            [
            
              
                ∑
                
                  k
                  =
                  1
                
                N
              
              ⁢
              
                
              
              ⁢
              
                
                  P
                  k
                
                ⁢
                
                  F
                  *
                
                ⁢
                
                  
                    H
                    k
                  
                  ⁡
                  
                    (
                    ω
                    )
                  
                
                ⁢
                
                  FP
                  k
                  T
                
              
            
            ]
          
        
      
    
    
      
        (
        11
        )
      
    
  




In small signal and noise analysis, a related system is solved at each frequency point of analysis. Because of the frequency dependent property of the distributed components, the transformation F is dependent on all time points in the simulation time interval. It follows from the form of Equation (3), that every p-port distributed element introduces p rows and columns that are full, into the Jacobian. This can be seen by noting that the matrices P, F*, and FPT are dense. It is not possible to form and solve large systems of such a form efficiently using direct linear algebra. Instead, as previously stated, a preferred embodiment of the present invention uses a Krylov subspace iterative solver such as GMRES.
Preferred embodiments of the present invention treat the distributed components as “black boxes” in a matrix-implicit context. Therefore, the actual Jacobian matrix does not have to be formed explicitly. Thus, for example, these embodiments evaluate the term, JD, by taking time domain waveforms as input, applying the Fourier transformation to transform them into the frequency domain, applying the transfer function of the distributed components—in terms of frequency-dependent S-parameters—to the frequency domain result, and inverse-transforming to the time domain.
This procedure has at least as much flexibility in dealing with distributed components as the standard harmonic balance method does. In fact, there is greater flexibility. Any part of the transfer function which is best suited to evaluation in the time domain can be extracted, and that part of the port-to-port transformation can be performed in the time domain. For example, the delay transformation of transmission lines can be performed in the time domain. This produces much more accurate results than can possibly be obtained by representing the delay using solely a sum of Fourier harmonics. All these operations fit in the matrix-vector product calculation of iterative solvers. Therefore, they may be done without forming a complex Jacobian matrix explicitly.
Denote the Jacobian matrix of A and B as JA and JB, respectively. Iterative solvers calculate v1=JA·v and v2=JB·v, where v is the corresponding part of the solution vector, and then calculate v1+v2 740, which is part of the matrix-vector product evaluation 610.
Rapid convergence of the Krylov-subspace iterative method 515 involves the construction of effective preconditioners 510. Shooting-based time domain RF circuit simulation methods construct the preconditioners 510 by using the fact that the block-lower-triangular portion of the Jacobian is easily inverted, since the diagonal blocks can be efficiently factored via sparse direct techniques. That is, to solve the preconditioned system P−1 JX=P−1b, the Jacobian is first decomposed into upper- and lower-block triangular pieces, J=L+U, with




  
    
      
        U
        =
        
          
            [
            
              
                
                  0
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                      D
                      0
                      1
                    
                    ⊗
                    
                      I
                      1
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  ⋰
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  0
                
              
            
            ]
          
          ⁡
          
            [
            
              
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        1
                      
                      )
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        2
                      
                      )
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        3
                      
                      )
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  ⋰
                
              
            
            ]
          
        
      
    
    
      
        (
        12
        )
      
    
  




and L={tilde over (J)}C+JG, where





  
    
      
        
          
            J
            ~
          
          C
        
        =
        
          
            [
            
              
                
                  
                    
                      D
                      1
                    
                    ⊗
                    
                      I
                      1
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  ⋰
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                      D
                      0
                      2
                    
                    ⊗
                    
                      I
                      2
                    
                  
                
                
                  
                    
                      D
                      2
                    
                    ⊗
                    
                      I
                      2
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  ⋰
                
              
            
            ]
          
          ⁡
          
            [
            
              
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        1
                      
                      )
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        2
                      
                      )
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    C
                    ⁡
                    
                      (
                      
                        t
                        3
                      
                      )
                    
                  
                
                
                  
                    
                  
                
              
              
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  
                    
                  
                
                
                  ⋰
                
              
            
            ]
          
        
      
    
    
      
        (
        13
        )
      
    
  




The preconditioner 510 is then P={tilde over (J)}C+JG=L. As P is a block-lower-triangular matrix, inversion is easily performed as long as the diagonal blocks can be factored or inverted efficiently, which is the case here. The reason that there are possible problems with applying a similar technique when distributed elements are present is because of the term JD. In the matrix-implicit context it is difficult to construct the lower-diagonal piece or to invert it.
In general, solutions at the nodes of the distributed components are coupled in time because of the Fourier transformation done in the periodic time interval. Existing preconditioning techniques for periodic steady-state simulation can not solve this difficulty. However, preferred embodiments of the present invention solve this problem using low-order lumped models to construct the distributed part of the preconditioner 510.
The first step in the preconditioning strategy of a preferred embodiment is to construct an approximate {tilde over (H)}(ω) that is close to H(ω). One possibility in constructing an approximate {tilde over (H)}(ω) is to use a rational approximation of the underlying device parameters S(ω). A preferred embodiment of the present invention constructs a rational approximation {tilde over (S)}(ω) of S(ω). Since the rational approximation will only be used as a preconditioner 510, it does not have to be extremely accurate. Therefore, S(ω) may be approximated with a low-order model, which is relatively cheap to construct. This approach has the advantage that the block-lower-triangular preconditioners previously discussed may be used.
Constructing a rational function model is equivalent to finding a state-space model of the form:




  
    
      
        
          
            
              d
              x
            
            
              d
              t
            
          
          =
          
            Ax
            +
            
              Bu
              ⁡
              
                (
                t
                )
              
            
          
        
        ,
        
          
        
        ⁢
        
          y
          =
          
            Cx
            +
            Du
          
        
      
    
    
      
        (
        14
        )
      
    
  




such that the transfer function, {tilde over (S)}(ω)=D+C(iωI−A)−1B, approximates S(ω). This is accomplished by requiring that the mean-squared error,





  
    
      
        
          E
          =
          
            
              ∑
              k
            
            ⁢
            
              
            
            ⁢
            
              
                
                  W
                  ⁡
                  
                    (
                    
                      ω
                      k
                    
                    )
                  
                
                2
              
              ⁢
              
                
                  
                  
                    
                    
                      
                        
                          S
                          ~
                        
                        ⁡
                        
                          (
                          
                            ω
                            k
                          
                          )
                        
                      
                      -
                      
                        S
                        ⁡
                        
                          (
                          
                            ω
                            k
                          
                          )
                        
                      
                    
                    
                  
                  
                
                2
              
            
          
        
        ,
      
    
    
      
        (
        15
        )
      
    
  




is minimized. In the above, W(ωk) represents the weighting at frequency point k for the least-squares minimization.

Ideally, the preconditioner 510 should be P={tilde over (J)}C+JG+{tilde over (J)}D, where




  
    
      
        
          
            J
            ~
          
          D
        
        =
        
          [
          
            
              ∑
              
                k
                =
                1
              
              N
            
            ⁢
            
              
            
            ⁢
            
              
                P
                k
              
              ⁢
              
                F
                *
              
              ⁢
              
                
                  
                    H
                    ~
                  
                  k
                
                ⁡
                
                  (
                  ω
                  )
                
              
              ⁢
              
                FP
                k
                T
              
              ⁢
              
                v
                .
              
            
          
          ]
        
      
    
    
      
        (
        16
        )
      
    
  




Unfortunately, even with the rational model technique, matrices of this form may not be inverted efficiently. However, since state-space models have finite-dimensional state spaces, the rational function models may be included in an extended version of the circuit equations. The extended circuit equations will include the states of the rational fitting model, and so the Jacobian of the extended system will agree with the Jacobian of the original system, treating the distributed component as the rational fitting model.

Adoptingthe J,L, U notation, let

JR=LR+UR  (17)

be the Jacobian for the circuit equations including the rational fitting model, where R denotes the rational fitting, and LR and UR denote the upper and lower block-triangular pieces, respectively, as defined above. If there are M time steps in the Chebyshev discretization of the periodic interval, and n circuit equations, then JεRMn×Mn, but JRεRM(n+q)×M(n+q), where q is the total number of additional state space variables introduced by the rational approximation of the frequency response of all the distributed components. Thus, the answer is not as simple as just writing P=LR, since LR and J have different dimensions.

Preferred embodiments of the present invention solve this problem by defining an operator, Q:RMn→RM(n+q), that embeds the Mn dimensional space into the M(n+q) dimensional one. The operator is an identity embedding represented by a section of the identity matrix. QT, the transpose of Q, likewise extracts the original state space from the extended one. In essence, QT projects the larger space onto the smaller space, and has kernel equal to the orthogonal complement of the subspace of original state space variables. The relationship that the Jacobian of the extended system has to the Jacobian of the original system—treating the distributed component as the rational fitting model—can be expressed as:

J=QTJRQ.  (18)

In order to use LR as the preconditioner 510 for the Jacobian, J,QT can be used to extract the relevant components, so that

P−1=QTLR−1Q.  (19)

The inverse of LR can be easily computed because it is a block lower-triangular system. Moreover, the preconditioner 510 will also include an approximation to {tilde over (H)}. If the rational fitting model is a fairly good approximation of the original system, then the GMRES solver will be efficient whenever the block-lower-triangular strategy is also effective.
Because the rational model is used solely as a preconditioner 510, its accuracy does not affect the accuracy of the final solution. If the rational approximation were used to construct an equivalent lumped model instead of evaluating the distributed components, the rational model would have to very closely track the frequency response, meaning that it would often be of a very high order. In addition, physical constraints—such as passivity—would have to be introduced into the rational model. Such constraints are computationally expensive to enforce for high-order, multi-port models. Indeed, both the model generation process, and the later time domain simulation, would be more computationally expensive than the strategy used in preferred embodiments of the present invention. These embodiments only use rational approximations of orders say two or three to give effective preconditioners 510.
In accordance with another embodiment, a computer program product for accurately and efficiently simulating a circuit is provided. It can be used to simulate a circuit so that on the one hand steady-state time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—i.e., those with an infinite dimensional state space—can also be simulated. A preferred embodiment can be used in the apparatus 100 described above, and the discussion of the computer program product parallels that of the apparatus 100.
The computer program product produces a mathematical model of the circuit. This model is in the form of an appropriate system of equations. The computer program product uses a two-tiered iterative approach to solving the system of equations. FIG. 8 is a flow chart depicting an overview of how the computer program product 800 solves the system of equations to simulate the circuit. As discussed in detail above in the disquisition on the apparatus 100, the computer program product 800 partitions a time interval 805 on which the system of equations is defined, and produces an interpolating polynomial 810 on the interval. The interpolating polynomial 810 provides an initial approximation to the solution, and is used in an iterative method to generate the next approximation. A preferred iterative method is Newton's method 815, and it serves as the top tier of the two-tiered iteration approach used by the computer program product 800.
FIG. 9 is a flow chart showing the implementation of Newton's method 815 to generate the next approximation, and ultimately a solution to the system of equations. The most recent approximation is evaluated in the appropriate iterative equation 905. The result is used to update the equation 910 and an error term is calculated. The error term is compared to a preset tolerance. If the error exceeds the tolerance 925 another iteration is performed 930. Otherwise, if the error is less than the tolerance 915 the iteration stops and the solution is provided as an output 920.
The equation evaluation step 905 of FIG. 9 is shown in greater detail in FIG. 10, which is a flow chart of the evaluation step 905. The candidate solution vector is decomposed 1005 into its frequency domain components 1020 and its time domain components 1010. The computer program product 800 takes the Fourier transform 1025 of the frequency domain components, evaluates the result in the frequency domain 1030, and then takes the inverse Fourier transform 1035 of the evaluation. Meanwhile, the apparatus evaluates the time domain components in the time domain 1015. The inverse Fourier transformed evaluation 1035 is then combined with the time domain evaluation 1015 to produce the equation evaluation 905.
FIG. 11 is a flow chart of the equation update step 910 of FIG. 9, i.e., of Newton's method 815 (or other suitable iterative method). The computer program product prepares information on the Jacobian matrix 1105 used in the iterations of Newton's method 815. It also prepares a preconditioner 1110 to help speed up convergence to the solution. It then performs the lower tier iteration, which in a preferred embodiment uses a Krylov iterative subspace solver 1115, as discussed in detail above in the disquisition on the apparatus 100.
FIG. 12 is a flow chart of the Krylov iterative subspace solver 1115 of FIG. 11. The Krylov solver 1115 computes a new direction vector 1205, and uses it to compute a matrix-vector product evaluation 1210 that is part of this lower tier iteration. The result of this evaluation 1210 is used to compute the next solution approximation 1215. An error term is calculated and compared to a preset tolerance that can—but need not necessarily—be the same as the tolerance used in the top tier iteration discussed above. If the error exceeds the tolerance 1230, another iteration is performed 1235. Otherwise the solution is provided as an output to be used to update 1225 next iteration of the Newton's method loop 910 in FIG. 9.
FIG. 13 is a flow chart of the matrix-vector product evaluation 1210 step of FIG. 12. The Krylov subspace vector is decomposed 1305 into its frequency domain components 1320 and its time domain components 1310. The computer program product 800 takes the Fourier transform 1325 of the frequency domain components 1320, performs a frequency domain Jacobian matrix evaluation 1330 on the result, and then takes the inverse Fourier transform 1335 of the evaluation 1330. The computer program product 800 also performs a time domain Jacobian matrix multiplication 1315 using the time domain components 1310. The result of this multiplication 1315 is combined with the inverse Fourier transform 1335 of the frequency domain evaluation 1330 to produce the next Krylov solution approximation 1215.
In accordance with another embodiment, a method for accurately and efficiently simulating a circuit is provided. It can be used to simulate a circuit so that on the one hand steady-state time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—i.e., those with an infinite dimensional state space—can also be simulated.
In accordance with another embodiment, a method for accurately and efficiently simulating a circuit is provided. It can be used to simulate a circuit so that on the one hand steady-state time domain analysis can be applied, while on the other hand the distributed passive components of the circuit—i.e., those with an infinite dimensional state space—can also be simulated. A preferred embodiment can be implemented using in the apparatus 100 described above, and the discussion of the method parallels that of the apparatus 100.
The method produces a mathematical model of the circuit. This model is in the form of an appropriate system of equations. The method uses a two-tiered iterative approach to solving the system of equations. FIG. 14 is a flow chart depicting an overview of how the method 1400 solves the system of equations to simulate the circuit. As discussed in detail above in the disquisition on the apparatus 100, the method 1400 partitions a time interval 1405 on which the system of equations is defined, and produces an interpolating polynomial 1410 on the interval. The interpolating polynomial 1410 provides an initial approximation to the solution, and is used in an iterative method to generate the next approximation. A preferred iterative method is Newton's method 1415, and it serves as the top tier of the two-tiered iteration approach used by the method 1400.
FIG. 15 is a flow chart showing the implementation of Newton's method 1415 to generate the next approximation, and ultimately a solution to the system of equations. The most recent approximation is evaluated in the appropriate iterative equation 1505. The result is used to update the equation 1510 and an error term is calculated. The error term is compared to a preset tolerance. If the error exceeds the tolerance 1525 another iteration is performed 1530. Otherwise, if the error is less than the tolerance 1515 the iteration stops and the solution is provided as an output 1520.
The equation evaluation step 1505 of FIG. 15 is shown in greater detail in FIG. 16, which is a flow chart of the evaluation step 1505. The candidate solution vector is decomposed 1605 into its frequency domain components 1620 and its time domain components 1610. The method 1400 takes the Fourier transform 1625 of the frequency domain components, evaluates the result in the frequency domain 1630, and then takes the inverse Fourier transform 1635 of the evaluation. Meanwhile, the apparatus evaluates the time domain components in the time domain 1615. The inverse Fourier transformed evaluation 1635 is then combined with the time domain evaluation 1615 to produce the equation evaluation 1505.
FIG. 17 is a flow chart of the equation update step 1510 of FIG. 15, i.e., of Newton's method 1415 (or other suitable iterative method). The computer program product prepares information on the Jacobian matrix 1705 used in the iterations of Newton's method 1415. It also prepares a preconditioner 1710 to help speed up convergence to the solution. It then performs the lower tier iteration, which in a preferred embodiment uses a Krylov iterative subspace solver 1715, as discussed in detail above in the disquisition on the apparatus 100.
FIG. 18 is a flow chart of the Krylov iterative subspace solver 1715 of FIG. 17. The Krylov solver 1715 computes a new direction vector 1805, and uses it to compute a matrix-vector product evaluation 1810 that is part of this lower tier iteration. The result of this evaluation 1810 is used to compute the next solution approximation 1815. An error term is calculated and compared to a preset tolerance that can—but need not necessarily—be the same as the tolerance used in the top tier iteration discussed above. If the error exceeds the tolerance 1830, another iteration is performed 1835. Otherwise the solution is provided as an output to be used to update 1825 next iteration of the Newton's method loop 1510 in FIG. 15.
FIG. 19 is a flow chart of the matrix-vector product evaluation 1810 step of FIG. 18. The Krylov subspace vector is decomposed 1905 into its frequency domain components 1920 and its time domain components 1910. The method 1400 takes the Fourier transform 1925 of the frequency domain components 1920, performs a frequency domain Jacobian matrix evaluation 1930 on the result, and then takes the inverse Fourier transform 1935 of the evaluation 1930. The method 1400 also performs a time domain Jacobian matrix multiplication 1915 using the time domain components 1910. The result of this multiplication 1915 is combined with the inverse Fourier transform 1935 of the frequency domain evaluation 1930 to produce the next Krylov solution approximation 1815.
E. CONCLUSION
The hybrid frequency-time domain approach for the treatment of distributed components, such as those described by frequency-dependent, tabulated S-parameters, is an effective technique for steady-state, time domain simulation of circuits with such components. Because of the spectral accuracy of the Chebyshev method, efficiency and accuracy are achieved through the transformation between the frequency and time domains using the Fourier and inverse Fourier transforms, for device evaluation involving frequency-dependent S-parameters. The various preferred embodiments use a matrix-implicit, Krylov-subspace method as the linear solver. The low-order rational fitting model the embodiments use as the preconditioner for the linear solver greatly improves its efficiency. Therefore, the method, computer program product, and implementing apparatus give more accurate results and have better convergence properties, and greater accuracy and efficiency than the pure rational-fitting lumped model approach.
Although particular embodiments of the present invention have been shown and described, it should be understood that the above discussion is not intended to limit the present invention to these embodiments. It will be appreciated by those of ordinary skill in the art that various changes and modifications may be made without departing from the spirit and scope of these embodiments. For example, the method, computer program product, and implementing apparatus can be conveniently extended to other time domain analyses, such as quasi-periodic steady-state analysis and small signal or noise analysis. Thus, the present invention is intended to cover alternatives, modifications, and equivalents that may fall within the spirit and scope of the present invention as defined by the claims.

## Claims

1. An apparatus for simulating a circuit, comprising:
a computing apparatus receiving inputted circuit data; and
a computer program product executable by the computing apparatus to process the inputted circuit data by:
modeling the circuit with a system of equations; partitioning a time interval on which the system of equations is defined;
computing an interpolating polynomial; and
applying an iterative method to solve the system of equations,
wherein the iterative method comprises:
performing an equation evaluation;
computing an equation update;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative method if the error exceeds the preset tolerance,
wherein the computing apparatus stores at least the solution to the system of equations.

2. The apparatus of claim 1, wherein the iterative method is Newton's method.

3. The apparatus of claim 1, wherein the equation evaluation step comprises:
decomposing a candidate solution vector to the system of equations into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
evaluating the time domain components in the time domain;
evaluating the Fourier transformed frequency domain components in the frequency domain;
applying an inverse Fourier transform to the evaluated Fourier transformed frequency domain components; and
combining the evaluated time domain components with the inverse Fourier transformed, evaluated Fourier transformed frequency domain components.

4. The apparatus of claim 3, wherein the Fourier transform is computed using a Fast Fourier Transform method.

5. The apparatus of claim 3, wherein the Fourier transform is computed using a Chebyshev Fourier quadrature method.

6. The apparatus of claim 3, wherein the Fourier transform is computed using a non-equispaced fast transform method.

7. The apparatus of claim 1, wherein the step of computing an equation update comprises:
preparing information about a Jacobian matrix;
preparing a preconditioner; and
applying an iterative subspace solver.

8. The apparatus of claim 7, wherein the iterative subspace solver is a Krylov iterative subspace solver.

9. The apparatus of claim 7, wherein the step of applying the iterative subspace solver comprises:
computing a new direction vector;
performing a matrix-vector product evaluation;
computing a solution drawn from the subspace formed by the direction vectors;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative subspace solver if the error exceeds the preset tolerance.

10. The apparatus of claim 9, wherein the step of performing a matrix-vector product evaluation comprises:
decomposing a Krylov vector into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
performing a time domain Jacobian multiplication using the time domain components of the Krylov vector;
performing a frequency domain Jacobian subspace evaluation on the Fourier transformed frequency domain components of the Krylov vector;
applying an inverse Fourier transform to the frequency domain Jacobian subspace evaluation; and
combining the result of performing the time domain Jacobian multiplication with the inverse Fourier transformed, frequency domain Jacobian subspace evaluation.

11. The apparatus of claim 10, wherein the Fourier transform is computed using a Fast Fourier Transform method.

12. The apparatus of claim 10, wherein the Fourier transform is computed using a Chebyshev Fourier quadrature method.

13. The apparatus of claim 10, wherein the Fourier transform is computed using a non-equispaced fast transform method.

14. The apparatus of claim 7, wherein the Jacobian matrix is the Jacobian matrix of equations discretized according to the interpolating polynomial.

15. The apparatus of claim 7, wherein the Jacobian matrix is decomposed into a dynamic piece, a static piece, and a distributed piece.

16. The apparatus of claim 15, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to the lower triangular matrix.

17. The apparatus of claim 15, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to an approximation of the lower triangular matrix.

18. The apparatus of claim 16, wherein the preconditioner is constructed using a rational function model.

19. The apparatus of claim 1, wherein the system of equations is comprised of non-linear, differential algebraic equations.

20. The apparatus of claim 1, wherein the system of differential equations is of the form:




  
    
      
        
          d
          
            Q
            ⁡
            
              (
              
                v
                ⁡
                
                  (
                  t
                  )
                
              
              )
            
          
        
        
          d
          t
        
      
      +
      
        I
        ⁡
        
          (
          
            v
            ⁡
            
              (
              t
              )
            
          
          )
        
      
      +
      
        u
        ⁡
        
          (
          r
          )
        
      
    
    =
    0
  
  ;



where Q(v(t))εRn is a vector that represents the contribution of the dynamic elements of the circuit, I(v(t))εRn is a vector representing the static elements of the circuit, u(t)εRn is a vector of inputs, and v(t)εRn is a vector that contains state variables.

21. The apparatus of claim 1, wherein the system of equations is of the form:




  
    
      
        
          d
          
            Q
            ⁡
            
              (
              
                v
                ⁡
                
                  (
                  t
                  )
                
              
              )
            
          
        
        
          d
          t
        
      
      +
      
        I
        ⁢
        
          (
          
            v
            ⁡
            
              (
              t
              )
            
          
          )
        
      
      +
      
        [
        
          
            ∑
            
              k
              =
              1
            
            K
          
          ⁢
          
            
          
          ⁢
          
            
              P
              k
            
            ⁢
            
              
                ∫
                
                  -
                  ∞
                
                t
              
              ⁢
              
                
                  
                    H
                    k
                  
                  ⁡
                  
                    (
                    
                      t
                      -
                      τ
                    
                    )
                  
                
                ⁢
                
                  P
                  k
                  T
                
                ⁢
                
                  v
                  ⁡
                  
                    (
                    τ
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  d
                  τ
                
              
            
          
        
        ]
      
      +
      
        u
        ⁡
        
          (
          t
          )
        
      
    
    =
    0
  
  ,



where Q(v(t))εRn is a vector that represents the contribution of the dynamic elements of the circuit, I(v(t))εRn is a vector representing the static elements of the circuit, u(t)εRn is a vector of inputs, v(t)εRn is a vector that contains state variables, Hk:(−∞,t]→Rpk×pk is a pk×pk matrix of impulse responses for a kth distributed component, Pk is a matrix having a one in the (i,j) entry if the jth connection to the kth device is through the state variable with index i, and having zeroes otherwise, PkT is the transpose of Pk, and PkT is an operator that extracts the relevant portion of the state vector.

22. The apparatus of claim 1, wherein the system of equations is of the form:




  
    
      
        
          d
          
            Q
            ⁡
            
              (
              
                v
                ⁡
                
                  (
                  t
                  )
                
              
              )
            
          
        
        
          d
          t
        
      
      +
      
        I
        ⁢
        
          (
          
            v
            ⁡
            
              (
              t
              )
            
          
          )
        
      
      +
      
        [
        
          
            ∑
            
              k
              =
              1
            
            N
          
          ⁢
          
            
          
          ⁢
          
            
              P
              k
            
            ⁢
            
              F
              *
            
            ⁢
            
              
                H
                k
              
              ⁡
              
                (
                ω
                )
              
            
            ⁢
            
              FP
              k
              T
            
            ⁢
            v
          
        
        ]
      
      +
      
        u
        ⁡
        
          (
          t
          )
        
      
    
    =
    0
  
  ;



where Q(v(t))εRn is a vector that represents the contribution of the dynamic elements of the circuit, I(v(t))εRn is a vector representing the static elements of the circuit, u(t)εRn is a vector of inputs, v(t)εRn is a vector that contains state variables, Hk(ω)—a frequency-dependent matrix—is the Fourier transform of a kth impulse response matrix, F is the matrix representation of the Fourier transform, F* is the conjugate transpose of F, Pk is a matrix having a one in the (i,j) entry if the jth connection to the kth device is through the state variable with index i, and having zeroes otherwise, PkT is the transpose of Pk, and PkT is an operator that extracts the relevant portion of the state vector.

23. The apparatus of claim 1, wherein the system of equations is to be solved for steady-state conditions.

24. The apparatus of claim 1, wherein the system of equations is to be solved for periodic steady-state conditions.

25. The apparatus of claim 1, wherein the time interval is partitioned using Chebyshev Gauss-Lobatto collocation points.

26. The apparatus of claim 1, wherein the interpolating polynomial is computed using Chebyshev polynomials.

27. The apparatus of claim 1, wherein the interpolating polynomial is computed using Legendre polynomials.

28. The apparatus of claim 1, wherein the interpolating polynomial is computed using mutually orthogonal polynomials.

29. The apparatus of claim 1, wherein the derivative of the interpolating polynomial agrees with the derivative of the solution to the system of equations at each of the points of the partition of the time interval.

30. The apparatus of claim 1, further comprising a memory component storing at least the solution to the system of equations.

31. A computer program product comprising a computer usable medium having executable code that, when executed on a computing apparatus, causes the computing apparatus to execute a process for simulating a circuit, the process comprising:
modeling the circuit with a system of equations;
partitioning a time interval on which the system of equations is defined;
computing an interpolating polynomial;
applying an iterative method to solve the system of equations; and
storing the solution to the system of equations,
wherein the iterative method comprises:
performing an equation evaluation;
computing an equation update;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative method if the error exceeds the preset tolerance.

32. The computer program product of claim 31, wherein the equation evaluation step comprises:
decomposing a candidate solution vector to the system of equations into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
evaluating the time domain components in the time domain;
evaluating the Fourier transformed frequency domain components in the frequency domain;
applying an inverse Fourier transform to the evaluated Fourier transformed frequency domain components; and
combining the evaluated time domain components with the inverse Fourier transformed, evaluated Fourier transformed frequency domain components.

33. The computer program product of claim 31, wherein the step of computing an equation update comprises:
preparing information about a Jacobian matrix;
preparing a preconditioner; and
applying an iterative subspace solver.

34. The computer program product of claim 33, wherein the step of applying the iterative subspace solver comprises:
computing a new direction vector;
performing a matrix-vector product evaluation;
computing a solution drawn from the subspace formed by the direction vectors;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative subspace solver if the error exceeds the preset tolerance.

35. The computer program product of claim 34, wherein the step of performing a matrix-vector product evaluation comprises:
decomposing a Krylov vector into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
performing a time domain Jacobian multiplication using the time domain components of the Krylov vector;
performing a frequency domain Jacobian subspace evaluation on the Fourier transformed frequency domain components of the Krylov vector;
applying an inverse Fourier transform to the frequency domain Jacobian subspace evaluation; and
combining the result of performing the time domain Jacobian multiplication with the inverse Fourier transformed, frequency domain Jacobian subspace evaluation.

36. The computer program product of claim 33, wherein the Jacobian matrix is decomposed into a dynamic piece, a static piece, and a distributed piece.

37. The computer program product of claim 36, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to the lower triangular matrix.

38. The computer program product of claim 36, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to an approximation of the lower triangular matrix.

39. The computer program product of claim 37, wherein the preconditioner is constructed using a rational function model.

40. The computer program product of claim 31, wherein the solution to the system of equations is stored on a memory device.

41. A method for simulating a circuit with a computer program product executable by a computing apparatus, the method comprising:
modeling the circuit with a system of equations;
partitioning a time interval on which the system of equations is defined;
computing an interpolating polynomial;
applying an iterative method to solve the system of equations; and
storing the solution to the system of equations,
wherein the iterative method comprises:
performing an equation evaluation;
computing an equation update;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative method if the error exceeds the preset tolerance.

42. The method of claim 41, wherein the equation evaluation step comprises:
decomposing a candidate solution vector to the system of equations into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
evaluating the time domain components in the time domain;
evaluating the Fourier transformed frequency domain components in the frequency domain;
applying an inverse Fourier transform to the evaluated Fourier transformed frequency domain components; and
combining the evaluated time domain components with the inverse Fourier transformed, evaluated Fourier transformed frequency domain components.

43. The method of claim 41, wherein the step of computing an equation update comprises:
preparing information about a Jacobian matrix;
preparing a preconditioner; and
applying an iterative subspace solver.

44. The method of claim 43, wherein the step of applying the iterative subspace solver comprises:
computing a new direction vector;
performing a matrix-vector product evaluation;
computing a solution drawn from the subspace formed by the direction vectors;
computing an error;
comparing the error with a preset tolerance; and
performing another iteration of the iterative subspace solver if the error exceeds the preset tolerance.

45. The method of claim 44, wherein the step of performing a matrix-vector product evaluation comprises:
decomposing a Krylov vector into its time domain components and its frequency domain components;
applying a Fourier transform to the frequency domain components;
performing a time domain Jacobian multiplication using the time domain components of the Krylov vector;
performing a frequency domain Jacobian subspace evaluation on the Fourier transformed frequency domain components of the Krylov vector;
applying an inverse Fourier transform to the frequency domain Jacobian subspace evaluation; and
combining the result of performing the time domain Jacobian multiplication with the inverse Fourier transformed, frequency domain Jacobian subspace evaluation.

46. The method of claim 43, wherein the Jacobian matrix is decomposed into a dynamic piece, a static piece, and a distributed piece.

47. The method of claim 46, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to the lower triangular matrix.

48. The method of claim 46, wherein the Jacobian matrix is represented as the sum of an upper triangular matrix and a lower triangular matrix, where the lower triangular matrix is the sum of the dynamic piece and the static piece, and the preconditioner is set equal to an approximation of the lower triangular matrix.

49. The method of claim 47, wherein the preconditioner is constructed using a rational function model.

50. The method of claim 41, wherein the solution to the system of equations is stored on a memory device.

51. A method for simulating a circuit with a computer program product executable by a computing apparatus, the method comprising:
a) modeling a circuit with a system of equations;
b) evaluating time domain components of the system of equations in the time domain;
c) transforming frequency domain components of the system of equations;
d) evaluating the transformed frequency domain components using time domain-based analysis;
e) generating simulation results by combining the evaluated time domain components and the evaluated frequency domain components; and
f) storing at least the simulation results.

52. The method of claim 51 in which (c) is performed with a Fourier transform.

53. The method of claim 51 in which an interpolating polynomial is computed.

54. The method of claim 51 in which an iterative method is performed.

55. The method of claim 54 in which the iterative method is Newton's method.

56. The method of claim 54 further comprising:
applying a subspace solver.

57. The method of claim 51, wherein the simulation results are stored on a memory device.

58. A computer program product comprising a computer usable medium having executable code that, when executed on a computing apparatus, causes the computing apparatus to execute a process for simulating a circuit, the process comprising:
a) modeling a circuit with a system of equations;
b) evaluating time domain components of the system of equations in the time domain;
c) transforming frequency domain components of the system of equations;
d) evaluating the transformed frequency domain components using time domain-based analysis;
e) generating simulation results by combining the evaluated time domain components and the evaluated frequency domain components; and
f) storing at least the simulation results.

59. The computer program product of claim 58 in which (c) is performed with a Fourier transform.

60. The computer program product of claim 58 in which an interpolating polynomial is computed.

61. The computer program product of claim 58 in which an iterative method is performed.

62. The computer program product of claim 61 in which the iterative method is Newton's method.

63. The computer program product of claim 61 further comprising:
applying a subspace solver.

64. The computer program product of claim 58, wherein the simulation results are stored on a memory device.