elementset.h

/***************************************************************************
 *   Copyright (C) 2003-2004 by David Saxton                               *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef ELEMENTSET_H
#define ELEMENTSET_H

#include <qvaluelist.h>
//#include <vector>

//using namespace std;

class CBranch;
class Circuit;
class CNode;
class Element;
class ElementSet;
class LogicIn;
class Matrix;
class NonLinear;

#include "math/qvector.h"

typedef QValueList<Element*> ElementList;
typedef QValueList<NonLinear*> NonLinearList;

//typedef vector<CBranch> CBranchList_T;

class ElementSet
{
public:
        ElementSet(Circuit *circuit, const int n, const int m);
        ~ElementSet();
        Circuit *circuit() const { return m_pCircuit; }
        void addElement( Element *e );
        void setCacheInvalidated();
        Matrix *matrix() const { return p_A; }
        QuickVector *b() const { return p_b; }
        QuickVector *x() const { return p_x; }
        void set_x(QuickVector *x) { delete p_x; p_x = x; }
        bool containsNonLinear() const { return b_containsNonLinear; }
        void doNonLinear( int maxIterations, double maxErrorV = 1e-9, double maxErrorI = 1e-12 );
        bool doLinear( bool performLU );

        CBranch *cbranches(const unsigned i) { return m_cbranches[i]; }
        CNode *cnodes(const unsigned i) { return m_cnodes[i]; }
        CNode *ground() const { return m_ground; }

        int cnodeCount() const { return m_cn; }

        int cbranchCount() const { return m_cb; }
//      int cbranchCount() const { return m_cbranches->size(); }

        void createMatrixMap();
        void displayEquations();
        void updateInfo();

private:
// calc enginge stuff
        Matrix *p_A;
        QuickVector *p_x;
        QuickVector *p_b;
// end calc engine stuff. 

        ElementList m_elementList;
        NonLinearList m_cnonLinearList;

        uint m_cb; // # cbranches
        CBranch **m_cbranches; // Pointer to an array of cbranches

//      CBranchList_T *m_cbranches;

        uint m_cn; // # cnodes
        CNode **m_cnodes; // Pointer to an array of cnodes
        CNode *m_ground;

        uint m_clogic;
        LogicIn **p_logicIn;
        bool b_containsNonLinear;
        Circuit *m_pCircuit;
};

#endif

---