circuit.h

/***************************************************************************
 *   Copyright (C) 2003-2005 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 CIRCUIT_H
#define CIRCUIT_H

#include <qguardedptr.h>
#include "qstringlist.h"
#include "qvaluelist.h"

#include "elementset.h"

class CircuitDocument;
class Wire;
class Pin;
class Element;
class LogicOut;

typedef QValueList<QGuardedPtr<Pin> > PinList;

class LogicCacheNode
{
        public:
                LogicCacheNode();
                ~LogicCacheNode();
        
                LogicCacheNode *high;
                LogicCacheNode *low;
                QuickVector *data;
};

class Circuit
{
public:
        Circuit();
        ~Circuit();
        
        void addPin( Pin *node );
        void addElement( Element *element );
        
        bool contains( Pin *node );
        bool containsNonLinear() const { return m_elementSet->containsNonLinear(); }
        
        void init();

        void initCache();

        void setCacheInvalidated();

        void doNonLogic();

        void doLogic() { m_elementSet->doLinear(false); }

        void displayEquations();
        void updateCurrents();

        void createMatrixMap();

        static int identifyGround( PinList nodeList, int *highest = 0 );

        void setNextChanged( Circuit * circuit, unsigned char chain ) { m_pNextChanged[chain] = circuit; }
        Circuit * nextChanged( unsigned char chain ) const { return m_pNextChanged[chain]; }
        void setCanAddChanged( bool canAdd ) { m_bCanAddChanged = canAdd; }
        bool canAddChanged() const { return m_bCanAddChanged; }

protected:
        void cacheAndUpdate();

        void updateNodalVoltages();

        void stepReactive();

        static bool recursivePinAdd( Pin *node, PinList *unassignedNodes, PinList *associated, PinList *nodes );

        int m_cnodeCount;
        int m_branchCount;
        int m_prepNLCount; // Count until next m_elementSet->prepareNonLinear() is called

        PinList m_pinList;
        ElementList m_elementList;
        ElementSet *m_elementSet;

        //Stuff for caching
        bool m_bCanCache;
        LogicCacheNode * m_pLogicCacheBase;
        unsigned m_logicOutCount;
        LogicOut ** m_pLogicOut;

        bool m_bCanAddChanged;
        Circuit * m_pNextChanged[2];
};

#endif

---