MOOSE - Multiscale Object Oriented Simulation Environment
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
testShell.cpp
Go to the documentation of this file.
1 /**********************************************************************
2 ** This program is part of 'MOOSE', the
3 ** Messaging Object Oriented Simulation Environment.
4 ** Copyright (C) 2003-2010 Upinder S. Bhalla. and NCBS
5 ** It is made available under the terms of the
6 ** GNU Lesser General Public License version 2.1
7 ** See the file COPYING.LIB for the full notice.
8 **********************************************************************/
9 
10 #include "header.h"
11 #include "Shell.h"
12 #ifdef USE_MPI
13 #include <mpi.h>
14 #endif
15 #include "../scheduling/Clock.h"
16 #include "../scheduling/testScheduling.h"
17 
18 #include "../builtins/Arith.h"
19 #include "SparseMatrix.h"
20 #include "SparseMsg.h"
21 #include "SingleMsg.h"
22 #include "OneToAllMsg.h"
23 #include "Wildcard.h"
24 
25 const bool TEST_WARNING = false;
26 
31 void testShellParserCreateDelete()
32 {
33  Eref sheller = Id().eref();
34  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
35 
36  Id child = shell->doCreate( "Neutral", Id(), "test", 1 );
37 
38  shell->doDelete( child );
39  cout << "." << flush;
40 }
41 
45 void testTreeTraversal()
46 {
47  Eref sheller = Id().eref();
48  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
49 
50  unsigned int i = 0;
51  Id f1 = shell->doCreate( "Neutral", Id(), "f1", 10 );
52  assert( f1 != Id() );
53  Id f2a = shell->doCreate( "Neutral", ObjId(f1, i++), "f2a", 10 );
54  assert( f2a != Id() );
55  Id f2b = shell->doCreate( "Neutral", ObjId(f1, i++), "f2b", 10 );
56  assert( f2b != Id() );
57  Id f2c = shell->doCreate( "Neutral", ObjId(f1, i++), "f2c", 10 );
58  assert( f2c != Id() );
59  Id f3aa = shell->doCreate( "Neutral", ObjId(f2a, i++), "f3aa", 10 );
60  assert( f3aa != Id() );
61  Id f3ab = shell->doCreate( "Neutral", ObjId(f2a, i++), "f3ab", 10 );
62  assert( f3ab != Id() );
63  Id f3ba = shell->doCreate( "Neutral", ObjId(f2b, i++), "f3ba", 10 );
64  assert( f3ba != Id() );
65  Id f4 = shell->doCreate( "IntFire", ObjId(f3ba, i++), "cell", 10 );
66  assert( f4 != Id() );
67  Id f5 = shell->doCreate( "SimpleSynHandler", ObjId(f4, i++), "syns", 10 );
68  assert( f5 != Id() );
69  Id syns( f5.value() + 1 );
70  for ( unsigned int i = 0; i < 10; ++i ) {
71  Field< unsigned int >::set( ObjId( f5, i ), "numSynapse", 5 );
72  }
73 
75  // Checking for own Ids
77  ObjId me = Field< ObjId >::get( f3aa, "me" );
78  assert( me == ObjId( f3aa, 0 ) );
79  me = Field< ObjId >::get( f3ba, "me" );
80  assert( me == ObjId( f3ba, 0 ) );
81  me = Field< ObjId >::get( f2c, "me" );
82  assert( me == ObjId( f2c, 0 ) );
83 
85  // Checking for parent Ids
87  ObjId pa = Field< ObjId >::get( f3aa, "parent" );
88  assert( pa == ObjId( f2a, 3 ) );
89  pa = Field< ObjId >::get( f3ab, "parent" );
90  assert( pa == ObjId( f2a, 4 ) );
91  pa = Field< ObjId >::get( f2b, "parent" );
92  assert( pa == ObjId( f1, 1 ) );
93  pa = Field< ObjId >::get( f1, "parent" );
94  assert( pa == ObjId( Id(), 0 ) );
95 
96  cout << "." << flush;
97 
99  // Checking for child Id lists
101  vector< Id > kids =
102  Field< vector< Id > >::get( ObjId( f1, 0 ), "children" );
103  assert( kids.size() == 1 );
104  assert( kids[0] == f2a );
105  kids = Field< vector< Id > >::get( ObjId( f1, 1 ), "children" );
106  assert( kids.size() == 1 );
107  assert( kids[0] == f2b );
108  kids = Field< vector< Id > >::get( ObjId( f1, 2 ), "children" );
109  assert( kids.size() == 1 );
110  assert( kids[0] == f2c );
111 
112  kids = Field< vector< Id > >::get( ObjId( f1, ALLDATA ), "children" );
113  assert( kids.size() == 3 );
114  assert( kids[0] == f2a );
115  assert( kids[1] == f2b );
116  assert( kids[2] == f2c );
117 
118  kids = Field< vector< Id > >::get( ObjId( f2a, ALLDATA ), "children" );
119  assert( kids.size() == 2 );
120  assert( kids[0] == f3aa );
121  assert( kids[1] == f3ab );
122 
123  kids = Field< vector< Id > >::get( ObjId( f2b, 0 ), "children" );
124  assert( kids.size() == 0 );
125  kids = Field< vector< Id > >::get( ObjId( f2b, 5 ), "children" );
126  assert( kids.size() == 1 );
127  assert( kids[0] == f3ba );
128 
129  kids = Field< vector< Id > >::get( f2c, "children" );
130  assert( kids.size() == 0 );
131 
132  cout << "." << flush;
133 
135  // Checking Id::path and ObjId::path
137  string path = syns.path();
138  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[7]/syns[0]/synapse" );
139  ObjId oi( syns, 8, 3 );
140  path = oi.path();
141  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[7]/syns[8]/synapse[3]" );
142  path = oi.id.path();
143  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[7]/syns[0]/synapse" );
144 
145  ObjId oi2( f4, 4 );
146  path = oi2.path();
147  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[4]" );
148  path = oi2.id.path();
149  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell" );
150 
151  cout << "." << flush;
152 
154  // Checking path string generation.
156  path = Field< string >::get( f3aa, "path" );
157  assert( path == "/f1[0]/f2a[3]/f3aa[0]" );
158  path = Field< string >::get( f3ab, "path" );
159  assert( path == "/f1[0]/f2a[4]/f3ab[0]" );
160  path = Field< string >::get( f3ba, "path" );
161  assert( path == "/f1[1]/f2b[5]/f3ba[0]" );
162  path = Field< string >::get( f4, "path" );
163  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[0]" );
164  path = Field< string >::get( syns, "path" );
165  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[7]/syns[0]/synapse[0]" );
166  path = Field< string >::get( ObjId( syns, 8, 3 ), "path" );
167  assert( path == "/f1[1]/f2b[5]/f3ba[6]/cell[7]/syns[8]/synapse[3]" );
168 
169  path = Field< string >::get( ObjId( f2a, 7 ), "path" );
170  assert( path == "/f1[0]/f2a[7]" );
171  path = Field< string >::get( ObjId( f2b, 2 ), "path" );
172  assert( path == "/f1[1]/f2b[2]" );
173  path = Field< string >::get( f2c, "path" );
174  assert( path == "/f1[2]/f2c[0]" );
175  path = Field< string >::get( f1, "path" );
176  assert( path == "/f1[0]" );
177  path = Field< string >::get( Id(), "path" );
178  assert( path == "/" );
179 
180  path = Field< string >::get( Id(), "path" );
181 
182  cout << "." << flush;
184  // Checking finding Ids from path
186 
187  shell->setCwe( Id() );
188  assert( shell->doFind( "/f1/f2a/tralalalala" ).bad() );
189  assert( shell->doFind( "/f1/f2a[723]/f3aa" ).bad() );
190  assert( shell->doFind( "/f1/f2a/f3aa[12]" ).bad() );
191  if ( TEST_WARNING ) {
192  cout << "\nTesting warning for bad path indexing: ";
193  assert( shell->doFind( "/f1/f2a/f3aa[-1]" ).bad() );
194  }
195  ObjId ret = shell->doFind( "/f1/f2a[3]/f3aa" );
196  assert( ret == f3aa );
197  ret = shell->doFind( "/f1/f2a[4]/f3ab" );
198  assert( ret == f3ab );
199  ret = shell->doFind( "/f1[1]/f2b[5]/f3ba" );
200  assert( ret == f3ba );
201  ret = shell->doFind( "/f1[1]/f2b[5]/f3ba[6]" );
202  assert( ret == ObjId( f3ba, 6 ) );
203  ret = shell->doFind( "/f1[1]/f2b[5]/f3ba/.." );
204  assert( ret == ObjId( f2b, 5 ) );
205  assert( shell->doFind( "f1[1]/f2b[5]/f3ba" ) == f3ba );
206  assert( shell->doFind( "./f1[1]/f2b[5]/f3ba" ) == f3ba );
207  assert( shell->doFind( "./f1[1]/f2b/.." ) == ObjId( f1, 1 ) );
208 
209  shell->setCwe( ObjId( f2b, 5 ) );
210  assert( shell->doFind( "." ) == ObjId( f2b, 5 ) );
211  assert( shell->doFind( "f3ba" ) == f3ba );
212  assert( shell->doFind( "f3ba[7]" ) == ObjId( f3ba, 7 ) );
213  assert( shell->doFind( "f3ba/" ) == f3ba );
214  assert( shell->doFind( "f3ba/.." ) == ObjId( f2b, 5 ) );
215  // assert( shell->doFind( "f3ba/../../f2a[3]/f3aa" ) == f3aa );
216  assert( shell->doFind( "f3ba/../../" ) == ObjId( f1, 1 ) );
217  assert( shell->doFind( "../../f1/f2a[4]/f3ab" ) == f3ab );
218  // assert( shell->doFind( "../f2a[4]/f3ab" ) == f3ab );
219 
220  cout << "." << flush;
222  // Checking getChild
224  // Neutral* f1data = reinterpret_cast< Neutral* >( f1.eref().data() );
225  assert( f2a == Neutral::child( Eref( f1.element(), 0 ), "f2a" ) );
226  assert( f2b == Neutral::child( Eref( f1.element(), 1 ), "f2b" ) );
227  assert( f2c == Neutral::child( Eref( f1.element(), 2 ), "f2c" ) );
228  shell->setCwe( Id() );
229  shell->doDelete( f1 );
230  cout << "." << flush;
231 }
232 
234 void testDescendant()
235 {
236  Eref sheller = Id().eref();
237  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
238 
239  Id f1 = shell->doCreate( "Neutral", Id(), "f1", 1 );
240  Id f2a = shell->doCreate( "Neutral", f1, "f2a", 1 );
241  Id f2b = shell->doCreate( "Neutral", f1, "f2b", 1 );
242  Id f3aa = shell->doCreate( "Neutral", f2a, "f3aa", 1 );
243 
244  assert( Neutral::isDescendant( f3aa, Id() ) );
245  assert( Neutral::isDescendant( f3aa, f1 ) );
246  assert( Neutral::isDescendant( f3aa, f2a ) );
247  assert( Neutral::isDescendant( f3aa, f3aa ) );
248  assert( !Neutral::isDescendant( f3aa, f2b ) );
249 
250  assert( Neutral::isDescendant( f2b, Id() ) );
251  assert( Neutral::isDescendant( f2b, f2b ) );
252  assert( !Neutral::isDescendant( f2b, f2a ) );
253  assert( !Neutral::isDescendant( f2b, f3aa ) );
254 
255  assert( Neutral::isDescendant( f1, Id() ) );
256  assert( Neutral::isDescendant( f1, f1 ) );
257  assert( !Neutral::isDescendant( f1, f2a ) );
258  assert( !Neutral::isDescendant( f1, f2b ) );
259  assert( !Neutral::isDescendant( f1, f3aa ) );
260 
261  shell->doDelete( f1 );
262  cout << "." << flush;
263 }
264 
266 void verifyKids( Id f1, Id f2a, Id f2b, Id f3, Id f4a, Id f4b )
267 {
268  Neutral* f1Data = reinterpret_cast< Neutral* >( f1.eref().data() );
269  vector< Id > kids;
270  f1Data->children( f1.eref(), kids );
271  assert( kids.size() == 2 );
272  assert( kids[0] == f2a );
273  assert( kids[1] == f2b );
274 
275  vector< Id > tree;
276 
277  // Neutral::buildTree is depth-first.
278  int num = f1Data->buildTree( f1.eref(), tree );
279  assert( num == 6 );
280  assert( tree.size() == 6 );
281  assert( tree[5] == f1 );
282  assert( tree[3] == f2a );
283  assert( tree[2] == f3 );
284  assert( tree[0] == f4a );
285  assert( tree[1] == f4b );
286  assert( tree[4] == f2b );
287 }
288 
290 void testChildren()
291 {
292  Eref sheller = Id().eref();
293  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
294 
295  Id f1 = shell->doCreate( "Neutral", Id(), "f1", 1 );
296  Id f2a = shell->doCreate( "Neutral", f1, "f2a", 1 );
297  Id f2b = shell->doCreate( "Neutral", f1, "f2b", 1 );
298  Id f3 = shell->doCreate( "Neutral", f2a, "f3", 1 );
299  Id f4a = shell->doCreate( "Neutral", f3, "f4a", 1 );
300  Id f4b = shell->doCreate( "Neutral", f3, "f4b", 1 );
301 
302  verifyKids( f1, f2a, f2b, f3, f4a, f4b );
303 
304  if ( TEST_WARNING ) {
305  // Should fail.
306  cout << "\nTesting warning for creating element with existing name: ";
307  Id fx1 = shell->doCreate( "Neutral", f1, "f2b", 1 );
308  assert( fx1 == Id() );
309  }
310 
311  // Should succeed
312  Field< string >::set( f4a, "name", "hippo" );
313  if ( TEST_WARNING ) {
314  // Should fail, because same name already exists.
315  cout << "\nTesting warning for name change to existing name: ";
316  Field< string >::set( f4a, "name", "f4b" );
317  }
318 
319  shell->doDelete( f1 );
320  cout << "." << flush;
321 }
322 
323 void testMove()
324 {
325  Eref sheller = Id().eref();
326  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
327 
328 
329  Id f1 = shell->doCreate( "Neutral", Id(), "f1", 1 );
330  Id f2a = shell->doCreate( "Neutral", f1, "f2a", 1 );
331  Id f2b = shell->doCreate( "Neutral", f1, "f2b", 1 );
332  Id f3 = shell->doCreate( "Neutral", f2a, "f3", 1 );
333  Id f4a = shell->doCreate( "Neutral", f3, "f4a", 1 );
334  Id f4b = shell->doCreate( "Neutral", f3, "f4b", 1 );
335  verifyKids( f1, f2a, f2b, f3, f4a, f4b );
336 
337  ObjId pa = Field< ObjId >::get( f4a, "parent" );
338  assert( pa == ObjId( f3, 0 ) );
339  pa = Field< ObjId >::get( f2a, "parent" );
340  assert( pa == ObjId( f1, 0 ) );
341  string path = Field< string >::get( f4a, "path" );
342  assert( path == "/f1[0]/f2a[0]/f3[0]/f4a[0]" );
343  Neutral* f1data = reinterpret_cast< Neutral* >( f1.eref().data() );
344 
345  vector< Id > kids = f1data->getChildren( f1.eref() );
346  assert( kids.size() == 2 );
347  assert( kids[0] == f2a );
348  assert( kids[1] == f2b );
349 
350  Neutral* f3data = reinterpret_cast< Neutral* >( f3.eref().data() );
351  kids = f3data->getChildren( f3.eref() );
352  assert( kids.size() == 2 );
353  assert( kids[0] == f4a );
354  assert( kids[1] == f4b );
355 
357  shell->doMove( f4a, f1 );
359 
360  pa = Field< ObjId >::get( f4a, "parent" );
361  assert( pa == ObjId( f1, 0 ) );
362 
363  kids = f1data->getChildren( f1.eref() );
364  assert( kids.size() == 3 );
365  assert( kids[0] == f2a );
366  assert( kids[1] == f2b );
367  assert( kids[2] == f4a );
368  kids = f3data->getChildren( f3.eref() );
369  assert( kids.size() == 1 );
370  assert( kids[0] == f4b );
371 
373  shell->doMove( f2a, f4a );
375  pa = Field< ObjId >::get( f2a, "parent" );
376  assert( pa == ObjId( f4a, 0 ) );
377  path = Field< string >::get( f4b, "path" );
378  assert( path == "/f1[0]/f4a[0]/f2a[0]/f3[0]/f4b[0]" );
379 
380  kids = f1data->getChildren( f1.eref() );
381  assert( kids[0] == f2b );
382  assert( kids[1] == f4a );
383 
384  shell->doDelete( f1 );
385  cout << "." << flush;
386 }
387 
388 void testCopy()
389 {
390  Eref sheller = Id().eref();
391  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
392 
393  Id f1 = shell->doCreate( "Neutral", Id(), "f1", 1, MooseGlobal );
394  Id f2a = shell->doCreate( "Neutral", f1, "f2a", 1, MooseGlobal );
395  Id f2b = shell->doCreate( "Neutral", f1, "f2b", 1, MooseGlobal );
396  Id f3 = shell->doCreate( "Neutral", f2a, "f3", 1, MooseGlobal );
397  Id f4a = shell->doCreate( "Neutral", f3, "f4a", 1, MooseGlobal );
398  Id f4b = shell->doCreate( "Neutral", f3, "f4b", 1, MooseGlobal );
399 
400  verifyKids( f1, f2a, f2b, f3, f4a, f4b );
401 
402  ObjId pa = Field< ObjId >::get( f3, "parent" );
403  assert( pa == ObjId( f2a, 0 ) );
404  pa = Field< ObjId >::get( f2a, "parent" );
405  assert( pa == ObjId( f1, 0 ) );
406  string path = Field< string >::get( f3, "path" );
407  assert( path == "/f1[0]/f2a[0]/f3[0]" );
408 
410  Id dupf2a = shell->doCopy( f2a, Id(), "TheElephantsAreLoose", 1, false, false );
412 
413  verifyKids( f1, f2a, f2b, f3, f4a, f4b );
414 
415  assert( dupf2a != Id() );
416  // pa = Field< ObjId >::get( dupf2a, "parent" );
417  // assert( pa == ObjId( f1, 0 ) );
418  assert( dupf2a.element()->getName() == "TheElephantsAreLoose" );
419  Neutral* f2aDupData = reinterpret_cast< Neutral* >( dupf2a.eref().data() );
420  Id dupf3 = f2aDupData->child( dupf2a.eref(), "f3" );
421  assert( dupf3 != Id() );
422  assert( dupf3 != f3 );
423  assert( dupf3.element()->getName() == "f3" );
424  vector< Id > kids = f2aDupData->getChildren( dupf2a.eref() );
425  assert( kids.size() == 1 );
426  assert( kids[0] == dupf3 );
427 
428  Neutral* f3DupData = reinterpret_cast< Neutral* >( dupf3.eref().data());
429  assert( f3DupData->getParent( dupf3.eref() ) == ObjId( dupf2a, 0 ));
430  kids = f3DupData->getChildren( dupf3.eref() );
431  assert( kids.size() == 2 );
432  assert( kids[0].element()->getName() == "f4a" );
433  assert( kids[1].element()->getName() == "f4b" );
434 
435  shell->doDelete( f1 );
436  shell->doDelete( dupf2a );
437  cout << "." << flush;
438 }
439 
440 void testCopyFieldElement()
441 {
442  Eref sheller = Id().eref();
443  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
444  unsigned int size = 10;
445  unsigned int size2 = 17;
446  Id origId = shell->doCreate( "SimpleSynHandler", Id(), "f1", size, MooseGlobal );
447  Id origSynId( origId.value() + 1 );
448  Id origChild = shell->doCreate( "Neutral", origId, "f2", size2, MooseGlobal );
449 
450  Element* syn = origSynId.element();
451  assert( syn != 0 );
452  assert( syn->getName() == "synapse" );
453  assert( syn->numData() == size );
454  assert( origChild.element()->numData() == size2 );
455  assert( syn->numField( 0 ) == 0 );
456  assert( syn->isGlobal() );
457  vector< unsigned int > vec(size);
458  /*
459  for ( unsigned int i = 0; i < size; ++i )
460  vec[i] = i;
461  bool ret = Field< unsigned int >::setVec( origId, "numSynapse", vec );
462  assert( ret );
463  */
464  bool ret;
465  for ( unsigned int i = 0; i < size; ++i ) {
466  ret = Field< unsigned int >::set( ObjId( origId, i ),
467  "numSynapse", i );
468  assert( ret );
469  }
470 
471  for ( unsigned int i = 0; i < size; ++i ) {
472  vector< double > delay;
473  for ( unsigned int j = 0; j < i; ++j ) {
474  delay.push_back( 3.14 * j + i * i );
475  }
476  ret = Field< double >::
477  setVec( ObjId( origSynId, i ), "delay", delay );
478  assert( ret == ( i > 0 ) );
479  ret = Field< double >::
480  setRepeat( ObjId( origSynId, i ), "weight", i + 100 );
481  assert( ret );
482  }
483 
484  Eref origEr( origId.element(), 0 );
485  vector< Id > origChildren;
486  Neutral::children( origEr, origChildren );
487  assert( origChildren.size() == 2 );
488 
489  unsigned int numCopy = 2;
491  Id copyId = shell->doCopy( origId, Id(), "dup", numCopy, false, false);
493 
494  assert( copyId.element()->numData() == numCopy * size );
495  origChildren.resize( 0 );
496  Eref copyEr( copyId.element(), 0 );
497  vector< Id > copyChildren;
498  Neutral::children( origEr, origChildren );
499  Neutral::children( copyEr, copyChildren );
500  assert( origChildren.size() == 2 );
501  assert( origChildren[0] == origSynId );
502  assert( origChildren.size() == copyChildren.size() );
503  Id copySynId = copyChildren[0];
504  Id copyChild = copyChildren[1];
505 
506  Element* copySynElm = copySynId.element();
507 
508  // Element should exist even if data doesn't
509  assert ( copySynElm != 0 );
510  assert ( copySynElm->getName() == "synapse" );
511  assert( copySynElm->numData() == numCopy * size );
512  unsigned int numSyn = 0;
513  for ( unsigned int i = 0; i < numCopy * size; ++i ) {
514  // assert( copySynElm->numField( i ) == i % size );
515  unsigned int nf = Field< unsigned int >::get(
516  ObjId( copySynId, i ), "numField" );
517  assert( nf == i % size );
518  numSyn += i % size;
519  }
520 
521  assert ( copyChild.element() != 0 );
522  assert ( copyChild.element()->getName() == "f2" );
523  assert( copyChild.element()->numData() == numCopy * size2 );
524 
525  for ( unsigned int i = 0; i < numCopy * size; ++i ) {
526  unsigned int k = i % size;
527  vector< double > delay;
528  vector< double > delay2;
529  /*
530  if ( k > 0 ) {
531  double x = Field< double >::get( ObjId( copySynId, i, 0 ), "delay" );
532  cout << endl << i << ": x = " << x << endl;
533  }
534  */
535  Field< double >::getVec( ObjId( origSynId, k ), "delay", delay );
536  Field< double >::getVec( ObjId( copySynId, i ), "delay", delay2 );
537  assert( delay.size() == k );
538  assert( delay == delay2 );
539  for ( unsigned int j = 0; j < k; ++j ) {
540  assert( doubleEq( delay[j], 3.14 * j + k * k ) );
541  }
542  }
543 
544  shell->doDelete( origId );
545  shell->doDelete( copyId );
546  cout << "." << flush;
547 }
548 
549 void testObjIdToAndFromPath()
550 {
551  Eref sheller = Id().eref();
552  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
553  unsigned int s1 = 10;
554  unsigned int s2 = 1;
555  unsigned int s3 = 23;
556  unsigned int s4 = 1;
557  unsigned int s5 = 9;
558  unsigned int index1 = 1;
559  unsigned int index2 = 0;
560  unsigned int index3 = 3;
561  unsigned int index4 = 0;
562  unsigned int index5 = 5;
563 
564  Id level1 = shell->doCreate( "SimpleSynHandler", Id(), "f1", s1 );
565  Id origSynId( level1.value() + 1 );
566 
567  // origSynId.element()->resizeField( 7, 8 );
568  Field< unsigned int >::set( ObjId( origSynId, 7 ), "numField", 8 );
569  ObjId origSynObj( origSynId, 7, 5 );
570  Field< double >::set( origSynObj, "weight", 1999.0 );
571  double wt = Field< double >::get( origSynObj, "weight" );
572  assert( doubleEq( wt, 1999.0 ) );
573  // char* origSynData = origSynId.element()->data( 7, 5 );
574  // assert( origSynData != 0 );
575  Id level2 = shell->doCreate( "Neutral",
576  ObjId( level1, index1 ), "f2", s2 );
577  Id level3 = shell->doCreate( "Neutral",
578  ObjId( level2, index2 ), "f3", s3 );
579  Id level4 = shell->doCreate( "Neutral",
580  ObjId( level3, index3 ), "f4", s4 );
581  Id level5 = shell->doCreate( "Neutral",
582  ObjId( level4, index4 ), "f5", s5 );
583 
584  ObjId oi( level5, index5 );
585  string path = oi.path();
586  assert( path == "/f1[1]/f2[0]/f3[3]/f4[0]/f5[5]" );
587 
588  ObjId readPath( path );
589  assert( readPath.id == level5 );
590  assert( readPath.dataIndex == index5 );
591 
592  ObjId f4 = Neutral::parent( oi.eref() );
593  path = f4.path();
594  assert( path == "/f1[1]/f2[0]/f3[3]/f4[0]" );
595 
596  ObjId f3 = Neutral::parent( f4.eref() );
597  path = f3.path();
598  assert( path == "/f1[1]/f2[0]/f3[3]" );
599 
600  ObjId f2 = Neutral::parent( f3.eref() );
601  path = f2.path();
602  assert( path == "/f1[1]/f2[0]" );
603 
604  ObjId f1 = Neutral::parent( f2.eref() );
605  path = f1.path();
606  assert( path == "/f1[1]" );
607 
608  ObjId f0 = Neutral::parent( f1.eref() );
609  path = f0.path();
610  assert( path == "/" );
611  assert( f0 == Id() );
612 
613  // Here check what happens with a move.
614  Id level6 = shell->doCreate( "Neutral", Id(), "foo", 1 );
615  Id level7 = shell->doCreate( "Neutral", level6, "bar", 1 );
616  Id level8 = shell->doCreate( "Neutral", level7, "zod", 1 );
617 
618  shell->doMove( level1, level8 );
619 
620  ObjId noi( "/foo/bar/zod/f1[1]/f2[0]/f3[3]/f4[0]/f5[5]" );
621  assert( noi.dataIndex == index5 );
622  assert( noi.id == level5 );
623  assert( noi == oi );
624 
625  ObjId syn( "/foo/bar/zod/f1[7]/synapse[5]" );
626  assert( syn.dataIndex == 7 );
627  assert( syn.fieldIndex == 5 );
628  assert( syn.id == origSynId );
629  // assert( syn.data() == origSynData );
630  wt = Field< double >::get( syn, "weight" );
631  assert( doubleEq( wt, 1999.0 ) );
632 
633  shell->doDelete( level6 );
634  cout << "." << flush;
635 }
636 
637 // Here we create the element independently on each node, and connect
638 // it up independently. Using the doAddMsg we will be able to do this
639 // automatically on all nodes.
640 void testShellParserStart()
641 {
642  Eref sheller = Id().eref();
643  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
644 
645  shell->doSetClock( 0, 5.0 );
646  shell->doSetClock( 1, 2.0 );
647  shell->doSetClock( 2, 2.0 );
648  shell->doSetClock( 3, 1.0 );
649  shell->doSetClock( 4, 3.0 );
650  shell->doSetClock( 5, 5.0 );
651 
652  Id tsid = shell->doCreate( "testSched", ObjId(), "tse", 1, MooseGlobal );
653 
654  /*
655  const Cinfo* testSchedCinfo = TestSched::initCinfo();
656  Id tsid = Id::nextId();
657  Element* tse = new GlobalDataElement( tsid, testSchedCinfo, "tse", 1 );
658  */
659  shell->doUseClock( "/tse", "process", 0 );
660  shell->doUseClock( "/tse", "process", 1 );
661  shell->doUseClock( "/tse", "process", 2 );
662  shell->doUseClock( "/tse", "process", 3 );
663  shell->doUseClock( "/tse", "process", 4 );
664  shell->doUseClock( "/tse", "process", 5 );
665 
666 
667  /*
668  // testThreadSchedElement tse;
669  Eref ts( tse, 0 );
670  Element* clocke = Id( 1 ).element();
671  Eref er0( clocke, DataId( 0 ) );
672  Eref er1( clocke, DataId( 1 ) );
673  Eref er2( clocke, DataId( 2 ) );
674  Eref er3( clocke, DataId( 3 ) );
675  Eref er4( clocke, DataId( 4 ) );
676  Eref er5( clocke, DataId( 5 ) );
677  */
678 
679  /*
680  // No idea what FuncId to use here. Assume 0.
681  FuncId f( 0 );
682  SingleMsg m0( er0, ts );
683  er0.element()->addMsgAndFunc( m0.mid(), f, 0 );
684  SingleMsg m1( er1, ts );
685  er1.element()->addMsgAndFunc( m1.mid(), f, 1 );
686  SingleMsg m2( er2, ts );
687  er2.element()->addMsgAndFunc( m2.mid(), f, 2 );
688  SingleMsg m3( er3, ts );
689  er3.element()->addMsgAndFunc( m3.mid(), f, 3 );
690  SingleMsg m4( er4, ts );
691  er4.element()->addMsgAndFunc( m4.mid(), f, 4 );
692  SingleMsg m5( er5, ts );
693  er5.element()->addMsgAndFunc( m5.mid(), f, 5 );
694  */
695 
696  if ( shell->myNode() != 0 )
697  return;
698 
699  shell->doStart( 10 );
700 
701  tsid.destroy();
702  cout << "." << flush;
703 }
704 
708 void testInterNodeOps() // redundant.
709 {
710  Eref sheller = Id().eref();
711  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
712  Id child;
713  if ( shell->myNode() == 0 ) {
714  unsigned int size = 6139;
715  child = shell->doCreate( "Neutral", Id(), "test", size );
716  }
717  // cout << shell->myNode() << ": testInterNodeOps: #entries = " << child()->dataHandler()->numData() << endl;
718 
719  shell->doDelete( child );
720  // child.destroy();
721  cout << "." << flush;
722 }
723 
724 void testShellSetGet()
725 {
726  Eref sheller = Id().eref();
727  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
728  const unsigned int size = 100;
729  vector< double > val;
730 
731  // Set up the objects.
732  Id a1 = shell->doCreate( "Arith", Id(), "a1", size );
733 
734  // cout << Shell::myNode() << ": testShellSetGet: data here = (" << a1()->dataHandler()->begin() << " to " << a1()->dataHandler()->end() << ")" << endl;
735  for ( unsigned int i = 0; i < size; ++i ) {
736  val.push_back( i * i * i ); // use i^3 as a simple test.
737  bool ret = SetGet1< double >::set( ObjId( a1, i ), "setOutputValue", i * i );
738  assert( ret );
739  }
740  for ( unsigned int i = 0; i < size; ++i ) {
741  double x = Field< double >::get( ObjId( a1, i ), "outputValue" );
742  assert( doubleEq( x, i * i ) );
743  }
744  bool ret = SetGet1< double >::setVec( a1, "setOutputValue", val );
745  assert( ret );
746  for ( unsigned int i = 0; i < size; ++i ) {
747  double x = Field< double >::get( ObjId( a1, i ), "outputValue" );
748  // cout << i << " x=" << x << " i^3=" << i * i * i << endl;
749  assert( doubleEq( x, i * i * i ) );
750  }
751 
752  val.clear();
753  Field< double >::getVec( a1, "outputValue", val );
754  for ( unsigned int i = 0; i < size; ++i ) {
755  assert( doubleEq( val[i], i * i * i ) );
756  }
757 
758  shell->doDelete( a1 );
759  cout << "." << flush;
760 }
761 
762 bool checkArg1( Id id,
763  double v0, double v1, double v2, double v3, double v4 )
764 {
765  bool ret = 1;
766  bool report = 0;
767  Eref e0( id.element(), 0 );
768  double val = reinterpret_cast< Arith* >( e0.data() )->getArg1();
769  ret = ret && ( fabs( val - v0 ) < 1e-6 );
770  if (report) cout << "( " << v0 << ", " << val << " ) ";
771 
772  Eref e1( id.element(), 1 );
773  val = reinterpret_cast< Arith* >( e1.data() )->getArg1();
774  ret = ret && ( fabs( val - v1 ) < 1e-6 );
775  if (report) cout << "( " << v1 << ", " << val << " ) ";
776 
777  Eref e2( id.element(), 2 );
778  val = reinterpret_cast< Arith* >( e2.data() )->getArg1();
779  ret = ret && ( fabs( val - v2 ) < 1e-6 );
780  if (report) cout << "( " << v2 << ", " << val << " ) ";
781 
782  Eref e3( id.element(), 3 );
783  val = reinterpret_cast< Arith* >( e3.data() )->getArg1();
784  ret = ret && ( fabs( val - v3 ) < 1e-6 );
785  if (report) cout << "( " << v3 << ", " << val << " ) ";
786 
787  Eref e4( id.element(), 4 );
788  val = reinterpret_cast< Arith* >( e4.data() )->getArg1();
789  ret = ret && ( fabs( val - v4 ) < 1e-6 );
790  if (report) cout << "( " << v4 << ", " << val << " )\n";
791 
792  return ret;
793 }
794 
795 bool checkOutput( Id e,
796  double v0, double v1, double v2, double v3, double v4 )
797 {
798  bool ret = true;
799  bool report = 0;
800 
801  vector< double > correct;
802  correct.push_back( v0 );
803  correct.push_back( v1 );
804  correct.push_back( v2 );
805  correct.push_back( v3 );
806  correct.push_back( v4 );
807 
808  vector< double > actual(5);
809  for ( unsigned int i = 0; i < 5; ++i ) {
810  actual[i] = Field< double >::get( ObjId( e, i ), "outputValue" );
811  ret = ret && doubleEq( actual[i], correct[i] );
812  }
813  if (report || !ret ) {
814  cout << endl;
815  for ( unsigned int i = 0; i < 5; ++i )
816  cout << "(" << correct[i] << ", " << actual[i] << ") ";
817  }
818  /*
819  vector< double > retVec;
820  Field< double >::getVec( e, "outputValue", retVec );
821  assert( retVec.size() == 5 );
822 
823  for ( unsigned int i = 0; i < 5; ++i ) {
824  ret = ret & doubleEq( retVec[i], correct[i] );
825  if (report) cout << "( " << correct[i] << ", " << retVec[i] << " ) ";
826  }
827  if ( !ret ) {
828  for ( unsigned int i = 0; i < 5; ++i ) {
829  cout << "( " << correct[i] << ", " << retVec[i] << " ) ";
830  }
831  }
832  */
833  return ret;
834 }
835 
836 void testShellAddMsg()
837 {
838  Eref sheller = Id().eref();
839  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
840  unsigned int size = 5;
841 
842 
844  // Set up the objects.
846  Id a1 = shell->doCreate( "Arith", Id(), "a1", size );
847  Id a2 = shell->doCreate( "Arith", Id(), "a2", size );
848 
849  Id b1 = shell->doCreate( "Arith", Id(), "b1", size );
850  Id b2 = shell->doCreate( "Arith", Id(), "b2", size );
851 
852  Id c1 = shell->doCreate( "Arith", Id(), "c1", size );
853  Id c2 = shell->doCreate( "Arith", Id(), "c2", size );
854 
855  Id d1 = shell->doCreate( "Arith", Id(), "d1", size );
856  Id d2 = shell->doCreate( "Arith", Id(), "d2", size );
857 
858  Id e1 = shell->doCreate( "Arith", Id(), "e1", size );
859  Id e2 = shell->doCreate( "Arith", Id(), "e2", size );
860 
861  Id f1 = shell->doCreate( "Arith", Id(), "f1", size );
862  Id f2 = shell->doCreate( "Arith", Id(), "f2", size );
863 
864  Id g1 = shell->doCreate( "Arith", Id(), "g1", size );
865  Id g2 = shell->doCreate( "Arith", Id(), "g2", size );
866 
867 
869  // Set up messaging
871  // Should give 04000
872  ObjId m1 = shell->doAddMsg( "Single",
873  ObjId( a1, 3 ), "output", ObjId( a2, 1 ), "arg3" );
874  assert( m1 != ObjId() );
875 
876  // Should give 33333
877  ObjId m2 = shell->doAddMsg( "OneToAll",
878  ObjId( b1, 2 ), "output", ObjId( b2, 0 ), "arg3" );
879  assert( m2 != ObjId() );
880 
881  // Should give 12345
882  ObjId m3 = shell->doAddMsg( "OneToOne",
883  ObjId( c1, 0 ), "output", ObjId( c2, 0 ), "arg3" );
884  assert( m3 != ObjId() );
885 
886  // Should give 01234
887  ObjId m4 = shell->doAddMsg( "Diagonal",
888  ObjId( d1, 0 ), "output", ObjId( d2, 0 ), "arg3" );
889  assert( m4 != ObjId() );
890 
891  // Should give 54321
892  ObjId m5 = shell->doAddMsg( "Sparse",
893  ObjId( e1, 0 ), "output", ObjId( e2, 0 ), "arg3" );
894  assert( m5 != ObjId() );
895 
896  bool ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
897  m5, "setEntry", 0, 4, 0 );
898  assert( ret );
899  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
900  m5, "setEntry", 1, 3, 0 );
901  assert( ret );
902  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
903  m5, "setEntry", 2, 2, 0 );
904  assert( ret );
905  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
906  m5, "setEntry", 3, 1, 0 );
907  assert( ret );
908  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
909  m5, "setEntry", 4, 0, 0 );
910  assert( ret );
911 
912  // Should give 15 15 15 15 15
913  for ( unsigned int i = 0; i < 5; ++i ) {
914  ObjId m6 = shell->doAddMsg( "OneToAll",
915  ObjId( f1, i ), "output", ObjId( f2, i ), "arg3" );
916  assert( m6 != ObjId() );
917  }
918 
919  // Should give 14 13 12 11 10
920  ObjId m7 = shell->doAddMsg( "Sparse",
921  ObjId( g1, 0 ), "output", ObjId( g2, 0 ), "arg3" );
922  assert( m7 != ObjId() );
923  for ( unsigned int i = 0; i < 5; ++i ) {
924  for ( unsigned int j = 0; j < 5; ++j ) {
925  if ( i != j ) {
926  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
927  m7, "setEntry", i, j, 0 );
928  assert( ret );
929  }
930  }
931  }
932 
934  // Set up scheduling
936  shell->doSetClock( 0, 1.0 );
937  shell->doSetClock( 9, 1.0 ); // Postmaster uses clock 9, always.
938 
939  ObjId clock( Id( 1 ), 0 );
940  // I want to compare the # of process msgs before and after.
941  vector< Id > tgts;
942  const SrcFinfo* sf = dynamic_cast< const SrcFinfo* >(
943  Clock::initCinfo()->findFinfo( "process0" ) );
944  assert( sf );
945  unsigned int numTgts = clock.eref().element()->getNeighbors( tgts, sf );
946  assert( numTgts == 0 );
947 
948  shell->doUseClock( "a1,a2,b1,b2,c1,c2,d1,d2,e1,e2,f1,f2,g1,g2", "process", 0 );
949  numTgts = clock.eref().element()->getNeighbors( tgts, sf );
950  assert( numTgts == 14 );
951 
953  // Set up initial conditions
955 
956  // shell->doReinit();
957 
958  vector< double > init; // 12345
959  for ( unsigned int i = 1; i < 6; ++i )
960  init.push_back( i );
961  ret = SetGet1< double >::setVec( a1, "arg1", init ); // 12345
962  assert( ret );
963  ret = SetGet1< double >::setVec( b1, "arg1", init ); // 12345
964  assert( ret );
965  ret = SetGet1< double >::setVec( c1, "arg1", init ); // 12345
966  assert( ret );
967  ret = SetGet1< double >::setVec( d1, "arg1", init ); // 12345
968  assert( ret );
969  ret = SetGet1< double >::setVec( e1, "arg1", init ); // 12345
970  assert( ret );
971  ret = SetGet1< double >::setVec( f1, "arg1", init ); // 12345
972  assert( ret );
973  ret = SetGet1< double >::setVec( g1, "arg1", init ); // 12345
974  assert( ret );
975 
976  double val = 0;
977  /*
978  * Silly to try to do this on multiple nodes. We don't know where
979  * the object may put its data entries.
980  val = (reinterpret_cast< const Arith* >( ObjId( a1, 0 ).data() ) )->getArg1();
981  assert( doubleEq( val, 1 ) );
982  val = (reinterpret_cast< const Arith* >( ObjId( a1, 1 ).data() ) )->getArg1();
983  assert( doubleEq( val, 2 ) );
984  */
985 
986  val = Field< double >::get( ObjId( a1, 0 ), "arg1Value" );
987  assert( doubleEq( val, 1 ) );
988  val = Field< double >::get( ObjId( a1, 1 ), "arg1Value" );
989  assert( doubleEq( val, 2 ) );
990  val = Field< double >::get( ObjId( a1, 2 ), "arg1Value" );
991  assert( doubleEq( val, 3 ) );
992  val = Field< double >::get( ObjId( a1, 3 ), "arg1Value" );
993  assert( doubleEq( val, 4 ) );
994  val = Field< double >::get( ObjId( a1, 4 ), "arg1Value" );
995  assert( doubleEq( val, 5 ) );
996 
997  for ( unsigned int i = 0; i < 5; ++i ) {
998  double x = Field< double >::get( ObjId( a1, i ), "arg1Value" );
999  assert( doubleEq( x, i + 1 ) );
1000  x = Field< double >::get( ObjId( b1, i ), "arg1Value" );
1001  assert( doubleEq( x, i + 1 ) );
1002  x = Field< double >::get( ObjId( c1, i ), "arg1Value" );
1003  assert( doubleEq( x, i + 1 ) );
1004  }
1005  vector< double > retVec( 0 );
1006  Field< double >::getVec( a1, "arg1Value", retVec );
1007  for ( unsigned int i = 0; i < 5; ++i )
1008  assert( doubleEq( retVec[i], i + 1 ) );
1009 
1010  retVec.resize( 0 );
1011  Field< double >::getVec( b1, "arg1Value", retVec );
1012  for ( unsigned int i = 0; i < 5; ++i )
1013  assert( doubleEq( retVec[i], i + 1 ) );
1014 
1015  retVec.resize( 0 );
1016  Field< double >::getVec( c1, "arg1Value", retVec );
1017  for ( unsigned int i = 0; i < 5; ++i )
1018  assert( doubleEq( retVec[i], i + 1 ) );
1019 
1020 
1022  // Run it
1024 
1025  shell->doStart( 2 );
1026 
1027  // Clock* clock = reinterpret_cast< Clock* >( Id(1).eref().data() );
1028  // clock->printCounts();
1029  // Qinfo::reportQ();
1030 
1032  // Check output.
1034 
1035  ret = checkOutput( a1, 1, 2, 3, 4, 5 );
1036  assert( ret );
1037  ret = checkOutput( b1, 1, 2, 3, 4, 5 );
1038  assert( ret );
1039  ret = checkOutput( c1, 1, 2, 3, 4, 5 );
1040  assert( ret );
1041  ret = checkOutput( d1, 1, 2, 3, 4, 5 );
1042  assert( ret );
1043  ret = checkOutput( e1, 1, 2, 3, 4, 5 );
1044  assert( ret );
1045  ret = checkOutput( a2, 0, 4, 0, 0, 0 );
1046  assert( ret );
1047  ret = checkOutput( b2, 3, 3, 3, 3, 3 );
1048  // assert( ret );
1049  ret = checkOutput( c2, 1, 2, 3, 4, 5 );
1050  // assert( ret );
1051  ret = checkOutput( d2, 0, 1, 2, 3, 4 );
1052  // assert( ret );
1053  ret = checkOutput( e2, 5, 4, 3, 2, 1 );
1054  // assert( ret );
1055  ret = checkOutput( f2, 15, 15, 15, 15, 15 );
1056  // assert( ret );
1057  ret = checkOutput( g2, 14, 13, 12, 11, 10 );
1058  assert( ret );
1059 
1061  // Clean up.
1063  shell->doDelete( a1 );
1064  shell->doDelete( a2 );
1065  shell->doDelete( b1 );
1066  shell->doDelete( b2 );
1067  shell->doDelete( c1 );
1068  shell->doDelete( c2 );
1069  shell->doDelete( d1 );
1070  shell->doDelete( d2 );
1071  shell->doDelete( e1 );
1072  shell->doDelete( e2 );
1073  shell->doDelete( f1 );
1074  shell->doDelete( f2 );
1075  shell->doDelete( g1 );
1076  shell->doDelete( g2 );
1077 
1078  cout << "." << flush;
1079 }
1080 
1081 // Very similar to above, except that the tests are done on a copy.
1082 // For now we can only copy from globals.
1083 void testCopyMsgOps()
1084 {
1085  Eref sheller = Id().eref();
1086  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1087  Id pa = shell->doCreate( "Neutral", Id(), "pa", 1, MooseGlobal );
1088  unsigned int size = 5;
1089 
1090 
1092  // Set up the objects.
1094  Id a1 = shell->doCreate( "Arith", pa, "a1", size, MooseGlobal );
1095  Id a2 = shell->doCreate( "Arith", pa, "a2", size, MooseGlobal );
1096 
1097  Id b1 = shell->doCreate( "Arith", pa, "b1", size, MooseGlobal );
1098  Id b2 = shell->doCreate( "Arith", pa, "b2", size, MooseGlobal );
1099 
1100  Id c1 = shell->doCreate( "Arith", pa, "c1", size, MooseGlobal );
1101  Id c2 = shell->doCreate( "Arith", pa, "c2", size, MooseGlobal );
1102 
1103  Id d1 = shell->doCreate( "Arith", pa, "d1", size, MooseGlobal );
1104  Id d2 = shell->doCreate( "Arith", pa, "d2", size, MooseGlobal );
1105 
1106  Id e1 = shell->doCreate( "Arith", pa, "e1", size, MooseGlobal );
1107  Id e2 = shell->doCreate( "Arith", pa, "e2", size, MooseGlobal );
1108 
1110  // Set up initial conditions and some scheduling.
1112  shell->doSetClock( 0, 1.0 );
1113  shell->doReinit();
1114  bool ret = 0;
1115  vector< double > init; // 12345
1116  for ( unsigned int i = 1; i < 6; ++i )
1117  init.push_back( i );
1118  ret = SetGet1< double >::setVec( a1, "arg1", init ); // 12345
1119  assert( ret );
1120  ret = SetGet1< double >::setVec( b1, "arg1", init ); // 12345
1121  assert( ret );
1122  ret = SetGet1< double >::setVec( c1, "arg1", init ); // 12345
1123  assert( ret );
1124  ret = SetGet1< double >::setVec( d1, "arg1", init ); // 12345
1125  assert( ret );
1126  ret = SetGet1< double >::setVec( e1, "arg1", init ); // 12345
1127  assert( ret );
1128 
1129 
1131  // Set up messaging
1133  // Should give 04000
1134  ObjId m1 = shell->doAddMsg( "Single",
1135  ObjId( a1, 3 ), "output", ObjId( a2, 1 ), "arg1" );
1136  assert( m1 != ObjId() );
1137 
1138  // Should give 33333
1139  ObjId m2 = shell->doAddMsg( "OneToAll",
1140  ObjId( b1, 2 ), "output", ObjId( b2, 0 ), "arg1" );
1141  assert( m2 != ObjId() );
1142 
1143  // Should give 12345
1144  ObjId m3 = shell->doAddMsg( "OneToOne",
1145  ObjId( c1, 0 ), "output", ObjId( c2, 0 ), "arg1" );
1146  assert( m3 != ObjId() );
1147 
1148  // Should give 01234
1149  ObjId m4 = shell->doAddMsg( "Diagonal",
1150  ObjId( d1, 0 ), "output", ObjId( d2, 0 ), "arg1" );
1151  assert( m4 != ObjId() );
1152 
1153  // Should give 54321
1154  ObjId m5 = shell->doAddMsg( "Sparse",
1155  ObjId( e1, 0 ), "output", ObjId( e2, 0 ), "arg1" );
1156  assert( m5 != ObjId() );
1157 
1158  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
1159  m5, "setEntry", 0, 4, 0 );
1160  assert( ret );
1161  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
1162  m5, "setEntry", 1, 3, 0 );
1163  assert( ret );
1164  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
1165  m5, "setEntry", 2, 2, 0 );
1166  assert( ret );
1167  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
1168  m5, "setEntry", 3, 1, 0 );
1169  assert( ret );
1170  ret = SetGet3< unsigned int, unsigned int, unsigned int >::set(
1171  m5, "setEntry", 4, 0, 0 );
1172  assert( ret );
1173 
1174  assert( ret );
1175 
1176  // ObjId clock( Id( 1 ), 0 );
1177 
1179  // Copy it
1181 
1182  Id pa2 = shell->doCopy( pa, Id(), "pa2", 1, false, false );
1183 
1185  // Pull out the child Ids.
1187  vector< Id > kids = Field< vector< Id > >::get( pa2, "children");
1188  assert ( kids.size() == 10 );
1189  shell->doUseClock( "/pa2/#", "process", 0 );
1190 
1191  unsigned int j = 0;
1192  assert( kids[j].element()->getName() == "a1" ); ++j;
1193  assert( kids[j].element()->getName() == "a2" ); ++j;
1194  assert( kids[j].element()->getName() == "b1" ); ++j;
1195  assert( kids[j].element()->getName() == "b2" ); ++j;
1196  assert( kids[j].element()->getName() == "c1" ); ++j;
1197  assert( kids[j].element()->getName() == "c2" ); ++j;
1198  assert( kids[j].element()->getName() == "d1" ); ++j;
1199  assert( kids[j].element()->getName() == "d2" ); ++j;
1200  assert( kids[j].element()->getName() == "e1" ); ++j;
1201  assert( kids[j].element()->getName() == "e2" ); ++j;
1202 
1203  /*
1204  vector< double > retVec;
1205  Field< double >::getVec( kids[0], "arg1Value", retVec );
1206  assert( retVec.size() == 5 );
1207  assert( doubleEq( retVec[i], init[i] ) );
1208  */
1209  for (unsigned int i = 0; i < 5; ++i ) {
1210  double x = Field< double >::get( ObjId( kids[0], i ), "arg1Value");
1211  assert( doubleEq( x, init[i] ) );
1212  }
1213 
1215  // Run it
1217 
1218  shell->doStart( 2 );
1219 
1221  // Check output.
1223 
1224  ret = checkOutput( kids[1], 0, 4, 0, 0, 0 );
1225  assert( ret );
1226  ret = checkOutput( kids[2], 1, 2, 3, 4, 5 );
1227  assert( ret );
1228  ret = checkOutput( kids[3], 3, 3, 3, 3, 3 );
1229  assert( ret );
1230  ret = checkOutput( kids[5], 1, 2, 3, 4, 5 );
1231  assert( ret );
1232  ret = checkOutput( kids[7], 0, 1, 2, 3, 4 );
1233  assert( ret );
1234  ret = checkOutput( kids[9], 5, 4, 3, 2, 1 );
1235  assert( ret );
1236 
1238  // Clean up.
1240  shell->doDelete( pa );
1241  shell->doDelete( pa2 );
1242 
1243  cout << "." << flush;
1244 }
1245 
1246 void testShellParserQuit()
1247 {
1248  Eref sheller = Id().eref();
1249  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1250  shell->doQuit( );
1251  cout << "." << flush;
1252 }
1253 
1254 extern bool
1255  extractIndex( const string& s, unsigned int& index );
1256 
1257 void testExtractIndices()
1258 {
1259  unsigned int ret;
1260 
1261  bool ok = extractIndex( "foo", ret );
1262  assert( ok );
1263  assert( ret == 0 );
1264 
1265  ok = extractIndex( "..", ret );
1266  assert( ok );
1267  assert( ret == 0 );
1268 
1269  ok = extractIndex( "a1[2]", ret );
1270  assert( ok );
1271  assert( ret == 2 );
1272 
1273  ok = extractIndex( "be451[0]", ret );
1274  assert( ok );
1275  assert( ret == 0 );
1276 
1277  ok = extractIndex( "be[0", ret );
1278  assert( !ok );
1279  assert( ret == 0 );
1280 
1281  ok = extractIndex( "[0]be", ret );
1282  assert( !ok );
1283  assert( ret == 0 );
1284 
1285  ok = extractIndex( "oops[0]]", ret );
1286  assert( !ok );
1287  assert( ret == 0 );
1288 
1289  ok = extractIndex( "fine [ 123 ]", ret );
1290  assert( ok );
1291  assert( ret == 123 );
1292 
1293  cout << "." << flush;
1294 }
1295 
1296 void testChopString()
1297 {
1298  vector< string > args;
1299 
1300  assert( Shell::chopString( ".", args ) == 0 );
1301  assert( args.size() == 1 );
1302  assert( args[0] == "." );
1303 
1304  assert( Shell::chopString( "/", args ) == 1 );
1305  assert( args.size() == 0 );
1306 
1307  assert( Shell::chopString( "..", args ) == 0 );
1308  assert( args.size() == 1 );
1309  assert( args[0] == ".." );
1310 
1311  assert( Shell::chopString( "./", args ) == 0 );
1312  assert( args.size() == 1 );
1313  assert( args[0] == "." );
1314 
1315  assert( Shell::chopString( "./foo", args ) == 0 );
1316  assert( args.size() == 2 );
1317  assert( args[0] == "." );
1318  assert( args[1] == "foo" );
1319 
1320  assert( Shell::chopString( "/foo", args ) == 1 );
1321  assert( args.size() == 1 );
1322  assert( args[0] == "foo" );
1323 
1324  assert( Shell::chopString( "foo", args ) == 0 );
1325  assert( args.size() == 1 );
1326  assert( args[0] == "foo" );
1327 
1328  assert( Shell::chopString( "foo/", args ) == 0 );
1329  assert( args.size() == 1 );
1330  assert( args[0] == "foo" );
1331 
1332  assert( Shell::chopString( "/foo/", args ) == 1 );
1333  assert( args.size() == 1 );
1334  assert( args[0] == "foo" );
1335 
1336  assert( Shell::chopString( "foo/bar/zod", args ) == 0 );
1337  assert( args.size() == 3 );
1338  assert( args[0] == "foo" );
1339  assert( args[1] == "bar" );
1340  assert( args[2] == "zod" );
1341 
1342  cout << "." << flush;
1343 }
1344 
1345 void testChopPath()
1346 {
1347  vector< string > args;
1348  vector< unsigned int > index;
1349 
1350  assert( Shell::chopPath( "foo[1]/bar[2]/zod[3]", args, index ) == 0 );
1351  assert( args.size() == 3 );
1352  assert( args[0] == "foo" );
1353  assert( args[1] == "bar" );
1354  assert( args[2] == "zod" );
1355 
1356  assert( index.size() == 3 );
1357 
1358  assert( index[0] == 1 );
1359  assert( index[1] == 2 );
1360  assert( index[2] == 3 );
1361 
1362  assert( Shell::chopPath( "/foo/bar[1]/zod[2]/zung[3]",
1363  args, index ) == 1 );
1364  assert( args.size() == 4 );
1365  assert( args[0] == "foo" );
1366  assert( args[1] == "bar" );
1367  assert( args[2] == "zod" );
1368  assert( args[3] == "zung" );
1369 
1370  assert( index.size() == 4 );
1371 
1372  assert( index[0] == 0 );
1373  assert( index[1] == 1 );
1374  assert( index[2] == 2 );
1375  assert( index[3] == 3 );
1376 
1377  cout << "." << flush;
1378 }
1379 
1380 void testFindModelParent()
1381 {
1382  bool findModelParent( Id cwe, const string& path,
1383  Id& parentId, string& modelName );
1384 
1385  Eref sheller = Id().eref();
1386  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1387 
1389  // Set up the objects.
1391  Id foo = shell->doCreate( "Neutral", Id(), "foo", 1 );
1392  Id zod = shell->doCreate( "Neutral", Id(), "zod", 1 );
1393  Id foo2 = shell->doCreate( "Neutral", zod, "foo", 1 );
1394 
1395  // shell->setCwe( zod );
1396 
1397  string modelName;
1398  Id parentId;
1399 
1401  bool ok = findModelParent( zod, "", parentId, modelName );
1402  assert( ok );
1403  assert( parentId == zod );
1404  assert( modelName == "model" );
1405  modelName = "";
1406 
1407  ok = findModelParent( zod, "/", parentId, modelName );
1408  assert( ok );
1409  assert( parentId == Id() );
1410  assert( modelName == "model" );
1411  modelName = "";
1412 
1413  ok = findModelParent( zod, "/foo", parentId, modelName );
1414  assert( ok );
1415  assert( parentId == Id() );
1416  assert( modelName == "foo" );
1417  modelName = "";
1418 
1419  ok = findModelParent( zod, "foo", parentId, modelName );
1420  assert( ok );
1421  assert( parentId == zod );
1422  assert( modelName == "foo" );
1423  modelName = "";
1424 
1426  ok = findModelParent( zod, "bar", parentId, modelName );
1427  assert( ok );
1428  assert( parentId == zod );
1429  assert( modelName == "bar" );
1430  modelName = "";
1431 
1432  ok = findModelParent( zod, "/bar", parentId, modelName );
1433  assert( ok );
1434  assert( parentId == Id() );
1435  assert( modelName == "bar" );
1436  modelName = "";
1437 
1438  ok = findModelParent( foo, "/foo/bar", parentId, modelName );
1439  assert( ok );
1440  assert( parentId == foo );
1441  assert( modelName == "bar" );
1442  modelName = "";
1443 
1444  ok = findModelParent( zod, "foo/bar", parentId, modelName );
1445  assert( ok );
1446  assert( parentId == foo2 );
1447  assert( modelName == "bar" );
1448 
1449  shell->doDelete( foo );
1450  shell->doDelete( foo2 );
1451  shell->doDelete( zod );
1452  cout << "." << flush;
1453 }
1454 
1455 void testSyncSynapseSize()
1456 {
1457  Eref sheller = Id().eref();
1458  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1459  const Cinfo* c = Cinfo::find( "SimpleSynHandler" );
1460  const Finfo* f = c->findFinfo( "getNumSynapses" );
1461  const DestFinfo* df = dynamic_cast< const DestFinfo* >( f );
1462  assert( df );
1463  unsigned int size = 100;
1464  Id neuronId = shell->doCreate( "SimpleSynHandler", Id(), "handler", size );
1465  assert( neuronId != Id() );
1466  Id synId( neuronId.value() + 1 );
1467  Element* syn = synId.element();
1468 
1469  // Element should exist even if data doesn't
1470  assert ( syn != 0 );
1471  assert ( syn->getName() == "synapse" );
1472 
1473  assert( syn->numData() == size );
1474  vector< unsigned int > ns( size, 0 );
1475  for ( unsigned int i = 0; i < size; ++i )
1476  ns[i] = i;
1477  bool ret = Field< unsigned int >::setVec( neuronId, "numSynapses", ns);
1478  assert( ret );
1479  // Here we check local entries
1480 
1481  assert( Field< unsigned int >::get( neuronId, "numData" ) == size );
1482  assert( Field< unsigned int >::get( synId, "numData" ) == size );
1483  for ( unsigned int i = 0; i < size; ++i ) {
1484  ObjId oi( synId, i );
1485  assert( Field< unsigned int >::get( oi, "numField" ) == i );
1486 
1487  // low-level access only works on single node.
1488  if ( Shell::numNodes() == 1 )
1489  assert( oi.element()->numField( i ) == i );
1490 
1491  for ( unsigned int j = 0; j < i; ++j ) {
1492  ObjId temp( synId, i, j );
1493  Field< double >::set( temp, "delay", i * 1000 + j );
1494  }
1495  }
1496  /*
1497  vector< double > delay;
1498  Field< double >::getVec( synId, "delay", delay );
1499  assert( delay.size() == size * ( size - 1 ) / 2 );
1500  unsigned int k = 0;
1501  for ( unsigned int i = 0; i < size; ++i )
1502  for ( unsigned int j = 0; j < i; ++j )
1503  assert( doubleEq( delay[ k++ ], i * 1000 + j ) );
1504  */
1505 
1506  shell->doDelete( neuronId );
1507  cout << "." << flush;
1508 }
1509 
1518 void testGetMsgs()
1519 {
1520  Eref sheller = Id().eref();
1521  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1522  unsigned int numData = 5;
1523 
1525  // Set up the objects.
1527  Id a1 = shell->doCreate( "Arith", Id(), "a1", numData );
1528  Id a2 = shell->doCreate( "Arith", Id(), "a2", numData );
1529 
1530  Id b1 = shell->doCreate( "Arith", Id(), "b1", numData );
1531  Id b2 = shell->doCreate( "Arith", Id(), "b2", numData );
1532 
1533  Id c1 = shell->doCreate( "Arith", Id(), "c1", numData );
1534  Id c2 = shell->doCreate( "Arith", Id(), "c2", numData );
1535 
1536  Id d1 = shell->doCreate( "Arith", Id(), "d1", numData );
1537  Id d2 = shell->doCreate( "Arith", Id(), "d2", numData );
1538 
1539  Id e1 = shell->doCreate( "Arith", Id(), "e1", numData );
1540  Id e2 = shell->doCreate( "Arith", Id(), "e2", numData );
1541 
1543  // Set up messaging
1545  // Should give 04000
1546  ObjId m1 = shell->doAddMsg( "Single",
1547  ObjId( a1, 3 ), "output", ObjId( a2, 1 ), "arg3" );
1548  assert( m1 != ObjId() );
1549 
1550  // Should give 33333
1551  ObjId m2 = shell->doAddMsg( "OneToAll",
1552  ObjId( a1, 2 ), "output", ObjId( b2, 0 ), "arg3" );
1553  assert( m2 != ObjId() );
1554 
1555  // Should give 12345
1556  ObjId m3 = shell->doAddMsg( "OneToOne",
1557  ObjId( a1, 0 ), "output", ObjId( c2, 0 ), "arg3" );
1558  assert( m3 != ObjId() );
1559 
1560  // Should give 01234
1561  ObjId m4 = shell->doAddMsg( "Diagonal",
1562  ObjId( a1, 0 ), "output", ObjId( d2, 0 ), "arg3" );
1563  assert( m4 != ObjId() );
1564 
1565  // Should give 54321
1566  ObjId m5 = shell->doAddMsg( "Sparse",
1567  ObjId( a1, 0 ), "output", ObjId( e2, 0 ), "arg3" );
1568  assert( m5 != ObjId() );
1569 
1571  // Check that the outgoing Msgs are OK.
1573  // Nov 2013: Wait till the Msg ObjIds are set up.
1574  /*
1575 
1576  vector< ObjId > msgMgrs =
1577  Field< vector< ObjId > >::get( a1, "msgOut" );
1578  assert( msgMgrs.size() == 5 ); // 5 above.
1579  for ( unsigned int i = 0; i < 5; ++i )
1580  assert( Field< Id >::get( msgMgrs[i], "e1" ) == a1 );
1581 
1582  assert( Field< string >::get( msgMgrs[0], "className" ) == "SingleMsg" );
1583  assert( Field< string >::get( msgMgrs[1], "className" ) == "OneToAllMsg" );
1584  assert( Field< string >::get( msgMgrs[2], "className" ) == "OneToOneMsg" );
1585  assert( Field< string >::get( msgMgrs[3], "className" ) == "DiagonalMsg" );
1586  assert( Field< string >::get( msgMgrs[4], "className" ) == "SparseMsg" );
1587 
1588  assert( Field< Id >::get( msgMgrs[0], "e2" ) == a2 );
1589  assert( Field< Id >::get( msgMgrs[1], "e2" ) == b2 );
1590  assert( Field< Id >::get( msgMgrs[2], "e2" ) == c2 );
1591  assert( Field< Id >::get( msgMgrs[3], "e2" ) == d2 );
1592  assert( Field< Id >::get( msgMgrs[4], "e2" ) == e2 );
1593  cout << "." << flush;
1594 
1596  // Check that the incoming Msgs are OK.
1598  msgMgrs = Field< vector< ObjId > >::get( a1, "msgIn" );
1599  assert( msgMgrs.size() == 1 ); // parent msg
1600  assert( msgMgrs[0].id == OneToAllMsg::managerId_ );
1601 
1602  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1603  assert( Field< Id >::get( msgMgrs[0], "e2" ) == a1 );
1604 
1605  msgMgrs = Field< vector< ObjId > >::get( a2, "msgIn" );
1606  assert( msgMgrs.size() == 2 ); // parent msg + input msg
1607  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1608  assert( Field< Id >::get( msgMgrs[0], "e2" ) == a2 );
1609  assert( Field< Id >::get( msgMgrs[1], "e1" ) == a1 );
1610  assert( Field< Id >::get( msgMgrs[1], "e2" ) == a2 );
1611 
1612  msgMgrs = Field< vector< ObjId > >::get( b2, "msgIn" );
1613  assert( msgMgrs.size() == 2 ); // parent msg + input msg
1614  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1615  assert( Field< Id >::get( msgMgrs[0], "e2" ) == b2 );
1616  assert( Field< Id >::get( msgMgrs[1], "e1" ) == a1 );
1617  assert( Field< Id >::get( msgMgrs[1], "e2" ) == b2 );
1618 
1619  msgMgrs = Field< vector< ObjId > >::get( c2, "msgIn" );
1620  assert( msgMgrs.size() == 2 ); // parent msg + input msg
1621  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1622  assert( Field< Id >::get( msgMgrs[0], "e2" ) == c2 );
1623  assert( Field< Id >::get( msgMgrs[1], "e1" ) == a1 );
1624  assert( Field< Id >::get( msgMgrs[1], "e2" ) == c2 );
1625 
1626  msgMgrs = Field< vector< ObjId > >::get( d2, "msgIn" );
1627  assert( msgMgrs.size() == 2 ); // parent msg + input msg
1628  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1629  assert( Field< Id >::get( msgMgrs[0], "e2" ) == d2 );
1630  assert( Field< Id >::get( msgMgrs[1], "e1" ) == a1 );
1631  assert( Field< Id >::get( msgMgrs[1], "e2" ) == d2 );
1632 
1633  msgMgrs = Field< vector< ObjId > >::get( e2, "msgIn" );
1634  assert( msgMgrs.size() == 2 ); // parent msg + input msg
1635  assert( Field< Id >::get( msgMgrs[0], "e1" ) == Id() );
1636  assert( Field< Id >::get( msgMgrs[0], "e2" ) == e2 );
1637  assert( Field< Id >::get( msgMgrs[1], "e1" ) == a1 );
1638  assert( Field< Id >::get( msgMgrs[1], "e2" ) == e2 );
1639  cout << "." << flush;
1640  */
1641 
1643  // Check that the MsgSrcs are OK.
1645  vector< Id > srcIds;
1646  srcIds = LookupField< string, vector< Id > >::get( a2, "neighbors", "arg3" );
1647  assert( srcIds.size() == 1 );
1648  assert( srcIds[0] == a1 );
1649  srcIds.resize( 0 );
1650  srcIds = LookupField< string, vector< Id > >::get( b2, "neighbors", "arg3" );
1651  assert( srcIds.size() == 1 );
1652  assert( srcIds[0] == a1 );
1653  srcIds.resize( 0 );
1654  srcIds = LookupField< string, vector< Id > >::get( c2, "neighbors", "arg3" );
1655  assert( srcIds.size() == 1 );
1656  assert( srcIds[0] == a1 );
1657 
1658  ObjId m6 = shell->doAddMsg( "Single",
1659  ObjId( b1, 3 ), "output", ObjId( b2, 1 ), "arg3" );
1660  assert( m6 != ObjId() );
1661  srcIds.resize( 0 );
1662  srcIds = LookupField< string, vector< Id > >::get( b2, "neighbors", "arg3" );
1663  assert( srcIds.size() == 2 );
1664  assert( srcIds[0] == a1 );
1665  assert( srcIds[1] == b1 );
1666  cout << "." << flush;
1667 
1669  // Check that the MsgDests are OK.
1671  vector< Id > destIds;
1672  destIds = LookupField< string, vector< Id > >::get( a1, "neighbors", "output" );
1673  assert( destIds.size() == 5 );
1674  assert( destIds[0] == a2 );
1675  assert( destIds[1] == b2 );
1676  assert( destIds[2] == c2 );
1677  assert( destIds[3] == d2 );
1678  assert( destIds[4] == e2 );
1679  destIds.resize( 0 );
1680  destIds = LookupField< string, vector< Id > >::get( b1, "neighbors", "output" );
1681  assert( destIds.size() == 1 );
1682  assert( destIds[0] == b2 );
1683  cout << "." << flush;
1684 
1686  // Clean up.
1688 
1689 
1690  shell->doDelete( a1 );
1691  shell->doDelete( a2 );
1692  shell->doDelete( b1 );
1693  shell->doDelete( b2 );
1694  shell->doDelete( c1 );
1695  shell->doDelete( c2 );
1696  shell->doDelete( d1 );
1697  shell->doDelete( d2 );
1698  shell->doDelete( e1 );
1699  shell->doDelete( e2 );
1700 }
1701 
1702 void testGetMsgSrcAndTarget()
1703 {
1704  // cout << "." << flush;
1705 }
1706 
1707 // Defined in Element.cpp.
1708 extern void filterOffNodeTargets(
1709  unsigned int start,
1710  unsigned int end,
1711  bool isSrcGlobal,
1712  unsigned int myNode,
1713  vector< vector < Eref > >& erefs,
1714  vector< vector< bool > >& targetNodes );
1715 
1716 void testFilterOffNodeTargets()
1717 {
1718  Eref sheller = Id().eref();
1719  Shell* shell = reinterpret_cast< Shell* >( sheller.data() );
1720  unsigned int numSrcData = 6; // # entries in src of msg.
1721  unsigned int numData = 6; // Number of entries in msg destination elm.
1722 
1723  vector< vector< Eref > > origErefs( numSrcData );
1724  // erefs[ srcDataId ][entries]: targets for each dataIndex.
1725  vector< vector< bool > > origTargetNodes( numSrcData );
1726  // targetNodes[srcDataId][node]
1727 
1728  Id neuronId = shell->doCreate( "IntFire", Id(), "neurons", numData,
1729  MooseBlockBalance );
1730  Element* elm = neuronId.element();
1731  unsigned int numPerSrcNode = 1 + ( numSrcData - 1 ) / Shell::numNodes();
1732  unsigned int numPerNode = 1 + ( numData - 1 ) / Shell::numNodes();
1733 
1734  for ( unsigned int i = 0; i < numSrcData; ++i ) {
1735  origTargetNodes[i].resize( Shell::numNodes(), false );
1736  for ( unsigned int j = 0; j < i && j < numData; ++j )
1737  origErefs[i].push_back( Eref (elm, j ) );
1738  }
1739 
1740  for ( unsigned int myNode = 0; myNode < Shell::numNodes(); ++myNode ){
1741  vector< vector< Eref > > erefs = origErefs;
1742  vector< vector< bool > > targetNodes = origTargetNodes;
1743 
1744  filterOffNodeTargets(
1745  0, numSrcData,
1746  false, myNode, erefs, targetNodes );
1747  for ( unsigned int i = 0; i < numSrcData; ++i ) {
1748  unsigned int sz = 0;
1749  // cout << endl << i << ": ";
1750  if ( i > numPerSrcNode * myNode ) {
1751  unsigned int j = i - numPerNode * myNode;
1752  if ( j > numPerNode )
1753  sz = numPerNode;
1754  else
1755  sz = j;
1756  }
1757  assert( erefs[i].size() == sz );
1758  // cout << "(" << sz << ", " << erefs[i].size() << "), ";
1759  for ( unsigned int j = 0; j < erefs[i].size(); ++j )
1760  assert( erefs[i][j].getNode() == myNode );
1761 
1762  for ( unsigned int j = 0; j < Shell::numNodes(); ++j ) {
1763  if ( j == myNode )
1764  assert( targetNodes[i][j] == false );
1765  else
1766  assert( targetNodes[i][j] == ( i > j * numPerNode ) );
1767  }
1768  }
1769  }
1770 
1771  for ( unsigned int i = 0; i < numSrcData; ++i ) {
1772  origTargetNodes[i].clear();
1773  origTargetNodes[i].resize( Shell::numNodes(), false );
1774  origErefs[i].clear();
1775  origErefs[i].push_back( Eref (elm, ALLDATA ) );
1776  }
1777  for ( unsigned int myNode = 0; myNode < Shell::numNodes(); ++myNode ){
1778  vector< vector< Eref > > erefs = origErefs;
1779  vector< vector< bool > > targetNodes = origTargetNodes;
1780  // cout << "\nmyNode = " << myNode << endl;
1781 
1782  unsigned int start = numPerSrcNode * myNode;
1783  unsigned int end = start + 1+ (numSrcData-1) % numPerSrcNode;
1784  filterOffNodeTargets(
1785  start, end,
1786  false, myNode, erefs, targetNodes );
1787  for ( unsigned int i = 0; i < numData; ++i ) {
1788  // assert( erefs[i].size() == 1 );
1789  // The above should be true, except that this test always
1790  // runs on node 0 and Erefs refer to the system myNode to
1791  // find where they are.
1792  assert( erefs[i].size() == ( myNode == 0 ) );
1793  // cout << "\n i = " << i << ", sz=" << erefs[i].size();
1794  for ( unsigned int j = 0; j < erefs[i].size(); ++j )
1795  assert( erefs[i][j].getNode() == myNode );
1796 
1797  // Rule is : msgs sourced here that go off-node.
1798  // This works despite the system myNode, because in ALLDATA
1799  // we do a special lookup.
1800  for ( unsigned int j = 0; j < Shell::numNodes(); ++j ) {
1801  // sourced here: i / numPerNode == myNode
1802  if ( i / numPerNode == myNode && j != myNode )
1803  assert( targetNodes[i][j] == true );
1804  else
1805  assert( targetNodes[i][j] == false );
1806  // cout << "\ntargetNodes[" << i << "][" << j << "] = " << targetNodes[i][j];
1807  }
1808  }
1809  }
1810 
1811  cout << "." << flush;
1812 
1813  shell->doDelete( neuronId );
1814 }
1815 
1816 extern void testWildcard();
1817 
1818 void testShell( )
1819 {
1820  testExtractIndices();
1821  testChopPath();
1822  testTreeTraversal();
1823  testChildren();
1824  testWildcard();
1826  testGetMsgs(); // Tests getting Msg info from Neutral.
1827  testGetMsgSrcAndTarget();
1828 
1829  // This is a multinode test, but only needs to run on master node.
1830  testFilterOffNodeTargets();
1831 }
1832 
1833 void testMpiShell( )
1834 {
1835  testFilterOffNodeTargets();
1836  testShellParserCreateDelete();
1837  testTreeTraversal();
1838  testChildren();
1839  testDescendant();
1840  testMove();
1841  testCopy();
1842  testCopyFieldElement();
1843 
1844  testObjIdToAndFromPath();
1845  // testMultiLevelCopyAndPath(); // Uses HH channels.
1846 
1847  testShellSetGet();
1848  testInterNodeOps();
1849  testShellAddMsg();
1850  testCopyMsgOps();
1851  testWildcard();
1852  testSyncSynapseSize();
1853  // Stuff for doLoadModel
1854  testFindModelParent();
1855  cout << "." << flush;
1856 }
testChopPath
void testChopPath()
Definition: testShell.cpp:1345
init
Id init(int argc, char **argv, bool &doUnitTests, bool &doRegressionTests, unsigned int &benchmark)
Definition: main.cpp:150
Shell::doStart
void doStart(double runtime, bool notify=false)
Definition: Shell.cpp:332
Eref::data
char * data() const
Definition: Eref.cpp:41
checkArg1
bool checkArg1(Id id, double v0, double v1, double v2, double v3, double v4)
Definition: testShell.cpp:762
findModelParent
bool findModelParent(Id cwe, const string &path, Id &parentId, string &modelName)
Definition: LoadModels.cpp:81
Neutral::parent
static ObjId parent(const Eref &e)
Definition: Neutral.cpp:701
Shell::chopString
static bool chopString(const string &path, vector< string > &ret, char separator= '/')
Definition: Shell.cpp:459
Neutral::getParent
ObjId getParent(const Eref &e) const
Definition: Neutral.cpp:326
testShellParserStart
void testShellParserStart()
Definition: testShell.cpp:640
checkOutput
bool checkOutput(Id e, double v0, double v1, double v2, double v3, double v4)
Definition: testShell.cpp:795
testFindModelParent
void testFindModelParent()
Definition: testShell.cpp:1380
testShellSetGet
void testShellSetGet()
Definition: testShell.cpp:724
ObjId::fieldIndex
unsigned int fieldIndex
Definition: ObjId.h:100
Id::element
Element * element() const
Synonym for Id::operator()()
Definition: Id.cpp:113
Arith
Definition: Arith.h:12
testCopyMsgOps
void testCopyMsgOps()
Definition: testShell.cpp:1083
Shell::doSetClock
void doSetClock(unsigned int tickNum, double dt)
Definition: Shell.cpp:377
ObjId::bad
bool bad() const
Definition: ObjId.cpp:18
Id::path
std::string path(const std::string &separator="/") const
Definition: Id.cpp:76
Id::value
unsigned int value() const
Definition: Id.cpp:197
testWildcard
void testWildcard()
Definition: Wildcard.cpp:591
testChildren
void testChildren()
Test the Neutral::children and buildTree.
Definition: testShell.cpp:290
Clock::initCinfo
static const Cinfo * initCinfo()
Definition: Clock.cpp:133
testChopString
void testChopString()
Definition: testShell.cpp:1296
Field::setRepeat
static bool setRepeat(ObjId destId, const string &field, A arg)
Definition: SetGet.h:260
testShellParserCreateDelete
void testShellParserCreateDelete()
Definition: testShell.cpp:31
Field
Definition: SetGet.h:236
ObjId::id
Id id
Definition: ObjId.h:98
extractIndex
bool extractIndex(const string &s, unsigned int &index)
Definition: Shell.cpp:423
testShellParserQuit
void testShellParserQuit()
Definition: testShell.cpp:1246
Cinfo::find
static const Cinfo * find(const std::string &name)
Definition: Cinfo.cpp:200
testMpiShell
void testMpiShell()
Definition: testShell.cpp:1833
Shell::doCopy
Id doCopy(Id orig, ObjId newParent, string newName, unsigned int n, bool toGlobal, bool copyExtMsgs)
Returns the Id of the root of the copied tree upon success.
Definition: ShellCopy.cpp:16
Neutral::child
static Id child(const Eref &e, const string &name)
Definition: Neutral.cpp:665
ObjId
Definition: ObjId.h:20
testShellAddMsg
void testShellAddMsg()
Definition: testShell.cpp:836
testCopy
void testCopy()
Definition: testShell.cpp:388
Id::eref
Eref eref() const
Definition: Id.cpp:125
Neutral::children
static void children(const Eref &e, vector< Id > &ret)
Definition: Neutral.cpp:342
Eref::element
Element * element() const
Definition: Eref.h:42
Field::set
static bool set(const ObjId &dest, const string &field, A arg)
Definition: SetGet.h:245
testExtractIndices
void testExtractIndices()
Definition: testShell.cpp:1257
Neutral::buildTree
unsigned int buildTree(const Eref &e, vector< Id > &tree) const
Definition: Neutral.cpp:583
Shell::doFind
ObjId doFind(const string &path) const
Definition: Shell.cpp:549
testGetMsgSrcAndTarget
void testGetMsgSrcAndTarget()
Definition: testShell.cpp:1702
Shell::doCreate
Id doCreate(string type, ObjId parent, string name, unsigned int numData, NodePolicy nodePolicy=MooseBlockBalance, unsigned int preferredNode=1)
Definition: Shell.cpp:181
Id::destroy
void destroy() const
Definition: Id.cpp:176
testShell
void testShell()
Definition: testShell.cpp:1818
ALLDATA
const unsigned int ALLDATA
Used by ObjId and Eref.
Definition: consts.cpp:22
Neutral::getChildren
vector< Id > getChildren(const Eref &e) const
Definition: Neutral.cpp:334
doubleEq
bool doubleEq(double x, double y)
Definition: doubleEq.cpp:16
verifyKids
void verifyKids(Id f1, Id f2a, Id f2b, Id f3, Id f4a, Id f4b)
Utility function to check a commonly used tree structure.
Definition: testShell.cpp:266
myNode
static unsigned int myNode
Definition: moosemodule.cpp:168
Neutral::isDescendant
static bool isDescendant(Id me, Id ancestor)
Definition: Neutral.cpp:647
testCopyFieldElement
void testCopyFieldElement()
Definition: testShell.cpp:440
filterOffNodeTargets
void filterOffNodeTargets(unsigned int start, unsigned int end, bool isSrcGlobal, unsigned int myNode, vector< vector< Eref > > &erefs, vector< vector< bool > > &targetNodes)
Definition: Element.cpp:429
ObjId::path
string path() const
Definition: ObjId.cpp:119
Element::numField
virtual unsigned int numField(unsigned int rawIndex) const =0
Returns number of field entries for specified data.
testFilterOffNodeTargets
void testFilterOffNodeTargets()
Definition: testShell.cpp:1716
Eref
Definition: Eref.h:26
Element::numData
virtual unsigned int numData() const =0
Returns number of data entries across all nodes.
Element::isGlobal
virtual bool isGlobal() const =0
True if there is a copy of every dataEntry on all nodes.
Field::setVec
static bool setVec(ObjId destId, const string &field, const vector< A > &arg)
Definition: SetGet.h:252
Shell::doQuit
void doQuit()
Definition: Shell.cpp:327
TEST_WARNING
const bool TEST_WARNING
Definition: testShell.cpp:25
ObjId::element
Element * element() const
Definition: ObjId.cpp:124
testObjIdToAndFromPath
void testObjIdToAndFromPath()
Definition: testShell.cpp:549
Shell::doReinit
void doReinit()
Definition: Shell.cpp:362
testSyncSynapseSize
void testSyncSynapseSize()
Definition: testShell.cpp:1455
Shell::chopPath
static bool chopPath(const string &path, vector< string > &ret, vector< unsigned int > &index)
Definition: Shell.cpp:512
Shell::setCwe
void setCwe(ObjId cwe)
Definition: Shell.cpp:610
ObjId::eref
Eref eref() const
Definition: ObjId.cpp:66
Shell::doAddMsg
ObjId doAddMsg(const string &msgType, ObjId src, const string &srcField, ObjId dest, const string &destField)
Definition: Shell.cpp:269
SetGet1::set
static bool set(const ObjId &dest, const string &field, A arg)
Definition: SetGet.h:153
SetGet3::set
static bool set(const ObjId &dest, const string &field, A1 arg1, A2 arg2, A3 arg3)
Definition: SetGet.h:626
Shell::doDelete
bool doDelete(ObjId oid)
Definition: Shell.cpp:259
Id
Definition: Id.h:17
Element::getNeighbors
unsigned int getNeighbors(vector< Id > &ret, const Finfo *finfo) const
Definition: Element.cpp:949
Shell::myNode
static unsigned int myNode()
Definition: ShellThreads.cpp:81
Shell::doUseClock
void doUseClock(string path, string field, unsigned int tick)
Definition: Shell.cpp:382
testDescendant
void testDescendant()
Test the Neutral::isDescendant.
Definition: testShell.cpp:234
Field::get
static A get(const ObjId &dest, const string &field)
Definition: SetGet.h:284
Shell::numNodes
static unsigned int numNodes()
Definition: ShellThreads.cpp:76
Field::getVec
static void getVec(ObjId dest, const string &field, vector< A > &vec)
Definition: SetGet.h:317
testTreeTraversal
void testTreeTraversal()
Definition: testShell.cpp:45
Element::getName
const string & getName() const
Definition: Element.cpp:56
testMove
void testMove()
Definition: testShell.cpp:323
testInterNodeOps
void testInterNodeOps()
Definition: testShell.cpp:708
testGetMsgs
void testGetMsgs()
Definition: testShell.cpp:1518
SetGet1::setVec
static bool setVec(ObjId destId, const string &field, const vector< A > &arg)
Definition: SetGet.h:188
Cinfo
Definition: Cinfo.h:18
path
static char path[]
Definition: mfield.cpp:403
Shell
Definition: Shell.h:43
Cinfo::findFinfo
const Finfo * findFinfo(const string &name) const
Definition: Cinfo.cpp:224
ObjId::dataIndex
unsigned int dataIndex
Definition: ObjId.h:99
Finfo
Definition: Finfo.h:12
Shell::doMove
void doMove(Id orig, ObjId newParent)
Definition: Shell.cpp:390