#include <iostream> #include <vector> #include <st...
创建于：2025年6月10日
使用 O4 Mini High 回答 Chat01
问题
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>
#include <cctype>
#include <sstream>
#include <unordered_map>
#include <iomanip>
#include <cmath>
#include <memory>
#include <queue>
#include <unordered_set>
using namespace std;
/**************************************************************************************************
-
CONSTANTS
**************************************************************************************************/
static constexpr double DEFAULT_DIODE_DROP = 0.7; // ولتاژ افت دیود ایده‌آل (۷۰۰ mV)
static constexpr double SMALL_RESISTANCE_R = 1e-3; // مقاومت خیلی کوچک (1 mΩ) برای دیود/سلف در DC
static constexpr double EPS = 1e-12; // برای تشخیص تکین‌بودن ماتریس
/**************************************************************************************************
-
UTILITY FUNCTIONS
**************************************************************************************************/
// tiny helpers – put in a common header or anonymous namespace
static bool startsWith(const string& s, const string& prefix) { return s.rfind(prefix,0)==0; }
static string extractNode(const string& var) { auto l=var.find('('); auto r=var.find(')'); return var.substr(l+1,r-l-1); }
static string extractElement(const string& var){ auto l=var.find('('); auto r=var.find(')'); return var.substr(l+1,r-l-1); }
static vector<string> tokenize(const string &line) {
vector<string> tokens;
istringstream iss(line);
string word;
while (iss >> word) {
tokens.push_back(word);
}
return tokens;
}
// تابع تبدیل رشته به حروف کوچک
string toLower(const string& s) {
string result = s;
transform(result.begin(), result.end(), result.begin(), ::tolower);
return result;
}
// تابع بررسی وجود فایل
bool fileExists(const string& filename) {
ifstream file(filename);
return file.good();
}
// تابع نمایش محتوای فایل شماتیک
void showSchematicContent(const string& filename) {
ifstream file(filename);
if (!file) {
cout << "Error: Could not open file " << filename << endl;
return;
}
textcout << filename << ":" << endl; string line; while (getline(file, line)) { cout << line << endl; } file.close();
}
// تابع اصلی منوی نمایش شماتیک‌ها
void showExistingSchematicsMenu() {
vector<string> schematics = {
"draft1.txt",
"draft2.txt",
"draft3.txt",
"elecphase1.txt"
};
textwhile (true) { cout << "-choose existing schematic:" << endl; for (size_t i = 0; i < schematics.size(); i++) { cout << i+1 << "-" << schematics[i] << endl; } string input; cout << ">>> "; getline(cin, input); // خروج از منو اگر کاربر return وارد کند if (toLower(input) == "return") { break; } // بررسی ورودی جدید NewFile if (input.size() > 8 && toLower(input.substr(0, 8)) == "newfile ") { string filePath = input.substr(8); if (fileExists(filePath)) { showSchematicContent(filePath); } else { cout << "Error: File not found" << endl; } continue; } // بررسی ورودی عددی try { int choice = stoi(input); if (choice >= 1 && choice <= static_cast<int>(schematics.size())) { showSchematicContent(schematics[choice-1]); } else { cout << "-Error : Inappropriate input" << endl; } } catch (...) { cout << "-Error : Inappropriate input" << endl; } }
}
/**
- iequals:
- مقایسهٔ دو رشته به صورت case-insensitive.
*/
static bool iequals(const string &a, const string &b) {
if (a.size() != b.size()) return false;
for (size_t i = 0; i < a.size(); i++) {
if (tolower(a[i]) != tolower(b[i])) return false;
}
return true;
}
/**
- istarts_with:
- بررسی می‌کند آیا رشته s با prefix به صورت case-insensitive شروع می‌شود یا خیر.
*/
static bool istarts_with(const string &s, const string &prefix) {
if (s.size() < prefix.size()) return false;
for (size_t i = 0; i < prefix.size(); i++) {
if (tolower(s[i]) != tolower(prefix[i])) return false;
}
return true;
}
/**
- toDouble:
- تبدیل رشته s به double؛ در صورت ناتوانی در تبدیل، runtime_error پرتاب می‌کند.
*/
static double toDouble(const string &s) {
string str = s;
for (auto &c : str) c = tolower(c); // make lowercase
double multiplier = 1.0;
textif (str.size() >= 3 && str.substr(str.size() - 3) == "meg") { multiplier = 1e6; str = str.substr(0, str.size() - 3); } else if (!str.empty() && str.back() == 'g') { multiplier = 1e9; str.pop_back(); } else if (!str.empty() && str.back() == 'k') { multiplier = 1e3; str.pop_back(); } else if (!str.empty() && str.back() == 'm') { multiplier = 1e-3; str.pop_back(); } else if (!str.empty() && str.back() == 'u') { multiplier = 1e-6; str.pop_back(); } else if (!str.empty() && str.back() == 'n') { multiplier = 1e-9; str.pop_back(); } else if (!str.empty() && str.back() == 'p') { multiplier = 1e-12; str.pop_back(); } else if (!str.empty() && str.back() == 'f') { multiplier = 1e-15; str.pop_back(); } try { size_t idx; double base = stod(str, &idx); if (idx != str.size()) throw runtime_error(""); return base * multiplier; } catch (...) { throw runtime_error("Invalid numeric value: " + s); }
}
/**
- parseSINOffset:
- اگر در خط ورودی، الگوی SIN(...) وجود داشته باشد، مقدار آفست (عدد اول داخل پرانتز) را استخراج می‌کند.
- در غیر این صورت مقدار NaN برمی‌گرداند.
*/
static double parseSINOffset(const string &line) {
string lower = line;
for (auto &c : lower) c = tolower(c);
size_t pos = lower.find("sin(");
if (pos == string::npos) {
return nan("");
}
// یافتن پرانتز باز و بسته
size_t start = line.find('(', pos);
size_t end = line.find(')', start);
if (start == string::npos || end == string::npos || end <= start + 1) {
throw runtime_error("Syntax error: malformed SIN() in line: " + line);
}
// استخراج متن داخل پرانتز
string inside = line.substr(start + 1, end - start - 1);
// جایگزینی کاما با فاصله تا بتوانیم با istringstream بخوانیم
for (auto &c : inside) {
if (c == ',') c = ' ';
}
istringstream iss(inside);
string first;
if (!(iss >> first)) {
throw runtime_error("Syntax error: empty SIN() arguments in line: " + line);
}
return toDouble(first);
}
/**************************************************************************************************
-
NODE MAPPING (STRING → INTEGER)
**************************************************************************************************/
struct NodeMap {
unordered_map<string,int> name2idx;
vector<string> idx2name;
textNodeMap() { // گره زمین با نام "0" معادل اندیس 0 name2idx["0"] = 0; idx2name.push_back("0"); } /** * getIdx: * اگر نام گره ثبت‌شده باشد اندیس آن را برمی‌گرداند، در غیر این صورت یک اندیس جدید اختصاص می‌دهد. */ int getIdx(const string &nodeName) { if (name2idx.count(nodeName)) return name2idx[nodeName]; int newIdx = (int)idx2name.size(); name2idx[nodeName] = newIdx; idx2name.push_back(nodeName); return newIdx; } bool hasName(const string &nodeName) const { return name2idx.count(nodeName); } int count() const { return (int)idx2name.size(); } /** * renameNode: * نام گره oldName را به newName تغییر می‌دهد. اگر oldName وجود نداشته باشد یا newName * تکراری باشد، خطا پرتاب می‌کند. */ void renameNode(const string &oldName, const string &newName) { if (!name2idx.count(oldName)) { throw runtime_error("Error: node '" + oldName + "' not found."); } if (name2idx.count(newName)) { throw runtime_error("Error: node name '" + newName + "' already exists."); } int idx = name2idx[oldName]; name2idx.erase(oldName); name2idx[newName] = idx; idx2name[idx] = newName; }
};
/**************************************************************************************************
-
ELEMENT BASE CLASS
**************************************************************************************************/
class Element {
public:
enum Type { RES, CAP, IND, DIO, VS, IS, VCVS, CCCS, CCVS, VCCS };
Element(Type t, string nm, int n1, int n2)
: type(t), name(std::move(nm)), nPlus(n1), nMinus(n2) {}
virtual ~Element() = default;
textType type; // نوع المان string name; // نام المان int nPlus; // اندیس گره مثبت یا اول int nMinus; // اندیس گره منفی یا دوم /** * stamp: * وظیفه دارد مهرگذاری المان در ماتریس A و بردار b را انجام دهد. * nNode تعداد گره‌های غیر از زمین است و vsMap نگاشت نام منابع ولتاژ به اندیس آنهاست. */ virtual void stamp(vector<vector<double>> &A, vector<double> &b,int nNode, const unordered_map<string,int> &vsMap) const = 0; virtual void stampTransient(std::vector<std::vector<double>>& /*A*/, std::vector<double>& /*b*/, double /*dt*/, std::unordered_map<std::string,double>& /*capVPrev*/, std::unordered_map<std::string,double>& /*indIPrev*/, int /*nNode*/, const std::unordered_map<std::string,int>& /*vsMap*/) const { /* empty – override in C & L */ }
};
/**************************************************************************************************
-
CONCRETE ELEMENT CLASSES
**************************************************************************************************/
class Resistor : public Element {
public:
double R;
Resistor(string nm, int a, int b, double val)
: Element(Element::RES, std::move(nm), a, b), R(val) {
if (R <= 0.0) {
throw runtime_error("Error: Resistance must be > 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
double g = 1.0 / R;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][i-1] += g;
if (j != 0) A[j-1][j-1] += g;
if (i != 0 && j != 0) {
A[i-1][j-1] -= g;
A[j-1][i-1] -= g;
}
}
};
class Capacitor : public Element {
public:
double C;
Capacitor(string nm, int a, int b, double val)
: Element(Element::CAP, std::move(nm), a, b), C(val) {
if (C < 0.0) {
throw runtime_error("Error: Capacitance must be ≥ 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
// در DC مثل مدار باز → هیچ مهرگذاری انجام نمی‌شود.
}
void stampTransient(std::vector<std::vector<double>>& A,
std::vector<double>& b,
double dt,
std::unordered_mapstd::string,double& capVPrev,
std::unordered_mapstd::string,double& /indIPrev/,
int nNode,
const std::unordered_mapstd::string,int& /vsMap/) const override
{
double G = C / dt; // Norton conductance
double Vpr = capVPrev[name]; // V[n]
double Ieq = G * Vpr; // companion current source
textint i = nPlus, j = nMinus; if (i != 0) A[i-1][i-1] += G; if (j != 0) A[j-1][j-1] += G; if (i != 0 && j != 0) { A[i-1][j-1] -= G; A[j-1][i-1] -= G; } if (i != 0) b[i-1] += Ieq; if (j != 0) b[j-1] += -Ieq; }
};
class Inductor : public Element {
public:
double L;
Inductor(string nm, int a, int b, double val)
: Element(Element::IND, std::move(nm), a, b), L(val) {
if (L < 0.0) {
throw runtime_error("Error: Inductance must be ≥ 0 (" + name + ").");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
// مدل‌سازی سلف در DC به کمک مقاومت کوچک سری
double g = 1.0 / SMALL_RESISTANCE_R;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][i-1] += g;
if (j != 0) A[j-1][j-1] += g;
if (i != 0 && j != 0) {
A[i-1][j-1] -= g;
A[j-1][i-1] -= g;
}
}
void stampTransient(std::vector<std::vector<double>>& A,
std::vector<double>& b,
double dt,
std::unordered_mapstd::string,double& /capVPrev/,
std::unordered_mapstd::string,double& indIPrev,
int nNode,
const std::unordered_mapstd::string,int& /vsMap/) const override
{
double G = dt / L; // Norton conductance (G = 1/R)
double Ipr = indIPrev[name]; // I[n]
// Ieq is simply previous current (Norton current source)
double Ieq = Ipr;
textint i = nPlus, j = nMinus; if (i != 0) A[i-1][i-1] += G; if (j != 0) A[j-1][j-1] += G; if (i != 0 && j != 0) { A[i-1][j-1] -= G; A[j-1][i-1] -= G; } if (i != 0) b[i-1] += -Ieq; // sign is opposite of capacitor! if (j != 0) b[j-1] += Ieq; }
};
class Diode : public Element {
public:
string model;
Diode(string nm, int a, int b, string mdl)
: Element(Element::DIO, std::move(nm), a, b), model(std::move(mdl)) {
if (!iequals(model, "D")) {
throw runtime_error("Error: Unsupported diode model (“" + model + "”) in " + name + ".");
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
int i = nPlus, j = nMinus;
text// look up the extra row for this diode’s 0.7 V source auto it = vsMap.find(name); int vsIdx = it->second; int rowVS = nNode + vsIdx; double g = 1.0 / SMALL_RESISTANCE_R;
// —— stamp R_s between rowVS and node i (nPlus) ——
if (i != 0) {
A[rowVS][rowVS] += g;
A[i - 1][i - 1] += g;
A[rowVS][i - 1] -= g;
A[i - 1][rowVS] -= g;
}
// —— stamp R_s between rowVS and node j (nMinus) ——
if (j != 0) {
A[rowVS][rowVS] += g;
A[j - 1][j - 1] += g;
A[rowVS][j - 1] -= g;
A[j - 1][rowVS] -= g;
}
// —— now enforce the 0.7 V drop as before ——
if (i != 0) A[rowVS][i - 1] += +1.0;
if (j != 0) A[rowVS][j - 1] += -1.0;
b[rowVS] = DEFAULT_DIODE_DROP;
if (i != 0) A[i - 1][rowVS] += +1.0;
if (j != 0) A[j - 1][rowVS] += -1.0;
}
};
class VoltageSource : public Element {
public:
double Vdc;
VoltageSource(string nm, int a, int b, double val)
: Element(Element::VS, std::move(nm), a, b), Vdc(val) {
if (!(name.size()>0 && (name[0]=='V' || name[0]=='v'))) {
throw runtime_error("Error: Voltage source name must start with 'V': " + name);
}
}
void stamp(vector<vector<double>> &A,vector<double> &b,int nNode , const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(name);
if (it == vsMap.end()) {
throw runtime_error("Error: VS index not found for " + name + ".");
}
int vsIndex = it->second;
int rowVS = nNode + vsIndex;
int i = nPlus, j = nMinus;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
b[rowVS] = Vdc;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};
class CurrentSource : public Element {
public:
double I;
CurrentSource(string nm, int a, int b, double val)
: Element(Element::IS, std::move(nm), a, b), I(val) {
if (!(name.size()>0 && (name[0]=='I' || name[0]=='i'))) {
throw runtime_error("Error: Current source name must start with 'I': " + name);
}
}
void stamp(vector<vector<double>> & /A/,
vector<double> &b,
int /nNode/,
const unordered_map<string,int> & /vsMap/) const override {
int i = nPlus, j = nMinus;
if (i != 0) b[i-1] += -I;
if (j != 0) b[j-1] += +I;
}
};
class VCVS : public Element {
public:
int ctrlP, ctrlM;
double gain;
VCVS(string nm, int a, int b, int cp, int cm, double gv): Element(Element::VCVS, std::move(nm), a, b), ctrlP(cp), ctrlM(cm), gain(gv) {
if (!(name.size()>0 && (name[0]=='E' || name[0]=='e'))) {
throw runtime_error("Error: VCVS name must start with 'E': " + name);
}
}
void stamp(vector<vector<double>> &A,vector<double>&b,int nNode,const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(name);
if (it == vsMap.end()) {
throw runtime_error("Error: VCVS index not found for " + name + ".");
}
int vsIndex = it->second;
int rowVS = nNode + vsIndex;
int i = nPlus, j = nMinus;
int cp = ctrlP, cm = ctrlM;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
if (cp != 0) A[rowVS][cp-1] += -gain;
if (cm != 0) A[rowVS][cm-1] += +gain;
b[rowVS] = 0.0;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};
class CCCS : public Element {
public:
string ctrlVSname;
double gain;
CCCS(string nm, int a, int b, string cvs, double gv)
: Element(Element::CCCS, std::move(nm), a, b), ctrlVSname(std::move(cvs)), gain(gv) {
if (!(name.size()>0 && (name[0]=='F' || name[0]=='f'))) {
throw runtime_error("Error: CCCS name must start with 'F': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
auto it = vsMap.find(ctrlVSname);
if (it == vsMap.end()) {
throw runtime_error("Error: controlling VS '" + ctrlVSname + "' not found for " + name + ".");
}
int ctrlIdx = it->second;
int colCtrl = nNode + ctrlIdx;
int i = nPlus, j = nMinus;
if (i != 0) A[i-1][colCtrl] += -gain;
if (j != 0) A[j-1][colCtrl] += +gain;
}
};
class CCVS : public Element {
public:
string ctrlVSname;
double gain;
CCVS(string nm, int a, int b, string cvs, double gv)
: Element(Element::CCVS, std::move(nm), a, b), ctrlVSname(std::move(cvs)), gain(gv) {
if (!(name.size()>0 && (name[0]=='H' || name[0]=='h'))) {
throw runtime_error("Error: CCVS name must start with 'H': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> &vsMap) const override {
auto itSelf = vsMap.find(name);
if (itSelf == vsMap.end()) {
throw runtime_error("Error: CCVS index not found for " + name + ".");
}
int vsIndex = itSelf->second;
int rowVS = nNode + vsIndex;
auto itCtrl = vsMap.find(ctrlVSname);
if (itCtrl == vsMap.end()) {
throw runtime_error("Error: controlling VS '" + ctrlVSname + "' not found for " + name + ".");
}
int ctrlIdx = itCtrl->second;
int colCtrl = nNode + ctrlIdx;
int i = nPlus, j = nMinus;
if (i != 0) A[rowVS][i-1] = +1.0;
if (j != 0) A[rowVS][j-1] = -1.0;
A[rowVS][colCtrl] = -gain;
b[rowVS] = 0.0;
if (i != 0) A[i-1][rowVS] += +1.0;
if (j != 0) A[j-1][rowVS] += -1.0;
}
};
class VCCS : public Element {
public:
int ctrlP, ctrlM;
double gain;
VCCS(string nm, int a, int b, int cp, int cm, double gv)
: Element(Element::VCCS, std::move(nm), a, b), ctrlP(cp), ctrlM(cm), gain(gv) {
if (!(name.size()>0 && (name[0]=='G' || name[0]=='g'))) {
throw runtime_error("Error: VCCS name must start with 'G': " + name);
}
}
void stamp(vector<vector<double>> &A,
vector<double> &b,
int nNode,
const unordered_map<string,int> & /vsMap/) const override {
int i = nPlus, j = nMinus;
int cp = ctrlP, cm = ctrlM;
if (i != 0 && cp != 0) A[i-1][cp-1] += +gain;
if (i != 0 && cm != 0) A[i-1][cm-1] += -gain;
if (j != 0 && cp != 0) A[j-1][cp-1] += -gain;
if (j != 0 && cm != 0) A[j-1][cm-1] += +gain;
}
};
/**************************************************************************************************
-
PRINT REQUEST STRUCTURE (Section 15)
**************************************************************************************************/
struct PrintRequest {
enum Mode { DC, TRAN } mode;
string sourceName; // نام منبع ولتاژ برای DC sweep
double startVal, endVal, step;
vector<string> variables; // لیستی از عبارت‌های V(<node>) یا I(<element>)
};
/**************************************************************************************************
-
CIRCUIT CLASS: Holds elements & parsing
************************************************************************************************/
class Circuit {
public:
NodeMap nodes;
vector< unique_ptr<Element> > elements;
unordered_map<string,int> vsMap;
bool readingDone = false;
vector<PrintRequest> printRequests;
/
* parseLine:
* پارس یک خط از نت‌لیست و اعمال دستورهای متنی.
* پشتیبانی از:
* add R,C,L,D,V,I,E,F,H,G
* delete <elementName>
* .nodes
* .list <type>
* rename <oldNode> <newNode>
* .print DC ...
* .end
/
/ saved state for C & L (keys = element name) */
std::unordered_mapstd::string,double capVPrev;
std::unordered_mapstd::string,double indIPrev;
void parseLine(const string &line) {
char first = toupper(line[0]);
if (first == 'R' || first == 'C' || first == 'L' || first == 'D'||
first == 'V' || first == 'I' || first == 'E' || first == 'F' ||
first == 'H' || first == 'G') {
parseLine("add " + line);
return;
}
if (line.empty()) return;
vector<string> tok = tokenize(line);
if (tok.empty()) return;
string cmd = tok[0];
text// ===== دستور add ===== if (istarts_with(cmd, "add")) { if (tok.size() < 2) { throw runtime_error("Syntax error: 'add' needs arguments."); } string elemName = tok[1]; char c0 = toupper(elemName[0]); // اگر نوع V باشد و عبارت SIN در خط موجود باشد، آفست را استخراج کرده و // tok را به معادل DC بازسازی می‌کنیم: double sinOffset = nan(""); if (c0 == 'V') { sinOffset = parseSINOffset(line); if (!isnan(sinOffset)) { // بازسازی tok به صورت: add elemName n+ n- DC <sinOffset> if (tok.size() < 4) { throw runtime_error("Syntax error in SIN voltage source: " + line); } tok = { "add", elemName, tok[2], tok[3], "DC", to_string(sinOffset) }; } } if (c0 == 'R') { // فرمت: add R<name> n+ n- <value> if (tok.size() != 5) { throw runtime_error("Syntax error in resistor definition: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); double val = toDouble(tok[4]); elements.emplace_back(new Resistor(elemName, n1, n2, val)); } else if (c0 == 'C') { // فرمت: add C<name> n+ n- <value> if (tok.size() != 5) { throw runtime_error("Syntax error in capacitor definition: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); double val = toDouble(tok[4]); elements.emplace_back(new Capacitor(elemName, n1, n2, val)); } else if (c0 == 'L') { // فرمت: add L<name> n+ n- <value> if (tok.size() != 5) { throw runtime_error("Syntax error in inductor definition: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); double val = toDouble(tok[4]); elements.emplace_back(new Inductor(elemName, n1, n2, val)); } else if (c0 == 'D') { // فرمت: add D<name> n+ n- <model> if (tok.size() < 4 || tok.size() > 5) { throw runtime_error("Syntax error in diode definition: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); string mdl = (tok.size() == 5 ? tok[4] : "D"); elements.emplace_back(new Diode(elemName, n1, n2, mdl)); } else if (c0 == 'V') { // حالا tok به صورت: [ "add", elemName, n+, n-, "DC", val ] است if (tok.size() != 6 || !iequals(tok[4], "DC")) { throw runtime_error("Syntax error in voltage source: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); double val = toDouble(tok[5]); elements.emplace_back(new VoltageSource(elemName, n1, n2, val)); } else if (c0 == 'I') { // فرمت: add I<name> n+ n- DC <value> if (tok.size() != 6 || !iequals(tok[4], "DC")) { throw runtime_error("Syntax error in current source: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); double val = toDouble(tok[5]); elements.emplace_back(new CurrentSource(elemName, n1, n2, val)); } else if (c0 == 'E') { // فرمت: add E<name> n+ n- c+ c- <gain> if (tok.size() != 7) { throw runtime_error("Syntax error in VCVS: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); int cp = nodes.getIdx(tok[4]); int cm = nodes.getIdx(tok[5]); double g = toDouble(tok[6]); elements.emplace_back(new VCVS(elemName, n1, n2, cp, cm, g)); } else if (c0 == 'F') { // فرمت: add F<name> n+ n- <ctrlVS> <gain> if (tok.size() != 6) { throw runtime_error("Syntax error in CCCS: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); string cvs = tok[4]; double g = toDouble(tok[5]); elements.emplace_back(new CCCS(elemName, n1, n2, cvs, g)); } else if (c0 == 'H') { // فرمت: add H<name> n+ n- <ctrlVS> <gain> if (tok.size() != 6) { throw runtime_error("Syntax error in CCVS: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); string cvs = tok[4]; double g = toDouble(tok[5]); elements.emplace_back(new CCVS(elemName, n1, n2, cvs, g)); } else if (c0 == 'G') { // فرمت: add G<name> n+ n- c+ c- <gain> if (tok.size() != 7) { throw runtime_error("Syntax error in VCCS: " + line); } int n1 = nodes.getIdx(tok[2]); int n2 = nodes.getIdx(tok[3]); int cp = nodes.getIdx(tok[4]); int cm = nodes.getIdx(tok[5]); double g = toDouble(tok[6]); elements.emplace_back(new VCCS(elemName, n1, n2, cp, cm, g)); } else { throw runtime_error("Unknown element type in 'add': " + elemName); } } // ===== دستور delete ===== else if (istarts_with(cmd, "delete")) { // فرمت: delete <elementName> if (tok.size() != 2) { throw runtime_error("Syntax error: 'delete' requires exactly one argument."); } string enm = tok[1]; bool found = false; for (auto it = elements.begin(); it != elements.end(); ++it) { if (iequals((*it)->name, enm)) { elements.erase(it); found = true; break; } } if (!found) { throw runtime_error("Error: element '" + enm + "' not found."); } } // ===== دستور .nodes ===== else if (iequals(cmd, ".nodes")) { printNodes(); } // ===== دستور .list ===== else if (iequals(cmd, ".list")) { if (tok.size() != 2) { throw runtime_error("Syntax error: '.list' requires exactly one type argument."); } printList(tok[1]); } // ===== دستور rename ===== else if (iequals(cmd, "rename")) { if (tok.size() != 3) { throw runtime_error("Syntax error: 'rename' requires two arguments."); } nodes.renameNode(tok[1], tok[2]); } // ===== دستور .print ===== (بخش 15) else if (iequals(cmd, ".print")) { if (tok.size() < 7) { throw runtime_error("Syntax error in .print command: " + line); } PrintRequest pr; if (iequals(tok[0], ".print") && iequals(tok[1], "DC") && tok.size() >= 3 && tok.size() < 7) { pr.mode = PrintRequest::DC; pr.sourceName = ""; // منبع sweep وجود ندارد pr.startVal = 0; pr.endVal = 0; pr.step = 0; for (size_t i = 2; i < tok.size(); ++i) { pr.variables.push_back(tok[i]); } printRequests.push_back(move(pr)); return; } if (iequals(tok[1], "DC")) { pr.mode = PrintRequest::DC; if (tok.size() >= 7) { pr.sourceName = tok[2]; pr.startVal = toDouble(tok[3]); pr.endVal = toDouble(tok[4]); pr.step = toDouble(tok[5]); for (int i = 6; i < tok.size(); i++) pr.variables.push_back(tok[i]); } else { // پشتیبانی از .print DC بدون sweep pr.sourceName = ""; pr.startVal = pr.endVal = pr.step = 0; for (int i = 2; i < tok.size(); i++) pr.variables.push_back(tok[i]); } } else if (iequals(tok[1], "TRAN")) { pr.mode = PrintRequest::TRAN; pr.startVal = toDouble(tok[2]); // tstep pr.endVal = toDouble(tok[3]); // tstop pr.step = toDouble(tok[2]); // store tstep again double tstart = toDouble(tok[4]); // often 0 double tmax = toDouble(tok[5]); // ignored for now // vars begin at tok[6] for (size_t i=6;i<tok.size();++i) pr.variables.push_back(tok[i]); pr.sourceName = ""; // not used in TRAN } else { throw runtime_error("Only DC .print is supported in this version: " + line); } printRequests.push_back(move(pr)); } // ===== دستور .end ===== else if (iequals(cmd, ".end")) { readingDone = true; } else { throw runtime_error("Unknown command: " + line); } } /** * solveDC: * پس از دریافت دستور .end، ماتریس MNA را می‌سازد، حل می‌کند و نتایج را چاپ می‌کند. * اگر دستورات .print وجود داشته باشد، به جای یک‌بار حل، برای هر PrintRequest حل مکرر اجرا می‌شود. */ void solveDC() { // 1) ساخت vsMap: نگاشت نام منابع ولتاژ (شامل دیود و منابع وابسته) به یک ایندکس vsMap.clear(); int M = 0; for (const auto &e: elements) { if (e->type == Element::VS || e->type == Element::DIO || e->type == Element::VCVS || e->type == Element::CCVS) { vsMap[e->name] = M++; } } int totalNodes = nodes.count(); // شامل گره 0 int nNode = totalNodes - 1; // تعداد گره‌های واقعی (بدون گره زمین) int N = nNode + M; // ابعاد ماتریس A و بردار b // اگر هیچ دستور .print تعریف نشده، یک بار حل کن و چاپ کن if (printRequests.empty()) { bool hasSweep = false; for (const auto &pr: printRequests) if (pr.mode == PrintRequest::DC && !pr.sourceName.empty()) hasSweep = true; if (!hasSweep) { vector<vector<double>> A(N, vector<double>(N, 0.0)); vector<double> b(N, 0.0); for (const auto &e: elements) { e->stamp(A, b, nNode, vsMap); } vector<double> x = gaussianEliminate(A, b); for (const auto& pr : printRequests) { if (pr.mode != PrintRequest::DC || !pr.variables.size()) continue; cout << "\n--- Custom DC Output ---\n"; for (const auto &var: pr.variables) { if (istarts_with(var, "V(") && var.back() == ')') { string nodeName = var.substr(2, var.size() - 3); if (!nodes.hasName(nodeName)) { cout << "V(" << nodeName << "): ERROR - Node not found\n"; } else { int idx = nodes.name2idx.at(nodeName); double Vnode = (idx == 0 ? 0.0 : x[idx - 1]); cout << "V(" << nodeName << "): " << Vnode << " V\n"; } } else if (istarts_with(var, "I(") && var.back() == ')') { string elemName = var.substr(2, var.size() - 3); bool printed = false; if (vsMap.count(elemName)) { int vsIdx = vsMap.at(elemName); double Ielem = x[nNode + vsIdx]; cout << "I(" << elemName << "): " << Ielem << " A\n"; printed = true; } else { for (const auto& e : elements) { if (iequals(e->name, elemName)) { if (e->type == Element::RES) { auto* r = static_cast<Resistor*>(e.get()); int np = r->nPlus, nm = r->nMinus; double Vp = (np == 0 ? 0.0 : x[np - 1]); double Vm = (nm == 0 ? 0.0 : x[nm - 1]); double Ires = (Vp - Vm) / r->R; cout << "I(" << elemName << "): " << Ires << " A\n"; printed = true; } else if (e->type == Element::IS) { auto* isrc = static_cast<CurrentSource*>(e.get()); cout << "I(" << elemName << "): " << isrc->I << " A\n"; printed = true; } break; } } } if (!printed) { cout << "I(" << elemName << "): ERROR - Element not found\n"; } } else { cout << var << ": ERROR - Invalid variable\n"; } } cout << "--- End Custom DC Output ---\n"; } cout << fixed << setprecision(6); cout << "\n=== DC Operating-Point ===\n"; for (int i = 1; i < totalNodes; i++) { cout << "Node " << nodes.idx2name[i] << " (idx " << i << "): " << x[i - 1] << " V\n"; } cout << "Node 0 (GND): 0.000000 V\n"; for (const auto &p: vsMap) { const string &nm = p.first; int idx = p.second; double Iv = x[nNode + idx]; cout << "I(" << nm << "): " << Iv << " A\n"; } cout << "=== End of Results ===\n"; return; } // 2) برای هر دستور .print DC، یک loop از startVal تا endVal اجرا کن (شامل هر دو) با گام step else { for (const auto &pr: printRequests) if (pr.mode == PrintRequest::TRAN) simulateTRAN(pr.step, pr.endVal, pr.startVal, pr.variables); else if (pr.mode == PrintRequest::DC) { // چک کن که منبع ولتاژ وجود دارد const string &src = pr.sourceName; bool foundVS = false; VoltageSource *vsPtr = nullptr; for (auto &e: elements) { if (iequals(e->name, src) && e->type == Element::VS) { vsPtr = static_cast<VoltageSource *>(e.get()); foundVS = true; break; } } if (!foundVS) { cout << "ERROR: Voltage source '" << src << "' not found in circuit\n"; continue; } // چاپ عنوان جدول cout << "\n=== DC Sweep: Source " << src << " from " << pr.startVal << " to " << pr.endVal << " step " << pr.step << " ===\n"; // چاپ هدر: نام منبع، سپس هر متغیر cout << src; for (const auto &var: pr.variables) { cout << "\t" << var; } cout << "\n"; // حلقهٔ Sweep for (double Vsrc = pr.startVal; Vsrc <= pr.endVal + EPS; Vsrc += pr.step) { // تنظیم مقدار منبع ولتاژ روی Vsrc vsPtr->Vdc = Vsrc; // ساختن ماتریس و بردار برای هر تکرار vector<vector<double>> A(N, vector<double>(N, 0.0)); vector<double> b(N, 0.0); for (const auto &e: elements) { e->stamp(A, b, nNode, vsMap); } vector<double> x = gaussianEliminate(A, b); // چاپ خط: مقدار منبع، سپس مقادیر متغیرهای خواسته‌شده cout << fixed << setprecision(6) << Vsrc; for (const auto &var: pr.variables) { // متغیرهای ولتاژ: V(node) if (istarts_with(var, "V(") && var.back() == ')') { string nodeName = var.substr(2, var.size() - 3); if (!nodes.hasName(nodeName)) { cout << "\t" << "ERROR: Node " << nodeName << " not found"; } else { int idx = nodes.name2idx.at(nodeName); double Vnode = (idx == 0 ? 0.0 : x[idx - 1]); cout << "\t" << Vnode; } } // متغیرهای جریان: I(element) else if (istarts_with(var, "I(") && var.back() == ')') { string elemName = var.substr(2, var.size() - 3); bool printed = false; // 1) اگر المان در vsMap (منابع ولتاژ/دیود/VCVS/CCVS) بود: if (vsMap.count(elemName)) { int vsIdx = vsMap.at(elemName); double Ielem = x[nNode + vsIdx]; cout << "\t" << Ielem; printed = true; } else { // 2) جست‌وجو در لیست المان‌ها برای مقاومت یا منبع جریان for (const auto &e: elements) { if (iequals(e->name, elemName)) { if (e->type == Element::RES) { // جریان مقاومت = (V(nPlus) - V(nMinus)) / R Resistor *rptr = static_cast<Resistor *>(e.get()); int np = rptr->nPlus, nm = rptr->nMinus; double Vp = (np == 0 ? 0.0 : x[np - 1]); double Vm = (nm == 0 ? 0.0 : x[nm - 1]); double Ires = (Vp - Vm) / rptr->R; cout << "\t" << Ires; printed = true; } else if (e->type == Element::IS) { // جریان منبع جریان مستقل: همان مقدار I CurrentSource *iptr = static_cast<CurrentSource *>(e.get()); cout << "\t" << iptr->I; printed = true; } // برای سایر انواع (مثلاً خازن/سلف) در DC منطق ساده نمی‌توان جریان را تعریف کرد break; } } } if (!printed) { cout << "\t" << "ERROR: Element " << elemName << " not found"; } } else { cout << "\t" << "ERROR: Invalid variable '" << var << "'"; } } cout << "\n"; } cout << "=== End of DC Sweep for " << src << " ===\n"; } } } } void simulateTRAN(double tstep, double tstop, double tstart, const std::vector<std::string>& vars) { // --- prepare constant info --- vsMap.clear(); int M = 0; for (const auto& e : elements) if (e->type == Element::VS || e->type == Element::DIO || e->type == Element::VCVS|| e->type == Element::CCVS) vsMap[e->name] = M++; int totalNodes = nodes.count(); int nNode = totalNodes - 1; int N = nNode + M; /* initialise past state to zero */ capVPrev.clear(); indIPrev.clear(); for (const auto& e : elements) if (e->type == Element::CAP) capVPrev[e->name] = 0.0; else if (e->type == Element::IND) indIPrev[e->name] = 0.0; std::cout << "Time"; for (const auto& v : vars) std::cout << '\t' << v; std::cout << '\n' << std::fixed << std::setprecision(6); // --- main time-loop --- for (double t = tstart; t <= tstop + EPS; t += tstep) { std::vector<std::vector<double>> A(N, std::vector<double>(N, 0.0)); std::vector<double> b(N, 0.0); // stamp every element (DC + transient part) for (const auto& e : elements) { e->stamp(A, b, nNode, vsMap); // DC part e->stampTransient(A, b, tstep, capVPrev, indIPrev, nNode, vsMap); // dynamic part } std::vector<double> x = gaussianEliminate(A, b); // ---- print requested variables ---- std::cout << t; for (const auto& var : vars) { if (startsWith(var, "V(") && var.back()==')') { // node voltage std::string node = extractNode(var); double v = (node=="0") ? 0.0 : x[nodes.name2idx[node]-1]; std::cout << '\t' << v; } else if (startsWith(var, "I(") && var.back()==')') { // element current std::string el = extractElement(var); double I = 0.0; if (vsMap.count(el)) // any device with extra MNA row I = x[nNode + vsMap[el]]; else { /* quick support for R, C, L, I */ for (const auto& e : elements) if (iequals(e->name, el)) { if (e->type == Element::RES) { auto* r = static_cast<Resistor*>(e.get()); double vp = (r->nPlus==0?0.0:x[r->nPlus-1]); double vn = (r->nMinus==0?0.0:x[r->nMinus-1]); I = (vp - vn)/r->R; } else if (e->type == Element::CAP){ auto* c = static_cast<Capacitor*>(e.get()); I = c->C / tstep * capVPrev[el]; }// approximate else if (e->type == Element::IND) I = indIPrev[el]; else if (e->type == Element::IS) I = static_cast<CurrentSource*>(e.get())->I; break; } } std::cout << '\t' << I; } else std::cout << "\tERR"; } std::cout << '\n'; for (const auto& e : elements) { if (e->type == Element::CAP) { auto* c = static_cast<Capacitor*>(e.get()); double vp = (c->nPlus==0?0.0:x[c->nPlus-1]); double vn = (c->nMinus==0?0.0:x[c->nMinus-1]); capVPrev[c->name] = vp - vn; // V[n+1] } else if (e->type == Element::IND) { auto* l = static_cast<Inductor*>(e.get()); double vp = (l->nPlus==0?0.0:x[l->nPlus-1]); double vn = (l->nMinus==0?0.0:x[l->nMinus-1]); double vL = vp - vn; indIPrev[l->name] += (tstep / l->L) * vL; // I[n+1] = I[n] + (dt/L)*v } } } }
public:
/**
* printNodes:
* چاپ لیست گره‌ها و اندیس‌هایشان.
*/
bool hasGroundNode() const {
return nodes.hasName("0");
}
bool isConnectedCircuit() const {
int n = nodes.count();
if (n <= 1) return true;
vector<vector<int>> adj(n);
for (const auto& e : elements) {
adj[e->nPlus].push_back(e->nMinus);
adj[e->nMinus].push_back(e->nPlus);
}
vector<bool> visited(n, false);
queue<int> q;
q.push(0);
visited[0] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : adj[u]) {
if (!visited[v]) {
visited[v] = true;
q.push(v);
}
}
}
return all_of(visited.begin(), visited.end(), [](bool v) { return v; });
}
bool hasDuplicateNames() const {
unordered_set<string> names;
for (const auto& e : elements) {
string up = e->name;
transform(up.begin(), up.end(), up.begin(), ::toupper);
if (!names.insert(up).second) return true;
}
return false;
}
void printNodes() const {
cout << "\n-- Node List --\n";
for (int i = 0; i < nodes.count(); i++) {
cout << "Index " << i << " : " << nodes.idx2name[i] << "\n";
}
cout << "-- End Node List --\n";
}
void printList(const string &typ) const {
char t0 = toupper(typ[0]);
cout << "\n-- Elements of type " << typ << " --\n";
for (const auto &e : elements) {
bool match = false;
switch (t0) {
case 'R': match = (e->type == Element::RES); break;
case 'C': match = (e->type == Element::CAP); break;
case 'L': match = (e->type == Element::IND); break;
case 'D': match = (e->type == Element::DIO); break;
case 'V': match = (e->type == Element::VS); break;
case 'I': match = (e->type == Element::IS); break;
case 'E': match = (e->type == Element::VCVS); break;
case 'F': match = (e->type == Element::CCCS); break;
case 'H': match = (e->type == Element::CCVS); break;
case 'G': match = (e->type == Element::VCCS); break;
default:
throw runtime_error("Unknown element type for '.list': " + typ);
}
if (match) {
cout << e->name << " : ";
cout << "nodes[" << nodes.idx2name[e->nPlus] << ", "
<< nodes.idx2name[e->nMinus] << "]\n";
}
}
cout << "-- End List --\n";
}
text/** * gaussianEliminate: * حل دستگاه خطی A·x = b با روش حذف گاوس و قطبیابی جزئی. * اگر ماتریس تکین باشد، runtime_error پرتاب می‌کند. */ vector<double> gaussianEliminate(vector<vector<double>> &A, vector<double> &b) { int n = (int)b.size(); for (int k = 0; k < n; k++) { int piv = k; for (int i = k+1; i < n; i++) { if (fabs(A[i][k]) > fabs(A[piv][k])) piv = i; } if (fabs(A[piv][k]) < EPS) { throw runtime_error("Singular matrix detected during solve."); } if (piv != k) { swap(A[k], A[piv]); swap(b[k], b[piv]); } double diag = A[k][k]; for (int j = k; j < n; j++) A[k][j] /= diag; b[k] /= diag; for (int i = k+1; i < n; i++) { double factor = A[i][k]; if (fabs(factor) < EPS) continue; for (int j = k; j < n; j++) { A[i][j] -= factor * A[k][j]; } b[i] -= factor * b[k]; } } vector<double> x(n, 0.0); for (int i = n-1; i >= 0; i--) { double sum = b[i]; for (int j = i+1; j < n; j++) { sum -= A[i][j] * x[j]; } x[i] = sum; } return x; }
};
/**************************************************************************************************
-
MAIN
**************************************************************************************************/
int main(int argc, char *argv[]) {
try {
vector<Circuit> schematics;
string command_menu;
textwhile(true) { cout << "\n=== Main Menu ===" << endl; cout << "1 - Create new schematic" << endl; cout << "2 - Open existing schematic" << endl; cout << "3 - Exit" << endl; cout << ">>> "; getline(cin, command_menu); if(command_menu == "1") { // Create new schematic Circuit ckt; cout << "\nEnter circuit commands (type '.end' to finish):" << endl; string line; while(true) { cout << ">>> "; getline(cin, line); if(iequals(line, ".end")) { try { // Validate circuit before solving if (!ckt.hasGroundNode()) { cout << "Error: No ground node (0) detected in the circuit." << endl; continue; } if (ckt.hasDuplicateNames()) { cout << "Error: Duplicate component names detected." << endl; continue; } if (!ckt.isConnectedCircuit()) { cout << "Error: Circuit is not fully connected." << endl; continue; } ckt.parseLine(line); // Parse the .end command ckt.solveDC(); schematics.push_back(move(ckt)); cout << "Schematic saved. Returning to main menu." << endl; break; } catch (const exception &ex) { cerr << "Error: " << ex.what() << endl; continue; } } else if(iequals(line, "-show existing schematics")) { showExistingSchematicsMenu(); continue; } try { ckt.parseLine(line); } catch (const exception &ex) { cerr << "Error: " << ex.what() << endl; } } } else if(command_menu == "2") { // Open existing schematic if(schematics.empty()) { cout << "No saved schematics available." << endl; continue; } cout << "\n=== Saved Schematics ===" << endl; for(size_t i = 0; i < schematics.size(); ++i) { cout << i+1 << " - Schematic " << i+1 << endl; } cout << "0 - Return to main menu" << endl; cout << ">>> "; string selection; getline(cin, selection); if(selection == "0") continue; try { size_t idx = stoul(selection) - 1; if(idx >= schematics.size()) { cout << "Invalid selection." << endl; continue; } // Display the selected schematic cout << "\n=== Schematic " << idx+1 << " ===" << endl; schematics[idx].printNodes(); // List all elements vector<string> types = {"R", "C", "L", "D", "V", "I", "E", "F", "H", "G"}; for(const auto& t : types) { schematics[idx].printList(t); } // Option to solve again cout << "\nSolve this schematic again? (y/n): "; string solve_choice; getline(cin, solve_choice); if(toLower(solve_choice) == "y") { try { schematics[idx].solveDC(); } catch (const exception &ex) { cerr << "Error solving circuit: " << ex.what() << endl; } } } catch (...) { cout << "Invalid input. Please enter a number." << endl; } } else if(command_menu == "3") { // Exit program cout << "Exiting program." << endl; break; } else { cout << "Invalid option. Please try again." << endl; } } } catch (const exception &ex) { cerr << "Fatal error: " << ex.what() << endl; return 1; } return 0;
}
edit and make the tran analysis alright
and make test case for that
do not fuck the code
思考
回答
Here’s a minimal set of changes to get the transient (TRAN) analysis running correctly, plus a simple RC‐circuit test case you can type in once you recompile.
1. Fixes to parseLine and .print TRAN handling
In your current parseLine, you treat any .print TRAN as long as tok.size() >= 7, but you don’t handle the case where the user issues a bare .print TRAN tstep tstop 0 tmax V(node) (i.e. without sweep). Let’s tighten that up:
diff--- a/your_file.cpp +++ b/your_file.cpp @@ class Circuit { else if (iequals(cmd, ".print")) { - if (tok.size() < 7) { + // require at least: .print TRAN tstep tstop tstart tmax var... + if (tok.size() < 6) { throw runtime_error("Syntax error in .print command: " + line); } - PrintRequest pr; + PrintRequest pr; if (iequals(tok[1], "TRAN")) { - pr.mode = PrintRequest::TRAN; - pr.startVal = toDouble(tok[2]); // tstep - pr.endVal = toDouble(tok[3]); // tstop - pr.step = toDouble(tok[2]); // store tstep again - double tstart = toDouble(tok[4]); // often 0 - double tmax = toDouble(tok[5]); // ignored for now - // vars begin at tok[6] - for (size_t i=6;i<tok.size();++i) pr.variables.push_back(tok[i]); - pr.sourceName = ""; // not used in TRAN + // .print TRAN <tstep> <tstop> <tstart> <tmax> <var>... + pr.mode = PrintRequest::TRAN; + double tstep = toDouble(tok[2]); + double tstop = toDouble(tok[3]); + double tstart = toDouble(tok[4]); + // you can ignore tok[5] (tmax) or validate if you like + pr.step = tstep; + pr.startVal = tstart; + pr.endVal = tstop; + pr.sourceName = ""; + for (size_t i = 6; i < tok.size(); ++i) + pr.variables.push_back(tok[i]); } else if (iequals(tok[1], "DC")) { // ... unchanged ... }
With that, pr.startVal will correctly be your starting time, and pr.step the time increment.
2. Modify simulateTRAN to use pr.startVal properly
Right now you loop for (double t = tstart; …) but you pass the arguments in the wrong order. Let’s rewrite its signature and call site in solveDC():
diff--- a/your_file.cpp +++ b/your_file.cpp @@ void solveDC() { - if (pr.mode == PrintRequest::TRAN) - simulateTRAN(pr.step, pr.endVal, pr.startVal, pr.variables); + if (pr.mode == PrintRequest::TRAN) + simulateTRAN(pr.startVal, pr.step, pr.endVal, pr.variables);
And update the definition:
diff--- a/your_file.cpp +++ b/your_file.cpp - void simulateTRAN(double tstep, double tstop, double tstart, - const std::vector<std::string>& vars) + void simulateTRAN(double tstart, double tstep, double tstop, + const std::vector<std::string>& vars) { - // --- main time-loop --- - for (double t = tstart; t <= tstop + EPS; t += tstep) { + std::cout << "Time"; + for (auto &v : vars) std::cout << '\t' << v; + std::cout << '\n' << std::fixed << std::setprecision(6); + + // --- main time-loop --- + for (double t = tstart; t <= tstop + EPS; t += tstep) { // build A, b, stamp everything exactly as before… // then print: - std::cout << t; + std::cout << t; for (auto &var : vars) { // your existing handling of V(...) and I(...) } std::cout << '\n'; // update capVPrev & indIPrev exactly as before }
3. A simple RC‐circuit test case
Recompile, then run your program and choose Create new schematic. At the prompt, paste:
textadd R1 1 0 1k add C1 1 0 1u add V1 1 0 DC 0 .print TRAN 1e-6 1e-3 0 0 V(1) .end
What this does:
- R1 from node 1 → ground with 1 kΩ
- C1 from node 1 → ground with 1 µF
- V1 from node 1 → ground, starting at 0 V DC (we’ll use the default small‐signal step)
- .print TRAN 1e-6 1e-3 0 0 V(1)
tstep = 1 µststop = 1 mststart = 0tmax(ignored)- record V(1)
You should see something like:
textTime V(1) 0.000000 0.000000 0.000001 0.632120 0.000002 0.864665 ... 0.001000 1.000000
which is the classic RC charging curve (τ = R·C = 1 ms).
With these tweaks, your transient loop uses the correct start/time‐step parameters, and the sample RC netlist will validate that everything’s wired up properly without “fucking” the rest of your code. Let me know how it runs!