int dumpweights(HyPerCol * hc, int argc, char * argv[]) { int status = PV_SUCCESS; bool existsgenconn = false; for( int k=0; k < hc->numberOfConnections(); k++ ) { HyPerConn * conn = dynamic_cast<HyPerConn *>(hc->getConnection(k)); //Only test plastic conns if( conn != NULL) { if(conn->getPlasticityFlag()){ existsgenconn = true; int status1 = dumponeweight(conn); if( status == PV_SUCCESS ) status = status1; } } } if( existsgenconn && status != PV_SUCCESS ) { for( int k=0; k<72; k++ ) { pvInfo().printf("="); } pvInfo().printf("\n"); } int rank = hc->icCommunicator()->commRank(); char * paramsfilename; pv_getopt_str(argc, argv, "-p", ¶msfilename, NULL/*paramusage*/); if( status != PV_SUCCESS ) { pvErrorNoExit().printf("Rank %d: %s failed with return code %d.\n", rank, paramsfilename, status); } else { pvInfo().printf("Rank %d: %s succeeded.\n", rank, paramsfilename); } free(paramsfilename); return status; }
int NormalizeScale::normalizeWeights() { int status = PV_SUCCESS; assert(numConnections >= 1); // All connections in the group must have the same values of sharedWeights, numArbors, and numDataPatches HyPerConn * conn0 = connectionList[0]; #ifdef USE_SHMGET #ifdef PV_USE_MPI if (conn->getShmgetFlag() && !callingConn->getShmgetOwner(0)) { // Assumes that all arbors are owned by the same process MPI_Barrier(conn->getParent()->icCommunicator()->communicator()); return status; } #endif // PV_USE_MPI #endif // USE_SHMGET float scale_factor = strength; status = NormalizeMultiply::normalizeWeights(); // applies normalize_cutoff threshold and symmetrizeWeights int nxp = conn0->xPatchSize(); int nyp = conn0->yPatchSize(); int nfp = conn0->fPatchSize(); int nxpShrunken = conn0->getNxpShrunken(); int nypShrunken = conn0->getNypShrunken(); int offsetShrunken = conn0->getOffsetShrunken(); int xPatchStride = conn0->xPatchStride(); int yPatchStride = conn0->yPatchStride(); int weights_per_patch = nxp*nyp*nfp; int nArbors = conn0->numberOfAxonalArborLists(); int numDataPatches = conn0->getNumDataPatches(); for (int patchindex = 0; patchindex<numDataPatches; patchindex++) { for (int arborID = 0; arborID<nArbors; arborID++) { for (int c=0; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; pvwdata_t * dataStartPatch = conn->get_wDataStart(arborID)+patchindex*weights_per_patch; normalizePatch(dataStartPatch, weights_per_patch, scale_factor); } } } #ifdef OBSOLETE // Marked obsolete Dec 9, 2014. #ifdef USE_SHMGET #ifdef PV_USE_MPI if (conn->getShmgetFlag()) { assert(conn->getShmgetOwner(0)); // Assumes that all arbors are owned by the same process MPI_Barrier(conn->getParent()->icCommunicator()->communicator()); } #endif // PV_USE_MPI #endif // USE_SHMGET #endif // OBSOLETE return status; }
int TestConnProbe::outputState(double timed){ //Grab weights of probe and test for the value of .625/1.5, or .4166666 HyPerConn* conn = getTargetHyPerConn(); int numPreExt = conn->preSynapticLayer()->getNumExtended(); int syw = conn->yPatchStride(); // stride in patch for(int kPre = 0; kPre < numPreExt; kPre++){ PVPatch * weights = conn->getWeights(kPre, 0); int nk = conn->fPatchSize() * weights->nx; pvwdata_t * data = conn->get_wData(0,kPre); int ny = weights->ny; for (int y = 0; y < ny; y++) { pvwdata_t * dataYStart = data + y * syw; for(int k = 0; k < nk; k++){ if(fabs(timed - 0) < (parent->getDeltaTime()/2)){ if(fabs(dataYStart[k] - 1) > .01){ std::cout << "dataYStart[k]: " << dataYStart[k] << "\n"; } assert(fabs(dataYStart[k] - 1) <= .01); } else if(fabs(timed - 1) < (parent->getDeltaTime()/2)){ if(fabs(dataYStart[k] - 1.375) > .01){ std::cout << "dataYStart[k]: " << dataYStart[k] << "\n"; } assert(fabs(dataYStart[k] - 1.375) <= .01); } } } } return PV_SUCCESS; }
int MomentumTestConnProbe::outputState(double timed){ //Grab weights of probe and test for the value of .625/1.5, or .4166666 HyPerConn* conn = getTargetHyPerConn(); int numPreExt = conn->preSynapticLayer()->getNumExtended(); int syw = conn->yPatchStride(); // stride in patch for(int kPre = 0; kPre < numPreExt; kPre++){ PVPatch * weights = conn->getWeights(kPre, 0); int nk = conn->fPatchSize() * weights->nx; pvwdata_t * data = conn->get_wData(0,kPre); int ny = weights->ny; pvdata_t wCorrect; for (int y = 0; y < ny; y++) { pvwdata_t * dataYStart = data + y * syw; for(int k = 0; k < nk; k++){ pvdata_t wObserved = dataYStart[k]; if(timed < 3){ wCorrect = 0; } else{ wCorrect = .376471; for(int i = 0; i < (timed-3); i++){ wCorrect += .376471 * exp(-(2*(i+1))); } } assert(fabs(wObserved - wCorrect) <= 1e-4); } } } return PV_SUCCESS; }
/** * @timef */ int PlasticConnTestProbe::outputState(double timed) { HyPerConn * c = getTargetHyPerConn(); InterColComm * icComm = c->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return PV_SUCCESS; } assert(getTargetConn()!=NULL); outputStream->printf(" Time %f, connection \"%s\":\n", timed, getTargetName()); const pvwdata_t * w = c->get_wDataHead(getArbor(), getKernelIndex()); const pvdata_t * dw = c->get_dwDataHead(getArbor(), getKernelIndex()); if( getOutputPlasticIncr() && dw == NULL ) { pvError().printf("PlasticConnTestProbe \"%s\": connection \"%s\" has dKernelData(%d,%d) set to null.\n", getName(), getTargetName(), getKernelIndex(), getArbor()); } int nxp = c->xPatchSize(); int nyp = c->yPatchSize(); int nfp = c->fPatchSize(); int status = PV_SUCCESS; for( int k=0; k<nxp*nyp*nfp; k++ ) { int x=kxPos(k,nxp,nyp,nfp); int wx = (nxp-1)/2 - x; // assumes connection is one-to-one if(getOutputWeights()) { pvdata_t wCorrect = timed*wx; pvdata_t wObserved = w[k]; if( fabs( ((double) (wObserved - wCorrect))/timed ) > 1e-4 ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); outputStream->printf(" index %d (x=%d, y=%d, f=%d: w = %f, should be %f\n", k, x, y, f, wObserved, wCorrect); } } if(timed > 0 && getOutputPlasticIncr() && dw != NULL) { pvdata_t dwCorrect = wx; pvdata_t dwObserved = dw[k]; if( dwObserved != dwCorrect ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); outputStream->printf(" index %d (x=%d, y=%d, f=%d: dw = %f, should be %f\n", k, x, y, f, dwObserved, dwCorrect); } } } assert(status==PV_SUCCESS); if( status == PV_SUCCESS ) { if (getOutputWeights()) { outputStream->printf(" All weights are correct.\n"); } if (getOutputPlasticIncr()) { outputStream->printf(" All plastic increments are correct.\n"); } } if(getOutputPatchIndices()) { patchIndices(c); } return PV_SUCCESS; }
/** * @timef */ int MomentumConnTestProbe::outputState(double timed) { HyPerConn * c = getTargetHyPerConn(); InterColComm * icComm = c->getParent()->icCommunicator(); const int rcvProc = 0; if( icComm->commRank() != rcvProc ) { return PV_SUCCESS; } assert(getTargetConn()!=NULL); FILE * fp = getStream()->fp; fprintf(fp, " Time %f, connection \"%s\":\n", timed, getTargetName()); const pvwdata_t * w = c->get_wDataHead(getArbor(), getKernelIndex()); const pvdata_t * dw = c->get_dwDataHead(getArbor(), getKernelIndex()); if( getOutputPlasticIncr() && dw == NULL ) { fprintf(stderr, "MomentumConnTestProbe \"%s\": connection \"%s\" has dKernelData(%d,%d) set to null.\n", getName(), getTargetName(), getKernelIndex(), getArbor()); assert(false); } int nxp = c->xPatchSize(); int nyp = c->yPatchSize(); int nfp = c->fPatchSize(); int status = PV_SUCCESS; for( int k=0; k<nxp*nyp*nfp; k++ ) { pvdata_t wObserved = w[k]; //Pulse happens at time 3 pvdata_t wCorrect; if(timed < 3){ wCorrect = 0; } else{ if(isViscosity){ wCorrect = 1; for(int i = 0; i < (timed - 3); i++){ wCorrect += exp(-(2*(i+1))); } } else{ wCorrect = 2 - pow(2, -(timed - 3)); } } if( fabs( ((double) (wObserved - wCorrect))/timed ) > 1e-4 ) { int y=kyPos(k,nxp,nyp,nfp); int f=featureIndex(k,nxp,nyp,nfp); fprintf(fp, " w = %f, should be %f\n", wObserved, wCorrect); exit(-1); } } return PV_SUCCESS; }
int main(int argc, char* argv[]) { int status = 0; PV_Init* initObj = new PV_Init(&argc, &argv); initObj->initialize(argc, argv); // create the managing hypercolumn // HyPerCol* hc = new HyPerCol("test_constant_input column", argc, argv, initObj); // create the image // TestImage * image = new TestImage("test_constant_input image", hc); // create the layers // HyPerLayer * retina = new Retina("test_constant_input retina", hc); // create the connections // HyPerConn * conn = new HyPerConn("test_constant_input connection", hc); const int nxp = conn->xPatchSize(); const int nyp = conn->yPatchSize(); const PVLayerLoc * imageLoc = image->getLayerLoc(); const PVLayerLoc * retinaLoc = image->getLayerLoc(); const int nfPre = imageLoc->nf; float sumOfWeights = (float) (nxp*nyp*nfPre); if (imageLoc->nx > retinaLoc->nx) { sumOfWeights *= imageLoc->nx/retinaLoc->nx;} if (imageLoc->ny > retinaLoc->ny) { sumOfWeights *= imageLoc->ny/retinaLoc->ny;} hc->run(); const int rank = hc->columnId(); #ifdef DEBUG_OUTPUT printf("[%d]: column: ", rank); printLoc(hc->getImageLoc()); printf("[%d]: image : ", rank); printLoc(image->getImageLoc()); printf("[%d]: retina: ", rank); printLoc(*retina->getLayerLoc()); printf("[%d]: l1 : ", rank); printLoc(*l1->getLayerLoc()); #endif status = checkLoc(hc, image->getLayerLoc()); if (status != PV_SUCCESS) { fprintf(stderr, "[%d]: test_constant_input: ERROR in image loc\n", rank); exit(status); } status = checkLoc(hc, retina->getLayerLoc()); if (status != PV_SUCCESS) { fprintf(stderr, "[%d]: test_constant_input: ERROR in retina loc\n", rank); exit(status); } status = checkInput(image->getLayerLoc(), image->getActivity(), image->getConstantVal(), true); if (status != PV_SUCCESS) { fprintf(stderr, "[%d]: test_constant_input: ERROR in image data\n", rank); exit(status); } float retinaVal = sumOfWeights * image->getConstantVal(); status = checkInput(retina->getLayerLoc(), retina->getActivity(), retinaVal, false); if (status != 0) { fprintf(stderr, "[%d]: test_constant_input: ERROR in retina data\n", rank); exit(status); } status = checkInput(retina->getLayerLoc(), retina->getLayerData(), retinaVal, true); if (status != 0) { fprintf(stderr, "[%d]: test_constant_input: ERROR in retina data\n", rank); exit(status); } delete hc; delete initObj; return status; }
int main(int argc, char * argv[]) { PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/); PV_Arguments * arguments = initObj->getArguments(); if (arguments->getParamsFile()==NULL) { int rank = 0; MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank==0) { fprintf(stderr, "%s does not take a -p argument; the necessary param file is hardcoded.\n", argv[0]); } MPI_Barrier(MPI_COMM_WORLD); exit(EXIT_FAILURE); } arguments->setParamsFile("input/test_gauss2d.params"); const char * pre_layer_name = "test_gauss2d pre"; const char * post_layer_name = "test_gauss2d post"; const char * pre2_layer_name = "test_gauss2d pre 2"; const char * post2_layer_name = "test_gauss2d post 2"; initObj->initialize(); PV::HyPerCol * hc = new PV::HyPerCol("test_gauss2d column", initObj); PV::Example * pre = new PV::Example(pre_layer_name, hc); assert(pre); PV::Example * post = new PV::Example(post_layer_name, hc); assert(post); PV::HyPerConn * cHyPer = new HyPerConn("test_gauss2d hyperconn", hc); PV::HyPerConn * cKernel = new HyPerConn("test_gauss2d kernelconn", hc); PV::Example * pre2 = new PV::Example(pre2_layer_name, hc); assert(pre2); PV::Example * post2 = new PV::Example(post2_layer_name, hc); assert(post2); PV::HyPerConn * cHyPer1to2 = new HyPerConn("test_gauss2d hyperconn 1 to 2", hc); assert(cHyPer1to2); PV::HyPerConn * cKernel1to2 = new HyPerConn("test_gauss2d kernelconn 1 to 2", hc); assert(cKernel1to2); PV::HyPerConn * cHyPer2to1 = new HyPerConn("test_gauss2d hyperconn 2 to 1", hc); assert(cHyPer2to1); PV::HyPerConn * cKernel2to1 = new HyPerConn("test_gauss2d kernelconn 2 to 1", hc); assert(cKernel2to1); int status = 0; for (int l=0; l<hc->numberOfLayers(); l++) { status = hc->getLayer(l)->communicateInitInfo(); assert(status==PV_SUCCESS); } for (int c=0; c<hc->numberOfConnections(); c++) { status = hc->getConnection(c)->communicateInitInfo(); assert(status==PV_SUCCESS); } for (int l=0; l<hc->numberOfLayers(); l++) { status = hc->getLayer(l)->allocateDataStructures(); assert(status==PV_SUCCESS); } for( int c=0; c<hc->numberOfConnections(); c++ ) { BaseConnection * baseConn = hc->getConnection(c); HyPerConn * conn = dynamic_cast<HyPerConn *>(baseConn); conn->allocateDataStructures(); conn->writeWeights(0, true); } const int axonID = 0; int num_pre_extended = pre->clayer->numExtended; assert(num_pre_extended == cHyPer->getNumWeightPatches()); for (int kPre = 0; kPre < num_pre_extended; kPre++) { //printf("testing testing 1 2 3...\n"); status = check_kernel_vs_hyper(cHyPer, cKernel, kPre, axonID); assert(status==0); status = check_kernel_vs_hyper(cHyPer1to2, cKernel1to2, kPre, axonID); assert(status==0); status = check_kernel_vs_hyper(cHyPer2to1, cKernel2to1, kPre, axonID); assert(status==0); } delete hc; delete initObj; return 0; }
int NormalizeContrastZeroMean::normalizeWeights() { int status = PV_SUCCESS; assert(numConnections >= 1); // TODO: need to ensure that all connections in connectionList have same nxp,nyp,nfp,numArbors,numDataPatches HyPerConn * conn0 = connectionList[0]; for (int c=1; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; if (conn->numberOfAxonalArborLists() != conn0->numberOfAxonalArborLists()) { if (parent->columnId() == 0) { pvErrorNoExit().printf("Normalizer %s: All connections in the normalization group must have the same number of arbors (Connection \"%s\" has %d; connection \"%s\" has %d).\n", this->getName(), conn0->getName(), conn0->numberOfAxonalArborLists(), conn->getName(), conn->numberOfAxonalArborLists()); } status = PV_FAILURE; } if (conn->getNumDataPatches() != conn0->getNumDataPatches()) { if (parent->columnId() == 0) { pvErrorNoExit().printf("Normalizer %s: All connections in the normalization group must have the same number of data patches (Connection \"%s\" has %d; connection \"%s\" has %d).\n", this->getName(), conn0->getName(), conn0->getNumDataPatches(), conn->getName(), conn->getNumDataPatches()); } status = PV_FAILURE; } if (status==PV_FAILURE) { MPI_Barrier(parent->icCommunicator()->communicator()); exit(EXIT_FAILURE); } } float scale_factor = strength; status = NormalizeBase::normalizeWeights(); // applies normalize_cutoff threshold and symmetrizeWeights int nArbors = conn0->numberOfAxonalArborLists(); int numDataPatches = conn0->getNumDataPatches(); if (normalizeArborsIndividually) { for (int arborID = 0; arborID<nArbors; arborID++) { for (int patchindex = 0; patchindex<numDataPatches; patchindex++) { double sum = 0.0; double sumsq = 0.0; int weights_per_patch = 0; for (int c=0; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; int nxp = conn0->xPatchSize(); int nyp = conn0->yPatchSize(); int nfp = conn0->fPatchSize(); weights_per_patch += nxp*nyp*nfp; pvwdata_t * dataStartPatch = conn->get_wDataStart(arborID) + patchindex * weights_per_patch; accumulateSumAndSumSquared(dataStartPatch, weights_per_patch, &sum, &sumsq); } if (fabs(sum) <= minSumTolerated) { pvWarn().printf("for NormalizeContrastZeroMean \"%s\": sum of weights in patch %d of arbor %d is within minSumTolerated=%f of zero. Weights in this patch unchanged.\n", this->getName(), patchindex, arborID, minSumTolerated); break; // TODO: continue instead of break? continue as opposed to break is more consistent with warning above. } float mean = sum/weights_per_patch; float var = sumsq/weights_per_patch - mean*mean; for (int c=0; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; pvwdata_t * dataStartPatch = conn->get_wDataStart(arborID) + patchindex * weights_per_patch; subtractOffsetAndNormalize(dataStartPatch, weights_per_patch, sum/weights_per_patch, sqrt(var)/scale_factor); } } } } else { for (int patchindex = 0; patchindex<numDataPatches; patchindex++) { double sum = 0.0; double sumsq = 0.0; int weights_per_patch = 0; for (int arborID = 0; arborID<nArbors; arborID++) { for (int c=0; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; int nxp = conn0->xPatchSize(); int nyp = conn0->yPatchSize(); int nfp = conn0->fPatchSize(); weights_per_patch += nxp*nyp*nfp; pvwdata_t * dataStartPatch = conn->get_wDataStart(arborID)+patchindex*weights_per_patch; accumulateSumAndSumSquared(dataStartPatch, weights_per_patch, &sum, &sumsq); } } if (fabs(sum) <= minSumTolerated) { pvWarn().printf("for NormalizeContrastZeroMean \"%s\": sum of weights in patch %d is within minSumTolerated=%f of zero. Weights in this patch unchanged.\n", getName(), patchindex, minSumTolerated); break; // TODO: continue instead of break? continue as opposed to break is more consistent with warning above. } int count = weights_per_patch*nArbors; float mean = sum/count; float var = sumsq/count - mean*mean; for (int arborID = 0; arborID<nArbors; arborID++) { for (int c=0; c<numConnections; c++) { HyPerConn * conn = connectionList[c]; pvwdata_t * dataStartPatch = conn->get_wDataStart(arborID)+patchindex*weights_per_patch; subtractOffsetAndNormalize(dataStartPatch, weights_per_patch, mean, sqrt(var)/scale_factor); } } } } return status; }
int customexit(HyPerCol * hc, int argc, char ** argv) { BaseConnection * baseConn; baseConn = hc->getConnFromName("initializeFromInitWeights"); HyPerConn * initializeFromInitWeightsConn = dynamic_cast<HyPerConn *>(baseConn); // There must be a connection named initializeFromInitWeights. It should have a single weight with value 1 assert(initializeFromInitWeightsConn); assert(initializeFromInitWeightsConn->xPatchSize()==1); assert(initializeFromInitWeightsConn->yPatchSize()==1); assert(initializeFromInitWeightsConn->fPatchSize()==1); assert(initializeFromInitWeightsConn->numberOfAxonalArborLists()==1); assert(initializeFromInitWeightsConn->get_wData(0,0)[0] == 1.0f); // There must be a connection named initializeFromCheckpoint. It should have a single weight with value 2 baseConn = hc->getConnFromName("initializeFromCheckpoint"); HyPerConn * initializeFromCheckpointConn = dynamic_cast<HyPerConn *>(baseConn); assert(initializeFromCheckpointConn); assert(initializeFromCheckpointConn->xPatchSize()==1); assert(initializeFromCheckpointConn->yPatchSize()==1); assert(initializeFromCheckpointConn->fPatchSize()==1); assert(initializeFromCheckpointConn->numberOfAxonalArborLists()==1); assert(initializeFromCheckpointConn->get_wData(0,0)[0] == 2.0f); return PV_SUCCESS; }
/** * @timef * NOTES: * - kPost, kxPost, kyPost are indices in the restricted post-synaptic layer. * */ int PostConnProbe::outputState(double timef) { int k, kxPre, kyPre; HyPerConn * c = getTargetHyPerConn(); PVPatch * w; PVPatch *** wPost = c->convertPreSynapticWeights(timef); // TODO - WARNING: currently only works if nfPre==0 const PVLayer * lPre = c->preSynapticLayer()->clayer; const PVLayer * lPost = c->postSynapticLayer()->clayer; const int nxPre = lPre->loc.nx; const int nyPre = lPre->loc.ny; const int nfPre = lPre->loc.nf; const PVHalo * haloPre = &lPre->loc.halo; const int nxPost = lPost->loc.nx; const int nyPost = lPost->loc.ny; const int nfPost = lPost->loc.nf; const PVHalo * haloPost = &lPost->loc.halo; // calc kPost if needed if (kPost < 0) { kPost = kIndex(kxPost, kyPost, kfPost, nxPost, nyPost, nfPost); } else { kxPost = kxPos(kPost, nxPost, nyPost, nfPost); kyPost = kyPos(kPost, nxPost, nyPost, nfPost); kfPost = featureIndex(kPost, nxPost, nyPost, nfPost); } c->preSynapticPatchHead(kxPost, kyPost, kfPost, &kxPre, &kyPre); const int kxPreEx = kxPre + haloPre->lt; const int kyPreEx = kyPre + haloPre->up; const int kxPostEx = kxPost + haloPost->lt; const int kyPostEx = kyPost + haloPost->up; const int kPostEx = kIndex(kxPostEx, kyPostEx, kfPost, nxPost+haloPost->lt+haloPost->rt, nyPost+haloPost->dn+haloPost->up, nfPost); const bool postFired = lPost->activity->data[kPostEx] > 0.0; w = wPost[getArborID()][kPost]; pvwdata_t * wPostData = c->getWPostData(getArborID(),kPost); const int nw = w->nx * w->ny * nfPost; //w->nf; if (wPrev == NULL) { wPrev = (pvwdata_t *) calloc(nw, sizeof(pvwdata_t)); for (k = 0; k < nw; k++) { wPrev[k] = wPostData[k]; // This is broken if the patch is shrunken } } if (wActiv == NULL) { wActiv = (pvwdata_t *) calloc(nw, sizeof(pvwdata_t)); } k = 0; for (int ky = 0; ky < w->ny; ky++) { for (int kx = 0; kx < w->nx; kx++) { int kPre = kIndex(kx+kxPreEx, ky+kyPreEx, 0, nxPre+haloPre->lt+haloPre->rt, nyPre+haloPre->dn+haloPre->up, nfPre); wActiv[k++] = lPre->activity->data[kPre]; } } bool changed = false; for (k = 0; k < nw; k++) { if (wPrev[k] != wPostData[k] || wActiv[k] != 0.0) { changed = true; break; } } FILE * fp = getStream()->fp; if (stdpVars && (postFired || changed)) { if (postFired) fprintf(fp, "*"); else fprintf(fp, " "); fprintf(fp, "t=%.1f w%d(%d,%d,%d) prePatchHead(%d,%d): ", timef, kPost, kxPost, kyPost, kfPost, kxPre, kyPre); if (image) fprintf(fp, "tag==%d ", image->tag()); fprintf(fp, "\n"); } if (stdpVars && changed) { text_write_patch_extra(fp, w, wPostData, wPrev, wActiv, getTargetHyPerConn()); fflush(fp); } for (k = 0; k < nw; k++) { wPrev[k] = wPostData[k]; } if (outputIndices) { fprintf(fp, "w%d(%d,%d,%d) prePatchHead(%d,%d): ", kPost, kxPost, kyPost, kfPost, kxPre, kyPre); if(!stdpVars){ fprintf(fp,"\n"); } const PVLayer * lPre = c->preSynapticLayer()->clayer; write_patch_indices(fp, w, &lPre->loc, kxPre, kyPre, 0); fflush(fp); } return 0; }