Welcome to FastHenry2

FastHenry2 User Guide

Welcome to FastHenry2 !

FastHenry2 is a powerful three-dimensional inductance extraction program.

Features include:

  • Computation of frequency dependent self and mutual inductances between conductors of complex shape!
  • Automatic generation of Spice netlist to model and simulate the frequency depended behaviour of your structure!
  • Very fast solution!
  • Full automation support allowing remote control of FastHenry2 by other programs, either in foreground or in background!
  • Lots of options!
  • Free (see disclaimer and conditions of use)!

FastHenry manual

The original FastHenry manuals in Acrobat Reader compatible format (needs Acrobat Reader) can be open clicking here for the FastHenry User's Guide and here for Nonuniformly Discretized Reference Planes Guide.

Support

Visit our web site FastFieldSolvers for new releases, support, customization and many other services!

Copyright FastFieldSolvers, 2012 - All rights reserved


FastHenry2 Tutorial

Getting started with FastHenry2

This tutorial will show you step-by-step how to perform the basic inductance extraction tasks with FastHenry2.

In this tutorial, you will learn how to:

  • Load a FastHenry2 input file into FastModel
  • Understand basic FastHenry2 input file syntax
  • Launch FastHenry2 from FastModel
  • Understand FastHenry2 output
  • Specify a finer discretization
  • Define uniform ground planes


FastHenry2 Tutorial

Load a FastHenry2 input file into FastModel

Launch FastModel

  1. If FastModel is not already running, double click the FastModel icon on your desktop or select 'FastModel' from your Start menu in Windows.
  2. Click on the I agree button to accept FastModel's license.

Load a FastHenry2 input file

  1. Select the FastHenry2 View (the view should be in foreground with the caption highlighted).
  2. From the File menu select File->Open FastHenry2 File or click on the [image] icon on the toolbar.
  3. Browse to the software installation directory (e.g. C:\Program Files\FastFieldSolvers) and under FastHenry2\Samples\Input_files select the file square.inp, then click Open.

    A model of a square loop will appear in the FastModel View.


FastHenry2 Tutorial

Understand basic FastHenry2 input file syntax

Examine the input file

  1. If the FastHenry2 View is not visible, bring it in foreground

  2. Examine the first line of the view.

    **This is the title line. It will always be ignored**.

    As stated in the line itself, the first line is the title line, and will always be ignored. However, as comments start with a '*' character, it is recommended to start also this line with an asterisk for consistency.

  3. Examine the two following lines.

    * Everything is case INsensitive
    * An asterisk starts a comment line.

    These lines are comments.

  4. Examine the .Units directive

    * The following line names millimeters as the length units for the rest
    * of the file.
    .Units mm

    The .Units directive specify the length units used in the rest of the file. Allowed values are km, m, cm, mm, um, in, mils. Note that length units must be set to match the real dimensions of your model, since inductance, unlike the capacitance extracted with FastCap2, does NOT scale linearly with the dimension, because of skin and proximity effects.

  5. Examine the .Default directive

    * Make z=0 the default z coordinate and copper the default conductivity.
    * Note that the conductivity is in units 1/(mm*Ohms), not 1/(m*Ohms)
    * since the default units are millimeters.
    .Default z=0 sigma=5.8e4

    The .Default directive specify default settings for the rest of the file. Note how the chosen length units impact the conductivity setting.

  6. Examine the nodes definition

    * The nodes of a square (z=0 is the default)
    N1 x=0 y=0
    N2 x=1 y=0
    N3 x=1 y=1
    N4 x=0 y=1
    N5 x=0 y=0.01

    The nodes are simply points in a 3D space. A node definition always begins with its name. The name of a node must always begin with the 'n' character. Then follow the 3D coordinates of the node. In our case, the z coordinate has not been specified as it was declared as zero in a .Default directive. Note, however, that you can always bypass a default setting specifying explicitly the parameter you need. For example, you can write

    N4 x=0 y=1 z=1

    if you need that the z coordinate is 1.0 for the node N4 only.

  7. Examine the segments definition

    * The segments connecting the nodes
    E1 N1 N2 w=0.2 h=0.1
    E2 N2 N3 w=0.2 h=0.1
    E3 N3 N4 w=0.2 h=0.1
    E4 N4 N5 w=0.2 h=0.1

    The segments are rectangular parallelepipeds connecting the nodes. For example, E1 connects node N1 and N2, that is, the nodes define the center of the segment end-faces. The name of a node must always begin with the 'e' character. Then follow the names of the two end-face nodes and the segment width (w) and height (h) indication.

    Segments connected to the same node are considered electrically connected at the node. For example, segments E1 and E2 are connected at node N2.

    Note that, given the two nodes, there are an infinite number of orientations possible for the rectangular end-faces around the central axis defined by the line through the nodes. You can see four of these orientations in the following figure:

    By default, the width vector is assumed to lie in x-y plane.

  8. Examine the port definition

    * define one 'port' of the network
    .external N1 N5

    The .external keyword is used to specify the beginning and the end of the paths whose impedance will be calculated by FastHenry2. In this case, we will find the inductance of the whole loop.

  9. Examine the .freq directive

    * Frequency range of interest.
    .freq fmin=1e4 fmax=1e8 ndec=1

    The .freq keyword is used to specify the frequencies of interest. The impedance of the 'ports' will be calculated at these frequencies; fmin and fmax define the minimum and maximum frequency, ndec is the number of desired frequency points per decade. In our example, FastHenry2 will calculate the impedance at the following frequencies: 10kHz, 100kHz, 1MHz, 10MHz, 100MHz.

  10. Examine the .end directive

    * All input files must end with:
    .end

    The .end keyword signals the end of the file.


