---

nport.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/13/02:  changed comments to javadoc format
// 12/10/99: added simple_nport class
// 11/16/99: changes to support new noise calculations
// 11/1/99:  added is_active() and is_source()
// 10/22/99: class device is now in device.h
// 10/22/99: device::Z0 is back to a parameter again
// 8/23/99:  added definition of size() to alias
// 7/26/99:  removed the superfluous sdata_nport class
// 7/25/99:  minor changes to remove some compiler warnings
// 4/28/99:  added support for state_tags.
// 9/30/98:  changed the fixes to device.
// 9/22/98:  fixed bug by adding assigment operator to device.
// 9/18/98:  class alias is now a subclass of data_ptr_nport.
// 9/18/98:  created data_ptr_nport class.
// 9/18/98:  improved S, C, and B function fo class nport.
// 9/16/98:  fixed sdata_nport = sdata_nport() bug.
// 7/27/98:  added nport::get_last_data(); some other minor
//           changes to nport
// 7/21/98:  changed generic_nport to sdata_nport
// 7/8/98:   added generic_nport; added nport::mode();
//           moved recalc() to nport; added new nport constuctor
// 12/30/97: changed device::Z0 to a double vice parameter
// 12/23/97: pulled out sdata and compute_passive_noise to
//           sdata.h (FR). Includes sdata.h.
// 12/19/97: modified by FR for matmath classes
//
// **************************************************************************

#ifndef NPORT_H
#define NPORT_H

#include "device.h"
#include "global.h"
#include "port.h"
#include "state_tag.h"
#include "parameter.h"
#include "sdata.h"

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

class nport : public device
{

public:
  struct data_info {

    bool noise;

    bool active;

    bool source;
  };

protected:
  sdata data;

  data_info info;

  virtual void recalc() = 0;

  virtual void recalc_S() { recalc(); }

public:
  nport(int n = 0) : data(n)
    { info.noise = info.active = info.source = true; }

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

  virtual const sdata& get_data() { last_state.reset(); recalc(); return data; }

  virtual const sdata& get_data(state_tag calc_id)
  {
    if(last_state == calc_id) return data;
    last_state = calc_id;
    recalc();
    return data;
  }

  virtual const sdata& get_last_data() const { return data; }

  virtual const sdata& get_data_S() { last_state.reset(); recalc_S(); return data; }

  virtual const sdata& get_data_S(state_tag calc_id)
  {
    if(last_state == calc_id) return data;
    last_state = calc_id;
    recalc_S();
    return data;
  }

  virtual int size() { return data.size(); }  // return the number of ports

  virtual const data_info & get_data_info() { return info; }

  virtual bool has_noise() { return get_data_info().noise; }

  virtual bool is_active() { return get_data_info().active; }

  virtual bool is_source() { return get_data_info().source; }

  virtual complex S(int p1, int p2);

  virtual complex C(int p1, int p2);

  virtual complex B(int p);

  virtual port get_port(int index);

  virtual int get_port(port p);

  virtual v_index_mode mode() { return data.mode(); }  // sdata indexing mode

};

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

class data_ptr_nport : public nport
{
protected:
  const sdata * data_ptr;

public:
  data_ptr_nport() : nport(0), data_ptr(&data) { }

  data_ptr_nport(const data_ptr_nport & c) : nport(c), data_ptr(&data) { }

  data_ptr_nport & operator=(const data_ptr_nport & c)
  { data = c.data; data_ptr = &data; return *this; }

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

  virtual const sdata& get_data()
  {
    last_state.reset(); recalc(); return *data_ptr;
  }

  virtual const sdata& get_data(state_tag calc_id)
  {
    if(last_state == calc_id) return *data_ptr;
    last_state = calc_id;
    recalc();
    return *data_ptr;
  }

  virtual const sdata& get_data_S()
  {
    last_state.reset(); recalc_S(); return *data_ptr;
  }

  virtual const sdata& get_data_S(state_tag calc_id)
  {
    if(last_state == calc_id) return *data_ptr;
    last_state = calc_id;
    recalc_S();
    return *data_ptr;
  }

  virtual const sdata& get_last_data() const { return *data_ptr; }

  virtual int size() { return data_ptr->size(); } // return the number of ports

  virtual v_index_mode mode() { return data_ptr->mode(); }
};

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

class alias : public data_ptr_nport
{
private:
  nport *original;

  void recalc()   { if(original) data_ptr = &original->get_data(); } 

  void recalc_S() { if(original) data_ptr = &original->get_data_S(); } 

public:
  // The default constructor.
  alias() : data_ptr_nport(), original(0) { }

  alias(nport & o) : data_ptr_nport(), original(&o) { }

  // return the number of ports
  // (need this definition since data may not be properly sized until get_data())
  int size() { return (original) ? original->size() : 0; }

  const nport::data_info & get_data_info()
    { return (original) ? original->get_data_info() : info; }

  alias & operator=(nport & n);
};

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

class simple_nport : public nport
{

public:
  simple_nport(int n = 0) : nport(n) { }

  sdata & operator()() { return data; }

  data_info & set_info() { return info; }

private:
  void recalc()   { }

  void recalc_S() { }

};

#endif /* NPORT_H */

---

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