glinerec.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
// we want to plot correctly during the local step method when
// cvode.solve(tstop) is invoked. However, not all GraphLine  are time graphs,
// so we assume that the time graphs will be added during stdinit
// during iteration over the graph lists of the stdrun implementation which
// calls Graph.simgraph(). Constantly updating during stdinit
// overcomes the problem of new addexpr, addval, and changed locations of
// point processes.
// Note: cvode.simgraph_remove() deletes all the GLineRecord instances.

#include "hocparse.h"
#include "code.h"
#undef begin
#undef add

#include <OS/list.h>
#include "nrnoc2iv.h"
#include "vrecitem.h"
#include "netcvode.h"
#include "cvodeobj.h"

#if HAVE_IV // to end of file
#include "graph.h"
#include "glinerec.h"
#include "ocjump.h"

extern NetCvode* net_cvode_instance;

class GLineRecordList;

declarePtrList(GLineRecordList, GLineRecord)
implementPtrList(GLineRecordList, GLineRecord)
static GLineRecordList* grl;

// Since GraphLine is not an observable, its destructor calls this.
// So ivoc will work, a stub is placed in ivoc/datapath.cpp
void graphLineRecDeleted(GraphLine* gl) {
    if (!grl) { return; }
    int i, cnt = grl->count();
    for (i = 0; i < cnt; ++i) {
        GLineRecord* r = grl->item(i);
        if (r->uses(gl)) {
            delete r;
            return;
        }
    }
}

void NetCvode::simgraph_remove() {
    if (!grl) { return; }
    while (grl->count()) {
        delete grl->item(grl->count()-1);
    }
}
    
void Graph::simgraph() {
    int i, cnt;
    if (!grl) { grl = new GLineRecordList(); }
    cnt = line_list_.count();
    for (i = 0; i < cnt; ++i) {
        GraphLine* gl = line_list_.item(i);
        PlayRecord* pr = net_cvode_instance->playrec_uses(gl);
        if (pr) {
            delete pr;
        }
        GLineRecord* r = new GLineRecord(gl);
        grl->append(r);
    }
}

void GLineRecord::fill_pd1() {
  Inst* pcsav = hoc_pc;
  for (hoc_pc = gl_->expr_->u.u_proc->defn.in; hoc_pc->in != STOP;) { // run machine analogous to hoc_execute(inst);
    double* pd = NULL;
    Inst* pc1 = hoc_pc++; // must be incremented before the function return.
    if (pc1->pf == rangepoint) {
        hoc_pushx(0.5); // arc position
        rangevarevalpointer();
        pd = hoc_pxpop();
        hoc_pushx(*pd);
    }else if (pc1->pf == rangevareval) {
        rangevarevalpointer();
        pd = hoc_pxpop();
        hoc_pushx(*pd);
    }else if (pc1->pf == varpush) {
        Symbol* sym = hoc_pc->sym;
        if (strcmp(sym->name, "t") == 0) {
          saw_t_ = true;
        }
        hoc_varpush();
    }else{
        (*((pc1)->pf))();
    }
    if (pd) {
      pd_and_vec_.push_back(std::pair<double*, IvocVect*>(pd, NULL));
    }
  }
  hoc_pc = pcsav;

#if 0
  Symbol* esym = gl_->expr_;
  int sz = esym->u.u_proc->size;
  Inst* inst = esym->u.u_proc->defn.in;
  printf("\n%s\n", gl_->name());
  for (int i = 0; i < sz; ++i) {
    hoc_debugzz(inst + i);
  }
#endif
}

