int main(int argc, char * argv[]) {
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
int status = PV_SUCCESS;
int rank = 0;
int numProcs = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &numProcs);
//int numProcs = initObj->getWorldSize();
if( numProcs != 6) {
// TODO Greater than six should be permissible, with the excess over 6 being idle
if (rank==0) {
fprintf(stderr, "%s: this test can only be used under MPI with exactly six processes.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile()!=NULL) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument.\n", arguments->getProgramName());
}
status = PV_FAILURE;
}
if (arguments->getNumRows()!=0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the rows argument.\n", arguments->getProgramName());
}
status = PV_FAILURE;
}
if (arguments->getNumColumns()!=0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the columns argument.\n", arguments->getProgramName());
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
fprintf(stderr, "The necessary parameters are hardcoded.\n");
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
arguments->setParamsFile("input/test_mpi_specifyrowscolumns.params");
arguments->setNumRows(2);
arguments->setNumColumns(3);
buildandverify(initObj);
arguments->setNumRows(3);
arguments->setNumColumns(2);
buildandverify(initObj);
delete initObj;
return status;
}
int main(int argc, char * argv[])
{
int status = 0;
int rank=0;
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile() != NULL) {
if (rank==0) {
fprintf(stderr, "%s does not take -p as an option. Instead the necessary params file is hard-coded.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
arguments->setParamsFile("input/test_border_activity.params");
initObj->initialize();
HyPerCol * hc = new HyPerCol("column", initObj);
const char * imageLayerName = "test_border_activity image";
const char * retinaLayerName = "test_border_activity retina";
const char * l1LayerName = "test_border_activity layer";
Image * image = new Image(imageLayerName, hc); assert(image);
Retina * retina = new Retina(retinaLayerName, hc); assert(retina);
ANNLayer * l1 = new ANNLayer(l1LayerName, hc); assert(l1);
HyPerConn * conn1 = new HyPerConn("test_border_activity connection 1", hc);
assert(conn1);
HyPerConn * conn2 = new HyPerConn("test_border_activity connection 2", hc);
assert(conn2);
#ifdef DEBUG_OUTPUT
PointProbe * p1 = new PointProbe( 0, 0, 0, "L1 (0,0,0):");
PointProbe * p2 = new PointProbe(32, 32, 32, "L1 (32,32,0):");
l1->insertProbe(p1);
l1->insertProbe(p2);
#endif
// run the simulation
hc->run();
status = check_activity(l1);
delete hc;
delete initObj;
return status;
}
int main(int argc, char * argv[]) {
const char * paramfile1 = "input/RandStateSystemTest1.params";
const char * paramfile2 = "input/RandStateSystemTest2.params";
int rank=0;
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* Can't use `initObj->getComm()->communicator()` because initObj->initialize hasn't been called. */
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile() != NULL) {
if (rank==0) {
fprintf(stderr, "%s does not take -p as an option. Instead the necessary params files are hard-coded.\n", arguments->getProgramName());
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
arguments->setParamsFile(paramfile1);
int status1 = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if (status1 != PV_SUCCESS) {
fprintf(stderr, "%s failed on param file %s with return code %d.\n", arguments->getProgramName(), paramfile1, status1);
return EXIT_FAILURE;
}
arguments->setParamsFile(paramfile2);
int status2 = rebuildandrun(initObj, NULL, &customexit, NULL);
if (status2 != PV_SUCCESS) {
fprintf(stderr, "%s failed on param file %s.\n", arguments->getProgramName(), paramfile2);
}
int status = status1==PV_SUCCESS && status2==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
#ifdef PV_USE_MPI
if (status == EXIT_SUCCESS) {
printf("Test complete. %s passed on process rank %d.\n", arguments->getProgramName(), rank);
}
else {
fprintf(stderr, "Test complete. %s FAILED on process rank %d.\n", arguments->getProgramName(), rank);
}
#else
if (status == EXIT_SUCCESS) {
printf("Test complete. %s passed.\n", arguments->getProgramName());
}
else {
fprintf(stderr, "Test complete. %s FAILED.\n", arguments->getProgramName());
}
#endif // PV_USE_MPI
delete initObj;
return status;
}
int main(int argc, char * argv[]) {
int status;
PV_Init * initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile()==NULL) {
arguments->setParamsFile("input/KernelActivationTest-fullData.params");
status = runKernelActivationTest(initObj);
if (status==PV_SUCCESS) {
arguments->setParamsFile("input/KernelActivationTest-maskData.params");
status = runKernelActivationTest(initObj);
}
}
else {
status = runKernelActivationTest(initObj);
}
delete initObj;
return status;
}
int main(int argc, char * argv[]) {
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
int rank = initObj->getWorldRank();
char const * paramFile1 = "input/DtAdaptController_ANNNormalized.params";
char const * paramFile2 = "input/DtAdaptController_dtAdaptController.params";
char const * paramFileCompare = "input/DtAdaptController_Comparison.params";
int status = PV_SUCCESS;
if (pv_getopt_str(argc, argv, "-p", NULL, NULL)==0) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument, as it uses hard-coded params files.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
PV_Arguments * arguments = initObj->getArguments();
arguments->setParamsFile(paramFile1);
status = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile1, status);
exit(status);
}
arguments->setParamsFile(paramFile2);
status = rebuildandrun(initObj, NULL, NULL, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile2, status);
exit(status);
}
arguments->setParamsFile(paramFileCompare);
status = rebuildandrun(initObj, NULL, &assertAllZeroes, NULL, 0);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFileCompare, status);
exit(status);
}
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
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, true/*allowUnrecognizedArguments*/);
// argv has to allow --generate, --testrun, etc.
int rank = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
bool generateFlag = false; // Flag for whether to generate correct output for future tests; don't check the RequireAllZeroActivity probe
bool testrunFlag = false; // Flag for whether to run from params and then check the RequireAllZeroActivity probe
bool testcheckpointFlag = false; // Flag for whether to run from checkpoint and then check the RequireAllZeroActivity probe
bool testioparamsFlag = false; // Flag for whether to run from the output pv.params and then check the RequireAllZeroActivity probe
// Run through the command line arguments. If an argument is any of
// --generate
// --testrun
// --testcheckpoint
// --testioparams
// --testall
// set the appropriate test flags
for (int arg=0; arg<argc;arg++) {
const char * thisarg = argv[arg];
if (!strcmp(thisarg, "--generate")) {
generateFlag = true;
}
else if (!strcmp(thisarg, "--testrun")) {
testrunFlag = true;
}
else if (!strcmp(thisarg, "--testcheckpoint")) {
testcheckpointFlag = true;
}
else if (!strcmp(thisarg, "--testioparams")) {
testioparamsFlag = true;
}
else if (!strcmp(thisarg, "--testall")) {
testrunFlag = true;
testcheckpointFlag = true;
testioparamsFlag = true;
}
else {
/* nothing to do here */
}
}
if (generateFlag && (testrunFlag||testcheckpointFlag||testioparamsFlag)) {
if (rank==0) {
fprintf(stderr, "%s error: --generate option conflicts with the --test* options.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD); // Make sure no child processes take down the MPI environment before root process prints error message.
exit(EXIT_FAILURE);
}
if (!(generateFlag||testrunFlag||testcheckpointFlag||testioparamsFlag)) {
if (rank==0) {
fprintf(stderr, "%s error: At least one of \"--generate\", \"--testrun\", \"--testcheckpoint\", \"--testioparams\" must be selected.\n", argv[0]);
}
MPI_Barrier(MPI_COMM_WORLD); // Make sure no child processes take down the MPI environment before root process prints error message.
exit(EXIT_FAILURE);
}
assert(generateFlag||testrunFlag||testcheckpointFlag||testioparamsFlag);
int status = PV_SUCCESS;
if (status==PV_SUCCESS && generateFlag) {
if (generate(initObj, rank)!=PV_SUCCESS) {
status = PV_FAILURE;
if (rank==0) {
fprintf(stderr, "%s: generate failed.\n", initObj->getArguments()->getProgramName());
}
}
}
if (status==PV_SUCCESS && testrunFlag) {
if (testrun(initObj, rank)!=PV_SUCCESS) {
status = PV_FAILURE;
if (rank==0) {
fprintf(stderr, "%s: testrun failed.\n", initObj->getArguments()->getProgramName());
}
}
}
if (status==PV_SUCCESS && testcheckpointFlag) {
if (testcheckpoint(initObj, rank)!=PV_SUCCESS) {
status = PV_FAILURE;
if (rank==0) {
fprintf(stderr, "%s: testcheckpoint failed.\n", initObj->getArguments()->getProgramName());
}
}
}
if (status==PV_SUCCESS && testioparamsFlag) {
if (testioparams(initObj, rank)!=PV_SUCCESS) {
status = PV_FAILURE;
if (rank==0) {
fprintf(stderr, "%s: testioparams failed.\n", initObj->getArguments()->getProgramName());
}
}
}
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char * argv[]) {
PV_Init* initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
InterColComm * icComm = new InterColComm(initObj->getArguments());
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile() != NULL) {
int rank = icComm->globalCommRank();
if (rank==0) {
fprintf(stderr, "%s does not take -p as an option. Instead the necessary params file is hard-coded.\n", arguments->getProgramName());
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
arguments->setParamsFile("input/TransposeHyPerConnTest.params");
initObj->initialize();
// Don't call buildandrun because it will delete hc before returning. (I could use the customexit hook)
HyPerCol * hc = build(initObj);
hc->run(); // Weight values are initialized when run calls allocateDataStructures
int status = PV_SUCCESS;
HyPerConn * originalMap = NULL;
TransposeConn * transpose = NULL;
TransposeConn * transposeOfTranspose = NULL;
BaseConnection * baseConn;
baseConn = hc->getConnFromName("Original Map for One to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for Many to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for One to Many Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for One to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, FeedbackConn");
baseConn = hc->getConnFromName("Original Map for Many to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, FeedbackConn");
baseConn = hc->getConnFromName("Original Map for One to Many Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, FeedbackConn");
delete hc;
delete initObj;
return status;
}
int main(int argc, char * argv[]) {
int rank = 0;
PV_Init * initObj = new PV_Init(&argc, &argv, false/*allowUnrecognizedArguments*/);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
char const * paramFile1 = "input/CheckpointParameters1.params";
char const * paramFile2 = "input/CheckpointParameters2.params";
int status = PV_SUCCESS;
PV_Arguments * arguments = initObj->getArguments();
if (arguments->getParamsFile()!=NULL) {
if (rank==0) {
fprintf(stderr, "%s should be run without the params file argument.\n", arguments->getProgramName());
}
status = PV_FAILURE;
}
if (arguments->getCheckpointReadDir()!=NULL) {
if (rank==0) {
fprintf(stderr, "%s should be run without the checkpoint directory argument.\n", argv[0]);
}
status = PV_FAILURE;
}
if (arguments->getRestartFlag()) {
if (rank==0) {
fprintf(stderr, "%s should be run without the restart flag.\n", argv[0]);
}
status = PV_FAILURE;
}
if (status != PV_SUCCESS) {
if (rank==0) {
fprintf(stderr, "This test uses two hard-coded params files, %s and %s. The second run is started from a checkpoint from the first run, and the results of the two runs are compared.\n",
paramFile1, paramFile2);
}
MPI_Barrier(MPI_COMM_WORLD);
exit(EXIT_FAILURE);
}
if (rank==0) {
char const * rmcommand = "rm -rf checkpoints1 checkpoints2 output";
status = system(rmcommand);
if (status != 0) {
fprintf(stderr, "deleting old checkpoints and output directories failed: \"%s\" returned %d\n", rmcommand, status);
exit(EXIT_FAILURE);
}
}
ParamGroupHandler * customGroupHandler = new CustomGroupHandler;
arguments->setParamsFile(paramFile1);
arguments->setBatchWidth(2);
status = rebuildandrun(initObj, NULL, NULL, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile1, status);
exit(status);
}
arguments->setParamsFile(paramFile2);
arguments->setCheckpointReadDir("checkpoints1/batchsweep_00/Checkpoint12:checkpoints1/batchsweep_01/Checkpoint12");
status = rebuildandrun(initObj, NULL, &customexit, &customGroupHandler, 1);
if( status != PV_SUCCESS ) {
fprintf(stderr, "%s: rank %d running with params file %s returned error %d.\n", arguments->getProgramName(), rank, paramFile2, status);
}
delete customGroupHandler;
delete initObj;
return status==PV_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char * argv[]) {
PV_Init* initObj = new PV_Init(&argc, &argv);
InterColComm * icComm = new InterColComm(argc, argv);
PVParams * params = new PVParams("input/TransposeHyPerConnTest.params", 2*(INITIAL_LAYER_ARRAY_SIZE+INITIAL_CONNECTION_ARRAY_SIZE), icComm);
initObj->initialize(params, icComm);
// Don't call buildandrun because it will delete hc before returning. (I could use the customexit hook)
HyPerCol * hc = build(argc, argv, initObj);
hc->run(); // Weight values are initialized when run calls allocateDataStructures
int status = PV_SUCCESS;
HyPerConn * originalMap = NULL;
TransposeConn * transpose = NULL;
TransposeConn * transposeOfTranspose = NULL;
BaseConnection * baseConn;
baseConn = hc->getConnFromName("Original Map for One to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for Many to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for One to Many Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of TransposeConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of TransposeConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, TransposeConn");
baseConn = hc->getConnFromName("Original Map for One to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to One Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to One Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-one case, FeedbackConn");
baseConn = hc->getConnFromName("Original Map for Many to One Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for Many to One Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for Many to One Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "Many-to-one case, FeedbackConn");
baseConn = hc->getConnFromName("Original Map for One to Many Test");
originalMap = dynamic_cast<HyPerConn *>(baseConn);
//assert(originalMap->usingSharedWeights());
transpose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose for One to Many Test of FeedbackConn"));
transposeOfTranspose = dynamic_cast<TransposeConn *>(hc->getConnFromName("Transpose of Transpose for One to Many Test of FeedbackConn"));
status = testTransposeOfTransposeWeights(originalMap, transpose, transposeOfTranspose, "One-to-many case, FeedbackConn");
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;
}
