Ejemplo n.º 1
0
def generate(morphologies=[16,17,18,19]):    
    for m in morphologies:
    #  try:
        db = Database(
            db_name='postgresql://hal08.g-node.pri/morphjongleur',
            exec_role='morphjokey_admin',
            exec_path='mitsubachi')
        
        # must be mapped before Object is created
        #mapping  = mrj.orm.experiment.Mapper( db.engine )
        mapping     = mrj.orm.morphology.Mapper( db.engine )
        mapping.orm_map()
        
        morphology = db.load_morphology( m )
        print morphology 

        iclamp  = mrj.model.clamp.IClamp(morphology.biggest)
        r  = mrj.model.experiment.RecordingPoint(morphology.compartments[len(morphology.compartments)-1])

        experiment  = mrj.model.experiment.Experiment(
                        morphology, 
                        clamps=[iclamp], recording_points=r, 
                        neuron_passive_parameter=Neuron_passive_parameter(Ra=35.4,g=0.001)
                    )
        db.store( experiment )
        print experiment

        experiment.run_simulation()
        voltage_trace   = experiment.get_voltage_trace()
        db.store( voltage_trace )
        print voltage_trace
Ejemplo n.º 2
0
def sinus_maxima(morphologies, rounds=3, frequency=265, xlim=None, ylim=None, picture_file='/tmp/', picture_formats=['png']):
    import numpy
    maxima  = {}
    minima  = {}
    titles  = {} 
    for morphology in morphologies:
       
        voltage_traces = {}
        cs  = [morphology.biggest]
        cs.extend( morphology.terminal_tips )
        print len(cs)
        
        print cs
        terminal_tips    = {}
        for c in cs:
            terminal_tips[c.radius]    = c
        cs  = terminal_tips.values()#TODO: remove pseudo representative choice
        print len(cs)
        print cs

        maxima[morphology]   = []
        minima[morphology]   = []
        titles[morphology]   = morphology.name
        for c in cs:
            recording_point  = mrj.model.experiment.RecordingPoint(compartment=morphology.biggest)
            print str(cs.index(c)+1)+"/"+str(len(cs))
            iclamp  = mrj.util.pattern_generator.SinusClamp(compartment=c, 
                        frequency=frequency, duration=rounds/float(frequency)
                    )
            neuron_passive_parameter    = Neuron_passive_parameter(Ra=35.4,g=0.001)
            experiment  = mrj.model.experiment.Experiment(
                            morphology, 
                            clamps=[iclamp], recording_points=[recording_point], 
                            neuron_passive_parameter=neuron_passive_parameter, 
                            duration=rounds/float(frequency),
                            dt=numpy.power(10, - (numpy.ceil(numpy.log10(265))+1) ),#one magnitue greater: e.g. 265 -> 1e-4, 
                            description = u"%f µm @ %i" % (c.radius, c.compartment_id)
                        )
            #print experiment
            experiment.run_simulation()
            voltage_trace   = recording_point.get_voltage_trace()
            maxima[morphology].append(voltage_trace.v_max)
            minima[morphology].append(voltage_trace.v_min)
            #print voltage_trace
            voltage_traces[c]    = voltage_trace
        voltage_traces[morphology.biggest].plot_ensemble(voltage_traces.values(), title="Voltagetrace in %s for sinusoidal inputsignal at %i Hz" % (morphology.name, frequency), ylim=ylim, picture_file=picture_file+'voltage_trace_f-'+str(frequency)+'_'+str(morphology.name), picture_formats=picture_formats)
    plot_daempfung(maxima.values(),titles=titles.values(), picture_file=picture_file+'/daempfung_maxima_f-265_'+str(morphology.name), picture_formats=picture_formats)
    plot_daempfung(minima.values(),titles=titles.values(), picture_file=picture_file+'/daempfung_minima_f-265_'+str(morphology.name), picture_formats=picture_formats)
Ejemplo n.º 3
0
def sinusclamp(morphology, rounds=3, frequency=265, picture_file='/tmp/voltage_trace_f-265_sinusclamp_', picture_formats=['png']):
    iclamp   = mrj.util.pattern_generator.SinusClamp(compartment=morphology.biggest,
                    frequency=frequency, duration=rounds/float(frequency)
                )
    r  = mrj.model.experiment.RecordingPoint(morphology.compartments[len(morphology.compartments)-1])

    experiment  = mrj.model.experiment.Experiment(
                    morphology=morphology, 
                    clamps=[iclamp], recording_points=r, 
                    neuron_passive_parameter    = Neuron_passive_parameter(Ra=35.4,g=0.001), 
                    duration=rounds/float(frequency)
                )
    print experiment
    experiment.run_simulation()
    voltage_trace   = r.get_voltage_trace()
    print voltage_trace
    voltage_trace.plot(picture_file=picture_file+str(morphology.name), picture_formats=picture_formats)
Ejemplo n.º 4
0
def experiment(morphology, compartment, frequency, amplitude):
        vclamp  = mrj.model.clamp.VClamp(compartment=morphology.biggest)
       
        iclamp  = mrj.util.pattern_generator.SinusClamp(compartment=compartment,
                    amplitude=amplitude,
                    frequency=frequency, duration=3./frequency
                )
        neuron_passive_parameter    = mrj.model.neuron_passive.Neuron_passive_parameter(Ra=35.4,g=0.001)
        experiment  = mrj.model.experiment.Experiment(
                        morphology, 
                        vclamps=[vclamp], iclamps=[iclamp], 
                        neuron_passive_parameter=neuron_passive_parameter, 
                        duration=3./frequency,
                        dt=1e-4,
                        description = "SinusExperiment %s %i %f" % (morphology.name, compartment.compartment_id, frequency),
                    )
        experiment.run_simulation()
        voltage_trace   = experiment.get_voltage_trace(delay=2./frequency)# nach Einschwinphase
        return mrj.model.sinusresult.SinusResult(voltage_trace, compartment, frequency, amplitude)
Ejemplo n.º 5
0
morphology = db.load_morphology( 256 )
print morphology 

#morphology.create_tree()
clamp   = IClamp(morphology.root.children[0])

neuron_passive_parameter    = Neuron_passive_parameter(Ra=80)
experiment  = Experiment(morphology, clamp, neuron_passive_parameter)
print experiment
db.store( experiment )

#TODO: change compartments needs group group mapping
#c   = m.getCompartment( 5 )
#c   = m.getCompartment( 7 )

experiment.neuron_create()
experiment.run_simulation()
result   = experiment.get_result()
print result
db.store( result )

e = db.load_experiment( experiment.experiment_key )
print e

e.run_simulation()
r   = e.get_result()
print r

experiment.plot_fit(r.r_in, r.tau_eff, r.tau_eff_fit)
plot( [experiment] )    # [e] works, (e) is flattend