---

elements.h

Go to the documentation of this file.

// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.
//

// ***************************************************************************
//
//  5/11/01:  Converted comments to javadoc format
//  4/28/00:  improved comments
//  1/12/00:  added series and parallel RLC classes
//  11/16/99: changes to support new noise calculations
//  11/1/99:   Added is_active() and is_source() support
//  9/14/98:  Made many constructors explicit
//  8/27/98:  Expanded comments for series_tee; changed
//            branch constructors
//  8/24/98:  Added additional constructors; made recalc private
//            changed some void return values.
//  8/21/98:  Added 1-ports zterm and yterm
//  8/19/98:  Added admittance rep to spimp; improved capacitor
//  8/15/98:  Fixed size returned by series_tee
//
// ***************************************************************************

#ifndef ELEMENTS_H
#define ELEMENTS_H 1

#include "nport.h"
#include "parameter/complex_parameter.h"

// ***************************************************************************

class spimp : public nport
{
protected:
  bool is_series;

  void calcZ(complex Z);

  void calcY(complex Y);

public:
  spimp() : nport(2), is_series(true) { info.source = false; }

  // Virtual destructor is necessary to ensure proper subclass destruction.
  virtual ~spimp() { }

  int size() { return 2; }

  spimp & series()
  { is_series = true; return *this; }

  spimp & parallel()
  { is_series = false; return *this; }
};

// ***************************************************************************

class resistor : public spimp
{
public:
  parameter R;

  parameter Temp;

  explicit resistor(double r = 0.0)
    : spimp(), R(r), Temp(&T) { R.set_min(0.0); }

  explicit resistor(const abstract_real_parameter * r)
    : spimp(), R(r), Temp(&T) { R.set_min(0.0); }

  resistor & set(double r)
  { R = r; return *this; }

  resistor & set(abstract_real_parameter * r)
  { R = r; return *this; }

  resistor & set_T(double t)
  { Temp = t; return *this; }

  resistor & set_T(abstract_real_parameter * t)
  { Temp = t; return *this; }

  const nport::data_info & get_data_info() 
  { info.active = (Temp != device::T); return info; }

private:
  // The calculation is done here.
  void recalc()   { calcZ(Complex(R)); data.passive_noise(f, Temp); } 
  void recalc_S() { calcZ(Complex(R)); }
};

// ***************************************************************************

class capacitor : public spimp
{
public:
  parameter C;

  explicit capacitor(double c = 0.0)
    : spimp(), C(c) { C.set_min(0.0); info.noise = info.active = false; }

  explicit capacitor(const abstract_real_parameter * c)
    : spimp(), C(c) { C.set_min(0.0); info.noise = info.active = false; }

  capacitor & set(double c)
  { C = c; return *this; }

  capacitor & set(abstract_real_parameter * c)
  { C = c; return *this; }

private:
  // The calculation is done here.
  void recalc() { calcY((2 * Pi * f * C) * I); }
};

// ***************************************************************************

class inductor : public spimp
{
public:
  parameter L;

  explicit inductor(double i = 0.0)
    : spimp(), L(i) { L.set_min(0.0); info.noise = info.active = false; }

  explicit inductor(const abstract_real_parameter * i)
    : spimp(), L(i) { L.set_min(0.0); info.noise = info.active = false; }

  inductor & set(double i)
  { L = i; return *this; }

  inductor & set(abstract_real_parameter * i)
  { L = i; return *this; }

private:
  // The calculation is done here.
  void recalc() { calcZ((2 * Pi * f * L) * I); }
};


class series_RLC: public spimp
{
public:
  parameter R;

  parameter L;

  parameter C;

  parameter Temp;

  explicit series_RLC(double r = 0.0, double l = 0.0, double c = 0.0)
    : spimp(), R(r), L(l), C(c), Temp(&T)
      { R.set_min(0.0); L.set_min(0.0); C.set_min(0.0);
        info.noise = info.active = false; }

  series_RLC & set_R(double r)
  { R = r; return *this; }

  series_RLC & set_R(abstract_real_parameter * r)
  { R = r; return *this; }

  series_RLC & set_L(double l)
  { L = l; return *this; }

  series_RLC & set_L(abstract_real_parameter * l)
  { L = l; return *this; }

  series_RLC & set_C(double c)
  { C = c; return *this; }

  series_RLC & set_C(abstract_real_parameter * c)
  { C = c; return *this; }

  series_RLC & set_T(double t)
  { Temp = t; return *this; }

