Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-05-03 04:56:45 +03:00
Code Issues Actions 10 Packages Projects Releases Wiki Activity

netlist: improve localized storage. (nw)

Browse Source
This commit is contained in:
couriersud 2019-10-29 22:05:45 +01:00
parent ba05d863b1
commit cebd828fcd
9 changed files with 132 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
src/lib/netlist/solver/nld_matrix_solver.cpp
View File

@ -16,11 +16,11 @@ namespace devices
{ {
terms_for_net_t::terms_for_net_t(analog_net_t * net) terms_for_net_t::terms_for_net_t(analog_net_t * net)
: m_railstart(0) : m_last_V(0.0)
, m_last_V(0.0)
, m_DD_n_m_1(0.0) , m_DD_n_m_1(0.0)
, m_h_n_m_1(1e-12) , m_h_n_m_1(1e-12)
, m_net(net) , m_net(net)
, m_railstart(0)
{ {
} }
@ -70,8 +70,8 @@ namespace devices
for (auto & net : nets) for (auto & net : nets)
{ {
m_terms.push_back(plib::make_unique<terms_for_net_t>(net)); m_terms.emplace_back(net);
m_rails_temp.push_back(plib::make_unique<terms_for_net_t>()); m_rails_temp.emplace_back();
} }
for (std::size_t k = 0; k < nets.size(); k++) for (std::size_t k = 0; k < nets.size(); k++)
@ -121,7 +121,7 @@ namespace devices
net_proxy_output->net().add_terminal(*p); net_proxy_output->net().add_terminal(*p);
// FIXME: repeated calling - kind of brute force // FIXME: repeated calling - kind of brute force
net_proxy_output->net().rebuild_list(); net_proxy_output->net().rebuild_list();
log().debug("Added input\n"); log().debug("Added input {1}", net_proxy_output->name());
} }
break; break;
case detail::terminal_type::OUTPUT: case detail::terminal_type::OUTPUT:
@ -204,7 +204,7 @@ namespace devices
for (std::size_t k = 0; k < iN - 1; k++) for (std::size_t k = 0; k < iN - 1; k++)
for (std::size_t i = k+1; i < iN; i++) for (std::size_t i = k+1; i < iN; i++)
{ {
if ((static_cast<int>(m_terms[k]->m_railstart) - static_cast<int>(m_terms[i]->m_railstart)) * sort_order < 0) if ((static_cast<int>(m_terms[k].railstart()) - static_cast<int>(m_terms[i].railstart())) * sort_order < 0)
{ {
std::swap(m_terms[i], m_terms[k]); std::swap(m_terms[i], m_terms[k]);
} }
@ -217,11 +217,11 @@ namespace devices
/* rebuild */ /* rebuild */
for (auto &term : m_terms) for (auto &term : m_terms)
{ {
int *other = term->m_connected_net_idx.data(); int *other = term.m_connected_net_idx.data();
for (std::size_t i = 0; i < term->count(); i++) for (std::size_t i = 0; i < term.count(); i++)
//FIXME: this is weird //FIXME: this is weird
if (other[i] != -1) if (other[i] != -1)
other[i] = get_net_idx(&term->terms()[i]->connected_terminal()->net()); other[i] = get_net_idx(&term.terms()[i]->connected_terminal()->net());
} }
} }
@ -231,9 +231,9 @@ namespace devices
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
m_terms[k]->m_railstart = m_terms[k]->count(); m_terms[k].set_railstart(m_terms[k].count());
for (std::size_t i = 0; i < m_rails_temp[k]->count(); i++) for (std::size_t i = 0; i < m_rails_temp[k].count(); i++)
this->m_terms[k]->add_terminal(m_rails_temp[k]->terms()[i], m_rails_temp[k]->m_connected_net_idx.data()[i], false); this->m_terms[k].add_terminal(m_rails_temp[k].terms()[i], m_rails_temp[k].m_connected_net_idx.data()[i], false);
} }
// free all - no longer needed // free all - no longer needed
@ -246,20 +246,20 @@ namespace devices
/* create a list of non zero elements. */ /* create a list of non zero elements. */
for (unsigned k = 0; k < iN; k++) for (unsigned k = 0; k < iN; k++)
{ {
terms_for_net_t * t = m_terms[k].get(); terms_for_net_t & t = m_terms[k];
/* pretty brutal */ /* pretty brutal */
int *other = t->m_connected_net_idx.data(); int *other = t.m_connected_net_idx.data();
t->m_nz.clear(); t.m_nz.clear();
for (std::size_t i = 0; i < t->m_railstart; i++) for (std::size_t i = 0; i < t.railstart(); i++)
if (!plib::container::contains(t->m_nz, static_cast<unsigned>(other[i]))) if (!plib::container::contains(t.m_nz, static_cast<unsigned>(other[i])))
t->m_nz.push_back(static_cast<unsigned>(other[i])); t.m_nz.push_back(static_cast<unsigned>(other[i]));
t->m_nz.push_back(k); // add diagonal t.m_nz.push_back(k); // add diagonal
/* and sort */ /* and sort */
std::sort(t->m_nz.begin(), t->m_nz.end()); std::sort(t.m_nz.begin(), t.m_nz.end());
} }
/* create a list of non zero elements right of the diagonal /* create a list of non zero elements right of the diagonal
@ -268,30 +268,30 @@ namespace devices
*/ */
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
terms_for_net_t * t = m_terms[k].get(); terms_for_net_t & t = m_terms[k];
/* pretty brutal */ /* pretty brutal */
int *other = t->m_connected_net_idx.data(); int *other = t.m_connected_net_idx.data();
if (k==0) if (k==0)
t->m_nzrd.clear(); t.m_nzrd.clear();
else else
{ {
t->m_nzrd = m_terms[k-1]->m_nzrd; t.m_nzrd = m_terms[k-1].m_nzrd;
for (auto j = t->m_nzrd.begin(); j != t->m_nzrd.end(); ) for (auto j = t.m_nzrd.begin(); j != t.m_nzrd.end(); )
{ {
if (*j < k + 1) if (*j < k + 1)
j = t->m_nzrd.erase(j); j = t.m_nzrd.erase(j);
else else
++j; ++j;
} }
} }
for (std::size_t i = 0; i < t->m_railstart; i++) for (std::size_t i = 0; i < t.railstart(); i++)
if (!plib::container::contains(t->m_nzrd, static_cast<unsigned>(other[i])) && other[i] >= static_cast<int>(k + 1)) if (!plib::container::contains(t.m_nzrd, static_cast<unsigned>(other[i])) && other[i] >= static_cast<int>(k + 1))
t->m_nzrd.push_back(static_cast<unsigned>(other[i])); t.m_nzrd.push_back(static_cast<unsigned>(other[i]));
/* and sort */ /* and sort */
std::sort(t->m_nzrd.begin(), t->m_nzrd.end()); std::sort(t.m_nzrd.begin(), t.m_nzrd.end());
} }
/* create a list of non zero elements below diagonal k /* create a list of non zero elements below diagonal k
@ -304,8 +304,8 @@ namespace devices
{ {
for (std::size_t j = 0; j < iN; j++) for (std::size_t j = 0; j < iN; j++)
touched[k][j] = false; touched[k][j] = false;
for (std::size_t j = 0; j < m_terms[k]->m_nz.size(); j++) for (std::size_t j = 0; j < m_terms[k].m_nz.size(); j++)
touched[k][m_terms[k]->m_nz[j]] = true; touched[k][m_terms[k].m_nz[j]] = true;
} }
m_ops = 0; m_ops = 0;
@ -317,8 +317,8 @@ namespace devices
if (touched[row][k]) if (touched[row][k])
{ {
m_ops++; m_ops++;
if (!plib::container::contains(m_terms[k]->m_nzbd, row)) if (!plib::container::contains(m_terms[k].m_nzbd, row))
m_terms[k]->m_nzbd.push_back(row); m_terms[k].m_nzbd.push_back(row);
for (std::size_t col = k + 1; col < iN; col++) for (std::size_t col = k + 1; col < iN; col++)
if (touched[k][col]) if (touched[k][col])
{ {
@ -334,7 +334,7 @@ namespace devices
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
pstring line = plib::pfmt("{1:3}")(k); pstring line = plib::pfmt("{1:3}")(k);
for (const auto & nzrd : m_terms[k]->m_nzrd) for (const auto & nzrd : m_terms[k].m_nzrd)
line += plib::pfmt(" {1:3}")(nzrd); line += plib::pfmt(" {1:3}")(nzrd);
log().verbose("{1}", line); log().verbose("{1}", line);
} }
@ -346,14 +346,14 @@ namespace devices
{ {
pstring num = plib::pfmt("{1}")(k); pstring num = plib::pfmt("{1}")(k);
state().save(*this, m_terms[k]->m_last_V, this->name(), "lastV." + num); state().save(*this, m_terms[k].m_last_V, this->name(), "lastV." + num);
state().save(*this, m_terms[k]->m_DD_n_m_1, this->name(), "m_DD_n_m_1." + num); state().save(*this, m_terms[k].m_DD_n_m_1, this->name(), "m_DD_n_m_1." + num);
state().save(*this, m_terms[k]->m_h_n_m_1, this->name(), "m_h_n_m_1." + num); state().save(*this, m_terms[k].m_h_n_m_1, this->name(), "m_h_n_m_1." + num);
// FIXME: This shouldn't be necessary, recalculate on each entry ... // FIXME: This shouldn't be necessary, recalculate on each entry ...
state().save(*this, m_gonn[k],"GO" + num, this->name(), m_terms[k]->count()); state().save(*this, m_gonn[k],"GO" + num, this->name(), m_terms[k].count());
state().save(*this, m_gtn[k],"GT" + num, this->name(), m_terms[k]->count()); state().save(*this, m_gtn[k],"GT" + num, this->name(), m_terms[k].count());
state().save(*this, m_Idrn[k],"IDR" + num, this->name(), m_terms[k]->count()); state().save(*this, m_Idrn[k],"IDR" + num, this->name(), m_terms[k].count());
} }
} }
@ -460,10 +460,10 @@ namespace devices
return next_time_step; return next_time_step;
} }
int matrix_solver_t::get_net_idx(const analog_net_t *net) const int matrix_solver_t::get_net_idx(const analog_net_t *net) const noexcept
{ {
for (std::size_t k = 0; k < m_terms.size(); k++) for (std::size_t k = 0; k < m_terms.size(); k++)
if (m_terms[k]->isNet(net)) if (m_terms[k].isNet(net))
return static_cast<int>(k); return static_cast<int>(k);
return -1; return -1;
} }
@ -483,9 +483,9 @@ namespace devices
auto &term = m_terms[irow]; auto &term = m_terms[irow];
for (std::size_t i = 0; i < term->count(); i++) for (std::size_t i = 0; i < term.count(); i++)
{ {
auto col = get_net_idx(&term->terms()[i]->connected_terminal()->net()); auto col = get_net_idx(&term.terms()[i]->connected_terminal()->net());
if (col != -1) if (col != -1)
{ {
if (col==row) col = diag; if (col==row) col = diag;
@ -511,9 +511,9 @@ namespace devices
double weight = 0.0; double weight = 0.0;
auto &term = m_terms[row]; auto &term = m_terms[row];
for (std::size_t i = 0; i < term->count(); i++) for (std::size_t i = 0; i < term.count(); i++)
{ {
auto col = get_net_idx(&term->terms()[i]->connected_terminal()->net()); auto col = get_net_idx(&term.terms()[i]->connected_terminal()->net());
if (col >= 0) if (col >= 0)
{ {
auto colu = static_cast<std::size_t>(col); auto colu = static_cast<std::size_t>(col);
@ -527,7 +527,7 @@ namespace devices
} }
} }
} }
return weight; // / static_cast<double>(term->m_railstart); return weight; // / static_cast<double>(term.railstart());
} }
} }
@ -535,19 +535,19 @@ namespace devices
{ {
if (term->connected_terminal()->net().isRailNet()) if (term->connected_terminal()->net().isRailNet())
{ {
m_rails_temp[k]->add_terminal(term, -1, false); m_rails_temp[k].add_terminal(term, -1, false);
} }
else else
{ {
int ot = get_net_idx(&term->connected_terminal()->net()); int ot = get_net_idx(&term->connected_terminal()->net());
if (ot>=0) if (ot>=0)
{ {
m_terms[k]->add_terminal(term, ot, true); m_terms[k].add_terminal(term, ot, true);
} }
/* Should this be allowed ? */ /* Should this be allowed ? */
else // if (ot<0) else // if (ot<0)
{ {
m_rails_temp[k]->add_terminal(term, ot, true); m_rails_temp[k].add_terminal(term, ot, true);
log().fatal(MF_FOUND_TERM_WITH_MISSING_OTHERNET(term->name())); log().fatal(MF_FOUND_TERM_WITH_MISSING_OTHERNET(term->name()));
} }
} }
@ -563,15 +563,15 @@ namespace devices
{ {
//const nl_double DD_n = (n->Q_Analog() - t->m_last_V); //const nl_double DD_n = (n->Q_Analog() - t->m_last_V);
// avoid floating point exceptions // avoid floating point exceptions
const nl_double DD_n = std::max(-1e100, std::min(1e100,(t->getV() - t->m_last_V))); const nl_double DD_n = std::max(-1e100, std::min(1e100,(t.getV() - t.m_last_V)));
const nl_double hn = cur_ts; const nl_double hn = cur_ts;
//printf("%g %g %g %g\n", DD_n, hn, t->m_DD_n_m_1, t->m_h_n_m_1); //printf("%g %g %g %g\n", DD_n, hn, t.m_DD_n_m_1, t.m_h_n_m_1);
nl_double DD2 = (DD_n / hn - t->m_DD_n_m_1 / t->m_h_n_m_1) / (hn + t->m_h_n_m_1); nl_double DD2 = (DD_n / hn - t.m_DD_n_m_1 / t.m_h_n_m_1) / (hn + t.m_h_n_m_1);
nl_double new_net_timestep(0); nl_double new_net_timestep(0);
t->m_h_n_m_1 = hn; t.m_h_n_m_1 = hn;
t->m_DD_n_m_1 = DD_n; t.m_DD_n_m_1 = DD_n;
if (std::fabs(DD2) > plib::constants<nl_double>::cast(1e-60)) // avoid div-by-zero if (std::fabs(DD2) > plib::constants<nl_double>::cast(1e-60)) // avoid div-by-zero
new_net_timestep = std::sqrt(m_params.m_dynamic_lte / std::fabs(plib::constants<nl_double>::cast(0.5)*DD2)); new_net_timestep = std::sqrt(m_params.m_dynamic_lte / std::fabs(plib::constants<nl_double>::cast(0.5)*DD2));
else else
@ -580,7 +580,7 @@ namespace devices
if (new_net_timestep < new_solver_timestep) if (new_net_timestep < new_solver_timestep)
new_solver_timestep = new_net_timestep; new_solver_timestep = new_net_timestep;
t->m_last_V = t->getV(); t.m_last_V = t.getV();
} }
if (new_solver_timestep < m_params.m_min_timestep) if (new_solver_timestep < m_params.m_min_timestep)
{ {

73
src/lib/netlist/solver/nld_matrix_solver.h
View File

@ -107,7 +107,7 @@ namespace devices
}; };
class terms_for_net_t : plib::nocopyassignmove class terms_for_net_t
{ {
public: public:
terms_for_net_t(analog_net_t * net = nullptr); terms_for_net_t(analog_net_t * net = nullptr);
@ -116,32 +116,36 @@ namespace devices
void add_terminal(terminal_t *term, int net_other, bool sorted); void add_terminal(terminal_t *term, int net_other, bool sorted);
std::size_t count() const { return m_terms.size(); } std::size_t count() const noexcept { return m_terms.size(); }
terminal_t **terms() { return m_terms.data(); } std::size_t railstart() const noexcept { return m_railstart; }
nl_double getV() const { return m_net->Q_Analog(); } terminal_t **terms() noexcept { return m_terms.data(); }
void setV(nl_double v) { m_net->set_Q_Analog(v); } nl_double getV() const noexcept { return m_net->Q_Analog(); }
bool isNet(const analog_net_t * net) const { return net == m_net; } void setV(nl_double v) noexcept { m_net->set_Q_Analog(v); }
std::size_t m_railstart; bool isNet(const analog_net_t * net) const noexcept { return net == m_net; }
std::vector<unsigned> m_nz; /* all non zero for multiplication */ void set_railstart(std::size_t val) noexcept { m_railstart = val; }
std::vector<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */
std::vector<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */ PALIGNAS_VECTOROPT()
plib::aligned_vector<unsigned> m_nz; /* all non zero for multiplication */
plib::aligned_vector<unsigned> m_nzrd; /* non zero right of the diagonal for elimination, may include RHS element */
plib::aligned_vector<unsigned> m_nzbd; /* non zero below of the diagonal for elimination */
/* state */ /* state */
nl_double m_last_V; nl_double m_last_V;
nl_double m_DD_n_m_1; nl_double m_DD_n_m_1;
nl_double m_h_n_m_1; nl_double m_h_n_m_1;
std::vector<int> m_connected_net_idx; plib::aligned_vector<int> m_connected_net_idx;
private: private:
analog_net_t * m_net; analog_net_t * m_net;
std::vector<terminal_t *> m_terms; plib::aligned_vector<terminal_t *> m_terms;
std::size_t m_railstart;
}; };
class proxied_analog_output_t : public analog_output_t class proxied_analog_output_t : public analog_output_t
@ -176,8 +180,8 @@ namespace devices
const netlist_time solve(netlist_time now); const netlist_time solve(netlist_time now);
void update_inputs(); void update_inputs();
bool has_dynamic_devices() const { return m_dynamic_devices.size() > 0; } bool has_dynamic_devices() const noexcept { return m_dynamic_devices.size() > 0; }
bool has_timestep_devices() const { return m_step_devices.size() > 0; } bool has_timestep_devices() const noexcept { return m_step_devices.size() > 0; }
void update_forced(); void update_forced();
void update_after(const netlist_time after) void update_after(const netlist_time after)
@ -190,7 +194,7 @@ namespace devices
NETLIB_RESETI(); NETLIB_RESETI();
public: public:
int get_net_idx(const analog_net_t *net) const; int get_net_idx(const analog_net_t *net) const noexcept;
std::pair<int, int> get_left_right_of_diag(std::size_t row, std::size_t diag); std::pair<int, int> get_left_right_of_diag(std::size_t row, std::size_t diag);
double get_weight_around_diag(std::size_t row, std::size_t diag); double get_weight_around_diag(std::size_t row, std::size_t diag);
@ -239,8 +243,8 @@ namespace devices
std::size_t max_rail = 0; std::size_t max_rail = 0;
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
max_count = std::max(max_count, m_terms[k]->count()); max_count = std::max(max_count, m_terms[k].count());
max_rail = std::max(max_rail, m_terms[k]->m_railstart); max_rail = std::max(max_rail, m_terms[k].railstart());
} }
m_mat_ptr.resize(iN, max_rail+1); m_mat_ptr.resize(iN, max_rail+1);
@ -251,12 +255,12 @@ namespace devices
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
auto count = m_terms[k]->count(); auto count = m_terms[k].count();
for (std::size_t i = 0; i < count; i++) for (std::size_t i = 0; i < count; i++)
{ {
m_terms[k]->terms()[i]->set_ptrs(&m_gtn[k][i], &m_gonn[k][i], &m_Idrn[k][i]); m_terms[k].terms()[i]->set_ptrs(&m_gtn[k][i], &m_gonn[k][i], &m_Idrn[k][i]);
m_connected_net_Vn[k][i] = m_terms[k]->terms()[i]->connected_terminal()->net().Q_Analog_state_ptr(); m_connected_net_Vn[k][i] = m_terms[k].terms()[i]->connected_terminal()->net().Q_Analog_state_ptr();
} }
} }
} }
@ -266,11 +270,11 @@ namespace devices
{ {
for (std::size_t k = 0; k < N; k++) for (std::size_t k = 0; k < N; k++)
{ {
auto *net = m_terms[k].get(); auto &net = m_terms[k];
auto **tcr_r = &(tcr[k][0]); auto **tcr_r = &(tcr[k][0]);
const std::size_t term_count = net->count(); const std::size_t term_count = net.count();
const std::size_t railstart = net->m_railstart; const std::size_t railstart = net.railstart();
const auto &go = m_gonn[k]; const auto &go = m_gonn[k];
const auto &gt = m_gtn[k]; const auto &gt = m_gtn[k];
const auto &Idr = m_Idrn[k]; const auto &Idr = m_Idrn[k];
@ -368,12 +372,11 @@ namespace devices
plib::pmatrix2d<nl_double *, aligned_alloc<nl_double *>> m_mat_ptr; plib::pmatrix2d<nl_double *, aligned_alloc<nl_double *>> m_mat_ptr;
plib::pmatrix2d<nl_double *, aligned_alloc<nl_double *>> m_connected_net_Vn; plib::pmatrix2d<nl_double *, aligned_alloc<nl_double *>> m_connected_net_Vn;
std::vector<plib::unique_ptr<terms_for_net_t>> m_terms; plib::aligned_vector<terms_for_net_t> m_terms;
plib::aligned_vector<terms_for_net_t> m_rails_temp;
std::vector<unique_pool_ptr<proxied_analog_output_t>> m_inps; std::vector<unique_pool_ptr<proxied_analog_output_t>> m_inps;
std::vector<plib::unique_ptr<terms_for_net_t>> m_rails_temp;
const solver_parameters_t &m_params; const solver_parameters_t &m_params;
state_var<int> m_stat_calculations; state_var<int> m_stat_calculations;
@ -410,7 +413,7 @@ namespace devices
const std::size_t iN = this->m_terms.size(); const std::size_t iN = this->m_terms.size();
typename std::decay<decltype(V[0])>::type cerr = 0; typename std::decay<decltype(V[0])>::type cerr = 0;
for (std::size_t i = 0; i < iN; i++) for (std::size_t i = 0; i < iN; i++)
cerr = std::max(cerr, std::abs(V[i] - this->m_terms[i]->getV())); cerr = std::max(cerr, std::abs(V[i] - this->m_terms[i].getV()));
return cerr; return cerr;
} }
@ -419,7 +422,7 @@ namespace devices
{ {
const std::size_t iN = this->m_terms.size(); const std::size_t iN = this->m_terms.size();
for (std::size_t i = 0; i < iN; i++) for (std::size_t i = 0; i < iN; i++)
this->m_terms[i]->setV(V[i]); this->m_terms[i].setV(V[i]);
} }
template <typename T> template <typename T>
@ -431,14 +434,14 @@ namespace devices
const std::size_t iN = child.size(); const std::size_t iN = child.size();
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
terms_for_net_t *terms = m_terms[k].get(); terms_for_net_t &terms = m_terms[k];
float_type * Ak = &child.A(k, 0ul); float_type * Ak = &child.A(k, 0ul);
for (std::size_t i=0; i < iN; i++) for (std::size_t i=0; i < iN; i++)
Ak[i] = 0.0; Ak[i] = 0.0;
const std::size_t terms_count = terms->count(); const std::size_t terms_count = terms.count();
const std::size_t railstart = terms->m_railstart; const std::size_t railstart = terms.railstart();
const float_type * const gt = m_gtn[k]; const float_type * const gt = m_gtn[k];
{ {
@ -450,7 +453,7 @@ namespace devices
} }
const float_type * const go = m_gonn[k]; const float_type * const go = m_gonn[k];
int * net_other = terms->m_connected_net_idx.data(); int * net_other = terms.m_connected_net_idx.data();
for (std::size_t i = 0; i < railstart; i++) for (std::size_t i = 0; i < railstart; i++)
Ak[net_other[i]] += go[i]; Ak[net_other[i]] += go[i];
@ -469,7 +472,7 @@ namespace devices
float_type rhsk_a = 0.0; float_type rhsk_a = 0.0;
float_type rhsk_b = 0.0; float_type rhsk_b = 0.0;
const std::size_t terms_count = m_terms[k]->count(); const std::size_t terms_count = m_terms[k].count();
const float_type * const go = m_gonn[k]; const float_type * const go = m_gonn[k];
const float_type * const Idr = m_Idrn[k]; const float_type * const Idr = m_Idrn[k];
const float_type * const * other_cur_analog = m_connected_net_Vn[k]; const float_type * const * other_cur_analog = m_connected_net_Vn[k];
@ -477,7 +480,7 @@ namespace devices
for (std::size_t i = 0; i < terms_count; i++) for (std::size_t i = 0; i < terms_count; i++)
rhsk_a = rhsk_a + Idr[i]; rhsk_a = rhsk_a + Idr[i];
for (std::size_t i = m_terms[k]->m_railstart; i < terms_count; i++) for (std::size_t i = m_terms[k].railstart(); i < terms_count; i++)
//rhsk = rhsk + go[i] * terms[i]->m_otherterm->net().as_analog().Q_Analog(); //rhsk = rhsk + go[i] * terms[i]->m_otherterm->net().as_analog().Q_Analog();
rhsk_b = rhsk_b - go[i] * *other_cur_analog[i]; rhsk_b = rhsk_b - go[i] * *other_cur_analog[i];

12
src/lib/netlist/solver/nld_ms_direct.h
View File

@ -73,10 +73,10 @@ namespace devices
/* add RHS element */ /* add RHS element */
for (std::size_t k = 0; k < size(); k++) for (std::size_t k = 0; k < size(); k++)
{ {
terms_for_net_t * t = m_terms[k].get(); terms_for_net_t & t = m_terms[k];
if (!plib::container::contains(t->m_nzrd, static_cast<unsigned>(size()))) if (!plib::container::contains(t.m_nzrd, static_cast<unsigned>(size())))
t->m_nzrd.push_back(static_cast<unsigned>(size())); t.m_nzrd.push_back(static_cast<unsigned>(size()));
} }
// FIXME: This shouldn't be necessary ... // FIXME: This shouldn't be necessary ...
@ -94,8 +94,8 @@ namespace devices
{ {
/* FIXME: Singular matrix? */ /* FIXME: Singular matrix? */
const FT f = 1.0 / A(i,i); const FT f = 1.0 / A(i,i);
const auto &nzrd = m_terms[i]->m_nzrd; const auto &nzrd = m_terms[i].m_nzrd;
const auto &nzbd = m_terms[i]->m_nzbd; const auto &nzbd = m_terms[i].m_nzbd;
for (auto j : nzbd) for (auto j : nzbd)
{ {
@ -178,7 +178,7 @@ namespace devices
for (std::size_t j = kN; j-- > 0; ) for (std::size_t j = kN; j-- > 0; )
{ {
FT tmp = 0; FT tmp = 0;
const auto &nzrd = m_terms[j]->m_nzrd; const auto &nzrd = m_terms[j].m_nzrd;
const auto e = nzrd.size() - 1; /* exclude RHS element */ const auto e = nzrd.size() - 1; /* exclude RHS element */
for ( std::size_t k = 0; k < e; k++) for ( std::size_t k = 0; k < e; k++)
tmp += A(j, nzrd[k]) * x[nzrd[k]]; tmp += A(j, nzrd[k]) * x[nzrd[k]];

12
src/lib/netlist/solver/nld_ms_gcr.h
View File

@ -90,7 +90,7 @@ namespace devices
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
fill[k].resize(iN, decltype(mat)::FILL_INFINITY); fill[k].resize(iN, decltype(mat)::FILL_INFINITY);
for (auto &j : this->m_terms[k]->m_nz) for (auto &j : this->m_terms[k].m_nz)
{ {
fill[k][j] = 0; fill[k][j] = 0;
raw_elements++; raw_elements++;
@ -108,9 +108,9 @@ namespace devices
{ {
std::size_t cnt(0); std::size_t cnt(0);
/* build pointers into the compressed row format matrix for each terminal */ /* build pointers into the compressed row format matrix for each terminal */
for (std::size_t j=0; j< this->m_terms[k]->m_railstart;j++) for (std::size_t j=0; j< this->m_terms[k].railstart();j++)
{ {
int other = this->m_terms[k]->m_connected_net_idx[j]; int other = this->m_terms[k].m_connected_net_idx[j];
for (auto i = mat.row_idx[k]; i < mat.row_idx[k+1]; i++) for (auto i = mat.row_idx[k]; i < mat.row_idx[k+1]; i++)
if (other == static_cast<int>(mat.col_idx[i])) if (other == static_cast<int>(mat.col_idx[i]))
{ {
@ -119,8 +119,8 @@ namespace devices
break; break;
} }
} }
nl_assert(cnt == this->m_terms[k]->m_railstart); nl_assert(cnt == this->m_terms[k].railstart());
m_mat_ptr[k][this->m_terms[k]->m_railstart] = &mat.A[mat.diag[k]]; m_mat_ptr[k][this->m_terms[k].railstart()] = &mat.A[mat.diag[k]];
} }
this->log().verbose("maximum fill: {1}", gr.first); this->log().verbose("maximum fill: {1}", gr.first);
@ -156,7 +156,7 @@ namespace devices
for (std::size_t i = 0; i < iN - 1; i++) for (std::size_t i = 0; i < iN - 1; i++)
{ {
const auto &nzbd = this->m_terms[i]->m_nzbd; const auto &nzbd = this->m_terms[i].m_nzbd;
if (nzbd.size() > 0) if (nzbd.size() > 0)
{ {

14
src/lib/netlist/solver/nld_ms_gmres.h
View File

@ -72,8 +72,8 @@ namespace devices
for (std::size_t k=0; k<iN; k++) for (std::size_t k=0; k<iN; k++)
{ {
fill[k].resize(iN, decltype(m_ops.m_mat)::FILL_INFINITY); fill[k].resize(iN, decltype(m_ops.m_mat)::FILL_INFINITY);
terms_for_net_t * row = this->m_terms[k].get(); terms_for_net_t & row = this->m_terms[k];
for (const auto &nz_j : row->m_nz) for (const auto &nz_j : row.m_nz)
{ {
fill[k][static_cast<mattype>(nz_j)] = 0; fill[k][static_cast<mattype>(nz_j)] = 0;
} }
@ -87,18 +87,18 @@ namespace devices
for (std::size_t k=0; k<iN; k++) for (std::size_t k=0; k<iN; k++)
{ {
std::size_t cnt = 0; std::size_t cnt = 0;
for (std::size_t j=0; j< this->m_terms[k]->m_railstart;j++) for (std::size_t j=0; j< this->m_terms[k].railstart();j++)
{ {
for (std::size_t i = m_ops.m_mat.row_idx[k]; i<m_ops.m_mat.row_idx[k+1]; i++) for (std::size_t i = m_ops.m_mat.row_idx[k]; i<m_ops.m_mat.row_idx[k+1]; i++)
if (this->m_terms[k]->m_connected_net_idx[j] == static_cast<int>(m_ops.m_mat.col_idx[i])) if (this->m_terms[k].m_connected_net_idx[j] == static_cast<int>(m_ops.m_mat.col_idx[i]))
{ {
this->m_mat_ptr[k][j] = &m_ops.m_mat.A[i]; this->m_mat_ptr[k][j] = &m_ops.m_mat.A[i];
cnt++; cnt++;
break; break;
} }
} }
nl_assert(cnt == this->m_terms[k]->m_railstart); nl_assert(cnt == this->m_terms[k].railstart());
this->m_mat_ptr[k][this->m_terms[k]->m_railstart] = &m_ops.m_mat.A[m_ops.m_mat.diag[k]]; this->m_mat_ptr[k][this->m_terms[k].railstart()] = &m_ops.m_mat.A[m_ops.m_mat.diag[k]];
} }
} }
@ -116,7 +116,7 @@ namespace devices
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
this->m_new_V[k] = this->m_terms[k]->getV(); this->m_new_V[k] = this->m_terms[k].getV();
} }
const float_type accuracy = this->m_params.m_accuracy; const float_type accuracy = this->m_params.m_accuracy;

10
src/lib/netlist/solver/nld_ms_sm.h
View File

@ -141,13 +141,13 @@ namespace devices
{ {
/* FIXME: Singular matrix? */ /* FIXME: Singular matrix? */
const float_type f = 1.0 / W(i,i); const float_type f = 1.0 / W(i,i);
const auto * const p = m_terms[i]->m_nzrd.data(); const auto * const p = m_terms[i].m_nzrd.data();
const std::size_t e = m_terms[i]->m_nzrd.size(); const std::size_t e = m_terms[i].m_nzrd.size();
/* Eliminate column i from row j */ /* Eliminate column i from row j */
const auto * const pb = m_terms[i]->m_nzbd.data(); const auto * const pb = m_terms[i].m_nzbd.data();
const std::size_t eb = m_terms[i]->m_nzbd.size(); const std::size_t eb = m_terms[i].m_nzbd.size();
for (std::size_t jb = 0; jb < eb; jb++) for (std::size_t jb = 0; jb < eb; jb++)
{ {
const unsigned j = pb[jb]; const unsigned j = pb[jb];
@ -236,7 +236,7 @@ namespace devices
{ {
std::size_t colcount = 0; std::size_t colcount = 0;
auto &nz = m_terms[row]->m_nz; auto &nz = m_terms[row].m_nz;
for (unsigned & col : nz) for (unsigned & col : nz)
{ {
v[col] = A(row,col) - lA(row,col); v[col] = A(row,col) - lA(row,col);

10
src/lib/netlist/solver/nld_ms_sor.h
View File

@ -84,13 +84,13 @@ unsigned matrix_solver_SOR_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_rap
float_type gabs_t = 0.0; float_type gabs_t = 0.0;
float_type RHS_t = 0.0; float_type RHS_t = 0.0;
const std::size_t term_count = this->m_terms[k]->count(); const std::size_t term_count = this->m_terms[k].count();
const float_type * const gt = this->m_gtn[k]; const float_type * const gt = this->m_gtn[k];
const float_type * const go = this->m_gonn[k]; const float_type * const go = this->m_gonn[k];
const float_type * const Idr = this->m_Idrn[k]; const float_type * const Idr = this->m_Idrn[k];
auto other_cur_analog = this->m_connected_net_Vn[k]; auto other_cur_analog = this->m_connected_net_Vn[k];
this->m_new_V[k] = this->m_terms[k]->getV(); this->m_new_V[k] = this->m_terms[k].getV();
for (std::size_t i = 0; i < term_count; i++) for (std::size_t i = 0; i < term_count; i++)
{ {
@ -98,7 +98,7 @@ unsigned matrix_solver_SOR_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_rap
RHS_t = RHS_t + Idr[i]; RHS_t = RHS_t + Idr[i];
} }
for (std::size_t i = this->m_terms[k]->m_railstart; i < term_count; i++) for (std::size_t i = this->m_terms[k].railstart(); i < term_count; i++)
RHS_t = RHS_t - go[i] * *other_cur_analog[i]; RHS_t = RHS_t - go[i] * *other_cur_analog[i];
RHS[k] = RHS_t; RHS[k] = RHS_t;
@ -134,8 +134,8 @@ unsigned matrix_solver_SOR_t<FT, SIZE>::vsolve_non_dynamic(const bool newton_rap
float_type err = 0; float_type err = 0;
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
{ {
const int * net_other = this->m_terms[k]->m_connected_net_idx.data(); const int * net_other = this->m_terms[k].m_connected_net_idx.data();
const std::size_t railstart = this->m_terms[k]->m_railstart; const std::size_t railstart = this->m_terms[k].railstart();
const float_type * go = this->m_gonn[k]; const float_type * go = this->m_gonn[k];
float_type Idrive = 0.0; float_type Idrive = 0.0;

6
src/lib/netlist/solver/nld_ms_sor_mat.h
View File

@ -166,7 +166,7 @@ namespace devices
#endif #endif
for (std::size_t k = 0; k < iN; k++) for (std::size_t k = 0; k < iN; k++)
this->m_new_V[k] = this->m_terms[k]->getV(); this->m_new_V[k] = this->m_terms[k].getV();
do { do {
resched = false; resched = false;
@ -176,8 +176,8 @@ namespace devices
{ {
float_type Idrive = 0; float_type Idrive = 0;
const auto *p = this->m_terms[k]->m_nz.data(); const auto *p = this->m_terms[k].m_nz.data();
const std::size_t e = this->m_terms[k]->m_nz.size(); const std::size_t e = this->m_terms[k].m_nz.size();
for (std::size_t i = 0; i < e; i++) for (std::size_t i = 0; i < e; i++)
Idrive = Idrive + this->A(k,p[i]) * this->m_new_V[p[i]]; Idrive = Idrive + this->A(k,p[i]) * this->m_new_V[p[i]];

10
src/lib/netlist/solver/nld_ms_w.h
View File

@ -156,13 +156,13 @@ void matrix_solver_w_t<FT, SIZE>::LE_invert()
{ {
/* FIXME: Singular matrix? */ /* FIXME: Singular matrix? */
const float_type f = 1.0 / W(i,i); const float_type f = 1.0 / W(i,i);
const auto * const p = m_terms[i]->m_nzrd.data(); const auto * const p = m_terms[i].m_nzrd.data();
const size_t e = m_terms[i]->m_nzrd.size(); const size_t e = m_terms[i].m_nzrd.size();
/* Eliminate column i from row j */ /* Eliminate column i from row j */
const auto * const pb = m_terms[i]->m_nzbd.data(); const auto * const pb = m_terms[i].m_nzbd.data();
const size_t eb = m_terms[i]->m_nzbd.size(); const size_t eb = m_terms[i].m_nzbd.size();
for (std::size_t jb = 0; jb < eb; jb++) for (std::size_t jb = 0; jb < eb; jb++)
{ {
const auto j = pb[jb]; const auto j = pb[jb];
@ -250,7 +250,7 @@ unsigned matrix_solver_w_t<FT, SIZE>::solve_non_dynamic(const bool newton_raphso
for (unsigned row = 0; row < iN; row ++) for (unsigned row = 0; row < iN; row ++)
{ {
unsigned cc=0; unsigned cc=0;
auto &nz = m_terms[row]->m_nz; auto &nz = m_terms[row].m_nz;
for (auto & col : nz) for (auto & col : nz)
{ {
if (A(row,col) != lA(row,col)) if (A(row,col) != lA(row,col))