FastHenry2 Tutorial

Launch FastHenry2 from FastModel

Launch FastHenry2

Now you are ready to start an impedance extraction. For this example, we will extract the impedance of the square loop you have visualized in FastModel.

  1. Click on the [image] icon on the toolbar. The Run Menu dialog from FastHenry2 should open.

Select FastHenry2 parameters

The FastHenry2 Run Menu dialog contains a lot of options. For most simulations, as in this case, you can keep the defaults.

Run FastHenry2

  1. Click the Run button to start the simulation.


FastHenry2 Tutorial

Understand FastHenry2 output

FastHenry2 has produced a detailed output about the simulation you ran. Let's examine it.

The preamble

FastHenry, (c) by M.I.T.
Windows porting and modifications, version 3.1
    (c) 1998, 2003 by Enrico Di Lorenzo, www.fastfieldsolvers.com

Running FastHenry 3.0 (29Sep96)
  Date: Wed Jul 13 16:30:53 2005
Solution technique: ITERATIVE
Matrix vector product method: MULTIPOLE
  Order of expansion: 2
Preconditioner: ON
Error tolerance: 0.001
Reading from file: C:\Program Files\FastFieldSolvers\FastHenry2\Samples\Input_files\square.inp
Title:
**This is the title line. It will always be ignored**.

all lengths multiplied by 0.001 to convert to meters
Total number of filaments before multipole refine: 4
Total number of filaments after multipole refine: 32

