---

sdata.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/14/01:  Converted comments to javadoc format
// 11/2/00:  Added passive_noise_temp()
// 10/22/99: Some major changes to device::Z0 handling
// 7/26/99:  Changed z_norm to protected in sdata
// 8/27/98:  Added SdB, tn, and NF (JSW)
// 7/8/98:   Added sdata::reindex(); ydata_ptr
// 6/26/98:  Made constructors explicit
// 6/22/98:  Added indexing mode flexibility, changed size to
//           size()
// 1/5/97:   Added sdata::resize(); changed void to object &
//
// **************************************************************************

#ifndef SDATA_H
#define SDATA_H

#include "global.h"
#include "device.h"

class sdata ;
class zdata ;
class ydata ;
class ydata_ptr ;

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

class sdata
{
protected:
  double z_norm;

public:
  Matrix S;

  Matrix C;

  Vector B;

  int size() const
  { return S.Lmaxindex(); }

  v_index_mode mode() const
  { return S.Lmode; }

  // convert sdata values to "engineering" forms:

  double SdB(int out, int in) const;

  double tn(int out, int in) const;

  double NF(int out, int in) const;

  explicit sdata(int n = 0, v_index_mode = Index_1);

  sdata(const sdata &sd) ;

  sdata(const sdata &sd, double z0) ;

  // "conversion" constructors - to sdata from zdata, ydata,  or ydata_ptr

  sdata(const zdata &zd, double z0 = double(device::Z0)) ;

  sdata(const ydata &yd, double z0 = double(device::Z0)) ;

  sdata(const ydata_ptr &, double z0 = double(device::Z0));

  sdata & resize(int);

  sdata & reindex(v_index_mode m = Index_1)
  { S.reindex(m,m); C.reindex(m,m); B.reindex(m); return *this; }

  double get_znorm() const { return z_norm; }

  sdata & set_znorm(double z) ;

  sdata & change_norm(double new_z0 = double(device::Z0)) ; 

  sdata & passive_noise(double freq, double temp) ;
};

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

class zdata
{
public:
  Matrix Z;

  Matrix C; 

  Vector Vs;

  int size() const
  { return Z.Lmaxindex(); }

  v_index_mode mode() const
  { return Z.Lmode; }

  explicit zdata(int n = 0, v_index_mode = Index_1);

  zdata(const zdata &zd) ;

  // "conversion" constructors - to zdata from sdata or ydata

  zdata(const sdata &sd) ;

  zdata(const ydata &yd) ;

  // assignment operator: just use default operator = for now
  // zdata & operator=(const zdata &zd) ;

  zdata & passive_noise(double freq, double temp) ;
};

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

class ydata
{
public:
  Matrix Y;
 
  Matrix C;

  Vector Is;

  int size() const
  { return Y.Lmaxindex(); }

  v_index_mode mode() const
  { return Y.Lmode; }

  explicit ydata(int n = 0, v_index_mode = Index_1);

  ydata(const ydata &yd) ;

  // "conversion" constructors - to ydata from sdata or zdata

  ydata(const sdata &sd) ;

  ydata(const zdata &zd) ;

  // assignment operator: just use default operator = for now
  // ydata & operator=(const ydata &yd) ;

  ydata & passive_noise(double freq, double temp) ;
};

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

class ydata_ptr
{
public:
  const Matrix * pY;

  const Matrix * pC;

  const Vector * pIs;

  int size() const
  { return (pY) ? pY -> Lmaxindex() : 0; }

  v_index_mode mode() const
  { return (pY) ? pY -> Lmode : Index_1; }

  // Constructor:
  explicit ydata_ptr
  (const Matrix * Y = 0, const Matrix * C = 0, const Vector * Is = 0)
    : pY(Y), pC(C), pIs(Is) { }

};

// **************************************************************************
//
// function compute_passive_noise
//

inline void compute_passive_noise(sdata& d, double freq, double Temp)
{ d.passive_noise(freq, Temp); }

inline void compute_passive_noise(ydata& d, double freq, double Temp)
{ d.passive_noise(freq, Temp); }

inline void compute_passive_noise(zdata& d, double freq, double Temp)
{ d.passive_noise(freq, Temp); }

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

double passive_noise_temp(double freq = device::f, double Temp = device::T);

#endif /* SDATA_H */

---

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