nemo::Network* constructWattsStrogatz(unsigned k, unsigned p, unsigned ncount, unsigned dmax, bool stdp) {
rng_t rng;
/* Neuron parameters and weights are partially randomised */
urng_t randomParameter(rng, boost::uniform_real<double>(0, 1));
uirng_t randomDelay(rng, boost::uniform_int<>(1, dmax));
std::vector<std::vector<unsigned> > matrix(ncount, std::vector<unsigned>(ncount));
networkWattsStrogatz(matrix, ncount, k, p);
nemo::Network* net = new nemo::Network();
for ( unsigned nidx = 0; nidx < ncount; ++nidx ) {
if ( nidx < (ncount * 4) / 5 ) { // excitatory
addExcitatoryNeuron(net, nidx, randomParameter);
for ( unsigned j = 0; j < ncount; ++j ) {
if ( matrix[nidx][j] == 1 )
net->addSynapse(nidx, j, randomDelay(), 0.5f * float(randomParameter()), stdp);
}
}
else { // inhibitory
addInhibitoryNeuron(net, nidx, randomParameter);
for ( unsigned j = 0; j < ncount; ++j ) {
if ( matrix[nidx][j] == 1 )
net->addSynapse(nidx, j, 1U, float(-randomParameter()), 0);
}
}
}
return net;
}
nemo::Network*
construct(unsigned ncount, unsigned scount, unsigned dmax, bool stdp)
{
rng_t rng;
/* Neuron parameters and weights are partially randomised */
urng_t randomParameter(rng, boost::uniform_real<double>(0, 1));
uirng_t randomTarget(rng, boost::uniform_int<>(0, ncount-1));
uirng_t randomDelay(rng, boost::uniform_int<>(1, dmax));
nemo::Network* net = new nemo::Network();
for(unsigned nidx=0; nidx < ncount; ++nidx) {
if(nidx < (ncount * 4) / 5) { // excitatory
addExcitatoryNeuron(net, nidx, randomParameter);
for(unsigned s = 0; s < scount; ++s) {
net->addSynapse(nidx, randomTarget(), randomDelay(), 0.5f * float(randomParameter()), stdp);
}
} else { // inhibitory
addInhibitoryNeuron(net, nidx, randomParameter);
for(unsigned s = 0; s < scount; ++s) {
net->addSynapse(nidx, randomTarget(), 1U, float(-randomParameter()), 0);
}
}
}
return net;
}
void fly_reset(Firefly* fly){
if(fly == 0) return;
if(fly->pin == 0) return;
fly->songIndex = randomSong();
//Serial.println(fly->songIndex+'a', BYTE);
fly->currentNote = 0;
fly->delay = randomDelay();
}
int main(void) {
char byte;
uint16_t timerValue;
// -------- Inits --------- //
initUSART();
initTimer1();
LED_DDR = 0xff; /* all LEDs for output */
BUTTON_PORT |= (1 << BUTTON); /* enable internal pull-up */
printString("\r\nReaction Timer:\r\n");
printString("---------------\r\n");
printString("Press any key to start.\r\n");
// ------ Event loop ------ //
while (1) {
byte = receiveByte(); /* press any key */
printString("\r\nGet ready...");
randomDelay();
printString("\r\nGo!\r\n");
LED_PORT = 0xff; /* light LEDs */
TCNT1 = 0; /* reset counter */
if (bit_is_clear(BUTTON_PIN, BUTTON)) {
/* Button pressed _exactly_ as LEDs light up. Suspicious. */
printString("You're only cheating yourself.\r\n");
}
else {
// Wait until button pressed, save timer value.
loop_until_bit_is_clear(BUTTON_PIN, BUTTON);
timerValue = TCNT1 >> 4;
/* each tick is approx 1/16 milliseconds, so we bit-shift divide */
printMilliseconds(timerValue);
printComments(timerValue);
}
// Clear LEDs and start again.
LED_PORT = 0x00;
printString("Press any key to try again.\r\n");
} /* End event loop */
return (0); /* This line is never reached */
}
int main(int argc,char **argv) {
LogLevel = 3;
iniMPI(argc, argv);
fftw_init_threads();
fftw_plan_with_nthreads(1);
loadCommandLineParameters(argc,argv);
loadDataFromAnalyzerToDoList();
iniTools(537*Parameter_Job_ID);
startTimer();
if (Parameter_Job_ID>0) randomDelay(1000);
SDReader = new StateDescriptorReader(Parameter_SD_FileName);
int threadCountPerNode = 1;
int ParaOpMode = 0;
char* fftPlanDescriptor = NULL;
bool usexFFT = false;
readOptimalFermionVectorEmbeddingAndFFTPlanFromTuningDB(SDReader->getL0(), SDReader->getL1(), SDReader->getL2(), SDReader->getL3(), threadCountPerNode, ParaOpMode, usexFFT, SDReader->getUseP(), SDReader->getUseQ(), SDReader->getUseR(), SDReader->getUseQHM(), fftPlanDescriptor);
delete[] fftPlanDescriptor;
char* fileNameExtension = SDReader->getFileNameExtension();
ioControl = new AnalyzerIOControl(fileNameExtension, Parameter_Job_ID);
delete[] fileNameExtension;
fermiOps = new FermionMatrixOperations(SDReader->getL0(), SDReader->getL1(), SDReader->getL2(), SDReader->getL3(), SDReader->getRho(), SDReader->getR(), SDReader->getYN());
fermiOps->setMassSplitRatio(SDReader->getMassSplit());
fermiOps->setAntiPeriodicBoundaryConditionsInTime(SDReader->useAntiPeriodicBoundaryConditionsInTimeDirection());
iniAnalyzerObs();
iniAuxVecs();
createFolders();
ioControl->removeDeprecatedInProgressFiles(48.0);
if (LogLevel>2) printf("\nEntering main Analyzer-Loop.\n");
int confID = -1;
while (((confID=getNextConfIDforAnalysis())>=0) && (timePassed()<3600*Parameter_MaxRunTime)) {
ioControl->markAsInProgress(confID);
bool keepMarked = false;
char* confFileName = ioControl->getPhiConfFileName(confID);
AnalyzerPhiFieldConfiguration* phiFieldConf = new AnalyzerPhiFieldConfiguration(confFileName, fermiOps);
delete[] confFileName;
if (phiFieldConf->getErrorState() == 0) {
for (int I=0; I<analyzerObsCount; I++) {
bool activeObs = false;
for (int I2=0; I2<Parameter_tagCount; I2++) {
if (analyzerObs[I]->isNick(Parameter_tags[I2])) activeObs = true;
}
if (activeObs) {
if ((!analyzerObs[I]->isConfAnalyzed(confID)) && (analyzerObs[I]->shallConfBeAnalyzed(confID))) {
if (LogLevel>2) printf("Analyzing Observable %s...\n",analyzerObs[I]->getObsName());
bool b = analyzerObs[I]->analyze(phiFieldConf, auxVecs);
phiFieldConf->clearPhiFieldCopies();
if (b) {
analyzerObs[I]->saveAnalyzerResults(confID);
} else {
keepMarked = true;
if (LogLevel>1) {
printf(" *** Could not analyze observable %s on configuration %d. Continue with next configuration.\n",analyzerObs[I]->getObsName(),confID);
}
}
}
}
}
} else {
keepMarked = true;
if (LogLevel>1) {
printf(" *** Could not load configuration file %d --> Skipping configuration file\n",confID);
}
}
delete phiFieldConf;
if (!keepMarked) ioControl->unmarkAsInProgress(confID);
if (Parameter_Job_ID>0) randomDelay(2);
}
if (LogLevel>2) printf("\nLeaving main Analyzer-Loop.\n\n");
desini();
desiniTools();
fftw_cleanup_threads();
if (LogLevel>1) printf("Analyzer terminated correctly.\n");
}
/* Used to demonstrate the optimal network for MPI simulations */
nemo::Network* constructSemiRandom(unsigned ncount, unsigned scount, unsigned dmax, bool stdp, unsigned workers, float ratio) {
rng_t rng;
/* Neuron parameters and weights are partially randomised */
urng_t randomParameter(rng, boost::uniform_real<double>(0, 1));
uirng_t randomDelay(rng, boost::uniform_int<>(1, dmax));
nemo::Network* net = new nemo::Network();
/* Firstly, add ncount neurons to the network.
* Properties: 80% excitatory, 20% inhibitory.
*/
for ( unsigned nidx = 0; nidx < ncount; ++nidx ) {
if ( nidx < (ncount * 4) / 5 ) { // excitatory
addExcitatoryNeuron(net, nidx, randomParameter);
}
else { // inhibitory
addInhibitoryNeuron(net, nidx, randomParameter);
}
}
/* Initialize partition counters */
float avgNeurons = ceil(((float) ncount) / ((float) workers));
std::vector<unsigned> counters(workers, avgNeurons);
counters.back() = ncount - (workers - 1) * avgNeurons;
std::vector<std::pair<nidx_t, nidx_t> > ranges;
/* Make index ranges for each partition */
for ( unsigned r = 0; r < workers; r++ ) {
unsigned start = r * avgNeurons;
std::pair<unsigned, unsigned> range(start, start + counters[r] - 1);
ranges.push_back(range);
}
for ( unsigned i = 0; i < workers; i++ ) {
uirng_t randomLocalNeuron(rng, boost::uniform_int<>(ranges[i].first, ranges[i].second));
unsigned partitionSynapses = counters[i] * scount;
unsigned globalSynapses = ratio * partitionSynapses;
unsigned localSynapses = partitionSynapses - globalSynapses;
// std::cout << "partitionSynapses: " << partitionSynapses << std::endl;
// std::cout << "localSynapses: " << localSynapses << std::endl;
// std::cout << "globalSynapses: " << globalSynapses << std::endl;
// std::cout << std::endl;
for ( unsigned j = 0; j < localSynapses; j++ ) {
unsigned source;
unsigned target;
while (true) {
source = randomLocalNeuron();
target = randomLocalNeuron();
if ( source != target )
break;
}
if ( randomLocalNeuron() < (ncount * 4) / 5 )
net->addSynapse(source, target, randomDelay(), 0.5f * float(randomParameter()), stdp);
else
net->addSynapse(source, target, 1U, float(-randomParameter()), stdp);
}
for ( unsigned j = 0; j < globalSynapses; j++ ) {
uirng_t randomWorker(rng, boost::uniform_int<>(0, workers - 1));
unsigned randomNeighbour;
while (true) {
randomNeighbour = randomWorker();
if ( randomNeighbour != i )
break;
}
uirng_t randomGlobalNeuron(rng,
boost::uniform_int<>(ranges[randomNeighbour].first, ranges[randomNeighbour].second));
if ( randomLocalNeuron() < (ncount * 4) / 5 )
net->addSynapse(randomLocalNeuron(), randomGlobalNeuron(), randomDelay(), 0.5f * float(randomParameter()), stdp);
else
net->addSynapse(randomLocalNeuron(), randomGlobalNeuron(), 1U, float(-randomParameter()), stdp);
}
}
// std::cout << "net->neuronCount: " << net->neuronCount() << std::endl;
// std::cout << "net->synapseCount: " << net->synapseCount() << std::endl;
return net;
}
/* Used for debugging */
nemo::Network* simpleNet(unsigned ncount, unsigned dmax, bool stdp) {
rng_t rng;
/* Neuron parameters and weights are partially randomised */
urng_t randomParameter(rng, boost::uniform_real<double>(0, 1));
uirng_t randomDelay(rng, boost::uniform_int<>(1, dmax));
nemo::Network* net = new nemo::Network();
for ( unsigned nidx = 0; nidx < ncount; ++nidx ) {
if ( nidx < (ncount * 4) / 5 ) { // excitatory
nemo::random::addExcitatoryNeuron(net, nidx, randomParameter);
if ( nidx == 0 ) {
net->addSynapse(nidx, 1, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 6, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 11, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(2, nidx, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(3, nidx, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(4, nidx, randomDelay(), 0.5f * float(randomParameter()), stdp);
}
if ( nidx == 8 ) {
net->addSynapse(nidx, 2, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 7, randomDelay(), 0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 14, randomDelay(), 0.5f * float(randomParameter()), stdp);
}
}
else { // inhibitory
nemo::random::addInhibitoryNeuron(net, nidx, randomParameter);
if ( nidx == 13 ) {
net->addSynapse(nidx, 3, randomDelay(), -0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 8, randomDelay(), -0.5f * float(randomParameter()), stdp);
net->addSynapse(nidx, 14, randomDelay(), -0.5f * float(randomParameter()), stdp);
}
}
}
return net;
}
