nrnnemo.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
 
#include "section.h"
 
 
#define OBSOLETE 1
 
#if !OBSOLETE
#include "membfunc.h"
#include "hocassrt.h"
 
/* basic loop taken from topology() in solve.cpp */
static FILE *fin, *fmark, *fdat;
static int inode;
static dashes(), file_func(), dat_head();
#define MAXMARKS 32
static long* marksec;
static printline();
 
extern int section_count;
extern Section** secorder;
#endif
 
void nemo2neuron(void) {
    hoc_retpushx(1.0);
}
 
void neuron2nemo(void) {
#if OBSOLETE
    hoc_execerror("neuron2nemo:", "implementation is obsolete");
#else
    short i, isec, imark;
    extern int tree_changed;
    char name[50];
 
    if (tree_changed) {
        setup_topology();
    }
    Sprintf(name, "in/%s", gargstr(1));
    if ((fin = fopen(name, "w")) == (FILE*) 0) {
        hoc_execerror("Can't write to ", name);
    }
    Sprintf(name, "mark/%s", gargstr(1));
    if ((fmark = fopen(name, "w")) == (FILE*) 0) {
        hoc_execerror("Can't write to ", name);
    }
    Sprintf(name, "dat/%s", gargstr(1));
    if ((fdat = fopen(name, "w")) == (FILE*) 0) {
        hoc_execerror("Can't write to ", name);
    }
    dat_head();
 
    /* set up the mark for every section */
    imark = 1;
    marksec = (long*) ecalloc(section_count, sizeof(long));
    for (i = 1; i < section_count; i++) {
        isec = i;
        if (marksec[isec]) {
            marksec[i] = marksec[isec];
        } else {
            if (imark < MAXMARKS) {
                marksec[i] = 1L << (imark++);
                file_func(secorder[isec]);
            }
        }
    }
    Fprintf(fin, "/* created by NEURON */\n");
    inode = 0;
    for (i = 0; i < rootnodecount; i++) {
        printline(v_node[i]->child, 0, 0., (double) (i * 100));
        dashes(v_node[i]->child, 0., (double) (i * 100), 0., 1);
    }
    free((char*) marksec);
    fclose(fin);
    fclose(fmark);
#endif
    hoc_retpushx(1.0);
}
 
#if !OBSOLETE
static dashes(Section* sec, double x, double y, double theta, int leftend) {
    Section* ch;
    int i, nrall, irall;
    double cos(), sin(), xx, yy, ttheta, dx;
 
    dx = section_length(sec) / ((double) sec->nnode - 1);
    nrall = (int) sec->prop->dparam[4].val;
    for (irall = 0; irall < nrall; irall++) {
        xx = x;
        yy = y;
        ttheta = theta + (double) (nrall - 2 * irall - 1) / (double) nrall;
        for (i = 0; i < sec->nnode - 1; i++) {
            xx += dx * cos(ttheta);
            yy += dx * sin(ttheta);
            printline(sec, i, xx, yy);
        }
        for (i = sec->nnode - 1; i >= 0; i--) {
            if ((ch = sec->pnode[i]->child) != (Section*) 0) {
                if (i == sec->nnode - 1) {
                    dashes(ch, xx, yy, ttheta, 0);
                } else {
                    dashes(ch, xx, yy, ttheta + .5, 0);
                }
            }
            if (i < sec->nnode - 1) {
                xx -= dx * cos(ttheta);
                yy -= dx * sin(ttheta);
            }
        }
        if (leftend) {
            ttheta = 3.14159 - .5;
        }
        if ((ch = sec->sibling) != (Section*) 0) {
            dashes(ch, x, y, ttheta + .5, 0);
        }
    }
}
 
static double diamval(Node* nd) {
    Prop* p;
 
    for (p = nd->prop; p; p = p->next) {
        if (p->type == MORPHOLOGY) {
            break;
        }
    }
    assert(p);
    return p->param[0];
}
 
static void printline(Section* sec, int i, double x, double y) {
    char type;
    int nb;
    Section* csec;
    Node* nd;
    double d;
 
    ++inode;
    assert(sec->nnode > 1);
    type = 'C';
    nd = sec->pnode[i];
    d = diamval(nd);
    nb = 0;
    for (csec = nd->child; csec; csec = csec->sibling) {
        nb += (int) csec->prop->dparam[4].val;
    }
    if (i == sec->nnode - 2) {
        ++i;
        nd = sec->pnode[i];
        for (csec = nd->child; csec; csec = csec->sibling) {
            nb += (int) csec->prop->dparam[4].val;
        }
    }
    if (i < sec->nnode - 2) {
        nb++;
    }
    if (nb > 2) { /*many branches*/
        type = 'B';
        x -= .001;
        while (nb > 2) {
            fwrite((char*) &marksec[sec->order], sizeof(long), 1, fmark);
            Fprintf(fin, "%d\t%c\t%g\t%g\t0\t%g\n", inode++, type, (x += .001), y, d);
            --nb;
        }
    } else if (nb == 2) { /*one branch*/
        type = 'B';
    } else if (nb == 0) {
        type = 'T';
    }
    fwrite((char*) &marksec[sec->order], sizeof(long), 1, fmark);
    Fprintf(fin, "%d\t%c\t%g\t%g\t0\t%g\n", inode, type, x, y, d);
}
 
/* modified from nemo.cpp */
static void file_func(Section* sec) {
    int active;
    Node* nd;
    Prop* p;
    Symbol *s, *hoc_lookup();
    static int hhtype = 0;
 
    if (!hhtype) {
        s = hoc_lookup("HH");
        hhtype = s->subtype;
    }
    nd = sec->pnode[0];
 
    active = 0;
    for (p = nd->prop; p; p = p->next) {
        if (p->type == hhtype) {
            active = 1;
        }
    }
 
    assert(sec->prop->dparam[0].sym);
    fprintf(fdat, "%s\n", sec->prop->dparam[0].sym->name);
    fprintf(fdat, "^area %g\n", 1.);
    fprintf(fdat, "^Rm %g\n", 1.);
    fprintf(fdat, "^active %d\n", active);
    fprintf(fdat, "^synapse %d\n", 0);
    fprintf(fdat, "^Erev %g\n", 0.);
    fprintf(fdat, "^gback %g\n", 0.);
    fprintf(fdat, "^gsyn %g\n", 0.);
    fprintf(fdat, "^tstart %g\n", 0.);
    fprintf(fdat, "^twidth %g\n", 0.);
}
 
static void dat_head(void) {
    double Ra = 35.4;
 
    fprintf(fdat, "freq\n");
    fprintf(fdat, "%d %g %g\n", 4, 1., 1000.);
 
    fprintf(fdat, "tran\n");
    fprintf(fdat, "%g %g\n", .1, 10.);
 
    fprintf(fdat, "elec\n");
    fprintf(fdat, "%g %g %g\n", 1000., 1.e-6, Ra);
 
    fprintf(fdat, "syn\n");
    fprintf(fdat, "%g %g\n", 30., -15.);
 
    fprintf(fdat, "hh\n");
    fprintf(fdat, "%g %g %g %g %g %g\n", 1., 1., 1., 1., 1., 1.);
 
    fprintf(fdat, "batt\n");
    fprintf(fdat, "%g %g\n", 115., -12.);
 
    fprintf(fdat, "%10d\n", 9999);
}
 
#endif