protected nld_base_proxy(netlist_base_t anetlist, string name, logic_t inout_proxied, detail.core_terminal_t proxy_inout)
: base(anetlist, name)
{
m_logic_family = inout_proxied.logic_family();
m_term_proxied = inout_proxied;
m_proxy_term = proxy_inout;
}
public nld_a_to_d_proxy(netlist_base_t anetlist, string name, logic_input_t in_proxied)
: base(anetlist, name, in_proxied, null)// m_I)
{
m_I = new analog_input_t(this, "I");
// set proxy_term after variable is initialized
proxy_term_prop = m_I;
}
//template<>
public static core_device_t bselect(bool b, netlist_base_t d1, core_device_t d2)
{
if (b)
{
throw new nl_exception("bselect with netlist and b==true");
}
return(d2);
}
//analog_output_t m_GNDHack; // FIXME: Long term, we need to connect proxy gnd to device gnd
//analog::NETLIB_SUB(twoterm) m_RV;
//state_var<int> m_last_state;
//bool m_is_timestep;
public nld_d_to_a_proxy(netlist_base_t anetlist, string name, logic_output_t out_proxied)
: base(anetlist, name, out_proxied, null) //m_RV.m_P)
{
throw new emu_unimplemented();
// TODO - add this code after initialization
// set proxy_term after variable is initialized
//proxy_term_prop = m_RV.m_p;
}
// ----------------------------------------------------------------------------------------
// matrix_solver
// ----------------------------------------------------------------------------------------
protected matrix_solver_t(netlist_base_t anetlist, string name, eSortType sort, solver_parameters_t params_)
: base(anetlist, name)
{
m_params = params_;
m_stat_calculations = new state_var <int>(this, "m_stat_calculations", 0);
m_stat_newton_raphson = new state_var <int>(this, "m_stat_newton_raphson", 0);
m_stat_vsolver_calls = new state_var <int>(this, "m_stat_vsolver_calls", 0);
m_iterative_fail = new state_var <int>(this, "m_iterative_fail", 0);
m_iterative_total = new state_var <int>(this, "m_iterative_total", 0);
m_last_step = new state_var <netlist_time>(this, "m_last_step", netlist_time.zero());
m_fb_sync = new logic_input_t(this, "FB_sync");
m_Q_sync = new logic_output_t(this, "Q_sync");
m_ops = 0;
m_sort = sort;
connect_post_start(m_fb_sync, m_Q_sync);
}
//plib::dynproc<void, double * RESTRICT, double * RESTRICT, double * RESTRICT> m_proc;
public matrix_solver_GCR_t(int SIZE, netlist_base_t anetlist, string name, solver_parameters_t params_, UInt32 size)
: base(anetlist, name, matrix_solver_t.eSortType.ASCENDING, params_)
{
this.SIZE = SIZE;
for (int i = 0; i < m_term_cr.Length; i++)
{
m_term_cr[i] = new std.vector <uint16_t>();
}
m_dim = size;
RHS = new double [size];
new_V = new double [size];
mat = new plib.mat_cr_t(storage_N, size);
m_proc = null;
}
public void run(netlist_base_t netlist)
{
foreach (var net in netlist.nets())
{
netlist.log().debug.op("processing {0}\n", net.name());
if (!net.isRailNet() && net.num_cons() > 0)
{
netlist.log().debug.op(" ==> not a rail net\n");
/* Must be an analog net */
analog_net_t n = (analog_net_t)net;
if (!already_processed(n))
{
groups.push_back(new analog_net_t_list_t());
process_net(n);
}
}
}
}
//typedef FT float_type;
//typedef matrix_solver_direct_t<FT, 1> base_type;
public matrix_solver_direct1_t(netlist_base_t anetlist, string name, solver_parameters_t params_)
: base(1, anetlist, name, params_, 1)
{
}
protected nld_base_a_to_d_proxy(netlist_base_t anetlist, string name, logic_input_t in_proxied, detail.core_terminal_t in_proxy)
: base(anetlist, name, in_proxied, in_proxy)
{
m_Q = new logic_output_t(this, "Q");
}
protected nld_base_d_to_a_proxy(netlist_base_t anetlist, string name, logic_output_t out_proxied, detail.core_terminal_t proxy_out)
: base(anetlist, name, out_proxied, proxy_out)
{
m_I = new logic_input_t(this, "I");
}
protected matrix_solver_direct_t(UInt32 SIZE, netlist_base_t anetlist, string name, eSortType sort, solver_parameters_t params_, UInt32 size)
: base(null, null, eSortType.NOSORT, params_)
{
throw new emu_unimplemented();
}
public override device_t Create(netlist_base_t anetlist, string name)
{
throw new emu_unimplemented();
}
