main.cpp

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <map>
#include <string>
#include <sstream>
#include <set>
#include <queue>
#include <Eigen/Dense>

using namespace std;
using namespace Eigen;

class Component {
public:
    string name;
    string type;
    int node1, node2;
    double value;

    Component(string n, string t, int n1, int n2, double v)
        : name(n), type(t), node1(n1), node2(n2), value(v) {}
};

class Circuit {
private:
    vector<Component> components;
    map<int, int> nodeMap;
    map<int, vector<int>> adjacencyList;
    int numNodes;
    int numVoltSources;

    bool isConnectedToGround(int node, set<int>& visited) {
        if (node == 0) return true;  // Ground node
        visited.insert(node);

        for (int neighbor : adjacencyList[node]) {
            if (visited.find(neighbor) == visited.end()) {
                if (isConnectedToGround(neighbor, visited)) {
                    return true;
                }
            }
        }
        return false;
    }

    void buildAdjacencyList() {
        adjacencyList.clear();
        for (const Component& comp : components) {
            adjacencyList[comp.node1].push_back(comp.node2);
            adjacencyList[comp.node2].push_back(comp.node1);
        }
    }

    void checkCircuitTopology() {
        buildAdjacencyList();

        // Check if each node is connected to ground
        for (const auto& node : nodeMap) {
            if (node.first == 0) continue;  // Skip ground node
            set<int> visited;
            if (!isConnectedToGround(node.first, visited)) {
                throw runtime_error("Node " + to_string(node.first) + " is floating (not connected to ground)");
            }
        }

        // Check for voltage source loops
        vector<bool> hasVoltageConnection(numNodes, false);
        for (const Component& comp : components) {
            if (comp.type == "V") {
                if (hasVoltageConnection[nodeMap[comp.node1]] &&
                    hasVoltageConnection[nodeMap[comp.node2]]) {
                    throw runtime_error("Invalid voltage source configuration detected");
                }
                hasVoltageConnection[nodeMap[comp.node1]] = true;
                hasVoltageConnection[nodeMap[comp.node2]] = true;
            }
        }
    }

public:
    Circuit() : numNodes(0), numVoltSources(0) {}

    void parseNetlist(const string& filename) {
        ifstream file(filename);
        if (!file.is_open()) {
            throw runtime_error("Could not open file: " + filename);
        }

        string line;
        components.clear();
        nodeMap.clear();
        numNodes = 0;
        numVoltSources = 0;

        // Always add ground node (0) first
        nodeMap[0] = numNodes++;

        while (getline(file, line)) {
            if (line.empty() || line[0] == '*') continue;

            istringstream iss(line);
            string name, node1Str, node2Str, valueStr;

            if (!(iss >> name >> node1Str >> node2Str >> valueStr)) {
                throw runtime_error("Invalid line format: " + line);
            }

            try {
                int node1 = stoi(node1Str);
                int node2 = stoi(node2Str);
                double value = stod(valueStr);

                // Validate node numbers
                if (node1 < 0 || node2 < 0) {
                    throw runtime_error("Node numbers must be non-negative");
                }

                if (nodeMap.find(node1) == nodeMap.end())
                    nodeMap[node1] = numNodes++;
                if (nodeMap.find(node2) == nodeMap.end())
                    nodeMap[node2] = numNodes++;

                string type = string(1, name[0]);
                if (type != "R" && type != "V") {
                    throw runtime_error("Unsupported component type: " + type);
                }

                if (value <= 0) {
                    throw runtime_error("Component values must be positive");
                }

                components.emplace_back(name, type, node1, node2, value);

                if (type == "V") numVoltSources++;
            }
            catch (const exception& e) {
                throw runtime_error("Error parsing line: " + line + "\nError: " + e.what());
            }
        }

        cout << "Circuit parsed successfully:\n";
        cout << "Number of nodes: " << numNodes << "\n";
        cout << "Number of voltage sources: " << numVoltSources << "\n";
        cout << "Number of components: " << components.size() << "\n\n";

        // Verify circuit topology
        checkCircuitTopology();
    }

    void solveCircuit() {
        if (components.empty()) {
            throw runtime_error("No components in circuit");
        }

        int matrixSize = numNodes + numVoltSources;
        cout << "Creating " << matrixSize << "x" << matrixSize << " matrix\n";

        MatrixXd A = MatrixXd::Zero(matrixSize, matrixSize);
        VectorXd b = VectorXd::Zero(matrixSize);

        int voltSourceIndex = numNodes;

        for (const Component& comp : components) {
            int n1 = nodeMap[comp.node1];
            int n2 = nodeMap[comp.node2];

            if (comp.type == "R") {
                double conductance = 1.0 / comp.value;

                if (n1 != 0) {
                    A(n1, n1) += conductance;
                    if (n2 != 0) A(n1, n2) -= conductance;
                }
                if (n2 != 0) {
                    A(n2, n2) += conductance;
                    if (n1 != 0) A(n2, n1) -= conductance;
                }
            }
            else if (comp.type == "V") {
                if (n1 != 0) A(n1, voltSourceIndex) = 1;
                if (n2 != 0) A(n2, voltSourceIndex) = -1;

                if (n1 != 0) A(voltSourceIndex, n1) = 1;
                if (n2 != 0) A(voltSourceIndex, n2) = -1;

                b(voltSourceIndex) = comp.value;
                voltSourceIndex++;
            }
        }

        cout << "\nCircuit matrix A:\n" << A << "\n\n";
        cout << "Vector b:\n" << b << "\n\n";

        VectorXd x = A.colPivHouseholderQr().solve(b);

        cout << "Node Voltages:\n";
        for (const auto& node : nodeMap) {
            if (node.first == 0) {
                cout << "Node " << node.first << " (GND): 0.0V\n";
            } else {
                cout << "Node " << node.first << ": " << x(node.second) << "V\n";
            }
        }
    }
};

int main() {
    try {
        Circuit circuit;
        circuit.parseNetlist("D:/Dev/Projects/circuit-solver/circuit.txt"); // enter the absolute path to the circuit.txt file
        circuit.solveCircuit();
    }
    catch (const exception& e) {
        cerr << "Error: " << e.what() << endl;
        return 1;
    }
    return 0;
}