The preamble summarizes the input file information. In particular, after the copyright notice, you find:

  • The date and time information

      Date: Wed Jul 13 16:30:53 2005
  • The solution technique

    Solution technique: ITERATIVE

    This is the method by which the admittance matrix is inverted to get the impedance matrix. The solution can be found either directly or through an iterative algorithm. The direct way is to use a technique known as gaussian LU decomposition, which gives exact results (within machine precision) but is lengty for big matrices. The iterative solution, on the other hand, provides results accurate only within a certain arbitrary value (1% by default) but it's much faster.

  • The matrix-vector product method

    Matrix vector product method: MULTIPOLE

    Every step of the iterative algorithm used to invert the admittance matrix requires a matrix-vector multiplication. The multipole method speeds up this multiplication considering the physical meaning of the problem and grouping the effect of far-away magnetic couplings.

  • The expansion order

      Order of expansion: 2

    This is the multipole expansion order selected in the Run Menu dialog. For normal geometries, you don't need to modify this parameter; in some cases, you can select 3 as expansion order to improve the precision of the results, but usually you get better results by further refining the input geometry.

  • The use of a preconditioner

    Preconditioner: ON

    The iterative algorithm used to invert the admittance matrix can be further improved by the use of a preconditioner, which conditions the matrix to achieve convergence in a smaller number of steps. The use of the preconditioner is always recommended.

  • The error tolerance

    Error tolerance: 0.001

    This is the error treshold at which the iterative algorithm stops. By default it is set to 0.001, that is, 1%, but you can use a tighter or looser precision. Of course, a very small tolerance would void the speed benefits of the iterative algorithm vs. the LU decomposition.

  • The input file name

    Reading from file: C:\Program Files\FastFieldSolvers\FastHenry2\Samples\Input_files\square.inp
  • The title line

    Title:
    **This is the title line. It will always be ignored**.

    This is simply the first line of the input file.

  • The scaling factor

    all lengths multiplied by 0.001 to convert to meters

    You may remember that the default units for the file were millimeters. This message informs you of this scaling factor.

  • The refine algorithm

    Total number of filaments before multipole refine: 4
    Total number of filaments after multipole refine: 32

    In FastHenry2 language, filaments are parts of a segment, which subdivide the segment along its cross-section. We will deal with filaments in the Specify a finer discretization chapter. For the moment, you can consider segments and filaments as equivalent.

    FastHenry2 implements an automatic refinement algorithm which breaks up segments that are too long. While this algorithm does not cover all cases, as you'll see later for the skin effect, it usually manages all other aspects, so you don't have to worry about the discretization of long segments in shorter ones.

The simulation and the result

Multipole Summary
  Expansion order: 2
  Number of partitioning levels: 3
  Total number of filaments: 32
No expansions at level 3 (lowest)
No expansions at level 2
Percentage of multiplies done by multipole: 100%
Scanning graph to find fundamental circuits...
Number of Groundplanes : 0
Number of filaments:         32
Number of segments:          32
Number of nodes:             33
Number of meshes:             1
          ----from tree:                   1
          ----from planes: (before holes)  0
Number of conductors:         1   (rows of matrix in Zc.mat)
Number of columns:            1  (columns of matrix in Zc.mat)
Number of real nodes:        33
filling M...
filling R and L...
Total Memory allocated: 70 kilobytes
Frequency = 10000
Forming sparse matrix preconditioner..
conductor 0 from node n1
Calling gmres...
1
Frequency = 100000
Forming sparse matrix preconditioner..
conductor 0 from node n1
Calling gmres...
1
Frequency = 1e+006
Forming sparse matrix preconditioner..
conductor 0 from node n1
Calling gmres...
1
Frequency = 1e+007
Forming sparse matrix preconditioner..
conductor 0 from node n1
Calling gmres...
1
Frequency = 1e+008
Forming sparse matrix preconditioner..
conductor 0 from node n1
Calling gmres...
1

Computed matrices (R+jL)
 Row 0: n1 to n5
 Freq = 10000
  Row 0: 0.00343966+1.59836e-009j
 Freq = 100000
  Row 0: 0.00343966+1.59836e-009j
 Freq = 1e+006
  Row 0: 0.00343966+1.59836e-009j
 Freq = 1e+007
  Row 0: 0.00343966+1.59836e-009j
 Freq = 1e+008
  Row 0: 0.00343966+1.59836e-009j

All impedance matrices dumped to file Zc.mat

Times:  Read geometry   0.016
        Multipole setup 0
        Scanning graph  0
        Form A M and Z  0
        form M'ZM       0
        Form precond    0
        GMRES time      0.016
   Total:               0.0320001

