nr_complex_t g = rect (alpha, beta);
nr_complex_t y11 = coth (g * l) / zl;
nr_complex_t y21 = -cosech (g * l) / zl;
setY (NODE_1, NODE_1, y11); setY (NODE_2, NODE_2, y11);
setY (NODE_1, NODE_2, y21); setY (NODE_2, NODE_1, y21);
}
void coaxline::calcNoiseAC (nr_double_t) {
nr_double_t l = getPropertyDouble ("L");
if (l < 0) return;
// calculate noise using Bosma's theorem
nr_double_t T = getPropertyDouble ("Temp");
setMatrixN (4 * kelvin (T) / T0 * real (getMatrixY ()));
}
// properties
PROP_REQ [] = {
{ "D", PROP_REAL, { 2.95e-3, PROP_NO_STR }, PROP_POS_RANGEX },
{ "d", PROP_REAL, { 0.9e-3, PROP_NO_STR }, PROP_POS_RANGEX },
{ "L", PROP_REAL, { 1500e-3, PROP_NO_STR }, PROP_NO_RANGE },
{ "er", PROP_REAL, { 2.29, PROP_NO_STR }, PROP_RNGII (1, 100) },
{ "mur", PROP_REAL, { 1, PROP_NO_STR }, PROP_RNGII (1, 100) },
{ "tand", PROP_REAL, { 4e-4, PROP_NO_STR }, PROP_POS_RANGE },
{ "rho", PROP_REAL, { 0.022e-6, PROP_NO_STR }, PROP_POS_RANGE },
PROP_NO_PROP };
PROP_OPT [] = {
{ "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
PROP_NO_PROP };
struct define_t coaxline::cirdef =
{ "COAX", 2, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
void iac::initAC (void) {
nr_double_t a = getPropertyDouble ("I");
nr_double_t p = getPropertyDouble ("Phase");
nr_complex_t i = polar (a, rad (p));
allocMatrixMNA ();
setI (NODE_1, +i); setI (NODE_2, -i);
}
void iac::calcTR (nr_double_t t) {
nr_double_t f = getPropertyDouble ("f");
nr_double_t p = getPropertyDouble ("Phase");
nr_double_t d = getPropertyDouble ("Theta");
nr_double_t a = getPropertyDouble ("I");
nr_double_t s = getNet()->getSrcFactor ();
nr_double_t o = 2 * M_PI * f;
nr_double_t T = p / f / 360;
nr_double_t i = s * a * exp (-(t + T) * d * f) * sin (o * t + rad (p));
setI (NODE_1, +i); setI (NODE_2, -i);
}
// properties
PROP_REQ [] = {
{ "I", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_NO_RANGE }, PROP_NO_PROP };
PROP_OPT [] = {
{ "Phase", PROP_REAL, { 0, PROP_NO_STR }, PROP_RNGII (-360, 360) },
{ "Theta", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
{ "f", PROP_REAL, { 1e9, PROP_NO_STR }, PROP_POS_RANGE },
PROP_NO_PROP };
struct define_t iac::cirdef =
{ "Iac", 2, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
nr_double_t n = getSize () - 1;
nr_double_t x;
for (x = 0, i = 0; i < n; i++) {
x += 2 / (1 - calcTransfer (i));
}
Vout = v * n / x;
}
void logicnor::calcDerivatives (void) {
nr_double_t n = getSize () - 1;
nr_double_t x;
for (int k = 0; k < n; k++) {
for (x = 0, i = 0; i < n; i++) {
x += 2 / (1 - calcTransfer (i));
}
x *= (1 - calcTransfer (k));
g[k] = -2 * n * calcDerivative (k) / x / x;
}
}
// properties
PROP_REQ [] = {
{ "V", PROP_REAL, { 1, PROP_NO_STR }, PROP_POS_RANGE }, PROP_NO_PROP };
PROP_OPT [] = {
{ "t", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
{ "TR", PROP_REAL, { 10, PROP_NO_STR }, PROP_RNGII (1, 100) },
PROP_NO_PROP };
struct define_t logicnor::cirdef =
{ "NOR",
PROP_NODES, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_NONLINEAR, PROP_DEF };
nr_double_t f = kelvin (T) * 4.0 * R * z0 / norm (4.0 * z0 + R) / T0;
setN (NODE_1, NODE_1, +f); setN (NODE_2, NODE_2, +f);
setN (NODE_1, NODE_2, -f); setN (NODE_2, NODE_1, -f);
}
void bondwire::calcNoiseAC (nr_double_t) {
// calculate noise current correlation matrix
nr_double_t y = 1 / R;
nr_double_t T = getPropertyDouble ("Temp");
nr_double_t f = kelvin (T) / T0 * 4.0 * y;
setN (NODE_1, NODE_1, +f); setN (NODE_2, NODE_2, +f);
setN (NODE_1, NODE_2, -f); setN (NODE_2, NODE_1, -f);
}
// properties
PROP_REQ [] = {
{ "D", PROP_REAL, { 25e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "L", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_POS_RANGE },
{ "H", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_POS_RANGE },
{ "mur", PROP_REAL, { 1, PROP_NO_STR }, PROP_RNGII (1, 100) },
{ "rho", PROP_REAL, { 0.022e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "Model", PROP_STR, { PROP_NO_VAL, "FREESPACE" },
PROP_RNG_STR3 ("FREESPACE", "MIRROR", "DESCHARLES") },
{ "Subst", PROP_STR, { PROP_NO_VAL, "Subst1" }, PROP_NO_RANGE },
PROP_NO_PROP };
PROP_OPT [] = {
{ "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
PROP_NO_PROP };
struct define_t bondwire::cirdef =
{ "BOND", 2, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
setY (NODE_2, NODE_2, y); setY (NODE_4, NODE_4, y);
y = 2.0*k * (p * (p - 1.0) - 0.5) / d;
setY (NODE_1, NODE_3, y); setY (NODE_3, NODE_1, y);
y = k * (p - 2.0) / d;
setY (NODE_2, NODE_4, y); setY (NODE_4, NODE_2, y);
y = k * (-2.0*p + 1.0) / d;
setY (NODE_1, NODE_4, y); setY (NODE_4, NODE_1, y);
setY (NODE_2, NODE_3, y); setY (NODE_3, NODE_2, y);
y = (4.0*p + 4.0) / d;
setY (NODE_1, NODE_2, y); setY (NODE_2, NODE_1, y);
setY (NODE_3, NODE_4, y); setY (NODE_4, NODE_3, y);
}
void hybrid::initTR (void) {
initDC ();
}
// properties
PROP_REQ [] = {
{ "phi", PROP_REAL, { 0, PROP_NO_STR }, PROP_RNGII (-180, +180) },
PROP_NO_PROP };
PROP_OPT [] = {
{ "Zref", PROP_REAL, { 50, PROP_NO_STR }, PROP_POS_RANGE },
PROP_NO_PROP };
struct define_t hybrid::cirdef =
{ "Hybrid", 4, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
#include "component.h"
#include "substrate.h"
// Constructor creates an unnamed instance of the substrate class.
substrate::substrate () : object () {
}
/* The copy constructor creates a new instance based on the given
substrate object. */
substrate::substrate (const substrate & c) : object (c) {
}
// Destructor deletes a substrate object.
substrate::~substrate () {
}
// properties
PROP_REQ [] = {
{ "er", PROP_REAL, { 9.8, PROP_NO_STR }, PROP_RNGII (1, 100) },
{ "h", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_POS_RANGE },
{ "t", PROP_REAL, { 35e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "tand", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_POS_RANGE },
{ "rho", PROP_REAL, { 0.022e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "D", PROP_REAL, { 0.15e-6, PROP_NO_STR }, PROP_POS_RANGE },
PROP_NO_PROP };
PROP_OPT [] = {
PROP_NO_PROP };
struct define_t substrate::miscdef =
{ "SUBST", 0, PROP_COMPONENT, PROP_SUBSTRATE, PROP_LINEAR, PROP_DEF };
}
}
/* Goes through the list of non-linear circuit objects and runs its
saveOperatingPoints() function. */
void dcsolver::saveOperatingPoints (void) {
circuit * root = subnet->getRoot ();
for (circuit * c = root; c != NULL; c = (circuit *) c->getNext ()) {
if (c->isNonLinear ()) c->saveOperatingPoints ();
}
}
// properties
PROP_REQ [] = {
PROP_NO_PROP };
PROP_OPT [] = {
{ "MaxIter", PROP_INT, { 150, PROP_NO_STR }, PROP_RNGII (2, 10000) },
{ "abstol", PROP_REAL, { 1e-12, PROP_NO_STR }, PROP_RNG_X01I },
{ "vntol", PROP_REAL, { 1e-6, PROP_NO_STR }, PROP_RNG_X01I },
{ "reltol", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_RNG_X01I },
{ "saveOPs", PROP_STR, { PROP_NO_VAL, "no" }, PROP_RNG_YESNO },
{ "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
{ "saveAll", PROP_STR, { PROP_NO_VAL, "no" }, PROP_RNG_YESNO },
{ "convHelper", PROP_STR, { PROP_NO_VAL, "none" },
PROP_RNG_STR6 ("none", "SourceStepping", "gMinStepping",
"LineSearch", "Attenuation", "SteepestDescent") },
{ "Solver", PROP_STR, { PROP_NO_VAL, "CroutLU" }, PROP_RNG_SOL },
PROP_NO_PROP };
struct define_t dcsolver::anadef =
{ "DC", 0, PROP_ACTION, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
{
data = A->get(r,c);
}
// properties
PROP_REQ [] =
{
PROP_NO_PROP
};
PROP_OPT [] =
{
{
"IntegrationMethod", PROP_STR, { PROP_NO_VAL, "Trapezoidal" },
PROP_RNG_STR4 ("Euler", "Trapezoidal", "Gear", "AdamsMoulton")
},
{ "Order", PROP_INT, { 2, PROP_NO_STR }, PROP_RNGII (1, 6) },
{ "InitialStep", PROP_REAL, { 1e-9, PROP_NO_STR }, PROP_POS_RANGE },
{ "MinStep", PROP_REAL, { 1e-16, PROP_NO_STR }, PROP_POS_RANGE },
{ "MaxStep", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
{ "MaxIter", PROP_INT, { 150, PROP_NO_STR }, PROP_RNGII (2, 10000) },
{ "abstol", PROP_REAL, { 1e-12, PROP_NO_STR }, PROP_RNG_X01I },
{ "vntol", PROP_REAL, { 1e-6, PROP_NO_STR }, PROP_RNG_X01I },
{ "reltol", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_RNG_X01I },
{ "LTEabstol", PROP_REAL, { 1e-6, PROP_NO_STR }, PROP_RNG_X01I },
{ "LTEreltol", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_RNG_X01I },
{ "LTEfactor", PROP_REAL, { 1, PROP_NO_STR }, PROP_RNGII (1, 16) },
{ "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
{ "Solver", PROP_STR, { PROP_NO_VAL, "CroutLU" }, PROP_RNG_SOL },
{ "relaxTSR", PROP_STR, { PROP_NO_VAL, "no" }, PROP_RNG_YESNO },
{ "initialDC", PROP_STR, { PROP_NO_VAL, "yes" }, PROP_RNG_YESNO },
PROP_NO_PROP
nr_double_t g = 1.0 / getPropertyDouble ("Z");
setY (NODE_1, NODE_1, +g); setY (NODE_2, NODE_2, +g);
setY (NODE_1, NODE_2, -g); setY (NODE_2, NODE_1, -g);
}
void pac::calcHB (nr_double_t frequency) {
nr_double_t f = getPropertyDouble ("f");
if (f == frequency) {
nr_double_t p = getPropertyDouble ("P");
nr_double_t r = getPropertyDouble ("Z");
nr_double_t u = sqrt (4 * p * r);
setE (VSRC_1, u);
}
else {
setE (VSRC_1, 0);
}
}
// properties
PROP_REQ [] = {
{ "f", PROP_REAL, { 1e9, PROP_NO_STR }, PROP_POS_RANGE },
{ "Z", PROP_REAL, { 50, PROP_NO_STR }, PROP_POS_RANGEX },
{ "Num", PROP_INT, { 1, PROP_NO_STR }, PROP_RNGII (1, MAX_PORTS) },
PROP_NO_PROP };
PROP_OPT [] = {
{ "P", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
{ "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
PROP_NO_PROP };
struct define_t pac::cirdef =
{ "Pac", 2, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
cy.set (NODE_I1P, NODE_I1P, +i1); cy.set (NODE_I1N, NODE_I1N, +i1);
cy.set (NODE_I1P, NODE_I1N, -i1); cy.set (NODE_I1N, NODE_I1P, -i1);
// entries of source 2
cy.set (NODE_I2P, NODE_I2P, +i2); cy.set (NODE_I2N, NODE_I2N, +i2);
cy.set (NODE_I2P, NODE_I2N, -i2); cy.set (NODE_I2N, NODE_I2P, -i2);
// correlation entries
cy.set (NODE_I1P, NODE_I2P, +ci); cy.set (NODE_I1N, NODE_I2N, +ci);
cy.set (NODE_I1P, NODE_I2N, -ci); cy.set (NODE_I1N, NODE_I2P, -ci);
cy.set (NODE_I2P, NODE_I1P, +ci); cy.set (NODE_I2N, NODE_I1N, +ci);
cy.set (NODE_I2P, NODE_I1N, -ci); cy.set (NODE_I2N, NODE_I1P, -ci);
return cy;
}
void iinoise::calcNoiseAC (nr_double_t frequency) {
setMatrixN (calcMatrixCy (frequency));
}
// properties
PROP_REQ [] = {
{ "i1", PROP_REAL, { 1e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "i2", PROP_REAL, { 1e-6, PROP_NO_STR }, PROP_POS_RANGE },
{ "C", PROP_REAL, { 0.5, PROP_NO_STR }, PROP_RNGII (-1, 1) },
PROP_NO_PROP };
PROP_OPT [] = {
{ "a", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
{ "c", PROP_REAL, { 1, PROP_NO_STR }, PROP_POS_RANGE },
{ "e", PROP_REAL, { 0, PROP_NO_STR }, PROP_POS_RANGE },
PROP_NO_PROP };
struct define_t iinoise::cirdef =
{ "IInoise", 4, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
nr_double_t a = getPropertyDouble ("U");
nr_double_t p = getPropertyDouble ("Phase");
setE (VSRC_1, polar (a, rad (p)));
}
void vam::initTR (void) {
initDC ();
}
void vam::calcTR (nr_double_t t) {
nr_double_t f = getPropertyDouble ("f");
nr_double_t p = getPropertyDouble ("Phase");
nr_double_t d = getPropertyDouble ("m");
nr_double_t a = getPropertyDouble ("U");
nr_double_t u = a * sin (2 * M_PI * f * t + rad (p));
setE (VSRC_1, u);
setC (VSRC_1, NODE_3, -u * d);
}
// properties
PROP_REQ [] = {
{ "U", PROP_REAL, { 1, PROP_NO_STR }, PROP_NO_RANGE },
{ "f", PROP_REAL, { 1e9, PROP_NO_STR }, PROP_POS_RANGE },
{ "m", PROP_REAL, { 1, PROP_NO_STR }, PROP_RNGII (0, 1) },
PROP_NO_PROP };
PROP_OPT [] = {
{ "Phase", PROP_REAL, { 0, PROP_NO_STR }, PROP_RNGII (-360, 360) },
PROP_NO_PROP };
struct define_t vam::cirdef =
{ "AM_Mod", 3, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };
