Source code

001    package cnslab.cnsnetwork;
002    
003    import java.io.PrintStream;
004    import java.io.FileOutputStream;
005    import java.util.ArrayList;
006    import java.util.Iterator;
007    import java.util.Map;
008
009    import jpvm.*;
010
011    import cnslab.cnsmath.*;
012    import edu.jhu.mb.ernst.engine.DiscreteEventQueue;
013    import edu.jhu.mb.ernst.model.ModelFactory;
014    import edu.jhu.mb.ernst.model.ModulatedSynapse;
015    import edu.jhu.mb.ernst.util.seq.Seq;
016
017    /***********************************************************************
018    * Same as Network but Avalanche recorder is added. 
019    * 
020    * @version
021    *   $Date: 2012-08-04 13:43:22 -0500 (Sat, 04 Aug 2012) $
022    *   $Rev: 104 $
023    *   $Author: croft $
024    * @author
025    *   Yi Dong
026    * @author
027    *   David Wallace Croft
028    ***********************************************************************/
029    public class  ANetwork
030      extends Network
031    ////////////////////////////////////////////////////////////////////////
032    ////////////////////////////////////////////////////////////////////////
033    {
034    
035    public AvalancheCounter aData;
036
037    ////////////////////////////////////////////////////////////////////////
038    ////////////////////////////////////////////////////////////////////////
039    
040    public  ANetwork (
041      final ModelFactory               modelFactory,
042      final DiscreteEventQueue         discreteEventQueue,
043      final Seq<ModulatedSynapse>      modulatedSynapseSeq,
044      final Neuron [ ]                 neurons,
045      final Map<Integer, Axon>         axons,
046      final double                     minDelay,
047      final SimulatorParser            pas,
048      final Seed                       idum )
049    ////////////////////////////////////////////////////////////////////////
050    {
051      super (
052        modelFactory,
053        discreteEventQueue,
054        modulatedSynapseSeq,
055        neurons,
056        axons,
057        minDelay,
058        pas,
059        idum );
060    }
061
062    public  ANetwork (
063      final ModelFactory               modelFactory,
064      final DiscreteEventQueue         discreteEventQueue,
065      final Seq<ModulatedSynapse>      modulatedSynapseSeq,
066      final Neuron [ ]                 neurons,
067      final Map<Integer, Axon>         axons,
068      final JpvmInfo                   info,
069      final int                        base,
070      final double                     minDelay,
071      final SimulatorParser            pas,
072      final Seed                       idum,
073      final Experiment                 exp )
074    ////////////////////////////////////////////////////////////////////////
075    {
076      super (
077        modelFactory,
078        discreteEventQueue,
079        modulatedSynapseSeq,
080        neurons,
081        axons,
082        info,
083        base,
084        minDelay,
085        pas,
086        idum,
087        exp );
088      
089      this.aData = new AvalancheCounter(exp);
090    }
091
092    public  ANetwork (
093      final ModelFactory               modelFactory,
094      final DiscreteEventQueue         discreteEventQueue,
095      final Seq<ModulatedSynapse>      modulatedSynapseSeq,
096      final Experiment                 exp,
097      final JpvmInfo                   info,
098      final int                        base,
099      final double                     minDelay,
100      final SimulatorParser            pas,
101      final Seed                       idum )
102    ////////////////////////////////////////////////////////////////////////
103    {
104      super (
105        modelFactory,
106        discreteEventQueue,
107        modulatedSynapseSeq,
108        exp,
109        info,
110        base,
111        minDelay,
112        pas,
113        idum );
114      
115      this.aData = new AvalancheCounter(exp);
116    }
117
118    ////////////////////////////////////////////////////////////////////////
119    ////////////////////////////////////////////////////////////////////////
120    
121    public void initNet()
122    ////////////////////////////////////////////////////////////////////////
123    {
124//    subExpId=0; //the first subExp
125//    trialId=-1; // the first trial;
126
127      double tmp_time;
128      //    minDelay = 0.001; //minimum delay is 1ms
129      //    inputQueue = new PriQueue<InputEvent>(); // assign the queue
130      //  inputQueue = new FiboQueue<InputEvent>(); // assign the queue
131      //    inputQueue = new TreeQueue<InputEvent>(); // assign the queue
132      inputQueue = new MTreeQueue<InputEvent>(); // assign the queue
133
134      //    fireQueue = new TreeQueue<FireEvent>();
135      fireQueue = new MTreeQueue<FireEvent>();
136
137      //    if(bFreq>0.0)
138      //    {
139      poissonQueue = new MTreeQueue<PInputEvent>(); // assign the queue
140      //    }
141
142
143      stop=false;
144      if(  info !=null )
145      {
146        spikeBuffers = new SpikeBuffer[info.numTasks];
147        neurons[neurons.length-1]=new SYNNeuron(this);//adding the clock neuron at the end of neuron list
148        for(int i=0; i<info.numTasks;i++)
149        {
150          spikeBuffers[i]=new SpikeBuffer();
151        }
152
153        recordBuff = new RecordBuffer();
154
155        received  = new int[info.numTasks];
156        for(int iter=0;iter<info.numTasks;iter++)
157        {       
158          received[iter]= 1; //leave mark here
159        }
160
161        intraRecBuffers = new IntraRecBuffer(experiment.recorder.intraNeurons());
162
163        //send initial input spikes from the sensory neuron to all the neurons in the network
164        /*
165         for(int i= 1; i< neurons.length; i++)
166         {
167         tmp_time=-Math.log(Cnsran.ran2(idum))/5.0; // 5Hz background input
168         inputQueue.insertItem( new InputEvent(0,tmp_time,i,1e-10)); //sensory neuron send spikes to the other neurons
169         }
170         inputQueue.show();
171         */
172        /*
173         if(bFreq>0.0)
174         {
175      //      poissonQueue = new PriQueue<PInputEvent>(); // assign the queue
176      poissonQueue = new MTreeQueue<PInputEvent>(); // assign the queue
177      //    poissonQueue = new TreeQueue<PInputEvent>(); // assign the queue
178      for(int i=0; i<neurons.length; i++)
179      {
180      if(!neurons[i].isSensory())
181      {
182      poissonQueue.insertItem( new PInputEvent(-Math.log(Cnsran.ran2(idum))/bFreq , new Synapse(base+i,1e-10,0),0));
183      }
184      }
185         }
186         */
187        /*
188
189         for(int i=0; i<neurons.length; i++)
190         {
191         if(neurons[i].isSensory())
192         {
193         fireQueue.insertItem( new FireEvent(i+base,0.0)); //sensory neuron send spikes to the other neurons
194         }
195         }
196         */
197
198        try {
199          FileOutputStream out = new FileOutputStream("log/"+info.parentJpvmTaskId.getHost()+"_myfile"+info.idIndex+".txt");
200          p = new  PrintStream(out);
201          //    p.println(base+neurons[neurons.length-1].toString());
202          p.println("Logfile start");
203        }
204        catch(Exception ex) {
205        }
206
207        String curDir = System.getProperty("user.dir");
208        p.println(curDir);
209        //added
210        /*
211      for(int iter=0;iter<info.numTasks;iter++)
212      {       
213        while(!received[iter].empty())
214        {
215          received[iter].pop();
216        }
217        received[iter].push(new Object());
218      }
219         */
220        //added over
221
222      }
223//    init();
224
225    }
226
227    public void init()
228    ////////////////////////////////////////////////////////////////////////
229    {
230      double tmp_time;
231//    minDelay = 0.001; //minimum delay is 1ms
232      stop=false;
233
234//    trialDone=false;
235
236      spikeState=true;
237
238      /* this modification make old simulator done's run any more
239
240    trialId++;
241    if(trialId == exp.subExp[subExpId].repetition)
242    {       
243      trialId =0;
244      subExpId++;
245    }
246       */
247//    p.println("sub "+subExpId+ "tri: "+trialId);
248
249
250      if(subExpId < experiment.subExp.length) // only initilize when subExp is within the range
251      {
252        /*
253         for(int iter=0;iter<info.numTasks;iter++)
254         {       
255         while(!received[iter].empty())
256         {
257         received[iter].pop();
258         }
259         received[iter].push(new Object());
260         }
261         */
262
263        if(info !=null )
264        {
265          for(int i=0; i<info.numTasks;i++)
266          {
267            spikeBuffers[i].buff.clear();
268          }
269        }
270
271        //    recordBuff.buff.clear();
272
273        //      intraBuff.init(); //clear intracelluar info;
274
275        if(simulatorParser.backgroundFrequency>0.0)
276        {
277          for(int i=0; i<neurons.length; i++)
278          {
279            if(!neurons[i].isSensory())
280            {
281              poissonQueue.insertItem (
282                new PInputEvent (
283                  -Math.log ( Cnsran.ran2 ( seed ) )
284                    / simulatorParser.backgroundFrequency,
285                  modelFactory.createSynapse (
286                    base + i,
287                    ( byte ) simulatorParser.bChannel,
288                    ( float ) simulatorParser.backgroundStrength ),
289                  -1 ) );
290            }
291          }
292        }
293
294        //put the other sources of inputs
295        for(int i = 0 ; i< experiment.subExp[subExpId].stimuli.length; i++)
296        {
297          experiment.subExp[subExpId].stimuli[i].seed = seed; //unify the seed
298          //        p.println("input seed:"+exp.subExp[subExpId].sti[i].idum.seed);
299          ArrayList<PInputEvent> tmp = experiment.subExp[subExpId].stimuli[i].init(i);
300          Iterator<PInputEvent> iter = tmp.iterator();
301          while(iter.hasNext())
302          {
303            //          PInputEvent pin;
304            poissonQueue.insertItem(iter.next());
305            //          p.println(pin);
306          }
307        }
308
309        for(int i=0; i<neurons.length-1; i++)
310        {
311
312          //  p.println("init neuron seed:"+idum.seed);
313          neurons[i].init(subExpId,trialId, seed,this,i+base); //all neurons will be initiazed;
314
315          //    if(neurons[i].isSensory())
316          //    {
317          //        fireQueue.insertItem( new FireEvent(i+base,0.0)); //sensory neuron send spikes to the other neurons
318          //      fireQueue.insertItem( new FireEvent(i+base, neurons[i].updateFire() )); //sensory neuron send spikes to the other neurons
319
320          //    }
321          //  else
322          //  {
323          //  }
324        }
325        //      p.println("neurons number: "+neurons.length);
326        if(info !=null )
327        {
328
329          if(info.numTasks==1 && experiment.recorder.intraEle.size()==0){
330            fireQueue.insertItem( new AFireEvent(neurons.length-1+base,experiment.subExp[subExpId].trialLength,-1,-1)); //sensory neuron send spikes to the other neurons
331          }
332          else
333          {
334            fireQueue.insertItem( new AFireEvent(neurons.length-1+base,0.0,-1,-1)); //sensory neuron send spikes to the other neurons
335          }
336        }
337
338      }
339    }
340
341    /** 
342     *process the event from fireQueue 
343     * 
344     * @param pFirstFire 
345     */
346    public void pFireProcess(FireEvent firstFire) throws jpvmException,Exception
347    ////////////////////////////////////////////////////////////////////////
348    {
349
350      double tmp_firetime;
351      if(neurons[firstFire.index-base].realFire()) // only neuron really fires
352      {
353
354        //  System.out.println("neuron:"+(firstFire.index-base)+" fire:"+firstFire.time);
355        int host;
356        if(neurons[firstFire.index-base].getRecord()) //if the neuron is recordable
357        {
358          //      p.println(firstFire.index+" recorded");
359          recordBuff.buff.add(new NetRecordSpike(firstFire.time,firstFire.index));
360        }
361
362        if(((AFireEvent) firstFire).avalancheId>=0 && !neurons[firstFire.index-base].isSensory())
363        {
364          aData.CountIt(this,((AFireEvent) firstFire).sourceId,((AFireEvent) firstFire).avalancheId);
365        }
366
367
368        long target = neurons[firstFire.index-base].getTHost();
369        for(int i=0; i < info.numTasks; i++)
370        {
371          if((target & (1L<<i))!=0) // it has target at host i
372          {
373            if(i == info.idIndex)  //localhost 
374            {
375              for(int iter=0 ; iter< axons.get(firstFire.index).branches.length ; iter++)
376              {
377                inputQueue.insertItem(new AInputEvent(firstFire.time + axons.get(firstFire.index).branches[iter].delay,axons.get(firstFire.index).branches[iter],firstFire.index,((AFireEvent) firstFire).sourceId,((AFireEvent) firstFire).avalancheId));
378              }
379            }
380            else //remote host
381            {
382              spikeBuffers[i].buff.add( new ANetMessage(firstFire.time, firstFire.index, ((AFireEvent) firstFire).sourceId, ((AFireEvent) firstFire).avalancheId));
383            }
384          }
385        }
386      }
387
388      double timeOfNextEvent;
389      if( (timeOfNextEvent= neurons[firstFire.index-base].updateFire())>=0) //neuron do fire
390      {
391
392        tmp_firetime=firstFire.time+ timeOfNextEvent;
393        //  neurons[firstFire.index-base].timeOfFire();
394        int aval=((AFireEvent) firstFire).avalancheId;      
395        if(neurons[firstFire.index-base].isSensory())
396        {
397          aval=aData.getId(this);
398          //p.println("sensory start ava: " + aval);
399        }      
400
401        fireQueue.insertItem(new AFireEvent(firstFire.index, tmp_firetime, ((AFireEvent) firstFire).sourceId, ((AFireEvent) firstFire).avalancheId)); //insert this into the new firing queue;
402        neurons[firstFire.index-base].setTimeOfNextFire(tmp_firetime);
403      }
404      else
405      {
406        neurons[firstFire.index-base].setTimeOfNextFire(-1); //if the neuron doesn't fire
407      }
408      fireQueue.deleteItem(firstFire); //delete this item
409    }
410
411
412    public void pMainProcess(FireEvent firstFire, double freq, double weight, Seed idum)
413    ////////////////////////////////////////////////////////////////////////
414    {
415    }
416
417
418    /** 
419     *process the event from inputQueue 
420     * 
421     * @param firstInput 
422     */
423    public void inputProcess(InputEvent firstInput)
424    ////////////////////////////////////////////////////////////////////////
425    {
426
427      double tmp_firetime;
428      //System.out.println("input: "+firstInput);
429      // first delete the false prediction  
430      //System.out.println("input:"+firstInput);
431      for ( int i = 0; i < firstInput.branch.synapses.length ; i++)
432      {
433        //    if(firstInput.branch.synapses[i].to==8300)System.out.println("find trace"+firstInput+" 8300");
434        if( neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].getTimeOfNextFire() != -1) //if last time predicts the neuron will fire in future
435        {
436          //System.out.println(new FireEvent( firstInput.branch.synapses[i].getTargetNeuronIndex ( ), neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].getTimeOfNextFire()));
437          fireQueue.deleteItem( new AFireEvent( firstInput.branch.synapses[i].getTargetNeuronIndex ( ), neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].getTimeOfNextFire(),((AInputEvent) firstInput).sourceId,((AInputEvent) firstInput).avalancheId));
438        }
439
440        double timeOfNextEvent;
441        if(( timeOfNextEvent = neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].updateInput(firstInput.time,firstInput.branch.synapses[i])) >=0.0) //neuron do fire
442        {
443          tmp_firetime=firstInput.time+ timeOfNextEvent;
444          //neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].timeOfFire();
445          neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].setTimeOfNextFire(tmp_firetime);
446          fireQueue.insertItem(new AFireEvent(firstInput.branch.synapses[i].getTargetNeuronIndex ( ) , tmp_firetime, ((AInputEvent) firstInput).sourceId, ((AInputEvent) firstInput).avalancheId)); //insert this into the new firing queue;
447        }
448        else
449        {
450          neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].setTimeOfNextFire(-1); //if the neuron doesn't fire
451        }
452      }
453      inputQueue.deleteItem(firstInput); //delete this item
454    }
455
456    /** 
457     *poisson input process 
458     * 
459     * @param poiInput 
460     */
461    public void poissonProcess(PInputEvent poiInput)
462    ////////////////////////////////////////////////////////////////////////
463    {
464
465      double tmp_firetime;
466      if( neurons[poiInput.synapse.getTargetNeuronIndex ( )].getTimeOfNextFire() != -1) //if last time predicts the neuron will fire in future
467      {
468        //System.out.println(new FireEvent( firstInput.branch.synapses[i].getTargetNeuronIndex ( ), neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )].getTimeOfNextFire()));
469        fireQueue.deleteItem( new AFireEvent( poiInput.synapse.getTargetNeuronIndex ( ), neurons[poiInput.synapse.getTargetNeuronIndex ( )].getTimeOfNextFire(),0,0));
470      }
471
472      double timeOfNextEvent;
473      if( ( timeOfNextEvent = neurons[poiInput.synapse.getTargetNeuronIndex ( )].updateInput(poiInput.time,poiInput.synapse)) >=0.0 ) //neuron do fire
474      {
475        tmp_firetime=poiInput.time+ timeOfNextEvent;
476        //neurons[poiInput.synapse.getTargetNeuronIndex ( )].timeOfFire();
477        neurons[poiInput.synapse.getTargetNeuronIndex ( )].setTimeOfNextFire(tmp_firetime);
478        fireQueue.insertItem(new AFireEvent(poiInput.synapse.getTargetNeuronIndex ( ) , tmp_firetime,info.idIndex,aData.getId(this))); //insert this into the new firing queue;
479      }
480      else
481      {
482        neurons[poiInput.synapse.getTargetNeuronIndex ( )].setTimeOfNextFire(-1); //if the neuron doesn't fire
483      }
484      poissonQueue.insertItem( new PInputEvent(poiInput.time+(-Math.log(Cnsran.ran2(seed))/simulatorParser.backgroundFrequency) , poiInput.synapse,-1));
485      poissonQueue.deleteItem(poiInput); //delete this item
486    }
487
488
489    /** 
490     *poisson input process 
491     * 
492     * @param poiInput 
493     */
494    public void pPoissonProcess(PInputEvent poiInput)
495    ////////////////////////////////////////////////////////////////////////
496    {
497//  p.println("t:"+poiInput.time+" sourceID:"+poiInput.sourceId+" id"+poiInput.synapse.getTargetNeuronIndex ( )+" syn:"+poiInput.synapse);
498//  p.flush();
499//  fireQueue.show(p);
500//  inputQueue.show(p);
501//  poissonQueue.show(p);
502
503
504      double tmp_firetime;
505      if( neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].getTimeOfNextFire() != -1) //if last time predicts the neuron will fire in future
506      {
507        fireQueue.deleteItem( new AFireEvent( poiInput.synapse.getTargetNeuronIndex ( ), neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].getTimeOfNextFire(), 0,0));
508      }
509
510      double timeOfNextEvent;
511      if(( timeOfNextEvent = neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].updateInput(poiInput.time,poiInput.synapse))>=0.0) //neuron do fire
512      {
513//  p.println("neuron fire");
514//  p.flush();
515
516        tmp_firetime=poiInput.time+ timeOfNextEvent;
517        //neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].timeOfFire();
518        fireQueue.insertItem(new AFireEvent(poiInput.synapse.getTargetNeuronIndex ( ) , tmp_firetime, info.idIndex, aData.getId(this))); //insert this into the new firing queue;
519        neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].setTimeOfNextFire(tmp_firetime);          
520//  p.println("neuron time caled");
521//  p.flush();
522
523      }
524      else
525      {
526//  p.println("neuron doesn't fire");
527//  p.flush();
528        neurons[poiInput.synapse.getTargetNeuronIndex ( )-base].setTimeOfNextFire(-1); //if the neuron doesn't fire
529      }
530//  p.println("input is updated");
531//  p.flush();
532      if(poiInput.sourceId==-1)
533      {
534        poissonQueue.insertItem( new PInputEvent(poiInput.time+(-Math.log(Cnsran.ran2(seed))/simulatorParser.backgroundFrequency) , poiInput.synapse,-1));
535      }
536      else
537      {
538        double timeOfNext = experiment.subExp[subExpId].stimuli[poiInput.sourceId].getNextTime(poiInput.time);
539        if(timeOfNext>=0)
540        {
541          //p.println("t:"+timeOfNext+" sourceID:"+poiInput.sourceId+" id"+poiInput.synapse.getTargetNeuronIndex ( ));
542          poissonQueue.insertItem( new PInputEvent(timeOfNext , poiInput.synapse, poiInput.sourceId));
543        }
544      }
545      poissonQueue.deleteItem(poiInput); //delete this item
546    }
547
548    /** 
549     *process the event from inputQueue 
550     * 
551     * @param firstInput 
552     */
553    public void pInputProcess(InputEvent firstInput)
554    {
555//  p.println("INPUT");
556//  fireQueue.show(p);
557//  inputQueue.show(p);
558//  poissonQueue.show(p);
559
560
561      double tmp_firetime;
562      for ( int i = 0; i < firstInput.branch.synapses.length ; i++)
563      {
564//    if(firstInput.branch.synapses[i].getTargetNeuronIndex ( )==8300)p.println("find trace"+firstInput+" 8300");
565        if( neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].getTimeOfNextFire() != -1) //if last time predicts the neuron will fire in future
566        {
567          fireQueue.deleteItem( new AFireEvent( firstInput.branch.synapses[i].getTargetNeuronIndex ( ), neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].getTimeOfNextFire(), ((AInputEvent) firstInput).sourceId, ((AInputEvent) firstInput).avalancheId));
568        }
569
570        double timeOfNextEvent;
571        if( (timeOfNextEvent = neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].updateInput(firstInput.time,firstInput.branch.synapses[i]))>=0.0) //neuron do fire
572        {
573          tmp_firetime=firstInput.time + timeOfNextEvent;
574          //      neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].timeOfFire();
575          fireQueue.insertItem(new AFireEvent(firstInput.branch.synapses[i].getTargetNeuronIndex ( ) , tmp_firetime, ((AInputEvent) firstInput).sourceId, ((AInputEvent) firstInput).avalancheId)); //insert this into the new firing queue;
576          neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].setTimeOfNextFire(tmp_firetime);
577        }
578        else
579        {
580          neurons[firstInput.branch.synapses[i].getTargetNeuronIndex ( )-base].setTimeOfNextFire(-1); //if the neuron doesn't fire
581        }
582      }
583      inputQueue.deleteItem(firstInput); //delete this item
584    }
585/*
586  public void testRun()
587  {
588    FireEvent firstFire;
589    InputEvent firstInput;
590    PInputEvent poiInput;
591    double minTime;
592    double fireTime, inputTime, pInputTime;
593//    System.out.println("before running...");
594
595//    inputQueue.show();
596
597    while(!stop)
598    {
599      firstFire =  fireQueue.firstItem(); // take out the first fire element
600      firstInput =  inputQueue.firstItem(); // take out the first input element
601      poiInput =  poissonQueue.firstItem(); // take out the first poisson input element
602
603//      System.out.println("running...");
604
605      if(firstFire != null)
606      {
607        fireTime=firstFire.time;
608      }
609      else
610      {
611        fireTime=Double.MAX_VALUE;
612      }
613
614      if(firstInput != null)
615      {
616        inputTime=firstInput.time;
617      }
618      else
619      {
620        inputTime=Double.MAX_VALUE;
621      }
622
623      if(poiInput != null)
624      {
625        pInputTime=poiInput.time;
626      }
627      else
628      {
629        pInputTime=Double.MAX_VALUE;
630      }
631
632      minTime = ( fireTime < inputTime? fireTime: inputTime); 
633      minTime = (minTime < pInputTime? minTime: pInputTime);
634
635      if( firstFire != null && minTime == firstFire.time) //fire event
636      {
637//        System.out.println("fire.."+firstFire);
638        fireProcess(firstFire);
639
640      }
641      else if ( firstInput !=null && minTime == firstInput.time) //input event
642      {
643        //        System.out.println("input..");
644        inputProcess(firstInput);
645      }
646      else if (  poiInput !=null && minTime == poiInput.time) //poissoninput event
647      {
648//        System.out.println("background: "+poiInput.synapse.getTargetNeuronIndex ( ));
649        poissonProcess(poiInput);
650      }
651    }
652  }
653 */
654    
655    ////////////////////////////////////////////////////////////////////////
656    ////////////////////////////////////////////////////////////////////////
657    }