The last part of the output provides information about the state of the simulation and the results. In particular:

  • The expansion order

      Expansion order: 2

    This information is redundant and states again the multipole expansion order.

  • The expansion order

      Number of partitioning levels: 3

    This is an internal parameter, automatically calculated by FastHenry2. It is an indicator of the depth of the spatial subdivision of the input geometry volume. The greater is the overall geometry dimension / minimum segment volume, the larger is the number of partitioning levels required to subdivide the space for simulation needs.

  • The total number of filaments

      Total number of filaments: 32

    This information is redundant and states again the total number of filaments used in the simulation.

  • The expansion order

    No expansions at level 3 (lowest)
    No expansions at level 2
    Percentage of multiplies done by multipole: 100%

    This information regards the internal multipole algorithm used by FastHenry2 to speed up the matrix-vector multiplication.

  • The elements used in the simulation

    Scanning graph to find fundamental circuits...
    Number of Groundplanes : 0
    Number of filaments:         32
    Number of segments:          32
    Number of nodes:             33
    Number of meshes:             1
              ----from tree:                   1
              ----from planes: (before holes)  0
    Number of conductors:         1   (rows of matrix in Zc.mat)
    Number of columns:            1  (columns of matrix in Zc.mat)
    Number of real nodes:        33

    This information summarizes all the elements which will be used in the simulation.

  • The allocated memory

    filling M...
    filling R and L...
    Total Memory allocated: 70 kilobytes

    This is the memory allocated to store all internal matrices.

  • The iteration data

    Frequency = 10000
    Forming sparse matrix preconditioner..
    conductor 0 from node n1
    Calling gmres...
    1
    Frequency = 100000
    Forming sparse matrix preconditioner..
    conductor 0 from node n1
    Calling gmres...
    1
    Frequency = 1e+006
    Forming sparse matrix preconditioner..
    conductor 0 from node n1
    Calling gmres...
    1
    Frequency = 1e+007
    Forming sparse matrix preconditioner..
    conductor 0 from node n1
    Calling gmres...
    1
    Frequency = 1e+008
    Forming sparse matrix preconditioner..
    conductor 0 from node n1
    Calling gmres...
    1

    This is the number of iterations required to reach convergence inverting the admittance matrix to get the impedance matrix. You can consider the number of iterations as an rough indicator of how well behaved the matrix is and so, indirectly, of how correctly discretized the input geometry is. You'll have a series of iterations for each port (conductor) defined in your problem. In this case, having only one conductor, there is only one row. You can see also how the computation is repeated for each frequency of interest.

  • The result

    Computed matrices (R+jL)
     Row 0: n1 to n5
     Freq = 10000
      Row 0: 0.00343966+1.59836e-009j
     Freq = 100000
      Row 0: 0.00343966+1.59836e-009j
     Freq = 1e+006
      Row 0: 0.00343966+1.59836e-009j
     Freq = 1e+007
      Row 0: 0.00343966+1.59836e-009j
     Freq = 1e+008
      Row 0: 0.00343966+1.59836e-009j

    All impedance matrices dumped to file Zc.mat

    This is the actual impedance of the square loop, for each frequency. You can see that the result is in the R+jL form, that is, the real part is the resistance and the imaginary part is the inductance.

    The results are also dumped to the file Zc.mat. Note however that in this file the results are in the R+jωL form, where ω is the angular frequency, that is, 2πf and f is the frequency.

  • The time summary

    Times:  Read geometry   0.016
            Multipole setup 0
            Scanning graph  0
            Form A M and Z  0
            form M'ZM       0
            Form precond    0
            GMRES time      0.016
       Total:               0.0320001

    The last part of the output reports a detailed summary about the simulation times.

Congratulations! You have just completed your first impedance extraction with FastHenry2.


FastHenry2 Tutorial

Specify a finer discretization

The skin effect

You may wonder now why the results you extracted with FastHenry2 do not change with the frequency. As a matter of fact, when the frequency increases, the current tend to flow only on the surface of the conductors. This is the so-called skin effect.

So, because of the skin effect, you would expect that, increasing the frequency:

  1. The resistance would rise, because there is less cross section available in the conductor for the current flow
  2. The inductance would lower, because the area included in the current loop becomes smaller, not comprising any more the internal of the conductor.

