hocevent.cpp

Go to the documentation of this file.

#include <objcmd.h>
#include <pool.h>
#include <netcon.h>
#include <nrnoc2iv.h>
#include <mymath.h>
 
extern int cvode_active_;
 
declarePool(HocEventPool, HocEvent)
    implementPool(HocEventPool, HocEvent) HocEventPool* HocEvent::hepool_;
 
HocEvent::HocEvent() {
    stmt_ = nil;
    ppobj_ = nil;
    reinit_ = 0;
}
 
HocEvent::~HocEvent() {
    if (stmt_) {
        delete stmt_;
    }
}
 
void HocEvent::pr(const char* s, double tt, NetCvode* ns) {
    Printf("%s HocEvent %s %.15g\n", s, stmt_ ? stmt_->name() : "", tt);
}
 
HocEvent* HocEvent::alloc(const char* stmt, Object* ppobj, int reinit, Object* pyact) {
    if (!hepool_) {
        nrn_hoc_lock();
        if (!hepool_) {
            hepool_ = new HocEventPool(100, 1);
        }
        nrn_hoc_unlock();
    }
    HocEvent* he = hepool_->alloc();
    he->stmt_ = nil;
    he->ppobj_ = ppobj;
    he->reinit_ = reinit;
    if (pyact) {
        he->stmt_ = new HocCommand(pyact);
    } else if (stmt) {
        he->stmt_ = new HocCommand(stmt);
    }
    return he;
}
 
void HocEvent::hefree() {
    if (stmt_) {
        delete stmt_;
        stmt_ = nil;
    }
    hepool_->hpfree(this);
}
 
void HocEvent::clear() {
    if (stmt_) {
        delete stmt_;
        stmt_ = nil;
    }
}
 
void HocEvent::deliver(double tt, NetCvode* nc, NrnThread* nt) {
    extern double t;
    if (!ppobj_) {
        nc->allthread_handle(tt, this, nt);
        return;
    }
    if (stmt_) {
        if (nrn_nthread > 1 || nc->is_local()) {
            if (!ppobj_) {
                hoc_execerror(
                    "multiple threads and/or local variable time step method require an "
                    "appropriate POINT_PROCESS arg to CVode.event to safely execute:",
                    stmt_->name());
            }
            Cvode* cv = (Cvode*) ob2pntproc(ppobj_)->nvi_;
            if (cv && cvode_active_) {
                nc->local_retreat(tt, cv);
                if (reinit_) {
                    cv->set_init_flag();
                }
                nt->_t = cv->t_;
            }
            nrn_hoc_lock();
            t = tt;
        } else if (cvode_active_ && reinit_) {
            nc->retreat(tt, nc->gcv_);
            assert(MyMath::eq(tt, nc->gcv_->t_, NetCvode::eps(tt)));
            assert(tt == nt->_t);
            nc->gcv_->set_init_flag();
            t = tt;
        } else {
            t = nt_t = tt;
        }
        stmt_->execute(false);
        if (nrn_nthread > 1 || nc->is_local()) {
            nrn_hoc_unlock();
        }
    }
    hefree();
}
 
void HocEvent::allthread_handle() {
    if (stmt_) {
        stmt_->execute(false);
    } else {
        tstopset;
    }
    hefree();
}
 
void HocEvent::pgvts_deliver(double tt, NetCvode* nc) {
    deliver(tt, nc, nrn_threads);
}
 
void HocEvent::reclaim() {
    if (hepool_) {
        hepool_->free_all();
    }
}
 
DiscreteEvent* HocEvent::savestate_save() {
    //  pr("HocEvent::savestate_save", 0, net_cvode_instance);
    HocEvent* he = new HocEvent();
    if (stmt_) {
        if (stmt_->pyobject()) {
            he->stmt_ = new HocCommand(stmt_->pyobject());
        } else {
            he->stmt_ = new HocCommand(stmt_->name(), stmt_->object());
        }
        he->reinit_ = reinit_;
        he->ppobj_ = ppobj_;
    }
    return he;
}
 
void HocEvent::savestate_restore(double tt, NetCvode* nc) {
    //  pr("HocEvent::savestate_restore", tt, nc);
    HocEvent* he = alloc(nil, nil, 0);
    NrnThread* nt = nrn_threads;
    if (stmt_) {
        if (stmt_->pyobject()) {
            he->stmt_ = new HocCommand(stmt_->pyobject());
        } else {
            he->stmt_ = new HocCommand(stmt_->name(), stmt_->object());
        }
        he->reinit_ = reinit_;
        he->ppobj_ = ppobj_;
        if (ppobj_) {
            nt = (NrnThread*) ob2pntproc(ppobj_)->_vnt;
        }
    }
    nc->event(tt, he, nt);
}
 
DiscreteEvent* HocEvent::savestate_read(FILE* f) {
    HocEvent* he = new HocEvent();
    int have_stmt, have_obj, index;
    char stmt[256], objname[100], buf[200];
    Object* obj = nil;
    //  nrn_assert(fscanf(f, "%d %d\n", &have_stmt, &have_obj) == 2);
    nrn_assert(fgets(buf, 200, f));
    nrn_assert(sscanf(buf, "%d %d\n", &have_stmt, &have_obj) == 2);
    if (have_stmt) {
        nrn_assert(fgets(stmt, 256, f));
        stmt[strlen(stmt) - 1] = '\0';
        if (have_obj) {
            //          nrn_assert(fscanf(f, "%s %d\n", objname, &index) == 1);
            nrn_assert(fgets(buf, 200, f));
            nrn_assert(sscanf(buf, "%s %d\n", objname, &index) == 1);
            obj = hoc_name2obj(objname, index);
        }
        he->stmt_ = new HocCommand(stmt, obj);
    }
    return he;
}
 
void HocEvent::savestate_write(FILE* f) {
    fprintf(f, "%d\n", HocEventType);
    fprintf(f, "%d %d\n", stmt_ ? 1 : 0, (stmt_ && stmt_->object()) ? 1 : 0);
    if (stmt_) {
        fprintf(f, "%s\n", stmt_->name());
        if (stmt_->object()) {
            fprintf(f, "%s %d\n", stmt_->object()->ctemplate->sym->name, stmt_->object()->index);
        }
    }
}