CElement.hh

Go to the documentation of this file.

#ifndef CElement_HH
#define CElement_HH

#include <math/Complex.hh>
#include <electro/CSignal.hh>
#include <electro/CBranch.hh>
#include <iostream>
#include <vector>


const double  MAX_DOUBLE=1.0e99;

class CElement;
class CBranch;
class CCircuit;

  class CPin
  {
    public:
      CPin(CElement *dst_item=NULL, unsigned int dst_pin=0){element=dst_item;pin=dst_pin;}
      ~CPin(){pin=0;element=NULL;};
      CElement *element;
      unsigned int pin;
    };

  
  class CElement
  {
    public:
      CElement(std::string symbol="",std::string name="",int x=0,int y=0,int rot=0);
      
      ~CElement();

      std::string getUnitSymbol() {return m_unitSymbol;}
      virtual std::string getValueSymbol() {return m_valueSymbol;}
      virtual std::string getValueString();
      virtual double getValue() {return 0;}
      
      
      std::string getType(void){return m_symbol;}
      std::string getName(void){return m_name;}
      int getX(void){return m_x;}
      int getY(void){return m_y;}
      int getRot(void){return m_rot;}
    
      void setName(std::string name){m_name=name;}
//      void setSymbol(std::string symbol){m_symbol=symbol;}
      void setX(int x){m_x=x;}
      void setY(int y){m_y=y;}
      void setRot(int rot){m_rot=rot;}

      bool conect(CElement *dest,unsigned int src_pin,unsigned int dest_pin);
      bool disconect(unsigned int src_pin);
    
      virtual void print(){ std::cout << m_symbol << ":"<< m_name << std::endl;}
      void print_conections();
    
      std::vector<CPin *> pins;
      CBranch *branch;    
      CSignal *signal;

      virtual void draw();
      void drawConnections();
      virtual void drawName();
      virtual void drawValue();

      
      // TODO: change these functions to one that returns Glib::Point.
      virtual int getPinX(int pinNumber);
      virtual int getPinY(int pinNumber);
    
      void setParent(CCircuit* parent) {m_ParentCircuit = parent;};
      
    protected: 
      std::string m_name;
      std::string m_symbol;
      std::string m_unitSymbol;
      std::string m_valueSymbol;
      int m_x;
      int m_y;
      int m_rot;
      unsigned int m_max_pin(){return pins.size();}
      CCircuit* m_ParentCircuit; 
  };


  class CExNode : public CElement
  {
    protected: 
 
    public:
      CExNode(std::string name,int x=0,int y=0) : CElement("EXNODE",name,x,y){};
      ~CExNode(){ }
      void add(CPin * pin){ pins.push_back(pin); }
      int count_pins(){return pins.size();}
      unsigned int nr;
  };



class CNode : public CElement
{
protected: 
    
public:
    CNode(std::string name,int x=0,int y=0) : CElement("NODE",name,x,y){
         for(int i=0;i<4;i++)
            pins.push_back(new CPin());
    };
    ~CNode(){};

    
    void draw();
    void drawName();
    void drawValue();

    // TODO: change these functions to one that returns Glib::Point.
    int getPinX(int pinNumber) {return m_x;}
    int getPinY(int pinNumber) {return m_y;}

    CExNode *papa;
};


class CElementPasive:public CElement
{
public:

    CElementPasive():CElement(){};
    CElementPasive(std::string symbol,std::string name,int x=0,int y=0,int rot=0):
        CElement(symbol,name,x,y,rot){};
    
    virtual ~CElementPasive(){};

    virtual Complex getZc(double omega){return Complex(0,0);};
     virtual Complex getYc(double omega){return Complex(0,0);};
    
};
class CElementActive:public CElement
{
protected:
    double m_omega;
    double m_fi0;  
public:
    CElementActive():CElement(){};
    CElementActive(std::string symbol,std::string name,double omega=0,double fi0=0,int x=0,int y=0,int rot=0):
      CElement(symbol,name,x,y,rot)
      {
        m_omega=omega;
        m_fi0=fi0;
      };
    
    virtual ~CElementActive(){};

    double getOmega(void){return m_omega;};
    void setOmega(double omega){m_omega=omega;};
    double getFi0(void){return m_fi0;};
    void setFi0(double fi){m_fi0=fi;};
  
};

class CElementControl:public CElement
{
protected:
    double m_gm;
    std::string m_on;
public:
    CElementControl():CElement(){};
    CElementControl(std::string symbol,std::string name,double gm, std::string on,int x=0,int y=0,int rot=0):
      CElement(symbol,name,x,y,rot)
      {
        m_gm=gm;
        m_on=on;
      };
    
    virtual ~CElementControl(){};

    double getGm(void){return m_gm;};
    void setGm(double gm){m_gm=gm;};
    
    std::string getOn(void ){return m_on;}
    void setOn(std::string on){m_on=on;};
    std::string getValueString();    
};

#endif

---