The skin depth at a given frequency can be estimated with the following formula:

where σ is the conductivity, f is the frequency, μ is the absolute magnetic permeability.

In our case, at the maximum frequency of 100MHz and considering the copper conductivity of 5.8e+7 S/m, the skin depth is about 6.6 μm, much smaller than the minimum dimension of our segments, which is 100 μm. The skin effect should be visible in the simulation results.

The filaments

The reason why the simulation results do not show any skin effect is that the segment discretization is too coarse. That is, FastHenry2 makes the assumption of constant current along the length of a segment. It's up to the user to specify a finer discretization to capture variation in the current density along the cross section.

Therefore, you should split each segment into a bundle of sub-segments with a smaller cross-section; of course, you should have to specify each sub-segment in the input file. However, to ease this task, FastHenry2 provides a directive which directly breaks up a segment into sub-segments or, in FastHenry2 language, into filaments.

  1. In the FastHenry2 View in FastModel, add the line

    .Default nhinc=5 nwinc=7

    as shown in the following figure.

  2. Launch the FastHenry2 simulation.
  3. Examine the results:

    Computed matrices (R+jL)
      Row 0: n1 to n5
     Freq = 10000
      Row 0: 0.00343967+1.59607e-009j
     Freq = 100000
      Row 0: 0.00344119+1.59602e-009j
     Freq = 1e+006
      Row 0: 0.00358479+1.59087e-009j
     Freq = 1e+007
      Row 0: 0.0071044+1.50867e-009j
     Freq = 1e+008
      Row 0: 0.0183057+1.44218e-009j

    Now the resistance and the inductance have the expected behaviour.

The discretization of a segment into multiple, parallel thin flaments is specifed with the nhinc and nwinc arguments. The keywords nhinc=5 and nwinc=7 specifiy that the interested segment must be broken up into thirty-five filaments: five along its height (nhinc=5) and seven along its width (nwinc=7).

The following figure shows the breaking up of one segment:

  • The first segment from the above is the original segment.
  • The second segment is the segment after having been broken up into filaments.
  • The third segment is the exploded view of the segment and its filaments (only as a visualization aid; the correct view is the second).

(Remark: FastModel, to keep a clearer view of the model, does not show the segments broken up into filaments; the figure has been created for explanation purposes.)

As you may notice from the figure, the default ratio of adjacent flaments is 2.0. Therefore, you can have an exponentially decreasing cross-section for your outer filaments, according to the current flow density variation inside the conductor.

In our example, the thinnest filaments are 9 μm x 10 μm, about the 6 μm skin depth we calculated at the maximum frequency of 100 MHz. So the model is able to correctly capture the skin effect.


FastHenry2 Tutorial

Define uniform ground planes

Load a new FastHenry2 input file

  1. Select the FastHenry2 View (the view should be in foreground with the caption highlighted).
  2. From the File menu select File->Close FastHenry2 File.
  3. From the File menu select File->Open FastHenry2 File or click on the [image] icon on the toolbar.
  4. Browse to the software installation directory (e.g. C:\Program Files\FastFieldSolvers) and under FastHenry2\Samples\Input_files select the file simple_gp.inp, then click Open.

    A model of a plane with a L-shaped line above it will appear in the FastModel View.

Examine the input file

