static double tstop_event(void* v) {
NetCvode* d = (NetCvode*)v;
double x = *getarg(1);
if (!cvode_active_) { // watch out for fixed step roundoff if x
// close to n*dt
double y = x/nrn_threads->_dt;
if (y > 1 && fabs(floor(y + 1e-6) - y) < 1e-6) {
//printf("reduce %g to avoid fixed step roundoff\n", x);
x -= nrn_threads->_dt/4.;
}
}
if (ifarg(2)) {
Object* ppobj = nil;
int reinit = 0;
if (ifarg(3)) {
ppobj = *hoc_objgetarg(3);
if (!ppobj || ppobj->ctemplate->is_point_ <= 0
|| nrn_is_artificial_[ob2pntproc(ppobj)->prop->type]
){
hoc_execerror(hoc_object_name(ppobj), "is not a POINT_PROCESS");
}
reinit = int(chkarg(4, 0, 1));
}
if (hoc_is_object_arg(2)) {
d->hoc_event(x, nil, ppobj, reinit, *hoc_objgetarg(2));
}else{
d->hoc_event(x, gargstr(2), ppobj, reinit);
}
}else{
//d->tstop_event(x);
d->hoc_event(x, 0, 0, 0);
}
return x;
}
static void* finithnd_cons(Object*) {
int type = 1; // default is after INITIAL blocks are called
int ia = 1;
if (hoc_is_double_arg(ia)) {
type = (int)chkarg(ia, 0, 3);
++ia;
}
char* s = NULL;
Object* pyact = NULL;
if (hoc_is_object_arg(ia)) {
pyact = *hoc_objgetarg(ia);
if (!pyact) {
hoc_execerror("arg is None", 0);
}
}else{
s =gargstr(ia);
}
++ia;
Object* obj = NULL;
if (ifarg(ia)) {
obj = *hoc_objgetarg(ia);
}
FInitialHandler* f = new FInitialHandler(type, s, obj, pyact);
return f;
}
void LinearMechanism::create()
{
int i;
lmfree();
i = 0;
Object* o = *hoc_objgetarg(++i);
if (strcmp(o->ctemplate->sym->name, "PythonObject") == 0) {
f_callable_ = o;
hoc_obj_ref(o);
c_ = matrix_arg(++i);
} else {
f_callable_ = NULL;
c_ = matrix_arg(1);
}
g_ = matrix_arg(++i);
y_ = vector_arg(++i);
if (ifarg(i + 2) && hoc_is_object_arg(i + 2) && is_vector_arg(i + 2)) {
y0_ = vector_arg(++i);
}
b_ = vector_arg(++i);
if (ifarg(++i)) {
#if HAVE_IV
Oc oc;
#endif
if (hoc_is_double_arg(i)) {
nnode_ = 1;
nodes_ = new Node*[1];
double x = chkarg(i, 0., 1.);
Section* sec = chk_access();
nodes_[0] = node_exact(sec, x);
nrn_notify_when_double_freed(&NODEV(nodes_[0]), this);
}else{
Object* o = *hoc_objgetarg(i);
check_obj_type(o, "SectionList");
SectionList* sl = new SectionList(o);
sl->ref();
Vect* x = vector_arg(i+1);
Section* sec;
nnode_ = 0;
nodes_ = new Node*[x->capacity()];
for (sec = sl->begin(); sec; sec = sl->next()) {
nodes_[nnode_] = node_exact(sec, x->elem(nnode_));
nrn_notify_when_double_freed(&NODEV(nodes_[nnode_]), this);
++nnode_;
}
if (ifarg(i+2)) {
elayer_ = vector_arg(i+2);
}
sl->unref();
}
}
model_ = new LinearModelAddition(c_, g_, y_, y0_, b_,
nnode_, nodes_, elayer_, f_callable_);
}
static void* ste_cons(Object*) {
int nstate = (int)chkarg(1, 1, 1e6);
Point_process* pnt = NULL;
if (ifarg(2)) {
Object* obj = *hoc_objgetarg(2);
pnt = ob2pntproc(obj);
}
StateTransitionEvent* ste = new StateTransitionEvent(nstate, pnt);
return ste;
}
static double extra_scatter_gather(void* v) {
int direction = int(chkarg(1, 0, 1));
Object* o = *hoc_objgetarg(2);
check_obj_type(o, "PythonObject");
ExtraScatterList* esl = extra_scatterlist[direction];
if (!esl) {
esl = new ExtraScatterList(2);
extra_scatterlist[direction] = esl;
}
esl->append(o);
hoc_obj_ref(o);
return 0.;
}
static double joequals(void* v) {
jobject jo1 = (jobject)v;
Object* o2 = *hoc_objgetarg(1);
jobject jo2;
if (o2 == nil) {return 0.;}
if (o2->ctemplate->constructor == joconstruct // a JavaObject
|| o2->ctemplate->sym->type == JAVAOBJECT) { // registerd java Object
jobject jo2 = (jobject)o2->u.this_pointer;
return (nrnjava_env->CallStaticIntMethod(neuronCls, identityID,
jo1,jo2 ) != 0 ) ? 1. : 0.;
}
return 0.;
}
static double ste_transition(void* v) {
StateTransitionEvent* ste = (StateTransitionEvent*)v;
int src = (int)chkarg(1, 0, ste->nstate()-1);
int dest = (int)chkarg(2, 0, ste->nstate()-1);
double* var1 = hoc_pgetarg(3);
double* var2 = hoc_pgetarg(4);
HocCommand* hc = NULL;
if (ifarg(5)) {
Object* obj = NULL;
if (hoc_is_str_arg(5)) {
char* stmt = NULL;
stmt = gargstr(5);
if (ifarg(6)) {
obj = *hoc_objgetarg(6);
}
hc = new HocCommand(stmt, obj);
}else{
obj = *hoc_objgetarg(5);
hc = new HocCommand(obj);
}
}
ste->transition(src, dest, var1, var2, hc);
return 1.;
}
static double extra_scatter_gather_remove(void* v) {
Object* o = *hoc_objgetarg(1);
for (int direction=0; direction < 2; ++direction) {
ExtraScatterList* esl = extra_scatterlist[direction];
if (esl) for (int i = esl->count()-1; i >= 0; --i) {
Object* o1 = esl->item(i);
// if esl exists then python exists
if ((*nrnpy_pysame)(o, o1)) {
esl->remove(i);
hoc_obj_unref(o1);
}
}
}
return 0.;
}
JNIEXPORT jobject JNICALL Java_neuron_Neuron_getHocObjectArg
(JNIEnv *env, jclass cl, jint i, jthrowable e) {
jobject ret;
//printf("getHocObjArg %s %ld\n", hoc_object_name(o), (long)o);
if (!ifarg(i)) {
printf("error - missing Object as arg %d\n", i);
illegalArg(env, "missing Object");
return e;
}
if (hoc_is_object_arg(i)) {
Object* o = *hoc_objgetarg(i);
ret = h2jObject(o);
}else if (hoc_is_str_arg(i)) { //encapsulate in String
char* s = gargstr(i);
ret = Java_neuron_Neuron_getHocStringArg(env, cl, i);
}else{
printf("error - expecting Object or strdef as arg %d\n", i);
illegalArg(env, "expecting Object or strdef");
ret = e;
}
return ret;
}
static void pack_help(int i, OcBBS* bbs) {
if (!posting_) {
bbs->pkbegin();
posting_ = true;
}
for (; ifarg(i); ++i) {
if (hoc_is_double_arg(i)) {
bbs->pkdouble(*getarg(i));
}else if (hoc_is_str_arg(i)) {
bbs->pkstr(gargstr(i));
}else if (is_vector_arg(i)){
int n; double* px;
n = vector_arg_px(i, &px);
bbs->pkint(n);
bbs->pkvec(n, px);
}else{ // must be a PythonObject
size_t size;
char* s = nrnpy_po2pickle(*hoc_objgetarg(i), &size);
bbs->pkpickle(s, size);
delete [] s;
}
}
}
Rand* nrn_random_arg(int i) {
Object* ob = *hoc_objgetarg(i);
check_obj_type(ob, "Random");
Rand* r = (Rand*)(ob->u.this_pointer);
return r;
}
void nrn_vecsim_add(void* v, boolean record) {
IvocVect* yvec, *tvec, *dvec;
extern short* nrn_is_artificial_;
double* pvar = nil;
char* s = nil;
double ddt;
Object* ppobj = nil;
int iarg = 0;
yvec = (IvocVect*)v;
if (hoc_is_object_arg(1)) {
iarg = 1;
ppobj = *hoc_objgetarg(1);
if (!ppobj || ppobj->ctemplate->is_point_ <= 0
|| nrn_is_artificial_[ob2pntproc(ppobj)->prop->type]
) {
hoc_execerror("Optional first arg is not a POINT_PROCESS", 0);
}
}
if (record == false && hoc_is_str_arg(iarg+1)) {//statement involving $1
// Vector.play("proced($1)", ...)
s = gargstr(iarg+1);
}else if (record == false && hoc_is_double_arg(iarg+1)) {// play that element
// Vector.play(index)
// must be a VecPlayStep and nothing else
VecPlayStep* vps = (VecPlayStep*)net_cvode_instance->playrec_uses(v);
if (vps) {
int j = (int)chkarg(iarg+1, 0., yvec->capacity()-1);
if (vps->si_) {
vps->si_->play_one(yvec->elem(j));
}
}
return;
}else{
// Vector.play(&SEClamp[0].amp1, ...)
// Vector.record(&SEClamp[0].i, ...)
pvar = hoc_pgetarg(iarg+1);
}
tvec = nil;
dvec = nil;
ddt = -1.;
int con = 0;
if (ifarg(iarg+2)) {
if (hoc_is_object_arg(iarg+2)) {
// Vector...(..., tvec)
tvec = vector_arg(iarg+2);
}else{
// Vector...(..., Dt)
ddt = chkarg(iarg+2, 1e-9, 1e10);
}
if (ifarg(iarg+3)) {
if (hoc_is_double_arg(iarg+3)) {
con = (int)chkarg(iarg+3, 0., 1.);
}else{
dvec = vector_arg(iarg+3);
con = 1;
}
}
}
// tvec can be used for many record/play items
// if (tvec) { nrn_vecsim_remove(tvec); }
if (record) {
// yvec can be used only for one record (but many play)
if (yvec) { nrn_vecsim_remove(yvec); }
if (tvec) {
new VecRecordDiscrete(pvar, yvec, tvec, ppobj);
} else if (ddt > 0.) {
new VecRecordDt(pvar, yvec, ddt, ppobj);
} else if (pvar == &t) {
new TvecRecord(chk_access(), yvec, ppobj);
} else {
new YvecRecord(pvar, yvec, ppobj);
}
}else{
if (con) {
if (s) {
new VecPlayContinuous(s, yvec, tvec, dvec, ppobj);
}else{
new VecPlayContinuous(pvar, yvec, tvec, dvec, ppobj);
}
}else{
if (!tvec && ddt == -1.) {
chkarg(iarg+2, 1e-9, 1e10);
}
if (s) {
new VecPlayStep(s, yvec, tvec, ddt, ppobj);
}else{
new VecPlayStep(pvar, yvec, tvec, ddt, ppobj);
}
}
}
}
static int submit_help(OcBBS* bbs) {
int id, i, firstarg, style;
char* pname = 0; // if using Python callable
posting_ = true;
bbs->pkbegin();
i = 1;
if (hoc_is_double_arg(i)) {
bbs->pkint((id = (int)chkarg(i++, 0, 1e7)));
}else{
bbs->pkint((id = --bbs->next_local_));
}
if (ifarg(i+1)) {
#if 1
int argtypes = 0;
int ii = 1;
if (hoc_is_str_arg(i)) {
style = 1;
bbs->pkint(style); // "fname", arg1, ... style
bbs->pkstr(gargstr(i++));
}else{
Object* ob = *hoc_objgetarg(i++);
size_t size;
if (nrnpy_po2pickle) {
pname = (*nrnpy_po2pickle)(ob, &size);
}
if (pname) {
style = 3;
bbs->pkint(style); // pyfun, arg1, ... style
bbs->pkpickle(pname, size);
delete [] pname;
}else{
style = 2;
bbs->pkint(style); // [object],"fname", arg1, ... style
bbs->pkstr(ob->ctemplate->sym->name);
bbs->pkint(ob->index);
//printf("ob=%s\n", hoc_object_name(ob));
bbs->pkstr(gargstr(i++));
}
}
firstarg = i;
for (; ifarg(i); ++i) { // first is least significant
if (hoc_is_double_arg(i)) {
argtypes += 1*ii;
}else if (hoc_is_str_arg(i)) {
argtypes += 2*ii;
}else if (is_vector_arg(i)) { //hoc Vector
argtypes += 3*ii;
}else{ // must be a PythonObject
argtypes += 4*ii;
}
ii *= 5;
}
//printf("submit style %d %s argtypes=%o\n", style, gargstr(firstarg-1), argtypes);
bbs->pkint(argtypes);
pack_help(firstarg, bbs);
#endif
}else{
if (hoc_is_str_arg(i)) {
bbs->pkint(0); // hoc statement style
bbs->pkstr(gargstr(i));
}else if (nrnpy_po2pickle) {
size_t size;
pname = (*nrnpy_po2pickle)(*hoc_objgetarg(i), &size);
bbs->pkint(3); // pyfun with no arg style
bbs->pkpickle(pname, size);
bbs->pkint(0); // argtypes
delete [] pname;
}
}
posting_ = false;
return id;
}
void fit_praxis(void) {
extern Symbol* hoc_lookup();
extern char* gargstr();
char* after_quad;
int i;
double err, fmin;
double* px;
/* allow nested calls to fit_praxis. I.e. store all the needed
statics specific to this invocation with proper reference
counting and then unref/destoy on exit from this invocation.
Before the prax call save the statics from earlier invocation
without increasing the
ref count and on exit restore without decreasing the ref count.
*/
/* save before setting statics, restore after prax */
double minerrsav, *minargsav, maxstepsizesav, tolerancesav;
long int printmodesav, nvarsav;
Symbol* efun_sym_sav;
Object* efun_py_save, *efun_py_arg_save;
void* vec_py_save_save;
/* store statics specified by this invocation */
/* will be copied just before calling prax */
double minerr_, *minarg_;
long int nvar_;
Symbol* efun_sym_;
Object* efun_py_, *efun_py_arg_;
void* vec_py_save_;
minerr_ = 0.0;
nvar_ = 0;
minarg_ = NULL;
efun_sym_ = NULL;
efun_py_ = NULL;
efun_py_arg_ = NULL;
vec_py_save_ = NULL;
fmin = 0.;
if (hoc_is_object_arg(1)) {
assert(nrnpy_praxis_efun);
efun_py_ = *hoc_objgetarg(1);
hoc_obj_ref(efun_py_);
efun_py_arg_ = *vector_pobj(vector_arg(2));
hoc_obj_ref(efun_py_arg_);
vec_py_save_ = vector_new2(efun_py_arg_->u.this_pointer);
nvar_ = vector_capacity(vec_py_save_);
px = vector_vec(vec_py_save_);
}else{
nvar_ = (int)chkarg(1, 0., 1e6);
efun_sym_ = hoc_lookup(gargstr(2));
if (!efun_sym_
|| (efun_sym_->type != FUNCTION
&& efun_sym_->type != FUN_BLTIN)) {
hoc_execerror(gargstr(2), "not a function name");
}
if (!hoc_is_pdouble_arg(3)) {
void* vec = vector_arg(3);
if (vector_capacity(vec) != nvar_) {
hoc_execerror("first arg not equal to size of Vector",0);
}
px = vector_vec(vec);
}else{
px = hoc_pgetarg(3);
}
}
minarg_ = (double*)ecalloc(nvar_, sizeof(double));
if (maxstepsize == 0.) {
hoc_execerror("call attr_praxis first to set attributes", 0);
}
machep = 1e-15;
if (ifarg(4)) {
after_quad = gargstr(4);
}else{
after_quad = (char*)0;
}
/* save the values set by earlier invocation */
minerrsav = minerr;
minargsav = minarg;
tolerancesav = tolerance;
maxstepsizesav = maxstepsize;
printmodesav = printmode;
nvarsav = nvar;
efun_sym_sav = hoc_efun_sym;
efun_py_save = efun_py;
efun_py_arg_save = efun_py_arg;
vec_py_save_save = vec_py_save;
/* copy this invocation values to the statics */
minerr = minerr_;
minarg = minarg_;
nvar = nvar_;
hoc_efun_sym = efun_sym_;
efun_py = efun_py_;
efun_py_arg = efun_py_arg_;
vec_py_save = vec_py_save_;
minerr=1e9;
err = praxis(&tolerance, &machep, &maxstepsize, nvar, &printmode,
px, efun, &fmin, after_quad);
err = minerr;
if (minerr < 1e9) {
for (i=0; i<nvar; ++i) { px[i] = minarg[i]; }
}
/* restore the values set by earlier invocation */
minerr = minerrsav;
minarg = minargsav;
tolerance = tolerancesav;
maxstepsize = maxstepsizesav;
printmode = printmodesav;
nvar = nvar_; /* in case one calls prax_pval */
hoc_efun_sym = efun_sym_sav;
efun_py = efun_py_save;
efun_py_arg = efun_py_arg_save;
vec_py_save = vec_py_save_save;
if (efun_py_) {
double* px = vector_vec(efun_py_arg_->u.this_pointer);
for (i=0; i < nvar_; ++i) {
px[i] = minarg_[i];
}
hoc_obj_unref(efun_py_);
hoc_obj_unref(efun_py_arg_);
vector_delete(vec_py_save_);
}
if (minarg_) {
free(minarg_);
}
hoc_retpushx(err);
}
