void Cvode::maxstate(bool b, NrnThread* nt) {
if (!maxstate_) { return; }
if (!nt) {
if (nrn_nthread > 1) {
maxstate_cv = this;
maxstate_b = b;
nrn_multithread_job(maxstate_thread);
return;
}
nt = nrn_threads;
}
CvodeThreadData& z = ctd_[nt->id];
int i;
double x;
double* y = n_vector_data(y_, nt->id);
double* m = n_vector_data(maxstate_, nt->id);
for (i=0; i < z.nvsize_; ++i) {
x = Math::abs(y[i]);
if (m[i] < x) {
m[i] = x;
}
}
if (b) {
y = n_vector_data(acorvec(), nt->id);
m = n_vector_data(maxacor_, nt->id);
for (i=0; i < z.nvsize_; ++i) {
x = Math::abs(y[i]);
if (m[i] < x) {
m[i] = x;
}
}
}
}
void N_VScale_NrnThread(realtype c, N_Vector x, N_Vector z)
{
cpass xpass zpass
nrn_multithread_job(vscale);
mydebug("vscale\n");
/*pr(z);*/
}
void N_VLinearSum_NrnThread(realtype a, N_Vector x, realtype b, N_Vector y, N_Vector z)
{
apass bpass xpass ypass zpass
nrn_multithread_job(vlinearsum);
mydebug("vlinearsum\n");
/*pr(z);*/
}
void Cvode::do_nonode(NrnThread* _nt) { // all the hacked integrators, etc, in SOLVE procedure
//almost a verbatim copy of nonvint in fadvance.c
if (!_nt) {
if (nrn_nthread > 1) {
nonode_cv = this;
nrn_multithread_job(nonode_thread);
return;
}
_nt = nrn_threads;
}
CvodeThreadData& z = CTD(_nt->id);
CvMembList* cml;
for (cml = z.cv_memb_list_; cml; cml = cml->next) {
Memb_func* mf = memb_func + cml->index;
if (mf->state) {
Memb_list* ml = cml->ml;
if (!mf->ode_spec){
Pfridot s = (Pfridot)mf->state;
(*s)(_nt, ml, cml->index);
#if 0
if (errno) {
if (nrn_errno_check(cml->index)) {
hoc_warning("errno set during calculation of states", (char*)0);
}
}
#endif
}else if (mf->singchan_) {
Pfridot s = (Pfridot)mf->singchan_;
(*s)(_nt, ml, cml->index);
}
}
}
}
realtype N_VMin_NrnThread(N_Vector x)
{
retval = BIG_REAL;
xpass
nrn_multithread_job(vmin);
mydebug2("vmin %.20g\n", retval);
return(retval);
}
realtype N_VL1Norm_NrnThread(N_Vector x)
{
retval = ZERO;
xpass
nrn_multithread_job(vl1norm);
mydebug2("vl1norm %.20g\n", retval);
return(retval);
}
realtype N_VMaxNorm_NrnThreadLD(N_Vector x)
{
retval = ZERO;
xpass
nrn_multithread_job(vmaxnorm);
mydebug2("vmaxnorm %.20g\n", retval);
return(retval);
}
booleantype N_VInvTest_NrnThread(N_Vector x, N_Vector z)
{
bretval = TRUE;
xpass zpass
nrn_multithread_job(vinvtest);
mydebug2("vinvtest %d\n", bretval);
return(bretval);
}
booleantype N_VConstrMask_NrnThread(N_Vector y, N_Vector x, N_Vector z)
{
bretval = TRUE;
ypass xpass zpass
nrn_multithread_job(vconstrmask);
mydebug2("vconstrmask %d\n", bretval);
return(bretval);
}
realtype N_VDotProd_NrnThread(N_Vector x, N_Vector y)
{
retval = ZERO;
xpass ypass
nrn_multithread_job(vdotprod);
mydebug2("vdotprod %.20g\n", retval);
return(retval);
}
realtype N_VMinQuotient_NrnThread(N_Vector x, N_Vector y) /* num, denom */
{
retval = BIG_REAL;
xpass ypass
nrn_multithread_job(vconstrmask);
mydebug2("vminquotient %.20g\n", retval);
return(retval);
}
void Cvode::gather_ydot(N_Vector y) {
if (nth_) {
gather_ydot(N_VGetArrayPointer(y), nth_->id);
return;
}
gather_cv = this;
gather_vec = y;
nrn_multithread_job(gather_ydot_thread);
}
realtype N_VWrmsNormMask_NrnThread(N_Vector x, N_Vector w, N_Vector id)
{
long int N;
N = NV_LENGTH_NT(x);
retval = ZERO;
xpass wpass idpass
nrn_multithread_job(vwrmsnormmask);
mydebug2("vwrmsnormmask %.20g\n", RSqrt(retval / N));
return(RSqrt(retval / N));
}
realtype N_VWL2Norm_NrnThread(N_Vector x, N_Vector w)
{
long int N;
retval = ZERO;
xpass wpass
nrn_multithread_job(vwl2norm);
N = NV_LENGTH_NT(x);
mydebug2("vwl2norm %.20g\n", RSqrt(retval));
return(RSqrt(retval));
}
nrn_daspk_init_step(double tt, double dteps, int upd){
int i;
double dtsav = nrn_threads->_dt;
int so = secondorder;
dt = dteps;
t = tt;
secondorder = 0;
dt2thread(dteps);
nrn_thread_table_check();
_upd = upd;
nrn_multithread_job(daspk_init_step_thread);
dt = dtsav;
secondorder = so;
dt2thread(dtsav);
nrn_thread_table_check();
}
realtype N_VWrmsNorm_NrnThread(N_Vector x, N_Vector w)
{
long int N;
N = NV_LENGTH_NT(x);
#if USELONGDOUBLE
longdretval = ZERO;
#else
retval = ZERO;
#endif
xpass wpass
nrn_multithread_job(vwrmsnorm);
#if USELONGDOUBLE
retval = longdretval;
#endif
mydebug2("vwrmsnorm %.20g\n", RSqrt(retval / N));
return(RSqrt(retval / N));
}
void nrn_fixed_step_group(int n) {
int i;
#if ELIMINATE_T_ROUNDOFF
nrn_chk_ndt();
#endif
dt2thread(dt);
nrn_thread_table_check();
if (nrn_multisplit_setup_) {
int b = 0;
nrn_multithread_job(nrn_ms_treeset_through_triang);
step_group_n = 0; /* abort at bksub flag */
for (i=1; i < n; ++i) {
nrn_multithread_job(nrn_ms_reduce_solve);
nrn_multithread_job(nrn_ms_bksub_through_triang);
if (step_group_n) {
step_group_n = 0;
if (nrn_allthread_handle) {
(*nrn_allthread_handle)();
}
/* aborted step at bksub, so if not stopped
must do the triang*/
b = 1;
if (!stoprun) {
nrn_multithread_job(nrn_ms_treeset_through_triang);
}
}
if (stoprun) { break; }
b = 0;
}
if (!b) {
nrn_multithread_job(nrn_ms_reduce_solve);
nrn_multithread_job(nrn_ms_bksub);
}
if (nrn_allthread_handle) { (*nrn_allthread_handle)(); }
}else{
step_group_n = n;
step_group_begin = 0;
step_group_end = 0;
while(step_group_end < step_group_n) {
/*printf("step_group_end=%d step_group_n=%d\n", step_group_end, step_group_n);*/
nrn_multithread_job(nrn_fixed_step_group_thread);
if (nrn_allthread_handle) { (*nrn_allthread_handle)(); }
if (stoprun) { break; }
step_group_begin = step_group_end;
}
}
t = nrn_threads[0]._t;
}
fcurrent()
{
int i;
if (tree_changed) {
setup_topology();
}
if (v_structure_change) {
v_setup_vectors();
}
if (diam_changed) {
recalc_diam();
}
dt2thread(-1.);
nrn_thread_table_check();
state_discon_allowed_ = 0;
nrn_multithread_job(setup_tree_matrix);
state_discon_allowed_ = 1;
ret(1.);
}
void nrn_fixed_step() {
int i;
#if ELIMINATE_T_ROUNDOFF
nrn_chk_ndt();
#endif
if (t != nrn_threads->_t) {
dt2thread(-1.);
}else{
dt2thread(dt);
}
nrn_thread_table_check();
if (nrn_multisplit_setup_) {
nrn_multithread_job(nrn_ms_treeset_through_triang);
if (!nrn_allthread_handle) {
nrn_multithread_job(nrn_ms_reduce_solve);
nrn_multithread_job(nrn_ms_bksub);
/* see comment below */
if (nrnthread_v_transfer_) {
if (nrnmpi_v_transfer_) {
(*nrnmpi_v_transfer_)();
}
nrn_multithread_job(nrn_fixed_step_lastpart);
}
}
}else{
nrn_multithread_job(nrn_fixed_step_thread);
/* if there is no nrnthread_v_transfer then there cannot be
a nrnmpi_v_transfer and lastpart
will be done in above call.
*/
if (nrnthread_v_transfer_) {
if (nrnmpi_v_transfer_) {
(*nrnmpi_v_transfer_)();
}
nrn_multithread_job(nrn_fixed_step_lastpart);
}
}
t = nrn_threads[0]._t;
if (nrn_allthread_handle) { (*nrn_allthread_handle)(); }
}
void N_VAbs_NrnThread(N_Vector x, N_Vector z)
{
xpass zpass
nrn_multithread_job(vabs);
mydebug("vabs\n");
}
void N_VCompare_NrnThread(realtype c, N_Vector x, N_Vector z)
{
cpass xpass zpass
nrn_multithread_job(vcompare);
mydebug("vcompare\n");
}
void N_VOneMask_NrnThread(N_Vector x)
{
xpass
nrn_multithread_job(v1mask);
}
void N_VConst_NrnThread(realtype c, N_Vector z)
{
cpass zpass
nrn_multithread_job(vconst);
mydebug("vconst\n");
}
void N_VProd_NrnThread(N_Vector x, N_Vector y, N_Vector z)
{
xpass ypass zpass
nrn_multithread_job(vprod);
mydebug("vprod\n");
}
void N_VDiv_NrnThread(N_Vector x, N_Vector y, N_Vector z)
{
xpass ypass zpass
nrn_multithread_job(vdiv);
mydebug("vdiv\n");
}
void N_VInv_NrnThread(N_Vector x, N_Vector z)
{
xpass zpass
nrn_multithread_job(vinv);
mydebug("vinv\n");
}
void N_VAddConst_NrnThread(N_Vector x, realtype b, N_Vector z)
{
bpass xpass zpass
nrn_multithread_job(vaddconst);
mydebug("vaddconst\n");
}