We will now focus on the new aspects of this file.

  1. Examine the ground plane definition.

    *  First define 3 corners of the plane, in clockwise or counter-cw order
    g1 x1 = 0     y1 = 0     z1 = 0
    +  x2 = 1000  y2 = 0     z2 = 0
    +  x3 = 1000  y3 = 1000  z3 = 0
    *     thickness:
    +  thick = 1.2
    *     discretization:
    +  seg1 = 20 seg2 = 20
    *     nodes to reference later:
    +  nin  (800,800,0)
    +  nout (0,200,0)

    First of all note that a line beginning with the '+' character is a continuation of the previous line.

    The ground plane is defined by three of its four corners, in our case (0,0,0), (1000,0,0) and (1000,1000,0). The default units (see the .Units directive at the beginning of the file) are mils, so these corners specify a 1000 mil x 1000 mil plane. The plane is also 1.2 mil thick.

    To finely represent the current flow and distribution on this plane, the plane is discretized into 20 x 20 segments. This means that the ground plane definition is in fact only a way to instruct FastHenry2 on how to lay out nodes and segments to build a discretized plane. You can see the effect of this discretization directly in FastModel; you can also change the discretization and see how this reflects on the plane in the FastModel View.

    So FastHenry2 has laid out a mesh of nodes for you to construct the ground plane. You must have a way to reference any of these nodes to be able to preform electrial connections. You can therefore specify explicitly any number of nodes (in our example only two, named nin and nout) and they will refer to the internal nodes of the plane which are closest to the supplied coordinates.

  2. Examine the .equiv statement

    .equiv nin n3

    The .equiv keyword shorts two nodes together. In this case, the .equiv is used to connect the L-shaped conductor with the ground plane.

    Note that segments geometrically touching are NOT considered electrically connected. Segments are electrically connected only if they share a node.

  3. Launch a FastHenry2 simulation. You get the loop inductance of the trace.


FastHenry2 Automation Overview

FastHenry2 provides a Windows Automation interface which allows a remote application to fully control FastHenry2.

For example, a Visual Basic script inside an MS Windows Excel sheet can launch FastHenry2 in background, make it perform some simulation, then retrieve the results and show them in some cells - and all without even showing up the FastHenry2 window!

The Automation Object

FastHenry2 can be controlled by any Automation-capable application. The automation object which must be created to control FastHenry2 is named FastHenry2.Document. This name is defined in the Windows Registry at installation time or, if removed from the Registry, any time FastHenry2 is run.

Automation References

Automation is quite a complex topic in itself and will not be described here. We suggest to the unexperienced User to read Microsoft documentation on Automation. In particular, the following sources could be useful and can be found, for instance, on Microsoft web site:
  • "Locating resources to study automation", Microsoft Knowledge Base Article KB152023
  • "Building OLE Automation Service Components in Visual Basic and Visual C++", David George, Microsoft Corporation, October 2, 1995
  • "Inside OLE 2nd Edition", Kraig Brockschmidt, Microsoft Press, 1995

Example programs

Some example programs are provided to help understand and implement FastHenry2 remote control.


FastHenry2 Example Programs

FastHenry2 Automation Example Programs

Altough Automation is a complex topic, using FastHenry2 via Automation is simple enough. To get you started, we have created some example scripts which can be used to learn how to control FastHenry2 and as a base to build more complex applications. In spite of their short length, these examples are quite comprehensive and the source code is well commented.

You can find the example files in a sub-directory in FastHenry2's installation directory.

FastHenryClient Sample Program

This is the most complete example, which shows the use of all FastHenry2 methods and properties. To compile this example, you must have MS Visual Basic 6.0 (or newer) installed.

fh_drive.xls Sample Program

This is a Visual Basic for Applications example. To run this example, you must have MS Excel 2000 (or newer) installed.

Remark: for the script to work, you must answer 'yes' at the prompt which asks you if you want to enable the macros, when you load the file into Excel.

Remark: the files coils1.inp, coils2.inp, coils3.inp are used by this script and must reside in the same directory of fh_drive.xls for the script to work.

fhdriv.vbs Sample Program

This is a Visual Basic Script example. To run this example, you only need one of the following Windows versions: Me, 2000, XP. The best way to launch this script is from a DOS shell, typing "cscript fhdriv.vbs", in the directory where fhdriv.vbs resides. You can also double-click on the file name, but in this case all the log messages will appear in separate pop-up message boxes.

Remark: the files coils1.inp, coils2.inp, coils3.inp are used by this script and must reside in the same directory of fhdriv.vbs for the script to work.


Run Method Reference

FastHenry2Object.Run