void GLineRecord::fill_pd() {
  // Call only if cache_efficient will not change pointers before useing
  // the results of his computation.

  // Get rid of old pd_and_vec_ info.
  for (GLineRecordEData::iterator it = pd_and_vec_.begin(); it != pd_and_vec_.end(); ++it) {
    if ((*it).second) {
      delete (*it).second;
    }
  }
  pd_and_vec_.resize(0);
  saw_t_ = false;
  pd_ = gl_->pval_;
  if (pd_) {
    return;
  }

  // Execute the expr Inst by Inst but when rangepoint or
  // rangevareval are seen, execute a series of stack machine instructions
  // that give us the pointer to the range variable (see the implementation
  // in nrn/src/nrnoc/cabcode.cpp) but leaving the stack as though the
  // original instruction was executed.
  assert(gl_->expr_);
  ObjectContext objc(gl_->obj_);
  fill_pd1();
  objc.restore();
#if 0
  printf("\n%s\n", gl_->name());
  for (GLineRecordEData::iterator it = pd_and_vec_.begin(); it != pd_and_vec_.end(); ++it) {
    printf("  pd=%p\n", (*it).first);
  }
#endif
}

GLineRecord::GLineRecord(GraphLine* gl) : PlayRecord(NULL){
    //shouldnt be necessary but just in case
//  printf("GLineRecord %p name=%s\n", this, gl->name());
    gl_ = gl;
    gl_->simgraph_activate(true);
    v_ = NULL;
    saw_t_ = false;
}

GVectorRecord::GVectorRecord(GraphVector* gv) : PlayRecord(NULL) {
  //printf("GVectorRecord %p\n", this);
  gv_ = gv;
}

void GraphVector::record_install() {
  //printf("GraphVector::record_install()\n");
  GVectorRecord* gvr = new GVectorRecord(this);
}

void GraphVector::record_uninstall() {
  //printf("GraphVector::record_uninstall()\n");
}

GLineRecord::~GLineRecord(){
//  printf("~GLineRecord %p\n", this);
    int i;
    if (v_) {
        delete v_;
        v_ = NULL;
    }

  for (GLineRecordEData::iterator it = pd_and_vec_.begin(); it != pd_and_vec_.end(); ++it) {
    if ((*it).second) {
      delete (*it).second;
    }
  }

    for (i = grl->count()-1; i >= 0; --i) {
        if (grl->item(i) == this) {
            gl_->simgraph_activate(false);
            grl->remove(i);
            return;
        }
    }
}

GVectorRecord::~GVectorRecord() {
  printf("~GVectorRecord %p\n", this);
#if 0 // for now not allowing vector buffering
  for (GLineRecordEData::iterator it = pd_and_vec_.begin(); it != pd_and_vec_.end(); ++it) {
    if ((*it).second) {
      delete (*it).second;
    }
  }
#endif
}

void GLineRecord::record_init() {
  gl_->simgraph_init();
}

void GVectorRecord::record_init() {
}

void GLineRecord::continuous(double t) {
  gl_->simgraph_continuous(t);
}

void GVectorRecord::continuous(double t) {
}

int GVectorRecord::count() {
  return gv_->py_data()->count();
}
double* GVectorRecord::pdata(int i) {
  return gv_->py_data()->p(i);
}

void GLineRecord::plot(int vecsz, double tstop) {
  double dt = tstop/double(vecsz-1);
  DataVec* x = (DataVec*)gl_->x_data();
  DataVec* y = (DataVec*)gl_->y_data();
  if (v_) {
    v_->resize(vecsz);
    double* v = vector_vec(v_);
    for (int i=0; i < vecsz; ++i) {
      x->add(dt*i);
      y->add(v[i]);
    }
  }else if (gl_->expr_) {
    // transfer elements to range variables and plot expression result
    ObjectContext obc(NULL);
    for (int i=0; i < vecsz; ++i) {
      x->add(dt*i);
      for (GLineRecordEData::iterator it = pd_and_vec_.begin(); it != pd_and_vec_.end(); ++it) {
        double* pd = (*it).first;
        *pd = (*it).second->elem(i);
      }
      gl_->plot();
    }
    obc.restore();
  }else{
    assert(0);
  }
}
#else // do not HAVE_IV
void NetCvode::simgraph_remove() {}
#endif // HAVE_IV