001 package cnslab.cnsnetwork; 002 003 import java.io.*; 004 import java.util.*; 005 import org.w3c.dom.bootstrap.DOMImplementationRegistry; 006 import org.w3c.dom.ls.DOMImplementationLS; 007 import org.w3c.dom.ls.LSSerializer; 008 import org.w3c.dom.ls.LSOutput; 009 010 import jpvm.*; 011 012 import cnslab.cnsmath.*; 013 014 /*********************************************************************** 015 * Same as MainSimulator but deals with avalanche 016 * 017 * @version 018 * $Date: 2012-08-04 13:43:22 -0500 (Sat, 04 Aug 2012) $ 019 * $Rev: 104 $ 020 * $Author: croft $ 021 * @author 022 * Yi Dong 023 * @author 024 * David Wallace Croft, M.Sc. 025 * @author 026 * Jeremy Cohen 027 ***********************************************************************/ 028 public class AMainSimulator extends MainSimulator 029 //////////////////////////////////////////////////////////////////////// 030 //////////////////////////////////////////////////////////////////////// 031 { 032 033 public AMainSimulator( Seed idum, String modelFile, int heapSize) 034 //////////////////////////////////////////////////////////////////////// 035 { 036 super(idum, modelFile, heapSize); 037 } 038 039 /* 040 public class ToDo { 041 Timer timer; 042 043 public ToDo ( int seconds ) { 044 timer = new Timer ( ) ; 045 timer.schedule ( new ToDoTask ( ) , seconds*1000, seconds*1000) ; 046 } 047 048 049 class ToDoTask extends TimerTask { 050 public void run ( ) { 051 jpvmBuffer buf; 052 try { 053 if(info.endIndex.length==1 && exp.rec.intraEle.size()==0) 054 { 055 for(int i = 0 ; i < info.numTasks; i++) 056 { 057 buf = new jpvmBuffer(); 058 buf.pack(i); 059 // System.out.println("pack "+i); 060 info.jpvm.pvm_mcast(buf,netTids[i],info.endIndex.length,NetMessageTag.checkTime); 061 } 062 } 063 else 064 { 065 buf = new jpvmBuffer(); 066 info.jpvm.pvm_mcast(buf,info.tids,info.numTasks,NetMessageTag.checkTime); 067 } 068 } 069 catch(jpvmException ex) { 070 ex.printStackTrace(); 071 System.exit(-1); 072 } 073 } 074 } 075 076 public void stop() 077 { 078 timer.cancel() ; 079 } 080 } 081 */ 082 public void run() 083 //////////////////////////////////////////////////////////////////////// 084 { 085 try { 086 087 //read network dom info 088 long simulationTime= System.currentTimeMillis(); 089 SimulatorParser pas = new SimulatorParser(idum, modelFile); 090 System.out.println("begin to map cells"); 091 pas.parseMapCells(); 092 pas.parseNeuronDef(); 093 System.out.println("begin to parseexp"); 094 pas.parseExperiment(); 095 System.out.println("experiment is parsed"); 096 experiment = pas.experiment; // experiment infomation 097 098 pas.findMinDelay(); 099 System.out.println("the mindelay is found"); 100 101 if(pas.documentType!=null) 102 { 103 pas.document.removeChild(pas.documentType); 104 } 105 DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance(); 106 DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS"); 107 LSSerializer writer = impl.createLSSerializer(); 108 LSOutput output = impl.createLSOutput(); 109 ByteArrayOutputStream bArray = new ByteArrayOutputStream(); 110 output.setByteStream(bArray); 111 writer.write(pas.document, output); 112 if(pas.documentType!=null) 113 { 114 pas.document.appendChild(pas.documentType); 115 } 116 byte [] ba = bArray.toByteArray(); 117 118 119 info= new JpvmInfo(); 120 // Enroll in the parallel virtual machine... 121 info.jpvm = new jpvmEnvironment(); 122 123 // Get my task id... 124 info.myJpvmTaskId = info.jpvm.pvm_mytid(); 125 System.out.println("Task Id: "+info.myJpvmTaskId.toString()); 126 127 info.numTasks= pas.parallelHost; // total number of trial hosts; 128 info.idIndex=info.numTasks; // root id; //not used at all 129 info.tids = new jpvmTaskId[info.numTasks]; 130 131 // Spawn some trialHosts 132 info.jpvm.pvm_spawn("cnslab.cnsnetwork.TrialHost",info.numTasks,info.tids,48); 133 System.out.println("spawn successfully"); 134 135 jpvmBuffer buf2 = new jpvmBuffer(); 136 // buf.pack(ba.length); //just send the 137 // buf.pack(ba, ba.length, 1); 138 139 buf2.pack(info.numTasks); 140 buf2.pack(info.tids, info.numTasks, 1); 141 buf2.pack(pas.minDelay); 142 143 info.jpvm.pvm_mcast(buf2,info.tids,info.numTasks,NetMessageTag.sendTids); 144 //send the different seed to the trialHost 145 /* 146 for(int i =0 ; i < info.numTasks; i++) 147 { 148 buf = new jpvmBuffer(); 149 buf.pack(seedInt); 150 seedInt--; 151 info.jpvm.pvm_send(buf,info.tids[i],NetMessageTag.sendSeed); 152 } 153 */ 154 155 System.out.println("All sent"); 156 157 //gernerate all the nethosts : 158 // 159 info.endIndex=pas.layerStructure.nodeEndIndices; 160 netJpvmTaskIds = new jpvmTaskId [info.numTasks][info.endIndex.length] ; 161 162 for(int i = 0 ; i < info.numTasks; i++) 163 { 164 System.out.println("generate child for trialHost "+i); 165 info.jpvm.pvm_spawn("cnslab.cnsnetwork.ANetHost",info.endIndex.length,netJpvmTaskIds[i],heapSize); //Net Host is to seperate large network into small pieces; 166 jpvmBuffer buf = new jpvmBuffer(); 167 buf.pack(info.endIndex.length); 168 buf.pack(netJpvmTaskIds[i],info.endIndex.length,1); 169 buf.pack(info.endIndex,info.endIndex.length,1); 170 seedInt = seedInt - info.endIndex.length; 171 buf.pack(seedInt); 172 buf.pack(info.tids[i]); //parent's tid; 173 buf.pack(ba.length); 174 buf.pack(ba, ba.length, 1); 175 info.jpvm.pvm_mcast(buf,netJpvmTaskIds[i],info.endIndex.length,NetMessageTag.sendTids); 176 } 177 178 for(int i = 0 ; i < info.numTasks; i++) 179 { 180 jpvmBuffer buf = new jpvmBuffer(); 181 buf.pack(info.endIndex.length); 182 buf.pack(netJpvmTaskIds[i],info.endIndex.length,1); 183 info.jpvm.pvm_send(buf,info.tids[i],NetMessageTag.sendTids2); //send trial Host the child tids 184 } 185 186 187 int trialId = -1; 188 int expId = 0; 189 int aliveHost = info.numTasks; 190 int totalTrials=0; 191 for(int j=0;j< experiment.subExp.length; j++) 192 { 193 totalTrials += experiment.subExp[j].repetition; 194 } 195 196 totalTrials = totalTrials * pas.numOfHosts; 197 198 LinkedList[] intraReceiver = new LinkedList[experiment.recorder.intraEle.size()*experiment.subExp.length]; 199 200 RecorderData rdata = new RecorderData(); 201 AvalancheCounter aData = new AvalancheCounter(experiment); 202 203 /* 204 HashMap<String, Integer> multiCounter = new HashMap<String, Integer>(); // don't consider trials 205 HashMap<String, Integer> multiCounterAll = new HashMap<String, Integer>(); // considering seperate trials 206 207 HashMap<String, Integer> fieldCounter = new HashMap<String, Integer>(); // different time section , neuron 208 209 HashMap<String, Double> vectorCounterX = new HashMap<String, Double>(); // different time section , neuron for X axis 210 HashMap<String, Double> vectorCounterY = new HashMap<String, Double>(); // different time section , neuron for Y axis 211 */ 212 213 214 215 boolean stop = false; 216 217 //Barrier Sync 218 for (int i=0;i<info.numTasks*info.endIndex.length+info.numTasks; i++) { 219 // Receive a message... 220 jpvmMessage message = info.jpvm.pvm_recv(NetMessageTag.readySig); 221 // Unpack the message... 222 String str = message.buffer.upkstr(); 223 System.out.println(str); 224 } 225 jpvmBuffer buf = new jpvmBuffer(); 226 /* 227 for(int i = 0 ; i < info.numTasks; i++) 228 { 229 info.jpvm.pvm_mcast(buf,netTids[i],info.endIndex.length,NetMessageTag.readySig); 230 } 231 */ 232 //info.jpvm.pvm_mcast(buf,info.tids,info.numTasks,NetMessageTag.readySig); 233 //Barrier Sync 234 long estimateTime = System.currentTimeMillis() - simulationTime; 235 System.out.format("****** Simulation is starting --- %dm:%ds was spent for connection\n" , estimateTime/60000, (estimateTime % 60000)/1000); 236 // System.out.println("************ simulation is starting *********************"); 237 ToDo toDo = new ToDo (5); //5 seconds 238 239 double [] per = new double[info.numTasks]; 240 int [] eeId = new int[info.numTasks]; 241 int [] ttId = new int[info.numTasks]; 242 243 int countDis =0; 244 int countHosts=0; 245 246 while(!stop) 247 { 248 jpvmMessage m = info.jpvm.pvm_recv(); //receive info from others 249 switch(m.messageTag) 250 { 251 case NetMessageTag.checkTime: 252 countDis ++; 253 int hostId = m.buffer.upkint(); 254 int eId = m.buffer.upkint(); 255 double root_time = m.buffer.upkdouble(); 256 int tId = m.buffer.upkint(); 257 per[hostId] = root_time/experiment.subExp[eId].trialLength*100; 258 eeId[hostId] = eId; 259 ttId[hostId] = tId; 260 if(countDis == info.numTasks) 261 { 262 countDis=0; 263 for(int ii=0; ii<info.numTasks; ii++)System.out.format("E%dT%d: %.1f%% ",eeId[ii], ttId[ii], per[ii]); 264 System.out.print("\r"); 265 } 266 break; 267 case NetMessageTag.trialReady: 268 int freeId = m.buffer.upkint(); //get free host id; 269 trialId++; 270 if(expId < experiment.subExp.length) 271 { 272 if(trialId == experiment.subExp[expId].repetition) 273 { 274 trialId =0; 275 expId++; 276 } 277 } 278 if(expId < experiment.subExp.length) // game is still on; 279 { 280 System.out.println(); 281 System.out.println("Subexp "+expId+" trial "+ trialId+" freeId "+freeId); 282 buf = new jpvmBuffer(); 283 buf.pack(trialId); 284 buf.pack(expId); 285 info.jpvm.pvm_send(buf,info.tids[freeId],NetMessageTag.oneTrial); 286 } 287 else if( aliveHost != 0 ) // if all the work are done and some hosts are not killed 288 { 289 if(toDo!=null) 290 { 291 toDo.stop(); 292 toDo=null; 293 System.out.println(); 294 } 295 296 System.out.println("host "+freeId+" is killed"); 297 buf = new jpvmBuffer(); 298 buf.pack(0); 299 info.jpvm.pvm_send(buf,info.tids[freeId],NetMessageTag.stopSig); 300 } 301 break; 302 case NetMessageTag.getBackData: 303 countHosts++; 304 if(countHosts== info.endIndex.length) {aliveHost--;countHosts=0;} 305 //System.out.println("Receiving data from "); 306 RecorderData spikes = (RecorderData)m.buffer.upkcnsobj(); 307 //System.out.print(m.buffer.upkint()+"\n"); 308 //comibne for single unit 309 Set entries = spikes.receiver.entrySet(); 310 Iterator entryIter = entries.iterator(); 311 while (entryIter.hasNext()) { 312 Map.Entry<String, LinkedList<Double> > entry = (Map.Entry<String, LinkedList<Double> >)entryIter.next(); 313 String key = entry.getKey(); // Get the key from the entry. 314 LinkedList<Double> value = entry.getValue(); // Get the value. 315 LinkedList<Double> tmp = rdata.receiver.get(key); 316 if(tmp == null) 317 { 318 rdata.receiver.put(key, tmp=(new LinkedList<Double>())); 319 } 320 //if( spike.time !=0.0 ) tmp.add(spike.time); //put received info into memory 321 tmp.addAll(value); //put received info into memory 322 } 323 ///comibne for multi unit 324 entries = spikes.multiCounter.entrySet(); 325 entryIter = entries.iterator(); 326 while (entryIter.hasNext()) { 327 Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>)entryIter.next(); 328 String key = entry.getKey(); // Get the key from the entry. 329 Integer value = entry.getValue(); // Get the value. 330 Integer tmp = rdata.multiCounter.get(key); 331 if(tmp == null) 332 { 333 rdata.multiCounter.put(key, tmp=(new Integer(0))); 334 } 335 tmp+=value; 336 rdata.multiCounter.put(key, tmp); 337 } 338 entries = spikes.multiCounterAll.entrySet(); 339 entryIter = entries.iterator(); 340 while (entryIter.hasNext()) { 341 Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>)entryIter.next(); 342 String key = entry.getKey(); // Get the key from the entry. 343 Integer value = entry.getValue(); // Get the value. 344 Integer tmp = rdata.multiCounterAll.get(key); 345 if(tmp == null) 346 { 347 rdata.multiCounterAll.put(key, tmp=(new Integer(0))); 348 } 349 tmp+=value; 350 rdata.multiCounterAll.put(key, tmp); 351 } 352 //combine for field ele 353 entries = spikes.fieldCounter.entrySet(); 354 entryIter = entries.iterator(); 355 while (entryIter.hasNext()) { 356 Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>)entryIter.next(); 357 String key = entry.getKey(); // Get the key from the entry. 358 // System.out.println(key); 359 Integer value = entry.getValue(); // Get the value. 360 Integer tmp = rdata.fieldCounter.get(key); 361 if(tmp == null) 362 { 363 rdata.fieldCounter.put(key, tmp=(new Integer(0))); 364 } 365 tmp+=value; 366 rdata.fieldCounter.put(key, tmp); 367 } 368 //combine for vector ele 369 entries = spikes.vectorCounterX.entrySet(); 370 entryIter = entries.iterator(); 371 while (entryIter.hasNext()) { 372 Map.Entry<String, Double> entry = (Map.Entry<String, Double>)entryIter.next(); 373 String key = entry.getKey(); // Get the key from the entry. 374 Double value = entry.getValue(); // Get the value. 375 Double tmp = rdata.vectorCounterX.get(key); 376 if(tmp == null) 377 { 378 rdata.vectorCounterX.put(key, tmp=(new Double(0.0))); 379 } 380 tmp+=value; 381 rdata.vectorCounterX.put(key, tmp); 382 } 383 entries = spikes.vectorCounterY.entrySet(); 384 entryIter = entries.iterator(); 385 while (entryIter.hasNext()) { 386 Map.Entry<String, Double> entry = (Map.Entry<String, Double>)entryIter.next(); 387 String key = entry.getKey(); // Get the key from the entry. 388 Double value = entry.getValue(); // Get the value. 389 Double tmp = rdata.vectorCounterY.get(key); 390 if(tmp == null) 391 { 392 rdata.vectorCounterY.put(key, tmp=(new Double(0.0))); 393 } 394 tmp+=value; 395 rdata.vectorCounterY.put(key, tmp); 396 } 397 //processing avalanche part. 398 // System.out.println("num elements: "+m.buffer.num_list_elts); 399 AvalancheCounter avalanche = (AvalancheCounter)m.buffer.upkcnsobj(); 400 for(int i=0; i< avalanche.avalancheCounter.size(); i++) 401 { 402 for(int j=0; j< avalanche.avalancheCounter.get(i).size();j++) 403 { 404 entries = avalanche.avalancheCounter.get(i).get(j).entrySet(); 405 entryIter = entries.iterator(); 406 while (entryIter.hasNext()) { 407 Map.Entry<String, Integer> entry = (Map.Entry<String, Integer>)entryIter.next(); 408 String key = entry.getKey(); // Get the key from the entry. 409 Integer value = entry.getValue(); // Get the value. 410 Integer tmp = aData.avalancheCounter.get(i).get(j).get(key); 411 if(tmp == null) 412 { 413 aData.avalancheCounter.get(i).get(j).put(key, tmp=(new Integer(0))); 414 } 415 tmp+=value; 416 aData.avalancheCounter.get(i).get(j).put(key, tmp); 417 418 } 419 420 } 421 //System.out.println(key+" --> "+tmp); 422 } //DATA TRANSFERRED FROM PARALLEL THREADS TO HOST AVALANCHE COUNTER? 423 424 break; 425 case NetMessageTag.trialDone: 426 totalTrials--; 427 int res_trial = m.buffer.upkint(); 428 int res_exp = m.buffer.upkint(); 429 // System.out.println("R: "+"E"+res_exp+"T"+res_trial); 430 // RecordBuffer spikes = (RecordBuffer)m.buffer.upkcnsobj(); 431 IntraRecBuffer intra = (IntraRecBuffer)m.buffer.upkcnsobj(); 432 // System.out.println(intra); 433 // int totalsize = spikes.buff.size(); 434 // int n =0; 435 436 // Iterator<NetRecordSpike> iter_spike = spikes.buff.iterator(); 437 // System.out.println("spikes"+spikes.buff.size()); 438 /* 439 while(iter_spike.hasNext()) 440 { 441 n++; 442 if( (n%(totalsize/1000)) == 0)System.out.print("recording..."+(double)n/(double)totalsize+"\r"); 443 NetRecordSpike spike = iter_spike.next(); 444 445 //single unit processing 446 if(exp.rec.singleUnit.contains(spike.from)) //if neuron is in single unit recorder 447 { 448 449 450 LinkedList<Double> tmp = receiver.get("E"+res_exp+"T"+res_trial+"N"+spike.from); 451 452 if(tmp == null) 453 { 454 receiver.put("E"+res_exp+"T"+res_trial+"N"+spike.from, tmp=(new LinkedList<Double>())); 455 } 456 //if( spike.time !=0.0 ) tmp.add(spike.time); //put received info into memory 457 tmp.add(spike.time); //put received info into memory 458 //System.out.println("fire: time:"+spike.time+ " index:"+spike.from); 459 } 460 //multiple unit processing 461 for(int mID = 0 ; mID < exp.rec.multiUnit.size(); mID++) 462 { 463 if(exp.rec.multiUnit.get(mID).contains(spike.from)) 464 { 465 int binIndex = (int)(spike.time/exp.rec.timeBinSize); 466 Integer tmpInt = multiCounter.get("E"+res_exp+"N"+mID+"B"+binIndex); 467 if(tmpInt == null) 468 { 469 multiCounter.put("E"+res_exp+"N"+mID+"B"+binIndex, tmpInt=(new Integer(0))); 470 } 471 tmpInt = tmpInt + 1; 472 multiCounter.put("E"+res_exp+"N"+mID+"B"+binIndex, tmpInt); 473 Integer tmpIntAll = multiCounterAll.get("E"+res_exp+"T"+res_trial+"N"+mID+"B"+binIndex); 474 if(tmpIntAll == null) 475 { 476 multiCounterAll.put("E"+res_exp+"T"+res_trial+"N"+mID+"B"+binIndex, tmpIntAll=(new Integer(0))); 477 } 478 tmpIntAll = tmpIntAll + 1; 479 multiCounterAll.put("E"+res_exp+"T"+res_trial+"N"+mID+"B"+binIndex, tmpIntAll); 480 481 } 482 } 483 //field processing 484 for(int fID = 0 ; fID < exp.rec.fieldEle.size(); fID++) 485 { 486 if(pas.ls.celllayer_test(spike.from,exp.rec.fieldEle.get(fID).getPrefix(),exp.rec.fieldEle.get(fID).getSuffix())) 487 { 488 int [] xy = pas.ls.celllayer_cordinate(spike.from,exp.rec.fieldEle.get(fID).getPrefix(),exp.rec.fieldEle.get(fID).getSuffix()); 489 int binIndex = (int)(spike.time/exp.rec.fieldTimeBinSize); 490 Integer tmpInt = fieldCounter.get("E"+res_exp+","+exp.rec.fieldEle.get(fID).getPrefix()+","+xy[0]+","+xy[1]+","+exp.rec.fieldEle.get(fID).getSuffix()+","+"B"+binIndex); 491 if(tmpInt == null) 492 { 493 fieldCounter.put("E"+res_exp+","+exp.rec.fieldEle.get(fID)+","+xy[0]+","+xy[1]+","+exp.rec.fieldEle.get(fID).getSuffix()+","+"B"+binIndex, tmpInt=(new Integer(0))); 494 } 495 tmpInt = tmpInt + 1; 496 fieldCounter.put("E"+res_exp+","+exp.rec.fieldEle.get(fID).getPrefix()+","+xy[0]+","+xy[1]+","+exp.rec.fieldEle.get(fID).getSuffix()+","+"B"+binIndex, tmpInt); 497 } 498 } 499 //vector processing 500 for(int vID = 0 ; vID < exp.rec.vectorUnit.size(); vID++) 501 { 502 for(int cID =0 ; cID < exp.rec.vectorUnit.get(vID).coms.size(); cID++) 503 { 504 if(pas.ls.celllayer_test(spike.from,exp.rec.vectorUnit.get(vID).coms.get(cID).layer.getPrefix(),exp.rec.vectorUnit.get(vID).coms.get(cID).layer.getSuffix())) 505 { 506 int [] xy = pas.ls.celllayer_cordinate(spike.from,exp.rec.vectorUnit.get(vID).coms.get(cID).layer.getPrefix(),exp.rec.vectorUnit.get(vID).coms.get(cID).layer.getSuffix()); 507 int binIndex = (int)(spike.time/exp.rec.vectorTimeBinSize); 508 Double tmpDX = vectorCounterX.get("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1]); 509 Double tmpDY = vectorCounterY.get("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1]); 510 511 if(tmpDX == null) 512 { 513 vectorCounterX.put("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1], tmpDX=(new Double(0.0))); 514 vectorCounterY.put("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1], tmpDY=(new Double(0.0))); 515 } 516 517 tmpDX = tmpDX + Math.cos( Math.PI/180.0*(double)exp.rec.vectorUnit.get(vID).coms.get(cID).orientation); 518 tmpDY = tmpDY + Math.sin( Math.PI/180.0*(double)exp.rec.vectorUnit.get(vID).coms.get(cID).orientation); 519 vectorCounterX.put("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1], tmpDX); 520 vectorCounterY.put("E"+res_exp+"V"+vID+"B"+binIndex+"C"+xy[0]+","+xy[1], tmpDY); 521 } 522 } 523 } 524 525 } 526 */ 527 528 for(int i = 0; i < intra.neurons.length; i++) 529 { 530 int neu = intra.neurons[i]; 531 int eleId = experiment.recorder.intraIndex(neu); 532 LinkedList<IntraInfo> info = intra.buff.get(i); 533 LinkedList<IntraInfo> currList; 534 if((currList=(LinkedList<IntraInfo>)intraReceiver[eleId+res_exp*experiment.recorder.intraEle.size()])!=null) 535 { 536 Iterator<IntraInfo> intraData = info.iterator(); 537 Iterator<IntraInfo> thisData = currList.iterator(); 538 while(intraData.hasNext()) 539 { 540 (thisData.next()).plus(intraData.next()); 541 } 542 } 543 else 544 { 545 intraReceiver[eleId+res_exp*experiment.recorder.intraEle.size()]=info; 546 } 547 } 548 break; 549 } 550 // System.out.println("alive hosts"+aliveHost); 551 552 if( aliveHost == 0 && totalTrials==0) 553 { 554 stop = true; 555 break; 556 } 557 } 558 559 System.out.println("Recording and exiting"); 560 System.gc(); 561 for(int j=0;j< experiment.subExp.length; j++) 562 { 563 for(int k=0; k< experiment.recorder.intraEle.size(); k++) 564 { 565 LinkedList<IntraInfo> currList = intraReceiver[k+j*experiment.recorder.intraEle.size()]; 566 Iterator<IntraInfo> intraData = currList.iterator(); 567 while(intraData.hasNext()) 568 { 569 (intraData.next()).divide(experiment.subExp[j].repetition*(experiment.recorder.intraEle.get(k).size())); 570 } 571 } 572 } 573 574 RecWriter wri= new RecWriter(experiment, pas, intraReceiver,rdata,aData); 575 // Thread.sleep(0); 576 //network.ncfile.close(); 577 System.out.print("\n"); 578 579 if(!experiment.recorder.outputFile.equals("")) 580 { 581 System.out.println ( 582 "output to file " 583 + RESULTS_DIR_PREFIX 584 + experiment.recorder.outputFile ); 585 586 final RecorderData outputRecorderData = new RecorderData ( ); 587 588 RecorderDataLib.insertExperimentRecorderDataIntoRecorderData ( 589 outputRecorderData, 590 experiment, 591 rdata ); 592 593 final File 594 binaryFile = new File ( 595 RESULTS_DIR, 596 experiment.recorder.outputFile ); 597 598 RecorderDataLib.writeRecorderDataToBinaryFile ( 599 outputRecorderData, 600 binaryFile ); 601 } 602 else 603 { 604 605 wri.record(pas.outFile); 606 PlotResult.init("results/"+pas.outFile); 607 if(experiment.recorder.plot) // plot is allowed 608 { 609 PlotResult.suPlot(); 610 PlotResult.muPlot(); 611 PlotResult.fieldPlot(); 612 PlotResult.vectorPlot(); 613 PlotResult.intraPlot(); 614 // PlotResult.exportFile(); 615 } 616 PlotResult.stop(); 617 } 618 /* 619 String filename = "results/datainput"; 620 FileOutputStream fos = null; 621 ObjectOutputStream out = null; 622 try { 623 624 RecorderData outdata = new RecorderData(); 625 for( int eId=0; eId<exp.subExp.length; eId++) 626 { 627 for( int tId=0; tId <exp.subExp[eId].repetition; tId++) 628 { 629 for( int sID= 0; sID < exp.rec.singleUnit.size(); sID++) 630 { 631 outdata.receiver.put("Exp"+eId+"Tri"+tId+"/"+exp.rec.suNames.get(sID),rdata.receiver.get("E"+eId+"T"+tId+"N"+exp.rec.singleUnit.get(sID))); 632 } 633 } 634 } 635 636 fos = new FileOutputStream(filename); 637 out = new ObjectOutputStream(fos); 638 out.writeObject(outdata); 639 out.close(); 640 System.out.println("Object Persisted"); 641 } catch (IOException ex) { 642 ex.printStackTrace(); 643 } 644 */ 645 646 estimateTime = System.currentTimeMillis() - simulationTime; 647 System.out.format("****** Simulation is done --- %dm:%ds was spent for the whole simulation\n" , estimateTime/60000, (estimateTime % 60000)/1000); 648 info.jpvm.pvm_exit(); 649 } 650 catch (jpvmException jpe) { 651 System.out.println("Error - mainhost jpvm exception"); 652 System.out.println(jpe); 653 } 654 catch (Exception a) 655 { 656 a.printStackTrace(); 657 } 658 } 659 660 //////////////////////////////////////////////////////////////////////// 661 //////////////////////////////////////////////////////////////////////// 662 }