  series_RLC & set_T(abstract_real_parameter * t)
  { Temp = t; return *this; }

  const nport::data_info & get_data_info() 
  { info.active = (Temp != device::T); return info; }

private:
  // The calculation is done here.
  void recalc_S()
  {
    if (C==0.0)
      calcY(0.0);   // Use admittance calculation since impedance is infinite.
    else
    {
      double omega = 2*Pi*f;
      calcZ(Complex(R, omega*L - 1/(omega*C)));
    }
  }

  void recalc() { recalc_S(); data.passive_noise(f, Temp); }
};

// ***************************************************************************

class parallel_RLC : public spimp
{
public:
  parameter R;

  parameter L;

  parameter C;

  parameter Temp;

  explicit parallel_RLC(double r = 0.0, double l = 0.0, double c = 0.0)
    : spimp(), R(r), L(l), C(c), Temp(&T)
      { R.set_min(0.0); L.set_min(0.0); C.set_min(0.0);
        info.noise = info.active = false; }

  parallel_RLC & set_R(double r)
  { R = r; return *this; }

  parallel_RLC & set_R(abstract_real_parameter * r)
  { R = r; return *this; }

  parallel_RLC & set_L(double l)
  { L = l; return *this; }

  parallel_RLC & set_L(abstract_real_parameter * l)
  { L = l; return *this; }

  parallel_RLC & set_C(double c)
  { C = c; return *this; }

  parallel_RLC & set_C(abstract_real_parameter * c)
  { C = c; return *this; }

  parallel_RLC & set_T(double t)
  { Temp = t; return *this; }

  parallel_RLC & set_T(abstract_real_parameter * t)
  { Temp = t; return *this; }

  const nport::data_info & get_data_info() 
  { info.active = (Temp != device::T); return info; }

private:
  // The calculation is done here.
  void recalc_S()
  {
    if (R==0.0 || L==0.0)    // Short circuit.
      calcZ(0.0);
    else
    {
      double omega = 2*Pi*f;
      // calcZ( R*L / (L + I*(R*omega*L*C - R/omega)));
      calcY(Complex(1/R, omega*C - 1/(omega*L)));
    }
  }

  void recalc() { recalc_S(); data.passive_noise(f, Temp); }
};

// ***************************************************************************

class branch : public nport
{
public:
  explicit branch(int b = 3);

  int size() { return branches; }

  branch & set_branches(int);

  int get_branches() const { return branches; }

private:
  int branches;

  void calc();

  void recalc() { }
};

// ***************************************************************************

class series_tee : public nport
{
public:
  series_tee();

  int size() { return 3; }

private:
  void recalc() { }
};

// ***************************************************************************

class zterm : public nport
{
public:
  complex_parameter Z;

  parameter Temp;

  explicit zterm(complex z = 0.0) : nport(1), Z(z), Temp(&T)
  { info.source = false; }

  explicit zterm(abstract_complex_parameter * z) : nport(1), Z(z), Temp(&T)
  { info.source = false; }

  zterm & set(complex z)
  { Z = z; return *this; }

  zterm & set(abstract_complex_parameter * z)
  { Z = z; return *this; }

  zterm & set_T(double t)
  { Temp = t; return *this; }

  zterm & set_T(abstract_real_parameter * t)
  { Temp = t; return *this; }

  const nport::data_info & get_data_info() 
  { info.active = (Temp != device::T && Z != Complex(0.0)); return info; }

private:
  // The calculation is done here.
  void recalc();
  void recalc_S();
};

typedef zterm short_term;

// ***************************************************************************

class yterm : public nport
{
public:
  complex_parameter Y;

  parameter Temp;

  explicit yterm(complex y = 0.0) : nport(1), Y(y), Temp(&T)
  { info.source = false; }

  explicit yterm(abstract_complex_parameter * y) : nport(1), Y(y), Temp(&T)
  { info.source = false; }

  yterm & set(complex y)
  { Y = y; return *this; }

  yterm & set(abstract_complex_parameter * y)
  { Y = y; return *this; }

  yterm & set_T(double t)
  { Temp = t; return *this; }

  yterm & set_T(abstract_real_parameter * t)
  { Temp = t; return *this; }

  const nport::data_info & get_data_info() 
  { info.active = (Temp != device::T && Y != Complex(0.0)); return info; }

private:
  // The calculation is done here.
  void recalc();
  void recalc_S();
};

typedef yterm open_term;

#endif /* ELEMENTS_H */

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7