void Pool::vRemesh( const Eref& e, const Qinfo* q, double oldvol, unsigned int numTotalEntries, unsigned int startEntry, const vector< unsigned int >& localIndices, const vector< double >& vols ) { if ( e.index().value() != 0 ) return; /* if ( q->addToStructuralQ() ) return; */ Neutral* n = reinterpret_cast< Neutral* >( e.data() ); assert( vols.size() > 0 ); double concInit = nInit_ / ( NA * oldvol ); if ( vols.size() != e.element()->dataHandler()->localEntries() ) n->setLastDimension( e, q, vols.size() ); // Note that at this point the Pool pointer may be invalid! // But we need to update the concs anyway. assert( e.element()->dataHandler()->localEntries() == vols.size() ); Pool* pooldata = reinterpret_cast< Pool* >( e.data() ); for ( unsigned int i = 0; i < vols.size(); ++i ) { pooldata[i].nInit_ = pooldata[i].n_ = concInit * vols[i] * NA; } }
string SigNeur::getChannelMap( Eref e, const string& i ) { SigNeur* sn = static_cast< SigNeur* >( e.data() ); map< string, string >::iterator j = sn->channelMap_.find( i ); if ( j != sn->channelMap_.end() ) return j->second; return ""; }
///////////////////////////////////////////////////////////////// // Now test 'get' across nodes. // Normally the 'get' call is invoked by the parser, which expects a // value to come back. Note that the return must be asynchronous: // the parser cannot block since we need to execute MPI polling // operations on either side. ///////////////////////////////////////////////////////////////// void testParGet( Id tnId, vector< Id >& testIds ) { unsigned int myNode = MuMPI::INTRA_COMM().Get_rank(); unsigned int numNodes = MuMPI::INTRA_COMM().Get_size(); Slot parGetSlot = initShellCinfo()->getSlot( "parallel.getSrc" ); char name[20]; string sname; if ( myNode == 0 ) { cout << "\ntesting parallel get" << flush; } else { sprintf( name, "foo%d", myNode * 2 ); sname = name; set< string >( tnId.eref(), "name", sname ); } MuMPI::INTRA_COMM().Barrier(); Eref e = Id::shellId().eref(); Shell* sh = static_cast< Shell* >( e.data() ); vector< unsigned int > rids( numNodes, 0 ); vector< string > ret( numNodes ); unsigned int origSize = sh->freeRidStack_.size(); ASSERT( origSize > 0 , "Stack initialized properly" ); if ( myNode == 0 ) { for ( unsigned int i = 1; i < numNodes; i++ ) { rids[i] = openOffNodeValueRequest< string >( sh, &ret[i], 1 ); ASSERT( sh->freeRidStack_.size() == origSize - i, "stack in use" ); sendTo3< Id, string, unsigned int >( Id::shellId().eref(), parGetSlot, i - 1, testIds[i - 1], "name", rids[i] ); } } // Here we explicitly do what the closeOffNodeValueRequest handles. MuMPI::INTRA_COMM().Barrier(); // Cycle a few times to make sure all data gets back to node 0 for ( unsigned int i = 0; i < 5; i++ ) { pollPostmaster(); MuMPI::INTRA_COMM().Barrier(); } // Now go through to check all values have come back. if ( myNode == 0 ) { ASSERT( sh->freeRidStack_.size() == 1 + origSize - numNodes, "Stack still waiting" ); for ( unsigned int i = 1; i < numNodes; i++ ) { sprintf( name, "foo%d", i * 2 ); sname = name; ASSERT( sh->offNodeData_[ rids[i] ].numPending == 0, "Pending requests cleared" ); ASSERT( sh->offNodeData_[ rids[i] ].data == static_cast< void* >( &ret[i] ), "Pointing to strings" ); ASSERT( ret[ i ] == sname, "All values returned correctly" ); // Clean up the debris sh->offNodeData_[ rids[i] ].data = 0; sh->freeRidStack_.push_back( rids[i] ); } } }
void Shell::destroy( const Eref& e, ObjId oid) { Neutral *n = reinterpret_cast< Neutral* >( e.data() ); assert( n ); // cout << myNode_ << ": Shell::destroy done for element id: " << eid << ", name = " << eid.element()->getName() << endl; n->destroy( oid.eref(), 0 ); if ( cwe_.id == oid.id ) cwe_ = ObjId(); }
double PulseGen::getSecondDelay(Eref e) { PulseGen* obj = static_cast <PulseGen*> (e.data()); ASSERT( obj != NULL, "PulseGen::getSecondDelay(Eref ) - target data pointer is NULL."); if (obj->delay_.size() >= 2){ return obj->delay_[obj->delay_.size() - 1]; } return 0.0; }
double BinSynchan::getReleaseCount( Eref e, const unsigned int& i ) { vector< BinSynInfo >& synapses = static_cast< BinSynchan* >( e.data() )->synapses_; if ( i < synapses.size() ) return synapses[i].getReleaseCount(); cout << "Error: BinSynchan::getReleaseCount : Index " << i << " out of range\n"; return 0.0; }
double PulseGen::getDelay(Eref e, const int& index) { PulseGen* obj = static_cast <PulseGen*> (e.data()); ASSERT( obj != NULL, "PulseGen::getDelay(Eref ) - target data pointer is NULL."); if (index >= 0 && index < obj->delay_.size()){ return obj->delay_[index]; } else { cout << "WARNING: PulseGen::getDelay - invalid index." << endl; return 0.0; } }
static double getDmap( Eref e, const string& s ) { map< string, double >::iterator i; LookupTestClass* atc = static_cast< LookupTestClass* >( e.data() ); i = atc->dmap.find( s ); if ( i != atc->dmap.end() ) return i->second; cout << "Error: LookupTestClass::getDvec: index not found \n"; return 0.0; }
// vRemesh: All the work is done by the message from the compartment to the // Stoich. None of the ZPools is remeshed directly. However, their // DataHandlers need updating. void ZPool::vRemesh( const Eref& e, const Qinfo* q, double oldvol, unsigned int numTotalEntries, unsigned int startEntry, const vector< unsigned int >& localIndices, const vector< double >& vols ) { ; if ( e.index().value() != 0 ) return; Neutral* n = reinterpret_cast< Neutral* >( e.data() ); if ( vols.size() != e.element()->dataHandler()->localEntries() ) n->setLastDimension( e, q, vols.size() ); }
// Static func void Shell::cleanSimulation() { Eref sheller = Id().eref(); Shell* s = reinterpret_cast< Shell* >( sheller.data() ); vector< Id > kids; Neutral::children( sheller, kids ); for ( vector< Id >::iterator i = kids.begin(); i != kids.end(); ++i ) { if ( i->value() > 4 ) { cout << "Shell::cleanSimulation: deleted cruft at " << i->value() << ": " << i->path() << endl; s->doDelete( *i ); } } }
double SigNeur::getSigDt( Eref e ) { return static_cast< SigNeur* >( e.data() )->sigDt_; }
string SigNeur::getSomaMethod( Eref e ) { return static_cast< SigNeur* >( e.data() )->somaMethod_; }
string SigNeur::getDendMethod( Eref e ) { return static_cast< SigNeur* >( e.data() )->dendMethod_; }
string SigNeur::getCellMethod( Eref e ) { return static_cast< SigNeur* >( e.data() )->cellMethod_; }
double IzhikevichNrn::getGamma(Eref e) { return static_cast<IzhikevichNrn*>(e.data())->gamma_; }
double SigNeur::getUpdateStep( Eref e ) { return static_cast< SigNeur* >( e.data() )->updateStep_; }
double SigNeur::getLambda( Eref e ) { return static_cast< SigNeur* >( e.data() )->lambda_; }
// created arrays Id SigNeur::getCell( Eref e ) { return static_cast< SigNeur* >( e.data() )->cell_; }
static double getDval( Eref e ) { return static_cast< LookupTestClass* >( e.data() )->dval; }
double IzhikevichNrn::getInitU(Eref e) { return static_cast<IzhikevichNrn*>(e.data())->initU_; }
double IzhikevichNrn::getInject(Eref e) { return static_cast<IzhikevichNrn*>(e.data())->Im_; }
double SigNeur::getCellDt( Eref e ) { return static_cast< SigNeur* >( e.data() )->cellDt_; }
double SigNeur::getDscale( Eref e ) { return static_cast< SigNeur* >( e.data() )->Dscale_; }
string SigNeur::getDendExclude( Eref e ) { return static_cast< SigNeur* >( e.data() )->dendExclude_; }
int SigNeur::getParallelMode( Eref e ) { return static_cast< SigNeur* >( e.data() )->parallelMode_; }
Id SigNeur::getSoma( Eref e ) { return static_cast< SigNeur* >( e.data() )->soma_; }
double SigNeur::getCalciumScale( Eref e ) { return static_cast< SigNeur* >( e.data() )->calciumScale_; }
double IzhikevichNrn::getBeta(Eref e) { return static_cast<IzhikevichNrn*>(e.data())->beta_; }
Id SigNeur::getSpine( Eref e ) { return static_cast< SigNeur* >( e.data() )->spine_; }
Id SigNeur::getDend( Eref e ) { return static_cast< SigNeur* >( e.data() )->dend_; }