boolean FastHenry2Object.Run(BSTR commandLine)

Return Value

True if FastHenry2 was able to start a simulation, false otherwise.

Notes:

A reason why FastHenry2 could not be able to start a simulation is that a simulation is already running. You can try to stop FastHenry2 before retrying and / or poll FastHenry2 status.

Parameters

commandLine

A string containing a FastHenry2 command line, as would be given from a shell console.

Example:

FastHenry2Object.Run("broken.inp -O")

Remarks

Runs a simulation.

See Also

FastHenry2 Automation Overview | IsRunning Property | Stop Method


Stop Method Reference

FastHenry2Object.Stop

void FastHenry2Object.Stop()

Return Value

None

Parameters

None

Remarks

Stops the currently running simulation.

Notes:

It could take some time before FastHenry2 actually stops, depending on the operation currently under execution. You can poll FastHenry2 status checking the IsRunning property or you can set a callback upon FastHenry2 end of operation using the SetEndCallback method.

See Also

FastHenry2 Automation Overview | IsRunning Property | SetEndCallback Method


Quit Method Reference

FastHenry2Object.Quit

boolean FastHenry2Object.Quit()

Return Value

If true, FastHenry2 was able to quit. If false, FastHenry2 couldn't quit (possibly because there's a simulaton on going; try to stop it before quitting).

Parameters

None

Remarks

Quits FastHenry2.

See Also

FastHenry2 Automation Overview | Stop Method


ShowWindow Method Reference

FastHenry2Object.ShowWindow

void FastHenry2Object.ShowWindow()

Return Value

None

Parameters

None

Remarks

Shows FastHenry2 console window, which is hidden by default when the FastHenry2 object is created via automation.

Notes:

Once the console becomes visible, you cannot hid it again.

See Also

FastHenry2 Automation Overview


GetInductance Method Reference

FastHenry2Object.GetInductance

VARIANT FastHenry2Object.GetInductance()

Return Value

The method returns a 3-dimensional safe-array encapsulated in a variant data.

The first dimension identifies the matrix solved for a particular frequency. To know the frequency, you must query the frequency array via the GetFrequencies Method. The index of both arrays is the same, e.g. the second matrix in the inductance array is calculated at the frequency in the second position of the frequency array.

The second and third dimensions correspond to the row and column index respectively.

If the number of columns equals the number of rows of the array, the array contains the inductance matrix as calculated by FastHenry2, in Henry.

