/* format a string into an ei_x_buff, except the version token */
static int eiformat(const char** fmt, union arg** args, ei_x_buff* x)
{
const char* p = *fmt;
int res;
ei_x_buff x2;
while (isspace((int)*p))
++p;
switch (*p) {
case '~':
res = pformat(&p, args, x);
break;
case '[':
res = ei_x_new(&x2);
if (res >= 0)
res = plist(&p, args, &x2, 0);
if (res > 0)
res = ei_x_encode_list_header(x, res);
if (res >= 0)
res = ei_x_append(x, &x2);
ei_x_free(&x2);
break;
case '{':
res = ei_x_new(&x2);
if (res >= 0)
res = ptuple(&p, args, &x2, 0);
if (res >= 0)
res = ei_x_encode_tuple_header(x, res);
if (res >= 0)
res = ei_x_append(x, &x2);
ei_x_free(&x2);
break;
case '"':
res = pstring(&p, x);
break;
case '\'':
res = pquotedatom(&p, x);
break;
default:
if (isdigit((int)*p))
res = pdigit(&p, x);
else if ((*p == '-' || *p == '+') && isdigit((int)*(p+1)))
res = pdigit(&p, x);
else if (islower((int)*p))
res = patom(&p, x);
else
res = -1;
break;
/*
Variables
*/
}
*fmt = p;
return res;
}
//**********************************************************************************************************************
vector<string> DeconvoluteCommand::setParameters(){
try {
CommandParameter pfasta("fasta", "InputTypes", "", "", "none", "none", "none","fasta-name",false,true,true); parameters.push_back(pfasta);
CommandParameter pname("name", "InputTypes", "", "", "namecount", "none", "none","name",false,false,true); parameters.push_back(pname);
CommandParameter pcount("count", "InputTypes", "", "", "namecount", "none", "none","count",false,false,true); parameters.push_back(pcount);
CommandParameter pformat("format", "Multiple", "count-name", "name", "", "", "","",false,false, true); parameters.push_back(pformat);
CommandParameter pseed("seed", "Number", "", "0", "", "", "","",false,false); parameters.push_back(pseed);
CommandParameter pinputdir("inputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(pinputdir);
CommandParameter poutputdir("outputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(poutputdir);
vector<string> myArray;
for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); }
return myArray;
}
catch(exception& e) {
m->errorOut(e, "DeconvoluteCommand", "setParameters");
exit(1);
}
}
//**********************************************************************************************************************
vector<string> ListSeqsCommand::setParameters(){
try {
CommandParameter pfastq("fastq", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(pfastq);
CommandParameter pfasta("fasta", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(pfasta);
CommandParameter pname("name", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(pname);
CommandParameter pcount("count", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(pcount);
CommandParameter pgroup("group", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(pgroup);
CommandParameter plist("list", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(plist);
CommandParameter ptaxonomy("taxonomy", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false,true); parameters.push_back(ptaxonomy);
CommandParameter palignreport("alignreport", "InputTypes", "", "", "FNGLT", "FNGLT", "none","accnos",false,false); parameters.push_back(palignreport);
CommandParameter pformat("format", "Multiple", "sanger-illumina-solexa-illumina1.8+", "illumina1.8+", "", "", "","",false,false,true); parameters.push_back(pformat);
CommandParameter pseed("seed", "Number", "", "0", "", "", "","",false,false); parameters.push_back(pseed);
CommandParameter pinputdir("inputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(pinputdir);
CommandParameter poutputdir("outputdir", "String", "", "", "", "", "","",false,false); parameters.push_back(poutputdir);
vector<string> myArray;
for (int i = 0; i < parameters.size(); i++) { myArray.push_back(parameters[i].name); }
return myArray;
}
catch(exception& e) {
m->errorOut(e, "ListSeqsCommand", "setParameters");
exit(1);
}
}
void parse(t_data *d, t_map *m)
{
(m->status == 1) ? pformat(d, m) : 0;
(m->status == 2) ? pbuild(d, m) : 0;
}
ATTR_COLD void NETLIB_NAME(solver)::post_start()
{
analog_net_t::list_t groups[256];
int cur_group = -1;
const bool use_specific = true;
m_params.m_accuracy = m_accuracy.Value();
m_params.m_gs_loops = m_gs_loops.Value();
m_params.m_nr_loops = m_nr_loops.Value();
m_params.m_nt_sync_delay = netlist_time::from_double(m_sync_delay.Value());
m_params.m_lte = m_lte.Value();
m_params.m_sor = m_sor.Value();
m_params.m_min_timestep = m_min_timestep.Value();
m_params.m_dynamic = (m_dynamic.Value() == 1 ? true : false);
m_params.m_max_timestep = netlist_time::from_hz(m_freq.Value()).as_double();
if (m_params.m_dynamic)
{
m_params.m_max_timestep *= NL_FCONST(1000.0);
}
else
{
m_params.m_min_timestep = m_params.m_max_timestep;
}
// Override log statistics
pstring p = nl_util::environment("NL_STATS");
if (p != "")
m_params.m_log_stats = (bool) p.as_long();
else
m_params.m_log_stats = (bool) m_log_stats.Value();
netlist().log("Scanning net groups ...");
// determine net groups
for (std::size_t i=0; i<netlist().m_nets.size(); i++)
{
SOLVER_VERBOSE_OUT(("processing %s\n", netlist().m_nets[i]->name().cstr()));
if (!netlist().m_nets[i]->isRailNet())
{
SOLVER_VERBOSE_OUT((" ==> not a rail net\n"));
analog_net_t *n = &netlist().m_nets[i]->as_analog();
if (!n->already_processed(groups, cur_group))
{
cur_group++;
n->process_net(groups, cur_group);
}
}
}
// setup the solvers
netlist().log("Found %d net groups in %" SIZETFMT " nets\n", cur_group + 1, SIZET_PRINTF(netlist().m_nets.size()));
for (int i = 0; i <= cur_group; i++)
{
matrix_solver_t *ms;
std::size_t net_count = groups[i].size();
switch (net_count)
{
case 1:
ms = create_solver<1,1>(1, use_specific);
break;
case 2:
ms = create_solver<2,2>(2, use_specific);
break;
case 3:
ms = create_solver<3,3>(3, use_specific);
break;
case 4:
ms = create_solver<4,4>(4, use_specific);
break;
case 5:
ms = create_solver<5,5>(5, use_specific);
break;
case 6:
ms = create_solver<6,6>(6, use_specific);
break;
case 7:
ms = create_solver<7,7>(7, use_specific);
break;
case 8:
ms = create_solver<8,8>(8, use_specific);
break;
case 12:
ms = create_solver<12,12>(12, use_specific);
break;
case 87:
ms = create_solver<87,87>(87, use_specific);
break;
default:
if (net_count <= 16)
{
ms = create_solver<0,16>(net_count, use_specific);
}
else if (net_count <= 32)
{
ms = create_solver<0,32>(net_count, use_specific);
}
else if (net_count <= 64)
{
ms = create_solver<0,64>(net_count, use_specific);
}
else
if (net_count <= 128)
{
ms = create_solver<0,128>(net_count, use_specific);
}
else
{
netlist().error("Encountered netgroup with > 128 nets");
ms = NULL; /* tease compilers */
}
break;
}
register_sub(pformat("Solver_%1")(m_mat_solvers.size()), *ms);
ms->vsetup(groups[i]);
m_mat_solvers.add(ms);
netlist().log("Solver %s", ms->name().cstr());
netlist().log(" # %d ==> %" SIZETFMT " nets", i, SIZET_PRINTF(groups[i].size())); //, (*(*groups[i].first())->m_core_terms.first())->name().cstr());
netlist().log(" has %s elements", ms->is_dynamic() ? "dynamic" : "no dynamic");
netlist().log(" has %s elements", ms->is_timestep() ? "timestep" : "no timestep");
for (std::size_t j=0; j<groups[i].size(); j++)
{
netlist().log("Net %" SIZETFMT ": %s", SIZET_PRINTF(j), groups[i][j]->name().cstr());
net_t *n = groups[i][j];
for (std::size_t k = 0; k < n->m_core_terms.size(); k++)
{
const core_terminal_t *p = n->m_core_terms[k];
netlist().log(" %s", p->name().cstr());
}
}
}
}
ATTR_COLD void matrix_solver_t::setup(analog_net_t::list_t &nets)
{
NL_VERBOSE_OUT(("New solver setup\n"));
m_nets.clear();
for (std::size_t k = 0; k < nets.size(); k++)
{
m_nets.add(nets[k]);
}
for (std::size_t k = 0; k < nets.size(); k++)
{
NL_VERBOSE_OUT(("setting up net\n"));
analog_net_t *net = nets[k];
net->m_solver = this;
for (std::size_t i = 0; i < net->m_core_terms.size(); i++)
{
core_terminal_t *p = net->m_core_terms[i];
NL_VERBOSE_OUT(("%s %s %d\n", p->name().cstr(), net->name().cstr(), (int) net->isRailNet()));
switch (p->type())
{
case terminal_t::TERMINAL:
switch (p->device().family())
{
case device_t::CAPACITOR:
if (!m_step_devices.contains(&p->device()))
m_step_devices.add(&p->device());
break;
case device_t::BJT_EB:
case device_t::DIODE:
case device_t::LVCCS:
case device_t::BJT_SWITCH:
NL_VERBOSE_OUT(("found BJT/Diode/LVCCS\n"));
if (!m_dynamic_devices.contains(&p->device()))
m_dynamic_devices.add(&p->device());
break;
default:
break;
}
{
terminal_t *pterm = dynamic_cast<terminal_t *>(p);
add_term(k, pterm);
}
NL_VERBOSE_OUT(("Added terminal\n"));
break;
case terminal_t::INPUT:
{
analog_output_t *net_proxy_output = NULL;
for (std::size_t i = 0; i < m_inps.size(); i++)
if (m_inps[i]->m_proxied_net == &p->net().as_analog())
{
net_proxy_output = m_inps[i];
break;
}
if (net_proxy_output == NULL)
{
net_proxy_output = palloc(analog_output_t);
net_proxy_output->init_object(*this, this->name() + "." + pformat("m%1")(m_inps.size()));
m_inps.add(net_proxy_output);
net_proxy_output->m_proxied_net = &p->net().as_analog();
}
net_proxy_output->net().register_con(*p);
// FIXME: repeated
net_proxy_output->net().rebuild_list();
NL_VERBOSE_OUT(("Added input\n"));
}
break;
default:
netlist().error("unhandled element found\n");
break;
}
}
NL_VERBOSE_OUT(("added net with %" SIZETFMT " populated connections\n", net->m_core_terms.size()));
}
}