If the number of columns of the array is not equal to the number of rows, the array contains the imaginary part of the rectangular admittance matrix (this case happens when option '-x' is used running FastHenry2, see FastHenry user's manual).

Notes:

The array dimensions can be queried from the safe array itself, see the 'safe array' topic in the MS Automation documentation.

Parameters

None

Remarks

Gets the inductance or the imaginary part of the admittance values calculated by FastHenry2, result of the simulation.

See Also

FastHenry2 Automation Overview | GetColPortNames Method | GetRowPortNames Method | GetResistance Method | GetFrequencies Method


GetResistance Method Reference

FastHenry2Object.GetResistance

VARIANT FastHenry2Object.GetResistance()

Return Value

The method returns a 3-dimensional safe-array encapsulated in a variant data.

The first dimension identifies the matrix solved for a particular frequency. To know the frequency, you must query the frequency array via the GetFrequencies Method. The index of both arrays is the same, e.g. the second matrix in the resistance array is calculated at the frequency in the second position of the frequency array.

The second and third dimensions correspond to the row and column index respectively.

If the number of columns equals the number of rows of the array, the array contains the resistance matrix as calculated by FastHenry2, in Ohms.

If the number of columns of the array is not equal to the number of rows, the array contains the real part of the rectangular admittance matrix (this case happens when option '-x' is used running FastHenry2, see FastHenry user's manual).

Notes:

The array dimensions can be queried from the safe array itself, see the 'safe array' topic in the MS Automation documentation.

Parameters

None

Remarks

Gets the resistance or the real part of the admittance values calculated by FastHenry2, result of the simulation.

See Also

FastHenry2 Automation Overview | GetColPortNames Method | GetRowPortNames Method | GetInductance Method | GetFrequencies Method


GetFrequencies Method Reference

FastHenry2Object.GetFrequencies

VARIANT FastHenry2Object.GetFrequencies()

Return Value

The method returns a 1-dimensional safe-array encapsulated in a variant data. The array contains the frequencies at which the resistance, inductance or admittance matrices are calculated.

Parameters

None

Remarks

Gets the list of frequency points at which FastHenry2's results are calculated.

See Also

FastHenry2 Automation Overview | GetColPortNames Method | GetRowPortNames Method | GetResistance Method | GetInductance Method


GetRowPortNames Method Reference

FastHenry2Object.GetRowPortNames

VARIANT FastHenry2Object.GetRowPortNames()

Return Value

The method returns a 1-dimensional safe-array encapsulated in a variant data. The array contains the names of the ports to which the resistance, inductance, and admittance matrices rows refer.

Notes:

The array dimensions can be queried from the safe array itself, see the 'safe array' topic in the MS Automation documentation.

Parameters

None

Remarks

Gets port names for the rows of the resistance, inductance, and admittance matrices.

See Also

FastHenry2 Automation Overview | GetColPortNames Method | GetResistance Method | GetInductance Method


GetColPortNames Method Reference

FastHenry2Object.GetColPortNames

VARIANT FastHenry2Object.GetColPortNames()

Return Value

The method returns a 1-dimensional safe-array encapsulated in a variant data. The array contains the names of the ports to which the resistance, inductance, and admittance matrices columns refer.

Notes:

The array dimensions can be queried from the safe array itself, see the 'safe array' topic in the MS Automation documentation.

Parameters

None

Remarks

Gets port names for the columns of the resistance, inductance, and admittance matrices.

See Also

FastHenry2 Automation Overview | GetRowPortNames Method | GetResistance Method | GetInductance Method


SetEndCallback Method Reference

FastHenry2Object.SetEndCallback

boolean FastHenry2Object.SetEndCallback(IDispatch* callback, BSTR cbName)

Return Value

True if a callback function was set. False if the callback function is reset to default (no callback).

Parameters

callback

Pointer to the client's automation object exposing the callback function. If NULL is passed as argument, the callback will be removed.

cbName

Name of the callback function.

The callback function must have the following prototype:

void cbName()

Remarks

Call this function to set a callback upon FastHenry2 simulation end. That is, when FastHenry2 has finished the simulation and results are available, the cbName function will be called to notify the client.

See Also

FastHenry2 Automation Overview | IsRunning Property | SetLogCallback Method


SetLogCallback Method Reference

FastHenry2Object.SetLogCallback

boolean FastHenry2Object.SetLogCallback(IDispatch* callback, BSTR cbName)

Return Value

True if a callback function was set. False if the callback function is reset to default (no callback).

Parameters

callback

Pointer to the client's automation object exposing the callback function. If NULL is passed as argument, the callback will be removed.

cbName

Name of the callback function.

The callback function must have the following prototype:

void cbName(BSTR logString, long color)

logString

The string containing the log text passed back to the client.

color

The color of the string. The color will be black (red 255, green 255, blue 255) for normal messages and red (red 255, green 0, blue 0) for error messages.

Remarks

Call this function to set a callback upon FastHenry2 log output. That is, when FastHenry2 has something to log (everything that would normally be visible in FastHenry2's console window), the cbName function will be called to notify the client and provide him the output string. This function is especially useful if FastHenry2's console window is hidden.

See Also

FastHenry2 Automation Overview | ShowWindow Method | SetEndCallback Method


IsRunning Property Reference

FastHenry2Object.IsRunning

boolean FastHenry2Object.IsRunning()

Return Value

True if there's a simulation running. False if FastHenry2 is idle.

Parameters

None

Remarks

Tests if FastHenry2 is running a simulation.

See Also

FastHenry2 Automation Overview | SetEndCallback Method | Stop Method